brightbox-cli 0.13.0

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/authorize_security_group_ingress.rb

@@ -0,0 +1,108 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # Add permissions to a security group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of group
+        # * options<~Hash>:
+        #   * '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?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AuthorizeSecurityGroupIngress.html]
+        def authorize_security_group_ingress(group_name, options = {})
+          if group_name.is_a?(Hash)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+            options = group_name
+            group_name = options['GroupName']
+          end
+          request({
+            'Action'    => 'AuthorizeSecurityGroupIngress',
+            'GroupName' => group_name,
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def authorize_security_group_ingress(group_name, options = {})
+          if group_name.is_a?(Hash)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+            options = group_name
+            group_name = options['GroupName']
+          end
+
+          response = Excon::Response.new
+          group = self.data[:security_groups][group_name]
+
+          if group
+            group['ipPermissions'] ||= []
+            if group_name && source_group_name = options['SourceSecurityGroupName']
+              ['tcp', 'udp'].each do |protocol|
+                group['ipPermissions'] << {
+                  'groups'      => [{'groupName' => source_group_name, 'userId' => (options['SourceSecurityGroupOwnerId'] || self.data[:owner_id]) }],
+                  'fromPort'    => 1,
+                  'ipRanges'    => [],
+                  'ipProtocol'  => protocol,
+                  'toPort'      => 65535
+                }
+              end
+              group['ipPermissions'] << {
+                'groups'      => [{'groupName' => source_group_name, 'userId' => (options['SourceSecurityGroupOwnerId'] || self.data[:owner_id]) }],
+                'fromPort'    => -1,
+                'ipRanges'    => [],
+                'ipProtocol'  => 'icmp',
+                'toPort'      => -1
+              }
+            else
+              group['ipPermissions'] << {
+                'groups'      => [],
+                'fromPort'    => options['FromPort'],
+                'ipRanges'    => [],
+                'ipProtocol'  => options['IpProtocol'],
+                'toPort'      => options['ToPort']
+              }
+              if options['CidrIp']
+                group['ipPermissions'].last['ipRanges'] << { 'cidrIp' => options['CidrIp'] }
+              end
+            end
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/cancel_spot_instance_requests.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/cancel_spot_instance_requests'
+
+        # Terminate specified spot instance requests
+        #
+        # ==== Parameters
+        # * spot_instance_request_id<~Array> - Ids of instances to terminates
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> id of request
+        #     * 'spotInstanceRequestSet'<~Array>:
+        #       * 'spotInstanceRequestId'<~String> - id of cancelled spot instance
+        #       * 'state'<~String> - state of cancelled spot instance
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CancelSpotInstanceRequests.html]
+        def cancel_spot_instance_requests(spot_instance_request_id)
+          params = Fog::AWS.indexed_param('SpotInstanceRequestId', spot_instance_request_id)
+          request({
+            'Action'    => 'CancelSpotInstanceRequests',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::CancelSpotInstanceRequests.new
+          }.merge!(params))
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_image.rb

@@ -0,0 +1,65 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/create_image'
+
+        # Create a bootable EBS volume AMI
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Instance used to create image.
+        # * name<~Name> - Name to give image.
+        # * description<~Name> - Description of image.
+        # * no_reboot<~Boolean> - Optional, whether or not to reboot the image when making the snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'imageId'<~String> - The ID of the created AMI.
+        #     * 'requestId'<~String> - Id of request.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateImage.html]
+        def create_image(instance_id, name, description, no_reboot = false)
+          request(
+            'Action'            => 'CreateImage',
+            'InstanceId'        => instance_id,
+            'Name'              => name,
+            'Description'       => description,
+            'NoReboot'          => no_reboot.to_s,
+            :parser             => Fog::Parsers::Compute::AWS::CreateImage.new
+          )
+        end
+      end
+
+      class Mock
+        
+        # Usage
+        # 
+        # AWS[:compute].create_image("i-ac65ee8c", "test", "something")
+        #
+        
+        def create_image(instance_id, name, description, no_reboot = false)
+          response = Excon::Response.new
+          if instance_id && !name.empty?
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId' => Fog::AWS::Mock.image_id
+            }
+          else
+            response.status = 400
+            response.body = {
+              'Code' => 'InvalidParameterValue'
+            }
+            if name.empty?
+              response.body['Message'] = "Invalid value '' for name. Must be specified."
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_key_pair.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/create_key_pair'
+
+        # Create a new key pair
+        #
+        # ==== Parameters
+        # * key_name<~String> - Unique name for key pair.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'keyFingerprint'<~String> - SHA-1 digest of DER encoded private key
+        #     * 'keyMaterial'<~String> - Unencrypted encoded PEM private key
+        #     * 'keyName'<~String> - Name of key
+        #     * 'requestId'<~String> - Id of request
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateKeyPair.html]
+        def create_key_pair(key_name)
+          request(
+            'Action'  => 'CreateKeyPair',
+            'KeyName' => key_name,
+            :parser   => Fog::Parsers::Compute::AWS::CreateKeyPair.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_key_pair(key_name)
+          response = Excon::Response.new
+          unless self.data[:key_pairs][key_name]
+            response.status = 200
+            data = {
+              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
+              'keyMaterial'     => Fog::AWS::Mock.key_material,
+              'keyName'         => key_name
+            }
+            self.data[:key_pairs][key_name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+            response
+          else
+            raise Fog::Compute::AWS::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_placement_group.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # Create a new placement group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of the placement group.
+        # * strategy<~String> - Placement group strategy. Valid options in ['cluster']
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreatePlacementGroup.html]
+        def create_placement_group(name, strategy)
+          request(
+            'Action'            => 'CreatePlacementGroup',
+            'GroupName'         => name,
+            'Strategy'          => strategy,
+            :parser             => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_security_group.rb

@@ -0,0 +1,57 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # Create a new security group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of the security group.
+        # * group_description<~String> - Description of group.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateSecurityGroup.html]
+        def create_security_group(name, description)
+          request(
+            'Action'            => 'CreateSecurityGroup',
+            'GroupName'         => name,
+            'GroupDescription'  => description,
+            :parser             => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_security_group(name, description)
+          response = Excon::Response.new
+          unless self.data[:security_groups][name]
+            data = {
+              'groupDescription'  => description,
+              'groupName'         => name,
+              'ipPermissions'     => [],
+              'ownerId'           => self.data[:owner_id]
+            }
+            self.data[:security_groups][name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::Error.new("InvalidGroup.Duplicate => The security group '#{name}' already exists")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_snapshot.rb

@@ -0,0 +1,73 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/create_snapshot'
+
+        # Create a snapshot of an EBS volume and store it in S3
+        #
+        # ==== Parameters
+        # * volume_id<~String> - Id of EBS volume to snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'progress'<~String> - The percentage progress of the snapshot
+        #     * 'requestId'<~String> - id of request
+        #     * 'snapshotId'<~String> - id of snapshot
+        #     * 'startTime'<~Time> - timestamp when snapshot was initiated
+        #     * 'status'<~String> - state of snapshot
+        #     * 'volumeId'<~String> - id of volume snapshot targets
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateSnapshot.html]
+        def create_snapshot(volume_id, description = nil)
+          request(
+            'Action'      => 'CreateSnapshot',
+            'Description' => description,
+            'VolumeId'    => volume_id,
+            :parser       => Fog::Parsers::Compute::AWS::CreateSnapshot.new
+          )
+        end
+
+      end
+
+      class Mock
+        
+        #
+        # Usage
+        #
+        # AWS[:compute].create_snapshot("vol-f7c23423", "latest snapshot")
+        #
+        
+        def create_snapshot(volume_id, description = nil)
+          response = Excon::Response.new
+          if volume = self.data[:volumes][volume_id]
+            response.status = 200
+            snapshot_id = Fog::AWS::Mock.snapshot_id
+            data = {
+              'description' => description,
+              'ownerId'     => self.data[:owner_id],
+              'progress'    => nil,
+              'snapshotId'  => snapshot_id,
+              'startTime'   => Time.now,
+              'status'      => 'pending',
+              'volumeId'    => volume_id,
+              'volumeSize'  => volume['size']
+            }
+            self.data[:snapshots][snapshot_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+            self.data[:snapshots][snapshot_id]['tagSet'] = {}
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_spot_datafeed_subscription.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/spot_datafeed_subscription'
+
+        # Create a spot datafeed subscription
+        #
+        # ==== Parameters
+        # * bucket<~String> - bucket name to store datafeed in
+        # * prefix<~String> - prefix to store data with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'spotDatafeedSubscription'<~Hash>:
+        #       * 'bucket'<~String> - S3 bucket where data is stored
+        #       * 'fault'<~Hash>:
+        #         * 'code'<~String> - fault code
+        #         * 'reason'<~String> - fault reason
+        #       * 'ownerId'<~String> - AWS id of account owner
+        #       * 'prefix'<~String> - prefix for datafeed items
+        #       * 'state'<~String> - state of datafeed subscription
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateSpotDatafeedSubscription.html]
+        def create_spot_datafeed_subscription(bucket, prefix)
+          request(
+            'Action'    => 'CreateSpotDatafeedSubscription',
+            'Bucket'    => bucket,
+            'Prefix'    => prefix,
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::SpotDatafeedSubscription.new
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_tags.rb

@@ -0,0 +1,84 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/basic'
+
+        # 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?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateTags.html]
+        def create_tags(resources, tags)
+          resources = [*resources]
+          for key, value in tags
+            if value.nil?
+              tags[key] = ''
+            end
+          end
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('ResourceId', resources))
+          params.merge!(Fog::AWS.indexed_param('Tag.%d.Key', tags.keys))
+          params.merge!(Fog::AWS.indexed_param('Tag.%d.Value', tags.values))
+          request({
+            'Action'            => 'CreateTags',
+            :parser             => Fog::Parsers::Compute::AWS::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 && self.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|
+            self.data[:tags][key] ||= {}
+            self.data[:tags][key][value] ||= []
+            self.data[:tags][key][value] = self.data[:tags][key][value] & tagged
+            
+            tagged.each {|resource| self.data[:"#{resource['resourceType']}s"][resource['resourceId']]['tagSet'][key] = value}
+          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/brightbox-cli/vendor/fog/lib/fog/compute/requests/aws/create_volume.rb

@@ -0,0 +1,87 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/compute/parsers/aws/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
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateVolume.html]
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          request(
+            'Action'            => 'CreateVolume',
+            'AvailabilityZone'  => availability_zone,
+            'Size'              => size,
+            'SnapshotId'        => snapshot_id,
+            :parser             => Fog::Parsers::Compute::AWS::CreateVolume.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_volume(availability_zone, size, snapshot_id = nil)
+          response = Excon::Response.new
+          if availability_zone && (size || snapshot_id)
+            snapshot = self.data[:snapshots][snapshot_id]
+            if snapshot_id && !snapshot
+              raise Fog::Compute::AWS::NotFound.new("The snapshot '#{snapshot_id}' does not exist.")
+            end
+
+            if snapshot && size && size < snapshot['volumeSize']
+              raise Fog::Compute::AWS::NotFound.new("The snapshot '#{snapshot_id}' has size #{snapshot['volumeSize']} which is greater than #{size}.")
+            elsif snapshot && !size
+              size = snapshot['volumeSize']
+            end
+
+            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
+            }
+            self.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