bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/bin.rb

@@ -0,0 +1,43 @@
+class AWS < Fog::Bin
+  class << self
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :cdn
+          Fog::AWS::CDN.new
+        when :compute
+          Fog::AWS::Compute.new
+        when :ec2
+          location = caller.first
+          warning = "[yellow][WARN] AWS[:ec2] is deprecated, use AWS[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::AWS::Compute.new
+        when :elb
+          Fog::AWS::ELB.new
+        when :eu_storage
+          Fog::AWS::Storage.new(:region => 'eu-west-1')
+        when :iam
+          Fog::AWS::IAM.new
+        when :sdb
+          Fog::AWS::SimpleDB.new
+        when :s3
+          location = caller.first
+          warning = "[yellow][WARN] AWS[:s3] is deprecated, use AWS[:storage] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::AWS::Storage.new
+        when :storage
+          Fog::AWS::Storage.new
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:cdn, :compute, :elb, :iam, :sdb, :storage]
+    end
+
+  end
+end

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

@@ -0,0 +1,99 @@
+module Fog
+  module AWS
+    class CDN < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+
+      model_path 'fog/aws/models/cdn'
+
+      request_path 'fog/aws/requests/cdn'
+      request 'delete_distribution'
+      request 'get_distribution'
+      request 'get_distribution_list'
+      request 'post_distribution'
+      request 'post_invalidation'
+      request 'put_distribution_config'
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, region|
+            hash[region] = Hash.new do |region_hash, key|
+              region_hash[key] = {
+                :buckets => {}
+              }
+            end
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          require 'mime/types'
+          @aws_access_key_id = options[:aws_access_key_id]
+          @data = self.class.data[options[:region]][@aws_access_key_id]
+        end
+
+        def signature(params)
+          "foo"
+        end
+      end
+
+      class Real
+
+        # Initialize connection to Cloudfront
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   cdn = Fog::AWS::CDN.new(
+        #     :aws_access_key_id => your_aws_access_key_id,
+        #     :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * cdn object with connection to aws.
+        def initialize(options={})
+          @aws_access_key_id = options[:aws_access_key_id]
+          @aws_secret_access_key = options[:aws_secret_access_key]
+          @hmac     = Fog::HMAC.new('sha1', @aws_secret_access_key)
+          @host     = options[:host]      || 'cloudfront.amazonaws.com'
+          @path     = options[:path]      || '/'
+          @port     = options[:port]      || 443
+          @scheme   = options[:scheme]    || 'https'
+          @version  = options[:version]  || '2010-11-01'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent] || true)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params, &block)
+          params[:headers] ||= {}
+          params[:headers]['Date'] = Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+          params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature(params)}"
+          params[:path] = "/#{@version}/#{params[:path]}" 
+          @connection.request(params, &block)
+        end
+
+        def signature(params)
+          string_to_sign = params[:headers]['Date']
+          signed_string = @hmac.sign(string_to_sign)
+          signature = Base64.encode64(signed_string).chomp!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,241 @@
+module Fog
+  module AWS
+    class Compute < Fog::Service
+
+      requires   :aws_access_key_id, :aws_secret_access_key
+      recognizes :endpoint, :region, :host, :path, :port, :scheme, :persistent
+
+      model_path 'fog/aws/models/compute'
+      model       :address
+      collection  :addresses
+      model       :flavor
+      collection  :flavors
+      model       :image
+      collection  :images
+      model       :key_pair
+      collection  :key_pairs
+      model       :security_group
+      collection  :security_groups
+      model       :server
+      collection  :servers
+      model       :snapshot
+      collection  :snapshots
+      model       :tag
+      collection  :tags
+      model       :volume
+      collection  :volumes
+
+      require 'fog/aws/parsers/compute/basic'
+
+      request_path 'fog/aws/requests/compute'
+      request :allocate_address
+      request :associate_address
+      request :attach_volume
+      request :authorize_security_group_ingress
+      request :create_image
+      request :create_key_pair
+      request :create_security_group
+      request :create_snapshot
+      request :create_tags
+      request :create_volume
+      request :delete_key_pair
+      request :delete_security_group
+      request :delete_snapshot
+      request :delete_tags
+      request :delete_volume
+      request :deregister_image
+      request :describe_addresses
+      request :describe_availability_zones
+      request :describe_images
+      request :describe_instances
+      request :describe_reserved_instances
+      request :describe_key_pairs
+      request :describe_regions
+      request :describe_security_groups
+      request :describe_snapshots
+      request :describe_tags
+      request :describe_volumes
+      request :detach_volume
+      request :disassociate_address
+      request :get_console_output
+      request :import_key_pair
+      request :modify_image_attributes
+      request :modify_snapshot_attribute
+      request :reboot_instances
+      request :release_address
+      request :register_image
+      request :revoke_security_group_ingress
+      request :run_instances
+      request :terminate_instances
+      request :start_instances
+      request :stop_instances
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, region|
+            owner_id = Fog::AWS::Mock.owner_id
+            hash[region] = Hash.new do |region_hash, key|
+              region_hash[key] = {
+                :deleted_at => {},
+                :addresses  => {},
+                :images     => {},
+                :instances  => {},
+                :key_pairs  => {},
+                :limits     => { :addresses => 5 },
+                :owner_id   => owner_id,
+                :security_groups => {
+                  'default' => {
+                    'groupDescription'  => 'default group',
+                    'groupName'         => 'default',
+                    'ipPermissions'     => [
+                      {
+                        'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
+                        'fromPort'    => -1,
+                        'toPort'      => -1,
+                        'ipProtocol'  => 'icmp',
+                        'ipRanges'    => []
+                      },
+                      {
+                        'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
+                        'fromPort'    => 0,
+                        'toPort'      => 65535,
+                        'ipProtocol'  => 'tcp',
+                        'ipRanges'    => []
+                      },
+                      {
+                        'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
+                        'fromPort'    => 0,
+                        'toPort'      => 65535,
+                        'ipProtocol'  => 'udp',
+                        'ipRanges'    => []
+                      }
+                    ],
+                    'ownerId'           => owner_id
+                  }
+                },
+                :snapshots => {},
+                :volumes => {},
+                :tags => {}
+              }
+            end
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @aws_access_key_id = options[:aws_access_key_id]
+          @region = options[:region] || 'us-east-1'
+          @data = self.class.data[@region][@aws_access_key_id]
+          @owner_id = @data[:owner_id]
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to EC2
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and 
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   sdb = SimpleDB.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1']
+        #
+        # ==== Returns
+        # * EC2 object with connection to aws.
+        def initialize(options={})
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+          if @endpoint = options[:endpoint]
+            endpoint = URI.parse(@endpoint)
+            @host = endpoint.host
+            @path = endpoint.path
+            @port = endpoint.port
+            @scheme = endpoint.scheme
+          else
+            options[:region] ||= 'us-east-1'
+            @host = options[:host] || case options[:region]
+            when 'ap-southeast-1'
+              'ec2.ap-southeast-1.amazonaws.com'
+            when 'eu-west-1'
+              'ec2.eu-west-1.amazonaws.com'
+            when 'us-east-1'
+              'ec2.us-east-1.amazonaws.com'
+            when 'us-west-1'
+              'ec2.us-west-1.amazonaws.com'
+            else
+              raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+            end
+            @path   = options[:path]      || '/'
+            @port   = options[:port]      || 443
+            @scheme = options[:scheme]    || 'https'
+          end
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+        
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :version            => '2010-08-31'
+            }
+          )
+
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::Error => error
+            if match = error.message.match(/<Code>(.*)<\/Code><Message>(.*)<\/Message>/)
+              raise case match[1].split('.').last
+              when 'NotFound'
+                Fog::AWS::Compute::NotFound.slurp(error, match[2])
+              else
+                Fog::AWS::Compute::Error.slurp(error, "#{match[1]} => #{match[2]}")
+              end
+            else
+              raise error
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/ec2.rb

@@ -0,0 +1,15 @@
+module Fog
+  module AWS
+    class EC2
+
+      def self.new(attributes = {})
+        location = caller.first
+        warning = "[yellow][WARN] Fog::AWS::EC2#new is deprecated, use Fog::AWS::Compute#new instead[/]"
+        warning << " [light_black](" << location << ")[/] "
+        Formatador.display_line(warning)
+        Fog::AWS::Compute.new(attributes)
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/elb.rb

@@ -0,0 +1,104 @@
+module Fog
+  module AWS
+    class ELB < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+
+      request_path 'fog/aws/requests/elb'
+      request :create_load_balancer
+      request :delete_load_balancer
+      request :deregister_instances_from_load_balancer
+      request :describe_instance_health
+      request :describe_load_balancers
+      request :disable_availability_zones_for_load_balancer
+      request :enable_availability_zones_for_load_balancer
+      request :register_instances_with_load_balancer
+
+      class Mock
+
+        def initialize(options={})
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to ELB
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   elb = ELB.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1'i, 'ap-southeast-1']
+        #
+        # ==== Returns
+        # * ELB object with connection to AWS.
+        def initialize(options={})
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+          when 'ap-southeast-1'
+            'elasticloadbalancing.ap-southeast-1.amazonaws.com'
+          when 'eu-west-1'
+            'elasticloadbalancing.eu-west-1.amazonaws.com'
+          when 'us-east-1'
+            'elasticloadbalancing.us-east-1.amazonaws.com'
+          when 'us-west-1'
+            'elasticloadbalancing.us-west-1.amazonaws.com'
+          else
+            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+          end
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :version            => '2009-11-25'
+            }
+          )
+
+          response = @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :idempotent => idempotent,
+            :host       => @host,
+            :method     => 'POST',
+            :parser     => parser
+          })
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/iam.rb

@@ -0,0 +1,102 @@
+module Fog
+  module AWS
+    class IAM < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+
+      request_path 'fog/aws/requests/iam'
+      request :add_user_to_group
+      request :create_access_key
+      request :create_group
+      request :create_user
+      request :delete_access_key
+      request :delete_group
+      request :delete_group_policy
+      request :delete_user
+      request :delete_user_policy
+      request :list_access_keys
+      request :list_groups
+      request :list_group_policies
+      request :list_user_policies
+      request :list_users
+      request :put_group_policy
+      request :put_user_policy
+      request :remove_user_from_group
+      request :update_access_key
+
+      class Mock
+
+        def initialize(options={})
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to IAM
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   iam = IAM.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * IAM object with connection to AWS.
+        def initialize(options={})
+          require 'json'
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
+          @host       = options[:host]      || 'iam.amazonaws.com'
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :version            => '2010-05-08'
+            }
+          )
+
+          response = @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :idempotent => idempotent,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :host       => @host,
+            :method     => 'POST',
+            :parser     => parser
+          })
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/address.rb

@@ -0,0 +1,69 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Address < Fog::Model
+
+        identity  :public_ip, :aliases => 'publicIp'
+
+        attribute :server_id, :aliases => 'instanceId'
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with new_record?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :public_ip
+
+          connection.release_address(public_ip)
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            associate(new_server)
+          else
+            disassociate
+          end
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          data = connection.allocate_address.body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        private
+
+        def associate(new_server)
+          if new_record?
+            @server = new_server
+          else
+            @server = nil
+            self.server_id = new_server.id
+            connection.associate_address(@server_id, @public_ip)
+          end
+        end
+
+        def disassociate
+          @server = nil
+          self.server_id = nil
+          unless new_record?
+            connection.disassociate_address(@public_ip)
+          end
+        end
+
+      end
+
+    end
+  end
+end