sockettalknaplet.java

来自「移动Agent编程工具Naplet」· Java 代码 · 共 265 行

/*
 * @<#> SocketTalkNaplet.java version 0.0.1, 11/2003
 *
 * THIS PROGRAM IS FREE SOFTWARE; YOU CAN DISTRIBUTE IT AND/OR
 * MODIFY IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE
 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION.
 *
 * 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.
 *
 * Copyright (c) 2000 Wayne State University. All Rights Reserved.
 */
package napletSocket2;

/**
 * The <code>SocketTalkNaplet</code> class defines two naplets that talk by
 * napletsocket while migrating through network.
 * Both naplets migrate concurrently at about the same rate. A parallel itinery
 * with two sequential itinery is formed by a list of machines as input
 * parameters.Both the sequential itineries have the same number of hosts.
 * Two agents migrate according to the itineries and keep communicating in
 * each host. A NapletServerSocket will be set up in the first host from the
 * given parameters.
 *
 * @version 0.0.1, 11/2003
 * @author Xiliang Zhong
 *
 */
import java.io.*;
import java.rmi.*;
import java.util.*;
import java.lang.reflect.*;
import java.net.*;
import naplet.*;
import naplet.server.*;
import naplet.itinerary.*;
import naplet.message.*;
import naplet.nsocket.*;
import service.*;

public class SocketTalkNaplet
    extends Naplet
{
  NapletSocket napletSocket;
  public SocketTalkNaplet( String[] servers )
      throws InvalidNapletException,
      InvalidItineraryException
  {
    this( null, servers, null );
  }

  public SocketTalkNaplet( String name, String[] servers )
      throws
      InvalidNapletException, InvalidItineraryException
  {
    this( name, servers, null );
  }

  /**
   * Constructs a naplet
   * @param servers a list of servers to be visited
   * @param listener listener of the naplet waiting for results
   */
  public SocketTalkNaplet( String[] servers, NapletListener listener )
      throws
      InvalidNapletException, InvalidItineraryException
  {
    this( null, servers, listener );
  }

  /**
   * Constructs a naplet, setting itinerary
   *
   * @param name Nick name of the naplet
   * @param servers A list of servers to be visitted
   * @param listener Listener of the naplet waiting for results
   */
  public SocketTalkNaplet( String name, String[] servers,
                           NapletListener listener )
      throws
      InvalidNapletException, InvalidItineraryException
  {

    super( name, listener );

    // set server name; Here the assumption is the 1st
    // machine has the SocketServer
    setServer( servers[0] );
    setServerID( getNapletID().toString() + ".1" );

    try
    {
      Hashtable messages = new Hashtable( servers.length );
      setNapletState( new ProtectedNapletState() );
      getNapletState().set( "message", messages );
    }
    catch ( NapletStateAccessException nsae )
    {
      throw new InvalidNapletException( "Naplet state initilization failure" );
    }

    setItinerary( new ICItinerary( servers ) );
  }

  /**
   * Entry point of a naplet at each server
   */
  public void onStart()
      throws InterruptedException
  {
    String serverName;
    String msg = null;

    URN server;

    server = getNapletContext().getServerURN();

    System.out.println( "Naplet " + this.getNapletID().toString()
                        + " arrives at " + server.toString() );

    String rank = getNapletID().getVersion();

    if ( rank.equals( ".1" ) )
    { // server
      if ( napletSocket == null )
      { // first time start a server and accept nsocket
        try
        {
          NapletServerSocket nss = new NapletServerSocket(
              getNapletID() );
          napletSocket = nss.accept();
        }
        catch ( NoSocketControllerException nsce )
        {
            throw new NapletRuntimeException( nsce );
        }
        catch ( IOException ioe )
        {
          ioe.printStackTrace();
        }
        catch ( Exception e )
        {
          e.printStackTrace();
        }
      } // end of first time for server

      // each time
      long start = 0, intv = 0;

      try
      {
        PrintWriter out
            = new PrintWriter( napletSocket.getOutputStream(), true );
        BufferedReader in = new BufferedReader(
            new InputStreamReader( napletSocket.getInputStream() ) );
        String request = null, response = null;
        request = in.readLine();
        System.out.println( "get a request:" + request );
        response = "echo:" + request;
        out.println( response );

      }
      catch ( Exception e )
      {
        e.printStackTrace();
      }

    } // end of server
    else
    { // all others are client
      try
      {
        // if first time, setup socket with the server
        if ( napletSocket == null )
        {
          // delay some time in case server needs more
          // time to set up.
          Thread.currentThread().sleep( 3000 );

          // first time for open napletsocket
          NapletID mynid = getNapletID();
          NapletID destnid = ( NapletID ) mynid.clone();

          destnid.setVersion( ".1" );

          napletSocket = new NapletSocket( mynid, destnid );
        } // end of first time for client

        PrintWriter out
            = new PrintWriter( napletSocket.getOutputStream(), true );
        BufferedReader in = new BufferedReader(
            new InputStreamReader( napletSocket.getInputStream() ) );

        String request = null, response = null;
        request = "request from:" +
            InetAddress.getLocalHost().getHostName();
        out.println( request );

        response = in.readLine();
        System.out.println( "**response from server is:" + response );
      } //end of client
      catch ( NoSocketControllerException nsce )
      {
          throw new NapletRuntimeException( nsce );
      }
      catch ( IOException ioe )
      {
        ioe.printStackTrace();
      }
      catch ( Exception e )
      {
        e.printStackTrace();
      }
    }

    try
    {
      getItinerary().travel( this );
    }
    catch ( NapletMigrateException nme )
    {
      throw new NapletRuntimeException( nme );
    }

  }

  static void classFinalize()
  {
    System.out.println( "MyNaplet was finalized" );
  }

  private class ICItinerary
      extends Itinerary
  {
    public ICItinerary( String[] servers )
        throws InvalidItineraryException
    {

      ItineraryPattern[] ip = new ItineraryPattern[2];

      int first = servers.length / 2;
      String[] dest = new String[first];
      for ( int i = 0; i < first; i++ )
      {
        dest[i] = new String( servers[i] );
      }

      String dest2[] = new String[servers.length - first];
      for ( int i = 0; i < servers.length - first; i++ )
      {
        dest2[i] = new String( servers[first + i] );
      }

      ip[0] = new SeqPattern( dest );
      ip[1] = new SeqPattern( dest2 );

      setRoute( new ParPattern( ip ) );

      System.out.println( "ICItinerary = " + getRoute().toString() );
    }
  }
}