stash-sword 0.1.0

data/lib/stash/sword/deposit_receipt.rb

@@ -0,0 +1,44 @@
+require 'xml/mapping_extensions'
+require 'stash/sword/namespace'
+
+module Stash
+  module Sword
+
+    class Link
+      include ::XML::Mapping
+
+      text_node :rel, '@rel'
+      uri_node :href, '@href'
+      mime_type_node :type, '@type', default_value: nil
+    end
+
+    class DepositReceipt
+      include ::XML::MappingExtensions::Namespaced
+
+      root_element_name 'entry'
+      namespace Namespace::ATOM.value
+
+      array_node :links, 'link', class: Link, default_value: []
+
+      def link(rel:)
+        rel = rel.to_s if rel
+        links.find { |l| l.rel == rel }
+      end
+
+      def em_iri
+        em_iri = link(rel: 'edit-media')
+        em_iri.href if em_iri
+      end
+
+      def edit_iri
+        edit_iri = link(rel: 'edit')
+        edit_iri.href if edit_iri
+      end
+
+      def se_iri
+        se_iri = link(rel: URI('http://purl.org/net/sword/terms/add'))
+        se_iri.href if em_iri
+      end
+    end
+  end
+end

data/lib/stash/sword/header_utils.rb

@@ -0,0 +1,42 @@
+module Stash
+  module Sword
+    module HeaderUtils
+
+      SIMPLE_ZIP                 = 'http://purl.org/net/sword/package/SimpleZip'.freeze
+      APPLICATION_ZIP            = 'application/zip'.freeze
+      MULTIPART_RELATED_ATOM_XML = 'multipart/related; type="application/atom+xml"'.freeze
+
+      attr_reader :on_behalf_of
+
+      def create_request_headers(zipfile, slug)
+        {
+          'Content-Type'        => APPLICATION_ZIP,
+          'Content-Disposition' => "attachment; filename=#{File.basename(zipfile)}",
+          'Packaging'           => SIMPLE_ZIP,
+          'Content-MD5'         => Digest::MD5.file(zipfile).to_s,
+          'On-Behalf-Of'        => on_behalf_of,
+          'Slug'                => slug
+        }
+      end
+
+      def update_request_headers(stream, boundary)
+        {
+          'Content-Length' => stream.size.to_s,
+          'Content-Type'   => "#{MULTIPART_RELATED_ATOM_XML}; boundary=\"#{boundary}\"",
+          'On-Behalf-Of'   => on_behalf_of,
+          'MIME-Version'   => '1.0'
+        }
+      end
+
+      def update_mime_headers(zipfile)
+        {
+          'Content-Type'        => APPLICATION_ZIP,
+          'Content-Disposition' => "attachment; name=payload; filename=\"#{File.basename(zipfile)}\"",
+          'Packaging'           => SIMPLE_ZIP,
+          'Content-MD5'         => Digest::MD5.file(zipfile).to_s,
+          'MIME-Version'        => '1.0'
+        }
+      end
+    end
+  end
+end

data/lib/stash/sword/http_helper.rb

@@ -0,0 +1,120 @@
+require 'net/http'
+require 'rest-client'
+require 'uri'
+require 'stash/sword/log_utils'
+
+module Stash
+  module Sword
+    # Utility class simplifying GET requests for HTTP/HTTPS resources.
+    class HTTPHelper
+
+      include LogUtils
+
+      # The default number of redirects to follow before erroring out.
+      DEFAULT_MAX_REDIRECTS = 5
+
+      # @return [String] the User-Agent string to send when making requests
+      attr_accessor :user_agent
+
+      # @return [Integer] the number of redirects to follow before erroring out
+      attr_accessor :redirect_limit
+
+      # @return [String] the HTTP Basic Authentication username
+      attr_reader :username
+
+      # @return [String] the HTTP Basic Authentication password
+      attr_reader :password
+
+      # Creates a new `HTTPHelper`
+      #
+      # @param user_agent [String] the User-Agent string to send when making requests
+      # @param redirect_limit [Integer] the number of redirects to follow before erroring out
+      #   (defaults to {DEFAULT_MAX_REDIRECTS})
+      def initialize(user_agent:, username: nil, password: nil, redirect_limit: DEFAULT_MAX_REDIRECTS)
+        @user_agent = user_agent
+        @redirect_limit = redirect_limit
+        @username = username
+        @password = password
+      end
+
+      # Gets the content of the specified URI as a string.
+      # @param uri [URI] the URI to download
+      # @param limit [Integer] the number of redirects to follow (defaults to {#redirect_limit})
+      # @return [String] the content of the URI
+      def get(uri:, limit: redirect_limit)
+        do_get(uri, limit) do |success|
+          # not 100% clear why we need an explicit return here; it
+          # doesn't show up in unit tests but it does in example.rb
+          return success.body
+        end
+      end
+
+      # Posts the specified payload string to the specified URI.
+      def post(uri:, payload:, headers: {}, limit: redirect_limit)
+        do_post_or_put(method: :post, uri: uri, payload: payload, headers: headers, limit: limit)
+      end
+
+      # Puts the specified payload string to the specified URI.
+      def put(uri:, payload:, headers: {}, limit: redirect_limit)
+        do_post_or_put(method: :put, uri: uri, payload: payload, headers: headers, limit: limit)
+      end
+
+      private
+
+      def default_headers
+        {
+          'User-Agent' => user_agent,
+          'Content-Transfer-Encoding' => 'binary'
+        }.freeze
+      end
+
+      def do_post_or_put(method:, uri:, payload:, headers:, limit:)
+        options = request_options(headers, limit, method, payload, uri)
+        log_hash(options)
+        RestClient::Request.execute(**options)
+      end
+
+      def request_options(headers, limit, method, payload, uri)
+        options = {
+          method: method,
+          url: uri.to_s,
+          payload: payload,
+          headers: headers.merge(default_headers),
+          max_redirects: limit
+        }
+        options[:user] = username if username
+        options[:password] = password if password
+        options
+      end
+
+      # TODO: Consider rewriting with RestClient
+      def do_get(uri, limit, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        raise "Redirect limit (#{redirect_limit}) exceeded retrieving URI #{uri}" if limit <= 0
+        req = Net::HTTP::Get.new(uri, 'User-Agent' => user_agent)
+        req.basic_auth(username, password) if username && password
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: (uri.scheme == 'https')) do |http|
+          http.request(req) do |response|
+            case response
+            when Net::HTTPSuccess
+              yield(response)
+            when Net::HTTPInformation, Net::HTTPRedirection
+              do_get(redirect_uri_for(response, uri), limit - 1, &block)
+            else
+              raise "Error #{response.code}: #{response.message} retrieving URI #{uri}"
+            end
+          end
+        end
+      end
+
+      def redirect_uri_for(response, original_uri)
+        if response.is_a?(Net::HTTPInformation)
+          original_uri
+        else
+          location = response['location']
+          new_uri = URI(location)
+          new_uri.relative? ? original_uri + location : new_uri
+        end
+      end
+    end
+  end
+end

data/lib/stash/sword/iri.rb

@@ -0,0 +1,12 @@
+require 'uri'
+require 'typesafe_enum'
+
+module Stash
+  module Sword
+    class IRI < TypesafeEnum::Base
+
+      new :BINARY, URI('http://purl.org/net/sword/package/Binary')
+      new :SIMPLE_ZIP, URI('http://purl.org/net/sword/package/SimpleZip')
+    end
+  end
+end

data/lib/stash/sword/log_utils.rb

@@ -0,0 +1,39 @@
+module Stash
+  module Sword
+    module LogUtils
+      def log
+        ::Stash::Sword.log
+      end
+
+      def log_error(e)
+        if e.respond_to?(:response)
+          log.error(response_to_log_msg(e.response))
+        else
+          log.error('Unable to log response')
+        end
+      end
+
+      def response_to_log_msg(response)
+        [
+          '-----------------------------------------------------',
+          "code: #{response.code}",
+          'headers:', hash_to_log_msg(response.headers),
+          "body:\n#{response.body}",
+          '-----------------------------------------------------'
+        ].join("\n")
+      end
+
+      def log_hash(hash)
+        msg = hash_to_log_msg(hash)
+        log.debug(msg)
+      end
+
+      def hash_to_log_msg(hash)
+        hash.map do |k, v|
+          value = v.is_a?(Hash) ? v.map { |k2, v2| "\n\t#{k2}: #{v2}" }.join : v
+          "#{k}: #{value}"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/stash/sword/module_info.rb

@@ -0,0 +1,12 @@
+module Stash
+  module Sword
+    # The name of this gem
+    NAME = 'stash-sword'.freeze
+
+    # The version of this gem
+    VERSION = '0.1.0'.freeze
+
+    # The copyright notice for this gem
+    COPYRIGHT = 'Copyright (c) 2016 The Regents of the University of California'.freeze
+  end
+end

data/lib/stash/sword/namespace.rb

@@ -0,0 +1,30 @@
+require 'typesafe_enum'
+require 'xml/mapping_extensions'
+
+module Stash
+  module Sword
+    class Namespace < TypesafeEnum::Base
+      NS = XML::MappingExtensions::Namespace
+      private_constant(:NS)
+
+      new :SWORD, NS.new(uri: 'http://purl.org/net/sword/')
+      new :SWORD_TERMS, NS.new(uri: 'http://purl.org/net/sword/terms/', prefix: 'sword')
+      new :SWORD_PACKAGE, NS.new(uri: 'http://purl.org/net/sword/package')
+      new :SWORD_ERROR, NS.new(uri: 'http://purl.org/net/sword/error')
+      new :SWORD_STATE, NS.new(uri: 'http://purl.org/net/sword/state')
+      new :ATOM_PUB, NS.new(uri: 'http://www.w3.org/2007/app', prefix: 'app')
+      new :ATOM, NS.new(uri: 'http://www.w3.org/2005/Atom', prefix: 'atom')
+      new :DC_TERMS, NS.new(uri: 'http://purl.org/dc/terms/', prefix: 'dcterms')
+      new :RDF, NS.new(uri: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', prefix: 'rdf')
+      new :OAI_ORE, NS.new(uri: 'http://www.openarchives.org/ore/terms/', prefix: 'ore')
+
+      def uri
+        value.uri
+      end
+
+      def prefix
+        value.prefix
+      end
+    end
+  end
+end

data/lib/stash/sword/sequence_io.rb

@@ -0,0 +1,105 @@
+require 'stringio'
+
+module Stash
+  module Sword
+    # A read-only `IO`-like that concatenates a sequence of strings or IOs.
+    class SequenceIO
+
+      # Creates a new {SequenceIO} concatenating the specified input sources.
+      # Strings are wrapped internally as `StringIO`.
+      #
+      # @param inputs [Enumerable<String, IO>] an array of strings and/or IOs to
+      #   concatenate
+      def initialize(inputs)
+        inputs  = [inputs] unless inputs.respond_to?(:[]) && inputs.respond_to?(:map)
+        @inputs = to_ios(inputs)
+        binmode if any_binmode(@inputs)
+        @index = 0
+        @input = @inputs[index] unless inputs.empty?
+      end
+
+      def size
+        @size ||= inputs.inject(0) do |sum, input|
+          raise "input #{input} does not respond to :size" unless input.respond_to?(:size)
+          sum + input.size
+        end
+      end
+
+      def read(length = nil, outbuf = nil)
+        # use <= instead of == to get around https://github.com/bbatsov/rubocop/issues/3131
+        return nil if size <= 0
+        outbuf = outbuf ? outbuf.clear : ''
+        length ? read_segment(length, outbuf) : read_fully(outbuf)
+        outbuf
+      end
+
+      def binmode
+        return self if binmode?
+        inputs.each do |input|
+          input.binmode if input.respond_to?(:binmode)
+        end
+        @binmode = true
+        self
+      end
+
+      def binmode?
+        @binmode
+      end
+
+      def close
+        next_input! until input.nil?
+      end
+
+      def closed?
+        input.nil? && index >= inputs.length
+      end
+
+      private
+
+      attr_reader :input
+      attr_reader :index
+      attr_reader :inputs
+
+      def read_fully(buffer)
+        until input.nil?
+          buffer << input.read(nil)
+          next_input!
+        end
+      end
+
+      def read_segment(length, buffer)
+        return unless input && length > 0
+
+        remaining = length
+        if (result = input.read(length))
+          buffer << result
+          remaining = length - result.length
+        end
+        return unless remaining > 0
+
+        next_input!
+        read_segment(remaining, buffer)
+      end
+
+      # TODO: Array.pop! or something
+      def next_input!
+        input.close if input && input.respond_to?(:close)
+        @index += 1
+        @input = index < inputs.length ? inputs[index] : nil
+      end
+
+      def to_ios(inputs)
+        inputs.map do |input|
+          input.respond_to?(:read) ? input : StringIO.new(input.to_s)
+        end
+      end
+
+      def any_binmode(ios)
+        ios.each do |io|
+          return true if io.respond_to?(:binmode?) && io.binmode?
+        end
+        false
+      end
+    end
+  end
+end

data/notes/Dash_Submission_To_Merritt.txt

@@ -0,0 +1,40 @@
+Status of submission is tracked - merritt_response {PROCESSING, “User not authorized for Merritt submission”, 
+
+How is dublincore called?  
+
+Review & Submit button —> record.review()
+creates datacite.xml file and places it in the uploads/<local_id>/ directory
+
+Submit button —>  record.send_archive_to_merritt
+
+Set up the user_email request headers 
+Create a new thread
+Record.Generate Merritt Zip()
+Record.Send Archive to Merritt
+Create a submission Log 
+
+
+If submission successful, remove files from local storage and add logging information
+Record.Purge_Files()
+
+Generate_Merritt_Zip()
+set file path to uploads_dir - this is a linked directory shared/uploads so it will stay persistent across releases
+local_id is used to name the uploads directory for a dataset.
+calls self.review
+calls self.dublincore
+calls self.dataone
+creates the zip file 
+purges all temp files, etc
+
+Record.Send_Archive_to_merritt
+gets info to send in curl command from MERRITT_CONFIG and user and camps
+sends curl command - no notification sent if no email
+No DOI/EZID is not created.  Merritt does this.
+returns sys_output
+
+
+SWORD - Slug identifier is the local_id
+
+
+
+   if @user_email.nil?
      sys_output = "curl --insecure --verbose -u #{merritt_username}:#{merritt_password} -F \"file=@./#{DATASHARE_CONFIG['uploads_dir']}/#{self.local_id}/#{self.local_id}.zip\" -F \"type=container\" -F \"submitter=Dash/#{external_id}\" -F \"responseForm=xml\" -F \"profile=#{merritt_profile}\" -F \"localIdentifier=#{self.local_id}\" #{merritt_endpoint} 2>&1"
    else
      sys_output = "curl --insecure --verbose -u #{merritt_username}:#{merritt_password} -F \"file=@./#{DATASHARE_CONFIG['uploads_dir']}/#{self.local_id}/#{self.local_id}.zip\" -F \"notification=#{@user_email}\" -F \"type=container\" -F \"submitter=Dash/#{external_id}\" -F \"responseForm=xml\" -F \"profile=#{merritt_profile}\" -F \"localIdentifier=#{self.local_id}\" #{merritt_endpoint} 2>&1"
    end