fog 1.26.0 → 1.27.0

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

@@ -1,322 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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 = filters)
-          unless filters.is_a?(Hash)
-            Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('group-name' => []) instead [light_black](#{caller.first})[/]")
-            filters = {'group-name' => [*filters]}
-          end
-          self.filters = filters
-          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

@@ -1,271 +0,0 @@
-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