ruby-atmos-pure 1.0.3

data/lib/atmos/exceptions.rb

@@ -0,0 +1,28 @@
+module Atmos
+   module Exceptions
+
+      class AtmosException < Exception
+      end
+   
+      class ArgumentException < AtmosException
+      end
+
+      class AuthException < AtmosException
+      end
+   
+      class InvalidStateException < AtmosException
+      end
+   
+      class NoSuchObjectException < AtmosException
+      end
+   
+      class ServerException < AtmosException
+      end
+
+      class NotImplementedException < AtmosException
+      end
+   
+      class InternalLibraryException < AtmosException
+      end
+   end
+end

data/lib/atmos/object.rb

@@ -0,0 +1,321 @@
+module Atmos
+
+   #
+   # == Object
+   # This class represents an object in an Atmos store.
+   #
+   # === Object Data
+   # When an object is instantiated, it's data is not loaded
+   # due to memory considerations. You can access an object's
+   # data as a ruby String or as a progressive download via a block.
+   #
+   # ==== all at once
+   #
+   #   obj.data
+   #
+   # ==== progressive download
+   #
+   #   obj.data_as_stream do |chunk|
+   #      datafile.write(chunk)
+   #   end
+   #
+   # ==== partial data
+   #
+   #   obj.data_as_stream(0...59) do |chunk|
+   #      readin.concat(chunk)
+   #   end
+   #
+   #
+   # === System Metadata
+   # Each object has some information about it stored by the system.
+   # This information is read only, and available as a hash on the object:
+   #
+   #  obj.system_metadata => Hash
+   #
+   #  obj.system_metadata.each do |key,value|
+   #    puts "#{key}=#{value}"
+   #  end
+   #
+   # See Atmos::Metadata for more detailed information.
+   #
+   #
+   # === User Metadata
+   # There are two kinds of user metadata, listable and non-listable.
+   # Each of these is available as a hash
+   # on the object class.  These can both be modified.
+   #
+   #  obj.listable_metadata => Hash
+   #
+   #  obj.listable_metadata.each do |key,value|
+   #    puts "#{key}=#{value}"
+   #  end
+   #
+   #  obj.metadata => Hash
+   #
+   #  obj.metadata.each do |key,value|
+   #    puts "#{key}=#{value}"
+   #  end
+   #
+   # See Atmos::Metadata for more detailed information.
+   #
+   #
+   # === Access Control Lists (ACLs)
+   #
+   # There are two hashes for access control available as properties
+   # on the object: +user_acl+ and +group_acl+.  
+   # The keys are the Atmos usernames and the values are one of
+   # <tt>:none</tt>, <tt>:read</tt>, <tt>:write</tt>, <tt>:full</tt>.
+   #
+   #    puts obj.user_acl.inspect => {user => :full}
+   #    puts obj.group_acl.inspect => {other => :none}
+   #
+   # See Atmos::ACL for more detailed information.
+   #
+   #
+   class Object
+      attr_reader :aoid, :request, :user # :nodoc:
+      
+      @request    = nil
+      @checksum   = nil
+      @user_acl   = nil
+      @group_acl         = nil
+      @metadata          = nil
+      @system_metadata   = nil
+      @listable_metadata = nil
+    
+    
+      #
+      # This constructor is only meant for internal use.  Get or create an object
+      # with an Atmos::Store object:
+      #
+      #    obj = store.create
+      #    obj = store.get(:id => obj_id)
+      #    obj = store.get(:namespace => obj_id)
+      #
+      def initialize(store, action, options = {})
+         Atmos::LOG.debug("obj.new options: #{options.inspect}")   
+         validate_options(options)
+
+         @deleted    = false
+         @aoid       = aoid
+         @store      = store
+         @request    = Atmos::Request.new(:store => @store)
+         @user       = @store.user
+
+         if (action == :create)
+            
+               if (options[:id])
+                  raise Atmos::Exceptions::ArgumentException, "You can't specify an id on object creation."
+               end
+            
+               Atmos::LOG.debug("Object.new: creating new object")
+               response = @request.do(:create_object, options)
+               @aoid = response.id
+            
+         elsif (action == :get)
+            
+               Atmos::LOG.debug("Retrieving object: id: #{options[:id]}; namespace: #{options[:namespace]}")
+               response = @request.do(:get_object_info, options)
+               @aoid = Atmos::Parser::response_get_string(response.http_response, '//xmlns:objectId')            
+               Atmos::LOG.debug("Retrieved object id for namespace: #{@aoid}")
+         end
+
+      end
+      
+      #
+      # Lazy evaluation of hash-like object containing user access control properties of the object.
+      # 
+      def user_acl
+         #Atmos::LOG.warn("user_acl: #{@user_acl.inspect}")   
+         if (@user_acl.nil?)
+            @user_acl = Atmos::ACL.new(self, Atmos::ACL::USER)
+            #Atmos::LOG.warn("user_acl: #{@user_acl.inspect}")   
+         end
+         
+         @user_acl
+      end
+      
+      
+      #
+      # Lazy evaluation of hash-like object containing group access control properties of the object.
+      # 
+      def group_acl
+         if (@group_acl.nil?)
+            @group_acl = Atmos::ACL.new(self, Atmos::ACL::GROUP)
+         end
+         
+         @group_acl
+      end
+      
+      
+      #
+      # Lazy evaluation of hash-like object containing non-listable properties of the object.
+      # 
+      def metadata
+         if (@metadata.nil?)
+            @metadata = Atmos::Metadata.new(self, Atmos::Metadata::NON_LISTABLE)
+         end
+         
+         @metadata
+      end
+      
+      
+      #
+      # Lazy evaluation of hash-like object containing listable metadata properties of the object.
+      # 
+      def listable_metadata
+         if (@listable_metadata.nil?)
+            @listable_metadata = Atmos::Metadata.new(self, Atmos::Metadata::LISTABLE)
+         end
+         
+         @listable_metadata
+      end
+      
+      
+      #
+      # Lazy evaluation of Hash-like object containing read-only system metadata associated with the object.
+      # 
+      def system_metadata
+         if (@system_metadata.nil?)
+            @system_metadata = Atmos::Metadata.new(self, Atmos::Metadata::SYSTEM)
+         end
+         
+         @system_metadata
+      end
+      
+      
+      #
+      # Truncates the object to size 0 without changing any of the Metadata or ACLs.
+      #
+      def truncate
+         do_delete_check
+         response = @request.do(:trunc_object, :id => @aoid, :data => nil, :length => 0)
+      end
+      
+      #
+      # Deletes the object from Atmos and invalidates the object.
+      #
+      #    obj = store.create
+      #    obj.delete
+      #
+      def delete
+         do_delete_check
+         response = @request.do(:delete_object, :id => @aoid)
+         @deleted = true
+      end
+      
+      
+      #
+      # Returns all the object data in a single string.  Be judicious about
+      # use of this method, since it can load the entire blob into memory.
+      #
+      # Optional:
+      # * <tt>:range</tt> - range of bytes to retrieve (e.g. 0...10000)
+      #
+      def data(range = nil)
+         do_delete_check
+         response = @request.do(:read_object, :id => @aoid, 'Range' => range)
+         response.http_response.body
+      end
+      
+      
+      #
+      # Allows progressive download of the object's data.  Takes a block:
+      #
+      #   obj.data_as_stream do |chunk|
+      #      datafile.write(chunk)
+      #   end
+      #
+      # Optional:
+      # * <tt>:range</tt> - range of bytes to retrieve (e.g. 0...10000)
+      #
+      def data_as_stream(range = nil, &block)
+         do_delete_check
+         @request.do(:read_object, :id => @aoid, 'Range' => range) do |response|
+            response.read_body do |chunk| 
+               block.call(chunk)
+            end
+         end
+      end
+      
+      
+      def update(data, range=nil)    
+         response = @request.do(:update_object, :id => @aoid, :data => data, 'Range' => range)
+      end
+    
+    
+      #
+      # Checks to see if the represented object exists on Atmos
+      # by requesting it's system metadata.  
+      #
+      # Returns boolean +true+ or +false+.
+      #
+      def exists?
+         rv = true
+         begin
+            @request.do(:list_system_metadata, :id => @aoid)
+         rescue Atmos::Exceptions::NoSuchObjectException
+            rv = false
+         end
+         rv
+      end
+    
+    
+      def copy #:nodoc:
+         do_delete_check
+      end
+
+
+      def headers #:nodoc:
+         do_delete_check
+         headers = {}
+         [@user_acl, @group_acl, @tags, @listable_tags, @metadata, @listable_metadata].each do |attr|
+            val = attr.header_value
+            next if (val.nil? || val.empty?)
+            headers[attr.header_name] = attr.header_value
+         end
+         headers
+      end
+      
+      
+      private
+         def do_delete_check
+            raise Atmos::Exceptions::InvalidStateException if (@deleted)
+         end
+         
+         def validate_options(options)
+            invalid_values = []
+
+            valid_options = [:checksum, :user_acl, :group_acl, :metadata, :listable_metadata, :mimetype, :length, :data, :namespace, :id].freeze
+            invalid_options = options.keys - valid_options
+            raise Atmos::Exceptions::ArgumentException, "Unrecognized options: #{invalid_options.inspect}" if (!invalid_options.empty?)
+            
+            options.each do |k,v|
+               case k
+               when :checksum
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(Boolean))
+               when :user_acl
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(Hash))
+               when :group_acl
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(Hash))
+               when  :metadata
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(Hash))
+               when  :listable_metadata
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(Hash))
+               when  :mimetype
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(String))
+               when  :namespace
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(String))
+               when  :length 
+                  invalid_values.push(k) if (options[k].nil? || !options[k].kind_of?(Integer))
+               when  :data
+                  invalid_values.push(k) if (options[k].nil? || (!options[k].kind_of?(String) && !options[k].class.ancestors.include?(IO)))
+               end
+            end
+
+            raise Atmos::Exceptions::ArgumentException, "Options of invalid type: #{invalid_values.inspect}" if (!invalid_values.empty?)
+         end
+
+  end
+  
+end 

data/lib/atmos/parser.rb

@@ -0,0 +1,110 @@
+module Atmos
+   class Parser
+      
+      NOKOGIRI   = "nokogiri"
+      REXML      = "rexml"
+      @@parser   = nil
+
+   
+      def self.parser
+         @@parser
+      end
+      
+      
+      def self.parser=(which)
+         
+         @@parser = which
+         if (@@parser == NOKOGIRI)
+            require 'nokogiri'
+         elsif (@@parser == REXML)
+            require 'rexml/document'
+         else
+            raise Atmos::Exceptions::ArgumentException, "The XML parser has not been set to a known parser."
+         end
+      end
+      
+      
+      def self.response_get_array(response, string)
+         rv = nil
+         
+         if (parser == NOKOGIRI)
+            
+            doc = Nokogiri::XML(response.body)
+            rv  = doc.xpath(string).map do |elt|
+               elt.content
+            end
+        
+         elsif (parser == REXML)
+
+            doc = ::REXML::Document.new(response.body)
+            rv  = doc.elements.to_a(string).map do |elt|
+               elt.text
+            end
+            
+         end
+
+         rv
+      end
+      
+
+      def self.response_get_string(response, string)
+         response_get_array(response,string)[0]
+      end
+      
+      
+      #
+      # Utility method to check the atmos server XML response for errors.
+      # Throws exception on error.
+      #
+      def self.response_check_action_error(action, response)
+         doc     = nil
+         code    = nil
+         msg     = nil
+         exclass = Atmos::Exceptions::AtmosException
+         
+         Atmos::LOG.info("body: #{response.body}")
+         if (!response.body.nil? && response.body.match(/<\?xml/))
+            if (parser == NOKOGIRI)
+            
+               doc  = Nokogiri::XML(response.body)
+            
+               code = doc.xpath('//Error/Code')[0]  
+               code = code.content if (!code.nil?)
+            
+               msg  = doc.xpath('//Error/Message')[0]
+               msg  = msg.content if (!msg.nil?)
+                               
+            elsif (parser == REXML)
+           
+               code = response_get_string(response, '//Error/Code')
+               msg  = response_get_string(response, '//Error/Message')
+
+            else
+               raise Atmos::Exceptions::InvalidStateException, "The XML parser has not been set to a known parser."
+            end
+         end
+         
+         if (!code.nil?)
+            
+            Atmos::LOG.info("code: #{code}")
+            Atmos::LOG.info("msg: #{msg}")
+
+            if (!REST[action][:errors].nil? && !REST[action][:errors][code].nil?)
+               tmp = REST[action][:errors][code][:message]
+               msg = tmp if (!tmp.nil?)
+
+               tmp = REST[action][:errors][code][:class]
+               exclass = tmp if (!tmp.nil?)
+            end
+                        
+            raise exclass, msg
+            
+         end
+         
+         true
+      end
+
+
+
+   end
+end