phpfog-fog 0.4.1

data/lib/fog/compute/aws.rb

@@ -0,0 +1,273 @@
+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
+
+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
+      recognizes :provider # remove post deprecation
+
+      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
+
+      require 'fog/compute/parsers/aws/basic'
+
+      request_path 'fog/compute/requests/aws'
+      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={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::AWS::Compute.new is deprecated, use Fog::Compute.new(:provider => 'AWS') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @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={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::AWS::Compute.new is deprecated, use Fog::Compute.new(:provider => 'AWS') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @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,
+              :port               => @port,
+              :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::HTTPStatusError => 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/fog/compute/bluebox.rb

@@ -0,0 +1,104 @@
+module Fog
+  module Bluebox
+    class Compute < Fog::Service
+
+      requires :bluebox_api_key, :bluebox_customer_id
+      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
+      recognizes :provider # remove post deprecation
+
+      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(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Bluebox::Compute.new is deprecated, use Fog::Compute.new(:provider => 'Bluebox') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @bluebox_api_key = options[:bluebox_api_key]
+          @data = self.class.data[@bluebox_api_key]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Bluebox::Compute.new is deprecated, use Fog::Compute.new(:provider => 'Bluebox') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          require '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::Bluebox::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/brightbox.rb

@@ -0,0 +1,159 @@
+module Fog
+  module Brightbox
+    class Compute < Fog::Service
+
+      API_URL = "https://api.gb1.brightbox.com/"
+
+      requires :brightbox_client_id, :brightbox_secret
+      recognizes :brightbox_auth_url, :brightbox_api_url
+      recognizes :provider # remove post deprecation
+
+      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 :add_nodes_load_balancer
+      request :create_api_client
+      request :create_cloud_ip
+      request :create_image
+      request :create_load_balancer
+      request :create_server
+      request :destroy_api_client
+      request :destroy_cloud_ip
+      request :destroy_image
+      request :destroy_load_balancer
+      request :destroy_server
+      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_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_types
+      request :list_servers
+      request :list_users
+      request :list_zones
+      request :map_cloud_ip
+      request :remove_nodes_load_balancer
+      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_user
+
+      class Mock
+
+        def initialize(options)
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Brightbox::Compute.new is deprecated, use Fog::Compute.new(:provider => 'Brightbox') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @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)
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Brightbox::Compute.new is deprecated, use Fog::Compute.new(:provider => 'Brightbox') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          require "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(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 = JSON.parse(response.body)
+          end
+        end
+
+        def account
+          Fog::Brightbox::Compute::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 = {'client_id' => @brightbox_client_id, 'grant_type' => 'none'}.to_json
+
+          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 = JSON.parse(response.body)["access_token"]
+          return @oauth_token
+        end
+
+        def authenticated_request(options)
+          headers = options[:headers] || {}
+          headers.merge!("Authorization" => "OAuth #{@oauth_token}")
+          options[:headers] = headers
+          @connection.request(options)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/go_grid.rb

@@ -0,0 +1,118 @@
+module Fog
+  module GoGrid
+    class Compute < Fog::Service
+
+      requires :go_grid_api_key, :go_grid_shared_secret
+      recognizes :host, :path, :port, :scheme, :persistent
+      recognizes :provider # remove post deprecation
+
+      model_path 'fog/compute/models/go_grid'
+      model         :image
+      collection    :images
+      model         :server
+      collection    :servers
+
+      request_path 'fog/compute/requests/go_grid'
+      request :common_lookup_list
+      request :grid_image_get
+      request :grid_image_list
+      request :grid_ip_list
+      request :grid_loadbalancer_list
+      request :grid_server_add
+      request :grid_server_delete
+      request :grid_server_get
+      request :grid_server_list
+      request :grid_server_power
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::GoGrid::Compute.new is deprecated, use Fog::Compute.new(:provider => 'GoGrid') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @go_grid_api_key = options[:go_grid_api_key]
+          @go_grid_shared_secret = options[:go_grid_shared_secret]
+          @data = self.class.data[@go_grid_api_key]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::GoGrid::Compute.new is deprecated, use Fog::Compute.new(:provider => 'GoGrid') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          require 'digest/md5'
+          require 'json'
+          @go_grid_api_key = options[:go_grid_api_key]
+          @go_grid_shared_secret = options[:go_grid_shared_secret]
+          @host   = options[:host]    || "api.gogrid.com"
+          @path   = options[:path]    || "/api"
+          @port   = options[:port]    || 443
+          @scheme = options[:scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params = {
+            :expects  => 200,
+            :method   => 'GET'
+          }.merge!(params)
+
+          params[:query] ||= {}
+          params[:query].merge!({
+            'api_key' => @go_grid_api_key,
+            'format'  => 'json',
+            'sig'     => Digest::MD5.hexdigest("#{@go_grid_api_key}#{@go_grid_shared_secret}#{Time.now.to_i}"),
+            'v'       => '1.5'
+          })
+
+          begin
+            response = @connection.request(
+              params.merge!(:path => "#{@path}/#{params[:path]}")
+            )
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::GoGrid::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end