DefaultIndexerListener.java

  1. package gov.usgs.earthquake.indexer;

  3. import gov.usgs.earthquake.indexer.IndexerChange.IndexerChangeType;
  4. import gov.usgs.earthquake.product.AbstractListener;
  5. import gov.usgs.earthquake.product.ProductId;
  6. import gov.usgs.earthquake.util.CompareUtil;
  7. import gov.usgs.util.Config;

  9. import java.util.Iterator;
  10. import java.util.List;
  11. import java.util.logging.Logger;

  13. /**
  14.  * DefaultIndexerListener provides a starting point from which all
  15.  * IndexerListeners may extend.
  16.  *
  17.  * As a child-class of the AbstractListener, this may be configured with all of
  18.  * the parent parameters and also accepts the following:
  19.  *
  20.  * <dl>
  21.  * <dt>command</dt>
  22.  * <dd>(Required) The command to execute. This must be an executable command and
  23.  * may include arguments. Any product-specific arguments are appended at the end
  24.  * of command.</dd>
  25.  *
  26.  * <dt>storage</dt>
  27.  * <dd>(Required) A directory used to store all products. Each product is
  28.  * extracted into a separate directory within this directory and is referenced
  29.  * by the --directory=/path/to/directory argument when command is executed.</dd>
  30.  *
  31.  * <dt>processUnassociated</dt>
  32.  * <dd>(Optional, Default = false) Whether or not to process unassociated
  33.  * products. Valid values are "true" and "false".</dd>
  34.  *
  35.  * <dt>processPreferredOnly</dt>
  36.  * <dd>(Optional, Default = false) Whether or not to process only preferred
  37.  * products of the type accepted by this listener. Valid values are "true" and
  38.  * "false".</dd>
  39.  *
  40.  * <dt>ignoreArchive</dt>
  41.  * <dd>(Optional, Default = false) Whether or not to ignore EVENT_ARCHIVED and
  42.  * PRODUCT_ARCHIVED indexer events. Value values are "true" and "false".</dd>
  43.  *
  44.  * </dl>
  45.  */
  46. public class DefaultIndexerListener extends AbstractListener implements
  47.         IndexerListener {
  48.     /** Logging object. */
  49.     private static final Logger LOGGER = Logger
  50.             .getLogger(DefaultIndexerListener.class.getName());

  52.     /** Property for process preferred only */
  53.     public static final String PROCESS_PREFERRED_ONLY_PROPERTY = "processPreferredOnly";
  54.     /** Default state of process preferred only */
  55.     public static final String PROCESS_PREFERRED_ONLY_DEFAULT = "false";

  57.     /** Property for process unassociated */
  58.     public static final String PROCESS_UNASSOCIATED_PROPERTY = "processUnassociated";
  59.     /** Default state of process unassociated */
  60.     public static final String PROCESS_UNASSOCIATED_DEFAULT = "true";

  62.     /** Property for process only when event change */
  63.     public static final String PROCESS_ONLY_WHEN_EVENT_CHANGE_PROPERTY = "processOnlyWhenEventChanged";
  64.     /** Default state of process only when event change */
  65.     public static final String PROCESS_ONLY_WHEN_EVENT_CHANGE_DEFAULT = "false";

  67.     /** Property for Ignore archive */
  68.     public static final String IGNORE_ARCHIVE_PROPERTY = "ignoreArchive";
  69.     /** Default state of ignore archive */
  70.     public static final String IGNORE_ARCHIVE_DEFAULT = "true";

  72.     /** Whether or not to process only preferred products. */
  73.     private boolean processOnlyPreferredProducts = false;

  75.     /** Whether or not to process unassociated products. */
  76.     private boolean processUnassociatedProducts = true;

  78.     /**
  79.      * Whether or not to process updates that don't change preferred event
  80.      * parameters.
  81.      */
  82.     private boolean processOnlyWhenEventChanged = false;

  84.     /** Whether or not to process archive events. */
  85.     private boolean ignoreArchive = false;

  87.     @Override
  88.     public void onIndexerEvent(IndexerEvent event) throws Exception {
  89.         StringBuffer buf = new StringBuffer();
  90.         Iterator<IndexerChange> changes = event.getIndexerChanges().iterator();
  91.         while (changes.hasNext()) {
  92.             IndexerChange change = changes.next();
  93.             buf.append("\n").append(change.getType().toString()).append(" ");
  94.             if (change.getOriginalEvent() == null) {
  95.                 buf.append("null");
  96.             } else {
  97.                 buf.append(change.getOriginalEvent().getEventId());
  98.             }
  99.             buf.append(" => ");
  100.             if (change.getNewEvent() == null) {
  101.                 buf.append("null");
  102.             } else {
  103.                 buf.append(change.getNewEvent().getEventId());
  104.             }
  105.         }
  106.         LOGGER.info(buf.toString());
  107.     }

  109.     /**
  110.      * @param change
  111.      *            the indexer event that has occurred
  112.      * @return whether this external indexer listener handles this product type
  113.      * @throws Exception if error occurs
  114.      */
  115.     public boolean accept(IndexerEvent change) throws Exception {
  116.         String productType = null;

  118.         if (change.getSummary() != null) {
  119.             ProductId productId = change.getSummary().getId();

  121.             productType = productId.getType();

  123.             // use default notification listener first
  124.             if (!super.accept(productId)) {
  125.                 return false;
  126.             }
  127.         }

  129.         List<Event> events = change.getEvents();
  130.         if (!processUnassociatedProducts && events.size() == 0) {
  131.             LOGGER.fine("[" + getName() + "] product is unassociated");
  132.             return false;
  133.         }

  135.         if (processOnlyPreferredProducts && events.size() > 0) {
  136.             // check if preferred for any event
  137.             boolean isPreferred = false;

  139.             // can only be a preferred product if a summary associated
  140.             if (productType != null) {
  141.                 Iterator<Event> iter = events.iterator();
  142.                 while (iter.hasNext()) {
  143.                     Event event = iter.next();
  144.                     ProductSummary preferred = event
  145.                             .getPreferredProduct(productType);
  146.                     if (preferred != null && preferred.getId().equals(
  147.                             change.getSummary().getId())) {
  148.                         // it is the most preferred product for this event
  149.                         isPreferred = true;
  150.                         break;
  151.                     }
  152.                 }
  153.             }

  155.             if (!isPreferred) {
  156.                 LOGGER.fine("[" + getName()
  157.                         + "] product is not preferred in any event");
  158.                 return false;
  159.             }
  160.         }

  162.         // accept by default
  163.         return true;
  164.     }

  166.     /**
  167.      * Returns a boolean based on if the preferred event params have changed
  168.      * Returns false if change is an archive indexer
  169.      * @param event an IndexerEvent
  170.      * @param change and IndexerChange
  171.      * @return boolean
  172.      * @throws Exception if error occurs
  173.      */
  174.     public boolean accept(IndexerEvent event, IndexerChange change)
  175.             throws Exception {
  176.         // check whether this is an archive indexer change
  177.         if (ignoreArchive
  178.                 && (change.getType() == IndexerChangeType.PRODUCT_ARCHIVED
  179.                 || change.getType() == IndexerChangeType.EVENT_ARCHIVED)) {
  180.             return false;
  181.         }

  183.         // see if preferred event parameters have changed
  184.         if (processOnlyWhenEventChanged) {
  185.             Event originalEvent = change.getOriginalEvent();
  186.             Event newEvent = change.getNewEvent();
  187.             if (originalEvent != null && newEvent != null) {
  188.                 EventSummary originalEventSummary = originalEvent.getEventSummary();
  189.                 EventSummary newEventSummary = newEvent.getEventSummary();
  190.                 if (CompareUtil.nullSafeCompare(
  191.                         originalEventSummary.getMagnitude(),
  192.                         newEventSummary.getMagnitude()) != 0) {
  193.                     // magnitude changed
  194.                 } else if (CompareUtil.nullSafeCompare(
  195.                         originalEventSummary.getLatitude(),
  196.                         newEventSummary.getLatitude()) != 0) {
  197.                     // latitude changed
  198.                 } else if (CompareUtil.nullSafeCompare(
  199.                         originalEventSummary.getLongitude(),
  200.                         newEventSummary.getLongitude()) != 0) {
  201.                     // longitude changed
  202.                 } else if (CompareUtil.nullSafeCompare(
  203.                         originalEventSummary.getDepth(),
  204.                         newEventSummary.getDepth()) != 0) {
  205.                     // depth changed
  206.                 } else if (CompareUtil.nullSafeCompare(
  207.                         originalEventSummary.getTime(),
  208.                         newEventSummary.getTime()) != 0) {
  209.                     // time changed
  210.                 } else if (originalEventSummary.isDeleted() != newEventSummary.isDeleted()) {
  211.                     // status changed
  212.                 } else {
  213.                     // preferred event parameters haven't changed
  214.                     return false;
  215.                 }
  216.             }
  217.         }

  219.         // accept changes by default
  220.         return true;
  221.     }

  223.     public void configure(Config config) throws Exception {
  224.         super.configure(config);

  226.         processOnlyPreferredProducts = Boolean.valueOf(config
  227.                 .getProperty(PROCESS_PREFERRED_ONLY_PROPERTY,
  228.                         PROCESS_PREFERRED_ONLY_DEFAULT));
  229.         LOGGER.config("[" + getName() + "] process only preferred products = "
  230.                 + processOnlyPreferredProducts);

  232.         processUnassociatedProducts = Boolean.valueOf(config.getProperty(
  233.                 PROCESS_UNASSOCIATED_PROPERTY, PROCESS_UNASSOCIATED_DEFAULT));
  234.         LOGGER.config("[" + getName() + "] process unassociated products = "
  235.                 + processUnassociatedProducts);

  237.         processOnlyWhenEventChanged = Boolean.valueOf(config.getProperty(
  238.                 PROCESS_ONLY_WHEN_EVENT_CHANGE_PROPERTY,
  239.                 PROCESS_ONLY_WHEN_EVENT_CHANGE_DEFAULT));
  240.         LOGGER.config("[" + getName() + "] process only when event changed = "
  241.                 + processOnlyWhenEventChanged);

  243.         ignoreArchive = Boolean.valueOf(config.getProperty(
  244.                 IGNORE_ARCHIVE_PROPERTY, IGNORE_ARCHIVE_DEFAULT));
  245.         LOGGER.config("[" + getName() + "] ignore archive changes = "
  246.                 + ignoreArchive);
  247.     }

  249.     /**
  250.      * @return whether only preferred products are processed
  251.      */
  252.     public boolean getProcessOnlyPreferredProducts() {
  253.         return processOnlyPreferredProducts;
  254.     }

  256.     /**
  257.      * @param processOnlyPreferredProducts
  258.      *            whether to process ony preferred products
  259.      */
  260.     public void setProcessOnlyPreferredProducts(
  261.             final boolean processOnlyPreferredProducts) {
  262.         this.processOnlyPreferredProducts = processOnlyPreferredProducts;
  263.     }

  265.     /** @param processUnassociatedProducts to set */
  266.     public void setProcessUnassociatedProducts(
  267.             final boolean processUnassociatedProducts) {
  268.         this.processUnassociatedProducts = processUnassociatedProducts;
  269.     }

  271.     /** @return boolean processUnassociatedProducts */
  272.     public boolean getProcessUnassociatedProducts() {
  273.         return processUnassociatedProducts;
  274.     }

  276.     /** @return boolean processOnlyWhenEventChanged */
  277.     public boolean isProcessOnlyWhenEventChanged() {
  278.         return processOnlyWhenEventChanged;
  279.     }

  281.     /** @param processOnlyWhenEventChanged to set */
  282.     public void setProcessOnlyWhenEventChanged(
  283.             boolean processOnlyWhenEventChanged) {
  284.         this.processOnlyWhenEventChanged = processOnlyWhenEventChanged;
  285.     }

  287.     /** @return ignoreArchive */
  288.     public boolean isIgnoreArchive() {
  289.         return ignoreArchive;
  290.     }

  292.     /** @param ignoreArchive to set */
  293.     public void setIgnoreArchive(boolean ignoreArchive) {
  294.         this.ignoreArchive = ignoreArchive;
  295.     }
  296. }
Created with JaCoCo 0.8.8.202204050719