SearchCLI.java

  1. package gov.usgs.earthquake.indexer;

  3. import java.io.FileOutputStream;
  4. import java.io.OutputStream;
  5. import java.math.BigDecimal;
  6. import java.net.InetAddress;
  7. import java.util.logging.Logger;

  9. import gov.usgs.earthquake.product.ProductId;
  10. import gov.usgs.util.XmlUtils;

  12. /**
  13.  * Command line interface for search socket.
  14.  *
  15.  * This class reads arguments from the command line that represent a
  16.  * ProductIndexQuery. Then it connects to a configured socket, executes the
  17.  * search, and outputs the response xml.
  18.  */
  19. public class SearchCLI {

  21.     private static final Logger LOGGER = Logger.getLogger(SearchCLI.class
  22.             .getName());

  24.     /**
  25.      * Command-line argument definitions
  26.      */
  27.     /** Argument for search method */
  28.     public static String SEARCH_METHOD_ARGUMENT = "--searchMethod=";
  29.     /** Argument for result type */
  30.     public static String RESULT_TYPE_ARGUMENT = "--resultType=";
  31.     /** Argument for event Source */
  32.     public static String EVENT_SOURCE_ARGUMENT = "--eventSource=";
  33.     /** Argument for event Source Code */
  34.     public static String EVENT_SOURCE_CODE_ARGUMENT = "--eventSourceCode=";
  35.     /** Argument for minimum Event Time */
  36.     public static String MIN_EVENT_TIME_ARGUMENT = "--minEventTime=";
  37.     /** Argument for maximum event time */
  38.     public static String MAX_EVENT_TIME_ARGUMENT = "--maxEventTime=";
  39.     /** Argument for minimum event latitude */
  40.     public static String MIN_EVENT_LATITUDE_ARGUMENT = "--minEventLatitude=";
  41.     /** Argument for minimum event longitude */
  42.     public static String MIN_EVENT_LONGITUDE_ARGUMENT = "--minEventLongitude=";
  43.     /** Argument for maximum event latitude */
  44.     public static String MAX_EVENT_LATITUDE_ARGUMENT = "--maxEventLatitude=";
  45.     /** Argument for maximum event longitude */
  46.     public static String MAX_EVENT_LONGITUDE_ARGUMENT = "--maxEventLongitude=";
  47.     /** Argument for minimum event depth */
  48.     public static String MIN_EVENT_DEPTH_ARGUMENT = "--minEventDepth=";
  49.     /** Argument for maximum event depth */
  50.     public static String MAX_EVENT_DEPTH_ARGUMENT = "--maxEventDepth=";
  51.     /** Argument for minimum event magnitude */
  52.     public static String MIN_EVENT_MAGNITUDE_ARGUMENT = "--minEventMagnitude=";
  53.     /** Argument for maximum event magnitude */
  54.     public static String MAX_EVENT_MAGNITUDE_ARGUMENT = "--maxEventMagnitude=";
  55.     /** Argument for product ID */
  56.     public static String PRODUCT_ID_ARGUMENT = "--productId=";
  57.     /** Argument for  minimum product update time */
  58.     public static String MIN_PRODUCT_UPDATE_TIME_ARGUMENT = "--minProductUpdateTime=";
  59.     /** Argument for maximum product update time */
  60.     public static String MAX_PRODUCT_UPDATE_TIME_ARGUMENT = "--maxProductUpdateTime=";
  61.     /** Argument for product source */
  62.     public static String PRODUCT_SOURCE_ARGUMENT = "--productSource=";
  63.     /** Argument for product type */
  64.     public static String PRODUCT_TYPE_ARGUMENT = "--productType=";
  65.     /** Argument for product verion */
  66.     public static String PRODUCT_VERSION_ARGUMENT = "--productVersion=";
  67.     /** Argument for product status */
  68.     public static String PRODUCT_STATUS_ARGUMENT = "--productStatus=";

  70.     /** Argument for search host */
  71.     public static String SEARCH_HOST_ARGUMENT = "--searchHost=";
  72.     /** Argument for search port */
  73.     public static String SEARCH_PORT_ARGUMENT = "--searchPort=";

  75.     /** Argument for file output */
  76.     public static String FILE_OUTPUT_ARGUMENT = "--outputFile=";

  78.     /**
  79.      * Default constructor, for configurable interface.
  80.      */
  81.     public SearchCLI() {
  82.     }

  84.     /**
  85.      * Entry point into search. Called by Main when the --search argument is
  86.      * used.
  87.      *
  88.      * @param args
  89.      *            command line arguments.
  90.      * @throws Exception if error occurs
  91.      */
  92.     public static void main(final String[] args) throws Exception {
  93.         String outputFilePath = null;
  94.         SearchMethod type = null;
  95.         InetAddress host = InetAddress.getByName("localhost");
  96.         int port = Integer.parseInt(SearchServerSocket.DEFAULT_SEARCH_PORT);
  97.         ProductIndexQuery query = new ProductIndexQuery();
  98.         // Alternate result types are currently not supported.
  99.         query.setResultType(ProductIndexQuery.RESULT_TYPE_CURRENT);
  100.         for (String arg : args) {
  101.             if (arg.startsWith(SEARCH_METHOD_ARGUMENT)) {
  102.                 type = SearchMethod.fromXmlMethodName(arg.replace(
  103.                         SEARCH_METHOD_ARGUMENT, ""));
  104.                 if (type == null) {
  105.                     LOGGER.severe("Undefined search method received: '"
  106.                             + arg.replace(SEARCH_METHOD_ARGUMENT, "")
  107.                             + "'. Search could not be processed.");
  108.                     throw new Exception();
  109.                 }
  110.                 /*
  111.                  * Alternate result types are currently not supported. } else if
  112.                  * (arg.startsWith(RESULT_TYPE_ARGUMENT)) { String resultType =
  113.                  * arg.replace(RESULT_TYPE_ARGUMENT, ""); if
  114.                  * (resultType.toLowerCase() == "current")
  115.                  * query.setResultType(ProductIndexQuery.RESULT_TYPE_CURRENT);
  116.                  * else if (resultType.toLowerCase() == "superseded")
  117.                  * query.setResultType
  118.                  * (ProductIndexQuery.RESULT_TYPE_SUPERSEDED); else if
  119.                  * (resultType.toLowerCase() == "all")
  120.                  * query.setResultType(ProductIndexQuery.RESULT_TYPE_ALL);
  121.                  */
  122.             } else if (arg.startsWith(EVENT_SOURCE_ARGUMENT)) {
  123.                 query.setEventSource(arg.replace(EVENT_SOURCE_ARGUMENT, ""));
  124.             } else if (arg.startsWith(EVENT_SOURCE_CODE_ARGUMENT)) {
  125.                 query.setEventSourceCode(arg.replace(
  126.                         EVENT_SOURCE_CODE_ARGUMENT, ""));
  127.             } else if (arg.startsWith(MIN_EVENT_TIME_ARGUMENT)) {
  128.                 query.setMinEventTime(XmlUtils.getDate(arg.replace(
  129.                         MIN_EVENT_TIME_ARGUMENT, "")));
  130.             } else if (arg.startsWith(MAX_EVENT_TIME_ARGUMENT)) {
  131.                 query.setMaxEventTime(XmlUtils.getDate(arg.replace(
  132.                         MAX_EVENT_TIME_ARGUMENT, "")));
  133.             } else if (arg.startsWith(MIN_EVENT_LATITUDE_ARGUMENT)) {
  134.                 query.setMinEventLatitude(new BigDecimal(arg.replace(
  135.                         MIN_EVENT_LATITUDE_ARGUMENT, "")));
  136.             } else if (arg.startsWith(MIN_EVENT_LONGITUDE_ARGUMENT)) {
  137.                 query.setMinEventLongitude(new BigDecimal(arg.replace(
  138.                         MIN_EVENT_LONGITUDE_ARGUMENT, "")));
  139.             } else if (arg.startsWith(MIN_EVENT_DEPTH_ARGUMENT)) {
  140.                 query.setMinEventDepth(new BigDecimal(arg.replace(
  141.                         MIN_EVENT_DEPTH_ARGUMENT, "")));
  142.             } else if (arg.startsWith(MAX_EVENT_LATITUDE_ARGUMENT)) {
  143.                 query.setMaxEventLatitude(new BigDecimal(arg.replace(
  144.                         MAX_EVENT_LATITUDE_ARGUMENT, "")));
  145.             } else if (arg.startsWith(MAX_EVENT_LONGITUDE_ARGUMENT)) {
  146.                 query.setMaxEventLongitude(new BigDecimal(arg.replace(
  147.                         MAX_EVENT_LONGITUDE_ARGUMENT, "")));
  148.             } else if (arg.startsWith(MAX_EVENT_DEPTH_ARGUMENT)) {
  149.                 query.setMaxEventDepth(new BigDecimal(arg.replace(
  150.                         MAX_EVENT_DEPTH_ARGUMENT, "")));
  151.             } else if (arg.startsWith(MIN_EVENT_MAGNITUDE_ARGUMENT)) {
  152.                 query.setMinEventMagnitude(new BigDecimal(arg.replace(
  153.                         MIN_EVENT_MAGNITUDE_ARGUMENT, "")));
  154.             } else if (arg.startsWith(MAX_EVENT_MAGNITUDE_ARGUMENT)) {
  155.                 query.setMaxEventMagnitude(new BigDecimal(arg.replace(
  156.                         MAX_EVENT_MAGNITUDE_ARGUMENT, "")));
  157.             } else if (arg.startsWith(PRODUCT_ID_ARGUMENT)) {
  158.                 query.getProductIds().add(
  159.                         ProductId.parse(arg.replace(PRODUCT_ID_ARGUMENT, "")));
  160.             } else if (arg.startsWith(PRODUCT_SOURCE_ARGUMENT)) {
  161.                 query.setProductSource(arg.replace(PRODUCT_SOURCE_ARGUMENT, ""));
  162.             } else if (arg.startsWith(PRODUCT_STATUS_ARGUMENT)) {
  163.                 query.setProductStatus(arg.replace(PRODUCT_STATUS_ARGUMENT, ""));
  164.             } else if (arg.startsWith(PRODUCT_TYPE_ARGUMENT)) {
  165.                 query.setProductType(arg.replace(PRODUCT_TYPE_ARGUMENT, ""));
  166.             } else if (arg.startsWith(PRODUCT_VERSION_ARGUMENT)) {
  167.                 query.setProductVersion(arg.replace(PRODUCT_VERSION_ARGUMENT,
  168.                         ""));
  169.             } else if (arg.startsWith(SEARCH_HOST_ARGUMENT)) {
  170.                 host = InetAddress.getByName(arg.replace(SEARCH_HOST_ARGUMENT,
  171.                         ""));
  172.             } else if (arg.startsWith(SEARCH_PORT_ARGUMENT)) {
  173.                 port = Integer.parseInt(arg.replace(SEARCH_PORT_ARGUMENT, ""));
  174.             } else if (arg.startsWith(FILE_OUTPUT_ARGUMENT)) {
  175.                 outputFilePath = arg.replace(FILE_OUTPUT_ARGUMENT, "");
  176.             }
  177.         }
  178.         SearchRequest request = new SearchRequest();
  179.         if (type == null) {
  180.             LOGGER.severe("No search type was provided.");
  181.         }
  182.         OutputStream stream;
  183.         if (outputFilePath != null) {
  184.             stream = new FileOutputStream(FILE_OUTPUT_ARGUMENT);
  185.         } else {
  186.             stream = System.out;
  187.         }
  188.         request.addQuery(SearchQuery.getSearchQuery(type, query));

  190.         SearchSocket socket = new SearchSocket(host, port);
  191.         socket.search(request, stream);
  192.     }

  194.     /**
  195.      * CLI Usage
  196.      * @return string of usage
  197.      */
  198.     public static String getUsage() {
  199.         StringBuffer buf = new StringBuffer();

  201.         buf.append("Product Index Search Interface:\n");
  202.         buf.append("--search : Command is using the search interface\n");
  203.         buf.append(SEARCH_METHOD_ARGUMENT + "METHOD : Any one of ");
  204.         SearchMethod[] methods = SearchMethod.values();
  205.         for (int i = 0; i < methods.length; i++) {
  206.             buf.append("'" + methods[i].getXmlMethodName() + "'");
  207.             if (i < methods.length - 1) {
  208.                 buf.append(", ");
  209.             } else {
  210.                 buf.append("\n");
  211.             }
  212.         }
  213.         buf.append("[" + EVENT_SOURCE_ARGUMENT
  214.                 + "SOURCE] : Filter results by event source network.\n");
  215.         buf.append("[" + EVENT_SOURCE_CODE_ARGUMENT
  216.                 + "CODE] : Filter results by event source network code.\n");
  217.         buf.append("["
  218.                 + MIN_EVENT_TIME_ARGUMENT
  219.                 + "XML_FORMATTED_TIME] : Filter results by start of time window.\n");
  220.         buf.append("["
  221.                 + MAX_EVENT_TIME_ARGUMENT
  222.                 + "XML_FORMATTED_TIME] : Filter results by end of time window.\n");
  223.         buf.append("[" + MIN_EVENT_LATITUDE_ARGUMENT
  224.                 + "LATITUDE] : Filter results by Southern boundary.\n");
  225.         buf.append("[" + MAX_EVENT_LATITUDE_ARGUMENT
  226.                 + "LATITUDE] : Filter results by Northern boundary.\n");
  227.         buf.append("[" + MIN_EVENT_LONGITUDE_ARGUMENT
  228.                 + "LONGITUDE] : Filter results by Western boundary.\n");
  229.         buf.append("[" + MAX_EVENT_LONGITUDE_ARGUMENT
  230.                 + "LONGITUDE] : Filter results by Eastern boundary.\n");
  231.         buf.append("[" + MIN_EVENT_DEPTH_ARGUMENT
  232.                 + "DEPTH] : Filter results by minimum depth in km.\n");
  233.         buf.append("[" + MAX_EVENT_DEPTH_ARGUMENT
  234.                 + "DEPTH] : Filter results by maximum depth in km.\n");
  235.         buf.append("[" + MIN_EVENT_MAGNITUDE_ARGUMENT
  236.                 + "MAGNITUDE] : Filter results by minimum magnitude.\n");
  237.         buf.append("[" + MAX_EVENT_MAGNITUDE_ARGUMENT
  238.                 + "MAGNITUDE] : Filter results by maximum magnitude.\n");
  239.         buf.append("["
  240.                 + PRODUCT_ID_ARGUMENT
  241.                 + "PRODUCT_ID] : Filter by product ID. Each time this appears the new ID is added.\n");
  242.         buf.append("[" + PRODUCT_SOURCE_ARGUMENT
  243.                 + "SOURCE] : Filter results by product source.\n");
  244.         buf.append("[" + PRODUCT_STATUS_ARGUMENT
  245.                 + "STATUS] : Filter results by product status.\n");
  246.         buf.append("[" + PRODUCT_TYPE_ARGUMENT
  247.                 + "TYPE] : Filter results by product type.\n");
  248.         buf.append("[" + PRODUCT_VERSION_ARGUMENT
  249.                 + "VERSION] : Filter results by product version.\n");
  250.         buf.append("["
  251.                 + SEARCH_HOST_ARGUMENT
  252.                 + "HOST] : The Product Index host to receive this query. Default is localhost.");
  253.         buf.append("["
  254.                 + SEARCH_PORT_ARGUMENT
  255.                 + "PORT] : The port on which to execute this query. Default is "
  256.                 + SearchServerSocket.DEFAULT_SEARCH_PORT + ".\n");
  257.         buf.append("["
  258.                 + FILE_OUTPUT_ARGUMENT
  259.                 + "FILE] : The file to write output to. If this is not included, output will be directed over stdout.");

  261.         return buf.toString();
  262.     }

  264. }
Created with JaCoCo 0.8.8.202204050719