ruby-atmos-pure 1.0.3

data/lib/atmos/parser/rexml.rb

@@ -0,0 +1 @@
+# This does nothing except signal that the chosen XML parser to use is REXML

data/lib/atmos/request.rb

@@ -0,0 +1,221 @@
+module Atmos
+      class Request # :nodoc:
+      
+      def initialize(options = {})
+         valid = [:store, :default_tag].freeze
+         invalid = options.keys - valid
+         raise Atmos::Exceptions::ArgumentException,
+               "Unrecognized options: #{invalid.inspect}" if (!invalid.empty?)
+         Atmos::LOG.debug("Request.initialize: options: #{options.inspect}")
+      
+         @baseurl = options[:store].uri
+         @uid     = options[:store].uid
+         @secret  = options[:store].secret
+         @http    = options[:store].http
+         @tag     = options[:default_tag]
+      end
+      
+      
+      #
+      # If there is no namespace option provided, we're using the object interface,
+      # otherwise we're using the namespace interface.  Determine which it is, so we know
+      # which URI to use.
+      #
+      # If aoid is nil, we're creating a new object regardless.
+      #
+      def get_uri(action, options)
+         
+         if (options.has_key?(:namespace) && action.has_key?(:namespace_uri))
+
+            # only two actions need namespace, so if the action doesn't have the 
+            # :namespace_url key, we use the regular :object_url.
+            ns = (options[:namespace].start_with?('/')) ? options[:namespace][1..-1] : options[:namespace]
+            uri = action[:namespace_uri].sub(/:namespace/, ns)
+            
+         else
+            
+            uri = action[:object_uri]
+
+            # only need the following check/substution if the uri requires an id
+            if (!uri.index(':id').nil?)
+
+               if (options.has_key?(:id) && !options[:id].nil?)
+                  uri = uri.sub(/:id/, options[:id])
+               else
+                  raise Atmos::Exceptions::ArgumentException, "An id is required for this action.  This is an internal error."
+               end
+            end
+         end
+
+         Atmos::LOG.info("uri: #{uri}")
+         uri
+      end
+         
+
+      
+      def do(actionname, options = {}, &block)
+         verbs = [:head, :get, :put, :post, :delete].freeze
+         Atmos::LOG.info("do #{actionname} options: #{options.inspect}")
+         raise Atmos::Exceptions::InternalLibraryException,
+               "Invalid REST action: #{actionname}" if (REST[actionname].nil?)
+         
+         action = REST[actionname]
+         uri    = get_uri(action, options)         
+         url    = URI::join(@baseurl.to_s, uri.to_s)
+         verb   = action[:verb]         
+
+         request = (verbs.include?(verb)) ? Net::HTTP.const_get(verb.to_s.capitalize).new(uri) : nil
+         raise Atmos::Exceptions::AtmosException,
+               "Couldn't create Net::HTTP request object for #{verb}" if (request.nil?)
+         
+         headers = {}
+         headers['Date'] = Time.now().httpdate()
+         headers['x-emc-date'] = Time.now().httpdate()
+         headers['x-emc-uid'] = @uid
+
+         if (!action[:required_headers].nil?)
+            action[:required_headers].each do |header|
+               case header
+               when 'Content-Type' then
+                  headers[header] = (!options[:mimetype].nil?) ? options[:mimetype] : 'binary/octet-stream'
+               when 'Content-Length' then
+                  headers[header] = (!options[:length].nil?) ? options[:length] : 0
+               when 'x-emc-tags' then
+                  headers[header] = (!options[header].nil?) ? options[header] : ""
+               else
+                  if (options[header])                  
+                     headers[header] = options[header]
+                  else
+                     raise "Value not supplied for required header: '#{header}'"
+                  end
+               end
+            end
+         end
+         
+         if (!action[:optional_headers].nil?)
+            action[:optional_headers].each do |header|
+               if (header.eql?('Range') && options.has_key?('Range') && !options['Range'].nil?)
+                  r = options['Range']
+                  options.delete('Range')
+                  #headers[header] = (r.kind_of?(Range)) ? "Bytes=#{r.first}-#{r.last}" : "Bytes=#{r.to_s}"
+                  if (r.kind_of?(Range)) 
+                     headers[header] = "Bytes=#{r.first}-#{r.last}"
+                     Atmos::LOG.info("Request.initialize: given Range object: #{headers[header]}")
+                  else 
+                     Atmos::LOG.info("Request.initialize: given range string: #{headers[header]}")
+                     headers[header] =  "Bytes=#{r.to_s}"
+                  end
+                  if ((!options[:data].nil?) and ((r.end-r.begin+1) != options[:data].length))
+                     raise Atmos::Exceptions::ArgumentException, "The range length (#{r.end - r.begin + 1}) doesn't match the data length (#{options[:data].length})."
+                  end
+               end
+               key = (action[:header2sym] && action[:header2sym][header]) ? action[:header2sym][header] : header
+                  
+               if (!options[key].nil?)
+                  if (options[key].kind_of?(Hash))
+                     headers[header] = ""
+                     options[key].each do |key,val|
+                        headers[header] += "#{key}=#{val}, "
+                     end
+                     headers[header].chop!
+                     headers[header].chop!
+                  elsif (options[key].kind_of?(Array))
+                     headers[header] = ""
+                     options[key].each do |val|
+                        headers[header] += "#{val}, "
+                     end
+                     headers[header].chop!
+                     headers[header].chop!
+                  elsif (options[key].respond_to?(:to_s))
+                     headers[header] = options[key]
+                  else
+                     raise "value for optional header '#{header}' id bad type: #{options[header].class}"
+                  end
+               end
+            end
+         end
+
+         if (!@tag.nil? && !action[:optional_headers].nil? && action[:optional_headers].include?('x-emc-listable-meta'))
+            if (headers.has_key?('x-emc-listable-meta'))
+               headers['x-emc-listable-meta'] += ", #{@tag}=atmos-ruby-default"
+            else 
+               headers['x-emc-listable-meta'] = "#{@tag}=atmos-ruby-default"
+            end
+         end
+
+         headers['x-emc-signature'] = calculate_signature(action[:verb], @secret, url, headers)
+         
+         if (options[:data])
+            Atmos::LOG.info("there is data: [#{options[:data]}]")
+            if (options[:data].respond_to?(:read))
+               request.body_stream = options[:data]         
+            else
+               request.body = options[:data]
+            end
+            headers['Content-Length'] = 
+               options[:data].respond_to?(:lstat) ? options[:data].stat.size : options[:data].size  
+            Atmos::LOG.info("set Content-Length to: #{headers['Content-Length']}\n")
+
+         end
+         
+         headers.each do |key,val|
+            request[key] = val
+         end
+                  
+        @http.set_debug_output($stdout) if (Atmos::LOG.level == Log4r::DEBUG)
+
+         
+         #
+         # so this is weird.  because some of these atmos request may be
+         # insanely long, we need to allow a mechanism for our API layer
+         # to read progressively, not only all at once
+         #
+         if (block)
+            @http.request(request) do |response|
+               block.call(response)
+            end
+            return
+         end
+         
+         response = @http.request(request)
+         Atmos::Parser::response_check_action_error(actionname, response)
+         
+         Atmos::Response.new(response, actionname)
+      end
+
+      
+      def calculate_signature(verb, secret, url, headers)        
+        headers_copy = headers.clone
+
+        # normalize emc headers
+        headers_copy.each do |header, value|
+           if (header.start_with?('x-emc-'))
+              headers.delete(header)
+              headers[header.to_s.strip.downcase] = value.to_s.strip.sub(/\s+/, ' ').sub(/\n/, '')
+           end
+        end
+      
+        # string together all emc headers, no newline at end
+        emc = ""
+        headers.keys.sort.each do |header|
+           if (header.start_with?('x-emc-'))
+              emc += "#{header}:#{headers[header]}\n"
+           end
+        end
+        emc.chomp!
+        
+        hashstring = verb.to_s.upcase+"\n"
+        ['Content-Type', 'Range', 'Date'].each do |key|
+           hashstring += headers[key] if (!headers[key].nil?)
+           hashstring += "\n"
+        end
+               
+        hashstring += url.path
+        hashstring += '?'+url.query if (!url.query.nil?)
+        hashstring += "\n"+ emc
+                               
+        Atmos::LOG.debug("calculate_signature: hashstring: #{hashstring}")
+        Base64.encode64(HMAC::SHA1.digest(Base64.decode64(secret), hashstring)).chomp()
+     end
+  end
+end

data/lib/atmos/response.rb

@@ -0,0 +1,116 @@
+module Atmos
+   class Response # :nodoc:
+      attr_reader :http_response
+      
+      def initialize(response, action)
+         @http_response = response
+         @action = action
+
+         if (response.kind_of?(Net::HTTPServerError))
+            raise Atmos::Exceptions::ServerException, response.message
+         elsif (response.kind_of?(Net::HTTPClientError))
+            
+            raise Atmos::Exceptions::AtmosException, "Atmos got a bad request.  This is probably a problem in this library." if (response.kind_of?(Net::HTTPBadRequest))
+               
+            Atmos::LOG.debug("#{response.class}")
+            Atmos::LOG.debug("#{response.body}")
+            
+            Atmos::Parser::response_check_action_error(@action, response)
+                        
+         elsif (!response.kind_of?(Net::HTTPSuccess))
+           raise Atmos::Exceptions::NotImplementedException, "This library doesn't handle these kinds of responses: #{response}"
+         end
+
+      end
+      
+      def each(header)
+         if (!self[header].nil?)
+            self[header].split(',').each do |elt|
+               if (!elt.index('=').nil?)
+                  key,val = elt.split('=')
+                  yield key.strip, val.strip
+               else
+                  yield elt.strip
+               end
+            end
+         end
+      end
+      
+      def body
+         @http_response.body
+      end
+      
+      def method_missing(sym, *args)
+         Atmos::LOG.info("method missing: #{sym}")
+         header = "x-emc-#{sym.id2name.sub(/_/, '-')}"
+         if (REST[@action][:return_headers].include?(header))
+            Atmos::LOG.info("header: #{header}")
+            rv = Atmos::Util.header2hash(header, @http_response[header])
+            Atmos::LOG.debug("rv: #{rv.inspect}")
+            return rv
+         else
+            return super.method_missing(sym, *args)
+         end
+      end
+            
+      def delta
+         if (REST[@action][:return_headers].include?('x-emc-delta'))
+            @http_response['x-emc-delta']
+         else
+            raise "A #{@action} request doesn't return a delta."
+         end
+      end
+      
+      def policy
+         if (REST[@action][:return_headers].include?('x-emc-policy'))
+            @http_response['x-emc-policy']
+         else
+            raise "A #{@action} request doesn't return a policy description."
+         end
+      end
+            
+      def id
+         if (REST[@action][:return_headers].include?('location'))
+            @http_response['location'][@http_response['location'].rindex('/')+1..-1]
+         else
+            raise "A #{@action} request doesn't return an id."
+         end
+      end
+            
+      def headers
+         headers = {}
+         @http_response.each do |header, value|
+            headers[header] = value
+         end
+         headers
+      end
+
+      def [](header)
+         @http_response[header]
+      end
+
+   end
+
+   
+         
+
+   
+
+#         while (response.kind_of?(Net::HTTPRedirection))
+            
+            #From http://railstips.org/blog/archives/2009/03/04/following-redirects-with-nethttp/
+#            rurl = (response['location'].nil?) ? response.body.match(/<a href=\"([^>]+)\">/i)[1] : response['location']
+
+#            puts("Got a redirect \nfrom: #{options[:url]}\n  to: #{rurl}")
+
+#            if rurl.start_with?('/')
+#            puts("Got a relative redirect url: #{options[:url]}")
+#             options[:url] = URI.parse("#{url.scheme}://#{url.host}#{redirect_url}")
+#           end
+
+#            options[:redirects] = (options[:redirects].nil?) ? 0 : options[:redirects] += 1    
+#            response = self.generic_request(options)
+#         end
+#         raise "Too many redirects (#{options[:redirects]}): #{url}" if (!options[:redirects].nil? && (options[:redirects] > 3))
+
+end

data/lib/atmos/rest.rb

@@ -0,0 +1,145 @@
+module Atmos
+   REST = {
+      :listable_tags       => { :verb             => :get, 
+                                :object_uri       => '/rest/objects?listabletags', 
+                                :required_headers => ['x-emc-tags'],
+                                :optional_headers => ['x-emc-token'],
+                                :http_response    => 200,
+                                :return_headers   => ['x-emc-listable-tags'],
+                              },
+      :set_group_acl       => { :verb             => :post, 
+                                :object_uri       => '/rest/objects/:id?acl', 
+                                :required_headers => ['x-emc-groupacl'],
+                                :http_response    => 200,
+                              },
+      :set_user_acl        => { :verb             => :post, 
+                                :object_uri       => '/rest/objects/:id?acl', 
+                                :required_headers => ['x-emc-useracl'],
+                                :http_response    => 200,
+                              },
+      :set_metadata        => { :verb             => :post,
+                                :object_uri       => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 200,
+                                :required_headers => ['x-emc-meta'],
+                              },
+      :set_listable_metadata => { :verb           => :post,
+                                :object_uri       => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 200,
+                                :required_headers => ['x-emc-listable-meta'],
+                              },
+      :delete_metadata     => { :verb             => :delete, 
+                                :object_uri       => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 204,
+                                :required_headers => ['x-emc-tags'],
+                              },
+      :read_object         => { :verb             => :get, 
+                                :object_uri       => '/rest/objects/:id', 
+                                :http_response    => 200,
+                                :optional_headers => ['Range'],
+                              },
+      :update_object       => { :verb             => :put, 
+                                :object_uri       => '/rest/objects/:id', 
+                                :http_response    => 200,
+                                :required_headers => ['Content-Type', 'Content-Length'],
+                                :optional_headers => ['x-emc-useracl', 'x-emc-groupacl', 'Range'],
+                                },
+      :trunc_object        => { :verb             => :put, 
+                                :object_uri       => '/rest/objects/:id', 
+                                :http_response    => 200,
+                                :required_headers => ['Content-Length'],
+                                :optional_headers => ['x-emc-useracl', 'x-emc-groupacl', 'Range'],
+                                },
+      :get_service_info    => { :verb             => :get, 
+                                :object_uri       => '/rest/service', 
+                                :response         => :xml,
+                                :http_response    => 200,
+                              },
+                              
+      :list_objects        => { :verb             => :get, 
+                                :object_uri       => '/rest/objects', 
+                                :response         => :xml,
+                                :http_response    => 200,
+                                :required_headers => ['x-emc-tags', 'Content-Type'],
+                                :optional_headers => ['x-emc-include-meta', 'x-emc-tags'],
+                                :errors           => { '1003' => { :class => Atmos::Exceptions::ArgumentException , 
+                                                                   :message => "No such listable tag found." } },
+                              },
+
+      :create_object       => { :verb             => :post, 
+                                :namespace_uri    => '/rest/namespace/:namespace', 
+                                :object_uri       => '/rest/objects', 
+                                :http_response    => 201,
+                                :optional_headers => ['x-emc-wschecksum', 'x-emc-useracl', 'x-emc-groupacl', 'x-emc-meta', 'x-emc-listable-meta'],
+                                :required_headers => ['Content-Type', 'Content-Length'],
+                                :return_headers   => ['x-emc-delta', 'x-emc-policy', 'location'],
+                                :header2sym       => {'x-emc-wschecksum'    => :checksum, 
+                                                      'x-emc-useracl'       => :user_acl,
+                                                      'x-emc-groupacl'      => :group_acl, 
+                                                      'x-emc-meta'          => :metadata, 
+                                                      'x-emc-listable-meta' => :listable_metadata},
+                              },
+
+      :get_object_info     => { :verb           => :get, 
+                                :namespace_uri  => '/rest/namespace/:namespace?info', 
+                                :object_uri     => '/rest/objects/:id?info', 
+                                :http_response  => 200,
+                                :return_headers   => ['x-emc-policy'],
+                              },
+      :delete_object       => { :verb             => :delete, 
+                                :object_uri       => '/rest/objects/:id', 
+                                :http_response    => 204,
+                                :required_headers => ['Content-Type'],
+                                :return_headers   => ['x-emc-delta', 'x-emc-policy'],
+                                :errors           => { '1003' => { :class => Atmos::Exceptions::NoSuchObjectException , 
+                                                                   :message => "Object not found to delete." } },
+                              },
+ 
+      :list_system_metadata=> { :verb             => :get, 
+                                :object_uri       => '/rest/objects/:id?metadata/system', 
+                                :http_response    => 200,
+                                :return_headers   => ['x-emc-meta'],
+                                :errors           => { '1003' => { :class => Atmos::Exceptions::NoSuchObjectException , 
+                                                                   :message => "Object not found to delete." } },
+                              },
+      :list_metadata       => { :verb             => :get, 
+                                :object_uri       => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 200,
+                                :required_headers => ['Content-Type'],
+                                :return_headers   => ['x-emc-meta', 'x-emc-listable-meta'],
+                              },
+
+      :list_tags           => { :verb             => :get, 
+                                :object_uri       => '/rest/objects/:id?metadata/tags', 
+                                :http_response    => 200,
+                                :return_headers   => ['x-emc-tags', 'x-emc-listable-tags'],
+                              },
+
+      :list_acl            => { :verb             => :get, 
+                                :object_uri       => '/rest/objects/:id?acl', 
+                                :http_response    => 200,
+                                :return_headers   => ['x-emc-useracl', 'x-emc-groupacl'],
+                              },
+
+
+
+
+
+
+
+      :delete_version      => { :verb           => :delete, 
+                                :object_uri     => '/rest/objects/:id?versions', 
+                                :http_response  => 204,
+                              },
+      :create_version      => { :verb           => :post, 
+                                :object_uri     => '/rest/objects/:id?versions' , 
+                                :http_response  => 201,
+                              },
+      :list_versions       => { :verb           => :get,
+                                :object_uri     => '/rest/objects/:id?versions',
+                                :http_response => 200},
+      :restore_version     => { :verb => :put,                                 
+                                :object_uri => '/rest/objects/:id?versions',
+                                :http_response => 200},
+   } # :nodoc:
+
+end