bbcloud 0.8.1 → 0.8.2

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/import_key_pair.rb

@@ -1,54 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        require 'fog/aws/parsers/compute/import_key_pair'
-
-        # Import an existing public key to create a new key pair
-        #
-        # ==== Parameters
-        # * key_name<~String> - Unique name for key pair.
-        # * public_key_material<~String> - RSA public key
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'keyFingerprint'<~String> - SHA-1 digest of DER encoded private key
-        #     * 'keyName'<~String> - Name of key
-        #     * 'requestId'<~String> - Id of request
-        def import_key_pair(key_name, public_key_material)
-          request(
-            'Action'  => 'ImportKeyPair',
-            'KeyName' => key_name,
-            'PublicKeyMaterial' => Base64::encode64(public_key_material),
-            :parser   => Fog::Parsers::AWS::Compute::ImportKeyPair.new
-          )
-        end
-
-      end
-
-      class Mock
-
-        def import_key_pair(key_name, public_key_material)
-          response = Excon::Response.new
-          unless @data[:key_pairs][key_name]
-            response.status = 200
-            data = {
-              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
-              'keyName'         => key_name
-            }
-            @data[:key_pairs][key_name] = data
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id
-            }.merge!(data)
-            response
-          else
-            raise Fog::AWS::Compute::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/modify_image_attributes.rb

@@ -1,39 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        # Modify image attributes
-        #
-        # ==== Parameters
-        # * image_id<~String> - Id of machine image to modify
-        # * attribute<~String> - Attribute to modify, in ['launchPermission', 'productCodes']
-        # * operation_type<~String> - Operation to perform on attribute, in ['add', 'remove']
-        #
-        def modify_image_attributes(image_id, attribute, operation_type, options = {})
-          params = {}
-          params.merge!(AWS.indexed_param('UserId', options['UserId']))
-          params.merge!(AWS.indexed_param('UserGroup', options['UserGroup']))
-          params.merge!(AWS.indexed_param('ProductCode', options['ProductCode']))
-          request({
-            'Action'        => 'ModifyImageAttribute',
-            'Attribute'     => attribute,
-            'ImageId'       => image_id,
-            'OperationType' => operation_type,
-            :idempotent     => true,
-            :parser         => Fog::Parsers::AWS::Compute::Basic.new
-          }.merge!(params))
-        end
-
-      end
-
-      class Mock
-
-        def modify_image_attributes(image_id, attribute, operation_type, options = {})
-          Fog::Mock.not_implemented
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/modify_snapshot_attribute.rb

@@ -1,38 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        # Modify snapshot attributes
-        #
-        # ==== Parameters
-        # * snapshot_id<~String> - Id of snapshot to modify
-        # * attribute<~String> - Attribute to modify, in ['createVolumePermission']
-        # * operation_type<~String> - Operation to perform on attribute, in ['add', 'remove']
-        #
-        def modify_snapshot_attribute(snapshot_id, attribute, operation_type, options = {})
-          params = {}
-          params.merge!(AWS.indexed_param('UserId', options['UserId']))
-          params.merge!(AWS.indexed_param('UserGroup', options['UserGroup']))
-          request({
-            'Action'        => 'ModifySnapshotAttribute',
-            'Attribute'     => attribute,
-            'SnapshotId'    => snapshot_id,
-            'OperationType' => operation_type,
-            :idempotent     => true,
-            :parser         => Fog::Parsers::AWS::Compute::Basic.new
-          }.merge!(params))
-        end
-
-      end
-
-      class Mock
-
-        def modify_snapshot_attribute(snapshot_id, attribute, operation_type, options = {})
-          Fog::Mock.not_implemented
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/reboot_instances.rb

@@ -1,50 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        # Reboot specified instances
-        #
-        # ==== Parameters
-        # * instance_id<~Array> - Ids of instances to reboot
-        #
-        # ==== Returns
-        # # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        def reboot_instances(instance_id = [])
-          params = AWS.indexed_param('InstanceId', instance_id)
-          request({
-            'Action'    => 'RebootInstances',
-            :idempotent => true,
-            :parser     => Fog::Parsers::AWS::Compute::Basic.new
-          }.merge!(params))
-        end
-
-      end
-
-      class Mock
-
-        def reboot_instances(instance_id = [])
-          response = Excon::Response.new
-          instance_id = [*instance_id]
-          if (@data[:instances].keys & instance_id).length == instance_id.length
-            for instance_id in instance_id
-              @data[:instances][instance_id]['status'] = 'rebooting'
-            end
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::AWS::Compute::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/register_image.rb

@@ -1,89 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        require 'fog/aws/parsers/compute/register_image'
-
-        # register an image
-        #
-        # ==== Parameters
-        # * Name<~String> - Name of the AMI to be registered
-        # * Description<~String> - AMI description
-        # * Location<~String> - S3 manifest location (for S3 backed AMIs)
-        # or
-        # * RootDeviceName<~String> - Name of Root Device (for EBS snapshot backed AMIs)
-        # * BlockDevices<~Array>:
-        #   * BlockDeviceOptions<~Hash>:
-        #     * DeviceName<~String> - Name of the Block Device
-        #     * VirtualName<~String> - Name of the Virtual Device
-        #     * SnapshotId<~String> - id of the EBS Snapshot
-        #     * VolumeSize<~Integer> - Size of the snapshot (optional)
-        #     * NoDevice<~Boolean> - Do not use an ebs device (def: true)
-        #     * DeleteOnTermation<~Boolean> - Delete EBS volume on instance term (def: true)
-        # * Options<~Hash>:
-        #   * Architecture<~String> - i386 or x86_64
-        #   * KernelId<~String> - kernelId
-        #   * RamdiskId<~String> - ramdiskId
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'imageId'<~String> - Id of newly created AMI
-
-        def register_image(name, description, location, block_devices=[], options={})
-          common_options = {
-            'Action'      => 'RegisterImage',
-            'Name'        => name,
-            'Description' => description,
-            :parser       => Fog::Parsers::AWS::Compute::RegisterImage.new
-          }
-
-          # This determines if we are doing a snapshot or a S3 backed AMI.
-          if(location =~ /^\/dev\/sd[a-p]\d{0,2}$/)
-            common_options['RootDeviceName'] = location
-          else
-            common_options['ImageLocation'] = location
-          end
-
-          bdi = 0
-          block_devices.each do |bd|
-            bdi += 1
-            ["DeviceName","VirtualName"].each do |n|
-              common_options["BlockDeviceMapping.#{bdi}.#{n}"] = bd["#{n}"] if bd["#{n}"]
-            end
-            ["SnapshotId","VolumeSize","NoDevice","DeleteOnTermination"].each do |n|
-              common_options["BlockDeviceMapping.#{bdi}.Ebs.#{n}"] = bd["#{n}"] if bd["#{n}"]
-            end
-
-          end
-
-          request(common_options.merge!(options))
-        end
-
-      end
-
-      class Mock
-
-        def register_image(name, description, location, block_devices=[], options={})
-          response = Excon::Response.new
-          if !name.empty?
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'imageId' => Fog::AWS::Mock.image_id
-            }
-            response
-          else
-            message = 'MissingParameter => '
-            if name.empty?
-              message << 'The request must contain the parameter name'
-            end
-            raise Fog::AWS::Compute::Error.new(message)
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/release_address.rb

@@ -1,43 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        # Release an elastic IP address.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        def release_address(public_ip)
-          request(
-            'Action'    => 'ReleaseAddress',
-            'PublicIp'  => public_ip,
-            :idempotent => true,
-            :parser     => Fog::Parsers::AWS::Compute::Basic.new
-          )
-        end
-
-      end
-
-      class Mock
-
-        def release_address(public_ip)
-          response = Excon::Response.new
-          if (address = @data[:addresses].delete(public_ip))
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::AWS::Compute::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/revoke_security_group_ingress.rb

@@ -1,74 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        # Remove permissions from a security group
-        #
-        # ==== Parameters
-        # * options<~Hash>:
-        #   * 'GroupName'<~String> - Name of group
-        #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
-        #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
-        #   or
-        #   * 'CidrIp' - CIDR range
-        #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
-        #   * 'GroupName' - Name of group to modify
-        #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
-        #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
-        #
-        # === Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        def revoke_security_group_ingress(options = {})
-          request({
-            'Action'    => 'RevokeSecurityGroupIngress',
-            :idempotent => true,
-            :parser     => Fog::Parsers::AWS::Compute::Basic.new
-          }.merge!(options))
-        end
-
-      end
-
-      class Mock
-
-        def revoke_security_group_ingress(options = {})
-          response = Excon::Response.new
-          group = @data[:security_groups][options['GroupName']]
-          if group
-            if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
-              group['ipPermissions'].delete_if {|permission|
-                permission['groups'].first['groupName'] == options['GroupName']
-              }
-            else
-              ingress = group['ipPermissions'].select {|permission|
-                permission['fromPort']    == options['FromPort'] &&
-                permission['ipProtocol']  == options['IpProtocol'] &&
-                permission['toPort']      == options['ToPort'] &&
-                (
-                  permission['ipRanges'].empty? ||
-                  (
-                    permission['ipRanges'].first &&
-                    permission['ipRanges'].first['cidrIp'] == options['CidrIp']
-                  )
-                )
-              }.first
-              group['ipPermissions'].delete(ingress)
-            end
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::AWS::Compute::NotFound.new("The security group '#{options['GroupName']}' does not exist")
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/run_instances.rb

@@ -1,167 +0,0 @@
-module Fog
-  module AWS
-    class Compute
-      class Real
-
-        require 'fog/aws/parsers/compute/run_instances'
-
-        # Launch specified instances
-        #
-        # ==== Parameters
-        # * image_id<~String> - Id of machine image to load on instances
-        # * min_count<~Integer> - Minimum number of instances to launch. If this
-        #   exceeds the count of available instances, no instances will be
-        #   launched.  Must be between 1 and maximum allowed for your account
-        #   (by default the maximum for an account is 20)
-        # * max_count<~Integer> - Maximum number of instances to launch. If this
-        #   exceeds the number of available instances, the largest possible
-        #   number of instances above min_count will be launched instead. Must
-        #   be between 1 and maximum allowed for you account
-        #   (by default the maximum for an account is 20)
-        # * options<~Hash>:
-        #   * 'Placement.AvailabilityZone'<~String> - Placement constraint for instances
-        #   * 'BlockDeviceMapping'<~Array>: array of hashes
-        #     * 'DeviceName'<~String> - where the volume will be exposed to instance
-        #     * 'VirtualName'<~String> - volume virtual device name
-        #     * 'Ebs.SnapshotId'<~String> - id of snapshot to boot volume from
-        #     * 'Ebs.VolumeSize'<~String> - size of volume in GiBs required unless snapshot is specified
-        #     * 'Ebs.DeleteOnTermination'<~String> - specifies whether or not to delete the volume on instance termination
-        #   * 'ClientToken'<~String> - unique case-sensitive token for ensuring idempotency
-        #   * 'SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances (you must omit this parameter if using Virtual Private Clouds)
-        #   * 'InstanceInitiatedShutdownBehaviour'<~String> - specifies whether volumes are stopped or terminated when instance is shutdown, in [stop, terminate]
-        #   * 'InstanceType'<~String> - Type of instance to boot. Valid options
-        #     in ['m1.small', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'm2.2xlarge', 'm2.4xlarge']
-        #     default is 'm1.small'
-        #   * 'KernelId'<~String> - Id of kernel with which to launch
-        #   * 'KeyName'<~String> - Name of a keypair to add to booting instances
-        #   * 'Monitoring.Enabled'<~Boolean> - Enables monitoring, defaults to
-        #     disabled
-        #   * 'RamdiskId'<~String> - Id of ramdisk with which to launch
-        #   * 'UserData'<~String> -  Additional data to provide to booting instances
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'groupSet'<~Array>: groups the instances are members in
-        #       * 'groupName'<~String> - Name of group
-        #     * 'instancesSet'<~Array>: returned instances
-        #       * instance<~Hash>:
-        #         * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
-        #         * 'architecture'<~String> - architecture of image in [i386, x86_64]
-        #         * 'blockDeviceMapping'<~Array>
-        #           * 'attachTime'<~Time> - time of volume attachment
-        #           * 'deleteOnTermination'<~Boolean> - whether or not to delete volume on termination
-        #           * 'deviceName'<~String> - specifies how volume is exposed to instance
-        #           * 'status'<~String> - status of attached volume
-        #           * 'volumeId'<~String> - Id of attached volume
-        #         * 'dnsName'<~String> - public dns name, blank until instance is running
-        #         * 'imageId'<~String> - image id of ami used to launch instance
-        #         * 'instanceId'<~String> - id of the instance
-        #         * 'instanceState'<~Hash>:
-        #           * 'code'<~Integer> - current status code
-        #           * 'name'<~String> - current status name
-        #         * 'instanceType'<~String> - type of instance
-        #         * 'ipAddress'<~String> - public ip address assigned to instance
-        #         * 'kernelId'<~String> - Id of kernel used to launch instance
-        #         * 'keyName'<~String> - name of key used launch instances or blank
-        #         * 'launchTime'<~Time> - time instance was launched
-        #         * 'monitoring'<~Hash>:
-        #           * 'state'<~Boolean - state of monitoring
-        #         * 'placement'<~Hash>:
-        #           * 'availabilityZone'<~String> - Availability zone of the instance
-        #         * 'privateDnsName'<~String> - private dns name, blank until instance is running
-        #         * 'privateIpAddress'<~String> - private ip address assigned to instance
-        #         * 'productCodes'<~Array> - Product codes for the instance
-        #         * 'ramdiskId'<~String> - Id of ramdisk used to launch instance
-        #         * 'reason'<~String> - reason for most recent state transition, or blank
-        #         * 'rootDeviceName'<~String> - specifies how the root device is exposed to the instance
-        #         * 'rootDeviceType'<~String> - root device type used by AMI in [ebs, instance-store]
-        #     * 'ownerId'<~String> - Id of owner
-        #     * 'requestId'<~String> - Id of request
-        #     * 'reservationId'<~String> - Id of reservation
-        def run_instances(image_id, min_count, max_count, options = {})
-          if block_device_mapping = options.delete('BlockDeviceMapping')
-            block_device_mapping.each_with_index do |mapping, index|
-              for key, value in mapping
-                options.merge!({ format("BlockDeviceMapping.%d.#{key}", index) => value })
-              end
-            end
-          end
-          if security_groups = options.delete('SecurityGroup')
-            options.merge!(AWS.indexed_param('SecurityGroup', [*security_groups]))
-          end
-          if options['UserData']
-            options['UserData'] = Base64.encode64(options['UserData'])
-          end
-
-          idempotent = !(options['ClientToken'].nil? || options['ClientToken'].empty?)
-
-          request({
-            'Action'    => 'RunInstances',
-            'ImageId'   => image_id,
-            'MinCount'  => min_count,
-            'MaxCount'  => max_count,
-            :idempotent => idempotent,
-            :parser     => Fog::Parsers::AWS::Compute::RunInstances.new
-          }.merge!(options))
-        end
-
-      end
-
-      class Mock
-
-        def run_instances(image_id, min_count, max_count, options = {})
-          response = Excon::Response.new
-          response.status = 200
-
-          group_set = [ (options['GroupId'] || 'default') ]
-          instances_set = []
-          reservation_id = Fog::AWS::Mock.reservation_id
-
-          min_count.times do |i|
-            instance_id = Fog::AWS::Mock.instance_id
-            instance = {
-              'amiLaunchIndex'      => i,
-              'blockDeviceMapping'  => [],
-              'clientToken'         => options['clientToken'],
-              'dnsName'             => nil,
-              'imageId'             => image_id,
-              'instanceId'          => instance_id,
-              'instanceState'       => { 'code' => 0, 'name' => 'pending' },
-              'instanceType'        => options['InstanceType'] || 'm1.small',
-              'kernelId'            => options['KernelId'] || Fog::AWS::Mock.kernel_id,
-              # 'keyName'             => options['KeyName'],
-              'launchTime'          => Time.now,
-              'monitoring'          => { 'state' => options['Monitoring.Enabled'] || false },
-              'placement'           => { 'availabilityZone' => options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone },
-              'privateDnsName'      => nil,
-              'productCodes'        => [],
-              'ramdiskId'           => options['RamdiskId'] || Fog::AWS::Mock.ramdisk_id,
-              'reason'              => nil,
-              'rootDeviceType'      => 'instance-store'
-            }
-            instances_set << instance
-            @data[:instances][instance_id] = instance.merge({
-              'architecture'        => 'i386',
-              'groupSet'            => group_set,
-              'ownerId'             => @owner_id,
-              'privateIpAddress'    => nil,
-              'reservationId'       => reservation_id,
-              'stateReason'         => {},
-              'tagSet'              => {}
-            })
-          end
-          response.body = {
-            'groupSet'      => group_set,
-            'instancesSet'  => instances_set,
-            'ownerId'       => @owner_id,
-            'requestId'     => Fog::AWS::Mock.request_id,
-            'reservationId' => reservation_id
-          }
-          response
-        end
-
-      end
-    end
-  end
-end