bbcloud 0.8.1 → 0.8.2

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

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

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

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

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

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

@@ -1,56 +0,0 @@
-require 'fog/core/collection'
-require 'fog/aws/models/compute/address'
-
-module Fog
-  module AWS
-    class Compute
-
-      class Addresses < Fog::Collection
-
-        attribute :filters
-        attribute :server
-
-        model Fog::AWS::Compute::Address
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        def all(filters = filters)
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('public-ip' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'public-ip' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_addresses(filters).body
-          load(
-            data['addressesSet'].map do |address|
-              address.reject {|key, value| value.nil? || value.empty? }
-            end
-          )
-          if server
-            self.replace(self.select {|address| address.server_id == server.id})
-          end
-          self
-        end
-
-        def get(public_ip)
-          if public_ip
-            self.class.new(:connection => connection).all('public-ip' => public_ip).first
-          end
-        end
-
-        def new(attributes = {})
-          if server
-            super({ :server => server }.merge!(attributes))
-          else
-            super(attributes)
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class Compute
-
-      class Flavor < Fog::Model
-
-        identity :id
-
-        attribute :bits
-        attribute :cores
-        attribute :disk
-        attribute :name
-        attribute :ram
-
-      end
-
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'fog/core/collection'
-require 'fog/aws/models/compute/flavor'
-
-module Fog
-  module AWS
-    class Compute
-
-      class Flavors < Fog::Collection
-
-        model Fog::AWS::Compute::Flavor
-
-        def all
-          data = [
-            { :bits => 0,  :cores =>   2,  :disk => 0,    :id =>  't1.micro',   :name => 'Micro Instance',       :ram => 613},
-
-            { :bits => 32, :cores =>   1,  :disk => 160,  :id =>  'm1.small',   :name => 'Small Instance',       :ram => 1740.8},
-            { :bits => 64, :cores =>   4,  :disk => 850,  :id =>  'm1.large',   :name => 'Large Instance',       :ram => 7680},
-            { :bits => 64, :cores =>   8,  :disk => 1690, :id =>  'm1.xlarge',  :name => 'Extra Large Instance', :ram => 15360},
-
-            { :bits => 32, :cores =>   5,  :disk => 350,  :id =>  'c1.medium',  :name => 'High-CPU Medium',      :ram => 1740.8},
-            { :bits => 64, :cores =>  20,  :disk => 1690, :id =>  'c1.xlarge',  :name => 'High-CPU Extra Large', :ram => 7168},
-
-            { :bits => 64, :cores =>  6.5, :disk => 420,  :id =>  'm2.xlarge',  :name => 'High-Memory Extra Large',           :ram => 17510.4},
-            { :bits => 64, :cores =>   13, :disk => 850,  :id =>  'm2.2xlarge', :name => 'High Memory Double Extra Large',    :ram => 35020.8},
-            { :bits => 64, :cores =>   26, :disk => 1690, :id =>  'm2.4xlarge', :name => 'High Memory Quadruple Extra Large', :ram => 70041.6},
-
-            { :bits => 64, :cores => 33.5, :disk => 1690, :id => 'cc1.4xlarge', :name => 'Cluster Compute Quadruple Extra Large', :ram => 23552},
-            { :bits => 64, :cores => 33.5, :disk => 1690, :id => 'cg1.4xlarge', :name => 'Cluster GPU Quadruple Extra Large',     :ram => 22528}
-          ]
-          load(data)
-          self
-        end
-
-        def get(flavor_id)
-          self.class.new(:connection => connection).all.detect {|flavor| flavor.id == flavor_id}
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class Compute
-
-      class Image < Fog::Model
-
-        identity :id,                     :aliases => 'imageId'
-
-        attribute :architecture
-        attribute :block_device_mapping,  :aliases => 'blockDeviceMapping'
-        attribute :location,              :aliases => 'imageLocation'
-        attribute :owner_id,              :aliases => 'imageOwnerId'
-        attribute :state,                 :aliases => 'imageState'
-        attribute :type,                  :aliases => 'imageType'
-        attribute :is_public,             :aliases => 'isPublic'
-        attribute :kernel_id,             :aliases => 'kernelId'
-        attribute :platform
-        attribute :product_codes,         :aliases => 'productCodes'
-        attribute :ramdisk_id,            :aliases => 'ramdiskId'
-        attribute :root_device_type,      :aliases => 'rootDeviceType'
-        attribute :root_device_name,      :aliases => 'rootDeviceName'
-        attribute :tags,                  :aliases => 'tagSet'
-
-        def deregister(delete_snapshot = false)
-          connection.deregister_image(id)
-
-          if(delete_snapshot && root_device_type == "ebs")
-            block_device = block_device_mapping.select {|block_device| block_device['deviceName'] == root_device_name}
-            @connection.snapshots.new(:id => block_device['snapshotId']).destroy
-          else
-            true
-          end
-        end
-
-      end
-
-    end
-  end
-end