duracloud-client 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6733dd180dfccf317acf1938b3f95265ee321a0
-  data.tar.gz: a61cb47c8d1411efc8d031c1dea604d651b79a49
+  metadata.gz: b304d53dd688ed00817d59d286e32a5d53f88acc
+  data.tar.gz: 065f2f3e9f0307f83e863f8ba7b1a60b680414e5
 SHA512:
-  metadata.gz: fb3b785bbbcc959e96fa2b13a550688375e1f1dff06cf44d10bc8e4f6b1aa5b9f23c41066402e2b67bb16f804cee2b20e6b427f32d0d1b6bf6b2016af3a10f2a
-  data.tar.gz: 628e6c8c041862732675419e04bb0c404b5014097ba819c23f59dec17f3d208412e33e734edb657774d9853557e89aa4e59c7455e9fd11610d73860305e72836
+  metadata.gz: d73d05c4ef0bbd91a4928b79c2c260fdec0b755ece9a43423eac2229a56874c65e24e0e7cf8a7830dcabd02a293a0945a20a585c8bb2790493dae9a5d2be9220
+  data.tar.gz: 6f2edaffb35c789e94e264c4f97607129e403d6673f52dcf6a28af28719e50b82c4fe0b703555923aa417144a38962300c7e8fc11ef293cc18d8f50cbc24b13c

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+  

data/README.md

@@ -43,32 +43,71 @@ end
  => #<Duracloud::Client:0x007fe953a1c630 @config=#<Duracloud::Configuration host="foo.duracloud.org", port=nil, user="bob@example.com", password="******">>
  ```
 
-### Create a new content item and store it in DuraCloud
+#### Logging
 
-If a relative URL is given (`:url` keyword option, or a combination of `:space_id` and `:content_id` options), the fully-qualified URL is built in the standard way from the base URL `https://{host}:{port}/durastore/`.
+By default, `Duracloud::Client` logs to `STDERR`.  Use the `logger` config setting to change:
 
+```ruby
+Duracloud::Client.configure do |config|
+  config.logger = Rails.logger
+end
 ```
-> new_content = Duracloud::Content.new(space_id: "rest-api-testing", content_id: "ark:/99999/fk4zzzz")
- => #<Duracloud::Content url="rest-api-testing/ark:/99999/fk4zzzz">
-> new_content.body = "test"
+
+### List Storage Providers
+
+```
+> stores = Duracloud::Store.all
+ => [#<Duracloud::Store:0x007faa592e9068 @owner_id="0", @primary="0", @id="1", @provider_type="AMAZON_GLACIER">, #<Duracloud::Store:0x007faa592dbd78 @owner_id="0", @primary="1", @id="2", @provider_type="AMAZON_S3">]
+
+> stores.first.primary?
+ => false 
+```
+
+### Space Methods
+
+TODO
+
+### Content Methods
+
+#### Create a new content item and store it in DuraCloud
+
+1. Initialize instance of `Duracloud::Content` and save:
+
+```
+>> new_content = Duracloud::Content.new(space_id: "rest-api-testing", id: "ark:/99999/fk4zzzz")
+ => #<Duracloud::Content space_id="rest-api-testing", id="ark:/99999/fk4zzzz">
+ 
+>> new_content.body = "test"
  => "test"
-> new_content.content_type = "text/plain"
+
+>> new_content.content_type = "text/plain"
  => "text/plain"
-> new_content.store
- => #<Duracloud::Content url="rest-api-testing/ark:/99999/fk4zzzz">
+ 
+>> new_content.save
+ => #<Duracloud::Content space_id="rest-api-testing", id="ark:/99999/fk4zzzz">
+```
+
+2. Create with class method `Duracloud::Content.create`:
+
+```
+>> Duracloud::Content.create(space_id: "rest-api-testing", id="ark:/99999/fk4zzzz") do |c|
+     c.body = "test"
+     c.content_type = "text/plain"
+   end
+ => #<Duracloud::Content space_id="rest-api-testing", id="ark:/99999/fk4zzzz">
 ```
 
-### Retrieve an existing content item from DuraCloud
+#### Retrieve an existing content item from DuraCloud
 
 ```ruby
-Duracloud::Content.find(**options) # :url, or :space_id and :content_id
+Duracloud::Content.find(id: "contentID", space_id: "spaceID") 
 ```
 
-### Update the properties for an item
+#### Update the properties for an item
 
 TODO
 
-### Delete a content item
+#### Delete a content item
 
 TODO
 
@@ -76,10 +115,14 @@ TODO
 
 We endeavor to follow semantic versioning.  In particular, versions < 1.0 may introduce backward-incompatible changes without notice.  Use at your own risk.  Version 1.0 signals a stable API.
 
-## Maintainers
+## Contributing
 
-* David Chandek-Stark (Duke University)
+1. Fork it ( https://github.com/[my-github-username]/duracloud-ruby-client/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
 
-## Contributing
+## Maintainers
 
-TODO
+* [David Chandek-Stark](https://github.com/dchandekstark) (Duke University)

data/Rakefile

@@ -1,2 +1,8 @@
 require "bundler/gem_tasks"
 
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+end

data/duracloud.gemspec

@@ -18,9 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = ">= 2.1"
+
   spec.add_dependency "hashie", "~> 3.4"
   spec.add_dependency "httpclient", "~> 2.7"
+  spec.add_dependency "activemodel", "~> 4.2"
+  spec.add_dependency "nokogiri", "~> 1.6"
 
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "rspec-its", "~> 1.2"
   spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 11.1"
 end

data/lib/duracloud/client.rb

@@ -1,11 +1,19 @@
 require "forwardable"
-require_relative "configuration"
-require_relative "connection"
-require_relative "content_request"
+
+require "duracloud/configuration"
+require "duracloud/connection"
+require "duracloud/error_handler"
+require "duracloud/rest_methods"
 
 module Duracloud
   class Client
     extend Forwardable
+    extend RestMethods
+    include RestMethods
+
+    def self.execute(request_class, http_method, url, **options)
+      new.execute(request_class, http_method, url, **options)
+    end
 
     def self.configure
       yield Configuration
@@ -13,35 +21,31 @@ module Duracloud
 
     attr_reader :config
 
-    delegate [:host, :port, :user, :password, :base_url] => :config
+    delegate [:host, :port, :user, :password, :base_url, :logger] => :config
 
     def initialize(**options)
       @config = Configuration.new(**options)
     end
 
-    def get_content(url, **options)
-      execute ContentRequest, :get, url, **options
-      #ContentRequest.get(self, url, **options)
-    end
-
-    def get_content_properties(url, **options)
-      execute ContentRequest, :head, url, **options
-    end
-
-    def set_content_properties(url, **options)
-      execute ContentRequest, :post, url, **options
-    end
-
-    def store_content(url, **options)
-      execute ContentRequest, :put, url, **options
-    end
-
-    def delete_content(url, **options)
-      execute ContentRequest, :delete, url, **options
-    end
-
     def execute(request_class, http_method, url, **options)
-      request_class.new(self, http_method, url, **options).execute
+      request = request_class.new(self, http_method, url, **options)
+      response = request.execute
+      handle_response(response)
+      response
+    end
+
+    private
+
+    def handle_response(response)
+      logger.debug([self.class.to_s, response.request_method, response.url,
+                    response.status, response.reason].join(' '))
+      if response.error?
+        ErrorHandler.call(response)
+      elsif %w(POST PUT DELETE).include?(response.request_method) &&
+            response.plain_text? &&
+            response.has_body?
+        logger.info(response.body)
+      end
     end
   end
 end

data/lib/duracloud/configuration.rb

@@ -1,16 +1,21 @@
+require "logger"
+require "uri"
+
 module Duracloud
   class Configuration
+
     class << self
-      attr_accessor :host, :port, :user, :password
+      attr_accessor :host, :port, :user, :password, :logger
     end
 
-    attr_reader :host, :port, :user, :password
+    attr_reader :host, :port, :user, :password, :logger
 
-    def initialize(host: nil, port: nil, user: nil, password: nil)
+    def initialize(host: nil, port: nil, user: nil, password: nil, logger: nil)
       @host     = host     || default(:host)
       @port     = port     || default(:port)
       @user     = user     || default(:user)
       @password = password || default(:password)
+      @logger   = logger   || Logger.new(STDERR)
       freeze
     end
 
@@ -18,14 +23,16 @@ module Duracloud
       URI::HTTPS.build(host: host, port: port)
     end
 
+    def inspect
+      "#<#{self.class} host=#{host.inspect}, port=#{port.inspect}, user=#{user.inspect}," \
+      " password=\"******\", logger=#{logger.inspect}>"
+    end
+
     private
 
     def default(attr)
       self.class.send(attr) || ENV["DURACLOUD_#{attr.to_s.upcase}"]
     end
 
-    def inspect
-      "#<#{self.class} host=#{host.inspect}, port=#{port.inspect}, user=#{user.inspect}, password=\"******\">"
-    end
   end
 end

data/lib/duracloud/connection.rb

@@ -9,20 +9,10 @@ module Duracloud
   # custom case-sensitive content property headers (x-dura-meta-*).
   #
   class Connection < HTTPClient
-    # class << self
-    #   attr_accessor :base_path
-    # end
-
-    # self.base_path = '/'
-
     def initialize(client, base_path = '/')
       base_url = client.base_url + base_path
       super(base_url: base_url, force_basic_auth: true)
       set_auth(client.base_url, client.user, client.password)
     end
   end
-
-  # class DurastoreConnection < Connection
-  #   self.base_path = '/durastore/'
-  # end
 end

data/lib/duracloud/content.rb

@@ -1,127 +1,189 @@
-require 'uri'
-require 'forwardable'
-require_relative 'content_properties'
+require "uri"
+require "stringio"
+require "active_model"
+
+require "duracloud/content_properties"
+require "duracloud/persistence"
+require "duracloud/has_properties"
 
 module Duracloud
   #
   # A piece of content in DuraCloud
   #
   class Content
-    extend Forwardable
-
-    class << self
-      def from_response(response)
-        new(url: response.url) { |c| c.load_from_response(response) }
+    include ActiveModel::Dirty
+    include Persistence
+    include HasProperties
+
+    after_save :changes_applied
+
+    # Find content in DuraCloud.
+    #
+    # @param id [String] the content ID
+    # @param space_id [String] the space ID.
+    # @return [Duraclound::Content] the content
+    # @raise [Duracloud::NotFoundError] the space or content ID does not exist.
+    def self.find(id:, space_id:)
+      new(id: id, space_id: space_id) do |content|
+        content.load_properties
       end
+    end
 
-      def find(**options)
-        new(**options).get
+    # Store content in DuraCloud
+    #
+    # @param id [String] The content ID
+    # @param space_id [String] The space ID.
+    # @param body [String, #read] The content body
+    # @return [Duracloud::Content] the content
+    # @raise [Duracloud::NotFoundError] if the space ID does not exist
+    # @raise [Duracloud::Error] if the body is empty.
+    def self.create(id:, space_id:, body:)
+      new(id: id, space_id: space_id) do |content|
+        content.body = body
+        yield content if block_given?
+        content.save
       end
+    end
 
-      def create(**options)
-        new(**options).store
-      end
+    attr_reader :id, :space_id
+
+    define_attribute_methods :content_type, :body, :md5
+
+    # Initialize a new piece of content
+    #
+    # @param id [String] The content ID
+    # @param space_id [String] The space ID
+    #
+    # @example
+    #   new(id: mycontent.txt", space_id: "myspace")
+    def initialize(id:, space_id:)
+      @id = id.freeze
+      @space_id = space_id.freeze
+      @body = nil
+      @content_type = nil
+      @md5 = nil
+      yield self if block_given?
     end
 
-    attr_reader :url
-    attr_accessor :md5, :content_type, :body
+    def space
+      Space.find(space_id)
+    end
 
-    delegate :empty? => :body
+    def inspect
+      "#<#{self.class} id=#{id.inspect}, space_id=#{space_id.inspect}>"
+    end
 
-    alias_method :checksum, :md5
+    # @api private
+    # @raise [Duracloud::NotFoundError] the content does not exist in DuraCloud.
+    def load_body
+      response = Client.get_content(url)
+      @body = response.body # don't use setter
+      persisted!
+    end
 
-    def initialize(**options)
-      url = if options[:url]
-              options[:url]
-            else
-              unless options[:space_id] && options[:content_id]
-                raise Error, "Content requires either :url OR both :space_id AND :content_id."
-              end
-              options.values_at(:space_id, :content_id).join('/')
-            end
-      @url = URI(url).path # might not be exactly what we want, but it works
-      @body = options[:body] || options[:payload]
-      @md5 = options[:md5]
-      @content_type = options[:content_type]
-      self.properties = options[:properties].to_h
-      yield self if block_given?
+    def load_properties
+      super do |response|
+        # don't mark content_type as changed
+        @content_type = response.content_type
+      end
     end
 
-    def inspect
-      "#<#{self.class} url=#{url.inspect}>"
+    def body=(str_or_io)
+      val = read_string_or_io(str_or_io)
+      raise ArgumentError, "Cannot set body to empty string." if val.empty?
+      self.md5 = Digest::MD5.hexdigest(val)
+      body_will_change! if md5_changed?
+      @body = StringIO.new(val, "r")
     end
 
-    def to_s
-      body
+    def body
+      load_body if persisted? && empty?
+      @body
     end
 
-    def get
-      response = client.get_content(url)
-      load_from_response(response)
-      self
+    def empty?
+      @body.nil? || @body.size == 0
     end
-    alias_method :reload, :get
 
-    def get_properties
-      response = client.get_content_properties(url)
-      load_properties_from_response(response)
-      self
+    def content_type=(val)
+      content_type_will_change! unless val == @content_type
+      @content_type = val
     end
-    alias_method :reload_properties, :get_properties
 
-    def set_properties
-      self.content_type = "text/plain" unless content_type
-      client.set_content_properties(url, properties: properties)
-      self
+    def content_type
+      @content_type
     end
 
-    def delete
-      client.delete_content(url)
-      reset
-      freeze
-      self
+    def md5
+      @md5
+    end
+
+    private
+
+    def md5=(val)
+      md5_will_change! unless val == @md5
+      @md5 = val
+    end
+
+    def set_properties
+      headers = properties.to_h
+      headers["Content-Type"] = content_type if content_type_changed?
+      response = Client.set_content_properties(url, headers: headers)
+      # response.body is a text message -- log?
     end
 
     def store
-      raise Error, "Refusing to store empty content file!" unless body
-      self.md5 = Digest::MD5.hexdigest(body) unless md5
-      unless content_type
-        self.content_type = body ? "application/octet-stream" : "text/plain"
-      end
-      options = {
-        payload: body, md5: md5, content_type: content_type, properties: properties
-      }
-      client.store_content(url, **options)
-      reload_properties
-      self
+      headers = { "Content-MD5" => md5,
+                  "Content-Type" => content_type || "application/octet-stream" }
+      headers.merge!(properties)
+      response = Client.store_content(url, body: body, headers: headers)
+      # response.body is a text message -- log?
     end
 
-    def load_from_response(response)
-      self.body = response.body
-      self.md5 = response.md5
-      self.content_type = response.content_type
-      load_properties_from_response(response)
+    def url
+      [space_id, id].join("/")
     end
 
-    def load_properties_from_response(response)
-      self.properties = response.headers.select { |h, v| ContentProperties.property?(h) }
+    def properties_class
+      ContentProperties
     end
 
-    def properties
-      @properties ||= ContentProperties.new
+    def get_properties_response
+      Client.get_content_properties(url)
     end
 
-    def properties=(props)
-      properties.replace(props)
+    def do_delete
+      Client.delete_content(url)
     end
 
-    def client
-      @client ||= Client.new
+    def do_save
+      if !empty? && body_changed?
+        store
+      elsif persisted?
+        set_properties
+      else
+        raise Error, "Cannot store empty content."
+      end
+    end
+
+    def read_string_or_io(str_or_io)
+      if str_or_io.respond_to?(:read)
+        read_io_like(str_or_io)
+      elsif str_or_io.respond_to?(:to_str)
+        str_or_io.to_str
+      else
+        raise ArgumentError, "IO-like or String-like argument required."
+      end
     end
 
-    def reset
-      properties.clear
-      @body, @md5, @content_type = nil, nil, nil
+    def read_io_like(io_like)
+      begin
+        io_like.rewind if io_like.respond_to?(:rewind)
+        io_like.read
+      ensure
+        io_like.rewind if io_like.respond_to?(:rewind)
+      end
     end
+
   end
 end