ProductArchivePolicy.java

  1. package gov.usgs.earthquake.indexer;

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

  4. import gov.usgs.earthquake.distribution.ConfigurationException;
  5. import gov.usgs.util.Config;

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

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

  14.   // --------------------------------------------------------------------
  15.   // Names of configurable parameters
  16.   // --------------------------------------------------------------------

  17.   /** Property for archive min product age */
  18.   public static final String ARCHIVE_MIN_PRODUCT_AGE_PROPERTY = "minProductAge";
  19.   /** Property for archive max product age */
  20.   public static final String ARCHIVE_MAX_PRODUCT_AGE_PROPERTY = "maxProductAge";

  21.   /** Property for archive min product time */
  22.   public static final String ARCHIVE_MIN_PRODUCT_TIME_PROPERTY = "minProductTime";
  23.   /** Property for archive max product time */
  24.   public static final String ARCHIVE_MAX_PRODUCT_TIME_PROPERTY = "maxProductTime";

  25.   /** Property for archive product type */
  26.   public static final String ARCHIVE_TYPE_PROPERTY = "productType";
  27.   /** Property for archive product source */
  28.   public static final String ARCHIVE_SOURCE_PROPERTY = "productSource";
  29.   /** Property for archive superseded */
  30.   public static final String ARCHIVE_SUPERSEDED_PROPERTY = "onlySuperseded";
  31.   /** Property for archive unassociated */
  32.   public static final String ARCHIVE_UNASSOCIATED_PROPERTY = "onlyUnassociated";
  33.   /** Property for archive product status */
  34.   public static final String ARCHIVE_STATUS_PROPERTY = "productStatus";

  35.   /** Default state for archive superseded */
  36.   public static final String DEFAULT_ARCHIVE_SUPERSEDED = "true";
  37.   /** Default state for archive unassociated */
  38.   public static final String DEFAULT_ARCHIVE_UNASSOCIATED = "false";
  39.   // --------------------------------------------------------------------
  40.   // Configured parameters.
  41.   // --------------------------------------------------------------------

  42.   /** Configured parameter for min product age */
  43.   protected Long minProductAge = null;
  44.   /** Configured parameter for max product age */
  45.   protected Long maxProductAge = null;
  46.   /** Configured parameter for min product time */
  47.   protected Long minProductTime = null;
  48.   /** Configured parameter for max product time */
  49.   protected Long maxProductTime = null;

  50.   /** Configured parameter for product type */
  51.   protected String productType = null;
  52.   /** Configured parameter for product source */
  53.   protected String productSource = null;
  54.   /** Configured parameter for only superseded */
  55.   protected boolean onlySuperseded = true;
  56.   /** Configured parameter for only unassociated */
  57.   protected boolean onlyUnassociated = false;
  58.   /** Configured parameter for product status */
  59.   protected String productStatus = null;

  60.   @SuppressWarnings("deprecation")
  61.   @Override
  62.   public void configure(Config config) throws Exception {
  63.     super.configure(config);

  64.     minProductAge = parseLong(config, ARCHIVE_MIN_PRODUCT_AGE_PROPERTY);
  65.     maxProductAge = parseLong(config, ARCHIVE_MAX_PRODUCT_AGE_PROPERTY);

  66.     minProductTime = parseDateOrLong(config, ARCHIVE_MIN_PRODUCT_TIME_PROPERTY);
  67.     maxProductTime = parseDateOrLong(config, ARCHIVE_MAX_PRODUCT_TIME_PROPERTY);

  68.     if (minProductAge != null && maxProductTime != null) {
  69.       LOGGER.config("Both minProductAge and maxProductTime were specified. "
  70.           + "Ignoring minProductAge. Only maxProductTime will be used.");
  71.     }
  72.     if (maxProductAge != null && minProductTime != null) {
  73.       LOGGER.config("Both maxProductAge and minProductTime were specified. "
  74.           + "Ignoring maxProductAge. Only minProductTime will be used.");
  75.     }

  76.     if ((minAge != null || maxAge != null)
  77.         && (minProductAge != null || maxProductAge != null || minProductTime != null || maxProductTime != null)) {
  78.       /*
  79.        * Do we need to log in addition to throwing the exception?
  80.        * LOGGER.severe("Configuration mismatch. Can not specify both " +
  81.        * "minAge/maxAge (legacy) properties as well as " +
  82.        * "minEventAge/maxEventAge.");
  83.        */
  84.       ConfigurationException ce = new ConfigurationException("Configuration mismatch. Can not specify both "
  85.           + "minAge/maxAge (legacy) properties as well as " + "minProductAge/maxProductAge.");
  86.       ce.fillInStackTrace();
  87.       throw ce;
  88.     }

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

  90.       ConfigurationException ce = new ConfigurationException(
  91.           "Configuration mismatch. minProductAge " + "greater than maxProductAge.");
  92.       ce.fillInStackTrace();
  93.       throw ce;
  94.     }

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

  96.       ConfigurationException ce = new ConfigurationException(
  97.           "Configuration mismatch. minProductTime " + "greater than maxProductTime.");
  98.       ce.fillInStackTrace();
  99.       throw ce;
  100.     }

  101.     productType = config.getProperty(ARCHIVE_TYPE_PROPERTY);
  102.     productSource = config.getProperty(ARCHIVE_SOURCE_PROPERTY);
  103.     onlySuperseded = Boolean.valueOf(config.getProperty(ARCHIVE_SUPERSEDED_PROPERTY, DEFAULT_ARCHIVE_SUPERSEDED));
  104.     onlyUnassociated = Boolean.valueOf(config.getProperty(ARCHIVE_UNASSOCIATED_PROPERTY, DEFAULT_ARCHIVE_UNASSOCIATED));

  105.     productStatus = config.getProperty(ARCHIVE_STATUS_PROPERTY);
  106.   }

  107.   @SuppressWarnings("deprecation")
  108.   @Override
  109.   public ProductIndexQuery getIndexQuery() {
  110.     ProductIndexQuery productIndexQuery = super.getIndexQuery();
  111.     Date now = new Date();

  112.     // Order of minAge, minProductAge, minProductTime is important here.
  113.     // Preference order is minProductTime > minProductAge > minAge
  114.     // Similar for max* properties.

  115.     if (minAge != null) {
  116.       // min age corresponds to minimum product created time
  117.       productIndexQuery.setMinProductUpdateTime(new Date(now.getTime() - minAge.longValue()));
  118.       productIndexQuery.setMinEventTime(null);
  119.     }
  120.     if (maxAge != null) {
  121.       // max age corresponds to maximum product created time
  122.       productIndexQuery.setMaxProductUpdateTime(new Date(now.getTime() - maxAge.longValue()));
  123.       productIndexQuery.setMaxEventTime(null);
  124.     }

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

  127.     if (maxProductAge != null) {
  128.       productIndexQuery.setMinProductUpdateTime(new Date(now.getTime() - maxProductAge.longValue()));
  129.     }
  130.     if (minProductAge != null) {
  131.       productIndexQuery.setMaxProductUpdateTime(new Date(now.getTime() - minProductAge.longValue()));
  132.     }

  133.     if (minProductTime != null) {
  134.       productIndexQuery.setMinProductUpdateTime(new Date(minProductTime.longValue()));
  135.     }
  136.     if (maxProductTime != null) {
  137.       productIndexQuery.setMaxProductUpdateTime(new Date(maxProductTime.longValue()));
  138.     }

  139.     // search for products of a specific type
  140.     productIndexQuery.setProductType(productType);
  141.     // search for products from a specific source
  142.     productIndexQuery.setProductSource(productSource);

  143.     if (onlySuperseded) {
  144.       // remove only old versions of products (keep the latest)
  145.       productIndexQuery.setResultType(ProductIndexQuery.RESULT_TYPE_SUPERSEDED);
  146.     } else {
  147.       // otherwise include all products
  148.       productIndexQuery.setResultType(ProductIndexQuery.RESULT_TYPE_ALL);
  149.     }

  150.     productIndexQuery.setProductStatus(productStatus);

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

  154.     return productIndexQuery;
  155.   }

  156.   @Override
  157.   public boolean isValidPolicy() {
  158.     boolean valid = super.isValidPolicy();
  159.     return valid || (minProductAge != null || maxProductAge != null || minProductTime != null || maxProductTime != null
  160.         || productType != null || productSource != null || productStatus != null);
  161.   }

  162.   /** @return minProductAge */
  163.   public Long getMinProductAge() {
  164.     return minProductAge;
  165.   }

  166.   /** @param minProductAge to set */
  167.   public void setMinProductAge(Long minProductAge) {
  168.     this.minProductAge = minProductAge;
  169.   }

  170.   /** @return maxProductAge */
  171.   public Long getMaxProductAge() {
  172.     return maxProductAge;
  173.   }

  174.   /** @param maxProductAge to set */
  175.   public void setMaxProductAge(Long maxProductAge) {
  176.     this.maxProductAge = maxProductAge;
  177.   }

  178.   /** @return minProductTime */
  179.   public Long getMinProductTime() {
  180.     return minProductTime;
  181.   }

  182.   /** @param minProductTime to set */
  183.   public void setMinProductTime(Long minProductTime) {
  184.     this.minProductTime = minProductTime;
  185.   }

  186.   /** @return maxProductTime */
  187.   public Long getMaxProductTime() {
  188.     return maxProductTime;
  189.   }

  190.   /** @param maxProductTime to set */
  191.   public void setMaxProductTime(Long maxProductTime) {
  192.     this.maxProductTime = maxProductTime;
  193.   }

  194.   /** @return productType */
  195.   public String getProductType() {
  196.     return productType;
  197.   }

  198.   /** @param productType to set */
  199.   public void setProductType(String productType) {
  200.     this.productType = productType;
  201.   }

  202.   /** @return productSource */
  203.   public String getProductSource() {
  204.     return productSource;
  205.   }

  206.   /** @param productSource to set */
  207.   public void setProductSource(String productSource) {
  208.     this.productSource = productSource;
  209.   }

  210.   /** @return onlySuperseded */
  211.   public boolean isOnlySuperseded() {
  212.     return onlySuperseded;
  213.   }

  214.   /** @param onlySuperseded to set */
  215.   public void setOnlySuperseded(boolean onlySuperseded) {
  216.     this.onlySuperseded = onlySuperseded;
  217.   }

  218.   /** @return onlyUnassociated */
  219.   public boolean isOnlyUnassociated() {
  220.     return onlyUnassociated;
  221.   }

  222.   /** @param onlyUnassociated to set */
  223.   public void setOnlyUnassociated(boolean onlyUnassociated) {
  224.     this.onlyUnassociated = onlyUnassociated;
  225.   }

  226.   /** @return productStatus */
  227.   public String getProductStatus() {
  228.     return productStatus;
  229.   }

  230.   /** @param productStatus to set */
  231.   public void setProductStatus(String productStatus) {
  232.     this.productStatus = productStatus;
  233.   }
  234. }