bbcloud 0.8.1 → 0.8.2

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

@@ -1,83 +0,0 @@
-require 'base64'
-require 'cgi'
-require 'excon'
-require 'formatador'
-require 'time'
-
-__DIR__ = File.dirname(__FILE__)
-
-$LOAD_PATH.unshift __DIR__ unless
-  $LOAD_PATH.include?(__DIR__) ||
-  $LOAD_PATH.include?(File.expand_path(__DIR__))
-
-require 'fog/core'
-
-module Fog
-
-  @mocking = false
-
-  unless const_defined?(:VERSION)
-    VERSION = '0.3.23'
-  end
-
-  module Mock
-    @delay = 1
-    def self.delay
-      @delay
-    end
-
-    def self.delay=(new_delay)
-      raise ArgumentError, "delay must be non-negative" unless new_delay >= 0
-      @delay = new_delay
-    end
-
-    def self.not_implemented
-      raise Fog::Errors::MockNotImplemented.new("Contributions welcome!")
-    end
-
-  end
-
-  def self.bin
-    @bin ||= false
-  end
-
-  def self.bin=(new_bin)
-    @bin = new_bin
-  end
-
-  def self.mock!
-    @mocking = true
-  end
-
-  def self.mocking?
-    !!@mocking
-  end
-
-  def self.wait_for(timeout=600, interval=1, &block)
-    duration = 0
-    start = Time.now
-    until yield || duration > timeout
-      sleep(interval)
-      duration = Time.now - start
-    end
-    if duration > timeout
-      false
-    else
-      { :duration => duration }
-    end
-  end
-  
-end
-
-require 'fog/aws'
-require 'fog/bluebox'
-require 'fog/brightbox'
-require 'fog/go_grid'
-require 'fog/linode'
-require 'fog/local'
-require 'fog/new_servers'
-require 'fog/rackspace'
-require 'fog/slicehost'
-require 'fog/terremark'
-require 'fog/vcloud'
-require 'fog/google'

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

@@ -1,214 +0,0 @@
-require 'nokogiri'
-require 'fog/core/parser'
-
-module Fog
-  module AWS
-
-    extend Fog::Provider
-
-    service_path 'fog/aws'
-    service 'cdn'
-    service 'compute'
-    service 'ec2'
-    service 'elb'
-    service 'iam'
-    service 's3'
-    service 'simpledb'
-    service 'storage'
-
-    def self.indexed_param(key, values)
-      params = {}
-      unless key.include?('%d')
-        key << '.%d'
-      end
-      [*values].each_with_index do |value, index|
-        params[format(key, index + 1)] = value
-      end
-      params
-    end
-
-    def self.indexed_filters(filters)
-      params = {}
-      filters.keys.each_with_index do |key, key_index|
-        key_index += 1
-        params[format('Filter.%d.Name', key_index)] = key
-        [*filters[key]].each_with_index do |value, value_index|
-          value_index += 1
-          params[format('Filter.%d.Value.%d', key_index, value_index)] = value
-        end
-      end
-      params
-    end
-
-    def self.signed_params(params, options = {})
-      params.merge!({
-        'AWSAccessKeyId'    => options[:aws_access_key_id],
-        'SignatureMethod'   => 'HmacSHA256',
-        'SignatureVersion'  => '2',
-        'Timestamp'         => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
-        'Version'           => options[:version]
-      })
-
-      body = ''
-      for key in params.keys.sort
-        unless (value = params[key]).nil?
-          body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
-        end
-      end
-      string_to_sign = "POST\n#{options[:host]}\n#{options[:path]}\n" << body.chop
-      signed_string = options[:hmac].sign(string_to_sign)
-      body << "Signature=#{CGI.escape(Base64.encode64(signed_string).chomp!).gsub(/\+/, '%20')}"
-
-      body
-    end
-
-    class Mock
-
-      def self.availability_zone
-        "us-east-1" << random_selection('abcd', 1)
-      end
-
-      def self.box_usage
-        sprintf("%0.10f", rand / 100).to_f
-      end
-
-      def self.dns_name_for(ip_address)
-        "ec2-#{ip_address.gsub('.','-')}.compute-1.amazonaws.com"
-      end
-
-      def self.private_dns_name_for(ip_address)
-        "ip-#{ip_address.gsub('.','-')}.ec2.internal"
-      end
-
-      def self.etag
-        hex(32)
-      end
-
-      def self.image
-        path = []
-        (rand(3) + 2).times do
-          path << letters(rand(9) + 8)
-        end
-        {
-          "imageOwnerId"   => letters(rand(5) + 4),
-          "blockDeviceMapping" => [],
-          "productCodes"   => [],
-          "kernelId"       => kernel_id,
-          "ramdiskId"      => ramdisk_id,
-          "imageState"     => "available",
-          "imageId"        => image_id,
-          "architecture"   => "i386",
-          "isPublic"       => true,
-          "imageLocation"  => path.join('/'),
-          "imageType"      => "machine",
-          "rootDeviceType" => ["ebs","instance-store"][rand(2)],
-          "rootDeviceName" => "/dev/sda1"
-        }
-      end
-
-      def self.image_id
-        "ami-#{hex(8)}"
-      end
-
-      def self.key_fingerprint
-        fingerprint = []
-        20.times do
-          fingerprint << hex(2)
-        end
-        fingerprint.join(':')
-      end
-
-      def self.instance_id
-        "i-#{hex(8)}"
-      end
-
-      def self.ip_address
-        ip = []
-        4.times do
-          ip << numbers(rand(3) + 1).to_i.to_s # remove leading 0
-        end
-        ip.join('.')
-      end
-
-      def self.kernel_id
-        "aki-#{hex(8)}"
-      end
-
-      def self.key_material
-        key_material = ['-----BEGIN RSA PRIVATE KEY-----']
-        20.times do
-          key_material << base64(76)
-        end
-        key_material << base64(67) + '='
-        key_material << '-----END RSA PRIVATE KEY-----'
-        key_material.join("\n")
-      end
-
-      def self.owner_id
-        numbers(12)
-      end
-
-      def self.ramdisk_id
-        "ari-#{hex(8)}"
-      end
-
-      def self.request_id
-        request_id = []
-        request_id << hex(8)
-        3.times do
-          request_id << hex(4)
-        end
-        request_id << hex(12)
-        request_id.join('-')
-      end
-
-      def self.reservation_id
-        "r-#{hex(8)}"
-      end
-
-      def self.snapshot_id
-        "snap-#{hex(8)}"
-      end
-
-      def self.volume_id
-        "vol-#{hex(8)}"
-      end
-
-      private
-      
-      def self.random_selection(characters, length)
-        selection = ''
-        length.times do
-          position = rand(characters.length)
-          selection << characters[position..position]
-        end
-        selection
-      end
-
-      def self.letters(length)
-        random_selection(
-          'abcdefghijklmnopqrstuvwxyz',
-          length
-        )
-      end
-
-      def self.numbers(length)
-        max = ('9' * length).to_i
-        rand(max).to_s
-      end
-
-      def self.hex(length)
-        max = ('f' * length).to_i(16)
-        rand(max).to_s(16).rjust(length, '0')
-      end
-
-      def self.base64(length)
-        random_selection(
-          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-          length
-        )
-      end
-
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,241 +0,0 @@
-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