---

Server.java

Go to the documentation of this file.

/**************************************************************************
 Copyright (c) 2000-2001, Tony Garnock-Jones
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
       with the distribution.

     * Neither the names of the copyright holders nor the names of this
       software's contributors may be used to endorse or promote
       products derived from this software without specific prior
       written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**************************************************************************/

package org.hebe.mps;

import java.util.*;
import java.io.*;
import java.net.*;

import org.hebe.mps.naming.Binding;

/**
 * Implements all the code needed to get an implementation of an MPS
 * interface running as an MPS server. Pass in your desired objectName
 * and an implementation of the correct interface to the
 * automatically-generated subclasses of this class. It will spawn a
 * thread that listens for connections to the server object.
 *
 * <p>
 * Note that the implementation object is managed by
 * <i>subclasses</i> of this class, and that this class knows nothing
 * about the implementation of the MPS interface at all.
 *
 * @author Tony Garnock-Jones <tonyg@kcbbs.gen.nz>
 * @see org.hebe.mps.Proxy
 */
public class Server implements Runnable {
    /**
     * Map used to associate an MPSIDL interface instance with an
     * instance of class Server.
     *
     * @see org.hebe.mps.OutputStream#writeReference
     */
    private static Hashtable allServers = new Hashtable();

    /**
     * Registers an instance of Server against the MPSIDL interface
     * object that it is serving. The MPSIDL compiler emits calls to
     * this method when compiling MPSIDL specifications down to java
     * skeletons.
     *
     * @param key the MPSIDL interface instance being served
     * @param svr the server object we are registering
     */
    protected static void registerServer(Object key, Server svr) {
        allServers.put(key, svr);
    }

    /**
     * Retrieve the Server associated with a particular MPSIDL
     * interface instance.
     *
     * @param key the MPSIDL interface instance we're interested in
     * @return an instance of Server, or null if key is not being served
     */
    public static Server serverFor(Object key) {
        return (Server) allServers.get(key);
    }

    ///////////////////////////////////////////////////////////////////////////

    /** Human-readable name for this object */
    private String objectName;
    /** Machine-readable address of this object */
    private String boundName;

    /** Server socket that clients connect to us on. */
    private ServerSocket serverSocket;
    /** Address of the interface our server socket is bound to */
    private InetAddress address;
    /** TCP Port number we're listening on */
    private int portNumber;

    /**
     * Set to true if we are to serve access to our implementation
     * object in a multithreaded way; set to false to serialize all
     * accesses
     * 
     * @see org.hebe.mps.Server#setMultiThreaded */
    private boolean multiThreaded = true;

    /**
     * Look-up-table mapping method number to method implementation.
     *
     * @see org.hebe.mps.Thunk
     * @see org.hebe.mps.Server#dispatch */
    private Vector methodTable = new Vector();

    /**
     * Create a new server named objectName. Bind to INADDR_ANY, on
     * any unused port number.
     *
     * @param objectName human-readable name for this server
     * @exception MPSException if anything goes wrong setting up the server */
    public Server(String objectName) throws MPSException {
        setup(objectName, null, 0);
    }

    /**
     * Create a new server named objectName. Bind to INADDR_ANY, on
     * the passed-in port number.
     *
     * @param objectName human-readable name for this server
     * @param portNumber the port to use to accept connections on
     * @exception MPSException if anything goes wrong setting up the server
     */
    public Server(String objectName, int portNumber)
        throws MPSException
    {
        setup(objectName, null, portNumber);
    }

    /**
     * Create a new server named objectName. Bind to a specific
     * interface, on the passed-in port number.
     *
     * @param objectName human-readable name for this server
     * @param address the InetAddress of the interface to bind to
     * @param portNumber the port to use to accept connections on
     * @exception MPSException if anything goes wrong setting up the server
     */
    public Server(String objectName, InetAddress address, int portNumber)
        throws MPSException
    {
        setup(objectName, address, portNumber);
    }

    /**
     * Return the canonical name of this server.
     *
     * @return the string representation of the canonical name
     */
    public String getBoundName() {
        return boundName;
    }

    /**
     * Performs all the steps needed to get the server started.
     *
     * @param objectName human-readable name for this server
     * @param address the InetAddress of the interface to bind to - null for INADDR_ANY
     * @param portNumber the port to use to accept connections on - 0 for any unused
     * @exception MPSException if anything goes wrong setting up the server
     */
    private void setup(String objectName, InetAddress address, int portNumber)
        throws MPSException
    {
        this.objectName = objectName;
        this.address = address;
        this.portNumber = portNumber;
        setup();
    }

    /**
     * Creates and starts the thread, once all the instance variables
     * have been set up.
     *
     * @exception MPSException if the specified local socket address is already taken
     */
    private void setup()
        throws MPSException
    {
        try {
            serverSocket =
                (address == null) ? new ServerSocket(portNumber)
                    : new ServerSocket(portNumber, 50, address);

            boundName =
                "mps:inet:" +
                ((address == null) ? InetAddress.getLocalHost() : serverSocket.getInetAddress()).getHostName() +
                ":" +
                serverSocket.getLocalPort() +
                ":0";

            new Thread(this).start();

        } catch (IOException e) {
            throw new MPSException("Cannot bind server socket.");
        }
    }

    /**
     * Returns true if this server is running multithreaded.
     * @return the current multithreadedness of this server
     */
    public boolean getMultiThreaded() {
        return multiThreaded;
    }

    /**
     * Determines whether multiple threads (one thread per client
     * connection, remember) may access methods on the implementation
     * object simultaneously. If not, all dispatches to the
     * implementation object go through a <code>synchronized</code>
     * lock.
     *
     * @param m set to true to enable parallel access, or to false to enforce serial access
     */
    public void setMultiThreaded(boolean m) {
        multiThreaded = m;
    }

    /**
     * Dispatches to a method on this MPS interface server.
     *
     * @param index the index of the method to call
     * @param in the inputstream used by the method to read in parameters
     * @param out the outputstream used by the method to return results
     * @exception MPSException if the method causes it to be raised,
     * or if the method index is out-of-range
     */
    public void dispatch(int index, InputStream in, OutputStream out)
        throws MPSException
    {
        //System.out.println("Dispatching " + index);
        try {
            Thunk t = (Thunk) methodTable.elementAt(index);
            t.action(in, out);
        } catch (ArrayIndexOutOfBoundsException ae) {
            throw new MPSException("Method number " + index + " out of range");
        }
    }

    /**
     * Register a method-handler with the server.
     *
     * @param index the method-index to use to register under
     * @param name the name of the method - not currently used, but useful for debugging
     * @param thunk the object to call when the method is invoked
     */
    public void registerMethod(int index, String name, Thunk thunk) {
        // We could use /name/ for debug info, later.
        methodTable.setSize(Math.max(index + 1, methodTable.size()));
        methodTable.setElementAt(thunk, index);
    }

    /**
     * The main body of the server thread.
     */
    public void run() {
        try {
            while (true) {
                Socket sock = serverSocket.accept();
                new Thread(new ConnectionThread(sock, this)).start();
            }
        } catch (IOException e) {
            // Stop serving.
            try {
                serverSocket.close();
            } catch (IOException ioee) {
            }

            // Start up again.
            try {
                setup();
            } catch (MPSException mpse) {
            }
        }
    }

    /**
     * This class implements the body of the thread that is run for
     * each client that connects to an MPS interface server.
     */
    private class ConnectionThread implements Runnable {
        /** Socket that connects us to our client */
        private Socket sock;
        /** Server we are acting on behalf of */
        private Server server;

        public ConnectionThread(Socket sock, Server server) {
            this.sock = sock;
            this.server = server;
        }

        /**
         * The main body of the thread. Read requests from the
         * InputStream until end-of-file, and dispatch on each request
         * as it comes in using the <code>dispatch</code> method in
         * our enclosing class, org.hebe.mps.Server.
         *
         * @author Tony Garnock-Jones <tonyg@kcbbs.gen.nz>
         * @see org.hebe.mps.Server
         */
        public void run() {
            try {
                InputStream in = new InputStream(sock.getInputStream());
                OutputStream out = new OutputStream(sock.getOutputStream());

                while (true) {
                    int targetOid = in.readint();       // ignored for now. Always zero.

                        // clear out any junk oids not sent (in the case of
                        // void-returning methods)
                        out.resetBuffer();
                        // put the oid for this invocation in the output message
                    out.writeint(targetOid);

                    int i = in.readint();

                    //System.out.println("Method " + i);

                    if (server.getMultiThreaded()) {
                        server.dispatch(i, in, out);
                    } else {
                        synchronized(server) {
                            server.dispatch(i, in, out);
                        }
                    }
                }
            } catch (MPSConnectionClosedException cce) {
                // Do nothing. This will happen from time to time.
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    sock.close();
                } catch (IOException ioee) {
                }
            }
        }
    }
}

---