rsbe-client 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9782c78a09597d6fee30ab7c6853c4a2c5ddce3d
+  data.tar.gz: 87adba5bdde063e8951e53499224037420ff4c12
+SHA512:
+  metadata.gz: b6769297879400a946220562a7e5a9fe1bb360773b1618246c54e7f9860dce6aab4bfb0bbab6cde1ae07c3b0e1940fa09d68a04961c2ecaff99e0984b400a0fc
+  data.tar.gz: ae2f8b4c95a096dc8d1a975fc7581efa23e42f4afd5dbdbeb7a4b325ddb869e4d79428988dec2a39c906d5b0975c10ef30d7480ec92b27cd166171339cbaed1d

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+.ruby-gemset
+*~
+.DS_Store

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/GETTING-STARTED.md

@@ -0,0 +1,17 @@
+## Getting Started
+
+The following instructions assume that you have [`RVM` installed](https://rvm.io/rvm/install).
+
+```
+git clone git@github.com:NYULibraries/rsbe-client.git
+cd rsbe-client
+rvm install 2.3
+rvm use 2.3
+rvm --ruby-version gemset use rsbe-client --create
+gem install bundler
+bundle
+rake
+```
+
+
+ 

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rsbe-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 jgpawletko
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# Rsbe::Client
+
+Client library for interaction with the rsbe API
+
+## Current Status
+
+### *UNDER DEVELOPMENT*
+
+## Description
+
+This library allows one to interact with the R* Backend (rsbe) API.
+
+#### Completed User stories:
+* As an Authorized Client, I want to create a new Partner and have it persist.
+* As an Authorized Client, I want to update a Partner.
+* As an Authorized Client, I want to find a Partner by id.
+* As an Authorized Client, I want to get a list of all available Partners.
+
+
+#### Required Environment Variables:
+```
+RSBE_URL
+RSBE_USER
+RSBE_PASSWORD
+```
+
+e.g.,
+```
+export RSBE_URL='https://rsbe.example.com'
+export RSBE_USER='foo'
+export RSBE_PASSWORD='bar'
+```
+
+#### Usage (irb example from project root)
+```
+$ irb -I lib
+irb> require 'rsbe/client'
+ => true 
+irb> include Rsbe::Client
+ => Object
+
+irb> Partner.all.each {|p| puts p.id}
+51213be7-c8de-4e06-8cc2-06bfc82cdd68
+977e659b-886a-4626-8799-8979426ad2b3
+...
+```
+
+#### Usage (code example)
+```
+...
+def select_item_or_exit(items, label)
+  # do some stuff
+end
+...
+
+partners = Rsbe::Client::Partner.all
+partners.sort! { |a, b| a.code <=> b.code }
+partner = select_item_or_exit(partners, 'partner')
+
+collections = partner.collections.sort { |a, b| a.code <=> b.code }
+collection = select_item_or_exit(collections, 'collection')
+puts "collection: #{collection.code}, #{collection.name} #{collection.id}"
+...
+```
+
+#### Methods:
+```
+Rsbe::Partner#save
+Rsbe::Partner#code
+Rsbe::Partner#name
+Rsbe::Partner#collections
+```
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end

data/TODO.md

@@ -0,0 +1,38 @@
+## TODO
+[ ] consider creating request and response classes that handle 404, 201, 200, etc.
+[ ] consider base class with get/put/post/delete methods that can be overridden, or better yet, create a "Connection" class
+    which would be useful for class-level operations as well.  Then objects would have a @conn instance variable.
+
+#### Pending User stories:
+* As an Authorized Client, I want to find a Partner by code.
+* As an Authorized Client, I want to list the Colls for a Partner.
+
+* As an Authorized Client, I want to create a new Coll and have it persist.
+
+* As an Authorized Client, I want to create a new FMD.
+* As an Authorized Client, I want to use a checksum to find a list of all matching files with that same checksum.
+* As an Authorized Client, I want to update the last ping datetime of an FMD.
+* As an Authorized Client, I want to add a checksum value to an FMD.
+* As an Authorized Client, I want to update the last fixity check datetime of an FMD.
+* As an Authorized Client, I want to update the path of an FMD.
+* As an Authorized Client, I want to find the id of an Fmd given its path.
+
+
+#### Possible Usage
+```ruby
+p = Rsbe::Client::Partner.new(attrs)
+p.save                                      # => true or false
+```
+
+```ruby
+p = Rsbe::Client::Partner.find_by_code(code)
+p.name = "Lorem Ipsum"
+p.save
+c = p.collections.new(attrs)
+c.quota = 9999
+c.ready_for_content = true
+unless c.save
+  puts c.errors
+end
+```
+

data/lib/rsbe/client.rb

@@ -0,0 +1,50 @@
+#CLIENT_CLASS = %w()
+%w(base
+partner
+collection
+provider
+se
+connection not_found_error
+method_not_implemented_error
+wrong_origin_error
+unrecognized_resource_error
+search
+search_results).each do |r|
+  require_relative "./client/#{r}"
+end
+
+module Rsbe
+  module Client
+    def self.find(url)
+      assert_same_origin(url)
+      find_and_instantiate(url)
+    end
+
+    def self.assert_same_origin(url)
+      conn = Rsbe::Client::Connection.new
+      unless conn.same_origin?(url)
+        raise Rsbe::Client::WrongOriginError.new("incorrect origin: #{url}")
+      end
+    end
+    private_class_method :assert_same_origin
+
+    def self.find_and_instantiate(url)
+      retval = nil
+      [
+        Rsbe::Client::Partner,
+        Rsbe::Client::Provider,
+        Rsbe::Client::Collection,
+        Rsbe::Client::Se
+      ].each do |klass|
+        # UUID Regexp from http://stackoverflow.com/a/14166194
+        m = /#{klass.base_path}\/(?<uuid>[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12})\z/i.match(url)
+        next if m.nil?
+        retval = klass.find(m['uuid'])
+        break
+      end
+      raise Rsbe::Client::UnrecognizedResourceError.new("no matching resource found for #{url}") if retval.nil?
+      retval
+    end
+    private_class_method :find_and_instantiate
+  end
+end

data/lib/rsbe/client/base.rb

@@ -0,0 +1,140 @@
+require 'faraday'
+require 'json'
+module Rsbe
+  module Client
+    class Base
+      def self.find(id)
+        o = find_and_instantiate(id)
+        raise Rsbe::Client::RecordNotFound.new("#{self.name} with #{id} not found") if o.nil?
+        o
+      end
+
+      # returns an array of Partner objects
+      def self.all
+        conn = Rsbe::Client::Connection.new
+        local_response = conn.get base_path
+        raise "Error retrieving partners" unless local_response.status == 200
+        JSON.parse(local_response.body).collect { |json_hash| new(json_hash) }
+      end
+
+      def self.find_and_instantiate(id)
+        p = self.new(id: id)
+        if p.send(:get)
+          p.send(:update_hash_from_response)
+        else
+          p = nil
+        end
+        p
+      end
+      private_class_method :find_and_instantiate
+
+      def initialize
+        @conn = Rsbe::Client::Connection.new
+      end
+      def self.base_path
+        '/api/v0'
+      end
+      def save
+        (has_id? && exists?) ? update : create
+      end
+
+      private
+      # N.B. intentionally not updating hash here
+      def get(id = @hash[:id])
+        @response = @conn.get item_path(id)
+        @response.status == 200
+      end
+
+      def get_children(path_segment)
+        path = item_path(id) + '/' + path_segment
+        @response = @conn.get path
+        @response.status == 200
+      end
+
+      def create
+        @response = @conn.post do |req|
+          req.url coll_path
+          req.headers['Content-Type'] = 'application/json'
+          req.body = @hash.to_json
+        end
+        return false unless @response.status == 201
+
+        update_hash_from_response
+        true
+      end
+
+      def update_hash_from_response
+        raise "@response not initialized" if @response.nil?
+
+        # update attributes with those from server
+        response_hash = JSON.parse(@response.body)
+        raise "unable to parse response to hash" unless response_hash.is_a?(Hash)
+        update_hash(response_hash)
+      end
+
+      def update_hash_nils_from_response
+        raise "@response not initialized" if @response.nil?
+
+        # update attributes with those from server
+        response_hash = JSON.parse(@response.body)
+        raise "unable to parse response to hash" unless response_hash.is_a?(Hash)
+        update_hash_nils(response_hash)
+      end
+
+      def update_hash(arg)
+        # update object state
+        self.class.all_attrs.each { |k| (@hash[k] = arg[k.to_s]) if arg.has_key?(k.to_s) }
+      end
+
+      def update_hash_nils(arg)
+        # update object state
+        self.class.all_attrs.each do |k|
+          (@hash[k] = arg[k.to_s]) if @hash[k].nil?
+        end
+      end
+
+      def update
+        @response = @conn.put do |req|
+          req.url item_path(@hash[:id])
+          req.headers['Content-Type'] = 'application/json'
+          req.body = @hash.to_json
+        end
+
+        success = @response.status == 204
+        if success
+          get
+          update_hash_from_response
+        end
+        success
+      end
+
+      def has_id?
+        !@hash[:id].nil?
+      end
+
+      def exists?
+        get
+      end
+
+      def coll_path
+        self.class.base_path
+      end
+
+      def item_path(id)
+        coll_path + "/#{id}"
+      end
+
+      def self.rw_attrs
+        []
+      end
+
+      def self.ro_attrs
+        []
+      end
+
+      def self.all_attrs
+        self.rw_attrs + self.ro_attrs
+      end
+    end
+  end
+end

data/lib/rsbe/client/collection.rb

@@ -0,0 +1,84 @@
+require 'active_support'
+
+module Rsbe
+  module Client
+    # Class simplifies interaction with RSBE Partner resources
+    class Collection < Base
+      def self.all
+        emsg = 'Method not supported. Access via Rsbe::Client::Partner#collections'
+        fail Rsbe::Client::MethodNotImplementedError, emsg
+      end
+
+      def self.base_path
+        super + '/colls'
+      end
+
+      def self.rw_attrs
+        [:id, :code, :partner_id, :coll_type, :quota, :name, :rel_path]
+      end
+
+      def self.ro_attrs
+        [:created_at, :updated_at, :lock_version]
+      end
+
+      def self.all_attrs
+        rw_attrs + ro_attrs
+      end
+
+      # define setter methods for RW attributes
+      rw_attrs.each  { |m| define_method("#{m}=") { |v| @hash[m] = v } }
+
+      # define getter methods for ALL attributes
+      all_attrs.each do |m|
+        define_method("#{m}")  do
+          @hash[m] || begin
+                        # only fetch if Partner has a known id
+                        if @hash[:id]
+                          # TODO: CLEAN THIS UP
+                          # This works currently because when a 404 is
+                          # returned there is nothing in the response
+                          # hash that matches the resource attributes,
+                          # but relying on this behavior seems very
+                          # brittle. Additionally, for every attribute
+                          # queried, a GET operation is performed.
+                          # Should store the object lifecycle state,
+                          # e.g.,
+                          # - new, no ID, no matching resource in RSBE: don't query RSBE
+                          # - new, ID assigned, but not yet    in RSBE: don't query RSBE
+                          # - existing, partially populated,
+                          #   not fully updated with RSBE values:             query RSBE
+                          # - existing, fully populated with data from RSBE
+                          # - existing, local modifications, not persisted to RSBE
+                          #
+                          get
+                          update_hash_nils_from_response
+                        end
+                        @hash[m]
+                      end
+        end
+      end
+
+      def initialize(vals = {})
+        fail(ArgumentError, 'Constructor requires a Hash') unless vals.is_a?(Hash)
+        super()
+        @hash = {}
+        @response = nil
+
+        # initialize local hash with incoming values, restrict to RW attrs
+        self.class.rw_attrs.each { |x| @hash[x] = (vals[x] || vals[x.to_s]) }
+      end
+
+      def create_path
+        fail 'partner_id not initialized!' unless partner_id
+        Rsbe::Client::Partner.item_path(partner_id)
+      end
+
+      def ses
+        fail 'Error getting source entities' unless get_children('ses')
+        JSON.parse(@response.body).collect do |json_hash|
+          Rsbe::Client::Se.new(json_hash)
+        end
+      end
+    end
+  end
+end