ShakeMapIndexerWedge.java

  1. /*
  2.  * ShakemapIndexerWedge
  3.  */
  4. package gov.usgs.earthquake.shakemap;

  6. import java.io.File;
  7. import java.io.IOException;
  8. import java.util.HashMap;
  9. import java.util.Map;
  10. import java.util.logging.Logger;

  12. import gov.usgs.earthquake.distribution.Command;
  13. import gov.usgs.earthquake.distribution.Command.CommandTimeout;
  14. import gov.usgs.earthquake.distribution.DefaultNotificationListener;
  15. import gov.usgs.earthquake.distribution.NotificationListenerException;
  16. import gov.usgs.earthquake.distribution.ProductTracker;
  17. import gov.usgs.earthquake.product.Product;
  18. import gov.usgs.earthquake.product.ProductId;
  19. import gov.usgs.earthquake.product.io.DirectoryProductHandler;
  20. import gov.usgs.earthquake.product.io.DirectoryProductSource;
  21. import gov.usgs.earthquake.product.io.ObjectProductHandler;
  22. import gov.usgs.earthquake.product.io.ObjectProductSource;
  23. import gov.usgs.util.Config;
  24. import gov.usgs.util.FileUtils;

  26. /**
  27.  * Legacy interface to trigger pre-Indexer ShakeMap processing.
  28.  *
  29.  * The Old ShakeMap Indexer is no longer used,
  30.  * and this class is deprecated.
  31.  *
  32.  * When a shakemap product arrives, it is only processed if one of these is
  33.  * true:
  34.  * <ul>
  35.  * <li>doesn't already exist</li>
  36.  * <li>from preferred source (product source = eventsource)</li>
  37.  * <li>from same source as before</li>
  38.  * </ul>
  39.  *
  40.  * When processing a shakemap:
  41.  * <ol>
  42.  * <li>remove previous version</li>
  43.  * <li>unpack new version, if not a delete</li>
  44.  * <li>trigger legacy indexer</li>
  45.  * <li>send tracker update</li>
  46.  * </ol>
  47.  *
  48.  * Configurable properties:
  49.  * <dl>
  50.  * <dt>indexerCommand</dt>
  51.  * <dd>The shakemap indexer command to run. Defaults to
  52.  * <code>/home/www/vhosts/earthquake/cron/shakemap_indexer.php</code> .</dd>
  53.  *
  54.  * <dt>shakemapDirectory</dt>
  55.  * <dd>The shakemap event directory. Defaults to
  56.  * <code>/home/www/vhosts/earthquake/htdocs/earthquakes/shakemap</code> .</dd>
  57.  *
  58.  * <dt>timeout</dt>
  59.  * <dd>How long in milliseconds the indexer is allowed to run before being
  60.  * terminated.</dd>
  61.  * </dl>
  62.  */
  63. @Deprecated()
  64. public class ShakeMapIndexerWedge extends DefaultNotificationListener {

  66.     /** Logging object. */
  67.     private static final Logger LOGGER = Logger
  68.             .getLogger(ShakeMapIndexerWedge.class.getName());

  70.     /** Translate from event source to old style shakemap source. */
  71.     private static final Map<String, String> SOURCE_TRANSLATION_MAP = new HashMap<String, String>();
  72.     static {
  73.         SOURCE_TRANSLATION_MAP.put("ci", "sc");
  74.         SOURCE_TRANSLATION_MAP.put("us", "global");
  75.         SOURCE_TRANSLATION_MAP.put("uu", "ut");
  76.         SOURCE_TRANSLATION_MAP.put("uw", "pn");
  77.     }

  79.     /** Configurable property. */
  80.     public static final String SHAKEMAP_INDEXER_COMMAND_PROPERTY = "indexerCommand";

  82.     /** The shakemap indexer command to execute. */
  83.     public static final String DEFAULT_SHAKEMAP_INDEXER_COMMAND = "/home/www/vhosts/earthquake/cron/shakemap_indexer.php";

  85.     /** Configurable property for command timeout. */
  86.     public static final String COMMAND_TIMEOUT_PROPERTY = "timeout";

  88.     /** Default command timeout. */
  89.     public static final String DEFAULT_COMMAND_TIMEOUT = "100000";

  91.     /** Configurable property for shakemap directory. */
  92.     public static final String SHAKEMAP_DIRECTORY_PROPERTY = "shakemapDirectory";

  94.     /** Default shakemap directory. */
  95.     public static final String DEFAULT_SHAKEMAP_DIRECTORY = "/home/www/vhosts/earthquake/htdocs/earthquakes/shakemap";

  97.     /** The indexer command to run. */
  98.     private String indexerCommand = DEFAULT_SHAKEMAP_INDEXER_COMMAND;

  100.     /** Base event directory for shakemap storage. */
  101.     private File baseEventDirectory = new File(DEFAULT_SHAKEMAP_DIRECTORY);

  103.     /** Timeout when running indexer command, in milliseconds. */
  104.     private long indexerTimeout = Long.valueOf(DEFAULT_COMMAND_TIMEOUT);

  106.     /**
  107.      * Create a new ShakeMapIndexerWedge.
  108.      *
  109.      * Sets up the includeTypes list to contain "shakemap".
  110.      */
  111.     public ShakeMapIndexerWedge() {
  112.         this.getIncludeTypes().add("shakemap");
  113.     }

  115.     /**
  116.      * Receive a ShakeMap from Product Distribution.
  117.      *
  118.      * @param product
  119.      *            a shakemap type product.
  120.      */
  121.     @Override
  122.     public void onProduct(final Product product) throws Exception {
  123.         ProductId productId = product.getId();

  125.         // convert this product to a ShakeMap product, which has more
  126.         // information
  127.         ShakeMap shakemap = new ShakeMap(product);

  129.         // get the legacy directory
  130.         File legacyDirectory = getEventDirectory(shakemap);

  132.         // check for a previous version of this shakemap
  133.         if (legacyDirectory.exists()) {
  134.             LOGGER.info("Shakemap directory exists "
  135.                     + legacyDirectory.getCanonicalPath());

  137.             try {
  138.                 ShakeMap previousShakemap = new ShakeMap(
  139.                         ObjectProductHandler
  140.                                 .getProduct(new DirectoryProductSource(
  141.                                         legacyDirectory)));
  142.                 ProductId previousId = previousShakemap.getId();

  144.                 // same version?
  145.                 if (productId.equals(previousId)) {
  146.                     // already have this version of shakemap
  147.                     LOGGER.info("Shakemap already processed "
  148.                             + productId.toString());
  149.                     return;
  150.                 } else {
  151.                     LOGGER.info("Shakemap is different, previous is "
  152.                             + previousId.toString());
  153.                 }

  155.                 if (!productId.getSource().equals(shakemap.getEventSource())
  156.                         && !productId.getSource().equals(previousId.getSource())) {
  157.                     // incoming is not from preferred source
  158.                     LOGGER.info("Skipping non-preferred shakemap, previous source='"
  159.                             + previousId.getSource()
  160.                             + "' incoming source='"
  161.                             + productId.getSource()
  162.                             + "'");
  163.                     return;
  164.                 }
  165.             } catch (Exception e) {
  166.                 // unable to load as a product, may be just a shakemap directory
  167.                 // received via rsync instead of a shakemap product directory

  169.                 if (!productId.getSource().equals(shakemap.getEventSource())) {
  170.                     // only process if product source matches event source
  171.                     LOGGER.info("Shakemap directory already exists, skipping non-preferred source '"
  172.                             + productId.getSource() + "'");
  173.                     return;
  174.                 }
  175.             }

  177.             // remove previous version
  178.             FileUtils.deleteTree(legacyDirectory);
  179.         }

  181.         // passed filtering, so do what the product says
  182.         String source = translateShakeMapSource(shakemap.getEventSource());
  183.         String code = shakemap.getEventSourceCode();
  184.         boolean delete = false;

  186.         if (!shakemap.isDeleted()) {
  187.             // write the original product, not the modified ShakeMap product.
  188.             new ObjectProductSource(product)
  189.                     .streamTo(new DirectoryProductHandler(legacyDirectory));
  190.         } else {
  191.             // need to delete the shakemap, everywhere
  192.             // the indexer will handle the everywhere part...
  193.             delete = true;
  194.         }

  196.         // run the indexer to update shakemap pages
  197.         int exitCode = runIndexer(source, code, delete);
  198.         if (exitCode == 0) {
  199.             new ProductTracker(product.getTrackerURL()).productIndexed(
  200.                     this.getName(), productId);
  201.         } else {
  202.             throw new NotificationListenerException("[" + getName()
  203.                     + "] command exited with status " + exitCode);
  204.         }
  205.     }

  207.     /**
  208.      * Run the shakemap indexer.
  209.      *
  210.      * If network and code are omitted, all events are updated.
  211.      *
  212.      * @param network
  213.      *            the network to update.
  214.      * @param code
  215.      *            the code to update.
  216.      * @param delete
  217.      *            whether indexer is handling a delete (true) or update (false).
  218.      * @return -1 if indexer does not complete within max(1, getAttemptCount())
  219.      *         times, or exit code if indexer completes.
  220.      * @throws IOException if IO error occurs
  221.      */
  222.     public int runIndexer(final String network, final String code,
  223.             final boolean delete) throws Exception {
  224.         // build indexer command
  225.         StringBuffer updateCommand = new StringBuffer(indexerCommand);
  226.         if (network != null && code != null) {
  227.             updateCommand.append(" --network=").append(network);
  228.             updateCommand.append(" --code=").append(code);
  229.             if (delete) {
  230.                 updateCommand.append(" --delete");
  231.             }
  232.         }

  234.         // now run command
  235.         String productCommand = updateCommand.toString();

  237.         Command command = new Command();
  238.         command.setCommand(productCommand);
  239.         command.setTimeout(indexerTimeout);
  240.         try {
  241.             LOGGER.fine("[" + getName() + "] running command '"
  242.                     + productCommand + "'");
  243.             command.execute();

  245.             int exitCode = command.getExitCode();
  246.             LOGGER.info("[" + getName() + "] command '" + productCommand
  247.                     + "' exited with status '" + exitCode + "'");
  248.             return exitCode;
  249.         } catch (CommandTimeout ct) {
  250.             LOGGER.warning("[" + getName() + "] command '" + productCommand
  251.                     + "' timed out");
  252.             return -1;
  253.         }
  254.     }

  256.     /**
  257.      * Get the directory for a particular shakemap.
  258.      *
  259.      * @param shakemap
  260.      *            the shakemap to find a directory for.
  261.      * @return the shakemap directory.
  262.      * @throws Exception if error occurs
  263.      */
  264.     public File getEventDirectory(final ShakeMap shakemap) throws Exception {
  265.         String source = translateShakeMapSource(shakemap.getEventSource());
  266.         String code = shakemap.getEventSourceCode();

  268.         return new File(baseEventDirectory, source + "/shake/" + code);
  269.     }

  271.     /**
  272.      * Translate from an event source to the old style shakemap source.
  273.      *
  274.      * Driven by the SOURCE_TRANSLATION_MAP.
  275.      *
  276.      * @param eventSource
  277.      *            the event network.
  278.      * @return the shakemap network.
  279.      */
  280.     public String translateShakeMapSource(final String eventSource) {
  281.         if (SOURCE_TRANSLATION_MAP.containsKey(eventSource)) {
  282.             return SOURCE_TRANSLATION_MAP.get(eventSource);
  283.         }
  284.         return eventSource;
  285.     }

  287.     /**
  288.      * Configure this shakemap indexer.
  289.      */
  290.     @Override
  291.     public void configure(final Config config) throws Exception {
  292.         super.configure(config);

  294.         baseEventDirectory = new File(config.getProperty(
  295.                 SHAKEMAP_DIRECTORY_PROPERTY, DEFAULT_SHAKEMAP_DIRECTORY));
  296.         LOGGER.config("Shakemap event directory "
  297.                 + baseEventDirectory.getCanonicalPath());

  299.         indexerCommand = config.getProperty(SHAKEMAP_INDEXER_COMMAND_PROPERTY,
  300.                 DEFAULT_SHAKEMAP_INDEXER_COMMAND);
  301.         LOGGER.config("Shakemap indexer command " + indexerCommand);

  303.         indexerTimeout = Long.valueOf(config.getProperty(
  304.                 COMMAND_TIMEOUT_PROPERTY, DEFAULT_COMMAND_TIMEOUT));
  305.         LOGGER.config("Shakemap indexer command timeout " + indexerTimeout);
  306.     }

  308. }
Created with JaCoCo 0.8.8.202204050719