ruby-atmos 0.6.0

data/lib/atmos/rest.rb

@@ -0,0 +1,254 @@
+module Atmos
+   REST = {
+      :listable_tags       => { :verb             => :get, 
+                                :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, 
+                                :uri              => '/rest/objects/:id?acl', 
+                                :required_headers => ['x-emc-groupacl'],
+                                :http_response    => 200,
+                              },
+      :set_user_acl        => { :verb             => :post, 
+                                :uri              => '/rest/objects/:id?acl', 
+                                :required_headers => ['x-emc-useracl'],
+                                :http_response    => 200,
+                              },
+      :set_metadata        => { :verb             => :post,
+                                :uri              => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 200,
+                                :required_headers => ['x-emc-meta'],
+                              },
+      :set_listable_metadata => { :verb             => :post,
+                                :uri              => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 200,
+                                :required_headers => ['x-emc-listable-meta'],
+                              },
+      :delete_metadata     => { :verb             => :delete, 
+                                :uri              => '/rest/objects/:id?metadata/user', 
+                                :http_response    => 204,
+                                :required_headers => ['x-emc-tags'],
+                              },
+      :read_object         => { :verb             => :get, 
+                                :uri              => '/rest/objects/:id', 
+                                :http_response    => 200,
+                                :optional_headers => ['Range'],
+                              },
+      :update_object       => { :verb             => :put, 
+                                :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, 
+                                :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, 
+                                :uri              => '/rest/service', 
+                                :response         => :xml,
+                                :http_response    => 200,
+                              },
+                              
+      :list_objects        => { :verb             => :get, 
+                                :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, 
+                                :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},
+                              },
+
+      :delete_object       => { :verb             => :delete, 
+                                :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, 
+                                :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, 
+                                :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, 
+                                :uri              => '/rest/objects/:id?metadata/tags', 
+                                :http_response    => 200,
+                                :return_headers   => ['x-emc-tags', 'x-emc-listable-tags'],
+                              },
+
+      :list_acl            => { :verb             => :get, 
+                                :uri              => '/rest/objects/:id?acl', 
+                                :http_response    => 200,
+                                :return_headers   => ['x-emc-useracl', 'x-emc-groupacl'],
+                              },
+
+
+
+
+
+
+
+      :delete_version      => { :verb => :delete, 
+                                :uri => '/rest/objects/:id?versions', 
+                                :http_response => 204,
+                              },
+      :get_object_info     => { :verb => :get, 
+                                :uri => '/rest/objects/:id?info', 
+                                :http_response => 200,
+                              },
+      :create_version      => { :verb => :post, 
+                                :uri => '/rest/objects/:id?versions' , 
+                                :http_response => 201,
+                              },
+      :list_versions       => { :verb => :get, :uri => '/rest/objects/:id?versions', :http_response => 200},
+      :restore_version     => { :verb => :put, :uri => '/rest/objects/:id?versions', :http_response => 200},
+   } # :nodoc:
+   
+   
+   
+   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/store.rb

@@ -0,0 +1,209 @@
+module Atmos
+
+  class Store
+    attr_reader :http, :uid, :secret, :uri, :tenant, :user, :proxy # :nodoc:
+    
+    #
+    # Create and validate a connection to an Atmos server.
+    # This API currently uses only the Atmos object interface,
+    # not the namespace interface.  Proxy support has been tested
+    # against squid 2.7.STABLE9 on ubuntu 10.10.
+    #
+    # If you have used Atmos Online this example will look familiar:
+    #
+    #   store = Atmos::Store.new(:url    => 'https://accesspoint.atmosonline.com'
+    #                            :uid    => 'ab9090e754b549eeb460a468abdf7fc2/A797558526171ea693ce'
+    #                            :secret => 'pEauABL07ujkF2hJN7r6wA9/HPs='
+    #                           )
+    #
+    # Required:
+    # * <tt>:url</tt> -     the url to the Atmos server the Store object will
+    #                       represent (e.g. \https://accesspoint.atmosonline.com)
+    # * <tt>:uid</tt> -     a string, "<tenant id>/<username>"
+    #                       ("Full Token ID" in Atmos Online)
+    # * <tt>:secret</tt> -  a string, the secret key associated with the user
+    #                       (shared secret for a token in Atmos Online)
+    # --
+    # Optional:
+    # * <tt>:proxy</tt> - url to proxy of the form 
+    #                     scheme://[user[:password]@]host:port
+    #
+    #
+    def initialize(options = {})
+      valid   = [:url,:secret,:uid,:tag,:version,:proxy,:unsupported].freeze
+      invalid = options.keys - valid
+      raise Atmos::Exceptions::ArgumentException,
+      "Unrecognized options: #{invalid.inspect}" if (!invalid.empty?)
+      Atmos::LOG.info("Store.initialize: options: #{options.inspect}")
+
+      raise Atmos::Exceptions::ArgumentException,
+      "The kind of XML parser you would like to use has not been set yet." if (Atmos::Parser::parser.nil?)         
+
+      @uri    = URI.parse(options[:url])
+      @secret = options[:secret]
+      @uid    = options[:uid]
+      @tag    = options[:tag]
+      
+      if (@uid =~ /^([^\/]+)\/([^\/]+)$/)
+        @tenant = $1
+        @user = $2
+      else
+        @tenant = nil
+        @user = @uid
+      end
+     
+     
+      proxyopts = [nil]
+      if !options[:proxy].nil?
+
+        proxyurl = URI.parse(options[:proxy])
+
+        if (!proxyurl.kind_of?(URI::HTTP) &&
+            !proxyurl.kind_of?(URI::HTTPS))
+
+          msg = "Please check the proxy URL scheme.  "
+          msg += "It's not being recognized as an http or https url.  "
+          msg +=  "You do have to include the http(s):// part."
+          raise Atmos::Exceptions::ArgumentException, msg
+        end
+        
+        Atmos::LOG.warn("using proxy: #{options[:proxy]}")
+        proxyopts = [proxyurl.host, proxyurl.port]
+
+        if (proxyurl.userinfo =~ /([^:]+):([^:])/)
+          proxyopts.push([$1, $2])
+        elsif (!proxyurl.userinfo.nil?)
+          proxyopts.push(proxyurl.userinfo)
+        end
+        Atmos::LOG.info("proxy options: #{proxyopts.inspect}")
+      end
+
+
+      @http = Net::HTTP.Proxy(*proxyopts).new(@uri.host, @uri.port)
+      if @uri.scheme == 'https'
+         @http.use_ssl = true
+         @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      Atmos::LOG.debug("http class: #{@http.inspect}")
+
+      @request = Atmos::Request.new(:store => self, :default_tag => @tag)
+      res = @request.do(:get_service_info)
+                                               
+      if (res.http_response.kind_of?(Net::HTTPMovedPermanently))
+         rurl = (res['location'].nil?) ? res.body.match(/<a href=\"([^>]+)\">/i)[1] : res['location']
+         raise ArgumentException, "The Atmos URL is redirecting.  Please supply the correct URL. (#{@uri.to_s} => #{rurl})"
+      end
+      
+      @server_version = Atmos::Parser::response_get_string(res.http_response, '//xmlns:Atmos')            
+
+      if ((!SUPPORTED_VERSIONS.include?(@server_version)) &&
+          (options[:unsupported] != true))
+        msg ="This library does not support Atmos version #{@server_version}.  "
+        msg +=  "Supported versions: #{SUPPORTED_VERSIONS.inspect}.  "
+        msg += "To silence this, pass :unsupported => true when instantiating."
+
+        raise Atmos::Exceptions::NotImplementedException, msg
+      end
+
+
+      if (!options[:version].nil? && !options[:version].eql?(@server_version))
+        raise Atmos::Exceptions::ArgumentException, 
+        "Atmos server version and version you were expecting do not match." 
+      end
+    end
+    
+    
+    #
+    # Create an Atmos object.  This can be done with no arguments,
+    # or with any of the listed optional arguments.  Checksums are 
+    # not yet supported.
+    #
+    # If no data is passed, a 0 length object is created.
+    # If no ACLs are passed, the default access control is applied.
+    # If no mime type is passed, the default is 'binary/octet-stream'.
+    #
+    # Optional:
+    # * <tt>:user_acl</tt>          - hash of username/permissions (<tt>:none</tt>, <tt>:read</tt>, <tt>:write</tt>, <tt>:full</tt>) pairs
+    # * <tt>:group_acl</tt>         - hash of groupname/permissions (<tt>:none</tt>, <tt>:read</tt>, <tt>:write</tt>, <tt>:full</tt>) pairs
+    # * <tt>:metadata</tt>          - hash of string pairs
+    # * <tt>:listable_metadata</tt> - hash of string pairs
+    # * <tt>:mimetype</tt>          - defaults to application/octet-stream
+    # * <tt>:data</tt>              - a String or an IO stream
+    # * <tt>:length</tt>            - a number  (requires <tt>:data</tt>)
+    #
+    def create(options = {})    
+       Atmos::Object.new(self, nil, options)
+    end
+    
+    
+    #
+    # Retrieve an Atmos object given an id.  
+    # When the object is retrieved, the ACL and
+    # Metadata information is loaded from the server.  
+    # The blob data is not loaded until
+    # accessed, so it can be progressively downloaded.
+    #
+    def get(id)
+       Atmos::Object.new(self, id)
+    end
+    
+    
+    #
+    # Tags are the key part of key/value metadata pairs.  
+    # Metadata that has been created as listable can be 
+    # retrieved based on the tag.  This method iterates
+    # through all listable tags in Atmos.
+    #
+    # Tags can be hierarchical: foo/bar/baz.  And each
+    # level anc have multiple tags under it.  So to
+    # list all tags under the "foo" tag pass "foo" as the
+    # argument.  To list all tags under "foo/bar", pass
+    # "foo/bar" as the argument.
+    #
+    def each_listable_tag(tag = nil) #:nodoc:
+       token = ""
+       headers = {}
+       headers['x-emc-tags'] = tag if (!tag.nil?)
+       
+       while (!token.nil?)
+          response = @request.do(:listable_tags, headers)
+          response.each('x-emc-listable-tags') do |tag|
+             yield tag
+          end
+          
+          token = response['x-emc-token']
+          headers['x-emc-token'] = token if (!token.nil?)
+       end
+    end
+    
+    
+    #
+    # Iterate through objects that are indexed by a particular tag.  Tag can't be nil,
+    # and must be a ruby String.  Note that as the objects are instantiated, ACLs and 
+    # Metadata will be retrieved, and object data will not.  
+    #
+    # Note that there may not be any objects associated with a listable tag even though 
+    # that tag shows up when listing all listable tags.
+    #
+    def each_object_with_listable_tag(tag)
+       raise Atmos::Exceptions::ArgumentException, "The 'tag' parameter cannot be nil." if (tag.nil?)
+       raise Atmos::Exceptions::ArgumentException, "Only one tag is allowed at a time." if (!tag.kind_of?(String))
+
+       response = @request.do(:list_objects, 'x-emc-include-meta' => 0, 'x-emc-tags' => tag)
+
+       Atmos::Parser::response_get_array(response, '//xmlns:ObjectID').each do |idxml|
+          yield Atmos::Object.new(self, idxml)
+       end
+    end
+    
+    
+    #
+    # Returns the version of the Atmos server authenticated to as a string.
+    #
+    def server_version
+       @server_version
+    end
+
+  end
+  
+end