openstack 1.0.0

data/lib/openstack/swift/connection.rb

@@ -0,0 +1,185 @@
+#Initial version of this code is based on and refactored from the rackspace/ruby-cloudfiles repo
+#@ https://github.com/rackspace/ruby-cloudfiles - Copyright (c) 2011, Rackspace US, Inc.
+# See COPYING for license information
+#
+module OpenStack
+module Swift
+  class Connection
+
+    attr_accessor :connection
+
+    def initialize(connection)
+      @connection = connection
+      OpenStack::Authentication.init(@connection)
+    end
+
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    #   cf.authok?
+    #   => true
+    def authok?
+      @connection.authok
+    end
+
+    # Returns an OpenStack::Swift::Container object that can be manipulated easily.
+    # Throws a OpenStack::Exception::ItemNotFound if the container doesn't exist.
+    #
+    #    container = cf.container('test')
+    #    container.count
+    #    => 2
+    #    container = cf.container("no_such_container")
+    #    => OpenStack::Exception::ItemNotFound: The resource could not be found
+    #
+    def container(name)
+      OpenStack::Swift::Container.new(self, name)
+    end
+    alias :get_container :container
+
+    # Sets instance variables for the bytes of storage used for this account/connection, as well as the number of containers
+    # stored under the account.  Returns a hash with :bytes and :count keys, and also sets the instance variables.
+    #
+    #   cf.get_info
+    #   => {:count=>8, :bytes=>42438527}
+    #   cf.bytes
+    #   => 42438527
+    # Hostname of the storage server
+    def get_info
+        raise OpenStack::Exception::Authentication, "Not authenticated" unless authok?
+        response = @connection.req("HEAD", "")
+        @bytes = response["x-account-bytes-used"].to_i
+        @count = response["x-account-container-count"].to_i
+        {:bytes => @bytes, :count => @count}
+    end
+
+    # The total size in bytes under this connection
+    def bytes
+      get_info[:bytes]
+    end
+
+    # The total number of containers under this connection
+    def count
+      get_info[:count]
+    end
+
+    # Gathers a list of the containers that exist for the account and returns the list of container names
+    # as an array.  If no containers exist, an empty array is returned.
+    #
+    # If you supply the optional limit and marker parameters, the call will return the number of containers
+    # specified in limit, starting after the object named in marker.
+    #
+    #   cf.containers
+    #   => ["backup", "Books", "cftest", "test", "video", "webpics"]
+    #
+    #   cf.containers(2,'cftest')
+    #   => ["test", "video"]
+    def containers(limit = nil, marker = nil)
+      path = OpenStack.get_query_params({:limit=>limit, :marker=>marker}, [:limit, :marker], "")
+      response = @connection.req("GET", URI.encode(path))
+      OpenStack.symbolize_keys(JSON.parse(response.body)).inject([]){|res,cur| res << cur[:name]; res }
+    end
+    alias :list_containers :containers
+
+    # Retrieves a list of containers on the account along with their sizes (in bytes) and counts of the objects
+    # held within them.  If no containers exist, an empty hash is returned.
+    #
+    # If you supply the optional limit and marker parameters, the call will return the number of containers
+    # specified in limit, starting after the object named in marker.
+    #
+    #   cf.containers_detail
+    #   => { "container1" => { :bytes => "36543", :count => "146" },
+    #        "container2" => { :bytes => "105943", :count => "25" } }
+    def containers_detail(limit = nil, marker = nil)
+      path = OpenStack.get_query_params({:limit=>limit, :marker=>marker}, [:limit, :marker], "")
+      response = @connection.req("GET", URI.encode(path))
+      OpenStack.symbolize_keys(JSON.parse(response.body)).inject({}){|res,current| res.merge!({current[:name]=>{:bytes=>current[:bytes].to_s,:count=>current[:count].to_s}}) ; res }
+    end
+    alias :list_containers_info :containers_detail
+
+    # Returns true if the requested container exists and returns false otherwise.
+    #
+    #   cf.container_exists?('good_container')
+    #   => true
+    #
+    #   cf.container_exists?('bad_container')
+    #   => false
+    def container_exists?(containername)
+      path = "/#{URI.encode(containername.to_s)}"
+      begin
+        response = @connection.req("HEAD", path)
+      rescue OpenStack::Exception::ItemNotFound
+        return false
+      end
+      true
+    end
+
+    # Creates a new container and returns the OpenStack::Swift::Container object.
+    #
+    # "/" is not valid in a container name.  The container name is limited to
+    # 256 characters or less.
+    #
+    #   container = cf.create_container('new_container')
+    #   container.name
+    #   => "new_container"
+    #
+    #   container = cf.create_container('bad/name')
+    #   => OpenStack::Exception::InvalidArgument: Container name cannot contain '/'
+    def create_container(containername)
+      raise OpenStack::Exception::InvalidArgument.new("Container name cannot contain '/'") if containername.match("/")
+      raise OpenStack::Exception::InvalidArgument.new("Container name is limited to 256 characters") if containername.length > 256
+      path = "/#{URI.encode(containername.to_s)}"
+      @connection.req("PUT", path)
+      OpenStack::Swift::Container.new(self, containername)
+    end
+
+    # Deletes a container from the account.  Throws a OpenStack::Exception::ResourceStateConflict
+    # if the container still contains objects.  Throws a OpenStack::Exception::ItemNotFound if the
+    # container doesn't exist.
+    #
+    #   cf.delete_container('new_container')
+    #   => true
+    #
+    #   cf.delete_container('video')
+    #   => OpenStack::Exception::ResourceStateConflict: The container: "video" is not empty. There was a conflict with the state of the resource
+    #
+    #
+    #   cf.delete_container('nonexistent')
+    #   => OpenStack::Exception::ItemNotFound: The container: "nonexistant" does not exist. The resource could not be found
+    def delete_container(containername)
+      path = "/#{URI.encode(containername.to_s)}"
+      begin
+        @connection.req("DELETE", path)
+      rescue OpenStack::Exception::ResourceStateConflict => conflict
+        msg = "The container: \"#{containername}\" is not empty. #{conflict.message}"
+        raise OpenStack::Exception::ResourceStateConflict.new(msg, conflict.response_code, conflict.response_body)
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "The container: \"#{containername}\" does not exist. #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+      true
+    end
+
+  end
+
+#used for PUT object with body_stream for http data
+#see OpenStack::Connection::put_object
+  class ChunkedConnectionWrapper
+    def initialize(data, chunk_size)
+      @size = chunk_size
+      @file = data
+    end
+
+    def read(foo)
+      @file.read(@size)
+    end
+
+    def eof!
+      @file.eof!
+    end
+    def eof?
+      @file.eof?
+    end
+  end
+
+
+end
+end

data/lib/openstack/swift/container.rb

@@ -0,0 +1,214 @@
+#Initial version of this code is based on and refactored from the rackspace/ruby-cloudfiles repo
+#@ https://github.com/rackspace/ruby-cloudfiles - Copyright (c) 2011, Rackspace US, Inc.
+# See COPYING for license information
+#
+module OpenStack
+module Swift
+  class Container
+
+    attr_reader :name
+    attr_reader :swift
+    attr_reader :metadata
+
+    def initialize(swift, name)
+      @swift = swift
+      @name = name
+      @metadata = container_metadata
+    end
+
+    # Retrieves Metadata for the container
+    def container_metadata
+      path = "/#{URI.encode(@name.to_s)}"
+      response = @swift.connection.req("HEAD", path)
+      resphash = response.to_hash
+      meta = {:bytes=>resphash["x-container-bytes-used"][0], :count=>resphash["x-container-object-count"][0], :metadata=>{}}
+      resphash.inject({}){|res, (k,v)| meta[:metadata].merge!({ k.gsub("x-container-meta-", "") => v.first }) if k.match(/^x-container-meta-/)}
+      meta
+    end
+
+    # Returns the container's metadata as a Hash, stripping off the X-Meta-Object-
+    # prefix that OpenStack prepends to the metadata key name.
+    #
+    #    object.metadata
+    #    => {"ruby"=>"cool", "foo"=>"bar"}
+    def metadata
+      metahash = {}
+      self.container_metadata[:metadata].each{ |key, value| metahash[key.gsub(/x-container-meta-/, '').gsub(/%20/, ' ')] = URI.decode(value).gsub(/\+\-/, ' ') }
+      metahash
+    end
+
+    # Sets the metadata for a container.  By passing a hash as an argument, you can set the metadata for an object.
+    # New calls to set metadata are additive.  To remove metadata, set the value of the key to nil.
+    # Including the X-Container-Meta- prefix for each metadata key is optional:
+    #
+    # container = os.container("foo")
+    # container.set_metadata({"X-Container-Meta-Author"=> "msa", "version"=>"1.2", :date=>"today"})
+    # => true
+    # container.metadata
+    # => {"date"=>"today", "author"=>"msa", "version"=>"1.2"}
+    #
+    # Returns true if operation is successful;  Throws OpenStack::Exception::ItemNotFound if the
+    # container doesn't exist.
+    #
+    def set_metadata(metadatahash)
+      headers = metadatahash.inject({}){|res, (k,v)| ((k.to_s.match /^X-Container-Meta-/i) ? res[k.to_s]=v : res["X-Container-Meta-#{k}"]=v ) ; res}
+      headers.merge!({'content-type'=>'application/json'})
+      begin
+        response = @swift.connection.req("POST", URI.encode("/#{@name.to_s}"), {:headers=>headers} )
+        true
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "Cannot set metadata - container: \"#{@name}\" does not exist!.  #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+    end
+
+    # Size of the container (in bytes)
+    def bytes
+      container_metadata[:bytes]
+    end
+
+    # Number of objects in the container
+    def count
+      container_metadata[:count]
+    end
+
+    # Returns the OpenStack::Swift::StorageObject for the named object.
+    # Refer to the OpenStack::Swift::StorageObject class for available methods.
+    # If the object exists, it will be returned.  If the object does not exist,
+    # a OpenStack::Exception::ItemNotFound will be thrown.
+    #
+    #   object = container.object('test.txt')
+    #   object.data
+    #   => "This is test data"
+    #
+    #   object = container.object('newfile.txt')
+    #   => OpenStack::Exception::ItemNotFound: No Object "newfile.txt" found in Container "another_container_foo"
+    #
+    def object(objectname)
+      o = OpenStack::Swift::StorageObject.new(self, objectname, true)
+      return o
+    end
+    alias :get_object :object
+
+
+    # Gathers a list of all available objects in the current container and returns an array of object names.
+    #   container = cf.container("My Container")
+    #   container.objects
+    #   => [ "cat", "dog", "donkey", "monkeydir", "monkeydir/capuchin"]
+    # Pass a limit argument to limit the list to a number of objects:
+    #   container.objects(:limit => 1)                  #=> [ "cat" ]
+    # Pass an marker with or without a limit to start the list at a certain object:
+    #   container.objects(:limit => 1, :marker => 'dog')                #=> [ "donkey" ]
+    # Pass a prefix to search for objects that start with a certain string:
+    #   container.objects(:prefix => "do")       #=> [ "dog", "donkey" ]
+    # Only search within a certain pseudo-filesystem path:
+    #   container.objects(:path => 'monkeydir')     #=> ["monkeydir/capuchin"]
+    # Only grab "virtual directories", based on a single-character delimiter (no "directory" objects required):
+    #   container.objects(:delimiter => '/')      #=> ["monkeydir"]
+    # All arguments to this method are optional.
+    #
+    # Returns an empty array if no object exist in the container.
+    # if the request fails.
+    def objects(params = {})
+      path = "/#{@name.to_s}"
+      path = (params.empty?)? path : OpenStack.get_query_params(params, [:limit, :marker, :prefix, :path, :delimiter], path)
+      response = @swift.connection.req("GET", URI.encode(path))
+      OpenStack.symbolize_keys(JSON.parse(response.body)).inject([]){|res, cur| res << cur[:name]; res }
+    end
+    alias :list_objects :objects
+
+    # Retrieves a list of all objects in the current container along with their size
+    # in bytes, hash, and content_type. If no objects exist, an empty hash is returned.
+    #
+    # Accepts the same options as 'objects' method to limit the returned set.
+    #
+    #   container.objects_detail
+    #   => {"test.txt"=>{:content_type=>"application/octet-stream",
+    #                    :hash=>"e2a6fcb4771aa3509f6b27b6a97da55b",
+    #                    :last_modified=>Mon Jan 19 10:43:36 -0600 2009,
+    #                    :bytes=>"16"},
+    #       "new.txt"=>{:content_type=>"application/octet-stream",
+    #                   :hash=>"0aa820d91aed05d2ef291d324e47bc96",
+    #                   :last_modified=>Wed Jan 28 10:16:26 -0600 2009,
+    #                   :bytes=>"22"}
+    #      }
+    def objects_detail(params = {})
+      path = "/#{@name.to_s}"
+      path = (params.empty?)? path : OpenStack.get_query_params(params, [:limit, :marker, :prefix, :path, :delimiter], path)
+      response = @swift.connection.req("GET", URI.encode(path))
+      OpenStack.symbolize_keys(JSON.parse(response.body)).inject({}){|res, current| res.merge!({current[:name]=>{:bytes=>current[:bytes].to_s, :content_type=>current[:content_type].to_s, :last_modified=>current[:last_modified], :hash=>current[:hash]}}) ; res }
+    end
+    alias :list_objects_info :objects_detail
+
+    # Returns true if a container is empty and returns false otherwise.
+    #
+    #   new_container.empty?
+    #   => true
+    #
+    #   full_container.empty?
+    #   => false
+    def empty?
+      return (container_metadata[:count].to_i == 0)? true : false
+    end
+
+    # Returns true if object exists and returns false otherwise.
+    #
+    #   container.object_exists?('goodfile.txt')
+    #   => true
+    #
+    #   container.object_exists?('badfile.txt')
+    #   => false
+    def object_exists?(objectname)
+      path = "/#{@name.to_s}/#{objectname}"
+      begin
+        response = @swift.connection.req("HEAD", URI.encode(path))
+        true
+      rescue OpenStack::Exception::ItemNotFound
+        false
+      end
+    end
+
+    # Creates a new OpenStack::Swift::StorageObject in the current container.
+    #
+    # If an object with the specified name exists in the current container, that object will be overwritten
+    #
+    #optional headers: {
+    #                    :metadata=>{key=>value, key1=>value1, ...}
+    #                    :content_type=>content type of created object
+    #                    :etag=>MD5 checksum of object data to be compared to that on server side
+    #                    :manifest=>set manifest header for segmented large object
+    #                   }
+    # The optional data can be a File or a String - see StorageObject.create and .write methods
+    def create_object(objectname, headers={}, data=nil)
+      OpenStack::Swift::StorageObject.create(self, objectname, headers, data)
+    end
+
+    # Removes an OpenStack::Swift::StorageObject from a container.
+    # True is returned if the removal is successful.
+    # Throws  OpenStack::Exception::ItemNotFound if the object doesn't exist.
+    #
+    #   container.delete_object('new.txt')
+    #   => true
+    #
+    #   container.delete_object('Foo')
+    #   =>OpenStack::Exception::ItemNotFound: The object: "Foo" does not exist in container "another_containerfoo".  The resource could not be found
+    #
+    def delete_object(objectname)
+      path = "/#{@name.to_s}/#{objectname}"
+      begin
+        response = @swift.connection.req("DELETE", URI.encode(path))
+        true
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "The object: \"#{objectname}\" does not exist in container \"#{@name}\".  #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+    end
+
+
+    def to_s # :nodoc:
+      @name
+    end
+
+  end
+end
+end

data/lib/openstack/swift/storage_object.rb

@@ -0,0 +1,311 @@
+#Initial version of this code is based on and refactored from the rackspace/ruby-cloudfiles repo
+#@ https://github.com/rackspace/ruby-cloudfiles - Copyright (c) 2011, Rackspace US, Inc.
+# See COPYING for license information
+#
+module OpenStack
+module Swift
+  class StorageObject
+
+    attr_reader :name
+    attr_reader :container
+    attr_reader :metadata
+
+    # Builds a new OpenStack::Swift::StorageObject in the specified container.
+    # If force_exist is set, the object must exist or a
+    # OpenStack::Exception::ItemNotFound will be raised.
+    # If not, an "empty" StorageObject will be returned, ready for data
+    # via the write method
+    #
+    # The container parameter must be an OpenStack::Swift::Container object.
+    #
+    # This constructor is typically not called directly. You can get a reference to
+    # an existing Object via OpenStack::Swift::Container::object method or create a
+    # new Object via OpenStack::Swift::Container::create_object method
+    #
+    def initialize(container, objectname, force_exists = false)
+      @container = container
+      @containername = container.name
+      @name = objectname
+
+      if force_exists
+        raise OpenStack::Exception::ItemNotFound.new("No Object \"#{@name}\" found in Container \"#{@containername}\"", "404", "") unless container.object_exists?(objectname)
+      end
+    end
+
+    #create a new Object in a given Container
+    #optional headers: {
+    #                    :metadata=>{key=>value, key1=>value1, ...}
+    #                    :content_type=>content type of created object
+    #                    :etag=>MD5 checksum of object data to be compared to that on server side
+    #                    :manifest=>set manifest header for segmented large object
+    #                   }
+    #
+    # The container parameter must be an OpenStack::Swift::Container object.
+    # Typically you'd create an Object by first getting a Container:
+    # cont = os.container("foo_container")
+    # cont.create_object("my_new_object", {}, "object data")
+    #
+    def self.create(container, objectname, headers={}, data=nil)
+      provided_headers = (headers[:metadata] || {}).inject({}){|res, (k,v)| ((k.match /^X-Object-Meta-/i) ? res[k]=v : res["X-Object-Meta-#{k}"]=v) ;res}
+      provided_headers["content-type"] = headers[:content_type] unless headers[:content_type].nil?
+      provided_headers["ETag"] = headers[:etag] unless headers[:etag].nil?
+      provided_headers["X-Object-Manifest"] = headers[:manifest] unless headers[:manifest].nil?
+      if data.nil? #just create an empty object
+        path = "/#{container.name}/#{objectname}"
+        provided_headers["content-length"] = "0"
+        container.swift.connection.req("PUT", URI.encode(path), {:headers=>provided_headers})
+      else
+        self.new(container, objectname).write(data, provided_headers)
+      end
+      self.new(container, objectname)
+    end
+
+    # Retrieves Metadata for the object
+    #  object = container.object("conversion_helper.rb")
+    #  => #<OpenStack::Swift::StorageObject:0xb7692488  ....
+    #  object.object_metadata
+    #  => {:manifest=>nil, :bytes=>"1918", :content_type=>"application/octet-stream", :metadata=>{"foo"=>"bar, "herpa"=>"derp"}, :etag=>"1e5b089a1d92052bcf759d86465143f8", :last_modified=>"Tue, 17 Apr 2012 08:46:35 GMT"}
+    #
+    def object_metadata
+      path = "/#{@containername}/#{@name}"
+      response = @container.swift.connection.req("HEAD", path)
+      resphash = response.to_hash
+      meta = { :bytes=>resphash["content-length"][0],
+               :content_type=>resphash["content-type"][0],
+               :last_modified=>resphash["last-modified"][0],
+               :etag=>resphash["etag"][0],
+               :manifest=> (resphash.has_key?("x-object-manifest") ? resphash["x-object-manifest"][0] : nil),
+               :metadata=>{}}
+      resphash.inject({}){|res, (k,v)| meta[:metadata].merge!({ k.gsub("x-object-meta-", "") => v.first }) if k.match(/^x-object-meta-/)}
+      meta
+    end
+
+    #returns just the user defined custom metadata
+    # obj.metadata
+    # => {"foo"=>"bar, "herpa"=>"derp"}
+    def metadata
+      self.object_metadata[:metadata]
+    end
+
+    # Size of the object (in bytes)
+    # obj.bytes
+    # => "493009"
+    def bytes
+      self.object_metadata[:bytes]
+    end
+
+    # Date of the object's last modification
+    # obj.last_modified
+    # => "Thu, 26 Apr 2012 09:22:51 GMT"
+    def last_modified
+      self.object_metadata[:last_modified]
+    end
+
+    # ETag of the object data
+    # obj.etag
+    # => "494e444f92a8082dabac80a74cdf2c3b"
+    def etag
+      self.object_metadata[:etag]
+    end
+
+    # Content type of the object data
+    # obj.content_type
+    # => "application/json"
+    def content_type
+      self.object_metadata[:content_type]
+    end
+
+    # Retrieves the data from an object and stores the data in memory.  The data is returned as a string.
+    # Throws a OpenStack::Exception::ItemNotFound if the object doesn't exist.
+    #
+    # If the optional size and range arguments are provided, the call will return the number of bytes provided by
+    # size, starting from the offset provided in offset.
+    #
+    #   object.data
+    #   => "This is the text stored in the file"
+    def data(size = -1, offset = 0, headers = {})
+      headers = {'content-type'=>'application/json'}
+      if size.to_i > 0
+        range = sprintf("bytes=%d-%d", offset.to_i, (offset.to_i + size.to_i) - 1)
+        headers['Range'] = range
+      end
+      path = "/#{@containername}/#{@name}"
+      begin
+        response = @container.swift.connection.req("GET", URI.encode(path), {:headers=>headers})
+        response.body
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "No Object \"#{@name}\" found in Container \"#{@containername}\".  #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+    end
+    alias :read :data
+
+    # Retrieves the data from an object and returns a stream that must be passed to a block.
+    # Throws a OpenStack::Exception::ItemNotFound if the object doesn't exist.
+    #
+    # If the optional size and range arguments are provided, the call will return the number of bytes provided by
+    # size, starting from the offset provided in offset.
+    #
+    # The method returns the HTTP response object
+    #
+    #   data = ""
+    #   object.data_stream do |chunk| data += chunk end
+    #   => #<Net::HTTPOK 200 OK readbody=true>
+    #   data
+    #   => "This is the text stored in the file"
+    def data_stream(size = -1, offset = 0, &block)
+      headers = {'content-type'=>'application/json'}
+      if size.to_i > 0
+        range = sprintf("bytes=%d-%d", offset.to_i, (offset.to_i + size.to_i) - 1)
+        headers['Range'] = range
+      end
+      server = @container.swift.connection.service_host
+      path = @container.swift.connection.service_path + URI.encode("/#{@containername}/#{@name}")
+      port = @container.swift.connection.service_port
+      scheme = @container.swift.connection.service_scheme
+      response = @container.swift.connection.csreq("GET", server, path, port, scheme, headers, nil, 0, &block)
+      raise OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      response
+    end
+
+    # Sets the metadata for an object.  By passing a hash as an argument, you can set the metadata for an object.
+    # However, setting metadata will overwrite any existing metadata for the object. Returns true if the call
+    # was successful. Throws OpenStack::Exception::ItemNotFound if the object doesn't exist.
+    #
+    # The OpenStack mandated 'X-Object-Meta' prefix is optional:
+    #
+    # obj.set_metadata({:foo=>"bar", "X-Object-Meta-herpa"=>"derp", "author"=>"me"})
+    # => true
+    #
+    # obj.metadata
+    # => {"foo"=>"bar", "author"=>"me", "herpa"=>"derp"}
+    #
+    def set_metadata(metadatahash)
+      headers  = metadatahash.inject({}){|res, (k,v)| ((k.to_s.match /^X-Object-Meta-/i) ? res[k.to_s]=v : res["X-Object-Meta-#{k.to_s}"]=v ) ;res}
+      headers['content-type'] = 'application/json'
+      path = "/#{@containername}/#{@name}"
+      begin
+        response = @container.swift.connection.req("POST", URI.encode(path), {:headers=>headers})
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "Can't set metadata: No Object \"#{@name}\" found in Container \"#{@containername}\".  #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+      true
+    end
+    alias :metadata= :set_metadata
+
+
+    # Returns the object's manifest.
+    #
+    #    object.manifest
+    #    => "container/prefix"
+    def manifest
+      self.object_metadata[:manifest]
+    end
+
+
+    # Sets the manifest for an object.  By passing a string as an argument, you can set the manifest for an object.
+    # However, setting manifest will overwrite any existing manifest for the object.
+    #
+    # Throws OpenStack::Exception::ItemNotFound if the object doesn't exist. Returns true if the call is successful.
+    #
+    def set_manifest(manifest)
+      headers = {'X-Object-Manifest' => manifest}
+      path = "/#{@containername}/#{@name}"
+      begin
+        response = @container.swift.connection.req("POST", URI.encode(path), {:headers=>headers})
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "Can't set manifest: No Object \"#{@name}\" found in Container \"#{@containername}\".  #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+      true
+    end
+
+
+    # Takes supplied data and writes it to the object, saving it.  You can supply an optional hash of headers, including
+    # Content-Type and ETag, that will be applied to the object.
+    #
+    # If you would rather stream the data in chunks, instead of reading it all into memory at once, you can pass an
+    # IO object for the data, such as: object.write(open('/path/to/file.mp3'))
+    #
+    # You can compute your own MD5 sum and send it in the "ETag" header.  If you provide yours, it will be compared to
+    # the MD5 sum on the server side.
+    #
+    # Returns true on success, raises exceptions if stuff breaks.
+    #
+    #   object = container.create_object("newfile.txt")
+    #
+    #   object.write("This is new data")
+    #   => true
+    #
+    #   object.data
+    #   => "This is new data"
+    #
+    #
+    def write(data, headers = {})
+      server = @container.swift.connection.service_host
+      path = @container.swift.connection.service_path + URI.encode("/#{@containername}/#{@name}")
+      port = @container.swift.connection.service_port
+      scheme = @container.swift.connection.service_scheme
+      body = (data.is_a?(String))? StringIO.new(data) : data
+      body.binmode if (body.respond_to?(:binmode))
+      response = @container.swift.connection.put_object(server, path, port, scheme, headers, body, 0)
+      raise OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+
+    # Copy this object to a new location (optionally in a new container)
+    #
+    # You must supply a name for the new object as well as a container name.
+    #
+    #    new_object = object.copy("new_obj", "my_container")
+    #
+    # You may also supply a hash of headers to set Content-Type, or custom
+    # key=>value metadata:
+    #optional headers: {
+    #                    :metadata=>{key=>value, key1=>value1, ...}
+    #                    :content_type=>content type of created object
+    #                  }
+    #
+    #    copied = object.copy('newfile.tmp', "my_container", {:content_type=>"text/plain", :metadata=>{:herp=>"derp", "X-Object-Meta-foo"=>"bar} } )
+    #    => => #<OpenStack::Swift::StorageObject:0xb728974c  .....
+    #
+    # Returns the new OpenStack::Swift::StorageObject for the copied item.
+    #
+    def copy(object_name, container_name, headers = {})
+      provided_headers = (headers[:metadata] || {}).inject({}){|res, (k,v)| ((k.to_s.match /^X-Object-Meta-/i) ? res[k.to_s]=v : res["X-Object-Meta-#{k.to_s}"]=v) ;res}
+      provided_headers["content-type"] = headers[:content_type] unless headers[:content_type].nil?
+      provided_headers["X-Copy-From"] = "/#{@containername}/#{@name}"
+      provided_headers["content-length"] = "0"
+      path = "/#{container_name}/#{object_name}"
+      begin
+        response = @container.swift.connection.req("PUT", URI.encode(path), {:headers=>provided_headers})
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        msg = "Can't copy \"#{@name}\": No Object \"#{@name}\" found in Container \"#{@containername}\".  #{not_found.message}"
+        raise OpenStack::Exception::ItemNotFound.new(msg, not_found.response_code, not_found.response_body)
+      end
+      OpenStack::Swift::StorageObject.new(@container.swift.container(container_name), object_name)
+    end
+
+    # Takes the same options as the copy method, only it does a copy followed by a delete on the original object.
+    #
+    # Returns the new OpenStack::Swift::StorageObject for the moved item.
+    # You should not attempt to use the old object after doing
+    # a move.
+    # optional headers: {
+    #                    :metadata=>{key=>value, key1=>value1, ...}
+    #                    :content_type=>content type of created object
+    #                  }
+    def move(object_name, container_name, headers={})
+      new_object = self.copy(object_name, container_name, headers)
+      @container.delete_object(@name)
+      new_object
+    end
+
+    def to_s # :nodoc:
+      @name
+    end
+
+  end
+end
+end