brightbox-cli 0.13.1 → 0.14.0

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

@@ -1,308 +0,0 @@
-module Fog
-  module Compute
-    class AWS < Fog::Service
-
-      requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :endpoint, :region, :host, :path, :port, :scheme, :persistent
-
-      model_path 'fog/compute/models/aws'
-      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
-      model       :spot_request
-      collection  :spot_requests
-
-      request_path 'fog/compute/requests/aws'
-      request :allocate_address
-      request :associate_address
-      request :attach_volume
-      request :authorize_security_group_ingress
-      request :cancel_spot_instance_requests
-      request :create_image
-      request :create_key_pair
-      request :create_placement_group
-      request :create_security_group
-      request :create_snapshot
-      request :create_spot_datafeed_subscription
-      request :create_tags
-      request :create_volume
-      request :delete_key_pair
-      request :delete_security_group
-      request :delete_placement_group
-      request :delete_snapshot
-      request :delete_spot_datafeed_subscription
-      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_placement_groups
-      request :describe_regions
-      request :describe_reserved_instances_offerings
-      request :describe_security_groups
-      request :describe_snapshots
-      request :describe_spot_datafeed_subscription
-      request :describe_spot_instance_requests
-      request :describe_spot_price_history
-      request :describe_tags
-      request :describe_volumes
-      request :detach_volume
-      request :disassociate_address
-      request :get_console_output
-      request :get_password_data
-      request :import_key_pair
-      request :modify_image_attribute
-      request :modify_instance_attribute
-      request :modify_snapshot_attribute
-      request :purchase_reserved_instances_offering
-      request :reboot_instances
-      request :release_address
-      request :register_image
-      request :request_spot_instances
-      request :revoke_security_group_ingress
-      request :run_instances
-      request :terminate_instances
-      request :start_instances
-      request :stop_instances
-      request :monitor_instances
-      request :unmonitor_instances
-
-      # deprecation
-      class Real
-
-        def modify_image_attributes(*params)
-          Formatador.display_line("[yellow][WARN] modify_image_attributes is deprecated, use modify_image_attribute instead[/] [light_black](#{caller.first})[/]")
-          modify_image_attribute(*params)
-        end
-
-      end
-
-      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  => {},
-                :reserved_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 = nil
-        end
-
-        def initialize(options={})
-          @aws_access_key_id = options[:aws_access_key_id]
-
-          @region = options[:region] || 'us-east-1'
-
-          unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1', 'us-west-1'].include?(@region)
-            raise ArgumentError, "Unknown region: #{@region.inspect}"
-          end
-        end
-
-        def data
-          self.class.data[@region][@aws_access_key_id]
-        end
-
-        def reset_data
-          self.class.data[@region].delete(@aws_access_key_id)
-        end
-
-        def apply_tag_filters(resources, filters)
-          # tag-key: match resources tagged with this key (any value)
-          if filters.has_key?('tag-key')
-            value = filters.delete('tag-key')
-            resources = resources.select{|r| r['tagSet'].has_key?(value)}
-          end
-          
-          # tag-value: match resources tagged with this value (any key)
-          if filters.has_key?('tag-value')
-            value = filters.delete('tag-value')
-            resources = resources.select{|r| r['tagSet'].values.include?(value)}
-          end
-          
-          # tag:key: match resources taged with a key-value pair.  Value may be an array, which is OR'd.
-          tag_filters = {}
-          filters.keys.each do |key| 
-            tag_filters[key.gsub('tag:', '')] = filters.delete(key) if /^tag:/ =~ key
-          end
-          for tag_key, tag_value in tag_filters
-            resources = resources.select{|r| tag_value.include?(r['tagSet'][tag_key])}
-          end
-          
-          resources
-        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', 'ap-northeast-1', 'ap-southeast-1']
-        #
-        # ==== Returns
-        # * EC2 object with connection to aws.
-        def initialize(options={})
-          require 'fog/core/parser'
-
-          @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)
-          @region = options[:region] ||= 'us-east-1'
-
-          if @endpoint = options[:endpoint]
-            endpoint = URI.parse(@endpoint)
-            @host = endpoint.host
-            @path = endpoint.path
-            @port = endpoint.port
-            @scheme = endpoint.scheme
-          else
-            @host = options[:host] || case options[:region]
-            when 'ap-northeast-1'
-              'ec2.ap-northeast-1.amazonaws.com'
-            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 = Fog::AWS.signed_params(
-            params,
-            {
-              :aws_access_key_id  => @aws_access_key_id,
-              :hmac               => @hmac,
-              :host               => @host,
-              :path               => @path,
-              :port               => @port,
-              :version            => '2011-05-15'
-            }
-          )
-
-          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::HTTPStatusError => error
-            if match = error.message.match(/<Code>(.*)<\/Code><Message>(.*)<\/Message>/)
-              raise case match[1].split('.').last
-              when 'NotFound', 'Unknown'
-                Fog::Compute::AWS::NotFound.slurp(error, match[2])
-              else
-                Fog::Compute::AWS::Error.slurp(error, "#{match[1]} => #{match[2]}")
-              end
-            else
-              raise error
-            end
-          end
-
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/bluebox.rb

@@ -1,94 +0,0 @@
-module Fog
-  module Compute
-    class Bluebox < Fog::Service
-
-      requires :bluebox_api_key, :bluebox_customer_id
-      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
-
-      model_path 'fog/compute/models/bluebox'
-      model       :flavor
-      collection  :flavors
-      model       :image
-      collection  :images
-      model       :server
-      collection  :servers
-
-      request_path 'fog/compute/requests/bluebox'
-      request :create_block
-      request :destroy_block
-      request :get_block
-      request :get_blocks
-      request :get_product
-      request :get_products
-      request :get_template
-      request :get_templates
-      request :reboot_block
-
-      class Mock
-
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @bluebox_api_key = options[:bluebox_api_key]
-        end
-
-        def data
-          self.class.data[@bluebox_api_key]
-        end
-
-        def reset_data
-          self.class.data.delete(@bluebox_api_key)
-        end
-
-      end
-
-      class Real
-
-        def initialize(options={})
-          require 'multi_json'
-          @bluebox_api_key      = options[:bluebox_api_key]
-          @bluebox_customer_id  = options[:bluebox_customer_id]
-          @host   = options[:bluebox_host]    || "boxpanel.bluebox.net"
-          @port   = options[:bluebox_port]    || 443
-          @scheme = options[:bluebox_scheme]  || 'https'
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-          params[:headers].merge!({
-            'Authorization' => "Basic #{Base64.encode64([@bluebox_customer_id, @bluebox_api_key].join(':')).delete("\r\n")}"
-          })
-
-          begin
-            response = @connection.request(params.merge!({:host => @host}))
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::Compute::Bluebox::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-          unless response.body.empty?
-            response.body = MultiJson.decode(response.body)
-          end
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/compute/brightbox.rb

@@ -1,165 +0,0 @@
-module Fog
-  module Compute
-    class Brightbox < Fog::Service
-
-      API_URL = "https://api.gb1.brightbox.com/"
-
-      requires :brightbox_client_id, :brightbox_secret
-      recognizes :brightbox_auth_url, :brightbox_api_url
-
-      model_path 'fog/compute/models/brightbox'
-      model       :account # Singular resource, no collection
-      collection  :servers
-      model       :server
-      collection  :flavors
-      model       :flavor
-      collection  :images
-      model       :image
-      collection  :load_balancers
-      model       :load_balancer
-      collection  :zones
-      model       :zone
-      collection  :cloud_ips
-      model       :cloud_ip
-      collection  :users
-      model       :user
-
-      request_path 'fog/compute/requests/brightbox'
-      request :activate_console_server
-      request :add_listeners_load_balancer
-      request :add_nodes_load_balancer
-      request :add_servers_server_group
-      request :create_api_client
-      request :create_cloud_ip
-      request :create_image
-      request :create_load_balancer
-      request :create_server
-      request :create_server_group
-      request :destroy_api_client
-      request :destroy_cloud_ip
-      request :destroy_image
-      request :destroy_load_balancer
-      request :destroy_server
-      request :destroy_server_group
-      request :get_account
-      request :get_api_client
-      request :get_cloud_ip
-      request :get_image
-      request :get_interface
-      request :get_load_balancer
-      request :get_server
-      request :get_server_group
-      request :get_server_type
-      request :get_user
-      request :get_zone
-      request :list_api_clients
-      request :list_cloud_ips
-      request :list_images
-      request :list_load_balancers
-      request :list_server_groups
-      request :list_server_types
-      request :list_servers
-      request :list_users
-      request :list_zones
-      request :map_cloud_ip
-      request :move_servers_server_group
-      request :remove_listeners_load_balancer
-      request :remove_nodes_load_balancer
-      request :remove_servers_server_group
-      request :reset_ftp_password_account
-      request :resize_server
-      request :shutdown_server
-      request :snapshot_server
-      request :start_server
-      request :stop_server
-      request :unmap_cloud_ip
-      request :update_account
-      request :update_api_client
-      request :update_image
-      request :update_load_balancer
-      request :update_server
-      request :update_server_group
-      request :update_user
-
-      class Mock
-
-        def initialize(options)
-          @brightbox_client_id = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
-          @brightbox_secret = options[:brightbox_secret] || Fog.credentials[:brightbox_secret]
-        end
-
-        def request(options)
-          raise "Not implemented"
-        end
-      end
-
-      class Real
-
-        def initialize(options)
-          require 'multi_json'
-          # Currently authentication and api endpoints are the same but may change
-          @auth_url = options[:brightbox_auth_url] || Fog.credentials[:brightbox_auth_url] || API_URL
-          @api_url = options[:brightbox_api_url] || Fog.credentials[:brightbox_api_url] || API_URL
-          @brightbox_client_id = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
-          @brightbox_secret = options[:brightbox_secret] || Fog.credentials[:brightbox_secret]
-          @connection = Fog::Connection.new(@api_url)
-        end
-
-        def request(method, url, expected_responses, options = nil)
-          request_options = {
-            :method   => method.to_s.upcase,
-            :path     => url,
-            :expects  => expected_responses
-          }
-          request_options[:body] = MultiJson.encode(options) unless options.nil?
-          make_request(request_options)
-        end
-
-        def account
-          Fog::Compute::Brightbox::Account.new(get_account)
-        end
-
-      private
-        def get_oauth_token(options = {})
-          auth_url = options[:brightbox_auth_url] || @auth_url
-
-          connection = Fog::Connection.new(auth_url)
-          @authentication_body = MultiJson.encode({'client_id' => @brightbox_client_id, 'grant_type' => 'none'})
-
-          response = connection.request({
-            :path => "/token",
-            :expects  => 200,
-            :headers  => {
-              'Authorization' => "Basic " + Base64.encode64("#{@brightbox_client_id}:#{@brightbox_secret}").chomp,
-              'Content-Type' => 'application/json'
-            },
-            :method   => 'POST',
-            :body     => @authentication_body
-          })
-          @oauth_token = MultiJson.decode(response.body)["access_token"]
-          return @oauth_token
-        end
-
-        def make_request(params)
-          begin
-            get_oauth_token if @oauth_token.nil?
-            response = authenticated_request(params)
-          rescue Excon::Errors::Unauthorized => e
-            get_oauth_token
-            response = authenticated_request(params)
-          end
-          unless response.body.empty?
-            response = MultiJson.decode(response.body)
-          end
-        end
-
-        def authenticated_request(options)
-          headers = options[:headers] || {}
-          headers.merge!("Authorization" => "OAuth #{@oauth_token}", "Content-Type" => "application/json")
-          options[:headers] = headers
-          @connection.request(options)
-        end
-      end
-    end
-  end
-end