ruby-atmos-pure 1.0.3

data/lib/atmos/store.rb

@@ -0,0 +1,220 @@
+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 supports both the object interface and 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>)
+    # * <tt>:namespace</tt>         - name for namespace interface instead of object interface
+    #
+    def create(options = {})    
+       Atmos::Object.new(self, :create, 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.
+    #
+    # Mutually exclusive, one required:
+    # * <tt>:id</tt>          - the id of the object to retrieve
+    # * <tt>:namespace</tt>   - the namespace key of the object to retrieve
+    def get(options)
+              
+       # can't both be set, can't both be empty
+       if (!options[:id].nil? && !options[:namespace].nil?)
+          raise Atmos::Exceptions::ArgumentException, "One of :id, :namespace is required, but not both."
+       elsif (options[:id].nil? && options[:namespace].nil?)
+          raise Atmos::Exceptions::ArgumentException, "One of :id, :namespace is required."
+       end
+       
+       Atmos::Object.new(self, :get, options)
+    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 

data/lib/atmos/util.rb

@@ -0,0 +1,40 @@
+module Atmos
+   class Util # :nodoc:
+            
+      #
+      # Utility method to convert from a standard Atmos key/value pair return header.
+      #
+      def self.header2hash(value)
+         return nil if (value.nil?)
+         raise Atmos::Exceptions::ArgumentException, "The 'value' parameter must be a String" if (!value.kind_of?(String))
+         
+         rv = {}
+         if (!value.nil?)
+            value.split(',').each do |elt|
+               key,val = elt.split('=')
+               rv[key.strip] = val.nil? ? "" : val.strip
+            end
+         end
+
+         rv
+      end
+      
+      
+      #
+      # Utility method to convert to a standard header value.
+      #
+      def self.hash2header(value)
+         return nil if (value.nil?)
+         raise Atmos::Exceptions::ArgumentException, "The 'value' parameter must be a Hash" if (!value.kind_of?(Hash))
+
+         rv = ""
+         if (!value.nil?)
+            value.each do |k,v|
+               rv += "#{k}=#{v}, "
+            end
+         end
+
+         rv[0..-3]
+      end
+   end
+end

data/lib/atmos/version.rb

@@ -0,0 +1,12 @@
+module Atmos
+   
+   # Version number of this library.
+   VERSION = "1.0.3"
+
+   # Array of version strings this library has been tested against.
+   SUPPORTED_VERSIONS = ["1.2.7", "1.3.4", "1.4.0", "1.4.1", "2.0.1"].freeze
+   
+   # The logger used by the entire gem.
+   LOG = Log4r::Logger.get('atmos')
+   
+end 

data/test/credentials.rb

@@ -0,0 +1,141 @@
+module Atmos
+  module Test
+    class Util
+      $stdout.sync = true
+      @use_proxy = false
+      @proxy = 'http://127.0.0.1:3128'
+      @store = nil
+      @server = :atmosonline
+      @servers =
+        {:alma         => {
+          :url         => 'https://10.5.113.71',
+          :redirect_url=> nil,
+          :version     => '2.0.1',
+          :default_tag => 'atmos-ruby',
+          :tenant      => '69eb3dc3bf9746f895d1ce12ae1d9589',
+          :user        => 'dragaf-test',
+          :group       => 'other',
+          :secret      => 'p97mki4AkiAyVi+/7QpdxFAU/jY=',
+          :other_user  => nil,
+          :other_group => nil,
+        },
+        :atmosonline  => {
+          :url         => 'https://accesspoint.atmosonline.com',
+          :redirect_url=> 'http://accesspoint.atmosonline.com',
+          :version     => '1.3.4',
+          :default_tag => 'atmos-ruby',
+          :tenant      => 'b245ad26f5c94bcbbaffa315a833f27a',
+          :user        => 'A79755852684b2e05d00',
+          :group       => 'other',
+          :secret      => 'sM6oN/k6e03iW7lNSUzFav9rwck=',
+          :other_user  => 'A797558526171ea693ce',
+          :other_group => 'grouptest',
+        },
+        :cambridge_71 => {
+          :url         => 'https://10.5.113.74',
+          :redirect_url=> nil,
+          :version     => '1.4.1',
+          :default_tag => 'atmos-ruby',
+          :tenant      => 'ab9090e754b549eeb460a468abdf7fc2',
+          :user        => 'dragaf-test-tenant-user1',
+          :group       => 'other',
+          :secret      => 't5R1ftRNLXQ3ejv6fvJLNFMFrPo=',
+          :other_user  => 'another',
+          :other_group => nil,
+        },
+        :matt        => {
+          :url         => 'http://137.69.164.126',
+          :redirect_url=> nil,
+          :version     => "1.4.0",
+          :default_tag => 'atmos-ruby',
+          #:tenant      => 'fdragan-atmos-ruby-test',
+          :tenant      => '4aba2817d7eb4a2d93dfdccb3caedb9f',
+          :user        => 'testuser02',
+          :group       => 'other',
+          :secret      => 'sWNxtrhorOpi0R3PNPSo1uKV4Vo=',
+          :other_user  => 'testuser01',
+          :other_group => nil,
+        },
+      }
+
+      def self.parser_type
+         Atmos::Parser::NOKOGIRI
+         #Atmos::Parser::REXML
+      end
+
+      #
+      # Provides the same store object to all who request it.
+      # This is the default for running tests.  If tests fail
+      # you can change the mode to get a new store each time
+      # and see if that fixes it.  If so, you know that something
+      # weird is going on with the Atmos::Store object.
+      #
+      def self.static_store
+         if (@store.nil?)
+            Atmos::Parser::parser = parser_type
+            @store = Atmos::Store.new(:url    => url,
+                                      :uid    => uid,
+                                      :secret => secret,
+                                      :proxy  => proxy
+                                      )
+        end
+
+        return @store
+      end
+
+      def self.new_store
+         Atmos::Parser::parser = parser_type
+         Atmos::Store.new(:url    => url,
+                          :uid    => uid,
+                          :secret => secret,
+                          :proxy  => proxy
+                          )
+      end
+
+
+      def self.server
+        @server
+      end
+
+      def self.use_proxy=(bool)
+        @use_proxy = bool
+      end
+
+      def self.proxy
+        (@use_proxy == true) ? @proxy : nil
+      end
+
+      def self.small_text_filename
+        File.join(File.dirname(__FILE__),
+                  'files/something.txt')
+      end
+         
+      def self.small_binary_filename
+        File.join(File.dirname(__FILE__),
+                  'files/dragaf-tiny-from-vsphere.ova')
+      end
+         
+      def self.large_binary_filename
+        File.join(File.dirname(__FILE__),
+                  'SmallImageForTest.iso')
+      end
+         
+      def self.test_server_info(key)
+        @servers[key]
+      end
+
+      def self.uid
+        return "#{Atmos::Test::Util.tenant}/#{Atmos::Test::Util.user}"
+      end
+
+      def self.method_missing(sym, *args)
+        if (@servers[@server].has_key?(sym))
+          return @servers[@server][sym]
+        else
+          return super.method_missing(sym, *args)
+        end
+      end
+            
+    end
+  end
+end

data/test/esutest.rb

@@ -0,0 +1,499 @@
+require 'rubygems'
+require 'test/unit'
+require 'tempfile'
+require 'EsuApi'
+require 'uri'
+
+class Esutest < Test::Unit::TestCase
+  def initialize( id )
+    super(id)
+    @esu = EsuApi::EsuRestApi.new( "192.168.15.115",80,"connectic","D7qsp4j16PBHWSiUbc/bt3lbPBY=")
+  end
+
+  def setup
+    @cleanup = []
+    @cleanfiles = []
+  end
+
+  def teardown
+    @cleanup.each { |id| @esu.delete_object( id ) }
+    @cleanfiles.each { |file| file.close! }
+  end
+
+  # 
+  # Test creating one empty object.  No metadata, no content.
+  # 
+  def test_create_empty_object()
+    id =  @esu.create_object( nil, nil, nil, nil )
+    assert_not_nil( id, "nil ID returned" );
+    @cleanup.push( id )
+
+    # Read back the content
+    content = @esu.read_object( id, nil, nil )
+    assert_equal( "", content, "object content wrong" );
+  end
+  
+  def test_hmac
+    str = "Hello World"
+    value = HMAC::SHA1.digest( Base64.decode64( "D7qsp4j16PBHWSiUbc/bt3lbPBY=" ), str )
+    signature = Base64.encode64( value ).chomp()
+    print "String to sign: #{str}\nSignature: #{signature}\nValue: #{value}\n"
+    assert_equal( "kFcjtduMr0rljJHxJRqF8i1DNp4=", signature, "HMAC failed to validate" )
+  end
+
+#  def test_create_empty_object_on_path()
+#    op = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    id = @esu.create_object_on_path( op, nil, nil, nil, nil )
+#    assert_not_nil( id, "nil ID returned" );
+#    @cleanup.push( id )
+#
+#    # Read back the content
+#    content = @esu.read_object( id, nil, nil )
+#    assert_equal( "", content, "object content wrong" );
+#  end
+#
+  def test_create_object_with_content()
+    id =  @esu.create_object( nil, nil, "hello", "text/plain" )
+    assert_not_nil( id, "nil ID returned" );
+    @cleanup.push( id )
+
+    # Read back the content
+    content = @esu.read_object( id, nil, nil )
+    assert_equal( "hello", content, "object content wrong" );
+  end
+  
+  def test_update_object
+    id =  @esu.create_object( nil, nil, "hello", "text/plain" )
+    assert_not_nil( id, "nil ID returned" );
+    @cleanup.push( id )
+    
+    # Change the content
+    @esu.update_object( id, nil, nil, "Hello World", "text/plain" )
+
+    # Read back the content
+    content = @esu.read_object( id, nil, nil )
+    assert_equal( "Hello World", content, "object content wrong" );
+    
+  end
+  
+#
+#  def test_create_object_with_stream()
+#    stream = createTestStream( 40 )
+#    id = @esu.create_object( nil, nil, stream.open, "text/plain" )
+#
+#    @cleanup.push( id )
+#
+#    # Read back the content
+#    content = @esu.read_object( id, nil, nil )
+#    assert_equal( content, stream.open.readlines, "object content wrong" );
+#  end
+#
+#  def test_create_object_with_metadata()
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "listable2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "unlistable2", "bar2    bar2", false )
+#    id = @esu.create_object( nil, meta, nil, nil )
+#    @cleanup.push( id )
+#
+#    # Read back and check
+#    meta = @esu.get_user_metadata( id )
+#
+#    assert_equal( "foo", meta["listable"].value, "Value of listable wrong" )
+#    assert_equal( "bar", meta["unlistable"].value, "Value of unlistable wrong" )
+#    assert_equal( "foo2   foo2", meta["listable2"].value, "Value of listable2 wrong" )
+#    assert_equal( "bar2    bar2", meta["unlistable2"].value, "Value of unlistable2 wrong" )
+#  end
+#  
+#  def test_acl
+#    acl = createAcl
+#    id = @esu.create_object( acl, nil, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # Read back and check
+#    newacl = @esu.getAcl( id )
+#    check_acl( acl, newacl )
+#  end
+#  
+#  def test_acl_on_path
+#    acl = createAcl
+#    op = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    id = @esu.create_object_on_path( op, acl, nil, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # Read back and check
+#    newacl = @esu.get_acl( id )
+#    check_acl( acl, newacl )
+#  end
+#  
+#  def test_delete_user_metadata
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "listable2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "unlistable2", "bar2    bar2", false )
+#    id = @esu.create_object( nil, meta, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # Delete some metadata
+#    deleteList = [ 'listable', 'unlistable' ]
+#    @esu.delete_user_metadata( id, deleteList )
+#      
+#    # Read back and check
+#    meta = @esu.get_user_metadata( id )
+#
+#    assert_nil( meta["listable"], "listable should have been deleted" )
+#    assert_nil( meta["unlistable"], "unlistable should have been deleted" )
+#    assert_equal( "foo2   foo2", meta["listable2"].value, "Value of listable2 wrong" )
+#    assert_equal( "bar2    bar2", meta["unlistable2"].value, "Value of unlistable2 wrong" )
+#  end
+#  
+#  def test_delete_version
+#    id = @esu.create_object( nil, nil, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # Create some versions
+#    vid1 = @esu.version_object( id );
+#    vid2 = @esu.version_object( id );
+#    
+#    # Delete one of the versions
+#    @esu.delete_version( vid1 )
+#    
+#    # List back the versions
+#    vlist = @esu.listVersions( id );
+#    assert_equal( 1, vlist.size, "Only expected one version" )
+#    assert_equal( vid2, vlist[0], "Expected second vid" )
+#  end
+#  
+#  def test_restore_version
+#    id = @esu.create_object( nil, nil, "Original Content", "text/plain" )
+#    @cleanup.push( id )
+#    
+#    # Version the object
+#    vid1 = @esu.version_object( id )
+#    
+#    # Change the content
+#    @esu.update_object( id, nil, nil, "New content you should never see", "text/plain" )
+#    
+#    # restore the first version
+#    @esu.restore_version( id, vid1 )
+#    
+#    # Read back the content
+#    content = @esu.read_object( id )
+#    assert_equal( "Original Content", content, "Expected original content" )
+#  end
+#  
+#  def test_get_system_metadata
+#    id = @esu.create_object( nil, nil, "12345", "text/plain" )
+#    @cleanup.push( id )
+#    
+#    tags = [ 'ctime', 'size' ]
+#    smeta = @esu.get_system_metadata( id, tags )
+#    
+#    assert_not_nil( smeta['ctime'], "Expected ctime to be set" )
+#    assert_equal( 5, smeta['size'].value, "Expected object size to be five" )
+#  end
+#  
+#  def test_list_objects
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "list/able/2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "un/list/able2", "bar2    bar2", false )
+#    id = @esu.create_object( nil, meta, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # List tags and check membership
+#    objects = @esu.list_objects( "listable" );
+#    assert_true( objects.include?(id), "Expected object to be listable" );
+#    
+#    objects = @esu.list_objects( "unlistable" )
+#    assert_true( !objects.include?(id), "Expected object to not be unlistable" )
+#    
+#    objects = @esu.list_objects( "list/able/2" )
+#    assert_true( objects.include?(id), "Expected object to be listable" )
+#  end
+#  
+#  def test_list_objects_with_metadata
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "list/able/2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "un/list/able2", "bar2    bar2", false )
+#    id = @esu.create_object( nil, meta, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # List tags and check membership
+#    objects = @esu.list_objects_with_metadata( "listable" );
+#    assert_true( objects.include?(id), "Expected object to be listable" );
+#    
+#    oid = objects[ objects.index(id) ]
+#    
+#    # Check metadata
+#    assert_equal( "foo", oid.meta['listable'], "Expected metadata to be set on object" )
+#  end
+#  
+#  def test_get_listable_tags
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "list/able/2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "list/able/not", "bar2    bar2", false )
+#    id = @esu.create_object( nil, meta, nil, nil )
+#    @cleanup.push( id )
+#    
+#    # Check root tags
+#    tags = @esu.get_listable_tags( nil )
+#    assert( tags.include?('listable'), "Expected listable in root" )
+#    assert( tags.include?('list'), "Expected list in root" )
+#    assert( !tags.include?('unlistable'), "Expected unlistable to be missing" )
+#    
+#    # Check deeper tag
+#    tags = @esu.get_listable_tags( 'list/able' )
+#    assert( tags.include?( '2' ), "Expected child tag" )
+#    assert( !tags.include?( 'listable' ), "Root tag found in child" )
+#    assert( !tags.include?( 'not' ), "Found unlistable tag" )
+#  end
+#  
+#  def test_list_user_metadata_tags
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "list/able/2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "list/able/not", "bar2    bar2", false )
+#    id = @esu.create_object( nil, meta, nil, nil )
+#    @cleanup.push( id )
+#
+#    # Check tags
+#    tags = @esu.list_user_metadata_tags( id )
+#    assert( tags.include?('listable'), "Metadata listable tag missing" );    
+#    assert( tags.include?('unlistable'), "Metadata unlistable tag missing" );    
+#    assert( tags.include?('list/able/2'), "Metadata list/able/2 tag missing" );    
+#    assert( tags.include?('list/able/not'), "Metadata list/able/not tag missing" );    
+#  end
+#  
+#  def test_update_object
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    id = @esu.create_object( nil, meta, "Four score and seven years ago", "text/plain" )
+#    @cleanup.push( id )
+#    
+#    # Update object
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "xxx", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "yyy", false )
+#    @esu.update_object( nil, meta, "New content here", "text/plain" )
+#
+#    # Read back metadata and check
+#    meta = @esu.get_user_metadata( id )
+#
+#    assert_equal( "xxx", meta["listable"].value, "Value of listable wrong" )
+#    assert_equal( "yyy", meta["unlistable"].value, "Value of unlistable wrong" )
+#    
+#    # Read back the content
+#    content = @esu.read_object( id, nil, nil )
+#    assert_equal( "New content here", content, "object content wrong" );
+#  end
+#  
+#  def test_update_object_with_stream()
+#    stream = createTestStream( 40 )
+#    id = @esu.create_object( nil, nil, stream.open, "text/plain" )
+#  
+#    @cleanup.push( id )
+#    
+#    stream2 = createTestStream( 45 )
+#    @esu.update_object( nil, nil, stream2.open(), "text/plain" )
+#  
+#    # Read back the content
+#    content = @esu.read_object( id, nil, nil )
+#    assert_equal( content, stream2.open.readlines, "object content wrong" );
+#  end
+#  
+#  def test_list_directory()
+#    dir = '/' + randomstr( 8 )
+#    
+#    file1 = EsuApi::ObjectPath.new( dir + '/' + randomstr( 8 ) )
+#    file2 = EsuApi::ObjectPath.new( dir + '/' + randomstr( 8 ) )
+#    dir2 = EsuApi::ObjectPath.new( dir + '/' + randomstr( 8 ) + '/' )
+#    id1 = @esu.create_object_on_path( file1, nil, nil, nil, nil )
+#    @cleanup.push( id1 )
+#    id2 = @esu.create_object_on_path( file2, nil, nil, nil, nil )
+#    @cleanup.push( id2 )
+#    id3 = @esu.create_object_on_path( dir2, nil, nil, nil, nil )
+#    @cleanup.push( id3 )
+#    
+#    dirlist = @esu.list_directory( EsuApi::ObjectPath.new( dir + '/' ) )
+#    assert( dirlist.find { |entry| entry == file1 }, "could not locate " + file1 )
+#    assert( dirlist.find { |entry| entry == file2 }, "could not locate " + file2 )
+#    assert( dirlist.find { |entry| entry == dir2 }, "could not locate " + dir2 )
+#  end
+# 
+#  def test_get_all_metadata()
+#    meta = {}
+#    meta['listable'] = EsuApi::Metadata.new( "listable", "foo", true )
+#    meta['unlistable'] = EsuApi::Metadata.new( "unlistable", "bar", false )
+#    meta['listable2'] = EsuApi::Metadata.new( "listable2", "foo2   foo2", true )
+#    meta['unlistable2'] = EsuApi::Metadata.new( "unlistable2", "bar2    bar2", false )
+#    acl = createAcl
+#    op = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    id = @esu.create_object_on_path( op, acl, meta, "object content", "text/plain" )
+#    
+#    om = @esu.get_object_metadata( op )
+#
+#    check_acl( acl, om.acl )    
+#    assert_equal( "text/plain", om.mimetype, "wrong mimetype" )
+#    assert_equal( "foo", om.meta["listable"].value, "Value of listable wrong" )
+#    assert_equal( "bar", om.meta["unlistable"].value, "Value of unlistable wrong" )
+#    assert_equal( "foo2   foo2", om.meta["listable2"].value, "Value of listable2 wrong" )
+#    assert_equal( "bar2    bar2", om.meta["unlistable2"].value, "Value of unlistable2 wrong" )
+#  end
+#  
+#  def test_get_shareable_url()
+#    text = "The quick brown fox jumped over the lazy dog"
+#    id = @esu.create_object( nil, nil, text, 'text/plain' )
+#    @cleanup.push( id )
+#    
+#    expires = Time.new()
+#    expires += 3600
+#    url = @esu.get_shareable_url( id, expires )
+#    
+#    uri = URI.parse( url )
+#    io = uri.open()
+#    
+#    assert_equal( text, io.readlines, "object content wrong" )
+#  end
+#  
+#  def test_read_object_stream() 
+#    text = "The quick brown fox jumped over the lazy dog"
+#    id = @esu.create_object( nil, nil, text, 'text/plain' )
+#    @cleanup.push( id )
+#    
+#    io = @esu.read_object_stream( id )
+#    assert_equal( text, io.readlines, "object content wrong" )
+#  end
+#  
+#  def test_checksum()
+#    text = "hello world"
+#    
+#    ck = EsuApi::Checksum.new( EsuApi::Checksum::SHA0 )
+#    ck.update( text )
+#    assert_equal( "SHA0/11/9fce82c34887c1953b40b3a2883e18850c4fa8a6", ck.to_s(), "Checkum test failed" )
+#  end
+#  
+#  def test_create_checksum() 
+#    ck = EsuApi::Checksum.new( EsuApi::Checksum::SHA0 )
+#    ObjectId id = @esu.create_object( nil, nil, "hello world", "text/plain", ck );
+#    @cleanup.push( id )
+#  end
+#  
+#  def test_rename()
+#    op1 = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    op2 = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    
+#    id = @esu.create_object_on_path( op1, nil, nil, "hello world", "text/plain" )
+#    @cleanup.push( id )
+#    
+#    # Rename it
+#    @esu.rename( op1, op2 )
+#    
+#    # Check loading from new name
+#    text = @esu.read_object( op2 )
+#    
+#    assert_equals( "hello world", text, "Renamed object content wrong" )
+#  end
+#  
+#  def test_overwrite()
+#    op1 = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    op2 = EsuApi::ObjectPath.new( '/' + randomstr( 8 ) )
+#    
+#    id = @esu.create_object_on_path( op1, nil, nil, "hello world", "text/plain" )
+#    @cleanup.push( id )
+#    @esu.create_object_on_path( op2, nil, nil, "you shouldn't see me", "text/plain" )
+#    
+#    # Rename it and overwrite
+#    @esu.rename( op1, op2, true )
+#    
+#    # Wait 5 seconds for server to overwrite object
+#    sleep( 5 )
+#    
+#    # Check loading from new name
+#    text = @esu.read_object( op2 )
+#    
+#    assert_equals( "hello world", text, "Renamed object content wrong" )
+#  end
+#      
+#  
+#  def test_get_service_information()
+#    si = @esu.get_service_information()
+#    
+#    assert_not_nil( si.atmos_version, "Atmos version is nil" ) 
+#  end
+#  
+#  # Tests readback with checksum verification.  In order to test this, create a policy
+#  # with erasure coding and then set a policy selector with "policy=erasure" to invoke
+#  # the erasure coding policy.
+#  def test_read_checksum()
+#    meta = {}
+#    meta["policy"] = EsuApi::Metadata.new( "policy", "erasure", false )
+#    ck = EsuApi::Checksum.new( EsuApi::Checksum::SHA0 )
+#    id = @esu.create_object( nil, meta, "hello world", "text/plain", ck )
+#    @cleanup.push( id )
+#    
+#    ck2 = EsuApi::Checksum.new( EsuApi::Checksum::SHA0 )
+#    text = @esu.read_object( id, nil, nil, ck2 )
+#    assert_equal( "hello world", text, "object content wrong" )
+#    assert_equal( ck1.to_s(), ck2.to_s(), "checksums don't match" )
+#    assert_equal( ck2.expected_value, ck2.to_s(), "checksum doesn't match expected value" )
+#  end
+#  
+#  private
+#
+#  #
+#  # Generate a random string that does not start or end with a space but can
+#  # contain a space.
+#  #
+#  def randomstr( len )
+#    chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + " ".to_a
+#    endchars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+#    newstr = ""
+#    newstr << endchars[rand(endchars.size-1)]
+#    2.upto(len-1) { |i| newstr << chars[rand(chars.size-1)] }
+#    newstr << endchars[rand(endchars.size-1)]
+#    return newstr
+#  end
+#
+#  #
+#  # Creates a file/stream with the given count of 
+#  # random characters
+#  #
+#  def createTestStream( len )
+#    tmpfile = Tempfile.new( "esutest" )
+#    @cleanfiles.push( tmpfile )
+#
+#    tmpfile.open() do |aFile|
+#      aFile << randomstr( len )
+#    end
+#
+#    return tmpfile
+#  end
+#  
+#  def createAcl
+#    acl = []
+#    
+#    acl.push( EsuApi::Grant.new( EsuApi::Grantee( @uid, EsuApi::Grantee::USER ), EsuApi::Grant::FULL_CONTROL ) )
+#    acl.push( EsuApi::Grant::OTHER, EsuApi::Grant::READ )  
+#    
+#    return acl
+#  end
+#  
+#  # 
+#  # Check to make sure that all the entries in acl1 exist
+#  # in ACL2.  We do it this way because some Atmos servers
+#  # are configured to add default grants to objects
+#  #
+#  def checkAcl( acl1, acl2 )
+#    acl1.each { |entry| assert( acl2.include?(entry), "ACL entry" + entry + " not found in " + acl2 ) }
+#  end
+end