Quadcap Embeddable Server

com/quadcap/net/server/Server.java

Go to the documentation of this file.

package com.quadcap.net.server;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.IOException;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;

import java.net.ServerSocket;

import com.quadcap.util.collections.ArrayQueue;
import com.quadcap.util.collections.IntMap;

/**
 * A server has a set of workers, a context, and an acceptor.  Workers
 * are created on demand, up to a configurable maximum.
 *
 * @author Stan Bailes
 */
public class Server {
    Class                       workerClass;
    Object                      workerLock              = new Object();
    Object                      context;
    ThreadGroup                 threads;
    IntMap                      allWorkers;
    ArrayQueue                  workers;
    int                         numWorkers              = 0;
    int                         maxWorkers              = 128;
    long                        shutdownInterval        = 2000L;
    String                      name;

    /*{com.quadcap.net.server.Server.xml}
     * <config-var>
     *   <config-name>maxWorkers</config-name>
     *   <config-dflt>64</config-dflt>
     *   <config-desc>QWS uses a thread-pool architecture; new worker threads are
     *       created on demand to satisfy load, up to a a configurable
     *       maximum number, specified by this configuration parameter.</config-desc>
     * </config-var>
     *
     * <config-var>
     *   <config-name>name</config-name>
     *   <config-dflt><i>none</i></config-dflt>
     *   <config-desc>Specify the name of this server.</config-desc>
     * </config-var>
     *
     * <config-var>
     *  <config-name>workerClass</config-name>
     *  <config-dflt><i>none</i></config-dflt>
     *  <config-desc>Class to instantiate to handle requests</config-desc>
     * </config-var>
     *
     * <config-var>
     *  <config-name>shutdownInterval</config-name>
     *  <config-dflt>2000</config-dflt>
     *  <config-desc>Graceful delay on shutdown</config-desc>
     * </config-var>
     *
     * <config-var>
     *  <config-name>port</config-name>
     *  <config-dflt><i>none</i></config-dflt>
     *  <config-desc>TCP Port to accept connections from</config-desc>
     * </config-var>
     *
     * <config-var>
     *  <config-name>queueDepth</config-name>
     *  <config-dflt>16</config-dflt>
     *  <config-desc>TCP listen queue depth</config-desc>
     * </config-var>
     */
    public Server(Properties props, Object context)
        throws ClassNotFoundException
    {
        this.context = context;
        this.workerClass = Class.forName(props.getProperty("workerClass"));

        int max = Integer.parseInt(props.getProperty("maxWorkers", "64"));
        this.workers = new ArrayQueue(max);
        this.allWorkers = new IntMap(max / 3);
        this.name = props.getProperty("name", "server");
        this.threads = new ThreadGroup(name);
        this.shutdownInterval =
            Long.parseLong(props.getProperty("shutdownInterval", "2000"));
        
    }

    public ThreadGroup getThreadGroup() {
        return threads;
    }
    
    public void startAcceptor(Properties props) throws IOException {
        int port = Integer.parseInt(props.getProperty("port"));
        int queueDepth =
            Integer.parseInt(props.getProperty("queueDepth", "16"));
        Acceptor acceptor = new Acceptor(this, port, queueDepth);
        Thread t = new Thread(threads, acceptor);
        t.start();
    }

    // XXX This implementation doesn't ensure fairness
    public Worker getIdleWorker() throws Exception {
        synchronized (workerLock) {
            while (true) {
                Worker w = (Worker)workers.popFront();
                if (w != null) return w;

                if (numWorkers < maxWorkers) {
                    return newWorker();
                } else {
                    try {
                        workerLock.wait();
                    } catch (InterruptedException ee) {
                    }
                }
            }
        }
    }

    public int getIdleWorkers(Worker[] workerv) throws Exception {
        int cnt = 0;
        synchronized (workerLock) {
            for (; cnt < workerv.length; cnt++) {
                Worker w = (Worker)workers.popFront();
                if (w != null) {
                    workerv[cnt] = w;
                } else {
                    if (numWorkers < maxWorkers) {
                        workerv[cnt] = newWorker();
                    } else if (cnt > 0) {
                        break;
                    } else {
                        try {
                            workerLock.wait();
                        } catch (InterruptedException ee) {
                        }
                    }
                }
            }
        }
        return cnt;
    }

    public void returnIdleWorker(Worker w) {
        synchronized (workerLock) {
            workers.pushFront(w);
            workerLock.notifyAll();
        }
    }

    public void workerDone(Worker w) {
        allWorkers.remove(w.getId());
        workerLock.notifyAll();
    }

    public Worker newWorker() throws Exception {
        Worker w = (Worker)workerClass.newInstance();
        w.init(this, context, name);
        allWorkers.put(w.getId(), w);
        new Thread(threads, w).start();
        return w;
    }

    public void stop() {
        Iterator iter = allWorkers.keys();
        while (iter.hasNext()) {
            int id = ((Integer)iter.next()).intValue();
            Worker w = (Worker)allWorkers.get(id);
            w.stop();
        }
        try { Thread.sleep(shutdownInterval); } catch (Throwable t) {}

        if (threads.activeCount() > 0) {
            Thread[] ts = new Thread[threads.activeCount()];
            int cnt = threads.enumerate(ts);
            for (int i = 0; i < cnt; i++) {
                Thread t = ts[i];
                if (!t.isInterrupted()) {
                    t.interrupt();
                }
            }
            try { Thread.sleep(shutdownInterval); } catch (Throwable t) {}
            cnt = threads.enumerate(ts);
            for (int i = 0; i < cnt; i++) {
                Thread t = ts[i];
                try {
                    t.join(shutdownInterval/10);
                } catch (Throwable th) {
                } finally {
                    try {
                        t.stop();
                    } catch (Throwable th2) {
                    }
                }
            }
        }
    }
}