gotime_aws 2.5.6

data/lib/iam/iam.rb

@@ -0,0 +1,126 @@
+module Aws
+
+  require 'xmlsimple'
+
+  class Iam < AwsBase
+
+    include AwsBaseInterface
+
+    API_VERSION = "2010-05-08"
+    DEFAULT_HOST = "iam.amazonaws.com"
+    DEFAULT_PATH = '/'
+    DEFAULT_PROTOCOL = 'https'
+    DEFAULT_PORT = 443
+
+    def self.connection_name
+      :iam_connection
+    end
+
+    @@bench = AwsBenchmarkingBlock.new
+
+    def self.bench
+      @@bench
+    end
+
+    def self.bench_xml
+      @@bench.xml
+    end
+
+    def self.bench_ec2
+      @@bench.service
+    end
+
+    # Current API version (sometimes we have to check it outside the GEM).
+    @@api = ENV['IAM_API_VERSION'] || API_VERSION
+
+    def self.api
+      @@api
+    end
+
+
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+      init({:name => 'IAM',
+            :default_host => ENV['IAM_URL'] ? URI.parse(ENV['IAM_URL']).host : DEFAULT_HOST,
+            :default_port => ENV['IAM_URL'] ? URI.parse(ENV['IAM_URL']).port : DEFAULT_PORT,
+            :default_service => ENV['IAM_URL'] ? URI.parse(ENV['IAM_URL']).path : DEFAULT_PATH,
+            :default_protocol => ENV['IAM_URL'] ? URI.parse(ENV['IAM_URL']).scheme : DEFAULT_PROTOCOL,
+            :api_version => API_VERSION},
+           aws_access_key_id || ENV['AWS_ACCESS_KEY_ID'],
+           aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
+           params)
+    end
+
+    def do_request(action, params, options={})
+      link = generate_request(action, params)
+      p link[:request]
+      resp = request_info_xml_simple(:iam_connection, @params, link, @logger,
+                                     :group_tags =>{"LoadBalancersDescriptions"=>"LoadBalancersDescription",
+                                                    "DBParameterGroups" =>"DBParameterGroup",
+                                                    "DBSecurityGroups" =>"DBSecurityGroup",
+                                                    "EC2SecurityGroups" =>"EC2SecurityGroup",
+                                                    "IPRanges" =>"IPRange"},
+                                     :force_array =>["DBInstances",
+                                                     "DBParameterGroups",
+                                                     "DBSecurityGroups",
+                                                     "EC2SecurityGroups",
+                                                     "IPRanges"],
+                                     :pull_out_array =>options[:pull_out_array],
+                                     :pull_out_single=>options[:pull_out_single],
+                                     :wrapper =>options[:wrapper])
+    end
+
+
+    #-----------------------------------------------------------------
+    #      REQUESTS
+    #-----------------------------------------------------------------
+
+
+    # options:
+    #    :marker => value received from previous response if IsTruncated = true
+    #    :max_items => number of items you want returned
+    #    :path_previx => for filtering results, default is /
+    def list_server_certificates(options={})
+      @logger.info("Listing server certificates...")
+
+      params = {}
+      params['Marker'] = options[:marker] if options[:marker]
+      params['MaxItems'] = options[:max_items] if options[:max_items]
+      params['PathPrefix'] = options[:path_prefix] if options[:path_prefix]
+
+      resp = do_request("ListServerCertificates", params, :pull_out_array=>[:list_server_certificates_result, :server_certificate_metadata_list])
+
+
+    rescue Exception
+      on_exception
+    end
+
+    #
+    # name: name of certificate
+    # public_key: public key certificate in PEM-encoded format
+    # private_key: private key in PEM-encoded format
+    # options:
+    #    :path => specify a path you want it stored in
+    #    :certificate_chain => contents of certificate chain
+    def upload_server_certificate(name, public_key, private_key, options={})
+      params = {}
+      params['ServerCertificateName'] = name
+      params['PrivateKey'] = private_key
+      params['CertificateBody'] = public_key
+
+      params['CertificateChain'] = options[:certificate_chain] if options[:certificate_chain]
+      params['Path'] = options[:path] if options[:path]
+
+      p params
+
+      resp = do_request("UploadServerCertificate", params, :pull_out_array=>[:list_server_certificates_result, :server_certificate_metadata_list])
+
+
+    rescue Exception
+      on_exception
+    end
+
+
+  end
+
+
+end

data/lib/rds/rds.rb

@@ -0,0 +1,222 @@
+module Aws
+  require 'xmlsimple'
+
+  # API Reference: http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/
+  class Rds < AwsBase
+    include AwsBaseInterface
+
+
+    # Amazon API version being used
+    API_VERSION      = nil
+    DEFAULT_HOST     = "rds.amazonaws.com"
+    DEFAULT_PATH     = '/'
+    DEFAULT_PROTOCOL = 'https'
+    DEFAULT_PORT     = 443
+
+    @@api            = ENV['RDS_API_VERSION'] || API_VERSION
+
+
+    def self.connection_name
+      :rds_connection
+    end
+
+    def self.api
+      @@api
+    end
+
+
+    @@bench = AwsBenchmarkingBlock.new
+
+    def self.bench
+      @@bench
+    end
+
+    def self.bench_xml
+      @@bench.xml
+    end
+
+
+    def self.bench_ec2
+      @@bench.service
+    end
+
+
+    def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+      uri = ENV['RDS_URL'] ? URI.parse(ENV['RDS_URL']) : nil
+      init({:name             => 'RDS',
+            :default_host     => uri ? uri.host : DEFAULT_HOST,
+            :default_port     => uri ? uri.port : DEFAULT_PORT,
+            :default_service  => uri ? uri.path : DEFAULT_PATH,
+            :default_protocol => uri ? uri.scheme : DEFAULT_PROTOCOL,
+            :api_version      => API_VERSION},
+           aws_access_key_id || ENV['AWS_ACCESS_KEY_ID'],
+           aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
+           params)
+    end
+
+
+    def do_request(action, params, options={})
+      link = generate_request(action, params)
+      resp = request_info_xml_simple(self.class.connection_name, @params, link, @logger,
+                                     :group_tags     =>{"DBInstances"      =>"DBInstance",
+                                                        "DBParameterGroups"=>"DBParameterGroup",
+                                                        "DBSecurityGroups" =>"DBSecurityGroup",
+                                                        "EC2SecurityGroups"=>"EC2SecurityGroup",
+                                                        "IPRanges"         =>"IPRange"},
+                                     :force_array    =>["DBInstances",
+                                                        "DBParameterGroups",
+                                                        "DBSecurityGroups",
+                                                        "EC2SecurityGroups",
+                                                        "IPRanges"],
+                                     :pull_out_array =>options[:pull_out_array],
+                                     :pull_out_single=>options[:pull_out_single],
+                                     :wrapper        =>options[:wrapper])
+    end
+
+
+    #-----------------------------------------------------------------
+    #      REQUESTS
+    #-----------------------------------------------------------------
+
+    #
+    # identifier: db instance identifier. Must be unique per account per zone.
+    # instance_class: db.m1.small | db.m1.large | db.m1.xlarge | db.m2.2xlarge | db.m2.4xlarge
+    # See this for other values: http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/
+    #
+    # options:
+    #    db_name: if you want a database created at the same time as the instance, specify :db_name option.
+    #    availability_zone: default is random zone.
+    def create_db_instance(identifier, instance_class, allocated_storage, master_username, master_password, options={})
+      params                         = {}
+      params['DBInstanceIdentifier'] = identifier
+      params['DBInstanceClass']      = instance_class
+      params['AllocatedStorage']     = allocated_storage
+      params['MasterUsername']       = master_username
+      params['MasterUserPassword']   = master_password
+
+      params['Engine']               = options[:engine] || "MySQL5.1"
+      params['DBName'] = options[:db_name] if options[:db_name]
+      params['AvailabilityZone'] = options[:availability_zone] if options[:availability_zone]
+      params['PreferredMaintenanceWindow'] = options[:preferred_maintenance_window] if options[:preferred_maintenance_window]
+      params['BackupRetentionPeriod'] = options[:preferred_retention_period] if options[:preferred_retention_period]
+      params['PreferredBackupWindow'] = options[:preferred_backup_window] if options[:preferred_backup_window]
+
+      @logger.info("Creating DB Instance called #{identifier}")
+
+      link = do_request("CreateDBInstance", params, :pull_out_single=>[:create_db_instance_result, :db_instance])
+
+    rescue Exception
+      on_exception
+    end
+
+
+    # options:
+    #      DBInstanceIdentifier
+    #      MaxRecords
+    #      Marker
+    #
+    # Returns array of instances as hashes.
+    # Response metadata can be retreived by calling array.response_metadata on the returned array.
+    def describe_db_instances(options={})
+      params = {}
+      params['DBInstanceIdentifier'] = options[:db_instance_identifier] if options[:db_instance_identifier]
+      params['MaxRecords'] = options[:max_records] if options[:max_records]
+      params['Marker'] = options[:marker] if options[:marker]
+
+      resp = do_request("DescribeDBInstances", params, :pull_out_array=>[:describe_db_instances_result, :db_instances])
+
+    rescue Exception
+      on_exception
+    end
+
+
+    # identifier: identifier of db instance to delete.
+    # final_snapshot_identifier: if specified, RDS will crate a final snapshot before deleting so you can restore it later.
+    def delete_db_instance(identifier, final_snapshot_identifier=nil)
+      @logger.info("Deleting DB Instance - " + identifier.to_s)
+
+      params                         = {}
+      params['DBInstanceIdentifier'] = identifier
+      if final_snapshot_identifier
+        params['FinalDBSnapshotIdentifier'] = final_snapshot_identifier
+      else
+        params['SkipFinalSnapshot'] = true
+      end
+
+      link = do_request("DeleteDBInstance", params, :pull_out_single=>[:delete_db_instance_result, :db_instance])
+
+    rescue Exception
+      on_exception
+    end
+
+
+    def create_db_security_group(group_name, description, options={})
+      params                               = {}
+      params['DBSecurityGroupName']        = group_name
+      params['DBSecurityGroupDescription'] = description
+
+      link                                 = do_request("CreateDBSecurityGroup", params, :pull_out_single => [:create_db_security_group_result, :db_security_group])
+
+    rescue Exception
+      on_exception
+    end
+
+
+    def delete_db_security_group(group_name, options={})
+      params                        = {}
+      params['DBSecurityGroupName'] = group_name
+
+      link                          = do_request("DeleteDBSecurityGroup", params)
+
+    rescue Exception
+      on_exception
+    end
+
+
+    def describe_db_security_groups(options={})
+      params = {}
+      params['DBSecurityGroupName'] = options[:DBSecurityGroupName] if options[:DBSecurityGroupName]
+      params['MaxRecords'] = options[:MaxRecords] if options[:MaxRecords]
+
+      link = do_request("DescribeDBSecurityGroups", params, :pull_out_array=>[:describe_db_security_groups_result, :db_security_groups], :wrapper=>:db_security_group)
+
+
+    rescue Exception
+      on_exception
+    end
+
+
+    def authorize_db_security_group_ingress_ec2group(group_name, ec2_group_name, ec2_group_owner_id, options={})
+      params                            = {}
+      params['DBSecurityGroupName']     = group_name
+      params['EC2SecurityGroupOwnerId'] = ec2_group_owner_id
+      params['EC2SecurityGroupName']    = ec2_group_name
+      link                              = do_request("AuthorizeDBSecurityGroupIngress", params)
+    rescue Exception
+      on_exception
+    end
+
+
+    def authorize_db_security_group_ingress_range(group_name, ip_range, options={})
+      params                        = {}
+      params['DBSecurityGroupName'] = group_name
+      params['CIDRIP']              = ip_range
+      link                          = do_request("AuthorizeDBSecurityGroupIngress", params)
+    rescue Exception
+      on_exception
+    end
+
+
+    def revoke_db_security_group_ingress(group_name, ip_range, options={})
+      params                        = {}
+      params['DBSecurityGroupName'] = group_name
+      params['CIDRIP']              = ip_range
+      link                          = do_request("RevokeDBSecurityGroupIngress", params)
+    rescue Exception
+      on_exception
+    end
+
+
+  end
+
+end

data/lib/right_aws.rb

@@ -0,0 +1,57 @@
+#
+# Copyright (c) 2007-2008 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'benchmark'
+require 'net/https'
+require 'uri'
+require 'time'
+require "cgi"
+require "base64"
+require "rexml/document"
+require "openssl"
+require "digest/sha1"
+
+require 'rubygems'
+require 'right_http_connection'
+
+$:.unshift(File.dirname(__FILE__))
+require 'awsbase/benchmark_fix'
+#require 'awsbase/support'
+require 'awsbase/awsbase'
+require 'ec2/ec2'
+require 'ec2/mon_interface'
+require 's3/s3_interface'
+require 's3/s3'
+require 'sqs/sqs_interface'
+require 'sqs/sqs'
+require 'sdb/sdb_interface'
+require 'acf/acf_interface'
+require 'elb/elb_interface'
+
+
+# backwards compatible.
+# @deprecated
+module RightAws
+    include Aws
+    extend Aws
+end

data/lib/s3/bucket.rb

@@ -0,0 +1,278 @@
+module Aws
+
+
+  class S3::Bucket
+    attr_reader :s3, :name, :owner, :creation_date
+
+    # Create a Bucket instance.
+    # If the bucket does not exist and +create+ is set, a new bucket
+    # is created on S3. Launching this method with +create+=+true+ may
+    # affect on the bucket's ACL if the bucket already exists.
+    # Returns Bucket instance or +nil+ if the bucket does not exist
+    # and +create+ is not set.
+    #
+    #  s3 = Aws::S3.new(aws_access_key_id, aws_secret_access_key)
+    #   ...
+    #  bucket1 = Aws::S3::Bucket.create(s3, 'my_awesome_bucket_1')
+    #  bucket1.keys  #=> exception here if the bucket does not exists
+    #   ...
+    #  bucket2 = Aws::S3::Bucket.create(s3, 'my_awesome_bucket_2', true)
+    #  bucket2.keys  #=> list of keys
+    #  # create a bucket at the European location with public read access
+    #  bucket3 = Aws::S3::Bucket.create(s3,'my-awesome-bucket-3', true, 'public-read', :location => :eu)
+    #
+    #  see http://docs.amazonwebservices.com/AmazonS3/2006-03-01/RESTAccessPolicy.html
+    #  (section: Canned Access Policies)
+    #
+    def self.create(s3, name, create=false, perms=nil, headers={})
+      s3.bucket(name, create, perms, headers)
+    end
+
+
+    # Create a bucket instance. In normal use this method should
+    # not be called directly.
+    # Use Aws::S3::Bucket.create or Aws::S3.bucket instead.
+    def initialize(s3, name, creation_date=nil, owner=nil)
+      @s3 = s3
+      @name = name
+      @owner = owner
+      @creation_date = creation_date
+      if @creation_date && !@creation_date.is_a?(Time)
+        @creation_date = Time.parse(@creation_date)
+      end
+    end
+
+    # Return bucket name as a String.
+    #
+    #  bucket = Aws::S3.bucket('my_awesome_bucket')
+    #  puts bucket #=> 'my_awesome_bucket'
+    #
+    def to_s
+      @name.to_s
+    end
+
+    alias_method :full_name, :to_s
+
+    # Return a public link to bucket.
+    #
+    #  bucket.public_link #=> 'https://s3.amazonaws.com:443/my_awesome_bucket'
+    #
+    def public_link
+      params = @s3.interface.params
+      "#{params[:protocol]}://#{params[:server]}:#{params[:port]}/#{full_name}"
+    end
+
+    # Returns the bucket location
+    def location
+      @location ||= @s3.interface.bucket_location(@name)
+    end
+
+    # Retrieves the logging configuration for a bucket.
+    # Returns a hash of {:enabled, :targetbucket, :targetprefix}
+    #
+    #   bucket.logging_info()
+    #   => {:enabled=>true, :targetbucket=>"mylogbucket", :targetprefix=>"loggylogs/"}
+    def logging_info
+      @s3.interface.get_logging_parse(:bucket => @name)
+    end
+
+    # Enables S3 server access logging on a bucket.  The target bucket must have been properly configured to receive server
+    # access logs.
+    #  Params:
+    #   :targetbucket - either the target bucket object or the name of the target bucket
+    #   :targetprefix - the prefix under which all logs should be stored
+    #
+    #  bucket.enable_logging(:targetbucket=>"mylogbucket", :targetprefix=>"loggylogs/")
+    #    => true
+    def enable_logging(params)
+      Utils.mandatory_arguments([:targetbucket, :targetprefix], params)
+      Utils.allow_only([:targetbucket, :targetprefix], params)
+      xmldoc = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><BucketLoggingStatus xmlns=\"http://doc.s3.amazonaws.com/2006-03-01\"><LoggingEnabled><TargetBucket>#{params[:targetbucket]}</TargetBucket><TargetPrefix>#{params[:targetprefix]}</TargetPrefix></LoggingEnabled></BucketLoggingStatus>"
+      @s3.interface.put_logging(:bucket => @name, :xmldoc => xmldoc)
+    end
+
+    # Disables S3 server access logging on a bucket.  Takes no arguments.
+    def disable_logging
+      xmldoc = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><BucketLoggingStatus xmlns=\"http://doc.s3.amazonaws.com/2006-03-01\"></BucketLoggingStatus>"
+      @s3.interface.put_logging(:bucket => @name, :xmldoc => xmldoc)
+    end
+
+    # Retrieve a group of keys from Amazon.
+    # +options+ is a hash: { 'prefix'=>'', 'marker'=>'', 'max-keys'=>5, 'delimiter'=>'' }).
+    # Retrieves meta-headers information if +head+ it +true+.
+    # Returns an array of Key instances.
+    #
+    #  bucket.keys                     #=> # returns all keys from bucket
+    #  bucket.keys('prefix' => 'logs') #=> # returns all keys that starts with 'logs'
+    #
+    def keys(options={}, head=false)
+      keys_and_service(options, head)[0]
+    end
+
+    # Same as +keys+ method but return an array of [keys, service_data].
+    # where +service_data+ is a hash with additional output information.
+    #
+    #  keys, service = bucket.keys_and_service({'max-keys'=> 2, 'prefix' => 'logs'})
+    #  p keys    #=> # 2 keys array
+    #  p service #=> {"max-keys"=>"2", "prefix"=>"logs", "name"=>"my_awesome_bucket", "marker"=>"", "is_truncated"=>true}
+    #
+    def keys_and_service(options={}, head=false)
+      opt = {}; options.each { |key, value| opt[key.to_s] = value }
+      service_data = {}
+      service_list = {}
+      list = []
+      @s3.interface.incrementally_list_bucket(@name, opt) do |thislist|
+        service_list = thislist
+        thislist[:contents].each do |entry|
+          owner = S3::Owner.new(entry[:owner_id], entry[:owner_display_name])
+          key = S3::Key.new(self, entry[:key], nil, {}, {}, entry[:last_modified], entry[:e_tag], entry[:size], entry[:storage_class], owner)
+          key.head if head
+          list << key
+        end
+      end
+      service_list.each_key do |key|
+        service_data[key] = service_list[key] unless (key == :contents || key == :common_prefixes)
+      end
+      [list, service_data]
+    end
+
+    # Retrieve key information from Amazon.
+    # The +key_name+ is a +String+ or Key instance.
+    # Retrieves meta-header information if +head+ is +true+.
+    # Returns new Key instance.
+    #
+    #  key = bucket.key('logs/today/1.log', true) #=> #<Aws::S3::Key:0xb7b1e240 ... >
+    #   # is the same as:
+    #  key = Aws::S3::Key.create(bucket, 'logs/today/1.log')
+    #  key.head
+    #
+    def key(key_name, head=false)
+      raise 'Key name can not be empty.' if Aws::Utils.blank?(key_name)
+      key_instance = nil
+      # if this key exists - find it ....
+      keys({'prefix'=>key_name}, head).each do |key|
+        if key.name == key_name.to_s
+          key_instance = key
+          break
+        end
+      end
+      # .... else this key is unknown
+      unless key_instance
+        key_instance = S3::Key.create(self, key_name.to_s)
+      end
+      key_instance
+    end
+
+    # Store object data.
+    # The +key+ is a +String+ or Key instance.
+    # Returns +true+.
+    #
+    #  bucket.put('logs/today/1.log', 'Olala!') #=> true
+    #
+    def put(key, data=nil, meta_headers={}, perms=nil, headers={})
+      key = S3::Key.create(self, key.to_s, data, meta_headers) unless key.is_a?(S3::Key)
+      key.put(data, perms, headers)
+    end
+
+    # Retrieve object data from Amazon.
+    # The +key+ is a +String+ or Key.
+    # Returns data.
+    #
+    #  data = bucket.get('logs/today/1.log') #=>
+    #  puts data #=> 'sasfasfasdf'
+    #
+    def get(key, headers={})
+      key = S3::Key.create(self, key.to_s) unless key.is_a?(S3::Key)
+      key.get(headers)
+    end
+
+     # Retrieve object data from Amazon.
+    # The +key+ is a +String+ or Key.
+    # Returns Key instance.
+    #
+    #  key = bucket.get('logs/today/1.log') #=>
+    #  puts key.data #=> 'sasfasfasdf'
+    #
+    def get_key(key, headers={})
+      key = S3::Key.create(self, key.to_s, headers) unless key.is_a?(S3::Key)
+      return key
+    end
+
+    # Rename object. Returns Aws::S3::Key instance.
+    #
+    #  new_key = bucket.rename_key('logs/today/1.log','logs/today/2.log')   #=> #<Aws::S3::Key:0xb7b1e240 ... >
+    #  puts key.name   #=> 'logs/today/2.log'
+    #  key.exists?     #=> true
+    #
+    def rename_key(old_key_or_name, new_name)
+      old_key_or_name = S3::Key.create(self, old_key_or_name.to_s) unless old_key_or_name.is_a?(S3::Key)
+      old_key_or_name.rename(new_name)
+      old_key_or_name
+    end
+
+    # Create an object copy. Returns a destination Aws::S3::Key instance.
+    #
+    #  new_key = bucket.copy_key('logs/today/1.log','logs/today/2.log')   #=> #<Aws::S3::Key:0xb7b1e240 ... >
+    #  puts key.name   #=> 'logs/today/2.log'
+    #  key.exists?     #=> true
+    #
+    def copy_key(old_key_or_name, new_key_or_name)
+      old_key_or_name = S3::Key.create(self, old_key_or_name.to_s) unless old_key_or_name.is_a?(S3::Key)
+      old_key_or_name.copy(new_key_or_name)
+    end
+
+    # Move an object to other location. Returns a destination Aws::S3::Key instance.
+    #
+    #  new_key = bucket.copy_key('logs/today/1.log','logs/today/2.log')   #=> #<Aws::S3::Key:0xb7b1e240 ... >
+    #  puts key.name   #=> 'logs/today/2.log'
+    #  key.exists?     #=> true
+    #
+    def move_key(old_key_or_name, new_key_or_name)
+      old_key_or_name = S3::Key.create(self, old_key_or_name.to_s) unless old_key_or_name.is_a?(S3::Key)
+      old_key_or_name.move(new_key_or_name)
+    end
+
+    # Remove all keys from a bucket.
+    # Returns +true+.
+    #
+    #  bucket.clear #=> true
+    #
+    def clear
+      @s3.interface.clear_bucket(@name)
+    end
+
+    # Delete all keys where the 'folder_key' can be interpreted
+    # as a 'folder' name.
+    # Returns an array of string keys that have been deleted.
+    #
+    #  bucket.keys.map{|key| key.name}.join(', ') #=> 'test, test/2/34, test/3, test1, test1/logs'
+    #  bucket.delete_folder('test')               #=> ['test','test/2/34','test/3']
+    #
+    def delete_folder(folder, separator='/')
+      @s3.interface.delete_folder(@name, folder, separator)
+    end
+
+    # Delete a bucket. Bucket must be empty.
+    # If +force+ is set, clears and deletes the bucket.
+    # Returns +true+.
+    #
+    #  bucket.delete(true) #=> true
+    #
+    def delete(force=false)
+      force ? @s3.interface.force_delete_bucket(@name) : @s3.interface.delete_bucket(@name)
+    end
+
+    # Deletes an object from s3 in this bucket.
+    def delete_key(key)
+      @s3.interface.delete(name, key)
+    end
+
+    # Return a list of grantees.
+    #
+    def grantees
+      S3::Grantee::grantees(self)
+    end
+
+  end
+
+end