bbcloud 0.8 → 0.8.1

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

@@ -0,0 +1,78 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Adds tags to resources
+        #
+        # ==== Parameters
+        # * resources<~String> - One or more resources to tag
+        # * tags<~String> - hash of key value tag pairs to assign
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def create_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(AWS.indexed_param('ResourceId', resources))
+          params.merge!(AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'            => 'CreateTags',
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def create_tags(resources, tags)
+          resources = [*resources]
+
+          tagged = resources.map do |resource_id|
+            type = case resource_id
+            when /^ami\-[a-z0-9]{8}$/i
+              'image'
+            when /^i\-[a-z0-9]{8}$/i
+              'instance'
+            when /^snap\-[a-z0-9]{8}$/i
+              'snapshot'
+            when /^vol\-[a-z0-9]{8}$/i
+              'volume'
+            end
+            if type && @data[:"#{type}s"][resource_id]
+              { 'resourceId' => resource_id, 'resourceType' => type }
+            else
+              raise(Fog::Service::NotFound.new("The #{type} ID '#{resource_id}' does not exist"))
+            end
+          end
+
+          tags.each do |key, value|
+            @data[:tags][key] ||= {}
+            @data[:tags][key][value] ||= []
+            @data[:tags][key][value] = @data[:tags][key][value] & tagged
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/create_volume'
+
+        # Create an EBS volume
+        #
+        # ==== Parameters
+        # * availability_zone<~String> - availability zone to create volume in
+        # * size<~Integer> - Size in GiBs for volume.  Must be between 1 and 1024.
+        # * snapshot_id<~String> - Optional, snapshot to create volume from
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'availabilityZone'<~String> - Availability zone for volume
+        #     * 'createTime'<~Time> - Timestamp for creation
+        #     * 'size'<~Integer> - Size in GiBs for volume
+        #     * 'snapshotId'<~String> - Snapshot volume was created from, if any
+        #     * 'status's<~String> - State of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          request(
+            'Action'            => 'CreateVolume',
+            'AvailabilityZone'  => availability_zone,
+            'Size'              => size,
+            'SnapshotId'        => snapshot_id,
+            :parser             => Fog::Parsers::AWS::Compute::CreateVolume.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          response = Excon::Response.new
+          if availability_zone && size
+            response.status = 200
+            volume_id = Fog::AWS::Mock.volume_id
+            data = {
+              'availabilityZone'  => availability_zone,
+              'attachmentSet'     => [],
+              'createTime'        => Time.now,
+              'size'              => size,
+              'snapshotId'        => snapshot_id,
+              'status'            => 'creating',
+              'tagSet'            => {},
+              'volumeId'          => volume_id
+            }
+            @data[:volumes][volume_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data.reject {|key,value| !['availabilityZone','createTime','size','snapshotId','status','volumeId'].include?(key) })
+          else
+            response.status = 400
+            response.body = {
+              'Code' => 'MissingParameter'
+            }
+            unless availability_zone
+              response.body['Message'] = 'The request must contain the parameter availability_zone'
+            else
+              response.body['Message'] = 'The request must contain the parameter size'
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Delete a key pair that you own
+        #
+        # ==== Parameters
+        # * key_name<~String> - Name of the key pair.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_key_pair(key_name)
+          request(
+            'Action'    => 'DeleteKeyPair',
+            'KeyName'   => key_name,
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_key_pair(key_name)
+          response = Excon::Response.new
+          @data[:key_pairs].delete(key_name)
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id,
+            'return'    => true
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Delete a security group that you own
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of the security group.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_security_group(name)
+          request(
+            'Action'    => 'DeleteSecurityGroup',
+            'GroupName' => name,
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+        def delete_security_group(name)
+          response = Excon::Response.new
+          if @data[:security_groups][name]
+            @data[:security_groups].delete(name)
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::Compute::NotFound.new("The security group '#{name}' does not exist")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Delete a snapshot of an EBS volume that you own
+        #
+        # ==== Parameters
+        # * snapshot_id<~String> - ID of snapshot to delete
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_snapshot(snapshot_id)
+          request(
+            'Action'      => 'DeleteSnapshot',
+            'SnapshotId'  => snapshot_id,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_snapshot(snapshot_id)
+          response = Excon::Response.new
+          if snapshot = @data[:snapshots].delete(snapshot_id)
+            response.status = true
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::Compute::NotFound.new("The snapshot '#{snapshot_id}' does not exist.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Remove tags from resources
+        #
+        # ==== Parameters
+        # * resources<~String> - One or more resources to tag
+        # * tags<~String> - hash of key value tag pairs to assign
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(AWS.indexed_param('ResourceId', resources))
+          params.merge!(AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'            => 'CreateTags',
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def delete_tags(resources, tags)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Delete an EBS volume
+        #
+        # ==== Parameters
+        # * volume_id<~String> - Id of volume to delete.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def delete_volume(volume_id)
+          request(
+            'Action'    => 'DeleteVolume',
+            'VolumeId'  => volume_id,
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_volume(volume_id)
+          response = Excon::Response.new
+          if volume = @data[:volumes][volume_id]
+            if volume["attachmentSet"].any?
+              attach = volume["attachmentSet"].first
+              raise Fog::AWS::Compute::Error.new("Client.VolumeInUse => Volume #{volume_id} is currently attached to #{attach["instanceId"]}")
+            end
+            @data[:deleted_at][volume_id] = Time.now
+            volume['status'] = 'deleting'
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/deregister_image'
+
+        # deregister an image
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of image to deregister 
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'return'<~Boolean> - Returns true if deregistration succeeded
+        #     * 'requestId'<~String> - Id of request
+        def deregister_image(image_id)
+          request(
+            'Action'      => 'DeregisterImage',
+            'ImageId'     => image_id,
+            :parser       => Fog::Parsers::AWS::Compute::DeregisterImage.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def deregister_image(image_id)
+          response = Excon::Response.new
+          if image_id 
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return' => "true"
+            }
+            response
+          else
+            message = 'MissingParameter => '
+            if !instance_id
+              message << 'The request must contain the parameter image_id'
+            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/describe_addresses.rb

@@ -0,0 +1,64 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_addresses'
+
+        # Describe all or specified IP addresses.
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'addressesSet'<~Array>:
+        #       * 'instanceId'<~String> - instance for ip address
+        #       * 'publicIp'<~String> - ip address for instance
+        def describe_addresses(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_addresses with #{filters.class} param is deprecated, use describe_addresses('public-ip' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeAddresses',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeAddresses.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_addresses(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_addresses with #{filters.class} param is deprecated, use describe_addresses('public-ip' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+
+          response = Excon::Response.new
+
+          addresses_set = @data[:addresses].values
+
+          aliases = {'public-ip' => 'publicIp', 'instance-id' => 'instanceId'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            addresses_set = addresses_set.reject{|address| ![*filter_value].include?(address[aliased_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'requestId'     => Fog::AWS::Mock.request_id,
+            'addressesSet'  => addresses_set
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_availability_zones'
+
+        # Describe all or specified availability zones
+        #
+        # ==== Params
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'availabilityZoneInfo'<~Array>:
+        #       * 'regionName'<~String> - Name of region
+        #       * 'zoneName'<~String> - Name of zone
+        #       * 'zoneState'<~String> - State of zone
+        def describe_availability_zones(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+          params = AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeAvailabilityZones',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeAvailabilityZones.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_availability_zones(filters = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] describe_availability_zones with #{filters.class} param is deprecated, use describe_availability_zones('zone-name' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+
+          response = Excon::Response.new
+
+          availability_zone_info = [
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1a", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1b", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1c", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "us-east-1", "zoneName" => "us-east-1d", "zoneState" => "available"},
+          ]
+
+          aliases = {'region-name' => 'regionName', 'zone-name' => 'zoneName', 'state' => 'zoneState'}
+          for filter_key, filter_value in filters
+            aliased_key = aliases[filter_key]
+            availability_zone_info = availability_zone_info.reject{|availability_zone| ![*filter_value].include?(availability_zone[aliased_key])}
+          end
+
+          response.status = 200
+          response.body = {
+            'availabilityZoneInfo'  => availability_zone_info,
+            'requestId'             => Fog::AWS::Mock.request_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_images'
+
+        # Describe all or specified images.
+        #
+        # ==== Params
+        # * filters<~Hash> - List of filters to limit results with
+        #   * filters and/or the following
+        #   * 'ExecutableBy'<~String> - Only return images that the executable_by
+        #     user has explicit permission to launch
+        #   * 'ImageId'<~Array> - Ids of images to describe
+        #   * 'Owner'<~String> - Only return images belonging to owner.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'imagesSet'<~Array>:
+        #       * 'architecture'<~String> - Architecture of the image
+        #       * 'blockDeviceMapping'<~Array> - An array of mapped block devices
+        #       * 'imageId'<~String> - Id of the image
+        #       * 'imageLocation'<~String> - Location of the image
+        #       * 'imageOwnerId'<~String> - Id of the owner of the image
+        #       * 'imageState'<~String> - State of the image
+        #       * 'imageType'<~String> - Type of the image
+        #       * 'isPublic'<~Boolean> - Whether or not the image is public
+        #       * 'kernelId'<~String> - Kernel id associated with image, if any
+        #       * 'platform'<~String> - Operating platform of the image
+        #       * 'productCodes'<~Array> - Product codes for the image
+        #       * 'ramdiskId'<~String> - Ramdisk id associated with image, if any
+        #       * 'rootDeviceName'<~String> - Root device name, e.g. /dev/sda1
+        #       * 'rootDeviceType'<~String> - Root device type, ebs or instance-store
+        def describe_images(filters = {})
+          options = {}
+          for key in ['ExecutableBy', 'ImageId', 'Owner']
+            if filters.is_a?(Hash) && filters.key?(key)
+              options[key] = filters.delete(key)
+            end
+          end
+          params = AWS.indexed_filters(filters).merge!(options)
+          request({
+            'Action'    => 'DescribeImages',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::DescribeImages.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_images(filters = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end