fog-aws 0.0.5

data/lib/fog/aws/models/compute/security_group.rb

@@ -0,0 +1,322 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class AWS
+      class SecurityGroup < Fog::Model
+        identity  :name,            :aliases => 'groupName'
+        attribute :description,     :aliases => 'groupDescription'
+        attribute :group_id,        :aliases => 'groupId'
+        attribute :ip_permissions,  :aliases => 'ipPermissions'
+        attribute :ip_permissions_egress,  :aliases => 'ipPermissionsEgress'
+        attribute :owner_id,        :aliases => 'ownerId'
+        attribute :vpc_id,          :aliases => 'vpcId'
+        attribute :tags,            :aliases => 'tagSet'
+
+        # Authorize access by another security group
+        #
+        #  >> g = AWS.security_groups.all(:description => "something").first
+        #  >> g.authorize_group_and_owner("some_group_name", "1234567890")
+        #
+        # == Parameters:
+        # group::
+        #   The name of the security group you're granting access to.
+        #
+        # owner::
+        #   The owner id for security group you're granting access to.
+        #
+        # == Returns:
+        #
+        # An excon response object representing the result
+        #
+        #  <Excon::Response:0x101fc2ae0
+        #    @status=200,
+        #    @body={"requestId"=>"some-id-string",
+        #           "return"=>true},
+        #    headers{"Transfer-Encoding"=>"chunked",
+        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
+        #            "Content-Type"=>"text/xml;charset=UTF-8",
+        #            "Server"=>"AmazonEC2"}
+        #
+
+        def authorize_group_and_owner(group, owner = nil)
+          Fog::Logger.deprecation("authorize_group_and_owner is deprecated, use authorize_port_range with :group option instead")
+
+          requires_one :name, :group_id
+
+          service.authorize_security_group_ingress(
+            name,
+            'GroupId'                    => group_id,
+            'SourceSecurityGroupName'    => group,
+            'SourceSecurityGroupOwnerId' => owner
+          )
+        end
+
+        # Authorize a new port range for a security group
+        #
+        #  >> g = AWS.security_groups.all(:description => "something").first
+        #  >> g.authorize_port_range(20..21)
+        #
+        # == Parameters:
+        # range::
+        #   A Range object representing the port range you want to open up. E.g., 20..21
+        #
+        # options::
+        #   A hash that can contain any of the following keys:
+        #    :cidr_ip (defaults to "0.0.0.0/0")
+        #    :group - ("account:group_name" or "account:group_id"), cannot be used with :cidr_ip
+        #    :ip_protocol (defaults to "tcp")
+        #
+        # == Returns:
+        #
+        # An excon response object representing the result
+        #
+        #  <Excon::Response:0x101fc2ae0
+        #    @status=200,
+        #    @body={"requestId"=>"some-id-string",
+        #           "return"=>true},
+        #    headers{"Transfer-Encoding"=>"chunked",
+        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
+        #            "Content-Type"=>"text/xml;charset=UTF-8",
+        #            "Server"=>"AmazonEC2"}
+        #
+
+        def authorize_port_range(range, options = {})
+          requires_one :name, :group_id
+
+          ip_permission = {
+            'FromPort'   => range.min,
+            'ToPort'     => range.max,
+            'IpProtocol' => options[:ip_protocol] || 'tcp'
+          }
+
+          if options[:group].nil?
+            ip_permission['IpRanges'] = [
+              { 'CidrIp' => options[:cidr_ip] || '0.0.0.0/0' }
+            ]
+          else
+            ip_permission['Groups'] = [
+              group_info(options[:group])
+            ]
+          end
+
+          service.authorize_security_group_ingress(
+            name,
+            'GroupId'       => group_id,
+            'IpPermissions' => [ ip_permission ]
+          )
+        end
+
+        # Removes an existing security group
+        #
+        # security_group.destroy
+        #
+        # ==== Returns
+        #
+        # True or false depending on the result
+        #
+
+        def destroy
+          requires_one :name, :group_id
+
+          if group_id.nil?
+            service.delete_security_group(name)
+          else
+            service.delete_security_group(nil, group_id)
+          end
+          true
+        end
+
+        # Revoke access by another security group
+        #
+        #  >> g = AWS.security_groups.all(:description => "something").first
+        #  >> g.revoke_group_and_owner("some_group_name", "1234567890")
+        #
+        # == Parameters:
+        # group::
+        #   The name of the security group you're revoking access to.
+        #
+        # owner::
+        #   The owner id for security group you're revoking access access to.
+        #
+        # == Returns:
+        #
+        # An excon response object representing the result
+        #
+        #  <Excon::Response:0x101fc2ae0
+        #    @status=200,
+        #    @body={"requestId"=>"some-id-string",
+        #           "return"=>true},
+        #    headers{"Transfer-Encoding"=>"chunked",
+        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
+        #            "Content-Type"=>"text/xml;charset=UTF-8",
+        #            "Server"=>"AmazonEC2"}
+        #
+
+        def revoke_group_and_owner(group, owner = nil)
+          Fog::Logger.deprecation("revoke_group_and_owner is deprecated, use revoke_port_range with :group option instead")
+
+          requires_one :name, :group_id
+
+          service.revoke_security_group_ingress(
+            name,
+            'GroupId'                    => group_id,
+            'SourceSecurityGroupName'    => group,
+            'SourceSecurityGroupOwnerId' => owner
+          )
+        end
+
+        # Revoke an existing port range for a security group
+        #
+        #  >> g = AWS.security_groups.all(:description => "something").first
+        #  >> g.revoke_port_range(20..21)
+        #
+        # == Parameters:
+        # range::
+        #   A Range object representing the port range you want to open up. E.g., 20..21
+        #
+        # options::
+        #   A hash that can contain any of the following keys:
+        #    :cidr_ip (defaults to "0.0.0.0/0")
+        #    :group - ("account:group_name" or "account:group_id"), cannot be used with :cidr_ip
+        #    :ip_protocol (defaults to "tcp")
+        #
+        # == Returns:
+        #
+        # An excon response object representing the result
+        #
+        #  <Excon::Response:0x101fc2ae0
+        #    @status=200,
+        #    @body={"requestId"=>"some-id-string",
+        #           "return"=>true},
+        #    headers{"Transfer-Encoding"=>"chunked",
+        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
+        #            "Content-Type"=>"text/xml;charset=UTF-8",
+        #            "Server"=>"AmazonEC2"}
+        #
+
+        def revoke_port_range(range, options = {})
+          requires_one :name, :group_id
+
+          ip_permission = {
+            'FromPort'   => range.min,
+            'ToPort'     => range.max,
+            'IpProtocol' => options[:ip_protocol] || 'tcp'
+          }
+
+          if options[:group].nil?
+            ip_permission['IpRanges'] = [
+              { 'CidrIp' => options[:cidr_ip] || '0.0.0.0/0' }
+            ]
+          else
+            ip_permission['Groups'] = [
+              group_info(options[:group])
+            ]
+          end
+
+          service.revoke_security_group_ingress(
+            name,
+            'GroupId'       => group_id,
+            'IpPermissions' => [ ip_permission ]
+          )
+        end
+
+        # Reload a security group
+        #
+        #  >> g = AWS.security_groups.get(:name => "some_name")
+        #  >> g.reload
+        #
+        #  == Returns:
+        #
+        #  Up to date model or an exception
+
+        def reload
+          if group_id.nil?
+            super
+            service.delete_security_group(name)
+          else
+            requires :group_id
+
+            data = begin
+              collection.get_by_id(group_id)
+            rescue Excon::Errors::SocketError
+              nil
+            end
+
+            return unless data
+
+            merge_attributes(data.attributes)
+            self
+          end
+        end
+
+
+        # Create a security group
+        #
+        #  >> g = AWS.security_groups.new(:name => "some_name", :description => "something")
+        #  >> g.save
+        #
+        # == Returns:
+        #
+        # True or an exception depending on the result. Keep in mind that this *creates* a new security group.
+        # As such, it yields an InvalidGroup.Duplicate exception if you attempt to save an existing group.
+        #
+
+        def save
+          requires :description, :name
+          data = service.create_security_group(name, description, vpc_id).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+
+          if tags = self.tags
+            # expect eventual consistency
+            Fog.wait_for { self.reload rescue nil }
+            service.create_tags(
+              self.group_id,
+              tags
+            )
+          end
+
+          true
+        end
+
+        private
+
+        #
+        # +group_arg+ may be a string or a hash with one key & value.
+        #
+        # If group_arg is a string, it is assumed to be the group name,
+        # and the UserId is assumed to be self.owner_id.
+        #
+        # The "account:group" form is deprecated.
+        #
+        # If group_arg is a hash, the key is the UserId and value is the group.
+        def group_info(group_arg)
+          if Hash === group_arg
+            account = group_arg.keys.first
+            group   = group_arg.values.first
+          elsif group_arg.match(/:/)
+            account, group = group_arg.split(':')
+            Fog::Logger.deprecation("'account:group' argument is deprecated. Use {account => group} or just group instead")
+          else
+            requires :owner_id
+            account = owner_id
+            group = group_arg
+          end
+
+          info = { 'UserId' => account }
+
+          if group.start_with?("sg-")
+            # we're dealing with a security group id
+            info['GroupId'] = group
+          else
+            # this has to be a security group name
+            info['GroupName'] = group
+          end
+
+          info
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/compute/security_groups.rb

@@ -0,0 +1,117 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/security_group'
+
+module Fog
+  module Compute
+    class AWS
+      class SecurityGroups < Fog::Collection
+        attribute :filters
+
+        model Fog::Compute::AWS::SecurityGroup
+
+        # Creates a new security group
+        #
+        # AWS.security_groups.new
+        #
+        # ==== Returns
+        #
+        # Returns the details of the new image
+        #
+        #>> AWS.security_groups.new
+        #  <Fog::AWS::Compute::SecurityGroup
+        #    name=nil,
+        #    description=nil,
+        #    ip_permissions=nil,
+        #    owner_id=nil
+        #    vpc_id=nil
+        #  >
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # Returns an array of all security groups that have been created
+        #
+        # AWS.security_groups.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all security groups
+        #
+        #>> AWS.security_groups.all
+        #  <Fog::AWS::Compute::SecurityGroups
+        #    filters={}
+        #    [
+        #      <Fog::AWS::Compute::SecurityGroup
+        #        name="default",
+        #        description="default group",
+        #        ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
+        #        owner_id="312571045469"
+        #        vpc_id=nill
+        #      >
+        #    ]
+        #  >
+        #
+
+        def all(filters_arg = filters)
+          unless filters_arg.is_a?(Hash)
+            Fog::Logger.deprecation("all with #{filters_arg.class} param is deprecated, use all('group-name' => []) instead [light_black](#{caller.first})[/]")
+            filters_arg = {'group-name' => [*filters_arg]}
+          end
+          self.filters = filters_arg
+          data = service.describe_security_groups(filters).body
+          load(data['securityGroupInfo'])
+        end
+
+        # Used to retrieve a security group
+        # group name is required to get the associated flavor information.
+        #
+        # You can run the following command to get the details:
+        # AWS.security_groups.get("default")
+        #
+        # ==== Returns
+        #
+        #>> AWS.security_groups.get("default")
+        #  <Fog::AWS::Compute::SecurityGroup
+        #    name="default",
+        #    description="default group",
+        #    ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
+        #    owner_id="312571045469"
+        #    vpc_id=nil
+        #  >
+        #
+
+        def get(group_name)
+          if group_name
+            self.class.new(:service => service).all('group-name' => group_name).first
+          end
+        end
+
+        # Used to retrieve a security group
+        # group id is required to get the associated flavor information.
+        #
+        # You can run the following command to get the details:
+        # AWS.security_groups.get_by_id("default")
+        #
+        # ==== Returns
+        #
+        #>> AWS.security_groups.get_by_id("sg-123456")
+        #  <Fog::AWS::Compute::SecurityGroup
+        #    name="default",
+        #    description="default group",
+        #    ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
+        #    owner_id="312571045469"
+        #  >
+        #
+
+        def get_by_id(group_id)
+          if group_id
+            self.class.new(:service => service).all('group-id' => group_id).first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/compute/server.rb

@@ -0,0 +1,271 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class AWS
+      class Server < Fog::Compute::Server
+        extend Fog::Deprecation
+        deprecate :ip_address, :public_ip_address
+
+        identity  :id,                       :aliases => 'instanceId'
+
+        attr_accessor :architecture
+        attribute :ami_launch_index,         :aliases => 'amiLaunchIndex'
+        attribute :associate_public_ip,      :aliases => 'associatePublicIP'
+        attribute :availability_zone,        :aliases => 'availabilityZone'
+        attribute :block_device_mapping,     :aliases => 'blockDeviceMapping'
+        attribute :network_interfaces,       :aliases => 'networkInterfaces'
+        attribute :client_token,             :aliases => 'clientToken'
+        attribute :disable_api_termination,  :aliases => 'disableApiTermination'
+        attribute :dns_name,                 :aliases => 'dnsName'
+        attribute :ebs_optimized,            :aliases => 'ebsOptimized'
+        attribute :groups
+        attribute :flavor_id,                :aliases => 'instanceType'
+        attribute :hypervisor
+        attribute :iam_instance_profile,     :aliases => 'iamInstanceProfile'
+        attribute :image_id,                 :aliases => 'imageId'
+        attr_accessor :instance_initiated_shutdown_behavior
+        attribute :kernel_id,                :aliases => 'kernelId'
+        attribute :key_name,                 :aliases => 'keyName'
+        attribute :created_at,               :aliases => 'launchTime'
+        attribute :lifecycle,                :aliases => 'instanceLifecycle'
+        attribute :monitoring,               :squash =>  'state'
+        attribute :placement_group,          :aliases => 'groupName'
+        attribute :platform,                 :aliases => 'platform'
+        attribute :product_codes,            :aliases => 'productCodes'
+        attribute :private_dns_name,         :aliases => 'privateDnsName'
+        attribute :private_ip_address,       :aliases => 'privateIpAddress'
+        attribute :public_ip_address,        :aliases => 'ipAddress'
+        attribute :ramdisk_id,               :aliases => 'ramdiskId'
+        attribute :reason
+        attribute :requester_id,             :aliases => 'requesterId'
+        attribute :root_device_name,         :aliases => 'rootDeviceName'
+        attribute :root_device_type,         :aliases => 'rootDeviceType'
+        attribute :security_group_ids,       :aliases => 'securityGroupIds'
+        attribute :source_dest_check,        :aliases => 'sourceDestCheck'
+        attribute :spot_instance_request_id, :aliases => 'spotInstanceRequestId'
+        attribute :state,                    :aliases => 'instanceState', :squash => 'name'
+        attribute :state_reason,             :aliases => 'stateReason'
+        attribute :subnet_id,                :aliases => 'subnetId'
+        attribute :tenancy
+        attribute :tags,                     :aliases => 'tagSet'
+        attribute :user_data
+        attribute :virtualization_type,      :aliases => 'virtualizationType'
+        attribute :vpc_id,                   :aliases => 'vpcId'
+
+        attr_accessor                        :password
+        attr_writer                          :iam_instance_profile_name, :iam_instance_profile_arn
+
+        def initialize(attributes={})
+          self.groups     ||= ["default"] unless (attributes[:subnet_id] || attributes[:security_group_ids] || attributes[:network_interfaces])
+          self.flavor_id  ||= 't1.micro'
+
+          # Old 'connection' is renamed as service and should be used instead
+          prepare_service_value(attributes)
+
+          self.image_id   ||= begin
+            self.username ||= 'ubuntu'
+            case @service.instance_variable_get(:@region) # Ubuntu 10.04 LTS 64bit (EBS)
+            when 'ap-northeast-1'
+              'ami-5e0fa45f'
+            when 'ap-southeast-1'
+              'ami-f092eca2'
+            when 'ap-southeast-2'
+              'ami-fb8611c1' # Ubuntu 12.04 LTS 64bit (EBS)
+            when 'eu-west-1'
+              'ami-3d1f2b49'
+            when 'sa-east-1'
+              'ami-d0429ccd'
+            when 'us-east-1'
+              'ami-3202f25b'
+            when 'us-west-1'
+              'ami-f5bfefb0'
+            when 'us-west-2'
+              'ami-e0ec60d0'
+            end
+          end
+          super
+        end
+
+        def addresses
+          requires :id
+
+          service.addresses(:server => self)
+        end
+
+        def console_output
+          requires :id
+
+          service.get_console_output(id)
+        end
+
+        def destroy
+          requires :id
+
+          service.terminate_instances(id)
+          true
+        end
+
+        remove_method :flavor_id
+        def flavor_id
+          @flavor && @flavor.id || attributes[:flavor_id]
+        end
+
+        def flavor=(new_flavor)
+          @flavor = new_flavor
+        end
+
+        def flavor
+          @flavor ||= service.flavors.all.find {|flavor| flavor.id == flavor_id}
+        end
+
+        def key_pair
+          requires :key_name
+          service.key_pairs.all({'key-name' => key_name}).first
+        end
+
+        def key_pair=(new_keypair)
+          self.key_name = new_keypair && new_keypair.name
+        end
+
+        def ready?
+          state == 'running'
+        end
+
+        def reboot
+          requires :id
+          service.reboot_instances(id)
+          true
+        end
+
+        def run_instance_options
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :image_id
+
+          options = {
+            'BlockDeviceMapping'          => block_device_mapping,
+            'NetworkInterfaces'           => network_interfaces,
+            'ClientToken'                 => client_token,
+            'DisableApiTermination'       => disable_api_termination,
+            'EbsOptimized'                => ebs_optimized,
+            'IamInstanceProfile.Arn'      => @iam_instance_profile_arn,
+            'IamInstanceProfile.Name'     => @iam_instance_profile_name,
+            'InstanceInitiatedShutdownBehavior' => instance_initiated_shutdown_behavior,
+            'InstanceType'                => flavor_id,
+            'KernelId'                    => kernel_id,
+            'KeyName'                     => key_name,
+            'Monitoring.Enabled'          => monitoring,
+            'Placement.AvailabilityZone'  => availability_zone,
+            'Placement.GroupName'         => placement_group,
+            'Placement.Tenancy'           => tenancy,
+            'PrivateIpAddress'            => private_ip_address,
+            'RamdiskId'                   => ramdisk_id,
+            'SecurityGroup'               => groups,
+            'SecurityGroupId'             => security_group_ids,
+            'SubnetId'                    => subnet_id,
+            'UserData'                    => user_data,
+          }
+          options.delete_if {|key, value| value.nil?}
+
+          # If subnet is defined then this is a Virtual Private Cloud.
+          # subnet & security group cannot co-exist. Attempting to specify
+          # both subnet and groups will cause an error.  Instead please make
+          # use of Security Group Ids when working in a VPC.
+          if subnet_id
+            options.delete('SecurityGroup')
+            if associate_public_ip
+              options['NetworkInterface.0.DeviceIndex'] = 0
+              options['NetworkInterface.0.AssociatePublicIpAddress'] = associate_public_ip
+              options['NetworkInterface.0.SubnetId'] = options['SubnetId']
+              options.delete('SubnetId')
+              if options['SecurityGroupId'].kind_of?(Array)
+                options['SecurityGroupId'].each {|id|
+                  options["NetworkInterface.0.SecurityGroupId.#{options['SecurityGroupId'].index(id)}"] = id
+                }
+              else
+                options["NetworkInterface.0.SecurityGroupId.0"] = options['SecurityGroupId']
+              end
+              options.delete('SecurityGroupId')
+              if private_ip_address
+                options.delete('PrivateIpAddress')
+                options['NetworkInterface.0.PrivateIpAddress'] = private_ip_address
+              end
+            end
+          else
+            options.delete('SubnetId')
+          end
+          options
+        end
+
+        def save
+          servers = service.servers.save_many(self, 1, 1)
+          merge_attributes(servers.first.attributes)
+          true
+        end
+
+        def setup(credentials = {})
+          requires :ssh_ip_address, :username
+          require 'net/ssh'
+
+          commands = [
+            %{mkdir .ssh},
+            %{passwd -l #{username}},
+            %{echo "#{Fog::JSON.encode(Fog::JSON.sanitize(attributes))}" >> ~/attributes.json}
+          ]
+          if public_key
+            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
+          end
+
+          # wait for aws to be ready
+          wait_for { sshable?(credentials) }
+
+          Fog::SSH.new(ssh_ip_address, username, credentials).run(commands)
+        end
+
+        def start
+          requires :id
+          service.start_instances(id)
+          true
+        end
+
+        def stop(force = false)
+          requires :id
+          service.stop_instances(id, force)
+          true
+        end
+
+        def volumes
+          requires :id
+          service.volumes(:server => self)
+        end
+
+        #I tried to call it monitoring= and be smart with attributes[]
+        #but in #save a merge_attribute is called after run_instance
+        #thus making an un-necessary request. Use this until finding a clever solution
+        def monitor=(new_monitor)
+          if persisted?
+            case new_monitor
+            when true
+              response = service.monitor_instances(identity)
+            when false
+              response = service.unmonitor_instances(identity)
+            else
+              raise ArgumentError.new("only Boolean allowed here")
+            end
+          end
+          self.monitoring = new_monitor
+        end
+
+        private
+
+        def placement=(new_placement)
+          if new_placement.is_a?(Hash)
+            merge_attributes(new_placement)
+          else
+            self.attributes[:placement] = new_placement
+          end
+        end
+      end
+    end
+  end
+end