EIDSClient.java

  1. /*
  2.  * EIDSClient
  3.  */
  4. package gov.usgs.earthquake.eidsutil;

  6. import java.util.Iterator;
  7. import java.util.List;
  8. import java.util.LinkedList;
  9. import java.util.Timer;
  10. import java.util.TimerTask;

  12. /**
  13.  * An EIDS client that is a java event source.
  14.  */
  15. public class EIDSClient implements EIDSListener {

  17.     /** Property name for eids server host address. */
  18.     public static final String EIDS_SERVER_HOST_PROPERTY = "serverHost";

  20.     /** Property name for eids server port. */
  21.     public static final String EIDS_SERVER_PORT = "serverPort";

  23.     /** Property name for eids server alternate servers list. */
  24.     public static final String EIDS_ALTERNATE_SERVERS = "alternateServers";

  26.     /** Property name for objects to load and add as EIDSListeners. */
  27.     public static final String EIDS_LISTENERS = "listeners";

  29.     /** Version string for program. */
  30.     public static final String PROGRAM_VERSION = "0.2";

  32.     /** Name string for program. */
  33.     public static final String PROGRAM_NAME = "EIDSClient";

  35.     /** Default server host. */
  36.     public static final String DEFAULT_SERVER_HOST = "eids1.cr.usgs.gov";

  38.     /** Default server port number. */
  39.     public static final Integer DEFAULT_SERVER_PORT = 39977;

  41.     /** Default maxServerEventAgeDays parameter. */
  42.     public static final Double DEFAULT_MAX_SERVER_EVENT_AGE_DAYS = 3.0;

  44.     /** Default Tracking filename. */
  45.     public static final String DEFAULT_TRACKING_FILE_NAME = "EIDSClient_tracking.dat";

  47.     /** Default client restart interval */
  48.     public static final Long DEFAULT_CLIENT_RESTART_INTERVAL = 86400000L;

  50.     /** Server host name. */
  51.     private String serverHost;

  53.     /** Server port number. */
  54.     private Integer serverPort;

  56.     /** Comma delimited list of host:port s. */
  57.     private String alternateServersList;

  59.     /** The decimal age in days. */
  60.     private Double maxServerEventAgeDays;

  62.     /** Tracking file for EIDS client. */
  63.     private String trackingFileName;

  65.     /** The actual client this object wraps. */
  66.     private QWEmbeddedClient client;

  68.     /** Listeners to notify when a message is received. */
  69.     private List<EIDSListener> listeners = new LinkedList<EIDSListener>();

  71.     /** A timer used to periodically restart the client. */
  72.     private Timer clientRestartTimer;

  74.     /** How often to periodically restart the client, in milliseconds. */
  75.     private Long clientRestartInterval;

  77.     /** Whether we are debugging or not. Affects log level. */
  78.     private boolean debug;

  80.     /** Constructor using default host and port */
  81.     public EIDSClient() {
  82.         this(DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT);
  83.     }

  85.     /**
  86.      * Construct an EIDSClient using only server host and port.
  87.      *
  88.      * Calls other constructor with null values for other parameters.
  89.      *
  90.      * @param serverHost Specific host
  91.      * @param serverPort Specific port
  92.      */
  93.     public EIDSClient(final String serverHost, final Integer serverPort) {
  94.         this(serverHost, serverPort, "");
  95.     }

  97.     /**
  98.      * Construct an EIDSClient using serverHost, serverPort, and
  99.      * alternateServersList.
  100.      *
  101.      * @param serverHost Host
  102.      * @param serverPort Port
  103.      * @param alternateServersList
  104.      *            a comma delimited list of host:port that are used when unable
  105.      *            to connect to the primary serverHost and serverPort.
  106.      */
  107.     public EIDSClient(final String serverHost, final Integer serverPort,
  108.             final String alternateServersList) {
  109.         this(serverHost, serverPort, alternateServersList,
  110.                 DEFAULT_MAX_SERVER_EVENT_AGE_DAYS, DEFAULT_TRACKING_FILE_NAME,
  111.                 DEFAULT_CLIENT_RESTART_INTERVAL);
  112.     }

  114.     /**
  115.      * Constructor with all options.
  116.      *
  117.      * @param serverHost
  118.      *            the eids server host or ip address.
  119.      * @param serverPort
  120.      *            the eids server port.
  121.      * @param alternateServersList
  122.      *            a comma delimited list of host:port that are used when unable
  123.      *            to connect to the primary serverHost and serverPort.
  124.      * @param maxServerEventAgeDays
  125.      *            number of days worth of messages to retrieve on first connect.
  126.      * @param trackingFileName
  127.      *            location where tracking file is stored. This file is used to
  128.      *            track which messages have been received.
  129.      * @param clientRestartInterval
  130.      *            How often to periodically restart the client, in milliseconds
  131.      */
  132.     public EIDSClient(final String serverHost, final Integer serverPort,
  133.             final String alternateServersList,
  134.             final Double maxServerEventAgeDays, final String trackingFileName,
  135.             final Long clientRestartInterval) {
  136.         this.serverHost = serverHost;
  137.         this.serverPort = serverPort;
  138.         this.alternateServersList = alternateServersList;
  139.         this.maxServerEventAgeDays = maxServerEventAgeDays;
  140.         this.trackingFileName = trackingFileName;
  141.         this.clientRestartInterval = clientRestartInterval;
  142.     }

  144.     /**
  145.      * Runs the client.
  146.      *
  147.      * Any listeners should be added before calling this method.
  148.      */
  149.     public void startup() {
  150.         // were we already running?
  151.         if (client != null) {
  152.             client.shutdown();
  153.             client = null;
  154.         }

  156.         // start the client
  157.         client = new QWEmbeddedClient(serverHost, serverPort,
  158.                 alternateServersList, maxServerEventAgeDays, trackingFileName);
  159.         client.addListener(this);

  161.         if (debug) {
  162.             client.setConsoleLogLevel("Debug5");
  163.         }

  165.         client.startup();

  167.         // if this is the first time through
  168.         if (clientRestartTimer == null && clientRestartInterval > 0) {
  169.             clientRestartTimer = new Timer();
  170.             clientRestartTimer.schedule(
  171.                     new TimerTask() {
  172.                         public void run() {
  173.                             reinitConnection();
  174.                         }
  175.                     },
  176.                     // before first execution
  177.                     clientRestartInterval,
  178.                     // between subsequent executions
  179.                     clientRestartInterval);
  180.         }
  181.     }

  183.     /**
  184.      * Shuts down a running client.
  185.      *
  186.      * Does not call system.exit.
  187.      */
  188.     public void shutdown() {
  189.         if (clientRestartTimer != null) {
  190.             clientRestartTimer.cancel();
  191.         }
  192.         if (client != null) {
  193.             client.shutdown();
  194.             client = null;
  195.         }
  196.     }

  198.     /**
  199.      * Add a listener.
  200.      *
  201.      * @param listener
  202.      *            the listener to add.
  203.      */
  204.     public synchronized void addListener(final EIDSListener listener) {
  205.         this.listeners.add(listener);
  206.     }

  208.     /**
  209.      * Remove a listener.
  210.      *
  211.      * @param listener
  212.      *            the listener to remove.
  213.      */
  214.     public synchronized void removeListener(final EIDSListener listener) {
  215.         this.listeners.remove(listener);
  216.     }

  218.     public void onEIDSMessage(EIDSMessageEvent event) {
  219.         // iterate over a copy of the listeners list
  220.         Iterator<EIDSListener> iter = new LinkedList<EIDSListener>(listeners)
  221.                 .iterator();
  222.         while (iter.hasNext()) {
  223.             iter.next().onEIDSMessage(event);
  224.         }
  225.     }

  227.     /**
  228.      * @return the serverHost
  229.      */
  230.     public String getServerHost() {
  231.         return serverHost;
  232.     }

  234.     /**
  235.      * @param serverHost
  236.      *            the serverHost to set
  237.      */
  238.     public void setServerHost(String serverHost) {
  239.         this.serverHost = serverHost;
  240.     }

  242.     /**
  243.      * @return the serverPort
  244.      */
  245.     public Integer getServerPort() {
  246.         return serverPort;
  247.     }

  249.     /**
  250.      * @param serverPort
  251.      *            the serverPort to set
  252.      */
  253.     public void setServerPort(Integer serverPort) {
  254.         this.serverPort = serverPort;
  255.     }

  257.     /**
  258.      * @return the alternateServersList
  259.      */
  260.     public String getAlternateServersList() {
  261.         return alternateServersList;
  262.     }

  264.     /**
  265.      * @param alternateServersList
  266.      *            the alternateServersList to set
  267.      */
  268.     public void setAlternateServersList(String alternateServersList) {
  269.         this.alternateServersList = alternateServersList;
  270.     }

  272.     /**
  273.      * @return the maxServerEventAgeDays
  274.      */
  275.     public Double getMaxServerEventAgeDays() {
  276.         return maxServerEventAgeDays;
  277.     }

  279.     /**
  280.      * @param maxServerEventAgeDays
  281.      *            the maxServerEventAgeDays to set
  282.      */
  283.     public void setMaxServerEventAgeDays(Double maxServerEventAgeDays) {
  284.         this.maxServerEventAgeDays = maxServerEventAgeDays;
  285.     }

  287.     /**
  288.      * @return the trackingFileName
  289.      */
  290.     public String getTrackingFileName() {
  291.         return trackingFileName;
  292.     }

  294.     /**
  295.      * @param trackingFileName
  296.      *            the trackingFileName to set
  297.      */
  298.     public void setTrackingFileName(String trackingFileName) {
  299.         this.trackingFileName = trackingFileName;
  300.     }

  302.     /**
  303.      * @return clientRestartInterval
  304.      */
  305.     public Long getClientRestartInterval() {
  306.         return clientRestartInterval;
  307.     }

  309.     /**
  310.      * @param clientRestartInterval
  311.      *            the clientRestartInterval to set
  312.      */
  313.     public void setClientRestartInterval(Long clientRestartInterval) {
  314.         this.clientRestartInterval = clientRestartInterval;
  315.     }

  317.     /** @param debug to set */
  318.     public void setDebug(boolean debug) {
  319.         this.debug = debug;
  320.     }

  322.     /** @return debug boolean */
  323.     public boolean isDebug() {
  324.         return debug;
  325.     }

  327.     /**
  328.      * @return result of reinitialzing the client connection
  329.      */
  330.     public boolean reinitConnection() {
  331.         if (client != null) {
  332.             return client.getConnManagerObj().reinitConnection();
  333.         }
  334.         return false;
  335.     }

  337.     /**
  338.      * A method to test the EIDSClient.
  339.      *
  340.      * @param args arguments
  341.      * @throws Exception if error occurs
  342.      */
  343.     public static void main(final String[] args) throws Exception {
  344.         EIDSListener listener = new EIDSListener() {
  345.             public void onEIDSMessage(EIDSMessageEvent event) {
  346.                 System.err.println(event.getServerHost() + " "
  347.                         + event.getServerSequence());
  348.                 System.err.println(event.getMessage());
  349.             }
  350.         };

  352.         String host = "eids1.cr.usgs.gov";
  353.         int port = 39977;
  354.         boolean debug = false;

  356.         for (String arg : args) {
  357.             if (arg.startsWith("--host=")) {
  358.                 host = arg.replace("--host=", "");
  359.             } else if (arg.startsWith("--port=")) {
  360.                 port = Integer.parseInt(arg.replace("--port=", ""));
  361.             } else if (arg.equals("--debug")) {
  362.                 debug = true;
  363.             }
  364.         }

  366.         EIDSClient client = new EIDSClient(host, port);
  367.         client.setClientRestartInterval(10000L);
  368.         client.setDebug(debug);
  369.         client.addListener(listener);
  370.         client.startup();
  371.     }

  373. }
Created with JaCoCo 0.8.8.202204050719