ProductTracker.java

  1. /*
  2.  * ProductTracker
  3.  */
  4. package gov.usgs.earthquake.distribution;

  6. import gov.usgs.earthquake.product.ProductId;
  7. import gov.usgs.util.Config;
  8. import gov.usgs.util.StreamUtils;
  9. import gov.usgs.util.XmlUtils;

  11. import java.io.InputStream;
  12. import java.io.OutputStream;
  13. import java.net.URL;
  14. import java.net.URLConnection;
  15. import java.net.URLEncoder;
  16. import java.nio.charset.StandardCharsets;
  17. import java.util.Date;
  18. import java.util.HashMap;
  19. import java.util.Iterator;
  20. import java.util.List;
  21. import java.util.Map;

  23. import java.util.logging.Level;
  24. import java.util.logging.Logger;

  26. /**
  27.  * Send updates and search sent updates about distribution status.
  28.  *
  29.  * ProductDistribution clients to send status updates about received
  30.  * notifications, and processed products.
  31.  *
  32.  * <strong>Search Example</strong>
  33.  *
  34.  * <pre>
  35.  * ProductTracker tracker = new ProductTracker(new URL(
  36.  *      &quot;http://ehppdl1.cr.usgs.gov/tracker/&quot;));
  37.  * String source = &quot;us&quot;;
  38.  * String type = &quot;losspager&quot;;
  39.  * String code = &quot;us2010abcd&quot;;
  40.  * Date updateTime = null;
  41.  * String className = null;
  42.  * List&lt;ProductTrackerUpdate&gt; updates = tracker.getUpdates(source, type, code,
  43.  *      updateTime, className);
  44.  * </pre>
  45.  *
  46.  * <strong>Update Example</strong>
  47.  *
  48.  * <pre>
  49.  * Product product = ...;
  50.  * ProductTracker tracker = new ProductTracker(product.getTrackerURL()).;
  51.  * ProductTrackerUpdate update = new ProductTrackerUpdate(product.getTrackerURL(),
  52.  *      product.getId(),
  53.  *      "my component name",
  54.  *      "my component message");
  55.  * tracker.sendUpdate(update);
  56.  * </pre>
  57.  *
  58.  */
  59. public class ProductTracker {

  61.     /** Logging object. */
  62.     private static final Logger LOGGER = Logger.getLogger(ProductTracker.class
  63.             .getName());

  65.     /** Whether tracker updates are enabled in this vm. */
  66.     private static boolean TRACKER_ENABLED = false;

  68.     /**
  69.      * Set whether sending tracker updates is enabled from this host.
  70.      *
  71.      * @param enabled
  72.      *            true to send tracker updates, false to disable.
  73.      */
  74.     public static void setTrackerEnabled(final boolean enabled) {
  75.         TRACKER_ENABLED = enabled;
  76.     }

  78.     /** Location of tracker. */
  79.     private URL trackerURL;

  81.     /**
  82.      * Create a new ProductTracker object.
  83.      * @param trackerURL location of tracker
  84.      */
  85.     public ProductTracker(final URL trackerURL) {
  86.         this.trackerURL = trackerURL;
  87.     }

  89.     /**
  90.      * @return the trackerURL
  91.      */
  92.     public URL getTrackerURL() {
  93.         return trackerURL;
  94.     }

  96.     /**
  97.      * @param trackerURL
  98.      *            the trackerURL to set
  99.      */
  100.     public void setTrackerURL(URL trackerURL) {
  101.         this.trackerURL = trackerURL;
  102.     }

  104.     /**
  105.      * Send an update to this ProductTracker.
  106.      *
  107.      * @param update
  108.      *            the update to send to the tracker.
  109.      * @return the update object processed by the tracker, including sequence
  110.      *         number, or null if unable to send.
  111.      * @throws Exception if error occurs
  112.      */
  113.     public ProductTrackerUpdate sendUpdate(final ProductTrackerUpdate update)
  114.             throws Exception {

  116.         HeartbeatListener.sendHeartbeatMessage(update.getClassName(), // component
  117.                 update.getMessage(), // key
  118.                 update.getId().toString() // value
  119.                 );
  120.         String response = sendUpdateXML(update);
  121.         try {
  122.             List<ProductTrackerUpdate> updates = parseTrackerResponse(
  123.                     update.getTrackerURL(),
  124.                     StreamUtils.getInputStream(response));
  125.             // should receive one update (the one that was sent)
  126.             if (updates.size() == 1) {
  127.                 return updates.get(0);
  128.             }
  129.         } catch (Exception e) {
  130.             // ignore
  131.         }
  132.         return null;
  133.     }

  135.     /**
  136.      * Send an update to this ProductTracker.
  137.      *
  138.      * @param update
  139.      *            the update to send to the tracker.
  140.      * @return the raw XML returned by the tracker, or null if unable to send.
  141.      * @throws Exception if error occurs
  142.      */
  143.     public String sendUpdateXML(final ProductTrackerUpdate update)
  144.             throws Exception {

  146.         // make sure this update hasn't already been sent
  147.         Long sequenceNumber = update.getSequenceNumber();
  148.         if (sequenceNumber != null && sequenceNumber > 0) {
  149.             throw new IllegalArgumentException(
  150.                     "ProductTrackerUpdate already has a sequence number.");
  151.         }

  153.         ProductId id = update.getId();

  155.         // log the update no matter what
  156.         LOGGER.fine(new StringBuffer().append(update.getMessage())
  157.                 .append(" source=").append(id.getSource()).append(", type=")
  158.                 .append(id.getType()).append(", code=").append(id.getCode())
  159.                 .append(", updateTime=").append(id.getUpdateTime().toString())
  160.                 .toString());

  162.         if (!TRACKER_ENABLED) {
  163.             LOGGER.finest("Tracker updates disabled, not sent");
  164.             // didn't send update
  165.             return null;
  166.         }

  168.         // build update request
  169.         Map<String, String> request = new HashMap<String, String>();
  170.         request.put("action", "update");
  171.         request.put("source", id.getSource());
  172.         request.put("type", id.getType());
  173.         request.put("code", id.getCode());
  174.         request.put("updateTime", Long.toString(id.getUpdateTime().getTime()));
  175.         request.put("className", update.getClassName());
  176.         request.put("message", update.getMessage());

  178.         try {
  179.             String response = post(update.getTrackerURL(), request);
  180.             return response;
  181.         } catch (Exception e) {
  182.             LOGGER.log(Level.INFO, "Unable to post to tracker", e);
  183.         }
  184.         return null;
  185.     }

  187.     /**
  188.      * Same as getUpdates with 0 for startid
  189.      * @param source
  190.      *            product source.
  191.      * @param type
  192.      *            product type.
  193.      * @param code
  194.      *            product code.
  195.      * @param updateTime
  196.      *            product update time.
  197.      * @param className
  198.      *            module name.
  199.      * @return updates matching the provided fields.
  200.      * @throws Exception if error occurs
  201.      */
  202.     public List<ProductTrackerUpdate> getUpdates(final String source,
  203.             final String type, final String code, final Date updateTime,
  204.             final String className) throws Exception {
  205.         return getUpdates(source, type, code, updateTime, className, 0L);
  206.     }

  208.     /**
  209.      * Search for updates on this tracker.
  210.      *
  211.      * At least one field must be not null, or this method will return no
  212.      * updates.
  213.      *
  214.      * @param source
  215.      *            product source.
  216.      * @param type
  217.      *            product type.
  218.      * @param code
  219.      *            product code.
  220.      * @param updateTime
  221.      *            product update time.
  222.      * @param className
  223.      *            module name.
  224.      * @param startid
  225.      *            starting ID
  226.      * @return updates matching the provided fields.
  227.      * @throws Exception if error occurs
  228.      */
  229.     public List<ProductTrackerUpdate> getUpdates(final String source,
  230.             final String type, final String code, final Date updateTime,
  231.             final String className, final Long startid) throws Exception {
  232.         String response = getUpdateXML(source, type, code, updateTime,
  233.                 className, startid);
  234.         List<ProductTrackerUpdate> updates = parseTrackerResponse(trackerURL,
  235.                 StreamUtils.getInputStream(response));
  236.         return updates;
  237.     }

  239.     /**
  240.      * Search for updates on this tracker, returning raw xml.
  241.      *
  242.      * @param source
  243.      *            product source.
  244.      * @param type
  245.      *            product type.
  246.      * @param code
  247.      *            product code.
  248.      * @param updateTime
  249.      *            product update time.
  250.      * @param className
  251.      *            module name.
  252.      * @param startid
  253.      *            start id
  254.      * @return the raw xml response from the tracker.
  255.      * @throws Exception if error occurs
  256.      */
  257.     public String getUpdateXML(final String source, final String type,
  258.             final String code, final Date updateTime, final String className,
  259.             final Long startid) throws Exception {

  261.         Map<String, String> request = new HashMap<String, String>();
  262.         request.put("action", "search");

  264.         if (source != null) {
  265.             request.put("source", source);
  266.         }
  267.         if (type != null) {
  268.             request.put("type", type);
  269.         }
  270.         if (code != null) {
  271.             request.put("code", code);
  272.         }
  273.         if (updateTime != null) {
  274.             request.put("updateTime", Long.toString(updateTime.getTime()));
  275.         }

  277.         if (className != null) {
  278.             request.put("className", className);
  279.         }

  281.         if (startid != null) {
  282.             request.put("startid", Long.toString(startid));
  283.         }

  285.         String response = post(trackerURL, request);
  286.         return response;
  287.     }

  289.     /**
  290.      * Send a custom tracker update message.
  291.      *
  292.      * @param className
  293.      *            the module that is sending the message.
  294.      * @param id
  295.      *            the product the message is about.
  296.      * @param message
  297.      *            the message about the product.
  298.      * @return the sent update.
  299.      * @throws Exception if error occurs
  300.      */
  301.     public ProductTrackerUpdate sendUpdate(final String className,
  302.             final ProductId id, final String message) throws Exception {
  303.         ProductTrackerUpdate update = new ProductTrackerUpdate(trackerURL, id,
  304.                 className, message);
  305.         return sendUpdate(update);
  306.     }

  308.     /**
  309.      * Send a productCreated update.
  310.      *
  311.      * @param className
  312.      *            the module that created the product.
  313.      * @param id
  314.      *            the product that was created.
  315.      * @return the sent update.
  316.      * @throws Exception if error occurs
  317.      */
  318.     public ProductTrackerUpdate productCreated(final String className,
  319.             final ProductId id) throws Exception {
  320.         ProductTrackerUpdate createdUpdate = new ProductTrackerUpdate(
  321.                 trackerURL, id, className, ProductTrackerUpdate.PRODUCT_CREATED);
  322.         return sendUpdate(createdUpdate);
  323.     }

  325.     /**
  326.      * Send a productIndexed update.
  327.      *
  328.      * @param className
  329.      *            the module that indexed the product.
  330.      * @param id
  331.      *            the product that was indexed.
  332.      * @return the sent update.
  333.      * @throws Exception if error occurs
  334.      */
  335.     public ProductTrackerUpdate productIndexed(final String className,
  336.             final ProductId id) throws Exception {
  337.         ProductTrackerUpdate indexedUpdate = new ProductTrackerUpdate(
  338.                 trackerURL, id, className, ProductTrackerUpdate.PRODUCT_INDEXED);
  339.         return sendUpdate(indexedUpdate);
  340.     }

  342.     /**
  343.      * Send a notificationSent update.
  344.      *
  345.      * @param className
  346.      *            the module that sent the notification.
  347.      * @param notification
  348.      *            the notification that was sent.
  349.      * @return the sent update.
  350.      * @throws Exception if error occurs
  351.      */
  352.     public ProductTrackerUpdate notificationSent(final String className,
  353.             final Notification notification) throws Exception {
  354.         ProductTrackerUpdate notifiedUpdate = new ProductTrackerUpdate(
  355.                 trackerURL, notification.getProductId(), className,
  356.                 ProductTrackerUpdate.NOTIFICATION_SENT);
  357.         return sendUpdate(notifiedUpdate);
  358.     }

  360.     /**
  361.      * Send a notificationReceived update.
  362.      *
  363.      * @param className
  364.      *            the module that received the notification.
  365.      * @param notification
  366.      *            the notification that was received.
  367.      * @return the sent update.
  368.      * @throws Exception if error occurs
  369.      */
  370.     public ProductTrackerUpdate notificationReceived(final String className,
  371.             final Notification notification) throws Exception {
  372.         ProductTrackerUpdate notifiedUpdate = new ProductTrackerUpdate(
  373.                 trackerURL, notification.getProductId(), className,
  374.                 ProductTrackerUpdate.NOTIFICATION_RECEIVED);
  375.         return sendUpdate(notifiedUpdate);
  376.     }

  378.     /**
  379.      * Send a productDownloaded update.
  380.      *
  381.      * @param className
  382.      *            the module that downloaded the product.
  383.      * @param id
  384.      *            the product that was downloaded.
  385.      * @return the sent update.
  386.      * @throws Exception if error occurs
  387.      */
  388.     public ProductTrackerUpdate productDownloaded(final String className,
  389.             final ProductId id) throws Exception {
  390.         ProductTrackerUpdate downloadedUpdate = new ProductTrackerUpdate(
  391.                 trackerURL, id, className,
  392.                 ProductTrackerUpdate.PRODUCT_DOWNLOADED);
  393.         return sendUpdate(downloadedUpdate);
  394.     }

  396.     /**
  397.      * Send a productReceived update.
  398.      *
  399.      * @param className
  400.      *            the module that received the product.
  401.      * @param id
  402.      *            the product that was received.
  403.      * @return the sent update.
  404.      * @throws Exception if error occurs
  405.      */
  406.     public ProductTrackerUpdate productReceived(final String className,
  407.             final ProductId id) throws Exception {
  408.         ProductTrackerUpdate receivedUpdate = new ProductTrackerUpdate(
  409.                 trackerURL, id, className,
  410.                 ProductTrackerUpdate.PRODUCT_RECEIVED);
  411.         return sendUpdate(receivedUpdate);
  412.     }

  414.     /**
  415.      * Send an exception update.
  416.      *
  417.      * @param className
  418.      *            the module that encountered an exception.
  419.      * @param id
  420.      *            the product that was being processed.
  421.      * @param e
  422.      *            the exception that was caught.
  423.      * @return the sent update.
  424.      * @throws Exception if error occurs
  425.      */
  426.     public ProductTrackerUpdate exception(final String className,
  427.             final ProductId id, final Exception e) throws Exception {
  428.         ProductTrackerUpdate exceptionUpdate = new ProductTrackerUpdate(
  429.                 trackerURL, id, className,
  430.                 ProductTrackerUpdate.PRODUCT_EXCEPTION + ": " + e.getMessage());
  431.         return sendUpdate(exceptionUpdate);
  432.     }

  434.     /**
  435.      * Encode data for a HTTP Post.
  436.      *
  437.      * @param data
  438.      *            a map containing name value pairs for encoding.
  439.      * @return a string of encoded data.
  440.      * @throws Exception if error occurs
  441.      */
  442.     public static String encodeURLData(final Map<String, String> data)
  443.             throws Exception {
  444.         StringBuffer buf = new StringBuffer();
  445.         Iterator<String> iter = data.keySet().iterator();
  446.         while (iter.hasNext()) {
  447.             String key = iter.next();
  448.             buf.append(URLEncoder.encode(key, StandardCharsets.UTF_8.toString()))
  449.                     .append("=")
  450.                     .append(URLEncoder.encode(data.get(key), StandardCharsets.UTF_8.toString()));
  451.             if (iter.hasNext()) {
  452.                 buf.append("&");
  453.             }
  454.         }
  455.         return buf.toString();
  456.     }

  458.     /**
  459.      * Execute a HTTP Post.
  460.      *
  461.      * @param url
  462.      *            the target url.
  463.      * @param data
  464.      *            the data to send.
  465.      * @return the response text.
  466.      * @throws Exception if error occurs
  467.      */
  468.     public static String post(final URL url, final Map<String, String> data)
  469.             throws Exception {
  470.         InputStream in = null;
  471.         OutputStream out = null;
  472.         String response = null;

  474.         try {
  475.             URLConnection connection = url.openConnection();
  476.             if (data != null) {
  477.                 String encodedData = encodeURLData(data);
  478.                 connection.setDoOutput(true);
  479.                 out = connection.getOutputStream();
  480.                 StreamUtils.transferStream(encodedData, out);
  481.             }

  483.             in = connection.getInputStream();
  484.             response = new String(StreamUtils.readStream(in));
  485.         } finally {
  486.             StreamUtils.closeStream(out);
  487.             StreamUtils.closeStream(in);
  488.         }

  490.         return response;
  491.     }

  493.     /**
  494.      * Parse xml received from a ProductTracker using a ProductTrackerParser.
  495.      *
  496.      * @param trackerURL
  497.      *            the trackerURL being parsed (so updates are flagged as from
  498.      *            this tracker).
  499.      * @param updateStream
  500.      *            the XML response stream from a product tracker.
  501.      * @return a list of parsed updates.
  502.      */
  503.     public List<ProductTrackerUpdate> parseTrackerResponse(
  504.             final URL trackerURL, final InputStream updateStream) {
  505.         ProductTrackerParser parser = new ProductTrackerParser(trackerURL);
  506.         parser.parse(updateStream);
  507.         return parser.getUpdates();
  508.     }

  510.     /** Search a product tracker. */
  511.     public static final String ACTION_SEARCH = "--search";
  512.     /** Send an update to a product tracker. */
  513.     public static final String ACTION_UPDATE = "--update";
  514.     /** Used when searching or sending an update to a product tracker. */
  515.     public static final String ARGUMENT_CLASSNAME = "--class=";
  516.     /** Used when searching or sending an update to a product tracker. */
  517.     public static final String ARGUMENT_PRODUCT_ID = "--productid=";
  518.     /** Used when searching. */
  519.     public static final String ARGUMENT_START_ID = "--startid=";

  521.     /**
  522.      * Command Line Interface to ProductTracker.
  523.      *
  524.      * @param args CLI arguments
  525.      * @throws Exception if error occurs
  526.      */
  527.     public static void main(final String[] args) throws Exception {
  528.         // whether we are sending an update (true)
  529.         boolean isUpdate = false;
  530.         // whether we are searching (true)
  531.         boolean isSearch = false;
  532.         // The update message being sent to the tracker (updates only)
  533.         String updateMessage = null;
  534.         // The tracker to communicate with
  535.         URL trackerURL = null;
  536.         // The module that sent an update
  537.         String className = null;
  538.         // The product id, an alternate to source+type+code+updateTime
  539.         ProductId id = null;
  540.         // The product source
  541.         String source = null;
  542.         // The product type
  543.         String type = null;
  544.         // The product code
  545.         String code = null;
  546.         // The product update time
  547.         Date updateTime = null;
  548.         // The starting sequence number (searches only)
  549.         Long startid = 0L;

  551.         // use the default tracker url unless overridden by arguments
  552.         String defaultTrackerURL = Config.getConfig().getProperty(
  553.                 CLIProductBuilder.TRACKER_URL_CONFIG_PROPERTY);
  554.         if (defaultTrackerURL != null) {
  555.             trackerURL = new URL(defaultTrackerURL);
  556.         }

  558.         // parse the arguments
  559.         for (String arg : args) {
  560.             if (arg.equals(ACTION_UPDATE)) {
  561.                 isUpdate = true;
  562.             } else if (arg.equals(ACTION_SEARCH)) {
  563.                 isSearch = true;
  564.             } else if (arg.startsWith(ARGUMENT_CLASSNAME)) {
  565.                 className = arg.replace(ARGUMENT_CLASSNAME, "");
  566.             } else if (arg.startsWith(ARGUMENT_PRODUCT_ID)) {
  567.                 id = ProductId.parse(arg.replace(ARGUMENT_PRODUCT_ID, ""));
  568.                 source = id.getSource();
  569.                 type = id.getType();
  570.                 code = id.getCode();
  571.                 updateTime = id.getUpdateTime();
  572.             } else if (arg.startsWith(CLIProductBuilder.TRACKER_URL_ARGUMENT)) {
  573.                 trackerURL = new URL(arg.replace(
  574.                         CLIProductBuilder.TRACKER_URL_ARGUMENT, ""));
  575.             } else if (arg.startsWith(CLIProductBuilder.SOURCE_ARGUMENT)) {
  576.                 source = arg.replace(CLIProductBuilder.SOURCE_ARGUMENT, "");
  577.             } else if (arg.startsWith(CLIProductBuilder.TYPE_ARGUMENT)) {
  578.                 type = arg.replace(CLIProductBuilder.TYPE_ARGUMENT, "");
  579.             } else if (arg.startsWith(CLIProductBuilder.CODE_ARGUMENT)) {
  580.                 code = arg.replace(CLIProductBuilder.CODE_ARGUMENT, "");
  581.             } else if (arg.startsWith(CLIProductBuilder.UPDATE_TIME_ARGUMENT)) {
  582.                 updateTime = XmlUtils.getDate(arg.replace(
  583.                         CLIProductBuilder.UPDATE_TIME_ARGUMENT, ""));
  584.             } else if (arg.startsWith(ARGUMENT_START_ID)) {
  585.                 startid = Long.valueOf(arg.replace(ARGUMENT_START_ID, ""));
  586.             }
  587.         }

  589.         // run the search or update
  590.         ProductTracker tracker = new ProductTracker(trackerURL);
  591.         if (isUpdate && isSearch) {
  592.             LOGGER.severe("Both " + ACTION_UPDATE + " and " + ACTION_SEARCH
  593.                     + " present, only one allowed");
  594.             System.exit(1);
  595.         } else if (!isUpdate && !isSearch) {
  596.             LOGGER.severe("Neither " + ACTION_UPDATE + " nor " + ACTION_SEARCH
  597.                     + " present, one is required");
  598.             System.exit(1);
  599.         } else if (isUpdate) {
  600.             LOGGER.info("Reading update message from STDIN...");
  601.             updateMessage = new String(StreamUtils.readStream(System.in));
  602.             if (id == null) {
  603.                 id = new ProductId(source, type, code, updateTime);
  604.             }
  605.             System.out.println(tracker.sendUpdateXML(new ProductTrackerUpdate(
  606.                     trackerURL, id, className, updateMessage)));
  607.             // LOGGER.info("Update id=" + update.getSequenceNumber());
  608.         } else if (isSearch) {
  609.             // default to search action

  611.             /*
  612.              * LOGGER.info("Searching for source=" + source + ", type=" + type +
  613.              * ", code=" + code + ", updateTime=" + updateTime + ", className="
  614.              * + className + ", startid=" + startid);
  615.              */
  616.             System.out.println(tracker.getUpdateXML(source, type, code,
  617.                     updateTime, className, startid));
  618.         }
  619.     }

  621.     /** Usage for ProductTracker
  622.      * @return CLI usage
  623.      */
  624.     public static String getUsage() {
  625.         StringBuffer buf = new StringBuffer();

  627.         buf.append("[--search]               search a tracker (default)\n");
  628.         buf.append("                         when searching, include at least one parameter\n");
  629.         buf.append("[--update]               send an update to a tracker\n");
  630.         buf.append("                         when updating, productid and class are required\n");
  631.         buf.append("                         the update message is read from STDIN\n");
  632.         buf.append("\n");

  634.         buf.append("--trackerURL=URL         which tracker to search or update\n");
  635.         buf.append("[--productid=URN]        the product to search or update\n");
  636.         buf.append("[--source=SOURCE]        a product source to search\n");
  637.         buf.append("[--type=TYPE]            a product type to search\n");
  638.         buf.append("[--code=CODE]            a product code to search\n");
  639.         buf.append("[--updateTime=TIME]      a product update time to search\n");
  640.         buf.append("[--class=MODULE]         a module to search or send an update\n");
  641.         buf.append("[--startid=SEQ]          only return updates with sequence number > SEQ\n");
  642.         buf.append("\n");

  644.         return buf.toString();
  645.     }

  647. }
Created with JaCoCo 0.8.8.202204050719