server.java

JMule是一个基于Java开发

			JMServerFoundSourceSP scannedPacket = (JMServerFoundSourceSP) packet;

			PeerManagerFactory.getInstance().addPeer(scannedPacket.getFileHash(), scannedPacket);

			return;
		}

		if (packet instanceof JMServerUDPStatusSP) {
			
			last_udp_response = System.currentTimeMillis();
			
			JMServerUDPStatusSP scannedPacket = (JMServerUDPStatusSP) packet;
			
			setNumFiles(scannedPacket.getFilesCount());
			
			setNumUsers(scannedPacket.getUserCount());
			
			setSoftLimit(scannedPacket.getSoftFilesLimit());
			
			setHardLimit(scannedPacket.getHardSoftLimits());

			long challenge_udp = scannedPacket.getChallenge();

			if (challenge_udp == challenge)
				
				setPing(System.currentTimeMillis() - challenge_send_time);

			return;
		}

		if (packet instanceof JMServerUDPDescSP) {
			
			last_udp_response = System.currentTimeMillis();
			
			JMServerUDPDescSP scannedPacket = (JMServerUDPDescSP) packet;
			
			setName(scannedPacket.getName());
			
			setDesc(scannedPacket.getDescription());
			
			return;
		}
		
		if (packet instanceof JMServerUDPNewDescSP) {
			
			last_udp_response = System.currentTimeMillis();
			
			JMServerUDPNewDescSP scannedPacket = (JMServerUDPNewDescSP) packet;
			
			tagList.addTag(scannedPacket.getTagList(), true);
			
		}
	}

	public boolean isConnected() {
		
		return this.isConnected;
		
	}

	public boolean isDown() {
		
		if (isConnected) return false;
		
		if (System.currentTimeMillis() - last_udp_response > ConfigurationManager.SERVER_DOWN_TIMEOUT)
			
			return true;
		
		return false;
		
	}
	
	protected void onConnect() {
		
		sendPacket(PacketFactory.getServerLoginPacket(userHash, ConfigurationManagerFactory.getInstance().getTCP(), 
				ConfigurationManagerFactory.getInstance().getNickName()));
	}

	protected void onDisconnect() {
		if (isDown())
			last_udp_response = System.currentTimeMillis();
		
		isConnected = false;
		
		allowSearch = false;
		
		notify_server_event(TCP_SOCKET_DISCONNECTED);
	}

	public TagList getTagList() {
		
		return tagList;
		
	}

	private void setName(String newName) {
		
		Tag tag = new StandardTag(TAG_TYPE_STRING, SL_SERVERNAME);
		
		tag.insertString(newName);
		
		tagList.removeTag(SL_SERVERNAME);
		
		tagList.addTag(tag);
		
	}

	public String getName() {
		
		try {
			
			String result = tagList.getStringTag(SL_SERVERNAME);
			
			result = result.trim();
			
			if (result.length()!=0)
				
				return result;
			
			return getAddress();
			
		} catch (TagException e) {
			
			return getAddress();
		}
	}

	private void setDesc(String serverDesc) {
		
		Tag tag = new StandardTag(TAG_TYPE_STRING, SL_DESCRIPTION);
		
		tag.insertString(serverDesc);
		
		tagList.removeTag(SL_DESCRIPTION);
		
		tagList.addTag(tag);
		
	}

	public String getDesc() {
		
		try {
			
			return tagList.getStringTag(SL_DESCRIPTION);
			
		} catch (TagException e) {
			
			return "";
		}
	}

	private void setSoftLimit(int softLimit) {
		
		Tag tag = new StandardTag(TAG_TYPE_DWORD, SL_SOFTFILES);
		
		tag.insertDWORD(softLimit);
		
		tagList.removeTag(SL_SOFTFILES);
		
		tagList.addTag(tag);
		
	}

	public int getSoftLimit() {
		
		try {
			
			return tagList.getDWORDTag(SL_SOFTFILES);
			
		} catch (TagException e) {
			return 0;
		}
	}

	private void setHardLimit(int hardLimit) {
		
		Tag tag = new StandardTag(TAG_TYPE_DWORD, SL_HARDFILES);
		
		tag.insertDWORD(hardLimit);
		
		tagList.removeTag(SL_HARDFILES);
		
		tagList.addTag(tag);
		
	}

	public int getHardLimit() {
		
		try {
			
			return tagList.getDWORDTag(SL_HARDFILES);
			
		} catch (TagException e) {
			
			return 0;
			
		}
	}

	private void setPing(long ping) {
		
		Tag tag = new StandardTag(TAG_TYPE_DWORD, SL_PING);
		
		tag.insertDWORD(Convert.longToInt(ping));
		
		tagList.removeTag(SL_PING);
		
		tagList.addTag(tag);

	}

	public long getPing() {
		
		try {
			
			return Convert.longToInt(tagList.getDWORDTag(SL_PING));
			
		} catch (TagException e) {
			
			return 0;
			
		}
	}

	public String getVersion() {
		
		try {
			
			long version = tagList.getDWORDTag(SL_VERSION);
			
			long major = version >> 16;
			
			long minor = version & 0xFFFF;
			
			return major+"."+minor;
			
		} catch (TagException e) {
			
			return "";
		}
	}
	
	public long getNumFiles() {
		
		try {
			
			return Convert.intToLong(tagList.getDWORDTag(SL_FILES));
			
		} catch (TagException e) {
			
			return 0;
			
		}
		
	}
	
	public long getMaxUsers() {
		
		try {
			
			return Convert.intToLong(tagList.getDWORDTag(SL_SRVMAXUSERS));
			
		} catch (TagException e) {
			
			return 0;
			
		}
	}

	public long getNumUsers() {
		
		try {
			
			return Convert.intToLong(tagList.getDWORDTag(SL_USERS));
			
		} catch (TagException e) {
			
			return 0;
			
		}
	}
	
	private void setNumUsers(long numUsers) {
		
		Tag tag = new StandardTag(TAG_TYPE_DWORD, SL_USERS);
		
		tag.insertDWORD(Convert.longToInt(numUsers));
		
		tagList.removeTag(SL_USERS);
		
		tagList.addTag(tag);

	}

	private void setNumFiles(long numFiles) {
		
		Tag tag = new StandardTag(TAG_TYPE_DWORD, SL_FILES);
		
		tag.insertDWORD(Convert.longToInt(numFiles));
		
		tagList.removeTag(SL_FILES);
		
		tagList.addTag(tag);
		
	}
	
	public boolean isStatic() {
		return isStatic;
	}

	public void setStatic(boolean isStatic) {
		this.isStatic = isStatic;
	}
	
	public int hashCode() {
		
		return (getAddress()+" : "+getPort()).hashCode(); 
	}
	
	public int getAddressAsInt() {
		
		return Convert.IPtoInt( Convert.stringIPToArray( getAddress() ) );
	}
	
	public boolean equals(Object object) {
		
		if (!(object instanceof Server)) return false;
		
		if (object.hashCode()!=this.hashCode()) return false;
		
		return true;
	}
	
	
	public void sendUDPDescRequest() {
		InetSocketAddress udpAddress = new InetSocketAddress(getAddress(), SERVER_UDP_PORT);
		UDPPacket packet = UDPPacketFactory.getUDPServerDescRequest(udpAddress);
		JMUDPConnection.getInstance().sendPacket(packet);
	}
	
	public void sendUDPStatusRequest() {
		challenge = random.nextInt();
		challenge_send_time = System.currentTimeMillis();
		InetSocketAddress udpAddress = new InetSocketAddress(getAddress(), SERVER_UDP_PORT);
		UDPPacket packet = UDPPacketFactory.getUDPStatusRequest(challenge, udpAddress);
		JMUDPConnection.getInstance().sendPacket(packet);
	}

	private class ProcessPacketsThread extends JMThread {
		
		public ProcessPacketsThread() {
			
			super("Server incoming packets process thread");

		}

		public void run() {
			
			ScannedPacket packet;
			
			Packet raw_packet;
			
			while (getPacketCount() > 0) {
				
				try {
					
					raw_packet = getReceivedPacket();
					
					packet = PacketScanner.scanPacket(raw_packet);
					
					processPacket(packet);
					
				} catch (Throwable e) {
					
					e.printStackTrace();
				}

			}
		}
	}
	
	private void notify_server_event(int socket_status) {
		
		switch( socket_status ) {
	    
	      case TCP_SOCKET_CONNECTED : {
	    	  
	    	  ServerManagerFactory.getInstance().serverConnected(this);
	    	  
	    	  break;
	      }
	      
	      case TCP_SOCKET_DISCONNECTED : {
	    	  
	    	  ServerManagerFactory.getInstance().serverDisconnected(this);
	    	
	    	  break;
	      }
	      
	      case TCP_SOCKET_CONNECTING : {
	    	  
	    	  ServerManagerFactory.getInstance().serverConnecting(this);
	    	  
	    	  break;
	      }
	   }	
	}
}