longleaf 0.3.0 → 1.0.0

data/lib/longleaf/services/s3_location_validator.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+require 'longleaf/errors'
+require 'longleaf/helpers/s3_uri_helper'
+
+module Longleaf
+  # Validates the configuration of a s3 based location
+  class S3LocationValidator
+    def self.validate(p_validator, name, path_prop, section_name, path)
+      base_msg = "Storage location '#{name}' specifies invalid #{section_name} '#{path_prop}' property: "
+      p_validator.assert(base_msg + 'Path must not be empty', !path.nil? && !path.to_s.strip.empty?)
+      begin
+        bucket_name = S3UriHelper.extract_bucket(path)
+        p_validator.assert(base_msg + 'Path must specify a bucket', !bucket_name.nil?)
+      rescue ArgumentError => e
+        p_validator.fail(base_msg + e.message)
+      end
+    end
+  end
+end

data/lib/longleaf/services/service_definition_validator.rb

@@ -10,21 +10,29 @@ module Longleaf
     SF ||= Longleaf::ServiceFields
     AF ||= Longleaf::AppFields
 
+    # @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)
 
       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))
+        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?)
+          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

data/lib/longleaf/services/service_manager.rb

@@ -68,26 +68,18 @@ module Longleaf
     # @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)
-      # If service not recorded for file, then it is needed
-      present_services = md_rec.list_services
-      return true unless present_services.include?(service_name)
-
       service_rec = md_rec.service(service_name)
-
-      return true if service_rec.run_needed
-      return true if service_rec.timestamp.nil?
+      return true if !service_rec.nil? && service_rec.run_needed
 
       definition = @definition_manager.services[service_name]
 
-      # Check if the amount of time defined in frequency has passed since the service timestamp
-      frequency = definition.frequency
-      unless frequency.nil?
-        service_timestamp = service_rec.timestamp
-        now = ServiceDateHelper.formatted_timestamp
+      next_run = ServiceDateHelper.next_run_needed(md_rec, definition)
 
-        return true if now > ServiceDateHelper.add_to_timestamp(service_timestamp, frequency)
-      end
-      false
+      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

data/lib/longleaf/services/service_mapping_validator.rb

@@ -9,40 +9,51 @@ module Longleaf
   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
+      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))
+        register_on_failure do
+          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 { validate_mapping_field(AF::LOCATIONS, mapping, location_names) }
+          register_on_failure { validate_mapping_field(AF::SERVICES, mapping, service_names) }
+        end
       end
+
+      @result
     end
 
-    def self.validate_mapping_field(field, mapping, valid_values)
+    private
+    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
-
-    private_class_method :validate_mapping_field
   end
 end

data/lib/longleaf/services/storage_location_manager.rb

@@ -1,14 +1,24 @@
 require 'longleaf/models/app_fields'
-require 'longleaf/models/storage_location'
+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'
 
 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)
@@ -16,15 +26,9 @@ module Longleaf
 
       @locations = Hash.new
       config[AF::LOCATIONS].each do |name, properties|
-        path = properties[AF::LOCATION_PATH]
-        md_path = properties[AF::METADATA_PATH]
-        md_digests = properties[AF::METADATA_DIGESTS]
-        location = Longleaf::StorageLocation.new(name: name,
-            path: path,
-            metadata_path: md_path,
-            metadata_digests: md_digests)
-
-        @locations[name] = location
+        md_loc = instantiate_metadata_location(properties)
+
+        @locations[name] = instantiate_storage_location(name, properties, md_loc)
       end
       @locations.freeze
     end
@@ -35,7 +39,7 @@ module Longleaf
     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
@@ -47,7 +51,7 @@ module Longleaf
     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 md_path.start_with?(location.metadata_path)
+        return location if location.metadata_location.contains?(md_path)
       end
 
       nil
@@ -68,5 +72,27 @@ module Longleaf
       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

data/lib/longleaf/services/storage_location_validator.rb

@@ -1,63 +1,74 @@
 require 'pathname'
-require 'longleaf/models/storage_location'
 require 'longleaf/models/app_fields'
+require 'longleaf/models/storage_types'
 require 'longleaf/errors'
 require_relative 'configuration_validator'
-require 'longleaf/services/storage_path_validator'
+require 'longleaf/services/filesystem_location_validator'
+require 'longleaf/services/s3_location_validator'
 
 module Longleaf
   # Validates application configuration of storage locations
   class StorageLocationValidator < ConfigurationValidator
     AF ||= Longleaf::AppFields
+    ST ||= Longleaf::StorageTypes
 
+    @@storage_type_mappings = {
+        ST::FILESYSTEM_STORAGE_TYPE => Longleaf::FilesystemLocationValidator,
+        ST::S3_STORAGE_TYPE => Longleaf::S3LocationValidator
+      }
+
+    # @param config [Hash] hash containing the application configuration
+    def initialize(config)
+      super(config)
+      @existing_paths = Array.new
+    end
+
+    protected
     # Validates configuration to ensure that it is syntactically correct and does not violate
     # schema and uniqueness 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::LOCATIONS}' key", config.key?(AF::LOCATIONS))
-      locations = config[AF::LOCATIONS]
+    def validate
+      assert("Configuration must be a hash, but a #{@config.class} was provided", @config.class == Hash)
+      assert("Configuration must contain a root '#{AF::LOCATIONS}' key", @config.key?(AF::LOCATIONS))
+      locations = @config[AF::LOCATIONS]
       assert("'#{AF::LOCATIONS}' must be a hash of locations", locations.class == Hash)
 
-      existing_paths = Array.new
       locations.each do |name, properties|
-        assert("Name of storage location must be a string, but was of type #{name.class}", name.instance_of?(String))
-        assert("Storage location '#{name}' must be a hash, but a #{properties.class} was provided", properties.is_a?(Hash))
+        register_on_failure do
+          assert("Name of storage location must be a string, but was of type #{name.class}", name.instance_of?(String))
+          assert("Storage location '#{name}' must be a hash, but a #{properties.class} was provided", properties.is_a?(Hash))
+
+          register_on_failure { assert_path_property_valid(name, AF::LOCATION_PATH, properties, 'location') }
 
-        assert_path_property_valid(name, AF::LOCATION_PATH, properties, existing_paths)
-        assert_path_property_valid(name, AF::METADATA_PATH, properties, existing_paths)
+          assert("Metadata location must be present for location '#{name}'", properties.key?(AF::METADATA_CONFIG))
+          assert_path_property_valid(name, AF::LOCATION_PATH, properties[AF::METADATA_CONFIG], 'metadata')
+        end
       end
+
+      @result
     end
 
-    def self.assert_path_property_valid(name, path_prop, properties, existing_paths)
+    private
+    def assert_path_property_valid(name, path_prop, properties, section_name)
       path = properties[path_prop]
-      begin
-        StoragePathValidator::validate(path)
-      rescue InvalidStoragePathError => err
-        raise ConfigurationError.new(
-            "Storage location '#{name}' specifies invalid '#{path_prop}' property: #{err.message}")
-      end
-      assert("Storage location '#{name}' must specify a '#{path_prop}' property", !path.nil? && !path.empty?)
-      assert("Storage location '#{name}' must specify an absolute path for property '#{path_prop}'",
-          Pathname.new(path).absolute? && !path.include?('/..'))
-      assert("Storage location '#{name}' specifies a '#{path_prop}' directory which does not exist", Dir.exist?(path))
+
+      storage_type = properties[AF::STORAGE_TYPE] || ST::DEFAULT_STORAGE_TYPE
+      type_validator = @@storage_type_mappings[storage_type]
+      type_validator.validate(self, name, path_prop, section_name, path)
 
       # Ensure paths have trailing slash to avoid matching on partial directory names
       path += '/' unless path.end_with?('/')
       # Verify that the (metadata_)path property's value is not inside of another storage location or vice versa
-      existing_paths.each do |existing|
+      @existing_paths.each do |existing|
         if existing.start_with?(path) || path.start_with?(existing)
-          msg = "Location '#{name}' defines property #{path_prop} with value '#{path}'" \
+          msg = "Location '#{name}' defines property #{section_name} #{path_prop} with value '#{path}'" \
                 " which overlaps with another configured path '#{existing}'." \
-                " Storage locations must not define #{AF::LOCATION_PATH} or #{AF::METADATA_PATH}" \
+                " Storage locations must not define #{AF::LOCATION_PATH}" \
                 " properties which are contained by another location property"
-          raise ConfigurationError.new(msg)
+          fail(msg)
         end
       end
 
-      existing_paths << path
+      @existing_paths << path
     end
-
-    private_class_method :assert_path_property_valid
   end
 end

data/lib/longleaf/specs/config_builder.rb

@@ -27,14 +27,21 @@ module Longleaf
     # @param path [String] value for the 'path' field
     # @param md_path [String] value for the 'metadata_path' field
     # @return this builder
-    def with_location(name:, path: '/file/path/', md_path: '/metadata/path/', md_digests: nil)
+    def with_location(name:, path: '/file/path/', s_type: nil, md_path: '/metadata/path/', md_type: nil, md_digests: nil)
       @config[AF::LOCATIONS] = Hash.new unless @config.key?(AF::LOCATIONS)
 
       location = {}
       @config[AF::LOCATIONS][name] = location
       location[AF::LOCATION_PATH] = path unless path.nil?
-      location[AF::METADATA_PATH] = md_path unless md_path.nil?
-      location[AF::METADATA_DIGESTS] = md_digests unless md_digests.nil?
+      location[AF::STORAGE_TYPE] = s_type unless s_type.nil?
+
+      if !md_path.nil?
+        md_loc = { AF::LOCATION_PATH => md_path }
+        location[AF::METADATA_CONFIG] = md_loc
+
+        md_loc[AF::METADATA_DIGESTS] = md_digests unless md_digests.nil?
+        md_loc[AF::STORAGE_TYPE] = md_type unless md_type.nil?
+      end
       self
     end
 

data/lib/longleaf/specs/config_validator_helpers.rb

@@ -0,0 +1,16 @@
+module Longleaf
+  module ConfigValidatorHelpers
+    def fails_validation_with_error(validator, *error_messages)
+      result = validator.validate_config
+      expect(result.valid?).to be false
+      error_messages.each do |error_message|
+        expect(result.errors).to include(error_message)
+      end
+    end
+
+    def passes_validation(validator)
+      result = validator.validate_config
+      expect(result.valid?).to eq(true), "expected validation to pass, but received errors:\n#{result.errors&.join("\n")}"
+    end
+  end
+end

data/lib/longleaf/specs/metadata_builder.rb

@@ -45,6 +45,7 @@ module Longleaf
 
     def with_properties(properties)
       @properties = properties
+      self
     end
 
     # @return the constructed metadata record

data/lib/longleaf/version.rb

@@ -1,3 +1,3 @@
 module Longleaf
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/longleaf.gemspec

@@ -29,10 +29,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency "thor", "~> 0.20.0"
   spec.add_dependency "yard", "~> 0.9.16"
   spec.add_dependency "sequel", "~> 5.20"
+  spec.add_dependency "aws-sdk-s3", "~> 1.56"
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler", "~> 2.1"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.8"
+  spec.add_development_dependency "rspec-core", "~> 3.8"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.4"
   spec.add_development_dependency "factory_bot", "~> 5.0"
   spec.add_development_dependency "aruba", "~> 0.14.9"

data/mkdocs.yml

@@ -1,9 +1,10 @@
 site_name: Longleaf Documentation
 site_url: https://unc-libraries.github.io/longleaf-preservation
 theme: readthedocs
-#repo_name: 'UNC-Libraries/Longleaf-preservation'
+# repo_name: 'UNC-Libraries/Longleaf-preservation'
 #setting edit_uri to empty string removes the "Edit in" link in upper right hand corner of pages, but keeps the Github link to repo in the bottom of sidepane
 repo_url: https://github.com/UNC-Libraries/longleaf-preservation/
+site_description: Longleaf is a command-line tool which allows users to configure a set of storage locations and define custom sets of preservation services to run on their contents. These services are executed in response to applicable preservation events issued by clients. Its primary goal is to provide tools to create a simple and customizable preservation environment.
 edit_uri: ''
 
 # include extra css file, in docs/

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: longleaf
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ben Pennell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-30 00:00:00.000000000 Z
+date: 2020-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -52,20 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.20'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.56'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.56'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
@@ -238,7 +266,6 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - ".yardopts"
 - Gemfile
 - LICENSE.txt
@@ -344,10 +371,12 @@ files:
 - exe/longleaf
 - lib/longleaf.rb
 - lib/longleaf/candidates/file_selector.rb
+- lib/longleaf/candidates/manifest_digest_provider.rb
 - lib/longleaf/candidates/registered_file_selector.rb
 - lib/longleaf/candidates/service_candidate_filesystem_iterator.rb
 - lib/longleaf/candidates/service_candidate_index_iterator.rb
 - lib/longleaf/candidates/service_candidate_locator.rb
+- lib/longleaf/candidates/single_digest_provider.rb
 - lib/longleaf/cli.rb
 - lib/longleaf/commands/deregister_command.rb
 - lib/longleaf/commands/preserve_command.rb
@@ -361,7 +390,10 @@ files:
 - lib/longleaf/events/event_status_tracking.rb
 - lib/longleaf/events/preserve_event.rb
 - lib/longleaf/events/register_event.rb
+- lib/longleaf/helpers/case_insensitive_hash.rb
 - lib/longleaf/helpers/digest_helper.rb
+- lib/longleaf/helpers/s3_uri_helper.rb
+- lib/longleaf/helpers/selection_options_parser.rb
 - lib/longleaf/helpers/service_date_helper.rb
 - lib/longleaf/indexing/index_manager.rb
 - lib/longleaf/indexing/sequel_index_driver.rb
@@ -369,23 +401,32 @@ files:
 - lib/longleaf/logging/redirecting_logger.rb
 - lib/longleaf/models/app_fields.rb
 - lib/longleaf/models/file_record.rb
+- lib/longleaf/models/filesystem_metadata_location.rb
+- lib/longleaf/models/filesystem_storage_location.rb
 - lib/longleaf/models/md_fields.rb
+- lib/longleaf/models/metadata_location.rb
 - lib/longleaf/models/metadata_record.rb
+- lib/longleaf/models/s3_storage_location.rb
 - lib/longleaf/models/service_definition.rb
 - lib/longleaf/models/service_fields.rb
 - lib/longleaf/models/service_record.rb
 - lib/longleaf/models/storage_location.rb
+- lib/longleaf/models/storage_types.rb
 - lib/longleaf/models/system_config_fields.rb
 - lib/longleaf/preservation_services/file_check_service.rb
 - lib/longleaf/preservation_services/fixity_check_service.rb
 - lib/longleaf/preservation_services/rsync_replication_service.rb
+- lib/longleaf/preservation_services/s3_replication_service.rb
 - lib/longleaf/services/application_config_deserializer.rb
 - lib/longleaf/services/application_config_manager.rb
 - lib/longleaf/services/application_config_validator.rb
 - lib/longleaf/services/configuration_validator.rb
+- lib/longleaf/services/filesystem_location_validator.rb
 - lib/longleaf/services/metadata_deserializer.rb
 - lib/longleaf/services/metadata_persistence_manager.rb
 - lib/longleaf/services/metadata_serializer.rb
+- lib/longleaf/services/metadata_validator.rb
+- lib/longleaf/services/s3_location_validator.rb
 - lib/longleaf/services/service_class_cache.rb
 - lib/longleaf/services/service_definition_manager.rb
 - lib/longleaf/services/service_definition_validator.rb
@@ -394,8 +435,8 @@ files:
 - lib/longleaf/services/service_mapping_validator.rb
 - lib/longleaf/services/storage_location_manager.rb
 - lib/longleaf/services/storage_location_validator.rb
-- lib/longleaf/services/storage_path_validator.rb
 - lib/longleaf/specs/config_builder.rb
+- lib/longleaf/specs/config_validator_helpers.rb
 - lib/longleaf/specs/custom_matchers.rb
 - lib/longleaf/specs/file_helpers.rb
 - lib/longleaf/specs/metadata_builder.rb
@@ -423,8 +464,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Longleaf preservation services tool