servermanagerimpl.java

JMule是一个基于Java开发

/*
 *  JMule - Java file sharing client
 *  Copyright (C) 2007-2008 JMule team ( [e-mail] / http://jmule.org )
 *
 *  Any parts of this program derived from other projects, or contributed
 *  by third-party developers are copyrighted by their respective authors.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */
package org.jmule.core.edonkey.impl;

import java.net.InetSocketAddress;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;

import org.jmule.core.JMIterable;
import org.jmule.core.JMThread;
import org.jmule.core.configmanager.ConfigurationManager;
import org.jmule.core.edonkey.ServerListIsNullException;
import org.jmule.core.edonkey.ServerListListener;
import org.jmule.core.edonkey.ServerListener;
import org.jmule.core.edonkey.ServerManager;
import org.jmule.core.edonkey.ServerManagerException;
import org.jmule.core.edonkey.metfile.ServerMet;
import org.jmule.core.edonkey.metfile.ServerMetException;
import org.jmule.core.statistics.JMuleCoreStats;
import org.jmule.core.statistics.JMuleCoreStatsProvider;

/**
 * 
 * @author javajox
 * @author binary256
 * @version $$Revision: 1.13 $$
 * Last changed by $$Author: binary256_ $$ on $$Date: 2008/10/10 16:50:18 $$
 */
public class ServerManagerImpl implements ServerManager {

	private static final int AUTOCONNECT_SLEEP_INTERVAL = 10000;
	
	private List<Server> server_list = new CopyOnWriteArrayList<Server>();
	
	private List<ServerListListener> server_list_listeners = new CopyOnWriteArrayList<ServerListListener>();
	
	private List<ServerListener> server_listeners = new CopyOnWriteArrayList<ServerListener>();
	
	// UDP query
	
	private ServersUDPQueryThread udp_query_thread;
	
	// Auto connect process
	
	private ServerMet server_met;
	
	private Comparator compare_servers_by_ping = new Comparator() {
		public int compare(Object object1, Object object2) {
			if( ((Server)object1).getPing() < ((Server)object2).getPing() ) {
				return -1;
			} else if( ((Server)object1).getPing() > ((Server)object2).getPing() ) {
				return +1;
			}
			return 0;
		}
	};
	
	public ServerManagerImpl() {
	}
	
	public boolean isConnected() {
		return getConnectedServer()!=null;
	}
	
	public void importList(String fileName) throws ServerManagerException {
		ServerMet server_met;
		try {
			server_met = new ServerMet(fileName);
			server_met.load();
			List<Server> new_server_list = server_met.getServerList();
			for(Server server : new_server_list) {
				server.setStatic(false);
				addServer(server);
			}
			server_met.close();
		} catch (Throwable e) {
			throw new ServerManagerException(e);
		}
		
		
	}
	
	public void addServer(Server server) {
		
		if (server_list.contains(server)) return ;
		
		
		server_list.add(server);
		
		// notify all listeners that a new server has been added to the server list
		for(ServerListListener s : server_list_listeners) {
			
			s.serverAdded( server );
			
		}
	
	}
	
	public void addServer(ED2KServerLink serverLink) {
		Server server = new Server(serverLink);
		addServer(server);
	}
	
	public void removeServer(List<Server> serverList) {
		
		for(Server server : serverList) {
			
			 if (server.isConnected()) server.disconnect();
				
	         server_list.remove(server);
	         
	         // notify all listeners that the given server has been removed from the server list
	         for(ServerListListener s : server_list_listeners) {
	        	 
	        	 s.serverRemoved( server );
	        	 
	         }
			
		}
		
		try {
			 
			storeServerList();
			
		 } catch (ServerManagerException e) {
			 
			e.printStackTrace();
			
		 }
		
	}

	public void removeServer(Server server) {
		
		 if (server.isConnected()) server.disconnect();
		
         server_list.remove(server);
         
         // notify all listeners that the given server has been removed from the server list
         for(ServerListListener s : server_list_listeners) {
        	 
        	 s.serverRemoved( server );
        	 
         }
         
 		 try {
 			 
			storeServerList();
			
		 } catch (ServerManagerException e) {
			 
			e.printStackTrace();
			
		 }

         
	}

	public void addServerListListener(ServerListListener serverListListener) {
		
		server_list_listeners.add(serverListListener);
		
	}

	public void clearServerList() {
		
		Server connected_server = getConnectedServer();
		
		if (connected_server != null)
			
			connected_server.disconnect();
		
		server_list.clear();
		
		//notify all listeners that the server list has been cleared
		for(ServerListListener s : server_list_listeners) {
			
			s.serverListCleared();
			
		}
		
		try {
			
			storeServerList();
			
		} catch (ServerManagerException e) {
			
			e.printStackTrace();
			
		}

		
	}

	public void connect(Server server) throws ServerManagerException {
		 
		 if (getConnectedServer()!=null)
			 getConnectedServer().disconnect();
		
		 server.connect();

	}
	
	public void connect() throws ServerManagerException {
		
		startAutoConnect();
	}
	
	JMThread auto_connect_thread;
	
	public void startAutoConnect() throws ServerManagerException {
		
		if (auto_connect_thread != null)
			if( auto_connect_thread.isAlive() ) 
				throw new ServerManagerException("The auto connect process is already running");
		
		if( server_list.isEmpty() ) throw new ServerListIsNullException();
		
		auto_connect_thread = new JMThread() {
			boolean stop = false;
			Server min_ping_server;
			
			public void run() {
				Server connected_server = getConnectedServer();
				if( connected_server != null ) { // maybe should throw an exception
					connected_server.disconnect();
				}
				
			    for(ServerListListener listener : server_list_listeners) 
			    	listener.autoConnectStarted();
			    
				List<Server> candidate_servers = new LinkedList<Server>();
				for(Server server : server_list) {
					candidate_servers.add(server);
				}
				
				final JMThread thread = this;
				
				ServerListener server_listener = new ServerListener() {

					public void connected(Server server) {
						thread.interrupt();
					}

					public void disconnected(Server server) {
						thread.interrupt();
					}

					public void isconnecting(Server server) {}

					public void serverMessage(Server server, String message) {}
					
				};
				
				addServerListener(server_listener);
				while( !candidate_servers.isEmpty() ) {
					min_ping_server = (Server)Collections.min(candidate_servers, compare_servers_by_ping);

		            min_ping_server.connect();
		            try {
		              Thread.sleep(AUTOCONNECT_SLEEP_INTERVAL);
		            }catch(Throwable t) {
		            	if (stop) {
		            		if (min_ping_server!= null)
		            			min_ping_server.disconnect();
		            		removeServerListener(server_listener);
		            		return;
		            	}
		            }
		            if( min_ping_server.isConnected() ) {
		        	    for(ServerListListener listener : server_list_listeners) {
		        	    	listener.autoConnectStopped();
		        	    }
		        	    removeServerListener(server_listener);
		            	return;
		            } else {
		            	min_ping_server.disconnect();
		            	candidate_servers.remove(min_ping_server);
		            }
				}
				removeServerListener(server_listener);
				stopAutoConnect();
			}
			
			public void JMStop() {
				stop = true;
				interrupt();
			}
		};
		auto_connect_thread.start();
	}
	
	public void stopAutoConnect() {
		if (auto_connect_thread != null)
			if (auto_connect_thread.isAlive()) {
				auto_connect_thread.JMStop();
				for(ServerListListener s : server_list_listeners) {
					s.autoConnectStopped();
				}
			}
	}
	
	public Server getConnectedServer() {
         
		 Server result = null;
		 
         for(Server server : server_list) {
        	 
        	 if( server.isConnected() ) {
        	     
        		 result = server;
        		 
        		 break;
        		 
        	 }
        	 
         }
		
        return result;
	}

	public Iterable<Server> getServers() {
			   
        return new JMIterable<Server>(server_list.iterator());
	}

	public int getServersCount() {
		
        return server_list.size();
        
	}

	public void loadServerList() throws ServerManagerException {
		
		//TODO : modify the exception architecture
		try {
			
            server_met.load();
            
            server_list = server_met.getServerList();
         
		} catch( ServerMetException sme ) {
			
			  throw new ServerManagerException("ServerMetException " + sme); }

	}
	
	public void storeServerList() throws ServerManagerException {
		//TODO : modify the exception architecture
		try {
			
			server_met.setServerList( server_list );
			
		    server_met.store();
		   
			
		} catch( ServerMetException sme ) {
			
			throw new ServerManagerException("ServerMetException :" + sme);
			
		}
		
	}

	public void removeServerListListener(ServerListListener serverListListener) {
		
		server_list_listeners.remove(serverListListener);
		
	}

	public void initialize() {
		try {
			server_met = new ServerMet(ConfigurationManager.SERVER_MET);
		} catch (ServerMetException e) {
		}
		
		Set<String> types = new HashSet<String>();
		types.add(JMuleCoreStats.ST_NET_SERVERS_COUNT);
		types.add(JMuleCoreStats.ST_NET_SERVERS_DEAD_COUNT);
		types.add(JMuleCoreStats.ST_NET_SERVERS_ALIVE_COUNT);
		
		JMuleCoreStats.registerProvider(types, new JMuleCoreStatsProvider() {
			public void updateStats(Set<String> types,Map<String, Object> values) {
				if (types.contains(JMuleCoreStats.ST_NET_SERVERS_COUNT)) {
					values.put(JMuleCoreStats.ST_NET_SERVERS_COUNT, getServersCount());
				}
				if (types.contains(JMuleCoreStats.ST_NET_SERVERS_DEAD_COUNT)) {
					int dead_servers_count = 0;
					for(Server server : server_list)
						if (server.isDown())  dead_servers_count++;
					values.put(JMuleCoreStats.ST_NET_SERVERS_DEAD_COUNT, dead_servers_count);
				}
				if (types.contains(JMuleCoreStats.ST_NET_SERVERS_ALIVE_COUNT)) {
					int alive_servers_count = 0;
					for(Server server : server_list)
						if (!server.isDown())  alive_servers_count++;
					values.put(JMuleCoreStats.ST_NET_SERVERS_ALIVE_COUNT, alive_servers_count);
				}
				
			}
		});
	}

	public void shutdown() {
	   
		stopUDPQuery();
		
		for(Server server : server_list) {
			
			if(server.isConnected()) {
				
				server.disconnect();
				
				return;
				
			}
			
		}
		
    }

	public void start() {}


	public void startUDPQuery() {
		
		udp_query_thread = new ServersUDPQueryThread();
		udp_query_thread.start();
		
	}


	public void stopUDPQuery() {
		
		udp_query_thread.JMStop();
		
	}
	


	public boolean hasServer(Server server) {
		
		for(Server checked_server : server_list) {
			
			if (checked_server.equals(server)) return true;
			
		}
		
		return false;
	}

	public boolean hasServer(String address, int port) {
		for(Server checked_server : server_list) {
			if (checked_server.getAddress().equals(address))
				if (checked_server.getPort() == port)
					return true;
		}
		return false;
	}

	public boolean hasServer(ED2KServerLink link) {
		for(Server checked_server : server_list) {
			if (checked_server.getServerLink().equals(link)) 
				return true;
		}
		return false;
	}
	
	public Server getServer(InetSocketAddress address) {
		String ip_address = address.getAddress().getHostAddress();
		// can't compare by InetAddress : UDP packet is from another port(4665) but same IP
		for(Server checked_server : server_list) {
			if (checked_server.getAddress().equals(ip_address))
					return checked_server;
		}
		
		return null;
	}


	public void addServerListener(ServerListener serverListener) {
		
		  server_listeners.add(serverListener);
		  
	}


	public void removeServerListener(ServerListener serverListener) {
		
		  server_listeners.remove(serverListener);

	}
	
	public void serverConnecting(Server server) {
		for(ServerListener listener : server_listeners)
			listener.isconnecting(server);
	}
	
	public void serverConnected(Server server) {
		for(ServerListener listener : server_listeners)
			listener.connected(server);
	}

	public void serverDisconnected(Server server) {
		for(ServerListener listener : server_listeners)
			listener.disconnected(server);
	}

	public void serverMessage(Server server, String message) {

		for(ServerListener listener : server_listeners)
			listener.serverMessage(server, message);
		
	}

	
	private class ServersUDPQueryThread extends JMThread {
		
		private boolean stop = false;
		
		public ServersUDPQueryThread() {
			super("Servers UDP query thread");
		}
		
		public void run() {
			while(!stop) {
				for(Server server : server_list ) { 
					server.sendUDPDescRequest();
					server.sendUDPStatusRequest();
				}
				try {
					Thread.sleep(ConfigurationManager.SERVER_UDP_QUERY_INTERVAL);
				} catch (InterruptedException e) {}
			}
		}
		
		public void JMStop() {
			stop = true;
			interrupt();
		}
		
	}	
}