xmlrpcmanager.java

使用工具jublider开发的一个聊天室实现基本功能,

package freecs.external;

import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.StringTokenizer;
import java.util.Vector;

import org.apache.xmlrpc.WebServer;
import org.apache.xmlrpc.XmlRpcException;
import org.apache.xmlrpc.XmlRpcHandler;

import freecs.Server;
import freecs.core.RequestReader;
import freecs.core.UserManager;

public class XmlRpcManager implements XmlRpcHandler {

	public static final XmlRpcManager mgr = new XmlRpcManager ();
	private WebServer webserver;

	/**
	 * wrap instance's start method.
	 * start the xmlrpc-server using values from server-config. 
	 */
	public static void startManager(){
		mgr.start();
	}
	
	private XmlRpcManager() {
	}

	private void start() {
		// by default, we don't start the xmlrpc-server
		if (Server.srv.ADMIN_XMLRPC_PORT == 0) {
			return;
		}
		webserver = new WebServer(Server.srv.ADMIN_XMLRPC_PORT);
		webserver.addHandler("freecs", this);
		webserver.setParanoid(true);
		StringBuffer sb = new StringBuffer("Started XmlRpc-Server on port " + Server.srv.ADMIN_XMLRPC_PORT + ", open for addresses: ");
		// parse list of allowed clients:
		StringTokenizer tok = new StringTokenizer(Server.srv.ADMIN_XMLRPC_ALLOWED, ",");
		while (tok.hasMoreTokens()) {
			String ip = tok.nextToken().trim();
			webserver.acceptClient(ip);
			sb.append (ip + ", ");
		}
		webserver.start();
		Server.log(this, sb.toString().substring(0, sb.toString().length()-2), Server.MSG_CONFIG, Server.LVL_MINOR);
	}

	/**
	 * main method for inbound xmlrpc-calls, distributes the function calls.
	 * exceptions thrown by the underlying methods are passed through to the clients
	 * @see org.apache.xmlrpc.XmlRpcHandler
	 */
	public Object execute(String name, Vector args) throws Exception {
		boolean reval = false;
		if ("freecs.kick".equals(name)) {
			reval = kick(args);
		} else if ("freecs.removeUser".equals(name)) {
			reval = removeUser(args);
		} else if ("freecs.messageToAll".equals(name)) {
			reval = messageToAll(args);
		} else if ("freecs.messageToGroup".equals(name)) {
			reval = messageToGroup(args);
		} else if ("freecs.messageToUser".equals(name)) {
			reval = messageToUser(args);
		} else if ("freecs.state".equals(name)) {
		    return xmlRpcStateReport(args);
        }
		return Boolean.valueOf(reval);
	}

    private Hashtable xmlRpcStateReport(Vector args) {
        Hashtable result = new Hashtable();
        result.put("error", "");
        result.put("freeThreads", new Integer(Server.srv.MAX_READERS - RequestReader.activeReaders()));
        result.put("maxThreads", new Integer(Server.srv.MAX_READERS));
        result.put("usersHighWaterMark", new Integer(UserManager.mgr.getHighWaterMark()));
        result.put("users", new Integer(UserManager.mgr.getActiveUserCount()));
        Runtime r = Runtime.getRuntime();
        result.put("vmFreeMem", new Integer(Math.round(r.freeMemory()/1024)));
        result.put("vmTotalMem", new Integer(Math.round(r.totalMemory()/1024)));
        // FIXME: at the moment only for linux
        Hashtable lomd = getLinuxMemoryDetails(r);
        if (lomd != null) {
            result.putAll(lomd);
        }
        return result;
    }

    /**
     * @return
     */
    private Hashtable getLinuxMemoryDetails(Runtime r) {
        
        try {
            // systemcall for checking memory
            Process p = r.exec("cat /proc/meminfo");
            try {
                int returnCode = p.waitFor();
                if (returnCode>0) {
                    // return ht;
                    return null;
                }
            } catch (InterruptedException ie) {}

            // read in stdout and stderr
            StringBuffer out = new StringBuffer();
            StringBuffer err = new StringBuffer();
            InputStream os = p.getInputStream();
            int b = os.read();
            while (b != -1) {
                out.append((char) b);
                b = os.read();
            }
            os = p.getErrorStream();
            b = os.read();
            while (b != -1) {
                err.append((char) b);
                b = os.read();
            }

            Hashtable ht = new Hashtable();
            // if stderr isn't empty return the error
            if (err.length() > 0) {
                Server.log("XmlRpc", "error while getting System-Memory-Information: " + err.toString(), Server.MSG_ERROR, Server.LVL_MINOR);
                ht.put("error", err.toString());
                return ht;
            }
            
            // parse the content of /proc/meminfo
            StringTokenizer st = new StringTokenizer(out.toString(), "\r\n");
            String props[] = st.nextToken().trim().split(":");
            StringTokenizer vst = new StringTokenizer(st.nextToken(), " ");
            String prefix = vst.nextToken().trim();
            int i = 0;
            while (vst.hasMoreTokens() && i < props.length) {
                props[i]=props[i].trim();
                ht.put(prefix + props[i], new Integer(Integer.parseInt(vst.nextToken())));
                i++;
            }
            vst = new StringTokenizer(st.nextToken(), " ");
            prefix = vst.nextToken().trim();
            i = 0;
            while (vst.hasMoreTokens() && i < props.length) {
                ht.put(prefix + props[i], new Integer(Integer.parseInt(vst.nextToken())));
                i++;
            }
            
            while (st.hasMoreTokens()) {
                String line = st.nextToken();
                int idx = line.indexOf(":");
                if (idx < 0)
                    continue;
                String key = line.substring(0, idx);
                Integer iObj = new Integer (
                        Integer.parseInt(
                                line.substring(idx+1, line.length()-3).trim()));
                ht.put(key, iObj);
            }
            return ht;
        } catch (IOException e) {
            // ignore
        }
        return null;
    }

    /**
	 * kick a user from the chat.
	 * freecs.kick(username, timeout, blockIp)
	 */
	public boolean kick(Vector args) throws Exception {
		String username;
		long timeout = 2000;
		boolean blockIp = false; 
		try {
			username = (String)args.elementAt(0);
			if (args.size()>1) {
				Object arg1 = args.elementAt(1);
				if (arg1 instanceof String) {
					timeout = Long.parseLong((String)arg1);
				} else if (arg1 instanceof Number) {
					timeout = ((Number)args.elementAt(1)).longValue();
				} else {
					throw new XmlRpcException (0, "illegal arguments for freecs.kick: couldn't parse timeout");
				}
			}
			if (args.size()>2) {
				Object obj = args.elementAt(2);
				if((obj instanceof Boolean && ((Boolean)obj).booleanValue()==true)
						|| (obj instanceof String && "true".equalsIgnoreCase((String)obj))   ) {
					blockIp = true;
				}
			}
		} catch (Exception any) {
			throw new XmlRpcException (0, "illegal arguments for freecs.kick: " + any.toString());
		}
		return AdminCore.kick(username, timeout, blockIp, "xmlrpc-remote");
	}
	
	/**
	 * removes a user from the chat (the polite version)
	 * freecs.removeUser(username)
	 */
	public boolean removeUser(Vector args) throws Exception {
		String username;
		try {		
			username = (String) args.elementAt(0);
		} catch (Exception ex) {
			throw new XmlRpcException (0, "illegal arguments for freecs.removeUser: " + ex.toString());
		}
		return AdminCore.removeUser(username);
	}
	
	/**
	 * sends a system message to all users of the chat
	 * freecs.messageToAll(message)
	 */
	public boolean messageToAll(Vector args) throws Exception {
		String msg;
		try {		
			msg = (String) args.elementAt(0);
		} catch (Exception ex) {
			throw new XmlRpcException (0, "illegal arguments for freecs.messageToAll: " + ex.toString());
		}
		return AdminCore.messageToAll(msg);
	}
	
	/**
	 * sends a system message to all users of a given group
	 * freecs.messageToAll(message, groupname)
	 */
	public boolean messageToGroup(Vector args) throws Exception {
		String msg, groupname;
		try {		
			msg = (String) args.elementAt(0);
			groupname = (String) args.elementAt(1);
		} catch (Exception ex) {
			throw new XmlRpcException (0, "illegal arguments for freecs.messageToGroup: " + ex.toString());
		}
		return AdminCore.messageToGroup(msg, groupname);
	}
	
	/**
	 * sends a system message to a single user
	 * freecs.messageToUser(message, username)
	 */
	public boolean messageToUser(Vector args) throws Exception {
		String msg, username;
		try {		
			msg = (String) args.elementAt(0);
			username = (String) args.elementAt(1);
		} catch (Exception ex) {
			throw new XmlRpcException (0, "illegal arguments for freecs.messageToUser: " + ex.toString());
		}
		return AdminCore.messageToUser(msg, username);
	}

}