nirvdrum-amazon-ec2 0.7.9

data/lib/AWS/EC2/instances.rb

@@ -0,0 +1,234 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # Launches a specified number of instances of an AMI for which you have permissions.
+      #
+      # Amazon API Docs : HTML[http://docs.amazonwebservices.com/AWSEC2/2009-10-31/APIReference/index.html?ApiReference-query-RunInstances.html]
+      #
+      # @option options [String] :image_id ("") Unique ID of a machine image.
+      # @option options [Integer] :min_count (1) Minimum number of instances to launch. If the value is more than Amazon EC2 can launch, no instances are launched at all.
+      # @option options [Integer] :max_count (1) Maximum number of instances to launch. If the value is more than Amazon EC2 can launch, the largest possible number above minCount will be launched instead.
+      # @option options [optional, String] :key_name (nil) The name of the key pair.
+      # @option options [optional, Array of Strings or String] :security_group (nil) Name of the security group(s).
+      # @option options [optional, String] :additional_info (nil) Specifies additional information to make available to the instance(s).
+      # @option options [optional, String] :user_data (nil) MIME, Base64-encoded user data.
+      # @option options [optional, String] :instance_type (nil) Specifies the instance type.
+      # @option options [optional, String] :availability_zone (nil) Specifies the placement constraints (Availability Zones) for launching the instances.
+      # @option options [optional, String] :kernel_id (nil) The ID of the kernel with which to launch the instance.
+      # @option options [optional, String] :ramdisk_id (nil) The ID of the RAM disk with which to launch the instance. Some kernels require additional drivers at launch. Check the kernel requirements for information on whether you need to specify a RAM disk. To find kernel requirements, go to the Resource Center and search for the kernel ID.
+      # @option options [optional, Array] :block_device_mapping ([]) An array of Hashes representing the elements of the block device mapping.  e.g. [{:device_name => '/dev/sdh', :virtual_name => '', :ebs_snapshot_id => '', :ebs_volume_size => '', :ebs_delete_on_termination => ''},{},...]
+      # @option options [optional, Boolean] :monitoring_enabled (false) Enables monitoring for the instance.
+      # @option options [optional, String] :subnet_id (nil) Specifies the Amazon VPC subnet ID within which to launch the instance(s) for Amazon Virtual Private Cloud.
+      # @option options [optional, Boolean] :disable_api_termination (true) Specifies whether the instance can be terminated using the APIs. You must modify this attribute before you can terminate any "locked" instances from the APIs.
+      # @option options [optional, String] :instance_initiated_shutdown_behavior ('stop') Specifies whether the instance's Amazon EBS volumes are stopped or terminated when the instance is shut down. Valid values : 'stop', 'terminate'
+      # @option options [optional, Boolean] :base64_encoded (false)
+      #
+      def run_instances( options = {} )
+        options = { :image_id => "",
+                    :min_count => 1,
+                    :max_count => 1,
+                    :base64_encoded => false }.merge(options)
+
+        raise ArgumentError, ":addressing_type has been deprecated." if options[:addressing_type]
+        raise ArgumentError, ":group_id has been deprecated." if options[:group_id]
+
+        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 or must be >= :min_count" unless options[:max_count].to_i > 0 && options[:max_count].to_i >= options[:min_count].to_i
+        raise ArgumentError, ":instance_type must specify a valid instance size" unless options[:instance_type].nil? || ["m1.small", "m1.large", "m1.xlarge", "c1.medium", "c1.xlarge", "m2.2xlarge", "m2.4xlarge"].include?(options[:instance_type])
+        raise ArgumentError, ":monitoring_enabled must be 'true' or 'false'" unless options[:monitoring_enabled].nil? || [true, false].include?(options[:monitoring_enabled])
+        raise ArgumentError, ":disable_api_termination must be 'true' or 'false'" unless options[:disable_api_termination].nil? || [true, false].include?(options[:disable_api_termination])
+        raise ArgumentError, ":instance_initiated_shutdown_behavior must be 'stop' or 'terminate'" unless options[:instance_initiated_shutdown_behavior].nil? || ["stop", "terminate"].include?(options[:instance_initiated_shutdown_behavior])
+        raise ArgumentError, ":base64_encoded must be 'true' or 'false'" unless [true, false].include?(options[:base64_encoded])
+
+        user_data = extract_user_data(options)
+
+        params = {}
+
+        if options[:security_group]
+          params.merge!(pathlist("SecurityGroup", options[:security_group]))
+        end
+
+        if options[:block_device_mapping]
+          params.merge!(pathhashlist('BlockDeviceMapping', options[:block_device_mapping].flatten, {:device_name => 'DeviceName', :virtual_name => 'VirtualName', :ebs_snapshot_id => 'Ebs.SnapshotId', :ebs_volume_size => 'Ebs.VolumeSize', :ebs_delete_on_termination => 'Ebs.DeleteOnTermination' }))
+        end
+
+        params["ImageId"]                           = options[:image_id]
+        params["MinCount"]                          = options[:min_count].to_s
+        params["MaxCount"]                          = options[:max_count].to_s
+        params["KeyName"]                           = options[:key_name] unless options[:key_name].nil?
+        params["AdditionalInfo"]                    = options[:additional_info] unless options[:additional_info].nil?
+        params["UserData"]                          = user_data unless user_data.nil?
+        params["InstanceType"]                      = options[:instance_type] unless options[:instance_type].nil?
+        params["Placement.AvailabilityZone"]        = options[:availability_zone] unless options[:availability_zone].nil?
+        params["KernelId"]                          = options[:kernel_id] unless options[:kernel_id].nil?
+        params["RamdiskId"]                         = options[:ramdisk_id] unless options[:ramdisk_id].nil?
+        params["Monitoring.Enabled"]                = options[:monitoring_enabled].to_s unless options[:monitoring_enabled].nil?
+        params["SubnetId"]                          = options[:subnet_id] unless options[:subnet_id].nil?
+        params["DisableApiTermination"]             = options[:disable_api_termination].to_s unless options[:disable_api_termination].nil?
+        params["InstanceInitiatedShutdownBehavior"] = options[:instance_initiated_shutdown_behavior] unless options[:instance_initiated_shutdown_behavior].nil?
+
+        return response_generator(:action => "RunInstances", :params => params)
+      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
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def describe_instance_attribute( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def modify_instance_attribute( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def reset_instance_attribute( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+      # Starts an instance that uses an Amazon EBS volume as its root device.
+      #
+      # @option options [Array] :instance_id ([]) Array of unique instance ID's of stopped instances.
+      #
+      def start_instances( options = {} )
+        options = { :instance_id => [] }.merge(options)
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        params = {}
+        params.merge!(pathlist("InstanceId", options[:instance_id]))
+        return response_generator(:action => "StartInstances", :params => params)
+      end
+
+
+      # Stops an instance that uses an Amazon EBS volume as its root device.
+      #
+      # @option options [Array] :instance_id ([]) Unique instance ID of a running instance.
+      # @option options [optional, Boolean] :force (false) Forces the instance to stop. The instance will not have an opportunity to flush file system caches nor file system meta data. If you use this option, you must perform file system check and repair procedures. This option is not recommended for Windows instances.
+      #
+      def stop_instances( options = {} )
+        options = { :instance_id => [] }.merge(options)
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        raise ArgumentError, ":force must be 'true' or 'false'" unless options[:force].nil? || [true, false].include?(options[:force])
+        params = {}
+        params.merge!(pathlist("InstanceId", options[:instance_id]))
+        params["Force"] = options[:force].to_s unless options[:force].nil?
+        return response_generator(:action => "StopInstances", :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 = {} )
+        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
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def describe_reserved_instances( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def describe_reserved_instances_offerings( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def purchase_reserved_instances_offering( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+    end
+  end
+end
+

data/lib/AWS/EC2/keypairs.rb

@@ -0,0 +1,47 @@
+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/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/lib/AWS/EC2/security_groups.rb

@@ -0,0 +1,164 @@
+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 = {} )
+        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 = {} )
+        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
+