CLIProductBuilder.java

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

  6. import gov.usgs.earthquake.aws.AwsProductSender;
  7. import gov.usgs.earthquake.product.ByteContent;
  8. import gov.usgs.earthquake.product.FileContent;
  9. import gov.usgs.earthquake.product.InputStreamContent;
  10. import gov.usgs.earthquake.product.Product;
  11. import gov.usgs.earthquake.product.ProductId;
  12. import gov.usgs.util.Config;
  13. import gov.usgs.util.CryptoUtils;
  14. import gov.usgs.util.DefaultConfigurable;
  15. import gov.usgs.util.StreamUtils;
  16. import gov.usgs.util.XmlUtils;
  17. import gov.usgs.util.CryptoUtils.Version;
  18. import gov.usgs.util.StringUtils;

  20. import java.io.File;
  21. import java.math.BigDecimal;
  22. import java.net.URI;
  23. import java.net.URL;

  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;
  29. import java.util.LinkedList;
  30. import java.util.Map;
  31. import java.util.logging.Level;
  32. import java.util.logging.Logger;

  34. /**
  35.  * Command Line Interface Product Builder.
  36.  *
  37.  * This class is used to build and send products. It is typically called by
  38.  * using the --build argument with the standard ProductClient.
  39.  *
  40.  * The CLIProductBuilder implements the Configurable interface and uses the
  41.  * following configuration parameters:
  42.  *
  43.  * <dl>
  44.  * <dt>senders</dt>
  45.  * <dd>(Required). A comma separated list of section names that should be loaded
  46.  * as ProductSender objects. Each sender in this list will be used to send any
  47.  * built products. See each type of ProductSender for more configuration
  48.  * details.</dd>
  49.  * </dl>
  50.  */
  51. public class CLIProductBuilder extends DefaultConfigurable {

  53.     /** Logging object. */
  54.     private static final Logger LOGGER = Logger
  55.             .getLogger(CLIProductBuilder.class.getName());

  57.     /** Exit code used when an invalid combination of arguments is used. */
  58.     public static final int EXIT_INVALID_ARGUMENTS = 1;

  60.     /** Exit code used when unable to build a product. */
  61.     public static final int EXIT_UNABLE_TO_BUILD = 2;

  63.     /** Exit code used when errors occur while sending. */
  64.     public static final int EXIT_UNABLE_TO_SEND = 3;

  66.     /** Exit code when errors occur while sending, but not to all senders. */
  67.     public static final int EXIT_PARTIALLY_SENT = 4;

  69.     /** product id type argument */
  70.     public static final String TYPE_ARGUMENT = "--type=";
  71.     /** product id code argument */
  72.     public static final String CODE_ARGUMENT = "--code=";
  73.     /** product id source argument */
  74.     public static final String SOURCE_ARGUMENT = "--source=";
  75.     /** product id updateTime argument */
  76.     public static final String UPDATE_TIME_ARGUMENT = "--updateTime=";

  78.     /** product status argument */
  79.     public static final String STATUS_ARGUMENT = "--status=";
  80.     /** product delete argument */
  81.     public static final String DELETE_ARGUMENT = "--delete";

  83.     /** tracker url argument */
  84.     public static final String TRACKER_URL_ARGUMENT = "--trackerURL=";

  86.   /** property argument */
  87.     public static final String PROPERTY_ARGUMENT = "--property-";
  88.     /** eventID argument */
  89.     public static final String EVENTID_ARGUMENT = "--eventid=";
  90.     /** eventsource argument */
  91.     public static final String EVENTSOURCE_ARGUMENT = "--eventsource=";
  92.     /** eventsourcecode argument */
  93.     public static final String EVENTSOURCECODE_ARGUMENT = "--eventsourcecode=";
  94.     /** eventCode argument */
  95.     public static final String EVENTCODE_ARGUMENT = "--eventcode=";
  96.     /** eventtime argument */
  97.     public static final String EVENTTIME_ARGUMENT = "--eventtime=";
  98.     /** latitude argument */
  99.     public static final String LATITUDE_ARGUMENT = "--latitude=";
  100.     /** longitude argument */
  101.     public static final String LONGITUDE_ARGUMENT = "--longitude=";
  102.     /** depth argument */
  103.     public static final String DEPTH_ARGUMENT = "--depth=";
  104.     /** magnitude argument */
  105.     public static final String MAGNITUDE_ARGUMENT = "--magnitude=";
  106.     /** version argument */
  107.     public static final String VERSION_ARGUMENT = "--version=";

  109.     /** product link argument */
  110.     public static final String LINK_ARGUMENT = "--link-";

  112.     /** product content argument */
  113.     public static final String CONTENT_ARGUMENT = "--content";
  114.     /** product content type argument */
  115.     public static final String CONTENT_TYPE_ARGUMENT = "--contentType=";
  116.     /** product directory argument */
  117.     public static final String DIRECTORY_ARGUMENT = "--directory=";
  118.     /** product file argument */
  119.     public static final String FILE_ARGUMENT = "--file=";

  121.     /** private key argument */
  122.     public static final String PRIVATE_KEY_ARGUMENT = "--privateKey=";
  123.     /** signature version argument */
  124.     public static final String SIGNATURE_VERSION_ARGUMENT = "--signatureVersion=";

  126.     /** Property name used for configuring a tracker url. */
  127.     public static final String TRACKER_URL_CONFIG_PROPERTY = "trackerURL";

  129.     /** Property name used for configuring the list of senders. */
  130.     public static final String SENDERS_CONFIG_PROPERTY = "senders";

  132.     /** Arguments for configuring servers and connectTimeouts. */
  133.     public static final String SERVERS_ARGUMENT = "--servers=";
  134.     /** connectionTimeout argument */
  135.     public static final String CONNECT_TIMEOUT_ARGUMENT = "--connectTimeout=";
  136.     /** Default connectionTimeout argument. 15s */
  137.     public static final Integer DEFAULT_CONNECT_TIMEOUT = 15000;
  138.     /** binaryFormat argument */
  139.     public static final String BINARY_FORMAT_ARGUMENT = "--binaryFormat";
  140.     /** disableDeflate argument */
  141.     public static final String DISABLE_DEFLATE = "--disableDeflate";
  142.     /** disableParallelSend argument */
  143.     public static final String DISABLE_PARALLEL_SEND = "--disableParallelSend";
  144.     /** parallelSendTimeout argument */
  145.     public static final String PARALLEL_SEND_TIMEOUT_ARGUMENT = "--parallelSendTimeout=";

  147.     /** Tracker URL that is used when not overriden by an argument. */
  148.     private URL defaultTrackerURL;

  150.     /** ProductSenders that send the product after it is built. */
  151.     private List<ProductSender> senders = new LinkedList<ProductSender>();

  153.     /** The command line arguments being parsed. */
  154.     private String[] args;

  156.     private Integer connectTimeout = DEFAULT_CONNECT_TIMEOUT;
  157.     private boolean parallelSend = Boolean.valueOf(ProductBuilder.DEFAULT_PARALLEL_SEND);
  158.     private long parallelSendTimeout = Long.valueOf(ProductBuilder.DEFAULT_PARALLEL_SEND_TIMEOUT);

  160.     /**
  161.      * This class is not intended to be instantiated directly.
  162.      * @param args arguments
  163.      */
  164.     protected CLIProductBuilder(final String[] args) {
  165.         this.args = args;
  166.     }

  168.     /**
  169.      * @return the senders
  170.      */
  171.     public List<ProductSender> getSenders() {
  172.         return senders;
  173.     }

  175.     /**
  176.      * @return the defaultTrackerURL
  177.      */
  178.     public URL getDefaultTrackerURL() {
  179.         return defaultTrackerURL;
  180.     }

  182.     /**
  183.      * @param defaultTrackerURL
  184.      *            the defaultTrackerURL to set
  185.      */
  186.     public void setDefaultTrackerURL(URL defaultTrackerURL) {
  187.         this.defaultTrackerURL = defaultTrackerURL;
  188.     }

  190.     /**
  191.      * Load ProductSenders that will send any built Products.
  192.      *
  193.      * There should be a property "senders" containing a comma delimited list of
  194.      * sender names to be loaded.
  195.      *
  196.      * @param config
  197.      *            the Config to load.
  198.      */
  199.     public void configure(final Config config) throws Exception {
  200.         Iterator<String> iter = StringUtils.split(
  201.                 config.getProperty(SENDERS_CONFIG_PROPERTY), ",").iterator();
  202.         while (iter.hasNext()) {
  203.             String senderName = iter.next();

  205.             LOGGER.config("Loading sender '" + senderName + "'");
  206.             // names reference global configuration objects.

  208.             ProductSender sender = (ProductSender) Config.getConfig()
  209.                     .getObject(senderName);

  211.             if (sender == null) {
  212.                 throw new ConfigurationException("Sender '" + senderName
  213.                         + "' is not properly configured");
  214.             }

  216.             senders.add(sender);
  217.         }

  219.         String trackerURLProperty = config
  220.                 .getProperty(TRACKER_URL_CONFIG_PROPERTY);
  221.         if (trackerURLProperty != null) {
  222.             defaultTrackerURL = new URL(trackerURLProperty);
  223.         }

  225.         parallelSend = Boolean.valueOf(config.getProperty(
  226.                 ProductBuilder.PARALLEL_SEND_PROPERTY,
  227.                 ProductBuilder.DEFAULT_PARALLEL_SEND));
  228.         parallelSendTimeout = Long.valueOf(config.getProperty(
  229.                 ProductBuilder.PARALLEL_SEND_TIMEOUT_PROPERTY,
  230.                 ProductBuilder.DEFAULT_PARALLEL_SEND_TIMEOUT));
  231.         LOGGER.config("[" + getName() + "] parallel send enabled="
  232.                 + parallelSend + ", timeout=" + parallelSendTimeout);
  233.     }

  235.     /**
  236.      * Called when the client is shutting down.
  237.      */
  238.     public void shutdown() throws Exception {
  239.         Iterator<ProductSender> iter = senders.iterator();
  240.         while (iter.hasNext()) {
  241.             try {
  242.                 iter.next().shutdown();
  243.             } catch (Exception e) {
  244.                 LOGGER.log(Level.WARNING, "Exception shutting down sender", e);
  245.             }
  246.         }
  247.     }

  249.     /**
  250.      * Called when the client is done configuring.
  251.      */
  252.     public void startup() throws Exception {
  253.         Iterator<ProductSender> iter = senders.iterator();
  254.         while (iter.hasNext()) {
  255.             iter.next().startup();
  256.         }
  257.     }

  259.     /**
  260.      * Send a product to all configured ProductSenders.
  261.      *
  262.      * @param product
  263.      *            the product to send.
  264.      * @return exceptions that occured while sending. If map is empty, there
  265.      *         were no exceptions.
  266.      */
  267.     public Map<ProductSender, Exception> sendProduct(final Product product) {
  268.         Map<ProductSender, Exception> sendExceptions = new HashMap<ProductSender, Exception>();

  270.         Iterator<ProductSender> iter = senders.iterator();
  271.         while (iter.hasNext()) {
  272.             ProductSender sender = iter.next();
  273.             try {
  274.                 sender.sendProduct(product);
  275.             } catch (Exception e) {
  276.                 sendExceptions.put(sender, e);
  277.             }
  278.         }

  280.         return sendExceptions;
  281.     }

  283.     /**
  284.      * Build a product using command line arguments.
  285.      *
  286.      * @return Product
  287.      * @throws Exception if error occurs
  288.      */
  289.     public Product buildProduct() throws Exception {
  290.         // start product id with null values, and verify they are all set after
  291.         // all arguments are parsed.
  292.         Product product = new Product(new ProductId(null, null, null));
  293.         product.setTrackerURL(defaultTrackerURL);

  295.         // These things are also processed after all arguments are parsed.
  296.         // used with inline content
  297.         boolean hasStdinContent = false;
  298.         String contentType = null;
  299.         // used when signing products
  300.         File privateKey = null;
  301.         Version signatureVersion = Version.SIGNATURE_V1;
  302.         boolean binaryFormat = false;
  303.         boolean enableDeflate = true;

  305.         for (String arg : args) {
  306.             if (arg.startsWith(TYPE_ARGUMENT)) {
  307.                 product.getId().setType(arg.replace(TYPE_ARGUMENT, ""));
  308.             } else if (arg.startsWith(CODE_ARGUMENT)) {
  309.                 product.getId().setCode(arg.replace(CODE_ARGUMENT, ""));
  310.             } else if (arg.startsWith(SOURCE_ARGUMENT)) {
  311.                 product.getId().setSource(arg.replace(SOURCE_ARGUMENT, ""));
  312.             } else if (arg.startsWith(UPDATE_TIME_ARGUMENT)) {
  313.                 product.getId()
  314.                         .setUpdateTime(
  315.                                 XmlUtils.getDate(arg.replace(
  316.                                         UPDATE_TIME_ARGUMENT, "")));
  317.             } else if (arg.startsWith(STATUS_ARGUMENT)) {
  318.                 product.setStatus(arg.replace(STATUS_ARGUMENT, ""));
  319.             } else if (arg.equals(DELETE_ARGUMENT)) {
  320.                 product.setStatus(Product.STATUS_DELETE);
  321.             } else if (arg.startsWith(TRACKER_URL_ARGUMENT)) {
  322.                 product.setTrackerURL(new URL(arg.replace(TRACKER_URL_ARGUMENT,
  323.                         "")));
  324.             } else if (arg.startsWith(PROPERTY_ARGUMENT)) {
  325.                 String[] props = arg.replace(PROPERTY_ARGUMENT, "").split("=",
  326.                         2);
  327.                 try {
  328.                     product.getProperties().put(props[0], props[1]);
  329.                 } catch (IndexOutOfBoundsException ioobe) {
  330.                     throw new IllegalArgumentException(
  331.                             "Invalid property argument, must have value");
  332.                 }
  333.             } else if (arg.startsWith(EVENTID_ARGUMENT)) {
  334.                 String id = arg.replace(EVENTID_ARGUMENT, "").toLowerCase();
  335.                 String eventNetwork = id.substring(0, 2);
  336.                 String eventNetworkId = id.substring(2);
  337.                 product.setEventId(eventNetwork, eventNetworkId);
  338.             } else if (arg.startsWith(EVENTSOURCE_ARGUMENT)) {
  339.                 product.setEventSource(arg.replace(EVENTSOURCE_ARGUMENT, "")
  340.                         .toLowerCase());
  341.             } else if (arg.startsWith(EVENTSOURCECODE_ARGUMENT)) {
  342.                 product.setEventSourceCode(arg.replace(
  343.                         EVENTSOURCECODE_ARGUMENT, "").toLowerCase());
  344.             } else if (arg.startsWith(EVENTCODE_ARGUMENT)) {
  345.                 product.setEventSourceCode(arg.replace(EVENTCODE_ARGUMENT, "")
  346.                         .toLowerCase());
  347.             } else if (arg.startsWith(EVENTTIME_ARGUMENT)) {
  348.                 product.setEventTime(XmlUtils.getDate(arg.replace(
  349.                         EVENTTIME_ARGUMENT, "")));
  350.             } else if (arg.startsWith(MAGNITUDE_ARGUMENT)) {
  351.                 product.setMagnitude(new BigDecimal(arg.replace(
  352.                         MAGNITUDE_ARGUMENT, "")));
  353.             } else if (arg.startsWith(LATITUDE_ARGUMENT)) {
  354.                 product.setLatitude(new BigDecimal(arg.replace(
  355.                         LATITUDE_ARGUMENT, "")));
  356.             } else if (arg.startsWith(LONGITUDE_ARGUMENT)) {
  357.                 product.setLongitude(new BigDecimal(arg.replace(
  358.                         LONGITUDE_ARGUMENT, "")));
  359.             } else if (arg.startsWith(DEPTH_ARGUMENT)) {
  360.                 product.setDepth(new BigDecimal(arg.replace(DEPTH_ARGUMENT, "")));
  361.             } else if (arg.startsWith(VERSION_ARGUMENT)) {
  362.                 product.setVersion(arg.replace(VERSION_ARGUMENT, ""));
  363.             } else if (arg.startsWith(LINK_ARGUMENT)) {
  364.                 String[] props = arg.replace(LINK_ARGUMENT, "").split("=", 2);
  365.                 try {
  366.                     product.addLink(props[0], new URI(props[1]));
  367.                 } catch (IndexOutOfBoundsException ioobe) {
  368.                     throw new IllegalArgumentException(
  369.                             "Invalid link, must have URL as value");
  370.                 }
  371.             } else if (arg.equals(CONTENT_ARGUMENT)) {
  372.                 hasStdinContent = true;
  373.             } else if (arg.startsWith(CONTENT_TYPE_ARGUMENT)) {
  374.                 contentType = arg.replace(CONTENT_TYPE_ARGUMENT, "");
  375.             } else if (arg.startsWith(DIRECTORY_ARGUMENT)) {
  376.                 product.getContents().putAll(
  377.                         FileContent.getDirectoryContents(new File(arg.replace(
  378.                                 DIRECTORY_ARGUMENT, ""))));
  379.             } else if (arg.startsWith(FILE_ARGUMENT)) {
  380.                 File file = new File(arg.replace(FILE_ARGUMENT, ""));
  381.                 product.getContents()
  382.                         .put(file.getName(), new FileContent(file));
  383.             } else if (arg.startsWith(PRIVATE_KEY_ARGUMENT)) {
  384.                 privateKey = new File(arg.replace(PRIVATE_KEY_ARGUMENT, ""));
  385.             } else if (arg.startsWith(SIGNATURE_VERSION_ARGUMENT)) {
  386.                 signatureVersion = Version.fromString(
  387.                         arg.replace(SIGNATURE_VERSION_ARGUMENT, ""));
  388.             } else if (arg.startsWith(SERVERS_ARGUMENT)) {
  389.                 senders.clear();
  390.                 senders.addAll(parseServers(arg.replace(SERVERS_ARGUMENT, ""),
  391.                         connectTimeout, binaryFormat, enableDeflate));
  392.             } else if (arg.startsWith(CONNECT_TIMEOUT_ARGUMENT)) {
  393.                 connectTimeout = Integer.valueOf(arg.replace(
  394.                         CONNECT_TIMEOUT_ARGUMENT, ""));
  395.             } else if (arg.equals(BINARY_FORMAT_ARGUMENT)) {
  396.                 binaryFormat = true;
  397.             } else if (arg.equals(DISABLE_DEFLATE)) {
  398.                 enableDeflate = false;
  399.             } else if (arg.equals(DISABLE_PARALLEL_SEND)) {
  400.                 parallelSend = false;
  401.             } else if (arg.startsWith(PARALLEL_SEND_TIMEOUT_ARGUMENT)) {
  402.                 parallelSendTimeout = Long.valueOf(
  403.                         arg.replace(PARALLEL_SEND_TIMEOUT_ARGUMENT, ""));
  404.             } else {
  405.                 // not a builder argument
  406.             }
  407.         }

  409.         // validate product
  410.         ProductId id = product.getId();
  411.         if (id.getType() == null || id.getSource() == null
  412.                 || id.getCode() == null || id.getUpdateTime() == null) {
  413.             throw new IllegalArgumentException("Incomplete ProductId: source="
  414.                     + id.getSource() + ", type=" + id.getType() + ", code="
  415.                     + id.getCode() + ", updateTime=" + id.getUpdateTime());
  416.         }

  418.         // tracker url is required
  419.         if (product.getTrackerURL() == null) {
  420.             throw new IllegalArgumentException("Tracker URL is required");
  421.         }

  423.         if (hasStdinContent) {
  424.             LOGGER.info("Reading content on standard input");

  426.             ByteContent stdinContent = new ByteContent(new InputStreamContent(
  427.                     System.in));
  428.             if (contentType != null) {
  429.                 stdinContent.setContentType(contentType);
  430.             }
  431.             product.getContents().put("", stdinContent);
  432.         }

  434.         // products that aren't being deleted should have content
  435.         if (product.getContents().size() == 0 && !product.isDeleted()) {
  436.             LOGGER.warning("Product has no content, are you sure this is intended?");
  437.         }

  439.         // mark which version of client was used to create product
  440.         product.getProperties().put(ProductClient.PDL_CLIENT_VERSION_PROPERTY,
  441.                 ProductClient.RELEASE_VERSION);

  443.         if (privateKey != null) {
  444.             LOGGER.fine("Signing product");
  445.             product.sign(
  446.                     CryptoUtils.readOpenSSHPrivateKey(
  447.                             StreamUtils.readStream(StreamUtils.getInputStream(privateKey)),
  448.                             null),
  449.                     signatureVersion);
  450.         }

  452.         return product;
  453.     }

  455.     /**
  456.      * Parse servers for list of product senders
  457.      * @param servers CSV string of servers
  458.      * @param connectTimeout timeout
  459.      * @param binaryFormat if binaryFormat
  460.      * @param enableDeflate if enableDeflate
  461.      * @return List of product senders
  462.      * */
  463.     public static List<ProductSender> parseServers(final String servers,
  464.             final Integer connectTimeout, final boolean binaryFormat,
  465.             final boolean enableDeflate) throws Exception {
  466.         List<ProductSender> senders = new ArrayList<ProductSender>();

  468.         Iterator<String> iter = StringUtils.split(servers, ",").iterator();
  469.         while (iter.hasNext()) {
  470.             String server = iter.next();
  471.             if (server.startsWith("https://")) {
  472.                 AwsProductSender sender = new AwsProductSender(new URL(server));
  473.                 senders.add(sender);
  474.             } else {
  475.                 String[] parts = server.split(":");
  476.                 SocketProductSender sender = new SocketProductSender(parts[0],
  477.                         Integer.parseInt(parts[1]), connectTimeout);
  478.                 sender.setBinaryFormat(binaryFormat);
  479.                 sender.setEnableDeflate(enableDeflate);
  480.                 senders.add(sender);
  481.             }
  482.         }

  484.         return senders;
  485.     }

  487.     /**
  488.      * Entry point into CLIProductBuilder.
  489.      *
  490.      * Called by Main if the --build argument is present.
  491.      *
  492.      * @param args arguments
  493.      * @throws Exception if error occurs
  494.      */
  495.     public static void main(final String[] args) throws Exception {
  496.         CLIProductBuilder builder = new CLIProductBuilder(args);
  497.         builder.configure(Config.getConfig());
  498.         builder.startup();

  500.         Product product = null;
  501.         try {
  502.             product = builder.buildProduct();
  503.         } catch (Exception e) {
  504.             if (e.getMessage() == null) {
  505.                 LOGGER.log(Level.SEVERE, "Error building product", e);
  506.             } else {
  507.                 LOGGER.severe("Invalid arguments: " + e.getMessage());
  508.             }
  509.             System.exit(EXIT_INVALID_ARGUMENTS);
  510.         }

  512.         if (product == null) {
  513.             LOGGER.severe("Unable to build product");
  514.             System.exit(EXIT_UNABLE_TO_BUILD);
  515.         }

  517.         // send tracker update
  518.         new ProductTracker(product.getTrackerURL()).productCreated(
  519.                 SocketProductSender.class.getName(), product.getId());

  521.         // send the product
  522.         Map<ProductSender, Exception> sendExceptions = builder.parallelSend
  523.                 ? ProductBuilder.parallelSendProduct(
  524.                             builder.senders,
  525.                             product,
  526.                             builder.parallelSendTimeout)
  527.                 : builder.sendProduct(product);

  529.         // handle any send exceptions
  530.         if (sendExceptions.size() != 0) {
  531.             Iterator<ProductSender> senders = sendExceptions.keySet()
  532.                     .iterator();
  533.             // log the exceptions
  534.             while (senders.hasNext()) {
  535.                 ProductSender sender = senders.next();
  536.                 if (sender instanceof SocketProductSender) {
  537.                     // put more specific information about socket senders
  538.                     SocketProductSender socketSender = (SocketProductSender) sender;
  539.                     LOGGER.log(
  540.                             Level.WARNING,
  541.                             "Exception sending product to "
  542.                                     + socketSender.getHost() + ":"
  543.                                     + socketSender.getPort(),
  544.                             sendExceptions.get(sender));
  545.                 } else {
  546.                     LOGGER.log(Level.WARNING, "Exception sending product "
  547.                             + sendExceptions.get(sender));
  548.                 }
  549.             }

  551.             if (sendExceptions.size() < builder.getSenders().size()) {
  552.                 LOGGER.warning("Partial failure sending product,"
  553.                         + " at least one sender accepted product."
  554.                         + " Check the tracker for more information.");
  555.                 // still output built product id
  556.                 System.out.println(product.getId().toString());
  557.                 // but exit with partial failure
  558.                 System.exit(EXIT_PARTIALLY_SENT);
  559.             } else {
  560.                 LOGGER.severe("Total failure sending product");
  561.                 System.exit(EXIT_UNABLE_TO_SEND);
  562.             }

  564.         }

  566.         // otherwise output built product id
  567.         System.out.println(product.getId().toString());

  569.         // normal exit
  570.         builder.shutdown();
  571.         System.exit(0);
  572.     }
  573.     /**
  574.      * Function on how to use command
  575.      * @return string
  576.      */
  577.     public static String getUsage() {
  578.         StringBuffer buf = new StringBuffer();

  580.         buf.append("Product identification\n");
  581.         buf.append("--source=SOURCE          product source, e.g. us, nc\n");
  582.         buf.append("--type=TYPE              product type, e.g. shakemap, pager\n");
  583.         buf.append("--code=CODE              product code, e.g. us2009abcd, nc12345678\n");
  584.         buf.append("[--updateTime=TIME]      when the product was updated\n");
  585.         buf.append("                         e.g. 2010-02-11T15:16:17+0000\n");
  586.         buf.append("                         default is now\n");
  587.         buf.append("[--status=STATUS]        product status\n");
  588.         buf.append("                         default is UPDATE\n");
  589.         buf.append("[--delete]               same as --status=DELETE\n");
  590.         buf.append("\n");

  592.         buf.append("Product contents\n");
  593.         buf.append("[--directory=DIR]        read content from a directory, preserves hierarchy\n");
  594.         buf.append("[--file=FILE]            read content from a file, added at top level of product\n");
  595.         buf.append("[--content]              read content from STDIN\n");
  596.         buf.append("[--contentType=MIMETYPE] used with --content to specify STDIN mime type\n");
  597.         buf.append("\n");

  599.         buf.append("Product metadata\n");
  600.         buf.append("[--link-RELATION=URI]    link to another product or resource\n");
  601.         buf.append("[--property-NAME=VALUE]  attributes of this product\n");
  602.         buf.append("[--latitude=LAT]         Latitude of associated event.\n");
  603.         buf.append("                             Decimal degrees\n");
  604.         buf.append("                             Same as --property-latitude=LAT\n");
  605.         buf.append("[--longitude=LNG]        Longitude of associated event.\n");
  606.         buf.append("                             Decimal degrees\n");
  607.         buf.append("                             Same as --property-longitude=LNG\n");
  608.         buf.append("[--eventtime=TIME]       Time of associated event.\n");
  609.         buf.append("                             Example: 2010-02-11T15:16:17+0000\n");
  610.         buf.append("                             Same as --property-eventtime=TIME\n");
  611.         buf.append("[--magnitude=MAG]        Magnitude of associated event.\n");
  612.         buf.append("                             Same as --property-magnitude=MAG\n");
  613.         buf.append("[--depth=DEPTH]          Depth of associated event.\n");
  614.         buf.append("                             Kilometers.\n");
  615.         buf.append("                             Same as --property-depth=DEPTH\n");
  616.         buf.append("[--eventsource=SOURCE]   Network of associated event.\n");
  617.         buf.append("                             Examples: us, nc, ci\n");
  618.         buf.append("                             Same as --property-eventsource=SOURCE\n");
  619.         buf.append("[--eventcode=CODE]       NetworkID of associated event.\n");
  620.         buf.append("                             Examples: 2010abcd, 12345678\n");
  621.         buf.append("                             Same as --property-eventsourcecode=CODE\n");
  622.         buf.append("[--eventid=EVENTID]      Deprecated, use --eventsource and --eventsourcecode.\n");
  623.         buf.append("                             Assumes a 10 character eventid: \n");
  624.         buf.append("                                 assigns first 2 characters as 'eventsource',\n");
  625.         buf.append("                                 rest as 'eventsourcecode'\n");
  626.         buf.append("[--version=VERSION]      Internal product version.\n");
  627.         buf.append("                             Same as --property-version=VERSION\n");
  628.         buf.append("\n");

  630.         buf.append("[--trackerURL=URL]       tracker url\n");
  631.         buf.append("                         Override a configured default trackerURL\n");
  632.         buf.append("[--privateKey=FILE]      OpenSSH DSA private key used to sign products\n");
  633.         buf.append("                         A product signature may or may not be optional\n");
  634.         buf.append("[--signatureVersion=v1]  signature version\n");
  635.         buf.append("                         valid values are 'v1' or 'v2'\n");
  636.         buf.append("\n");

  638.         buf.append("Where product is sent\n");
  639.         buf.append("[--connectTimeout=15000] Connect timeout in milliseconds\n");
  640.         buf.append("                         Only used with --servers argument\n");
  641.         buf.append("                         Must appear before --servers argument.\n");
  642.         buf.append("[--binaryFormat]         Send to hub using binary format.\n");
  643.         buf.append("                         Only used with --servers argument\n");
  644.         buf.append("                         Must appear before --servers argument.\n");
  645.         buf.append("[--disableDeflate]       Send to hub without using deflate compression.\n");
  646.         buf.append("                         Only used with --servers argument\n");
  647.         buf.append("                         Must appear before --servers argument.\n");
  648.         buf.append("[--disableParallelSend]  Send to servers sequentially.\n");
  649.         buf.append("[--parallelSendTimeout=300]\n");
  650.         buf.append("                         timeout for parallel send in seconds.\n");
  651.         buf.append("[--servers=SERVERLIST]   server:port[,server:port]\n");
  652.         buf.append("                         Overrides any configured senders\n");
  653.         buf.append("                         Example: pdldevel.cr.usgs.gov:11235\n");
  654.         buf.append("\n");

  656.         return buf.toString();
  657.     }
  658. }
Created with JaCoCo 0.8.8.202204050719