ProductArchivePolicy.java

  1. package gov.usgs.earthquake.indexer;

  3. import java.util.Date;
  4. import java.util.logging.Logger;

  6. import gov.usgs.earthquake.distribution.ConfigurationException;
  7. import gov.usgs.util.Config;

  9. /**
  10.  * An archive policy for products, instead of events.
  11.  *
  12.  * Allows removal of superseded products, preserving latest versions. Also
  13.  * allows targeting unassociated products.
  14.  */
  15. public class ProductArchivePolicy extends ArchivePolicy {

  17.     private static final Logger LOGGER = Logger
  18.             .getLogger(ProductArchivePolicy.class.getName());

  20.     // --------------------------------------------------------------------
  21.     // Names of configurable parameters
  22.     // --------------------------------------------------------------------

  24.     /** Property for archive min product age */
  25.     public static final String ARCHIVE_MIN_PRODUCT_AGE_PROPERTY = "minProductAge";
  26.     /** Property for archive max product age */
  27.     public static final String ARCHIVE_MAX_PRODUCT_AGE_PROPERTY = "maxProductAge";

  29.     /** Property for archive min product time */
  30.     public static final String ARCHIVE_MIN_PRODUCT_TIME_PROPERTY = "minProductTime";
  31.     /** Property for archive max product time */
  32.     public static final String ARCHIVE_MAX_PRODUCT_TIME_PROPERTY = "maxProductTime";

  34.     /** Property for archive product type */
  35.     public static final String ARCHIVE_TYPE_PROPERTY = "productType";
  36.     /** Property for archive product source */
  37.     public static final String ARCHIVE_SOURCE_PROPERTY = "productSource";
  38.     /** Property for archive superseded */
  39.     public static final String ARCHIVE_SUPERSEDED_PROPERTY = "onlySuperseded";
  40.     /** Property for archive unassociated */
  41.     public static final String ARCHIVE_UNASSOCIATED_PROPERTY = "onlyUnassociated";
  42.     /** Property for archive product status */
  43.     public static final String ARCHIVE_STATUS_PROPERTY = "productStatus";

  45.     /** Default state for archive superseded */
  46.     public static final String DEFAULT_ARCHIVE_SUPERSEDED = "true";
  47.     /** Default state for archive unassociated */
  48.     public static final String DEFAULT_ARCHIVE_UNASSOCIATED = "false";
  49.     // --------------------------------------------------------------------
  50.     // Configured parameters.
  51.     // --------------------------------------------------------------------

  53.     /** Configured parameter for min product age  */
  54.     protected Long minProductAge = null;
  55.     /** Configured parameter for max product age */
  56.     protected Long maxProductAge = null;
  57.     /** Configured parameter for min product time */
  58.     protected Long minProductTime = null;
  59.     /** Configured parameter for max product time */
  60.     protected Long maxProductTime = null;

  62.     /** Configured parameter for product type */
  63.     protected String productType = null;
  64.     /** Configured parameter for product source */
  65.     protected String productSource = null;
  66.     /** Configured parameter for only superseded */
  67.     protected boolean onlySuperseded = true;
  68.     /** Configured parameter for only unassociated */
  69.     protected boolean onlyUnassociated = false;
  70.     /** Configured parameter for product status */
  71.     protected String productStatus = null;

  73.     @SuppressWarnings("deprecation")
  74.     @Override
  75.     public void configure(Config config) throws Exception {
  76.         super.configure(config);

  78.         minProductAge = parseLong(config, ARCHIVE_MIN_PRODUCT_AGE_PROPERTY);
  79.         maxProductAge = parseLong(config, ARCHIVE_MAX_PRODUCT_AGE_PROPERTY);

  81.         minProductTime = parseDateOrLong(config, ARCHIVE_MIN_PRODUCT_TIME_PROPERTY);
  82.         maxProductTime = parseDateOrLong(config, ARCHIVE_MAX_PRODUCT_TIME_PROPERTY);

  84.         if (minProductAge != null && maxProductTime != null) {
  85.             LOGGER.config("Both minProductAge and maxProductTime were specified. "
  86.                     +
  87.                     "Ignoring minProductAge. Only maxProductTime will be used.");
  88.         }
  89.         if (maxProductAge != null && minProductTime != null) {
  90.             LOGGER.config("Both maxProductAge and minProductTime were specified. "
  91.                     +
  92.                     "Ignoring maxProductAge. Only minProductTime will be used.");
  93.         }

  95.         if ((minAge != null || maxAge != null) &&
  96.                 (minProductAge != null || maxProductAge != null ||
  97.                  minProductTime != null || maxProductTime != null)) {
  98.             /*
  99.              * Do we need to log in addition to throwing the exception?
  100.              * LOGGER.severe("Configuration mismatch. Can not specify both " +
  101.              * "minAge/maxAge (legacy) properties as well as " +
  102.              * "minEventAge/maxEventAge.");
  103.              */
  104.             ConfigurationException ce = new ConfigurationException(
  105.                     "Configuration mismatch. Can not specify both " +
  106.                             "minAge/maxAge (legacy) properties as well as " +
  107.                             "minProductAge/maxProductAge.");
  108.             ce.fillInStackTrace();
  109.             throw ce;
  110.         }

  112.         if ((minProductAge != null && maxProductAge != null) &&
  113.                 (minProductAge  > maxProductAge)) {

  115.             ConfigurationException ce = new ConfigurationException(
  116.                     "Configuration mismatch. minProductAge " +
  117.                             "greater than maxProductAge.");
  118.             ce.fillInStackTrace();
  119.             throw ce;
  120.         }

  122.         if ((minProductTime != null && maxProductTime != null) &&
  123.                 (minProductTime  > maxProductTime)) {

  125.             ConfigurationException ce = new ConfigurationException(
  126.                     "Configuration mismatch. minProductTime " +
  127.                             "greater than maxProductTime.");
  128.             ce.fillInStackTrace();
  129.             throw ce;
  130.         }

  132.         productType = config.getProperty(ARCHIVE_TYPE_PROPERTY);
  133.         productSource = config.getProperty(ARCHIVE_SOURCE_PROPERTY);
  134.         onlySuperseded = Boolean.valueOf(config.getProperty(
  135.                 ARCHIVE_SUPERSEDED_PROPERTY, DEFAULT_ARCHIVE_SUPERSEDED));
  136.         onlyUnassociated = Boolean.valueOf(config.getProperty(
  137.                 ARCHIVE_UNASSOCIATED_PROPERTY, DEFAULT_ARCHIVE_UNASSOCIATED));

  139.         productStatus = config.getProperty(ARCHIVE_STATUS_PROPERTY);
  140.     }

  142.     @SuppressWarnings("deprecation")
  143.     @Override
  144.     public ProductIndexQuery getIndexQuery() {
  145.         ProductIndexQuery productIndexQuery = super.getIndexQuery();
  146.         Date now = new Date();

  148.         // Order of minAge, minProductAge, minProductTime is important here.
  149.         // Preference order is minProductTime > minProductAge > minAge
  150.         // Similar for max* properties.

  152.         if (minAge != null) {
  153.             // min age corresponds to minimum product created time
  154.             productIndexQuery.setMinProductUpdateTime(new Date(now.getTime()
  155.                     - minAge.longValue()));
  156.             productIndexQuery.setMinEventTime(null);
  157.         }
  158.         if (maxAge != null) {
  159.             // max age corresponds to maximum product created time
  160.             productIndexQuery.setMaxProductUpdateTime(new Date(now.getTime()
  161.                     - maxAge.longValue()));
  162.             productIndexQuery.setMaxEventTime(null);
  163.         }

  165.         // See ASCII art in ArchivePolicy.getIndexQuery if you are confused by
  166.         // maxAge --> minTime differences.

  168.         if (maxProductAge != null) {
  169.             productIndexQuery.setMinProductUpdateTime(new Date(now.getTime()
  170.                     - maxProductAge.longValue()));
  171.         }
  172.         if (minProductAge != null) {
  173.             productIndexQuery.setMaxProductUpdateTime(new Date(now.getTime()
  174.                     - minProductAge.longValue()));
  175.         }

  177.         if (minProductTime != null) {
  178.             productIndexQuery.setMinProductUpdateTime(new Date(minProductTime
  179.                     .longValue()));
  180.         }
  181.         if (maxProductTime != null) {
  182.             productIndexQuery.setMaxProductUpdateTime(new Date(maxProductTime
  183.                     .longValue()));
  184.         }

  186.         // search for products of a specific type
  187.         productIndexQuery.setProductType(productType);
  188.         // search for products from a specific source
  189.         productIndexQuery.setProductSource(productSource);

  191.         if (onlySuperseded) {
  192.             // remove only old versions of products (keep the latest)
  193.             productIndexQuery
  194.                     .setResultType(ProductIndexQuery.RESULT_TYPE_SUPERSEDED);
  195.         } else {
  196.             // otherwise include all products
  197.             productIndexQuery.setResultType(ProductIndexQuery.RESULT_TYPE_ALL);
  198.         }

  200.         productIndexQuery.setProductStatus(productStatus);

  202.         // this archive policy searches products, so this shouldn't matter, but
  203.         // just to be safe in case the default changes
  204.         productIndexQuery
  205.                 .setEventSearchType(ProductIndexQuery.SEARCH_EVENT_PRODUCTS);

  207.         return productIndexQuery;
  208.     }

  210.     @Override
  211.     public boolean isValidPolicy() {
  212.         boolean valid = super.isValidPolicy();
  213.         return valid || (minProductAge != null || maxProductAge != null
  214.                 || minProductTime != null || maxProductTime != null
  215.                 || productType != null || productSource != null
  216.                 || productStatus != null);
  217.     }

  219.     /** @return minProductAge */
  220.     public Long getMinProductAge() {
  221.         return minProductAge;
  222.     }

  224.     /** @param minProductAge to set */
  225.     public void setMinProductAge(Long minProductAge) {
  226.         this.minProductAge = minProductAge;
  227.     }

  229.     /** @return maxProductAge */
  230.     public Long getMaxProductAge() {
  231.         return maxProductAge;
  232.     }

  234.     /** @param maxProductAge to set */
  235.     public void setMaxProductAge(Long maxProductAge) {
  236.         this.maxProductAge = maxProductAge;
  237.     }

  239.     /** @return minProductTime */
  240.     public Long getMinProductTime() {
  241.         return minProductTime;
  242.     }

  244.     /** @param minProductTime to set */
  245.     public void setMinProductTime(Long minProductTime) {
  246.         this.minProductTime = minProductTime;
  247.     }

  249.     /** @return maxProductTime */
  250.     public Long getMaxProductTime() {
  251.         return maxProductTime;
  252.     }

  254.     /** @param maxProductTime to set */
  255.     public void setMaxProductTime(Long maxProductTime) {
  256.         this.maxProductTime = maxProductTime;
  257.     }

  259.     /** @return productType */
  260.     public String getProductType() {
  261.         return productType;
  262.     }

  264.     /** @param productType to set */
  265.     public void setProductType(String productType) {
  266.         this.productType = productType;
  267.     }

  269.     /** @return productSource */
  270.     public String getProductSource() {
  271.         return productSource;
  272.     }

  274.     /** @param productSource to set */
  275.     public void setProductSource(String productSource) {
  276.         this.productSource = productSource;
  277.     }

  279.     /** @return onlySuperseded */
  280.     public boolean isOnlySuperseded() {
  281.         return onlySuperseded;
  282.     }

  284.     /** @param onlySuperseded to set */
  285.     public void setOnlySuperseded(boolean onlySuperseded) {
  286.         this.onlySuperseded = onlySuperseded;
  287.     }

  289.     /** @return onlyUnassociated */
  290.     public boolean isOnlyUnassociated() {
  291.         return onlyUnassociated;
  292.     }

  294.     /** @param onlyUnassociated to set */
  295.     public void setOnlyUnassociated(boolean onlyUnassociated) {
  296.         this.onlyUnassociated = onlyUnassociated;
  297.     }

  299.     /** @return productStatus */
  300.     public String getProductStatus() {
  301.         return productStatus;
  302.     }

  304.     /** @param productStatus to set */
  305.     public void setProductStatus(String productStatus) {
  306.         this.productStatus = productStatus;
  307.     }
  308. }
Created with JaCoCo 0.8.8.202204050719