Re: Get the ping roundtriptime in Java

vanisathish@gmail.com wrote:


You could look at this code:

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.regex.Pattern;

/**
  * W.E. Consultants
  */
public class JHackerAppPing implements JHackerAppInterface
{

     protected static final boolean DEBUGMODE = false;

     private static final String PROGRAM = (((new Throwable())

..getStackTrace())[0]
                                                         .getClassName())

..replace(PACKAGE, "")
                                                         + ".";
     private static final String Debugheader = "( DEBUG ) " + PROGRAM;

     // The default daytime port
     static int DAYTIME_PORT = 80;
     // The port we'll actually use
     static int port = DAYTIME_PORT;

     // Representation of a ping target
     //
     static class Target
     {
         InetSocketAddress address;
         SocketChannel channel;
         Exception failure;
         long connectStart;
         long connectFinish = 0;
         boolean shown = false;

         Target(String host)
         {
             try
             {
                 address = new
InetSocketAddress(InetAddress.getByName(host),
                         port);
             } catch (IOException x)
             {
                 failure = x;
             }
         }
         void show()
         {
             String result;
             if (connectFinish != 0)
                 result = Long.toString(connectFinish - connectStart) +
"ms";
             else if (failure != null)
                 result = failure.toString();
             else
                 result = "Timed out";
             System.out.println(address + " : " + result);
             shown = true;
         }
     }
     //
     // Thread for printing targets as they're heard from
     static class Printer extends Thread
     {
         LinkedList pending = new LinkedList();
         Printer()
         {
             setName("Printer");
             setDaemon(true);
         }
         void add(Target t)
         {
             synchronized (pending)
             {
                 pending.add(t);
                 pending.notify();
             }
         }
         /**
          * (non-Javadoc)
          *
          * @see java.lang.Thread#run()
          */
         public void run()
         {
             try
             {
                 for (;;)
                 {
                     Target t = null;
                     synchronized (pending)
                     {
                         while (pending.size() == 0)
                             pending.wait();
                             t = (Target)pending.removeFirst();
                     }
                     t.show();
                 }
             } catch (InterruptedException x)
             {
                 return;
             }
         }
     }
     //
     // Thread for connecting to all targets in parallel via a single
selector
     static class Connector extends Thread
     {
         Selector sel;
         Printer printer;
         //
         // List of pending targets. We use this list because if we try to
         // register a channel with the selector while the connector
thread is
         // blocked in the selector then we will block.
         LinkedList pending = new LinkedList();
         Connector(Printer pr) throws IOException
         {
             printer = pr;
             sel = Selector.open();
             setName("Connector");
         }
         //
         // Initiate a connection sequence to the given target and add the
         // target to the pending-target list
         void add(Target t)
         {
             SocketChannel sc = null;
             try
             {
                 //
                 // Open the channel, set it to non-blocking, initiate
connect
                 sc = SocketChannel.open();
                 sc.configureBlocking(false);
                 sc.connect(t.address);
                 //
                 // Record the time we started
                 t.channel = sc;
                 t.connectStart = System.currentTimeMillis();
                 //
                 // Add the new channel to the pending list
                 synchronized (pending)
                 {
                     pending.add(t);
                 }
                 //
                 // Nudge the selector so that it will process the
pending list
                 sel.wakeup();
             } catch (IOException x)
             {
                 if (sc != null)
                 {
                     try
                     {
                         sc.close();
                     } catch (IOException xx)
                     {}
                 }
                 t.failure = x;
                 printer.add(t);
             }
         }
         //
         // Process any targets in the pending list
         void processPendingTargets() throws IOException
         {
             synchronized (pending)
             {
                 while (pending.size() > 0)
                 {
                     Target t = (Target)pending.removeFirst();
                     try
                     {
                         //
                         // Register the channel with the selector,
indicating
                         // interest in connection completion and
attaching the
                         // target object so that we can get the target back
                         // after the key is added to the selector's
                         // selected-key set
                         t.channel.register(sel,
SelectionKey.OP_CONNECT, t);

                     } catch (IOException x)
                     {
                         //
                         // Something went wrong, so close the channel and
                         // record the failure
                         t.channel.close();
                         t.failure = x;
                         printer.add(t);

                     }
                 }
             }
         }
         //
         // Process keys that have become selected
         void processSelectedKeys() throws IOException
         {
             for (Iterator i = sel.selectedKeys().iterator(); i.hasNext();)
             {

                 // Retrieve the next key and remove it from the set
                 SelectionKey sk = (SelectionKey)i.next();
                 i.remove();

                 // Retrieve the target and the channel
                 Target t = (Target)sk.attachment();
                 SocketChannel sc = (SocketChannel)sk.channel();

                 // Attempt to complete the connection sequence
                 try
                 {
                     if (sc.finishConnect())
                     {
                         sk.cancel();
                         t.connectFinish = System.currentTimeMillis();
                         sc.close();
                         printer.add(t);
                     }
                 } catch (IOException x)
                 {
                     sc.close();
                     t.failure = x;
                     printer.add(t);
                 }
             }
         }
         volatile boolean shutdown = false;
         //
         // Invoked by the main thread when it's time to shut down
         void shutdown()
         {
             shutdown = true;
             sel.wakeup();
         }
         //
         // Connector loop
         /**
          * (non-Javadoc)
          *
          * @see java.lang.Thread#run()
          */
         public void run()
         {
             for (;;)
             {
                 try
                 {
                     int n = sel.select();
                     if (n > 0)
                         processSelectedKeys();
                     processPendingTargets();
                     if (shutdown)
                     {
                         sel.close();
                         return;
                     }
                 } catch (IOException x)
                 {
                     x.printStackTrace();
                 }
             }
         }
     }

     /**
      * @param args
      * @throws InterruptedException
      * @throws IOException
      */
     public static void main(String[] args) throws InterruptedException,
IOException
     {
         if (args.length < 1)
         {
             System.err.println("Usage: java JHackerAppPing [port]
host...");
             return;
         }
         int firstArg = 0;
         //
         // If the first argument is a string of digits then we take that
         // to be the port number to use
         if (Pattern.matches("[0-9]+", args[0]))
         {
             port = Integer.parseInt(args[0]);
             firstArg = 1;
         }
         //
         // Create the threads and start them up
         Printer printer = new Printer();
         printer.start();
         Connector connector = new Connector(printer);
         connector.start();
         //
         // Create the targets and add them to the connector
         LinkedList targets = new LinkedList();
         for (int i = firstArg; i < args.length; i++)
         {
             Target t = new Target(args[i]);
             targets.add(t);
             connector.add(t);
         }
         //
         // Wait for everything to finish
         Thread.sleep(2000);
         connector.shutdown();
         connector.join();
         //
         // Print status of targets that have not yet been shown
         for (Iterator i = targets.iterator(); i.hasNext();)
         {
             Target t = (Target)i.next();
             if (!t.shown)
                 t.show();
         }
     }
}

--
Thanks in Advance... http://ichbin.9999mb.com
IchBin, Pocono Lake, Pa, USA
______________________________________________________________________
'If there is one, Knowledge is the "Fountain of Youth"'
-William E. Taylor, Regular Guy (1952-)