---

Connection.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.io.*;
import java.net.*;
import java.util.*;
import org.hebe.mps.naming.Binding;

/**
 * Manages client-side connections to an MPS server. Contains the
 * looked-up/resolved address of the remote server (ie. the canonical
 * name of the server), and a Socket for communication with the
 * server. This class is only used internally, and should never be
 * exposed to client objects outside this package.
 *
 * @author Tony Garnock-Jones <tonyg@kcbbs.gen.nz>
 * @see org.hebe.mps.Proxy
 * @see org.hebe.mps.InputStream
 * @see org.hebe.mps.OutputStream */
class Connection {
    /** mps:inet:<host>:<port>:<oid> - server's canonical (bound) name */
    private String resolvedName;

    /** Socket that connects us to the remote server */
    private Socket connection;

    /** Transport name - always "inet", for the Java implementation, currently */
    private String method;
    /** Hostname of the remote server - taken from resolvedName */
    private String hostname;
    /** Port number of the remote server - taken from resolvedName */
    private int portnumber;
    /** OID (Object ID) of the remote server - taken from resolvedName */
    private int oid;

    /**
     * Creates a fresh Connection given the resolved name of a remote
     * object to connect to.
     *
     * @param name the resolved name of the MPS server to connect to
     * @exception MPSException if the resolved name is ill-formed or unsupported
     */
    public Connection(String name) throws MPSException {
        resolvedName = name;
        connection = null;
        parseResolvedName();
    }

    /**
     * Obtains a (simple) human-readable representation of this
     * connection object.
     *
     * @return the printable string
     */
    public String toString() {
        return "MPSConnection(" + resolvedName + ")";
    }

    /**
     * Splits up the resolvedName of this object into its components.
     *
     * @exception MPSException if the resolvedName of this object is ill-formed or unsupported
     */
    private void parseResolvedName() throws MPSException {
        try {
            StringTokenizer st = new StringTokenizer(resolvedName, ":");
            st.nextToken();     // skip "mps:"
            method = st.nextToken();
            hostname = st.nextToken();
            portnumber = Integer.parseInt(st.nextToken());
            oid = Integer.parseInt(st.nextToken());
        } catch (Exception e) {
            throw new MPSException("Invalid object name " + toString());
        }

        if (!method.equals("inet")) {
            throw new MPSException("Invalid transport name " + method);
        }
    }

    /**
     * Opens the connection to the remote server. Only called on
     * demand.
     *
     * @exception MPSException if the resolvedName of this object is ill-formed or unsupported
     * @exception MPSException if the server is refusing connections
     */
    public void open() throws MPSException {
        if (connection != null)
            return;

        parseResolvedName();

        try {
            connection = new Socket(hostname, portnumber);
        } catch (Exception e) {
            throw new MPSException("Could not connect to object " + toString());
        }
    }

    /**
     * Closes the connection to the remote server.
     *
     * @exception MPSException if there was a problem closing the socket.
     */
    public void close() throws MPSException {
        try {
            connection.close();
        } catch (IOException e) {
            throw new MPSException("Error closing connection " + toString());
        } finally {
            connection = null;
        }
    }

    /**
     * Allows clients access to the input (server-to-client)
     * facilities of the socket connected to the remote server.
     *
     * @return a Java input stream for reading bytes from the server
     * @exception MPSException from open() if the connection was closed and wouldn't open
     * @exception MPSException if the socket failed to create an InputStream for us
     */
    public java.io.InputStream getInputStream() throws MPSException {
        try {
            open();
            return connection.getInputStream();
        } catch (IOException e) {
            throw new MPSException("Could not get input stream for " + toString());
        }
    }

    /**
     * Allows clients access to the output (client-to-server)
     * facilities of the socket connected to the remote server.
     *
     * @return a Java output stream for reading bytes from the server
     * @exception MPSException from open() if the connection was closed and wouldn't open
     * @exception MPSException if the socket failed to create an OutputStream for us
     */
    public java.io.OutputStream getOutputStream() throws MPSException {
        try {
            open();
            return connection.getOutputStream();
        } catch (IOException e) {
            throw new MPSException("Could not get output stream for " + toString());
        }
    }

    /**
     * Allows clients to inspect the canonical name for the server we
     * are connected to.
     */
    public String getResolvedName() {
        return resolvedName;
    }

    /**
     * Returns the OID of the remote object. For use by
     * {Input,Output}Stream's constructors.
     */
    int getOid() {
        return oid;
    }
}

---