longleaf 0.1.0 → 1.1.1

data/lib/longleaf/services/service_definition_manager.rb

@@ -1,36 +1,39 @@
 require_relative '../models/app_fields'
 require_relative '../models/service_definition'
 
-# Manager which loads and provides access to Longleaf::ServiceDefinition objects
 module Longleaf
+  # Manager which loads and provides access to Longleaf::ServiceDefinition objects
   class ServiceDefinitionManager
     SF ||= Longleaf::ServiceFields
     AF ||= Longleaf::AppFields
-    
+
+    # Hash containing the set of configured services, represented as {ServiceDefinition} objects
     attr_reader :services
-    
+
+    # @param config [Hash] hash representation of the application configuration
     def initialize(config)
       raise ArgumentError.new("Configuration must be provided") if config.nil? || config.empty?
 
       services_config = config[AF::SERVICES]
       raise ArgumentError.new("Services configuration must be provided") if services_config.nil?
-      
+
       @services = Hash.new
       config[AF::SERVICES].each do |name, properties|
         work_script = properties.delete(SF::WORK_SCRIPT)
+        work_class = properties.delete(SF::WORK_CLASS)
         frequency = properties.delete(SF::FREQUENCY)
         delay = properties.delete(SF::DELAY)
         service = Longleaf::ServiceDefinition.new(
             name: name,
             work_script: work_script,
+            work_class: work_class,
             frequency: frequency,
             delay: delay,
             properties: properties)
-        
+
         @services[name] = service
       end
       @services.freeze
     end
-    
   end
-end
+end

data/lib/longleaf/services/service_definition_validator.rb

@@ -1,32 +1,39 @@
 require 'pathname'
-require_relative '../models/service_fields'
-require_relative '../models/app_fields'
-require_relative '../errors'
+require 'longleaf/models/service_fields'
+require 'longleaf/models/app_fields'
+require 'longleaf/errors'
 require_relative 'configuration_validator'
 
-# Validates application configuration of service definitions
 module Longleaf
+  # Validates application configuration of service definitions
   class ServiceDefinitionValidator < ConfigurationValidator
     SF ||= Longleaf::ServiceFields
     AF ||= Longleaf::AppFields
-    
-    # Validates configuration to ensure that it is syntactically correct and does not violate 
+
+    # @param config [Hash] hash containing the application configuration
+    def initialize(config)
+      super(config)
+    end
+
+    protected
+    # Validates configuration to ensure that it is syntactically correct and does not violate
     # schema requirements.
     # @param config [Hash] hash containing the application configuration
-    def self.validate_config(config)
-      assert("Configuration must be a hash, but a #{config.class} was provided", config.class == Hash)
-      assert("Configuration must contain a root '#{AF::SERVICES}' key", config.key?(AF::SERVICES))
-      services = config[AF::SERVICES]
+    def validate
+      assert("Configuration must be a hash, but a #{@config.class} was provided", @config.class == Hash)
+      assert("Configuration must contain a root '#{AF::SERVICES}' key", @config.key?(AF::SERVICES))
+      services = @config[AF::SERVICES]
       assert("'#{AF::SERVICES}' must be a hash of services", services.class == Hash)
-      
-      existing_paths = Array.new
+
       services.each do |name, properties|
-        assert("Name of service definition must be a string, but was of type #{name.class}", name.instance_of?(String))
-        assert("Service definition '#{name}' must be a hash, but a #{properties.class} was provided", properties.is_a?(Hash))
-        
-        work_script = properties[SF::WORK_SCRIPT]
-        assert("Service definition '#{name}' must specify a '#{SF::WORK_SCRIPT}' property", !work_script.nil? && !work_script.empty?)
+        register_on_failure do
+          assert("Name of service definition must be a string, but was of type #{name.class}", name.instance_of?(String))
+          assert("Service definition '#{name}' must be a hash, but a #{properties.class} was provided", properties.is_a?(Hash))
+
+          work_script = properties[SF::WORK_SCRIPT]
+          assert("Service definition '#{name}' must specify a '#{SF::WORK_SCRIPT}' property", !work_script.nil? && !work_script.empty?)
+        end
       end
     end
   end
-end
+end

data/lib/longleaf/services/service_manager.rb

@@ -1,21 +1,96 @@
-# Manager which provides preservation service definitions based on their mappings
+require 'longleaf/helpers/service_date_helper'
+require 'longleaf/services/service_class_cache'
+
 module Longleaf
+  # Manager which provides preservation service definitions based on their mappings
   class ServiceManager
-    
-    def initialize(definition_manager:, mapping_manager:)
+    attr_reader :definition_manager
+    attr_reader :mapping_manager
+
+    # @param definition_manager [ServiceDefinitionManager] the service definition manager
+    # @param mapping_manager [ServiceMappingManager] the mapping of services to locations
+    # @param app_manager [ApplicationConfigManager] manager for storage locations
+    def initialize(definition_manager:, mapping_manager:, app_manager:)
       raise ArgumentError.new('Service definition manager required') if definition_manager.nil?
       raise ArgumentError.new('Service mappings manager required') if mapping_manager.nil?
+      raise ArgumentError.new('Storage location manager required') if app_manager.nil?
       @definition_manager = definition_manager
       @mapping_manager = mapping_manager
+      @app_manager = app_manager
+      @service_class_cache = ServiceClassCache.new(app_manager)
     end
-    
-    # Gets a list of ServiceDefinition objects which match the given criteria
-    # @param location [String] name of the location to lookup
-    # @return [Array] a list of ServiceDefinition objects associated with the location,
-    #    or an empty list if no services match the criteria
-    def list_service_definitions(location: nil)
+
+    # Return a service instance instance for provided service name.
+    # @param service_name [String] name of the service
+    # @return Preservation service class for the provided name
+    # @raise ArgumentError if service_name does not reference an existing service
+    def service(service_name)
+      raise ArgumentError.new('Service name is required') if service_name.nil? || service_name.empty?
+      raise ArgumentError.new("No service with name #{service_name}") unless @definition_manager.services.key?(service_name)
+      definition = @definition_manager.services[service_name]
+      @service_class_cache.service_instance(definition)
+    end
+
+    # List the names of services which are applicable to the given criteria
+    # @param location [String] name of the locations to lookup
+    # @param event [String] name of the preservation event taking place
+    # @return [Array] a list of service names which match the provided criteria
+    def list_services(location: nil, event: nil)
       service_names = @mapping_manager.list_services(location)
-      service_names.collect { |name| @definition_manager.services[name] }
+      if !event.nil?
+        # Filter service names down by event
+        service_names.select { |name| applicable_for_event?(name, event) }
+      else
+        service_names
+      end
+    end
+
+    # List definitions for services which are applicable to the given criteria
+    # @param location [String] name of the locations to lookup
+    # @param event [String] name of the preservation event taking place
+    # @return [Array] List of service definitions which match the provided criteria
+    def list_service_definitions(location: nil, event: nil)
+      names = list_services(location: location, event: event)
+      names.map { |name| @definition_manager.services[name] }
+    end
+
+    # Determines if a service is applicable for a specific preservation event
+    # @param service_name [String] name of the service being evaluated
+    # @param event [String] name of the event to check against
+    # @return [Boolean] true if the service is applicable for the event
+    def applicable_for_event?(service_name, event)
+      service(service_name).is_applicable?(event)
+    end
+
+    # Determine if a service should run for a particular file based on the service's definition and
+    # the file's service related metadata.
+    # @param service_name [String] name of the service being evaluated
+    # @param md_rec [MetadataRecord] metadata record for the file being evaluated
+    # @return [Boolean] true if the service should be run.
+    def service_needed?(service_name, md_rec)
+      service_rec = md_rec.service(service_name)
+      return true if !service_rec.nil? && service_rec.run_needed
+
+      definition = @definition_manager.services[service_name]
+
+      next_run = ServiceDateHelper.next_run_needed(md_rec, definition)
+
+      return false if next_run.nil?
+
+      # If next run timestamp has passed then service is needed
+      now = ServiceDateHelper.formatted_timestamp
+      now >= next_run
+    end
+
+    # Perform the specified service on the file record, in the context of the specified event
+    # @param service_name [String] name of the service
+    # @param file_rec [FileRecord] file record to perform service upon
+    # @param event [String] name of the event service is being performed within.
+    def perform_service(service_name, file_rec, event)
+      definition = @definition_manager.services[service_name]
+
+      service = @service_class_cache.service_instance(definition)
+      service.perform(file_rec, event)
     end
   end
-end
+end

data/lib/longleaf/services/service_mapping_manager.rb

@@ -1,29 +1,30 @@
-require_relative '../models/app_fields'
-require_relative '../models/service_definition'
+require 'longleaf/models/app_fields'
+require 'longleaf/models/service_definition'
 
-# Manager which loads and provides access to location to service mappings
 module Longleaf
+  # Manager which loads and provides access to location to service mappings
   class ServiceMappingManager
     AF ||= Longleaf::AppFields
-    
+
+    # @param config [Hash] has representation of the application configuration
     def initialize(config)
       raise ArgumentError.new("Configuration must be provided") if config.nil? || config.empty?
 
       mappings_config = config[AF::SERVICE_MAPPINGS]
       raise ArgumentError.new("Service mappings configuration must be provided") if mappings_config.nil?
-      
+
       @loc_to_services = Hash.new
-      
+
       mappings_config.each do |mapping|
         locations = mapping[AF::LOCATIONS]
         services = mapping[AF::SERVICES]
-        
+
         locations = [locations] if locations.is_a?(String)
         services = [services] if services.is_a?(String)
-        
+
         locations.each do |loc_name|
           @loc_to_services[loc_name] = Array.new unless @loc_to_services.key?(loc_name)
-          
+
           service_set = @loc_to_services[loc_name]
           if services.is_a?(String)
             service_set.push(services)
@@ -32,11 +33,11 @@ module Longleaf
           end
         end
       end
-      
+
       @loc_to_services.each { |loc, services| services.uniq! }
       @loc_to_services.freeze
     end
-    
+
     # Gets a list of service names associated with the given location
     # @param loc_name [String] name of the location to lookup
     # @return [Array] a list of service names associated with the location
@@ -44,4 +45,4 @@ module Longleaf
       @loc_to_services[loc_name] || []
     end
   end
-end
+end

data/lib/longleaf/services/service_mapping_validator.rb

@@ -1,49 +1,59 @@
 require 'pathname'
-require_relative '../models/service_fields'
-require_relative '../models/app_fields'
-require_relative '../errors'
+require 'longleaf/models/service_fields'
+require 'longleaf/models/app_fields'
+require 'longleaf/errors'
 require_relative 'configuration_validator'
 
-# Validates application configuration of service to location mappings
 module Longleaf
+  # Validates application configuration of service to location mappings
   class ServiceMappingValidator < ConfigurationValidator
     AF ||= Longleaf::AppFields
-    
+
+    # @param config [Hash] hash containing the application configuration
+    def initialize(config)
+      super(config)
+    end
+
+    protected
     # Validates service mapping configuration to ensure that it is syntactically and referentially correct.
     # @param config [Hash] hash containing the application configuration
-    def self.validate_config(config)
-      
-      assert("Configuration must be a hash, but a #{config.class} was provided", config.class == Hash)
-      assert("Configuration must contain a root '#{AF::SERVICE_MAPPINGS}' key", config.key?(AF::SERVICE_MAPPINGS))
-      mappings = config[AF::SERVICE_MAPPINGS]
+    def validate
+      assert("Configuration must be a hash, but a #{@config.class} was provided", @config.class == Hash)
+      assert("Configuration must contain a root '#{AF::SERVICE_MAPPINGS}' key", @config.key?(AF::SERVICE_MAPPINGS))
+      mappings = @config[AF::SERVICE_MAPPINGS]
       return if mappings.nil? || mappings.empty?
       assert("'#{AF::SERVICE_MAPPINGS}' must be an array of mappings", mappings.is_a?(Array))
-      
-      service_names = config[AF::SERVICES].keys
-      location_names = config[AF::LOCATIONS].keys
-      
-      existing_paths = Array.new
+
+      service_names = @config[AF::SERVICES].keys
+      location_names = @config[AF::LOCATIONS].keys
+
       mappings.each do |mapping|
-        assert("Mapping must be a hash, but received #{mapping.inspect} instead", mapping.is_a?(Hash))
-        
-        validate_mapping_field(AF::LOCATIONS, mapping, location_names)
-        validate_mapping_field(AF::SERVICES, mapping, service_names)
+        register_on_failure do
+          assert("Mapping must be a hash, but received #{mapping.inspect} instead", mapping.is_a?(Hash))
+
+          register_on_failure { validate_mapping_field(AF::LOCATIONS, mapping, location_names) }
+          register_on_failure { validate_mapping_field(AF::SERVICES, mapping, service_names) }
+        end
       end
+
+      @result
     end
-    
+
     private
-    def self.validate_mapping_field(field, mapping, valid_values)
+    def validate_mapping_field(field, mapping, valid_values)
       assert("Mapping must contain a '#{field}' field", mapping.key?(field))
       field_values = mapping[field]
-      assert("Mapping '#{field}' field must be either a string or an array, but received '#{field_values.inspect}' instead",
+      assert("Mapping '#{field}' field must be either a string or an array, but received '#{field_values.class}' instead",
           field_values.is_a?(Array) || field_values.is_a?(String))
       assert("Mapping must specify one or more value in the '#{field}' field", !field_values.empty?)
-      
+
       check_values = field_values.is_a?(String) ? [field_values] : field_values
       check_values.each do |value|
-        assert("Mapping '#{field}' specifies value '#{value}', but no #{field} with that name exist",
-            valid_values.include?(value))
+        register_on_failure do
+          assert("Mapping specifies value '#{value}', but no #{field} with that name exist",
+              valid_values.include?(value))
+        end
       end
     end
   end
-end
+end

data/lib/longleaf/services/storage_location_manager.rb

@@ -1,37 +1,98 @@
-require_relative '../models/app_fields'
-require_relative '../models/storage_location'
+require 'longleaf/models/app_fields'
+require 'longleaf/models/storage_types'
+require 'longleaf/models/filesystem_storage_location'
+require 'longleaf/models/s3_storage_location'
+require 'longleaf/models/filesystem_metadata_location'
+require 'longleaf/errors'
 
-# Manager which loads and provides access to Longleaf::StorageLocation objects
 module Longleaf
+  # Manager which loads and provides access to {StorageLocation} objects
   class StorageLocationManager
     AF ||= Longleaf::AppFields
-    
+    ST ||= Longleaf::StorageTypes
+
+    # Hash mapping storage location names to {StorageLocation} objects
     attr_reader :locations
-    
+    # Mapping of storage types to storage location classes
+    @@storage_type_mappings = {
+        ST::FILESYSTEM_STORAGE_TYPE => Longleaf::FilesystemStorageLocation,
+        ST::S3_STORAGE_TYPE => Longleaf::S3StorageLocation
+      }
+    @@metadata_type_mappings = { ST::FILESYSTEM_STORAGE_TYPE => Longleaf::FilesystemMetadataLocation }
+
+    # @param config [Hash] has representation of the application configuration
     def initialize(config)
       raise ArgumentError.new("Configuration must be provided") if config&.empty?
 
       @locations = Hash.new
       config[AF::LOCATIONS].each do |name, properties|
-        path = properties[AF::LOCATION_PATH]
-        md_path = properties[AF::METADATA_PATH]
-        location = Longleaf::StorageLocation.new(name: name, path: path, metadata_path: md_path)
-        
-        @locations[name] = location
+        md_loc = instantiate_metadata_location(properties)
+
+        @locations[name] = instantiate_storage_location(name, properties, md_loc)
       end
       @locations.freeze
     end
-    
-    # Get the StorageLocation object which should contain the given path
+
+    # Get the {StorageLocation} object which should contain the given path
     # @return [Longleaf::StorageLocation] location containing the given path
     #    or nil if the path is not contained by a registered location.
     def get_location_by_path(path)
       raise ArgumentError.new("Path parameter is required") if path.nil? || path.empty?
       @locations.each do |name, location|
-        return location if path.start_with?(location.path) 
+        return location if location.contains?(path)
+      end
+
+      nil
+    end
+
+    # Get the {StorageLocation} object which should contain the given metadata path
+    # @return [Longleaf::StorageLocation] location containing the given metadata path
+    #    or nil if the path is not contained by a registered location.
+    def get_location_by_metadata_path(md_path)
+      raise ArgumentError.new("Metadata path parameter is required") if md_path.nil? || md_path.empty?
+      @locations.each do |name, location|
+        return location if location.metadata_location.contains?(md_path)
       end
-      
+
       nil
     end
+
+    # Raises a {StorageLocationUnavailableError} if the given path is not in a known storage location,
+    #    or if it is not within the expected location if provided
+    # @param path [String] file path
+    # @param expected_loc [String] name of the storage location which path should be contained by
+    # @raise [StorageLocationUnavailableError] if the path is not in a known/expected storage location
+    # @return [StorageLocation] the storage location which contains path, if it was within one.
+    def verify_path_in_location(path, expected_loc = nil)
+      location = get_location_by_path(path)
+      if location.nil?
+        raise StorageLocationUnavailableError.new("Path #{path} is not from a known storage location.")
+      elsif !expected_loc.nil? && expected_loc != location.name
+        raise StorageLocationUnavailableError.new("Path #{path} is not contained by storage location #{expected_loc}.")
+      end
+      location
+    end
+
+    private
+    def instantiate_metadata_location(loc_properties)
+      m_config = loc_properties[AF::METADATA_CONFIG]
+      m_type = m_config[AF::STORAGE_TYPE]
+      m_type = ST::FILESYSTEM_STORAGE_TYPE if m_type.nil?
+
+      m_class = @@metadata_type_mappings[m_type]
+      raise ArgumentError.new("Unknown metadata location type #{m_type}") if m_class.nil?
+
+      m_class.new(m_config)
+    end
+
+    def instantiate_storage_location(name, properties, md_loc)
+      s_type = properties[AF::STORAGE_TYPE]
+      s_type = ST::FILESYSTEM_STORAGE_TYPE if s_type.nil?
+
+      s_class = @@storage_type_mappings[s_type]
+      raise ArgumentError.new("Unknown storage location type #{s_type}") if s_class.nil?
+
+      s_class.new(name, properties, md_loc)
+    end
   end
-end
+end