poolparty 1.3.15 → 1.4.0

data/vendor/gems/amazon-ec2/lib/AWS/EC2/instances.rb

@@ -0,0 +1,212 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+      # The RunInstances operation launches a specified number of instances.
+      #
+      # Note : The Query version of RunInstances only allows instances of a single AMI to be launched in
+      # one call. This is different from the SOAP API call of the same name but similar to the
+      # ec2-run-instances command line tool.
+      #
+      # If Amazon EC2 cannot launch the minimum number AMIs you request, no instances launch. If there
+      # is insufficient capacity to launch the maximum number of AMIs you request, Amazon EC2 launches
+      # as many as possible to satisfy the requested maximum values.
+      #
+      # Every instance is launched in a security group. If you do not specify a security group at
+      # launch, the instances start in the default security group.
+      #
+      # An optional instance type can be specified.  Currently supported types are 'm1.small', 'm1.large',
+      # 'm1.xlarge' and the high CPU types 'c1.medium' and 'c1.xlarge'.  'm1.small' is the default
+      # if no instance_type is specified.
+      #
+      # You can provide an optional key pair ID for each image in the launch request. All instances
+      # that are created from images that use this key pair will have access to the associated public
+      # key at boot. You can use this key to provide secure access to an instance of an image on a
+      # per-instance basis. Amazon EC2  public images use this feature to provide secure access
+      # without passwords.
+      #
+      # Important!  Launching public images without a key pair ID will leave them inaccessible.
+      #
+      # The public key material is made available to the instance at boot time by placing it in a file named
+      # openssh_id.pub on a logical device that is exposed to the instance as /dev/sda2 (the ephemeral
+      # store). The format of this file is suitable for use as an entry within ~/.ssh/authorized_keys (the
+      # OpenSSH format). This can be done at boot time (as part of rclocal, for example) allowing for secure
+      # password-less access.
+      #
+      # Optional user data can be provided in the launch request. All instances comprising the launch
+      # request have access to this data (see Instance Metadata for details).
+      #
+      # If any of the AMIs have product codes attached for which the user has not subscribed,
+      # the RunInstances call will fail.
+      #
+      # @option options [String] :image_id ("")
+      # @option options [Integer] :min_count (1)
+      # @option options [Integer] :max_count (1)
+      # @option options [optional, String] :key_name (nil)
+      # @option options [optional, Array] :group_id ([])
+      # @option options [optional, String] :user_data (nil)
+      # @option options [optional, String] :addressing_type ("public")
+      # @option options [optional, String] :instance_type ("m1.small")
+      # @option options [optional, String] :kernel_id (nil)
+      # @option options [optional, String] :availability_zone (nil)
+      # @option options [optional, Boolean] :base64_encoded (false)
+      #
+      def run_instances( options = {} )
+
+        options = { :image_id => "",
+                    :min_count => 1,
+                    :max_count => 1,
+                    :key_name => nil,
+                    :group_id => [],
+                    :user_data => nil,
+                    :addressing_type => "public",
+                    :instance_type => "m1.small",
+                    :kernel_id => nil,
+                    :availability_zone => nil,
+                    :base64_encoded => false }.merge(options)
+
+        # Do some validation on the arguments provided
+        raise ArgumentError, ":image_id must be provided" if options[:image_id].nil? || options[:image_id].empty?
+        raise ArgumentError, ":min_count is not valid" unless options[:min_count].to_i > 0
+        raise ArgumentError, ":max_count is not valid" unless options[:max_count].to_i > 0
+        raise ArgumentError, ":addressing_type must be 'direct' or 'public'" unless options[:addressing_type] == "public" || options[:addressing_type] == "direct"
+        raise ArgumentError, ":instance_type must be 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', or 'c1.xlarge'" unless options[:instance_type] == "m1.small" || options[:instance_type] == "m1.large" || options[:instance_type] == "m1.xlarge" || options[:instance_type] == "c1.medium" || options[:instance_type] == "c1.xlarge"
+        raise ArgumentError, ":base64_encoded must be 'true' or 'false'" unless options[:base64_encoded] == true || options[:base64_encoded] == false
+
+        user_data = extract_user_data(options)
+
+        params = {
+          "ImageId"  => options[:image_id],
+          "MinCount" => options[:min_count].to_s,
+          "MaxCount" => options[:max_count].to_s,
+        }.merge(pathlist("SecurityGroup", options[:group_id]))
+
+        params["KeyName"] = options[:key_name] unless options[:key_name].nil?
+        params["UserData"] = user_data unless user_data.nil?
+        params["AddressingType"] = options[:addressing_type]
+        params["InstanceType"] = options[:instance_type]
+        params["KernelId"] = options[:kernel_id] unless options[:kernel_id].nil?
+        params["Placement.AvailabilityZone"] = options[:availability_zone] unless options[:availability_zone].nil?
+
+        return response_generator(:action => "RunInstances", :params => params)
+
+      end
+
+      # If :user_data is passed in then URL escape and Base64 encode it
+      # as needed.  Need for URL Escape + Base64 encoding is determined
+      # by :base64_encoded param.
+      def extract_user_data( options = {} )
+        return unless options[:user_data]
+        if options[:user_data]
+          if options[:base64_encoded]
+            Base64.encode64(options[:user_data]).gsub(/\n/,"").strip()
+          else
+            options[:user_data]
+          end
+        end
+      end
+
+
+      # The DescribeInstances operation returns information about instances owned by the user
+      # making the request.
+      #
+      # An optional list of instance IDs may be provided to request information for those instances only. If no
+      # instance IDs are provided, information of all relevant instances information will be returned. If an
+      # instance is specified that does not exist a fault is returned. If an instance is specified that exists but is not
+      # owned by the user making the request, then that instance will not be included in the returned results.
+      #
+      # Recently terminated instances will be included in the returned results for a small interval subsequent to
+      # their termination. This interval is typically of the order of one hour
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def describe_instances( options = {} )
+
+        options = { :instance_id => [] }.merge(options)
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "DescribeInstances", :params => params)
+
+      end
+
+
+      # The RebootInstances operation requests a reboot of one or more instances. This operation is
+      # asynchronous; it only queues a request to reboot the specified instance(s). The operation will succeed
+      # provided the instances are valid and belong to the user. Terminated instances will be ignored.
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def reboot_instances( options = {} )
+
+        # defaults
+        options = { :instance_id => [] }.merge(options)
+
+        raise ArgumentError, "No instance IDs provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "RebootInstances", :params => params)
+
+      end
+
+
+      # The TerminateInstances operation shuts down one or more instances. This operation is idempotent
+      # and terminating an instance that is in the process of shutting down (or already terminated) will succeed.
+      # Terminated instances remain visible for a short period of time (approximately one hour) after
+      # termination, after which their instance ID is invalidated.
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def terminate_instances( options = {} )
+
+        options = { :instance_id => [] }.merge(options)
+
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "TerminateInstances", :params => params)
+
+      end
+
+
+      # The MonitorInstances operation tells Cloudwatch to begin logging metrics from one or more EC2 instances
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def monitor_instances( options = {} )
+
+        options = { :instance_id => [] }.merge(options)
+
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "MonitorInstances", :params => params)
+
+      end
+
+
+
+      # The UnmonitorInstances operation tells Cloudwatch to stop logging metrics from one or more EC2 instances
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def unmonitor_instances( options = {} )
+
+        options = { :instance_id => [] }.merge(options)
+
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "UnmonitorInstances", :params => params)
+
+      end
+
+    end
+
+  end
+end

data/vendor/gems/amazon-ec2/lib/AWS/EC2/keypairs.rb

@@ -0,0 +1,61 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+
+      # The CreateKeyPair operation creates a new 2048 bit RSA keypair and returns a unique ID that can be
+      # used to reference this keypair when launching new instances.
+      #
+      # @option options [String] :key_name ("")
+      #
+      def create_keypair( options = {} )
+
+        options = { :key_name => "" }.merge(options)
+
+        raise ArgumentError, "No :key_name provided" if options[:key_name].nil? || options[:key_name].empty?
+
+        params = { "KeyName" => options[:key_name] }
+
+        return response_generator(:action => "CreateKeyPair", :params => params)
+
+      end
+
+
+      # The DescribeKeyPairs operation returns information about keypairs available for use by the user
+      # making the request. Selected keypairs may be specified or the list may be left empty if information for
+      # all registered keypairs is required.
+      #
+      # @option options [Array] :key_name ([])
+      #
+      def describe_keypairs( options = {} )
+
+        options = { :key_name => [] }.merge(options)
+
+        params = pathlist("KeyName", options[:key_name] )
+
+        return response_generator(:action => "DescribeKeyPairs", :params => params)
+
+      end
+
+
+      # The DeleteKeyPair operation deletes a keypair.
+      #
+      # @option options [String] :key_name ("")
+      #
+      def delete_keypair( options = {} )
+
+        options = { :key_name => "" }.merge(options)
+
+        raise ArgumentError, "No :key_name provided" if options[:key_name].nil? || options[:key_name].empty?
+
+        params = { "KeyName" => options[:key_name] }
+
+        return response_generator(:action => "DeleteKeyPair", :params => params)
+
+      end
+
+    end
+
+  end
+end

data/vendor/gems/amazon-ec2/lib/AWS/EC2/products.rb

@@ -0,0 +1,21 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The ConfirmProductInstance operation returns true if the given product code is attached to the instance
+      # with the given instance id. False is returned if the product code is not attached to the instance.
+      #
+      # @option options [String] :product_code ("")
+      # @option options [String] :instance_id ("")
+      #
+      def confirm_product_instance( options ={} )
+        options = {:product_code => "", :instance_id => ""}.merge(options)
+        raise ArgumentError, "No product code provided" if options[:product_code].nil? || options[:product_code].empty?
+        raise ArgumentError, "No instance ID provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        params = { "ProductCode" => options[:product_code], "InstanceId" => options[:instance_id] }
+        return response_generator(:action => "ConfirmProductInstance", :params => params)
+      end
+
+    end
+  end
+end

data/vendor/gems/amazon-ec2/lib/AWS/EC2/security_groups.rb

@@ -0,0 +1,183 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The CreateSecurityGroup operation creates a new security group. Every instance is launched
+      # in a security group. If none is specified as part of the launch request then instances
+      # are launched in the default security group. Instances within the same security group have
+      # unrestricted network access to one another. Instances will reject network access attempts from other
+      # instances in a different security group. As the owner of instances you may grant or revoke specific
+      # permissions using the AuthorizeSecurityGroupIngress and RevokeSecurityGroupIngress operations.
+      #
+      # @option options [String] :group_name ("")
+      # @option options [String] :group_description ("")
+      #
+      def create_security_group( options = {} )
+
+        options = {:group_name => "",
+                   :group_description => ""
+                   }.merge(options)
+
+        raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+        raise ArgumentError, "No :group_description provided" if options[:group_description].nil? || options[:group_description].empty?
+
+        params = {
+          "GroupName" => options[:group_name],
+          "GroupDescription" => options[:group_description]
+        }
+
+        return response_generator(:action => "CreateSecurityGroup", :params => params)
+
+      end
+
+
+      # The DescribeSecurityGroups operation returns information about security groups owned by the
+      # user making the request.
+      #
+      # An optional list of security group names may be provided to request information for those security
+      # groups only. If no security group names are provided, information of all security groups will be
+      # returned. If a group is specified that does not exist an exception is returned.
+      #
+      # @option options [optional, Array] :group_name ([])
+      #
+      def describe_security_groups( options = {} )
+
+        options = { :group_name => [] }.merge(options)
+
+        params = pathlist("GroupName", options[:group_name] )
+
+        return response_generator(:action => "DescribeSecurityGroups", :params => params)
+
+      end
+
+
+      # The DeleteSecurityGroup operation deletes a security group.
+      #
+      # If an attempt is made to delete a security group and any instances exist that are members of that group a
+      # fault is returned.
+      #
+      # @option options [String] :group_name ("")
+      #
+      def delete_security_group( options = {} )
+
+        options = { :group_name => "" }.merge(options)
+
+        raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+
+        params = { "GroupName" => options[:group_name] }
+
+        return response_generator(:action => "DeleteSecurityGroup", :params => params)
+
+      end
+
+
+      # The AuthorizeSecurityGroupIngress operation adds permissions to a security group.
+      #
+      # Permissions are specified in terms of the IP protocol (TCP, UDP or ICMP), the source of the request (by
+      # IP range or an Amazon EC2 user-group pair), source and destination port ranges (for TCP and UDP),
+      # and ICMP codes and types (for ICMP). When authorizing ICMP, -1 may be used as a wildcard in the
+      # type and code fields.
+      #
+      # Permission changes are propagated to instances within the security group being modified as quickly as
+      # possible. However, a small delay is likely, depending on the number of instances that are members of
+      # the indicated group.
+      #
+      # When authorizing a user/group pair permission, GroupName, SourceSecurityGroupName and
+      # SourceSecurityGroupOwnerId must be specified. When authorizing a CIDR IP permission,
+      # GroupName, IpProtocol, FromPort, ToPort and CidrIp must be specified. Mixing these two types
+      # of parameters is not allowed.
+      #
+      # @option options [String] :group_name ("")
+      # @option options [optional, String] :ip_protocol (nil) Required when authorizing CIDR IP permission
+      # @option options [optional, Integer] :from_port (nil) Required when authorizing CIDR IP permission
+      # @option options [optional, Integer] :to_port (nil) Required when authorizing CIDR IP permission
+      # @option options [optional, String] :cidr_ip (nil) Required when authorizing CIDR IP permission
+      # @option options [optional, String] :source_security_group_name (nil) Required when authorizing user group pair permissions
+      # @option options [optional, String] :source_security_group_owner_id (nil) Required when authorizing user group pair permissions
+      #
+      def authorize_security_group_ingress( options = {} )
+
+        # defaults
+        options = { :group_name => nil,
+                    :ip_protocol => nil,
+                    :from_port => nil,
+                    :to_port => nil,
+                    :cidr_ip => nil,
+                    :source_security_group_name => nil,
+                    :source_security_group_owner_id => nil }.merge(options)
+
+        # lets not validate the rest of the possible permutations of required params and instead let
+        # EC2 sort it out on the server side.  We'll only require :group_name as that is always needed.
+        raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+
+        params = { "GroupName" => options[:group_name],
+                   "IpProtocol" => options[:ip_protocol],
+                   "FromPort" => options[:from_port].to_s,
+                   "ToPort" => options[:to_port].to_s,
+                   "CidrIp" => options[:cidr_ip],
+                   "SourceSecurityGroupName" => options[:source_security_group_name],
+                   "SourceSecurityGroupOwnerId" => options[:source_security_group_owner_id]
+                   }
+
+        return response_generator(:action => "AuthorizeSecurityGroupIngress", :params => params)
+
+      end
+
+
+      # The RevokeSecurityGroupIngress operation revokes existing permissions that were previously
+      # granted to a security group. The permissions to revoke must be specified using the same values
+      # originally used to grant the permission.
+      #
+      # Permissions are specified in terms of the IP protocol (TCP, UDP or ICMP), the source of the request (by
+      # IP range or an Amazon EC2 user-group pair), source and destination port ranges (for TCP and UDP),
+      # and ICMP codes and types (for ICMP). When authorizing ICMP, -1 may be used as a wildcard in the
+      # type and code fields.
+      #
+      # Permission changes are propagated to instances within the security group being modified as quickly as
+      # possible. However, a small delay is likely, depending on the number of instances that are members of
+      # the indicated group.
+      #
+      # When revoking a user/group pair permission, GroupName, SourceSecurityGroupName and
+      # SourceSecurityGroupOwnerId must be specified. When authorizing a CIDR IP permission,
+      # GroupName, IpProtocol, FromPort, ToPort and CidrIp must be specified. Mixing these two types
+      # of parameters is not allowed.
+      #
+      # @option options [String] :group_name ("")
+      # @option options [optional, String] :ip_protocol (nil) Required when revoking CIDR IP permission
+      # @option options [optional, Integer] :from_port (nil) Required when revoking CIDR IP permission
+      # @option options [optional, Integer] :to_port (nil) Required when revoking CIDR IP permission
+      # @option options [optional, String] :cidr_ip (nil) Required when revoking CIDR IP permission
+      # @option options [optional, String] :source_security_group_name (nil) Required when revoking user group pair permissions
+      # @option options [optional, String] :source_security_group_owner_id (nil) Required when revoking user group pair permissions
+      #
+      def revoke_security_group_ingress( options = {} )
+
+        # defaults
+        options = { :group_name => nil,
+                    :ip_protocol => nil,
+                    :from_port => nil,
+                    :to_port => nil,
+                    :cidr_ip => nil,
+                    :source_security_group_name => nil,
+                    :source_security_group_owner_id => nil }.merge(options)
+
+        # lets not validate the rest of the possible permutations of required params and instead let
+        # EC2 sort it out on the server side.  We'll only require :group_name as that is always needed.
+        raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+
+        params = { "GroupName" => options[:group_name],
+                   "IpProtocol" => options[:ip_protocol],
+                   "FromPort" => options[:from_port].to_s,
+                   "ToPort" => options[:to_port].to_s,
+                   "CidrIp" => options[:cidr_ip],
+                   "SourceSecurityGroupName" => options[:source_security_group_name],
+                   "SourceSecurityGroupOwnerId" => options[:source_security_group_owner_id]
+                   }
+
+        return response_generator(:action => "RevokeSecurityGroupIngress", :params => params)
+
+      end
+
+    end
+  end
+end

data/vendor/gems/amazon-ec2/lib/AWS/EC2/snapshots.rb

@@ -0,0 +1,59 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+      # The DescribeSnapshots operation describes the status of Amazon EBS snapshots.
+      #
+      # @option options [Array] :snapshot_id ([])
+      #
+      def describe_snapshots( options = {} )
+
+        options = { :snapshot_id => [] }.merge(options)
+
+        params = pathlist("SnapshotId", options[:snapshot_id] )
+
+        return response_generator(:action => "DescribeSnapshots", :params => params)
+
+      end
+
+      # The CreateSnapshot operation creates a snapshot of an Amazon EBS volume and stores it in Amazon S3. You can use snapshots for backups, to launch instances from identical snapshots, and to save data before shutting down an instance.
+      #
+      # @option options [String] :volume_id ('')
+      #
+      def create_snapshot( options = {} )
+
+        options = { :volume_id => '' }.merge(options)
+
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+
+        params = {
+          "VolumeId" => options[:volume_id]
+        }
+
+        return response_generator(:action => "CreateSnapshot", :params => params)
+
+      end
+
+
+      # The DeleteSnapshot operation deletes a snapshot of an Amazon EBS  volume that is stored in Amazon S3.
+      #
+      # @option options [String] :snapshot_id ('')
+      #
+      def delete_snapshot( options = {} )
+
+        options = { :snapshot_id => '' }.merge(options)
+
+        raise ArgumentError, "No :snapshot_id provided" if options[:snapshot_id].nil? || options[:snapshot_id].empty?
+
+        params = {
+          "SnapshotId" => options[:snapshot_id]
+        }
+
+        return response_generator(:action => "DeleteSnapshot", :params => params)
+
+      end
+
+    end
+  end
+end

data/vendor/gems/amazon-ec2/lib/AWS/EC2/volumes.rb

@@ -0,0 +1,115 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The DescribeVolumes operation lists one or more Amazon EBS volumes that you own, If you do not specify any volumes, Amazon EBS returns all volumes that you own.
+      #
+      # @option options [optional, String] :volume_id ([])
+      #
+      def describe_volumes( options = {} )
+        options = { :volume_id => [] }.merge(options)
+        params = pathlist("VolumeId", options[:volume_id] )
+        return response_generator(:action => "DescribeVolumes", :params => params)
+      end
+
+      # The CreateVolume operation creates a new Amazon EBS volume that you can mount from any Amazon EC2 instance.
+      #
+      # @option options [String] :availability_zone ('')
+      # @option options [optional, String] :size ('')
+      # @option options [optional, String] :snapshot_id ('')
+      #
+      def create_volume( options = {} )
+
+        # defaults
+        options = { :availability_zone => '' }.merge(options)
+
+        raise ArgumentError, "No :availability_zone provided" if options[:availability_zone].nil? || options[:availability_zone].empty?
+
+        options = { :size => '' }.merge(options)
+        options = { :snapshot_id => '' }.merge(options)
+
+        params = {
+          "AvailabilityZone" => options[:availability_zone],
+          "Size" => options[:size],
+          "SnapshotId" => options[:snapshot_id]
+        }
+
+        return response_generator(:action => "CreateVolume", :params => params)
+
+      end
+
+      # The DeleteVolume operation deletes an Amazon EBS volume.
+      #
+      # @option options [String] :volume_id ('')
+      #
+      def delete_volume( options = {} )
+
+        options = { :volume_id => '' }.merge(options)
+
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+
+        params = {
+          "VolumeId" => options[:volume_id]
+        }
+
+        return response_generator(:action => "DeleteVolume", :params => params)
+
+      end
+
+      # The AttachVolume operation attaches an Amazon EBS volume to an instance.
+      #
+      # @option options [String] :volume_id ('')
+      # @option options [String] :instance_id ('')
+      # @option options [String] :device ('')
+      #
+      def attach_volume( options = {} )
+
+        options = { :volume_id => '' }.merge(options)
+        options = { :instance_id => '' }.merge(options)
+        options = { :device => '' }.merge(options)
+
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        raise ArgumentError, "No :device provided" if options[:device].nil? || options[:device].empty?
+
+        params = {
+          "VolumeId" => options[:volume_id],
+          "InstanceId" => options[:instance_id],
+          "Device" => options[:device]
+        }
+
+        return response_generator(:action => "AttachVolume", :params => params)
+
+      end
+
+      # The DetachVolume operation detaches an Amazon EBS volume from an instance.
+      #
+      # @option options [String] :volume_id ('')
+      # @option options [optional, String] :instance_id ('')
+      # @option options [optional, String] :device ('')
+      # @option options [optional, Boolean] :force ('')
+      #
+      def detach_volume( options = {} )
+
+        options = { :volume_id => '' }.merge(options)
+
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+
+        options = { :instance_id => '' }.merge(options)
+        options = { :device => '' }.merge(options)
+        options = { :force => '' }.merge(options)
+
+        params = {
+          "VolumeId" => options[:volume_id],
+          "InstanceId" => options[:instance_id],
+          "Device" => options[:device],
+          "Force" => options[:force]
+        }
+
+        return response_generator(:action => "DetachVolume", :params => params)
+      end
+
+    end
+  end
+end
+