dor-services 2.2.4

data/lib/dor/cleanup_service.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+require 'lyber-utils'
+
+module Dor
+  class CleanupService
+    Config.declare(:cleanup) do
+  	  local_workspace_root '/dor/workspace'
+      local_export_home '/dor/export'
+    end
+
+    # Delete all workspace and export entities for the druid
+    # @param [LyberCore::Robots::WorkItem]
+    def self.cleanup(dor_item)
+      druid = dor_item.pid
+      workspace_dir = Druid.new(druid).path(Config.cleanup.local_workspace_root)
+      self.remove_entry(workspace_dir)
+      bag_dir = File.join(Config.cleanup.local_export_home, druid)
+      self.remove_entry(bag_dir)
+      tarfile = "#{bag_dir}.tar"
+      self.remove_entry(tarfile)
+    end
+
+    # Deleta a filesystem entry
+    # @param [String]
+    def self.remove_entry(entry)
+      FileUtils.remove_entry(entry) if File.exist?(entry)
+    end
+
+
+  end
+
+end

data/lib/dor/config.rb

@@ -0,0 +1,45 @@
+require 'mod_cons'
+
+module Dor
+  Config = ModCons::Configuration.new(:'Dor::Config')
+
+  Config.declare do
+    fedora do
+      url nil
+      safeurl nil
+      cert_file nil
+      key_file nil
+      key_pass ''
+
+      instance_eval do
+        def client
+          RestClient::Resource.new(
+            self.url,
+            :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read(self.cert_file)),
+            :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read(self.key_file), self.key_pass)
+          )
+        end
+      end
+
+      config_changed do |fedora|
+        fedora_uri = URI.parse(fedora.url)
+        fedora_uri.user = fedora_uri.password = nil
+        fedora.safeurl fedora_uri.to_s
+        
+        temp_v = $-v
+        $-v = nil
+        begin
+         ::ENABLE_SOLR_UPDATES = false
+         ::Fedora::Repository.register(fedora.url)
+         ::Fedora::Connection.const_set(:SSL_CLIENT_CERT_FILE,fedora.cert_file)
+         ::Fedora::Connection.const_set(:SSL_CLIENT_KEY_FILE,fedora.key_file)
+         ::Fedora::Connection.const_set(:SSL_CLIENT_KEY_PASS,fedora.key_pass)
+        ensure
+         $-v = temp_v
+        end
+      end
+    end
+  end
+    
+end
+

data/lib/dor/digital_stacks_service.rb

@@ -0,0 +1,82 @@
+require 'tempfile'
+require 'systemu'
+
+module Dor
+  class DigitalStacksService
+    
+    Config.declare(:stacks) do
+  	  document_cache_storage_root nil
+  	  document_cache_host nil
+  	  document_cache_user nil
+  	  
+  	  storage_root '/stacks'
+  	  host nil
+  	  user nil
+  	  
+  	  local_workspace_root '/dor'
+    end
+    
+    # TODO copied from lyber-core, but didn't want to create circular dependency for between gems for this one method
+    # Executes a system command in a subprocess. 
+    # The method will return stdout from the command if execution was successful.
+    # The method will raise an exception if if execution fails. 
+    # The exception's message will contain the explaination of the failure.
+    # @param [String] command the command to be executed
+    # @return [String] stdout from the command if execution was successful
+    def self.execute(command)
+      status, stdout, stderr = systemu(command)
+      if (status.exitstatus != 0)
+        raise stderr
+      end
+      return stdout
+    rescue
+      msg = "Command failed to execute: [#{command}] caused by <STDERR =\n#{stderr.split($/).join("\n")}>"
+      msg << "\nSTDOUT =\n#{stdout.split($/).join("\n")}" if (stdout && (stdout.length > 0))
+      raise msg
+    end
+    
+    def self.druid_tree(druid)
+      Druid.new(druid).path
+    rescue
+      nil
+    end
+        
+    def self.transfer_to_document_store(id, content, filename)
+      path = self.druid_tree(id)
+      raise "Invalid druid: #{id}" if(path.nil?)
+      
+      # create the remote directory in the document cache
+      remote_document_cache_dir = File.join(Config.stacks.document_cache_storage_root, path)
+      command = "ssh #{Config.stacks.document_cache_user}@#{Config.stacks.document_cache_host} mkdir -p #{remote_document_cache_dir}"
+      self.execute(command)
+
+      # create a temp file containing the content and copy the contents to the remote document cache
+      Tempfile.open(filename) do |tf| 
+        tf.write(content) 
+        tf.flush
+        command = "scp \"#{tf.path}\" #{Config.stacks.document_cache_user}@#{Config.stacks.document_cache_host}:#{remote_document_cache_dir}/#{filename}"
+        self.execute(command)
+      end
+    end
+    
+    def self.shelve_to_stacks(id, files)
+      path = self.druid_tree(id)
+      raise "Invalid druid: #{id}" if(path.nil?)
+      
+      # create the remote directory on the digital stacks
+      remote_storage_dir = File.join(Config.stacks.storage_root, path)
+      command = "ssh #{Config.stacks.user}@#{Config.stacks.host} mkdir -p #{remote_storage_dir}"
+      self.execute(command)
+
+      # copy the contents for the given object from the local workspace directory to the remote directory
+      local_storage_dir = File.join(Config.stacks.local_workspace_root, path)
+      files.each do |file|
+        command = "scp \"#{local_storage_dir}/#{file}\" #{Config.stacks.user}@#{Config.stacks.host}:#{remote_storage_dir}"
+        self.execute(command)
+      end
+    end
+
+  end
+
+end
+

data/lib/dor/druid_utils.rb

@@ -0,0 +1,41 @@
+class Druid
+  attr_accessor :druid
+  
+  DRUID_PATTERN = /^(?:druid:)?([a-z]{2})(\d{3})([a-z]{2})(\d{4})$/
+  def initialize(druid)
+    if druid !~ DRUID_PATTERN
+      raise ArgumentError, "Invalid DRUID: #{druid}"
+    end
+    @druid = druid
+  end
+  
+  def id
+    @druid.scan(/^(?:druid:)?(.+)$/).flatten.last
+  end
+  
+  def tree
+    @druid.scan(DRUID_PATTERN).flatten
+  end
+  
+  def path(base=nil)
+    File.join(*([base,tree].compact))
+  end
+  
+  def mkdir(base)
+    FileUtils.mkdir_p(path(base))
+  end
+  
+  def rmdir(base)
+    parts = tree
+    while parts.length > 0
+      dir = File.join(base, *parts)
+      begin
+        FileUtils.rm(File.join(dir,'.DS_Store'), :force => true)
+        FileUtils.rmdir(dir)
+      rescue Errno::ENOTEMPTY
+        break
+      end
+      parts.pop
+    end
+  end
+end

data/lib/dor/embargo.rb

@@ -0,0 +1,41 @@
+require 'datastreams/embargo_metadata_ds'
+require 'datastreams/events_ds'
+
+module Dor
+  
+  # These methods manipulate the object for embargo purposes
+  # They assume the object has embargoMetadata, rightsMetadata, and events datastreams
+  module Embargo
+    
+    # Manipulates datastreams in the object when embargo is lifted:
+    # Sets embargo status to released in embargoMetadata
+    # Modifies rightsMetadata to remove embargoReleaseDate and updates/adds access from embargoMetadata/releaseAccess
+    # @param [String] release_agent name of the person, application or thing that released embargo
+    # @note The caller should save the object to fedora to commit the changes
+    def release_embargo(release_agent="unknown")
+      # Set status to released
+      embargo_md = datastreams['embargoMetadata']
+      embargo_md.status = 'released'
+      
+      # Remove embargoReleaseDate from rights
+      rights_xml = datastreams['rightsMetadata'].ng_xml
+      rights_xml.xpath("//rightsMetadata/access[@type='read']/machine/embargoReleaseDate").remove
+      
+      # Replace rights <access> nodes with those from embargoMetadta
+      release_access = embargo_md.release_access_node
+      release_access.xpath('//releaseAccess/access').each do |new_access|
+        type = new_access['type']
+        rights_xml.xpath("//rightsMetadata/access[@type='#{type}']").remove
+        access_sibling = rights_xml.at_xpath("//rightsMetadata/access[last()]")
+        if(access_sibling)
+          access_sibling.add_next_sibling(new_access.clone)
+        else
+          rights_xml.root.add_child(new_access.clone)
+        end
+      end
+      
+      datastreams['rightsMetadata'].dirty = true
+      datastreams['events'].add_event("embargo", release_agent, "Embargo released")
+    end
+  end
+end

data/lib/dor/exceptions.rb

@@ -0,0 +1,13 @@
+module Dor
+  
+  class Exception < ::Exception; end
+  class ParameterError < Exception; end
+  class DuplicateIdError < Exception
+    attr_reader :pid
+    
+    def initialize(pid)
+      @pid = pid
+    end
+  end
+  
+end

data/lib/dor/item.rb

@@ -0,0 +1,141 @@
+require 'dor/base'
+require 'datastreams/content_metadata_ds'
+require 'datastreams/ng_tidy'
+require 'tmpdir'
+
+module Dor
+  
+  class Item < Base
+    
+    has_metadata :name => "contentMetadata", :type => ContentMetadataDS
+    has_metadata :name => "descMetadata", :type => ActiveFedora::NokogiriDatastream
+    has_metadata :name => "rightsMetadata", :type => ActiveFedora::NokogiriDatastream
+    has_metadata :name => "provenanceMetadata", :type => ActiveFedora::NokogiriDatastream
+    has_metadata :name => "technicalMetadata", :type => ActiveFedora::NokogiriDatastream
+
+    def admin_policy_object
+      apo_ref = Array(self.rels_ext.relationships[:self]['hydra_isGovernedBy']).first
+      if apo_ref.nil?
+        return nil
+      else
+        apo_id = apo_ref.value.split(%r{/}).last
+        if apo_id.empty?
+          return nil
+        else
+          return Dor::AdminPolicyObject.load_instance(apo_id)
+        end
+      end
+    end
+  
+    def fetch_descMetadata_datastream
+      candidates = self.identity_metadata.otherIds.collect { |oid| oid.to_s }
+      metadata_id = Dor::MetadataService.resolvable(candidates).first
+      unless metadata_id.nil?
+        return Dor::MetadataService.fetch(metadata_id.to_s)
+      else
+        return nil
+      end
+    end
+
+    def build_contentMetadata_datastream(ds)
+      path = Druid.new(self.pid).path(Dor::Config.stacks.local_workspace_root)
+      if File.exists?(File.join(path, 'content_metadata.xml'))
+        ds.label = 'Content Metadata'
+        ds.ng_xml = Nokogiri::XML(File.read(File.join(path, 'content_metadata.xml')))
+      end
+    end
+    
+    def build_descMetadata_datastream(ds)
+      content = fetch_descMetadata_datastream
+      unless content.nil?
+        ds.label = 'Descriptive Metadata'
+        ds.ng_xml = Nokogiri::XML(content)
+        ds.ng_xml.normalize_text!
+      end
+    end
+    
+    def build_rightsMetadata_datastream(ds)
+      content_ds = self.admin_policy_object.datastreams['defaultObjectRights']
+      ds.label = 'Rights Metadata'
+      ds.ng_xml = content_ds.ng_xml.clone
+    end
+
+    def public_xml      
+      pub = Nokogiri::XML("<publicObject/>").root
+      pub['id'] = pid
+      pub.add_child(self.datastreams['identityMetadata'].ng_xml.root.clone)
+      pub.add_child(self.datastreams['contentMetadata'].public_xml.root.clone)
+      pub.add_child(self.datastreams['rightsMetadata'].ng_xml.root.clone)
+      pub.add_child(generate_dublin_core.root)
+      Nokogiri::XML(pub.to_xml) { |x| x.noblanks }.to_xml { |config| config.no_declaration }
+    end
+    
+    # Generates Dublin Core from the MODS in the descMetadata datastream using the LoC mods2dc stylesheet
+    # Should not be used for the Fedora DC datastream
+    def generate_dublin_core
+      apo = self.admin_policy_object
+      format = apo.nil? ? 'mods' : apo.datastreams['administrativeMetadata'].ng_xml.at('/administrativeMetadata/descMetadata/format').text.downcase
+      xslt = Nokogiri::XSLT(File.new(File.expand_path(File.dirname(__FILE__) + "/#{format}2dc.xslt")) )
+      xslt.transform(self.datastreams['descMetadata'].ng_xml)
+    end
+    
+    def publish_metadata
+      DigitalStacksService.transfer_to_document_store(pid, self.datastreams['identityMetadata'].to_xml, 'identityMetadata')
+      DigitalStacksService.transfer_to_document_store(pid, self.datastreams['contentMetadata'].to_xml, 'contentMetadata')
+      DigitalStacksService.transfer_to_document_store(pid, self.datastreams['rightsMetadata'].to_xml, 'rightsMetadata')
+      dc_xml = self.generate_dublin_core.to_xml {|config| config.no_declaration}
+      DigitalStacksService.transfer_to_document_store(pid, dc_xml, 'dc')
+      DigitalStacksService.transfer_to_document_store(pid, public_xml, 'public')
+    end
+
+    def build_provenanceMetadata_datastream(workflow_id, event_text)
+      ProvenanceMetadataService.add_provenance(self, workflow_id, event_text)
+    end
+
+    def build_technicalMetadata_datastream(ds)
+      unless defined? ::JhoveService
+        begin
+          require 'jhove_service'
+        rescue LoadError => e
+          puts e.inspect
+          raise "jhove-service dependency gem was not found.  Please add it to your Gemfile and run bundle install"
+        end
+      end
+      begin
+        content_dir = Druid.new(self.pid).path(Config.sdr.local_workspace_root)
+        temp_dir = Dir.mktmpdir(self.pid)
+        jhove_service = ::JhoveService.new(temp_dir)
+        jhove_output_file = jhove_service.run_jhove(content_dir)
+        tech_md_file = jhove_service.create_technical_metadata(jhove_output_file)
+        ds.label = 'Technical Metadata'
+        ds.ng_xml = Nokogiri::XML(IO.read(tech_md_file))
+      ensure
+        FileUtils.remove_entry_secure(temp_dir) if File.exist?(temp_dir)
+      end
+    end
+
+    def shelve
+      files = [] # doc.xpath("//file").select {|f| f['shelve'] == 'yes'}.map{|f| f['id']}
+      self.datastreams['contentMetadata'].ng_xml.xpath('//file').each do |file|
+        files << file['id'] if(file['shelve'].downcase == 'yes')
+      end
+      
+      DigitalStacksService.shelve_to_stacks(pid, files)
+    end
+
+    def sdr_ingest_transfer(agreement_id)
+      SdrIngestService.transfer(self,agreement_id)
+    end
+
+    def cleanup()
+      CleanupService.cleanup(self)
+    end
+
+    def initiate_apo_workflow(name)
+      wf_xml = admin_policy_object.datastreams['administrativeMetadata'].ng_xml.xpath(%{//workflow[@id="#{name}"]}).first.to_xml
+      Dor::WorkflowService.create_workflow('dor',self.pid,name,wf_xml)
+    end
+    
+  end
+
+end

data/lib/dor/metadata_handlers/catalog_handler.rb

@@ -0,0 +1,22 @@
+require 'rest-client'
+
+handler = Class.new do
+  Dor::Config.metadata.declare(:catalog) { url nil }
+  
+  def fetch(prefix, identifier)
+    client = RestClient::Resource.new(Dor::Config.metadata.catalog.url)
+    client["?#{prefix.chomp}=#{identifier.chomp}"].get
+  end
+
+  def label(metadata)
+    mods = Nokogiri::XML(metadata)
+    mods.root.add_namespace_definition('mods','http://www.loc.gov/mods/v3')
+    mods.xpath('/mods:mods/mods:titleInfo[1]').xpath('mods:title|mods:nonSort').collect { |n| n.text }.join(' ').strip
+  end
+
+  def prefixes
+    ['catkey','barcode']
+  end
+end
+
+Dor::MetadataService.register(handler)

data/lib/dor/metadata_handlers/mdtoolkit_handler.rb

@@ -0,0 +1,42 @@
+require 'nokogiri'
+require 'rest-client'
+
+handler = Class.new do
+  Dor::Config.metadata.declare(:exist) { url nil }
+  
+  def fetch(prefix, identifier)
+    query = <<-QUERY
+<?xml version="1.0" encoding="UTF-8"?>
+<query xmlns="http://exist.sourceforge.net/NS/exist">
+    <text>
+    collection('orbeon/fr')[contains(base-uri(), "#{identifier}")]
+    </text>
+</query>
+    QUERY
+    client = RestClient::Resource.new(Dor::Config.metadata.exist.url)
+    response = client['db'].post(query, :content_type => 'application/xquery')
+    doc = Nokogiri::XML(response)
+    doc.root.add_namespace_definition('exist','http://exist.sourceforge.net/NS/exist')
+    result = doc.xpath('/exist:result/*[1]').first
+    result.nil? ? nil : result.to_s
+  end
+
+  def label(metadata)
+    xml = Nokogiri::XML(metadata)
+    if xml.root.nil?
+      return ""
+    end
+    case xml.root.name
+    when 'msDesc' then xml.xpath('/msDesc/msIdentifier/collection').text
+    when 'mods'   then 
+      xml.root.add_namespace_definition('mods','http://www.loc.gov/mods/v3')
+      xml.xpath('/mods:mods/mods:titleInfo[1]').xpath('mods:title|mods:nonSort').collect { |n| n.text }.join(' ').strip
+    end
+  end
+
+  def prefixes
+    ['mdtoolkit','druid']
+  end
+end
+
+Dor::MetadataService.register(handler)