bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/cdn/post_invalidation.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class CDN
+      class Real
+
+        require 'fog/aws/parsers/cdn/post_invalidation'
+
+        # List information about distributions in CloudFront
+        #
+        # ==== Parameters
+        # * distribution_id<~String> - Id of distribution for invalidations
+        # * paths<~Array> - Array of string paths to objects to invalidate
+        # * caller_reference<~String> - Used to prevent replay, defaults to Time.now.to_i.to_s
+        #
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Id'<~String> - Id of invalidation
+        #     * 'Status'<~String> - Status of invalidation
+        #     * 'CreateTime'<~Integer> - Time of invalidation creation
+        #     * 'InvalidationBatch'<~Array>:
+        #       * 'Path'<~Array> - Array of strings of objects to invalidate
+        #       * 'CallerReference'<~String> - Used to prevent replay, defaults to Time.now.to_i.to_s
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudFront/latest/APIReference/CreateInvalidation.html
+
+        def post_invalidation(distribution_id, paths, caller_reference = Time.now.to_i.to_s)
+          body = '<?xml version="1.0" encoding="UTF-8"?>'
+          body << "<InvalidationBatch>"
+          for path in [*paths]
+            body << "<Path>" << path << "</Path>"
+          end
+          body << "<CallerReference>" << caller_reference << "</CallerReference>"
+          body << "</InvalidationBatch>"
+          request({
+            :body       => body,
+            :expects    => 201,
+            :headers    => {'Content-Type' => 'text/xml'},
+            :idempotent => true,
+            :method     => 'POST',
+            :parser     => Fog::Parsers::AWS::CDN::PostInvalidation.new,
+            :path       => "/distribution/#{distribution_id}/invalidation"
+          })
+        end
+
+      end
+
+      class Mock # :nodoc:all
+
+        def post_invalidation(distribution_id, paths, caller_reference = Time.now.to_i.to_s)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/cdn/put_distribution_config.rb

@@ -0,0 +1,102 @@
+module Fog
+  module AWS
+    class CDN
+      class Real
+
+        require 'fog/aws/parsers/cdn/distribution'
+
+        # update a distribution in CloudFront
+        #
+        # ==== Parameters
+        # * distribution_id<~String> - Id of distribution to update config for
+        # * options<~Hash> - config for distribution.  Defaults to {}.
+        #   REQUIRED:
+        #   * 'S3Origin'<~Hash>:
+        #     * 'DNSName'<~String> - origin to associate with distribution, ie 'mybucket.s3.amazonaws.com'
+        #     * 'OriginAccessIdentity'<~String> - Optional: Used when serving private content
+        #   or
+        #   * 'CustomOrigin'<~Hash>:
+        #     * 'DNSName'<~String> - origin to associate with distribution, ie 'www.example.com'
+        #     * 'HTTPPort'<~Integer> - HTTP port of origin, in [80, 443] or (1024...65535)
+        #     * 'HTTPSPort'<~Integer> - HTTPS port of origin, in [80, 443] or (1024...65535)
+        #     * 'OriginProtocolPolicy'<~String> - Policy on using http vs https, in ['http-only', 'match-viewer']
+        #   OPTIONAL:
+        #   * 'CallerReference'<~String> - Used to prevent replay, defaults to Time.now.to_i.to_s
+        #   * 'Comment'<~String> - Optional comment about distribution
+        #   * 'CNAME'<~Array> - Optional array of strings to set as CNAMEs
+        #   * 'DefaultRootObject'<~String> - Optional default object to return for '/'
+        #   * 'Enabled'<~Boolean> - Whether or not distribution should accept requests, defaults to true
+        #   * 'Logging'<~Hash>: Optional logging config
+        #     * 'Bucket'<~String> - Bucket to store logs in, ie 'mylogs.s3.amazonaws.com'
+        #     * 'Prefix'<~String> - Optional prefix for log filenames, ie 'myprefix/'
+        #   * 'OriginAccessIdentity'<~String> - Used for serving private content, in format 'origin-access-identity/cloudfront/ID'
+        #   * 'RequiredProtocols'<~String> - Optional, set to 'https' to force https connections
+        #   * 'TrustedSigners'<~Array> - Optional grant of rights to up to 5 aws accounts to generate signed URLs for private content, elements are either 'Self' for your own account or an AWS Account Number
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'DomainName'<~String>: Domain name of distribution
+        #     * 'Id'<~String> - Id of distribution
+        #     * 'LastModifiedTime'<~String> - Timestamp of last modification of distribution
+        #     * 'Status'<~String> - Status of distribution
+        #     * 'DistributionConfig'<~Array>:
+        #       * 'CallerReference'<~String> - Used to prevent replay, defaults to Time.now.to_i.to_s
+        #       * 'CNAME'<~Array> - array of associated cnames
+        #       * 'Comment'<~String> - comment associated with distribution
+        #       * 'Enabled'<~Boolean> - whether or not distribution is enabled
+        #       * 'Logging'<~Hash>:
+        #         * 'Bucket'<~String> - bucket logs are stored in
+        #         * 'Prefix'<~String> - prefix logs are stored with
+        #       * 'Origin'<~String> - s3 origin bucket
+        #       * 'TrustedSigners'<~Array> - trusted signers
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudFront/latest/APIReference/CreateDistribution.html
+
+        def put_distribution_config(distribution_id, etag, options = {})
+          data = '<?xml version="1.0" encoding="UTF-8"?>'
+          data << "<DistributionConfig xmlns=\"http://cloudfront.amazonaws.com/doc/#{@version}/\">"
+          for key, value in options
+            case value
+            when Array
+              for item in value
+                data << "<#{key}>#{item}</#{key}>"
+              end
+            when Hash
+              data << "<#{key}>"
+              for inner_key, inner_value in value
+                data << "<#{inner_key}>#{inner_value}</#{inner_key}>"
+              end
+              data << "</#{key}>"
+            else
+              data << "<#{key}>#{value}</#{key}>"
+            end
+          end
+          data << "</DistributionConfig>"
+          request({
+            :body       => data,
+            :expects    => 200,
+            :headers    => {
+              'Content-Type'  => 'text/xml',
+              'If-Match'      => etag
+            },
+            :idempotent => true,
+            :method     => 'PUT',
+            :parser     => Fog::Parsers::AWS::CDN::Distribution.new,
+            :path       => "/distribution/#{distribution_id}/config"
+          })
+        end
+
+      end
+
+      class Mock # :nodoc:all
+
+        def put_distribution_config(distribution_id, etag, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/allocate_address'
+
+        # Acquire an elastic IP address.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'publicIp'<~String> - The acquired address
+        #     * 'requestId'<~String> - Id of the request
+        def allocate_address
+          request(
+            'Action'  => 'AllocateAddress',
+            :parser   => Fog::Parsers::AWS::Compute::AllocateAddress.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def allocate_address
+          response = Excon::Response.new
+          if describe_addresses.body['addressesSet'].size < @data[:limits][:addresses]
+            response.status = 200
+            public_ip = Fog::AWS::Mock.ip_address
+            data ={
+              'instanceId' => nil,
+              'publicIp'   => public_ip
+            }
+            @data[:addresses][public_ip] = data
+            response.body = {
+              'publicIp'  => public_ip,
+              'requestId' => Fog::AWS::Mock.request_id
+            }
+            response
+          else
+            response.status = 400
+            response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>AddressLimitExceeded</Code><Message>Too many addresses allocated</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestID></Response>"
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Associate an elastic IP address with an instance
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to associate address with
+        # * public_ip<~String> - Public ip to assign to instance
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def associate_address(instance_id, public_ip)
+          request(
+            'Action'      => 'AssociateAddress',
+            'InstanceId'  => instance_id,
+            'PublicIp'    => public_ip,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def associate_address(instance_id, public_ip)
+          response = Excon::Response.new
+          response.status = 200
+          instance = @data[:instances][instance_id]
+          address = @data[:addresses][public_ip]
+          if instance && address
+            address['instanceId'] = instance_id
+            instance['originalIpAddress'] = instance['ipAddress']
+            instance['ipAddress'] = public_ip
+            instance['dnsName'] = Fog::AWS::Mock.dns_name_for(public_ip)
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          elsif !instance
+            raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
+          elsif !address
+            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/attach_volume.rb

@@ -0,0 +1,81 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/attach_volume'
+
+        # Attach an Amazon EBS volume with a running instance, exposing as specified device
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to associate volume with
+        # * volume_id<~String> - Id of amazon EBS volume to associate with instance
+        # * device<~String> - Specifies how the device is exposed to the instance (e.g. "/dev/sdh")
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'attachTime'<~Time> - Time of attachment was initiated at
+        #     * 'device'<~String> - Device as it is exposed to the instance
+        #     * 'instanceId'<~String> - Id of instance for volume
+        #     * 'requestId'<~String> - Id of request
+        #     * 'status'<~String> - Status of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        def attach_volume(instance_id, volume_id, device)
+          request(
+            'Action'      => 'AttachVolume',
+            'VolumeId'    => volume_id,
+            'InstanceId'  => instance_id,
+            'Device'      => device,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::Compute::AttachVolume.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def attach_volume(instance_id, volume_id, device)
+          response = Excon::Response.new
+          if instance_id && volume_id && device
+            response.status = 200
+            instance = @data[:instances][instance_id]
+            volume = @data[:volumes][volume_id]
+            if instance && volume
+              data = {
+                'attachTime'  => Time.now,
+                'device'      => device,
+                'instanceId'  => instance_id,
+                'status'      => 'attaching',
+                'volumeId'    => volume_id
+              }
+              volume['attachmentSet'] = [data]
+              volume['status'] = 'attaching'
+              response.status = 200
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id
+              }.merge!(data)
+              response
+            elsif !instance
+              raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist.")
+            elsif !volume
+              raise Fog::AWS::Compute::NotFound.new("The volume '#{volume_id}' does not exist.")
+            end
+          else
+            message = 'MissingParameter => '
+            if !instance_id
+              message << 'The request must contain the parameter instance_id'
+            elsif !volume_id
+              message << 'The request must contain the parameter volume_id'
+            else
+              message << 'The request must contain the parameter device'
+            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/authorize_security_group_ingress.rb

@@ -0,0 +1,86 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # Add permissions to 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 authorize_security_group_ingress(options = {})
+          request({
+            'Action'    => 'AuthorizeSecurityGroupIngress',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def authorize_security_group_ingress(options = {})
+          response = Excon::Response.new
+          group = @data[:security_groups][options['GroupName']]
+
+          if group
+            group['ipPermissions'] ||= []
+            if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
+              ['tcp', 'udp'].each do |protocol|
+                group['ipPermissions'] << {
+                  'groups'      => [{'groupName' => options['GroupName'], 'userId' => @owner_id}],
+                  'fromPort'    => 1,
+                  'ipRanges'    => [],
+                  'ipProtocol'  => protocol,
+                  'toPort'      => 65535
+                }
+              end
+              group['ipPermissions'] << {
+                'groups'      => [{'groupName' => options['GroupName'], 'userId' => @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::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/create_image.rb

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/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.
+        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::AWS::Compute::CreateImage.new
+          )
+        end
+      end
+
+      class Mock
+
+        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/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/create_key_pair.rb

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/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
+        def create_key_pair(key_name)
+          request(
+            'Action'  => 'CreateKeyPair',
+            'KeyName' => key_name,
+            :parser   => Fog::Parsers::AWS::Compute::CreateKeyPair.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_key_pair(key_name)
+          response = Excon::Response.new
+          unless @data[:key_pairs][key_name]
+            response.status = 200
+            data = {
+              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
+              'keyMaterial'     => Fog::AWS::Mock.key_material,
+              '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/create_security_group.rb

@@ -0,0 +1,53 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        # 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?
+        def create_security_group(name, description)
+          request(
+            'Action'            => 'CreateSecurityGroup',
+            'GroupName'         => name,
+            'GroupDescription'  => CGI.escape(description),
+            :parser             => Fog::Parsers::AWS::Compute::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_security_group(name, description)
+          response = Excon::Response.new
+          unless @data[:security_groups][name]
+            data = {
+              'groupDescription'  => CGI.escape(description).gsub('%20', '+'),
+              'groupName'         => CGI.escape(name).gsub('%20', '+'),
+              'ipPermissions'     => [],
+              'ownerId'           => @owner_id
+            }
+            @data[:security_groups][name] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::Compute::Error.new("InvalidGroup.Duplicate => The security group '#{name}' already exists")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/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
+        def create_snapshot(volume_id, description = nil)
+          request(
+            'Action'      => 'CreateSnapshot',
+            'Description' => description,
+            'VolumeId'    => volume_id,
+            :parser       => Fog::Parsers::AWS::Compute::CreateSnapshot.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_snapshot(volume_id, description = nil)
+          response = Excon::Response.new
+          if volume = @data[:volumes][volume_id]
+            response.status = 200
+            snapshot_id = Fog::AWS::Mock.snapshot_id
+            data = {
+              'description' => description,
+              'ownerId'     => @owner_id,
+              'progress'    => nil,
+              'snapshotId'  => snapshot_id,
+              'startTime'   => Time.now,
+              'status'      => 'pending',
+              'volumeId'    => volume_id,
+              'volumeSize'  => volume['size']
+            }
+            @data[:snapshots][snapshot_id] = data
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+            @data[:snapshots][snapshot_id]['tagSet'] = {}
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end