URLProductStorage.java

  1. /*
  2.  * URLProductStorage
  3.  */
  4. package gov.usgs.earthquake.distribution;

  6. import gov.usgs.earthquake.product.ProductId;

  8. import gov.usgs.earthquake.product.io.BinaryProductHandler;
  9. import gov.usgs.earthquake.product.io.BinaryProductSource;
  10. import gov.usgs.earthquake.product.io.JsonProductHandler;
  11. import gov.usgs.earthquake.product.io.JsonProductSource;
  12. import gov.usgs.earthquake.product.io.ProductSource;
  13. import gov.usgs.earthquake.product.io.ProductHandler;
  14. import gov.usgs.earthquake.product.io.XmlProductSource;
  15. import gov.usgs.earthquake.product.io.XmlProductHandler;
  16. import gov.usgs.util.Config;
  17. import gov.usgs.util.StreamUtils;

  19. import java.io.File;
  20. import java.io.InputStream;
  21. import java.io.OutputStream;

  23. import java.net.URL;
  24. import java.util.logging.Logger;

  26. /**
  27.  * Store products in a file system which is also available at a URL.
  28.  */
  29. public class URLProductStorage extends FileProductStorage {

  31.     /** Different types of formats */
  32.     public enum Format {
  33.         /** Enum for BINARY/bin format */
  34.         BINARY("bin"),
  35.         /** Enum for JSON format */
  36.         JSON("json"),
  37.         /** Enum for XML format */
  38.         XML("xml");

  40.         private String value;

  42.         private Format(final String value) {
  43.             this.value = value;
  44.         }

  46.         public String toString() {
  47.             return this.value;
  48.         }

  50.         /**
  51.          * Takes a string value and returns ENUM of its format
  52.          * @param value String
  53.          * @return Format ENUM
  54.          */
  55.         public static Format fromString(final String value) {
  56.             if (BINARY.value.equals(value)) {
  57.                 return BINARY;
  58.             } else if (JSON.value.equals(value)) {
  59.                 return JSON;
  60.             } else if (XML.value.equals(value)) {
  61.                 return XML;
  62.             } else {
  63.                 throw new IllegalArgumentException("Invalid format");
  64.             }
  65.         }
  66.     };

  68.     private static final Logger LOGGER = Logger
  69.             .getLogger(URLProductStorage.class.getName());

  71.     /** Property name representing base URL. */
  72.     public static final String URL_PROPERTY_NAME = "url";

  74.     /** The URL which corresponds to baseDirectory. */
  75.     private URL baseURL;

  77.     /** Property for storageFormat */
  78.     public static final String STORAGE_FORMAT_PROPERTY = "storageFormat";

  80.     /** Property for storagePath */
  81.     public static final String STORAGE_PATH_PROPERTY = "storagePath";
  82.     /** Sets up default storage path */
  83.     public static final String DEFAULT_STORAGE_PATH = "{source}_{type}_{code}_{updateTime}.{format}";

  85.     /** (Deprecated, use STORAGE_PATH) Property name to configure binary or xml format. */
  86.     public static final String BINARY_FORMAT_PROPERTY = "binaryFormat";
  87.     /** Default value for whether to use binary format. */
  88.     public static final String BINARY_FORMAT_DEFAULT = "false";

  90.     private Format storageFormat = Format.XML;
  91.     private String storagePath = DEFAULT_STORAGE_PATH;

  93.     /**
  94.      * Constructor for the Configurable interface.
  95.      */
  96.     public URLProductStorage() {
  97.     }

  99.     /**
  100.      * Construct a new ProductStorage object
  101.      *
  102.      * @param baseDirectory
  103.      *            the storage directory where products are stored.
  104.      * @param baseURL
  105.      *            the url where storage directory is available.
  106.      */
  107.     public URLProductStorage(final File baseDirectory, final URL baseURL) {
  108.         super(baseDirectory);
  109.         this.baseURL = baseURL;
  110.     }

  112.     /**
  113.      * Load the baseURL from configuration.
  114.      *
  115.      * @param config
  116.      *            the configuration object.
  117.      */
  118.     public void configure(final Config config) throws Exception {
  119.         super.configure(config);

  121.         String urlString = config.getProperty(URL_PROPERTY_NAME);
  122.         if (urlString == null) {
  123.             throw new ConfigurationException("[" + getName()
  124.                     + "] 'url' is a required configuration property");
  125.         }
  126.         baseURL = new URL(urlString);
  127.         LOGGER.config("[" + getName() + "] base url is '" + baseURL.toString()
  128.                 + "'");

  130.         String format = config.getProperty(STORAGE_FORMAT_PROPERTY);
  131.         if (format != null) {
  132.             storageFormat = Format.fromString(format);
  133.         } else {
  134.             if (Boolean.valueOf(config.getProperty(
  135.                     BINARY_FORMAT_PROPERTY,
  136.                     BINARY_FORMAT_DEFAULT))) {
  137.                 storageFormat = Format.BINARY;
  138.             } else {
  139.                 storageFormat = Format.XML;
  140.             }
  141.         }
  142.         LOGGER.config("[" + getName() + "] using format " + storageFormat);

  144.         storagePath = config.getProperty(STORAGE_PATH_PROPERTY, DEFAULT_STORAGE_PATH);
  145.         LOGGER.config("[" + getName() + "] using path " + storagePath);
  146.     }

  148.     /**
  149.      * Compute the URL to a product.
  150.      *
  151.      * @param id
  152.      *            which product.
  153.      * @return the URL to a product.
  154.      * @throws Exception if error occurs
  155.      */
  156.     public URL getProductURL(final ProductId id) throws Exception {
  157.         return new URL(baseURL, getProductPath(id));
  158.     }

  160.     /**
  161.      * A method for subclasses to override the storage path.
  162.      *
  163.      * The returned path is appended to the base directory when storing and
  164.      * retrieving products.
  165.      *
  166.      * @param id
  167.      *            the product id to convert.
  168.      * @return the directory used to store id.
  169.      */
  170.     @Override
  171.     public String getProductPath(final ProductId id) {
  172.         String path = storagePath;
  173.         path = path.replace("{source}", id.getSource());
  174.         path = path.replace("{type}", id.getType());
  175.         path = path.replace("{code}", id.getCode());
  176.         path = path.replace("{updateTime}", Long.toString(id.getUpdateTime().getTime()));
  177.         path = path.replace("{format}", storageFormat.toString());
  178.         return path;
  179.     }

  181.     /**
  182.      * A method for subclasses to override the storage format.
  183.      *
  184.      * When overriding this method, the method getProductInputForFile should
  185.      * also be overridden.
  186.      *
  187.      * @param file
  188.      *            a file that should be converted into a ProductOutput.
  189.      * @return the ProductOutput.
  190.      */
  191.     protected ProductHandler getProductHandlerFormat(final File file)
  192.             throws Exception {
  193.         OutputStream out = StreamUtils.getOutputStream(file);
  194.         if (storageFormat == Format.BINARY) {
  195.             return new BinaryProductHandler(out);
  196.         } else if (storageFormat == Format.JSON) {
  197.             return new JsonProductHandler(out);
  198.         } else {
  199.             return new XmlProductHandler(out);
  200.         }
  201.     }

  203.     /**
  204.      * A method for subclasses to override the storage format.
  205.      *
  206.      * When overriding this method, the method getProductOutputForFile should
  207.      * also be overridden.
  208.      *
  209.      * @param file
  210.      *            a file that should be converted into a ProductInput.
  211.      * @return the ProductInput.
  212.      */
  213.     protected ProductSource getProductSourceFormat(final File file)
  214.             throws Exception {
  215.         InputStream in = StreamUtils.getInputStream(file);
  216.         if (storageFormat == Format.BINARY) {
  217.             return new BinaryProductSource(in);
  218.         } else if (storageFormat == Format.JSON) {
  219.             return new JsonProductSource(in);
  220.         } else {
  221.             return new XmlProductSource(in);
  222.         }
  223.     }

  225.     /** @return storageFormat */
  226.     public Format getStorageFormat() {
  227.         return this.storageFormat;
  228.     }

  230.     /** @param format set a storageFormat */
  231.     public void setStorageFormat(final Format format) {
  232.         this.storageFormat = format;
  233.     }

  235.     /** @return storagePath */
  236.     public String getStoragePath() {
  237.         return this.storagePath;
  238.     }

  240.     /** @param path set a string as the storagePath */
  241.     public void setStoragePath(final String path) {
  242.         this.storagePath = path;
  243.     }

  245. }
Created with JaCoCo 0.8.8.202204050719