bufferedionaplet.java~1~

移动Agent编程工具Naplet

/*
 * @<#> BufferedIONaplet.java version 0.0.1, 5/13/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) 2003 Wayne State University. All Rights Reserved.
 */
package bufferedIO;

/**
 * The <code>BufferedIONaplet</code> class implements an example of Naplets
 * that require priviledged services on visited servers by buffered
 * character stream. It aims to test the efficiency of the buffered IO
 * between naplets and servers.
 *
 * In this example, the naplet reads file "testData" from /tmp/ directory and
 * sends it to each visited server. After finishing that, it tries to read
 * the responce from servers. Corresponding services should be implemented
 * in the directory of "ServiceImpl" at naplet server side.
 *
 * @version 0.0.1, 1/1/2000
 * @author C. Xu
 *
 */
import java.io.*;
import java.rmi.*;
import java.util.*;
import java.lang.reflect.*;
import naplet.*;
import naplet.itinerary.*;
import naplet.serviceChannel.*;

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

    public BufferedIONaplet( 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 BufferedIONaplet( 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 BufferedIONaplet( String name, String[] servers,
                             NapletListener listener )
        throws InvalidNapletException, InvalidItineraryException
    {
        super( name, listener );
        try
        {
            Hashtable messages = new Hashtable( servers.length );
            setNapletState( new ProtectedNapletState() );
            getNapletState().set( "message", messages );
        }
        catch ( NoSuchFieldException nsfe )
        {
            throw new InvalidNapletException();
        }

        setItinerary( new ICItinerary( servers ) );
    }

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

        serverName = getNapletContext().getServerURN().getHostName();

        System.out.println( "Naplet " + this.getNapletID().toString()
                            + " is running at " + serverName );

        ServiceChannel channel = null;
        try
        {
            channel = ( ServiceChannel )
                getNapletContext().getServiceChannel(
                "serviceImpl.BufferedIOTestService" );
        }
        catch ( NoSuchServiceException nse )
        {
            System.out.println( "No such service" );
        }
        catch ( IllegalAccessException iae )
        {
            System.out.println( "Access to the service is denied" );
        }

        try
        {
            if ( channel == null )
            {
                System.out.println( "No such service" );
            }
            else
            {
                // get the read and write ends at Naplet side of
                // service channel and wrap them in buffered read and write.
                NapletOutputStream outStream
                    = channel.getNapletOutputStream();
                BufferedNapletOutputStream bOutStream
                    = new BufferedNapletOutputStream( outStream );
                NapletWriter writer
                    = channel.getNapletWriter();
                BufferedNapletWriter bWriter
                    = new BufferedNapletWriter( writer );

                NapletInputStream inStream
                    = channel.getNapletInputStream();
                BufferedNapletInputStream bInStream
                    = new BufferedNapletInputStream( inStream );
                NapletReader reader
                    = channel.getNapletReader();
                BufferedNapletReader bReader
                    = new BufferedNapletReader( reader );

                //  write 10000000 integers to each server naplet visits
                try
                {

                    int i = 0;
                    final int len = 10000000;
                    for ( ; i < len; i++ )
                    {
                        bWriter.write( i );
                    }

                    System.out.println(
                        "\nNaplet writes " + i
                        + " characters to BufferedIOTestService" );

                }
                catch ( IOException e )
                {
                    System.err.println( "Error: " + e.getMessage() );
                }
                finally
                {
                    bWriter.close();
                    bOutStream.close();
                }

                // Read the responce from the server.
                try
                {

                    int j = 0;
                    int ch;
                    while ( ( ch = bReader.read() ) != -1 )
                    {
                        j++;
                    }

                    System.out.println(
                        "\nNaplet reads " + j
                        + " characters from BufferedIOTestService" );

                }
                catch ( Exception e )
                {
                    System.err.println( e.getMessage() );
                }

                try
                {
                    getItinerary().travel( this );
                }
                catch ( UnableDispatchException ude )
                {
                    System.out.println( ude.getMessage() );
                }
                catch ( RemoteException re )
                {
                    System.out.println( re.getMessage() );
                }
            }
        }
        catch ( Exception e )
        {
            System.err.println( e.getMessage() );
        }
    }

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

    private class ICItinerary extends Itinerary
    {
        public ICItinerary( String[] servers )
            throws InvalidItineraryException
        {
            // seq(s0,s1,s2)
            setRoute( new SeqPattern( servers ) );

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