dor-services 6.8.0 → 7.0.0

data/lib/dor/services/file_metadata_merge_service.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  # Merges contentMetadata from several objects into one.
-  class FileMetadataMergeService
-    extend Deprecation
-    self.deprecation_horizon = 'dor-services version 7.0.0'
-
-    # @param [Array<String>] secondary_druids ids of the secondary objects that will get their contentMetadata merged into this one
-    def self.copy_file_resources(primary, secondary_druids)
-      merge_service = FileMetadataMergeService.new primary, secondary_druids
-      merge_service.copy_file_resources
-    end
-
-    def initialize(primary, secondary_druids)
-      @pid = primary.pid
-      content_metadata = primary.contentMetadata
-      content_metadata.ng_xml_will_change!
-      @primary_cm = content_metadata.ng_xml
-      @secondary_druids = secondary_druids
-    end
-
-    # Appends contentMetadata file resources from the source objects to this object
-    def copy_file_resources
-      base_id = primary_cm.at_xpath('/contentMetadata/@objectId').value
-      max_sequence = primary_cm.at_xpath('/contentMetadata/resource[last()]/@sequence').value.to_i
-
-      secondary_druids.each do |src_pid|
-        source_obj = Dor.find src_pid
-        source_cm = source_obj.contentMetadata.ng_xml
-
-        # Copy the resources from each source object
-        source_cm.xpath('/contentMetadata/resource').each do |old_resource|
-          max_sequence += 1
-          resource_copy = old_resource.clone
-          resource_copy['sequence'] = max_sequence.to_s
-
-          # Append sequence number to each secondary filename, then
-          # look for filename collisions with the primary object
-          resource_copy.xpath('file').each do |secondary_file|
-            secondary_file['id'] = SecondaryFileNameService.create(secondary_file['id'], max_sequence)
-
-            if primary_cm.at_xpath("//file[@id = '#{secondary_file['id']}']")
-              raise Dor::Exception, "File '#{secondary_file['id']}' from secondary object #{src_pid} already exist in primary object: #{pid}"
-            end
-          end
-
-          if old_resource['type']
-            resource_copy['id'] = "#{old_resource['type']}_#{max_sequence}"
-          else
-            resource_copy['id'] = "#{base_id}_#{max_sequence}"
-          end
-
-          lbl = old_resource.at_xpath 'label'
-          resource_copy.at_xpath('label').content = "#{Regexp.last_match(1)} #{max_sequence}" if lbl && lbl.text =~ /^(.*)\s+\d+$/
-
-          primary_cm.at_xpath('/contentMetadata/resource[last()]').add_next_sibling resource_copy
-          attr_node = primary_cm.create_element 'attr', src_pid, name: 'mergedFromPid'
-          resource_copy.first_element_child.add_previous_sibling attr_node
-          attr_node = primary_cm.create_element 'attr', old_resource['id'], name: 'mergedFromResource'
-          resource_copy.first_element_child.add_previous_sibling attr_node
-        end
-      end
-    end
-    deprecation_deprecate copy_file_resources: 'No longer used by any DLSS code'
-
-    private
-
-    attr_reader :secondary_druids, :primary_cm, :pid
-  end
-end

data/lib/dor/services/indexing_service.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark'
-
-module Dor
-  class IndexingService
-    extend Deprecation
-
-    class ReindexError < RuntimeError; end
-
-    ##
-    # Returns a Logger instance for recording info about indexing attempts
-    # @yield attempt to execute 'entry_id_block' and use the result as an extra identifier for the log
-    #   entry.  a placeholder will be used otherwise. 'request.uuid' might be useful in a Rails app.
-    def self.generate_index_logger(&entry_id_block)
-      Deprecation.warn(self, 'generate_index_logger is deprecated and will be removed in dor-services version 7')
-      index_logger = Logger.new(Config.indexing_svc.log, Config.indexing_svc.log_rotation_interval)
-      index_logger.formatter = proc do |_severity, datetime, _progname, msg|
-        date_format_str = Config.indexing_svc.log_date_format_str
-        entry_id = begin begin
-                           entry_id_block.call
-                         rescue StandardError
-                           '---'
-                         end end
-        "[#{entry_id}] [#{datetime.utc.strftime(date_format_str)}] #{msg}\n"
-      end
-      index_logger
-    end
-
-    # memoize the loggers we create in a hash, init with a nil default logger
-    @@loggers = { default: nil }
-
-    def self.default_index_logger
-      Deprecation.warn(self, 'default_index_logger is deprecated and will be removed in dor-services version 7')
-      @@loggers[:default] ||= generate_index_logger
-    end
-
-    # takes a Dor object and indexes it to solr.  doesn't commit automatically.
-    def self.reindex_object(obj, options = {})
-      Deprecation.warn(self, 'reindex_pid is deprecated and will be removed in dor-services 7.')
-      solr_doc = obj.to_solr
-      Dor::SearchService.solr.add(solr_doc, options)
-      solr_doc
-    end
-
-    # Use the dor-indexing-app service to reindex a pid
-    # @param [String] pid the druid
-    # @raise [ReindexError] on failure
-    def self.reindex_pid_remotely(pid)
-      Deprecation.warn(self, 'reindex_pid_remotely is deprecated and will be removed in dor-services 7.')
-
-      pid = "druid:#{pid}" unless pid =~ /^druid:/
-      realtime = Benchmark.realtime do
-        with_retries(max_tries: 3, rescue: [RestClient::Exception, Errno::ECONNREFUSED]) do
-          RestClient.post("#{Config.dor_indexing_app.url}/reindex/#{pid}", '')
-        end
-      end
-      default_index_logger.info "successfully updated index for #{pid} in #{'%.3f' % realtime}s"
-    rescue RestClient::Exception, Errno::ECONNREFUSED => e
-      msg = "failed to reindex #{pid}: #{e}"
-      default_index_logger.error msg
-      raise ReindexError.new(msg)
-    rescue StandardError => e
-      default_index_logger.error "failed to reindex #{pid}: #{e}"
-      raise
-    end
-
-    # retrieves a single Dor object by pid, indexes the object to solr, does some logging
-    # (will use a default logger if one is not provided).  doesn't commit automatically.
-    #
-    # WARNING/TODO:  the tests indicate that the "rescue Exception" block at the end will
-    # get skipped, and the thrown exception (e.g. SystemStackError) will not be logged.  since
-    # that's the only consequence, and the exception bubbles up as we would want anyway, it
-    # doesn't seem worth blocking refactoring.  see https://github.com/sul-dlss/dor-services/issues/156
-    # extra logging in this case would be nice, but centralized indexing that's otherwise
-    # fully functional is nicer.
-    #
-    # @overload reindex_pid(pid, index_logger, options = {})
-    # @overload reindex_pid(pid, index_logger, should_raise_errors, options = {})
-    # @overload reindex_pid(pid, options = {})
-    def self.reindex_pid(pid, *args)
-      Deprecation.warn(self, 'reindex_pid is deprecated and will be removed in dor-services 7.')
-      options = {}
-      options = args.pop if args.last.is_a? Hash
-
-      if args.length > 0
-        warn 'Dor::IndexingService.reindex_pid with primitive arguments is deprecated; pass e.g. { logger: logger, raise_errors: bool } instead'
-        index_logger, should_raise_errors = args
-        index_logger ||= default_index_logger
-        should_raise_errors = true if should_raise_errors.nil?
-      else
-        index_logger = options.fetch(:logger, default_index_logger)
-        should_raise_errors = options.fetch(:raise_errors, true)
-      end
-
-      obj = nil
-      solr_doc = nil
-
-      # benchmark how long it takes to load the object
-      load_stats = Benchmark.measure('find') do
-        obj = Dor.find pid
-      end.format('%n realtime %rs total CPU %ts').gsub(/[\(\)]/, '')
-
-      # benchmark how long it takes to convert the object to a Solr document
-      to_solr_stats = Benchmark.measure('to_solr') do
-        solr_doc = reindex_object obj, options
-      end.format('%n realtime %rs total CPU %ts').gsub(/[\(\)]/, '')
-
-      index_logger.info "successfully updated index for #{pid} (metrics: #{load_stats}; #{to_solr_stats})"
-
-      solr_doc
-    rescue StandardError => se
-      if se.is_a? ActiveFedora::ObjectNotFoundError
-        index_logger.warn "failed to update index for #{pid}, object not found in Fedora"
-      else
-        index_logger.warn "failed to update index for #{pid}, unexpected StandardError, see main app log: #{se.backtrace}"
-      end
-      raise se if should_raise_errors
-    rescue Exception => ex
-      index_logger.error "failed to update index for #{pid}, unexpected Exception, see main app log: #{ex.backtrace}"
-      raise ex # don't swallow anything worse than StandardError
-    end
-
-    # given a list of pids, retrieve those objects from fedora, index each to solr, optionally commit
-    def self.reindex_pid_list(pid_list, should_commit = false)
-      Deprecation.warn(self, 'reindex_pid_list is deprecated and will be removed in dor-services 7')
-      pid_list.each { |pid| reindex_pid pid, raise_errors: false } # use the default logger, don't let individual errors nuke the rest of the batch
-      ActiveFedora.solr.conn.commit if should_commit
-    end
-  end
-end

data/lib/dor/services/merge_service.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class MergeService
-    extend Deprecation
-    self.deprecation_horizon = 'dor-services version 7.0.0'
-
-    def self.merge_into_primary(primary_druid, secondary_druids, tag, logger = nil)
-      # TODO: test the secondary_obj to see if we've processed it already
-      merge_service = Dor::MergeService.new primary_druid, secondary_druids, tag, logger
-      merge_service.check_objects_editable
-      merge_service.move_metadata_and_content
-      merge_service.decommission_secondaries
-      # kick off commonAccessioning for the primary?
-    end
-
-    def initialize(primary_druid, secondary_pids, tag, logger = nil)
-      @primary = Dor.find primary_druid
-      @secondary_pids = secondary_pids
-      @secondary_objs = secondary_pids.map { |pid| Dor.find pid }
-      if logger.nil?
-        @logger = Logger.new(STDERR)
-      else
-        @logger = logger
-      end
-      @tag = tag
-    end
-
-    def check_objects_editable
-      raise Dor::Exception, "Primary object is not editable: #{@primary.pid}" unless @primary.allows_modification?
-
-      non_editable = @secondary_objs.detect { |obj| !obj.allows_modification? }
-      raise Dor::Exception, "Secondary object is not editable: #{non_editable.pid}" if non_editable
-    end
-    deprecation_deprecate check_objects_editable: 'No longer used by any DLSS code'
-
-    def move_metadata_and_content
-      FileMetadataMergeService.copy_file_resources @primary, @secondary_pids
-      @primary.save
-      copy_workspace_content
-    end
-    deprecation_deprecate move_metadata_and_content: 'No longer used by any DLSS code'
-
-    # Copies the content from the secondary object workspace to the primary object's workspace
-    #   Depends on Dor::Config.stacks.local_workspace_root
-    def copy_workspace_content
-      pri_file = @primary.contentMetadata.resource(0).file(0).id.first
-      pri_druid = DruidTools::Druid.new @primary.pid, Dor::Config.stacks.local_workspace_root
-      dest_path = pri_druid.find_filelist_parent 'content', pri_file
-      primary_cm = @primary.contentMetadata.ng_xml
-
-      @secondary_objs.each do |secondary|
-        sec_druid = DruidTools::Druid.new secondary.pid, Dor::Config.stacks.local_workspace_root
-        secondary.contentMetadata.ng_xml.xpath('//resource').each do |src_resource|
-          primary_resource = primary_cm.at_xpath "//resource[attr[@name = 'mergedFromPid']/text() = '#{secondary.pid}' and
-                                                             attr[@name = 'mergedFromResource']/text() = '#{src_resource['id']}' ]"
-          sequence = primary_resource['sequence']
-          src_resource.xpath('//file/@id').map(&:value).each do |file_id|
-            copy_path = sec_druid.find_content file_id
-            new_name = SecondaryFileNameService.create(file_id, sequence)
-            # TODO: verify new_name exists in primary_cm?
-            FileUtils.cp(copy_path, File.join(dest_path, "/#{new_name}"))
-          end
-        end
-      end
-    end
-    deprecation_deprecate copy_workspace_content: 'No longer used by any DLSS code'
-
-    def decommission_secondaries
-      @secondary_objs.each do |secondary_obj|
-        begin
-          @current_secondary = secondary_obj
-          @current_secondary.decommission @tag
-          @current_secondary.save
-
-          unshelve
-          unpublish
-          Dor::CleanupService.cleanup_by_druid @current_secondary.pid
-          Dor::Config.workflow.client.archive_active_workflow 'dor', @current_secondary.pid
-        rescue StandardError => e
-          @logger.error "Unable to decommission #{@current_secondary.pid} with primary object #{@primary.pid}: #{e.inspect}"
-          @logger.error e.backtrace.join("\n")
-        end
-      end
-    end
-    deprecation_deprecate decommission_secondaries: 'No longer used by any DLSS code'
-
-    alias decomission_secondaries decommission_secondaries
-    deprecate decomission_secondaries: 'Use decommission_secondaries instead'
-
-    # Remove content from stacks
-    # TODO: might set workflow status in future for robot to do
-    def unshelve
-      DigitalStacksService.prune_stacks_dir @current_secondary.pid
-    end
-    deprecation_deprecate unshelve: 'No longer used by any DLSS code'
-
-    # Withdraw item from Purl
-    # TODO: might set workflow status in future for robot to do
-    def unpublish
-      @current_secondary.publish_metadata
-    end
-    deprecation_deprecate unpublish: 'No longer used by any DLSS code'
-  end
-end

data/lib/dor/services/public_xml_service.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  class PublicXmlService
-    attr_reader :object
-
-    def initialize(object)
-      @object = object
-    end
-
-    def to_xml
-      pub = Nokogiri::XML('<publicObject/>').root
-      pub['id'] = object.pid
-      pub['published'] = Time.now.utc.xmlschema
-      pub['publishVersion'] = 'dor-services/' + Dor::VERSION
-
-      pub.add_child(public_identity_metadata.root) # add in modified identityMetadata datastream
-      pub.add_child(public_content_metadata.root) if public_content_metadata.xpath('//resource').any?
-      pub.add_child(public_rights_metadata.root)
-
-      pub.add_child(public_relationships.root) unless public_relationships.nil? # TODO: Should never be nil in practice; working around an ActiveFedora quirk for testing
-      pub.add_child(DublinCoreService.new(object).ng_xml.root)
-      pub.add_child(PublicDescMetadataService.new(object).ng_xml.root)
-      pub.add_child(release_xml.root) unless release_xml.xpath('//release').children.size == 0 # If there are no release_tags, this prevents an empty <releaseData/> from being added
-      # Note we cannot base this on if an individual object has release tags or not, because the collection may cause one to be generated for an item,
-      # so we need to calculate it and then look at the final result.
-
-      thumb = ThumbnailService.new(object).thumb
-      pub.add_child(Nokogiri("<thumb>#{thumb}</thumb>").root) unless thumb.nil?
-
-      new_pub = Nokogiri::XML(pub.to_xml, &:noblanks)
-      new_pub.encoding = 'UTF-8'
-      new_pub.to_xml
-    end
-
-    # Generate XML structure for inclusion to Purl
-    # @return [String] The XML release node as a string, with ReleaseDigest as the root document
-    def release_xml
-      @release_xml ||= begin
-        builder = Nokogiri::XML::Builder.new do |xml|
-          xml.releaseData do
-            object.released_for.each do |project, released_value|
-              xml.release(released_value['release'], to: project)
-            end
-          end
-        end
-        Nokogiri::XML(builder.to_xml)
-      end
-    end
-
-    def public_relationships
-      @public_relationships ||= object.public_relationships.clone
-    end
-
-    def public_rights_metadata
-      @public_rights_metadata ||= object.datastreams['rightsMetadata'].ng_xml.clone
-    end
-
-    def public_identity_metadata
-      @public_identity_metadata ||= begin
-        im = object.datastreams['identityMetadata'].ng_xml.clone
-        im.search('//release').each(&:remove) # remove any <release> tags from public xml which have full history
-        im
-      end
-    end
-
-    # @return [Nokogiri::XML::Document] sanitized for public consumption
-    def public_content_metadata
-      return Nokogiri::XML::Document.new unless object.datastreams['contentMetadata']
-
-      @public_content_metadata ||= begin
-        result = object.datastreams['contentMetadata'].ng_xml.clone
-
-        # remove any resources or attributes that are not destined for the public XML
-        result.xpath('/contentMetadata/resource[not(file[(@deliver="yes" or @publish="yes")]|externalFile)]').each(&:remove)
-        result.xpath('/contentMetadata/resource/file[not(@deliver="yes" or @publish="yes")]').each(&:remove)
-        result.xpath('/contentMetadata/resource/file').xpath('@preserve|@shelve|@publish|@deliver').each(&:remove)
-        result.xpath('/contentMetadata/resource/file/checksum').each(&:remove)
-
-        # support for dereferencing links via externalFile element(s) to the source (child) item - see JUMBO-19
-        result.xpath('/contentMetadata/resource/externalFile').each do |external_file|
-          add_data_from_src(external_file)
-        end
-
-        result
-      end
-    end
-
-    def add_data_from_src(external_file)
-      # enforce pre-conditions that resourceId, objectId, fileId are required
-      src_resource_id = external_file['resourceId']
-      src_druid = external_file['objectId']
-      src_file_id = external_file['fileId']
-      raise DataError, "Malformed externalFile data: #{external_file.to_xml}" if [src_resource_id, src_file_id, src_druid].map(&:blank?).any?
-
-      # grab source item
-      src_item = Dor.find(src_druid)
-
-      # locate and extract the resourceId/fileId elements
-      doc = src_item.contentMetadata.ng_xml
-      src_resource = doc.at_xpath("//resource[@id=\"#{src_resource_id}\"]")
-      src_file = src_resource.at_xpath("file[@id=\"#{src_file_id}\"]")
-      raise DataError, "Unable to find a file node with id=\"#{src_file_id}\" (child of #{object.pid})" unless src_file
-
-      src_image_data = src_file.at_xpath('imageData')
-
-      # always use title regardless of whether a child label is present
-      src_label = doc.create_element('label')
-      src_label.content = src_item.full_title
-
-      # add the extracted label and imageData
-      external_file.add_previous_sibling(src_label)
-      external_file << src_image_data unless src_image_data.nil?
-    end
-  end
-end

data/lib/dor/services/publish_metadata_service.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Dor
-  # Merges contentMetadata from several objects into one.
-  class PublishMetadataService
-    # @param [Dor::Item] item the object to be publshed
-    def self.publish(item)
-      new(item).publish
-    end
-
-    def initialize(item)
-      @item = item
-    end
-
-    # Appends contentMetadata file resources from the source objects to this object
-    def publish
-      return unpublish unless world_discoverable?
-
-      transfer_metadata
-      publish_notify_on_success
-    end
-
-    private
-
-    attr_reader :item
-
-    def transfer_metadata
-      transfer_to_document_store(DublinCoreService.new(item).ng_xml.to_xml(&:no_declaration), 'dc')
-      %w(identityMetadata contentMetadata rightsMetadata).each do |stream|
-        transfer_to_document_store(item.datastreams[stream].content.to_s, stream) if item.datastreams[stream]
-      end
-      transfer_to_document_store(PublicXmlService.new(item).to_xml, 'public')
-      transfer_to_document_store(PublicDescMetadataService.new(item).to_xml, 'mods')
-    end
-
-    # Clear out the document cache for this item
-    def unpublish
-      purl_druid.prune!
-      publish_delete_on_success
-    end
-
-    def world_discoverable?
-      rights = item.rightsMetadata.ng_xml.clone.remove_namespaces!
-      rights.at_xpath("//rightsMetadata/access[@type='discover']/machine/world")
-    end
-
-    # Create a file inside the content directory under the stacks.local_document_cache_root
-    # @param [String] content The contents of the file to be created
-    # @param [String] filename The name of the file to be created
-    # @return [void]
-    def transfer_to_document_store(content, filename)
-      new_file = File.join(purl_druid.content_dir, filename)
-      File.open(new_file, 'w') { |f| f.write content }
-    end
-
-    def purl_druid
-      @purl_druid ||= DruidTools::PurlDruid.new item.pid, Config.stacks.local_document_cache_root
-    end
-
-    def prune_purl_dir
-      purl_druid.prune!
-    end
-
-    ##
-    # When publishing a PURL, we notify purl-fetcher of changes.
-    # If the purl service isn't configured, instead we drop a `aa11bb2222` file into the `local_recent_changes` folder
-    # to notify other applications watching the filesystem (i.e., purl-fetcher).
-    # We also remove any .deletes entry that may have left over from a previous removal
-    def publish_notify_on_success
-      id = item.pid.gsub(/^druid:/, '')
-      if Dor::Config.purl_services.url
-        purl_services = Dor::Config.purl_services.rest_client
-        purl_services["purls/#{id}"].post ''
-      else
-        Deprecation.warn(self, 'You have not configured perl-fetcher (Dor::Config.purl_services.url). This will result in an error in dor-services 7 ')
-        local_recent_changes = Config.stacks.local_recent_changes
-        raise ArgumentError, "Missing local_recent_changes directory: #{local_recent_changes}" unless File.directory?(local_recent_changes)
-
-        FileUtils.touch(File.join(local_recent_changes, id))
-        begin
-          DruidTools::Druid.new(id, Dor::Config.stacks.local_document_cache_root).deletes_delete_record
-        rescue Errno::EACCES
-          Dor.logger.warn "Access denied while trying to remove .deletes file for druid:#{id}"
-        end
-      end
-    end
-
-    ##
-    # When publishing a PURL, we notify purl-fetcher of changes.
-    def publish_delete_on_success
-      return unless Dor::Config.purl_services.url
-
-      id = item.pid.gsub(/^druid:/, '')
-
-      purl_services = Dor::Config.purl_services.rest_client
-      purl_services["purls/#{id}"].delete
-    end
-  end
-end