sdr-client 2.12.0 → 2.13.0.beta1

data/lib/sdr_client/redesigned_client/job_status.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module SdrClient
+  class RedesignedClient
+    # Wraps operations waiting for results from jobs
+    class JobStatus
+      def initialize(job_id:)
+        @job_id = job_id
+        @result = {
+          status: 'not started',
+          output: {
+            errors: nil,
+            druid: ''
+          }
+        }
+      end
+
+      def complete?
+        @result = client.get(path: path)
+        @result[:status] == 'complete'
+      end
+
+      def druid
+        @result[:output][:druid]
+      end
+
+      def errors
+        @result[:output][:errors]
+      end
+
+      # Polls using exponential backoff, so as not to overrwhelm the server.
+      # @param [Float] secs_between_requests (3.0) initially, how many secs between polling requests
+      # @param [Integer] timeout_in_secs (180) timeout after this many secs
+      # @param [Float] backoff_factor (2.0) how quickly to backoff. This should be > 1.0 and probably ought to be <= 2.0
+      # @return [Boolean] true if successful false if unsuccessful.
+      def wait_until_complete(secs_between_requests: 3.0,
+                              timeout_in_secs: 180,
+                              backoff_factor: 2.0,
+                              max_secs_between_requests: 60)
+        poll_until_complete(secs_between_requests, timeout_in_secs, backoff_factor, max_secs_between_requests)
+        errors.nil?
+      end
+
+      private
+
+      attr_reader :job_id
+
+      def client
+        SdrClient::RedesignedClient.instance
+      end
+
+      def path
+        "/v1/background_job_results/#{job_id}"
+      end
+
+      def poll_until_complete(secs_between_requests, timeout_in_secs, backoff_factor, max_secs_between_requests)
+        interval = secs_between_requests
+        Timeout.timeout(timeout_in_secs) do
+          loop do
+            break if complete?
+
+            sleep(interval)
+            # Exponential backoff, limited to max_secs_between_requests
+            interval = [interval * backoff_factor, max_secs_between_requests].min
+          end
+        end
+      rescue Timeout::Error
+        @result[:output][:errors] = ["Not complete after #{timeout_in_secs} seconds"]
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/matching_file_grouping_strategy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # This strategy is for building one file set per set of similarly prefixed uploaded files
+    class MatchingFileGroupingStrategy
+      # @param [Array<SdrClient::RedesignedClient::DirectUploadResponse>] uploads the uploaded files to attach.
+      # @return [Array<Array<SdrClient::RedesignedClient::DirectUploadResponse>>] uploads the grouped uploaded files.
+      def self.run(uploads: [])
+        # Call `#values` on the result of the grouping operation because:
+        #   1) `StructuralGrouper#build_filesets` expects an array of arrays (not hashes); and
+        #   2) the keys aren't used anywhere
+        uploads.group_by do |ul|
+          ::File.join(::File.dirname(ul.filename), ::File.basename(ul.filename, '.*'))
+        end.values
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/metadata.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Build an object and then deposit it
+    class Metadata
+      def self.deposit(...)
+        new(...).deposit
+      end
+
+      # @param [String] apo object ID (druid) of the admin policy/APO
+      # @param [String] basepath the base path of the files (to make relative paths absolute)
+      # @param [String] source_id source ID
+      # @param [Hash] options optional parameters
+      # @option options [Array<String>] files a list of relative filepaths to upload
+      # @option options [Hash<String, Hash<String, String>>] files_metadata file name, hash of additional file metadata
+      def initialize(apo:, basepath:, source_id:, **options)
+        @apo = apo
+        @basepath = basepath
+        @source_id = source_id
+        @options = options
+      end
+
+      def deposit # rubocop:disable Metrics/MethodLength
+        structural_metadata = SdrClient::RedesignedClient::StructuralMetadataBuilder.build(
+          files: files, files_metadata: files_metadata, basepath: basepath
+        )
+        request_builder = SdrClient::RedesignedClient::RequestBuilder.new(
+          apo: apo,
+          source_id: source_id,
+          files_metadata: structural_metadata,
+          **options
+        )
+        client.deposit_model(
+          model: request_builder.to_cocina,
+          basepath: basepath,
+          files: files,
+          request_builder: request_builder,
+          **options
+        )
+      end
+
+      private
+
+      attr_reader :apo, :basepath, :source_id, :options
+
+      def client
+        SdrClient::RedesignedClient.instance
+      end
+
+      def files
+        options.fetch(:files, [])
+      end
+
+      def files_metadata
+        options.fetch(:files_metadata, {})
+      end
+
+      def accession
+        options.fetch(:accession, false)
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/operations/md5.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    module Operations
+      # MD5 for this file.
+      class MD5
+        NAME = 'md5'
+
+        def self.for(filepath:, **)
+          Digest::MD5.file(filepath).hexdigest
+        end
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/operations/mime_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    module Operations
+      # Mime-type for this file.
+      class MimeType
+        NAME = 'mime_type'
+
+        def self.for(filepath:, **)
+          argv = Shellwords.escape(filepath)
+          `file --mime-type -b #{argv}`.chomp
+        end
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/operations/sha1.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    module Operations
+      # SHA1 for this file.
+      class SHA1
+        NAME = 'sha1'
+
+        def self.for(filepath:, **)
+          Digest::SHA1.file(filepath).hexdigest
+        end
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/request_builder.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Builds a Cocina request object from metadata. This is what we send to the server when doing a deposit.
+    class RequestBuilder # rubocop:disable Metrics/ClassLength
+      # @param [String] apo the object ID of the administrative policy object
+      # @param [String] source_id the source ID of the object
+      # @param [Hash] options optional parameters
+      # @option options [String] label the required object label
+      # @option options [String] view the access level for viewing the object
+      # @option options [String] download the access level for downloading the object
+      # @option options [String] type (https://cocina.sul.stanford.edu/models/object) the required object type.
+      # @option options [String] use_and_reproduction the use and reproduction statement
+      # @option options [String] copyright the copyright statement
+      # @option options [String] collection the object ID of the collection object
+      # @option options [String] catkey the catalog key (from now unused Symphony ILS)
+      # @option options [String] folio_instance_hrid the instance ID from the Folio ILS
+      # @option options [String] viewing_direction the viewing direction (left to right, right to left)
+      # @option options [Date|nil] embargo_release_date when to release the embargo (or nil if none)
+      # @option options [String] embargo_access the access level for viewing the object after the embargo period
+      # @option options [String] embargo_download the access level for downloading the object after the embargo period
+      # @option options [Array<FileSet>] file_sets the file sets to attach.
+      # @option options [Hash<String, Hash<String, String>>] files_metadata file name, hash of additional file metadata
+      # Additional metadata includes access, preserve, shelve, publish, md5, sha1
+      def initialize(apo:, source_id:, **options)
+        @apo = apo
+        @source_id = source_id
+        @options = options
+      end
+
+      def to_h
+        {
+          access: access_struct,
+          type: type,
+          administrative: administrative,
+          identification: identification,
+          structural: structural,
+          version: 1,
+          label: label.nil? ? ':auto' : label
+        }
+      end
+
+      def to_cocina
+        Cocina::Models.build_request(to_h.with_indifferent_access)
+      end
+
+      # @param [String] filename
+      # @return [Hash] the metadata for the file
+      def for(filename)
+        files_metadata
+          .fetch(filename, {})
+          .with_indifferent_access
+          .tap do |metadata|
+          metadata[:view] = view unless metadata.key?(:view)
+          metadata[:download] = download unless metadata.key?(:download)
+        end
+      end
+
+      def type
+        options.fetch(:type, Cocina::Models::ObjectType.object)
+      end
+
+      attr_writer :file_sets
+
+      private
+
+      attr_reader :apo, :source_id, :options
+
+      def administrative
+        {
+          hasAdminPolicy: apo
+        }
+      end
+
+      def identification
+        { sourceId: source_id }.tap do |json|
+          json[:catalogLinks] = []
+          json[:catalogLinks] << { catalog: 'symphony', catalogRecordId: catkey, refresh: true } if catkey
+          if folio_instance_hrid
+            json[:catalogLinks] << { catalog: 'folio', catalogRecordId: folio_instance_hrid,
+                                     refresh: true }
+          end
+          json.delete(:catalogLinks) if json[:catalogLinks].empty?
+        end
+      end
+
+      def structural
+        {}.tap do |json|
+          json[:isMemberOf] = [collection] if collection
+          json[:contains] = file_sets.map(&:to_h) unless file_sets.empty?
+          json[:hasMemberOrders] = [{ viewingDirection: viewing_direction }] if viewing_direction
+        end
+      end
+
+      def access_struct # rubocop:disable Metrics/MethodLength
+        {
+          view: view,
+          download: download
+        }.tap do |json|
+          json[:useAndReproductionStatement] = use_and_reproduction if use_and_reproduction
+          json[:copyright] = copyright if copyright
+
+          if embargo_release_date
+            json[:embargo] = {
+              releaseDate: embargo_release_date.strftime('%FT%T%:z'),
+              view: embargo_access,
+              download: embargo_download
+            }
+          end
+        end
+      end
+
+      def view
+        options.fetch(:view, 'dark')
+      end
+
+      def download
+        options.fetch(:download, 'none')
+      end
+
+      def label
+        options[:label]
+      end
+
+      def use_and_reproduction
+        options[:use_and_reproduction]
+      end
+
+      def copyright
+        options[:copyright]
+      end
+
+      def collection
+        options[:collection]
+      end
+
+      def catkey
+        options[:catkey]
+      end
+
+      def folio_instance_hrid
+        options[:folio_instance_hrid]
+      end
+
+      def viewing_direction
+        options[:viewing_direction]
+      end
+
+      def embargo_release_date
+        options[:embargo_release_date]
+      end
+
+      def embargo_access
+        options.fetch(:embargo_access, 'world')
+      end
+
+      def embargo_download
+        options.fetch(:embargo_download, 'world')
+      end
+
+      def file_sets
+        @file_sets ||= options.fetch(:file_sets, [])
+      end
+
+      def files_metadata
+        options.fetch(:files_metadata, {})
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/single_file_grouping_strategy.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # This strategy is for building one file set per uploaded file
+    class SingleFileGroupingStrategy
+      # @param [Array<SdrClient::RedesignedClient::DirectUploadResponse>] uploads the uploaded files to attach.
+      # @return [Array<Array<SdrClient::RedesignedClient::DirectUploadResponse>>] uploads the grouped uploaded files.
+      def self.run(uploads: [])
+        uploads.map { |upload| [upload] }
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/structural_grouper.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Builds and constructs the structural metadata given upload responses (file
+    # IDs, file set grouping strategies, etc.)
+    class StructuralGrouper
+      def self.group(...)
+        new(...).group
+      end
+
+      # @param [RequestBuilder] request_biulder a request builder instance
+      # @param [Array<DirectUploadResponse>] upload_responses upload response instances
+      # @param [String] grouping_strategy what strategy will be used to group files
+      # @param [String] file_set_strategy what strategy will be used to group file sets
+      def initialize(request_builder:, upload_responses:, grouping_strategy:, file_set_strategy: nil) # rubocop:disable Metrics/MethodLength
+        @request_builder = request_builder
+        @upload_responses = upload_responses
+        @grouping_strategy = if grouping_strategy == 'filename'
+                               SdrClient::RedesignedClient::MatchingFileGroupingStrategy
+                             else
+                               SdrClient::RedesignedClient::SingleFileGroupingStrategy
+                             end
+        @file_set_strategy = if file_set_strategy == 'image'
+                               SdrClient::RedesignedClient::ImageFileSetStrategy
+                             else
+                               SdrClient::RedesignedClient::FileTypeFileSetStrategy
+                             end
+      end
+
+      def group
+        request_builder
+          .tap { |request| request.file_sets = build_filesets(uploads: upload_responses) }
+          .to_cocina
+      end
+
+      private
+
+      attr_reader :request_builder, :file_set_strategy, :grouping_strategy, :upload_responses
+
+      # @param [Array<SdrClient::RedesignedClient::DirectUploadResponse>] uploads the uploaded files to attach.
+      # @return [Array<SdrClient::RedesignedClient::FileSet>] the uploads transformed to filesets
+      def build_filesets(uploads:)
+        grouping_strategy
+          .run(uploads: uploads)
+          .map
+          .with_index(1) do |upload_group, i|
+          SdrClient::RedesignedClient::FileSet.new(uploads: upload_group,
+                                                   uploads_metadata: metadata_group(upload_group),
+                                                   label: label(i),
+                                                   type_strategy: file_set_strategy)
+        end
+      end
+
+      def label(index)
+        case request_builder.type
+        when Cocina::Models::ObjectType.book
+          "Page #{index}"
+        else
+          "Object #{index}"
+        end
+      end
+
+      # Get the metadata for the files belonging to a fileset
+      def metadata_group(upload_group)
+        upload_group.each_with_object({}) do |upload, obj|
+          obj[upload.filename] = request_builder.for(upload.filename)
+        end
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/structural_metadata_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Build basic metadata for files, iterating over a series of operations
+    # The available options are here: https://github.com/sul-dlss/sdr-client/blob/v0.8.1/lib/sdr_client/deposit/file.rb#L8-L10
+    class StructuralMetadataBuilder
+      OPERATIONS = [
+        Operations::MimeType,
+        Operations::MD5,
+        Operations::SHA1
+      ].freeze
+      private_constant :OPERATIONS
+
+      # @param (see #initialize)
+      # @return (see #build)
+      def self.build(files:, files_metadata:, basepath:)
+        new(files: files, files_metadata: files_metadata.dup, basepath: basepath).build
+      end
+
+      # @param [Array<String>] files the list of relative filepaths for which to generate metadata
+      def initialize(files:, files_metadata:, basepath:)
+        @files = files
+        @files_metadata = files_metadata
+        @basepath = basepath
+      end
+
+      # @return [Hash<String, Hash<String, String>>] a map of relative filepaths to a map of metadata
+      def build
+        files.each do |filepath|
+          OPERATIONS.each do |operation|
+            result = operation.for(filepath: absolute_filepath_for(filepath))
+            next if result.nil?
+
+            files_metadata[filepath] ||= {}
+            files_metadata[filepath][operation::NAME] = result
+          end
+        end
+        files_metadata
+      end
+
+      private
+
+      attr_reader :files, :files_metadata, :basepath
+
+      def absolute_filepath_for(filepath)
+        ::File.join(basepath, filepath)
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/unexpected_response.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Handles unexpected responses
+    class UnexpectedResponse
+      # Raised when there is a request error (e.g.: a cocina-models version mismatch)
+      class BadRequest < StandardError; end
+      # Raised when there is a problem with the credentials
+      class Unauthorized < StandardError; end
+
+      # @param [Faraday::Response] response
+      def self.call(response)
+        case response.status
+        when 400
+          raise BadRequest, "There was an error with your request: #{response.body}"
+        when 401
+          raise Unauthorized, 'There was an error with your credentials.'
+        else
+          raise "unexpected response: #{response.status} #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/update_dro_with_file_identifiers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Updates a DRO so that the structural metadata references the uploaded file ids
+    class UpdateDroWithFileIdentifiers
+      # @param [Cocina::Model::RequestDRO] request_dro for depositing
+      # @param [Array<DirectUploadResponse>] upload_responses the responses from uploading files
+      # @return [Cocina::Models::RequestDRO]
+      def self.update(request_dro:, upload_responses:)
+        # Manipulating request_dro as hash since immutable
+        structural = request_dro.to_h[:structural]
+        return request_dro.new({}) unless structural
+
+        signed_ids = signed_id_map(upload_responses)
+        request_dro.new(structural: updated_structural(structural, signed_ids))
+      end
+
+      def self.signed_id_map(upload_responses)
+        upload_responses.to_h { |response| [response.filename, response.signed_id] }
+      end
+      private_class_method :signed_id_map
+
+      def self.updated_structural(structural, signed_ids)
+        structural[:contains].each do |file_set|
+          file_set[:structural][:contains].each do |file|
+            file[:externalIdentifier] = signed_ids[file[:filename]] if signed_ids.key?(file[:filename])
+          end
+        end
+        structural
+      end
+      private_class_method :updated_structural
+    end
+  end
+end

data/lib/sdr_client/redesigned_client/update_resource.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SdrClient
+  class RedesignedClient
+    # Updates a resource (metadata) in SDR
+    class UpdateResource
+      RESOURCE_PATH = '/v1/resources/%<id>s'
+
+      def self.run(...)
+        new(...).run
+      end
+
+      # @param [Cocina::Models::DRO] model
+      # @param [String] version_description
+      def initialize(model:, version_description: nil)
+        @model = model
+        @version_description = version_description
+      end
+
+      # @return [String] job id for the background job result
+      def run # rubocop:disable Metrics/MethodLength
+        json = model.to_json
+        logger.debug("Starting update with model: #{json}")
+
+        response_hash = client.put(
+          path: path,
+          body: json,
+          headers: { 'X-Cocina-Models-Version' => Cocina::Models::VERSION },
+          params: request_params,
+          expected_status: 202
+        )
+
+        logger.info("Response from server: #{response_hash}")
+
+        response_hash.fetch('jobId')
+      end
+
+      private
+
+      attr_reader :model, :version_description
+
+      def client
+        SdrClient::RedesignedClient.instance
+      end
+
+      def logger
+        SdrClient::RedesignedClient.config.logger
+      end
+
+      def path
+        format(RESOURCE_PATH, id: model.externalIdentifier)
+      end
+
+      def request_params
+        return { 'versionDescription' => version_description } if version_description
+
+        {}
+      end
+    end
+  end
+end