duracloud-client 0.0.1 → 0.0.2

data/lib/duracloud/content_properties.rb

@@ -1,116 +1,10 @@
-require 'hashie'
+require "duracloud/properties"
 
 module Duracloud
-  #
-  # [See https://groups.google.com/d/msg/duracloud-users/67ONTkAqyCM/SGVOOHTvAAAJ]
-  #
-  # These are used as part of the REST call to perform a copy
-  #
-  #   x-dura-meta-copy-source
-  #   x-dura-meta-copy-source-store
-  #
-  # These are used to provide details about a space.
-  # You could probably set them on a content item, but that would be a little odd:
-  #
-  #   x-dura-meta-space-count
-  #   x-dura-meta-space-created
-  #
-  # These are use used as part of the REST call to set space access control
-  # (the * is replaced by the user or group name)
-  #
-  #   x-dura-meta-acl-*
-  #   x-dura-meta-acl-group-*
-  #
-  # These are used for some internal DuraCloud data wrangling,
-  # I'd recommend that you not use them in your code:
-  #
-  #   x-dura-meta-content-mimetype
-  #   x-dura-meta-content-size
-  #   x-dura-meta-content-checksum
-  #   x-dura-meta-content-modified
-  #
-  # That's it for the exceptions.
-  #
-  # One other set I'll call out is the values which are captured by the DuraCloud SyncTool.
-  # These are added automatically by the SyncTool, so you may have an interest in reading
-  # or updating them. Either way, it's good to be aware of them so you don't accidentally
-  # step on the values being captured for you.
-  #
-  #   x-dura-meta-creator
-  #   x-dura-meta-content-file-created
-  #   x-dura-meta-content-file-modified
-  #   x-dura-meta-content-file-last-accessed
-  #   x-dura-meta-content-file-path
-  #
-  # A few other notes:
-  #
-  # Stick with US-ASCII characters for property names and values
-  # There is a 2 KB total size limit on all user-metadata (this includes the metadata
-  # we create for you and that you add yourself)
-  #
-  # Both of these restrictions are put in place by Amazon S3, so we don't have much say
-  # in the matter.
-  #
-  class ContentProperties < Hashie::Mash
-    include Hashie::Extensions::Coercion
+  class ContentProperties < Properties
 
-    PREFIX = "x-dura-meta-".freeze
-
-    ENCODING = Encoding::US_ASCII
-
-    RESERVED = [
-      /\Ax-dura-meta-acl-/,
-      /\Ax-dura-meta-space-(count|created)\z/,
-      /\Ax-dura-meta-copy-source(-store)\z/,
-      /\Ax-dura-meta-content-(mimetype|size|checksum|modified)\z/,
-    ]
-
-    coerce_value Array, ->(v) { v.first }
-
-    class << self
-      attr_accessor :ignore_reserved
-
-      def property?(prop)
-        prop.start_with?(PREFIX)
-      end
-    end
-
-    self.ignore_reserved = true
-
-    def ignore_reserved?
-      self.class.ignore_reserved
-    end
-
-    def regular_writer(key, value)
-      if reserved?(key)
-        if ignore_reserved?
-          warn "#{self.class}: Ignoring reserved content property \"#{key}\"."
-        else
-          raise Error, "#{self.class}: The content property \"#{key}\" is reserved."
-        end
-      else
-        super
-      end
-    end
-
-    def convert_key(key)
-      converted = super.dup
-      converted.gsub!(/_/, '-')
-      converted.downcase!
-      converted.prepend(PREFIX) unless self.class.property?(converted)
-      converted.force_encoding(ENCODING)
-    end
-
-    def reserved?(key)
-      RESERVED.any? { |k| k.match(key) }
-    end
-
-    def convert_value(value, _ = nil)
-      if value.is_a?(Array)
-        value.map { |v| convert_value(v) }
-      else
-        value.force_encoding(ENCODING)
-      end
+    def self.property?(prop)
+      super && !( space_property?(prop) || space_acl?(prop) || copy_content_property?(prop) )
     end
 
   end

data/lib/duracloud/durastore_request.rb

@@ -0,0 +1,9 @@
+require "duracloud/request"
+
+module Duracloud
+  class DurastoreRequest < Request
+   def base_path
+      '/durastore/'
+    end
+  end
+end

data/lib/duracloud/error_handler.rb

@@ -45,14 +45,4 @@ module Duracloud
       response.plain_text? && response.has_body?
     end
   end
-
-  # class StoreContentErrorHandler < ErrorHandler
-  #   def handle_400
-  #     InvalidContentIDError
-  #   end
-
-  #   def handle_409
-  #     ChecksumError
-  #   end
-  # end
 end

data/lib/duracloud/has_properties.rb

@@ -0,0 +1,45 @@
+module Duracloud
+  module HasProperties
+
+    def self.included(base)
+      base.class_eval do
+        include Persistence
+
+        before_delete :reset_properties
+        after_save :reset_properties
+      end
+    end
+
+    def properties
+      load_properties if persisted? && @properties.nil?
+      @properties ||= properties_class.new
+    end
+
+    def load_properties
+      response = get_properties_response
+      self.properties = response.headers
+      yield response if block_given?
+      persisted!
+    end
+
+    private
+
+    def properties=(props)
+      filtered = props ? properties_class.filter(props) : props
+      @properties = properties_class.new(filtered)
+    end
+
+    def reset_properties
+      @properties = nil
+    end
+
+    def properties_class
+      Properties
+    end
+
+    def get_properties_response
+      raise NotImplementedError, "Class must implement `get_properties_response`."
+    end
+
+  end
+end

data/lib/duracloud/persistence.rb

@@ -0,0 +1,59 @@
+require "active_model/callbacks"
+
+module Duracloud
+  module Persistence
+
+    def self.included(base)
+      base.class_eval do
+        extend ActiveModel::Callbacks
+
+        define_model_callbacks :save, :delete
+      end
+    end
+
+    def save
+      raise Error, "Cannot save deleted #{self.class}." if deleted?
+      run_callbacks :save do
+        do_save
+        persisted!
+      end
+    end
+
+    def delete
+      raise Error, "Cannot delete, already deleted." if deleted?
+      run_callbacks :delete do
+        do_delete
+        deleted!
+        freeze
+      end
+    end
+
+    def persisted?
+      !!@persisted
+    end
+
+    def deleted?
+      !!@deleted
+    end
+
+    private
+
+    def persisted!
+      @persisted = true
+    end
+
+    def deleted!
+      @deleted = true
+      @persisted = false
+    end
+
+    def do_delete
+      raise NotImplementedError, "Classes must implement `do_delete`."
+    end
+
+    def do_save
+      raise NotImplementedError, "Classes must implement `do_save`."
+    end
+
+  end
+end

data/lib/duracloud/properties.rb

@@ -0,0 +1,108 @@
+require 'hashie'
+require 'time'
+require 'date'
+
+module Duracloud
+  # @abstract
+  class Properties < Hashie::Mash
+
+    PREFIX = "x-dura-meta-".freeze
+
+    # Space properties
+    SPACE = /\A#{PREFIX}space-(count|created)\z/
+
+    # Space ACL headers
+    SPACE_ACLS = /\A#{PREFIX}acl-/
+
+    # Copy Content headers
+    COPY_CONTENT = /\A#{PREFIX}copy-source(-store)\z/
+
+    # DuraCloud internal content properties
+    INTERNAL = /\A#{PREFIX}content-(mimetype|size|checksum|modified)\z/
+
+    # Properties set by the DuraCloud SyncTool
+    SYNCTOOL = /\A#{PREFIX}(creator|(content-file-(created|modified|last-accessed-path)))\z/
+
+    def self.property?(prop)
+      duraspace_property?(prop) && !internal_property?(prop)
+    end
+
+    def self.filter(hsh)
+      hsh.select { |k, v| property?(k) }
+    end
+
+    def self.duraspace_property?(prop)
+      prop.start_with?(PREFIX)
+    end
+
+    def self.internal_property?(prop)
+      INTERNAL =~ prop
+    end
+
+    def self.space_property?(prop)
+      SPACE =~ prop
+    end
+
+    def self.space_acl?(prop)
+      SPACE_ACLS =~ prop
+    end
+
+    def self.copy_content_property?(prop)
+      COPY_CONTENT =~ prop
+    end
+
+    def property?(prop)
+      self.class.property?(prop)
+    end
+
+    def regular_writer(key, value)
+      if property?(key)
+        super
+      else
+        raise Error, "#{self.class}: Unrecognized or restricted property \"#{key}\"."
+      end
+    end
+
+    def convert_key(key)
+      force_ascii(duraspace_property!(super))
+    end
+
+    def convert_value(value, _ = nil)
+      case value
+      when Array
+        convert_array(value)
+      when Time
+        value.utc.iso8601
+      when DateTime
+        convert_value(value.to_time)
+      else
+        force_ascii(value.to_s)
+      end
+    end
+
+    private
+
+    # coerce to a Duraspace property
+    def duraspace_property!(prop)
+      prop.dup.tap do |p|
+        p.gsub!(/_/, '-')
+        p.downcase!
+        p.prepend(PREFIX) unless self.class.duraspace_property?(p)
+      end
+    end
+
+    def convert_array(value)
+      value.uniq!
+      if value.length > 1
+        value.map { |v| convert_value(v) }
+      else
+        convert_value(value.first)
+      end
+    end
+
+    def force_ascii(str)
+      str.ascii_only? ? str : str.force_encoding("US-ASCII")
+    end
+
+  end
+end

data/lib/duracloud/request.rb

@@ -1,25 +1,34 @@
-require_relative "connection"
-require_relative "response"
-require_relative "request_options"
+require "duracloud/connection"
+require "duracloud/response"
 
 module Duracloud
   class Request
-    attr_reader :client, :url, :http_method, :options
+    attr_reader :client, :url, :http_method, :body, :headers, :query
 
-    def initialize(client, http_method, url, **options)
+    # @param client [Duracloud::Client] the client
+    # @param http_method [Symbol] the lower-case symbol corresponding to HTTP method
+    # @param url [String] relative or absolute URL
+    # @param body [String] the body of the request
+    # @param headers [Hash] HTTP headers
+    # @param query [Hash] Query string parameters
+    def initialize(client, http_method, url, body: nil, headers: nil, query: nil)
       @client      = client
       @http_method = http_method
       @url         = url
-      @options = RequestOptions.new(**options)
+      @body        = body
+      @headers     = headers
+      @query       = query
     end
 
     def execute
-      original_response = connection.send(http_method,
-                                          url,
-                                          body: options.payload,
-                                          query: options.query,
-                                          header: options.headers)
-      response_class.new(original_response)
+      begin
+        original_response = connection.send(http_method,
+                                            url,
+                                            body: body,
+                                            query: query,
+                                            header: headers)
+        Response.new(original_response)
+      end
     end
 
     private
@@ -28,10 +37,6 @@ module Duracloud
       '/'
     end
 
-    def response_class
-      Response
-    end
-
     def connection
       @connection ||= Connection.new(client, base_path)
     end

data/lib/duracloud/response.rb

@@ -1,22 +1,9 @@
 require "forwardable"
-require_relative "error_handler"
 
 module Duracloud
   class Response
     extend Forwardable
 
-    # class << self
-    #   def error_handler
-    #     @error_handler ||=
-    #       begin
-    #         class_name = self.name.split(/::/).last.sub(/Response\z/, "ErrorHandler")
-    #         Duracloud.const_get(class_name)
-    #       rescue NameError
-    #         superclass.error_handler
-    #       end
-    #   end
-    # end
-
     attr_reader :original_response
 
     delegate [:header, :body, :code, :ok?, :redirect?, :status, :reason] => :original_response,
@@ -24,11 +11,10 @@ module Duracloud
              [:size, :empty?] => :body
 
     def_delegator :header, :request_uri, :url
+    def_delegator :header, :request_method
 
     def initialize(original_response)
       @original_response = original_response
-      #self.class.error_handler.call(self) if error?
-      ErrorHandler.call(self) if error?
     end
 
     def error?

data/lib/duracloud/rest_methods.rb

@@ -0,0 +1,89 @@
+require "duracloud/durastore_request"
+
+module Duracloud
+  module RestMethods
+
+    def get_stores
+      durastore :get, "stores"
+    end
+
+    def get_spaces
+      durastore :get, "spaces"
+    end
+
+    def get_space(space_id, query: nil)
+      durastore :get, space_id, query: query
+    end
+
+    def get_space_properties(space_id)
+      durastore :head, space_id
+    end
+
+    def get_space_acls(space_id)
+      durastore :head, "acl/#{space_id}"
+    end
+
+    def set_space_acls(space_id, acls)
+      durastore :post, space_id, properties: acls
+    end
+
+    def create_space(space_id)
+      durastore :put, space_id
+    end
+
+    def delete_space(space_id)
+      durastore :delete, space_id
+    end
+
+    def get_content(url, **options)
+      durastore :get, url, **options
+    end
+
+    def get_content_properties(url, **options)
+      durastore :head, url, **options
+    end
+
+    def set_content_properties(url, **options)
+      durastore :post, url, **options
+    end
+
+    def store_content(url, **options)
+      durastore :put, url, **options
+    end
+
+    def delete_content(url, **options)
+      durastore :delete, url, **options
+    end
+
+    def get_audit_log
+      raise NotImplementedError
+    end
+
+    def get_manifest
+      raise NotImplementedError
+    end
+
+    def get_bit_integrity_report
+      raise NotImplementedError
+    end
+
+    def get_bit_integrity_report_properties
+      raise NotImplementedError
+    end
+
+    def get_tasks
+      raise NotImplementedError
+    end
+
+    def perform_task
+      raise NotImplementedError
+    end
+
+    private
+
+    def durastore(*args)
+      execute(DurastoreRequest, *args)
+    end
+
+  end
+end

data/lib/duracloud/space.rb

@@ -0,0 +1,104 @@
+require "date"
+require "nokogiri"
+require "forwardable"
+
+require "duracloud/persistence"
+require "duracloud/has_properties"
+require "duracloud/space_properties"
+require "duracloud/space_acls"
+
+module Duracloud
+  class Space
+    extend Forwardable
+    include Persistence
+    include HasProperties
+
+    MAX_RESULTS = 1000
+
+    def self.all
+      response = Client.get_spaces
+      doc = Nokogiri::XML(response.body)
+      doc.css('space').map { |s| new(s['id']) }
+    end
+
+    def self.create(id)
+      # TODO
+    end
+
+    def self.find(id)
+      space = new(id)
+      space.load_properties
+      space
+    end
+
+    attr_reader :id
+
+    delegate [:count, :created] => :properties
+
+    after_save :reset_acls
+    before_delete :reset_acls
+
+    def initialize(id)
+      @id = id
+    end
+
+    def acls
+      @acls ||= SpaceAcls.new(self)
+    end
+
+    def each(prefix: nil)
+      raise Error, "Space not yet persisted." unless persisted?
+      num = 0
+      while num < count
+        response = Client.get_space(id, query: {prefix: prefix, max_results: MAX_RESULTS})
+        xml = Nokogiri::XML(response.body)
+        content_ids = xml.css('item').map(&:text)
+        content_ids.each do |content_id|
+          yield content_id
+        end
+        num += content_ids.length
+      end
+    end
+
+    def each_item(prefix: nil)
+      each(prefix: prefix) do |content_id|
+        yield Content.find(self, content_id)
+      end
+    end
+
+    private
+
+    def reset_acls
+      @acls = nil
+    end
+
+    def create
+      Client.create_space(id)
+    end
+
+    def update
+      Client.set_space_acls(id, acls)
+    end
+
+    def properties_class
+      SpaceProperties
+    end
+
+    def get_properties_response
+      Client.get_space_properties(id)
+    end
+
+    def do_delete
+      Client.delete_space(id)
+    end
+
+    def do_save
+      if persisted?
+        update
+      else
+        create
+      end
+    end
+
+  end
+end

data/lib/duracloud/space_acls.rb

@@ -0,0 +1,23 @@
+require "delegate"
+require "duracloud/properties"
+
+module Duracloud
+  class SpaceAcls < Properties
+
+    def self.property?(prop)
+      space_acl?(prop)
+    end
+
+    attr_reader :space
+
+    def initialize(space)
+      super()
+      @space = space
+      if space.persisted?
+        response = Client.get_space_acls(space.id)
+        update SpaceAcls.filter(response.headers)
+      end
+    end
+
+  end
+end

data/lib/duracloud/space_properties.rb

@@ -0,0 +1,22 @@
+require "date"
+require "duracloud/properties"
+
+module Duracloud
+  class SpaceProperties < Properties
+
+    def self.property?(prop)
+      space_property?(prop)
+    end
+
+    def count
+      space_count.to_i
+    end
+
+    def created
+      DateTime.parse(space_created)
+    rescue ArgumentError
+      space_created
+    end
+
+  end
+end