fog 1.9.0 → 1.10.0

data/lib/fog/aws/requests/data_pipeline/describe_pipelines.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class DataPipeline
+
+      class Real
+
+        # Describe pipelines
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_DescribePipelines.html
+        # ==== Parameters
+        # * PipelineIds <~String> - ID of pipeline to retrieve information for
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_pipelines(ids)
+          params = {}
+          params['pipelineIds'] = ids
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.DescribePipelines' },
+          })
+
+          Fog::JSON.decode(response.body)
+        end
+
+      end
+
+      class Mock
+        def describe_pipelines(ids)
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/data_pipeline/list_pipelines.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class DataPipeline
+
+      class Real
+
+        # List all pipelines
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_ListPipelines.html
+        # ==== Parameters
+        # * Marker <~String> - The starting point for the results to be returned. 
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def list_pipelines(options={})
+          params = {}
+          params['Marker'] = options[:marker] if options[:marker]
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.ListPipelines' },
+          })
+
+          Fog::JSON.decode(response.body)
+        end
+
+      end
+
+      class Mock
+        def list_pipelines(options={})
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/data_pipeline/put_pipeline_definition.rb

@@ -0,0 +1,72 @@
+module Fog
+  module AWS
+    class DataPipeline
+
+      class Real
+
+        # Put raw pipeline definition JSON
+        # http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_PutPipelineDefinition.html
+        # ==== Parameters
+        # * PipelineId <~String> - The ID of the pipeline
+        # * PipelineObjects <~String> - Objects in the pipeline
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def put_pipeline_definition(id, objects)
+          params = {
+            'pipelineId' => id,
+            'pipelineObjects' => transform_objects(objects),
+          }
+
+          response = request({
+            :body => Fog::JSON.encode(params),
+            :headers => { 'X-Amz-Target' => 'DataPipeline.PutPipelineDefinition' },
+          })
+
+          Fog::JSON.decode(response.body)
+        end
+
+        # Take a list of pipeline object hashes as specified in the Data Pipeline JSON format
+        # and transform it into the format expected by the API
+        private
+        def transform_objects(objects)
+          output = []
+
+          objects.each do |object|
+            new_object = {}
+            new_object['id'] = object.delete('id')
+            new_object['name'] = object.delete('name') || new_object['id']
+
+            new_object['fields'] = []
+            object.each do |key, value|
+              if value.is_a?(Hash)
+                new_object['fields'] << { 'key' => key, 'refValue' => value['ref'] }
+
+              elsif value.is_a?(Array)
+                value.each do |v|
+                  new_object['fields'] << { 'key' => key, 'stringValue' => v }
+                end
+
+              else
+                new_object['fields'] << { 'key' => key, 'stringValue' => value }
+
+              end
+            end
+
+            output << new_object
+          end
+
+          output
+        end
+
+      end
+
+      class Mock
+        def put_pipeline_definition(id, objects)
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/rds/describe_db_instances.rb

@@ -48,14 +48,14 @@ module Fog
           server_set.each do |server|
              case server["DBInstanceStatus"]
              when "creating"
-                 if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
-                   region = "us-east-1"
-                   server["DBInstanceStatus"] = "available"
-                   server["AvailabilityZone"] ||= region + 'a'
-                   server["Endpoint"] = {"Port"=>3306, 
-                                         "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
-                   server["PendingModifiedValues"] = {}
-                 end
+               if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
+                 region = "us-east-1"
+                 server["DBInstanceStatus"] = "available"
+                 server["AvailabilityZone"] ||= region + 'a'
+                 server["Endpoint"] = {"Port"=>3306,
+                                       "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
+                 server["PendingModifiedValues"] = {}
+               end
               when "rebooting"
                 if Time.now - self.data[:reboot_time] >= Fog::Mock.delay
                   # apply pending modified values
@@ -76,7 +76,6 @@ module Fog
                 unless server["PendingModifiedValues"].empty?
                   server["DBInstanceStatus"] = 'modifying'
                 end
-
              end
           end
 

data/lib/fog/aws/requests/storage/get_service.rb

@@ -25,8 +25,7 @@ module Fog
             :host     => @host,
             :idempotent => true,
             :method   => 'GET',
-            :parser   => Fog::Parsers::Storage::AWS::GetService.new,
-            :url      => @host
+            :parser   => Fog::Parsers::Storage::AWS::GetService.new
           })
         end
 

data/lib/fog/aws/requests/storage/list_multipart_uploads.rb

@@ -7,9 +7,9 @@ module Fog
 
         # List multipart uploads for a bucket
         #
-        # @params bucket_name [String] Name of bucket to list multipart uploads for
-        # @params upload_id [String] upload id to list objects for
-        # @params options [Hash] config arguments for list.  Defaults to {}.
+        # @param bucket_name [String] Name of bucket to list multipart uploads for
+        # @param upload_id [String] upload id to list objects for
+        # @param options [Hash] config arguments for list.  Defaults to {}.
         # @option options key-marker[String] limits parts to only those that appear lexicographically after this key.
         # @option options max-uploads [Integer] limits number of uploads returned
         # @option options upload-id-marker [String] limits uploads to only those that appear lexicographically after this upload id.

data/lib/fog/aws/requests/storage/put_bucket_policy.rb

@@ -6,9 +6,9 @@ module Fog
         # Change bucket policy for an S3 bucket
         #
         # @param bucket_name [String] name of bucket to modify
-        # @param policy [Hash] policy document 
+        # @param policy [Hash] policy document
         #
-        # @ee http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTpolicy.html 
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketPUTpolicy.html
 
         def put_bucket_policy(bucket_name, policy)
           request({

data/lib/fog/aws/storage.rb

@@ -400,7 +400,7 @@ DATA
           begin
             response = @connection.request(params, &block)
           rescue Excon::Errors::TemporaryRedirect => error
-            uri = URI.parse(error.response.headers['Location'])
+            uri = URI.parse(error.response.is_a?(Hash) ? error.response[:headers]['Location'] : error.response.headers['Location'])
             Fog::Logger.warning("fog: followed redirect to #{uri.host}, connecting to the matching region will be more performant")
             response = Fog::Connection.new("#{@scheme}://#{uri.host}:#{@port}", false, @connection_options).request(original_params, &block)
           end

data/lib/fog/bin.rb

@@ -65,6 +65,7 @@ require 'fog/bin/cloudstack'
 require 'fog/bin/clodo'
 require 'fog/bin/dnsimple'
 require 'fog/bin/dnsmadeeasy'
+require 'fog/bin/dreamhost'
 require 'fog/bin/dynect'
 require 'fog/bin/ecloud'
 require 'fog/bin/glesys'
@@ -72,6 +73,7 @@ require 'fog/bin/go_grid'
 require 'fog/bin/google'
 require 'fog/bin/hp'
 require 'fog/bin/ibm'
+require 'fog/bin/internet_archive'
 require 'fog/bin/joyent'
 require 'fog/bin/libvirt'
 require 'fog/bin/linode'
@@ -85,7 +87,6 @@ require 'fog/bin/serverlove'
 require 'fog/bin/stormondemand'
 require 'fog/bin/terremark'
 require 'fog/bin/vcloud'
-require 'fog/bin/virtual_box'
 require 'fog/bin/vmfusion'
 require 'fog/bin/vsphere'
 require 'fog/bin/voxel'

data/lib/fog/bin/aws.rb

@@ -15,6 +15,8 @@ class AWS < Fog::Bin
         Fog::AWS::CloudWatch
       when :compute
         Fog::Compute::AWS
+      when :data_pipeline
+        Fog::AWS::DataPipeline
       when :ddb, :dynamodb
         Fog::AWS::DynamoDB
       when :dns
@@ -68,6 +70,8 @@ class AWS < Fog::Bin
         when :compute
           Fog::Logger.warning("AWS[:compute] is not recommended, use Compute[:aws] for portability")
           Fog::Compute.new(:provider => 'AWS')
+        when :data_pipeline
+          Fog::AWS::DataPipeline
         when :ddb, :dynamodb
           Fog::AWS::DynamoDB.new
         when :dns

data/lib/fog/bin/bluebox.rb

@@ -7,6 +7,8 @@ class Bluebox < Fog::Bin
         Fog::Compute::Bluebox
       when :dns
         Fog::DNS::Bluebox
+      when :blb
+        Fog::Bluebox::BLB
       else
         raise ArgumentError, "Unsupported #{self} service: #{key}"
       end

data/lib/fog/bin/dreamhost.rb

@@ -0,0 +1,31 @@
+class Dreamhost < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :dns
+        Fog::DNS::Dreamhost
+      else
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :dns
+          Fog::Logger.warning("Dreamhost[:dns] is not recommended, use DNS[:dreamhost] for portability")
+          Fog::DNS.new(:provider => 'Dreamhost')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Dreamhost.services
+    end
+
+  end
+end

data/lib/fog/bin/hp.rb

@@ -3,6 +3,8 @@ class HP < Fog::Bin
 
     def class_for(key)
       case key
+      when :block_storage
+        Fog::HP::BlockStorage
       when :cdn
         Fog::CDN::HP
       when :compute
@@ -17,11 +19,16 @@ class HP < Fog::Bin
     def [](service)
       @@connections ||= Hash.new do |hash, key|
         hash[key] = case key
+        when :block_storage
+          Fog::HP::BlockStorage.new
         when :cdn
+          Fog::Logger.warning("HP[:cdn] is deprecated, use CDN[:hp] instead")
           Fog::CDN.new(:provider => 'HP')
         when :compute
+          Fog::Logger.warning("HP[:compute] is deprecated, use Compute[:hp] instead")
           Fog::Compute.new(:provider => 'HP')
         when :storage
+          Fog::Logger.warning("HP[:storage] is deprecated, use Storage[:hp] instead")
           Fog::Storage.new(:provider => 'HP')
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"

data/lib/fog/bin/internet_archive.rb

@@ -0,0 +1,34 @@
+class InternetArchive < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :storage
+        Fog::Storage::InternetArchive
+      else
+        # @todo Replace most instances of ArgumentError with NotImplementedError
+        # @todo For a list of widely supported Exceptions, see:
+        # => http://www.zenspider.com/Languages/Ruby/QuickRef.html#35
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :storage
+          Fog::Logger.warning("InternetArchive[:storage] is not recommended, use Storage[:aws] for portability")
+          Fog::Storage.new(:provider => 'InternetArchive')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::InternetArchive.services
+    end
+
+  end
+end

data/lib/fog/bin/openstack.rb

@@ -7,8 +7,14 @@ class OpenStack < Fog::Bin
         Fog::Compute::OpenStack
       when :identity
         Fog::Identity::OpenStack
+      when :image
+        Fog::Image::OpenStack
       when :network
         Fog::Network::OpenStack
+      when :storage
+        Fog::Storage::OpenStack
+      when :volume
+        Fog::Volume::OpenStack
       else
         raise ArgumentError, "Unrecognized service: #{key}"
       end
@@ -21,11 +27,20 @@ class OpenStack < Fog::Bin
           Fog::Logger.warning("OpenStack[:compute] is not recommended, use Compute[:openstack] for portability")
           Fog::Compute.new(:provider => 'OpenStack')
         when :identity
-          Fog::Logger.warning("OpenStack[:identity] is not recommended, use Compute[:openstack] for portability")
-          Fog::Compute.new(:provider => 'OpenStack')
+          Fog::Logger.warning("OpenStack[:identity] is not recommended, use Identity[:openstack] for portability")
+          Fog::Identity.new(:provider => 'OpenStack')
+        when :image
+          Fog::Logger.warning("OpenStack[:image] is not recommended, use Image[:openstack] for portability")
+          Fog::Image.new(:provider => 'OpenStack')
         when :network
           Fog::Logger.warning("OpenStack[:network] is not recommended, use Network[:openstack] for portability")
           Fog::Network.new(:provider => 'OpenStack')
+        when :storage
+          Fog::Logger.warning("OpenStack[:storage] is not recommended, use Storage[:openstack] for portability")
+          Fog::Storage.new(:provider => 'OpenStack')
+        when :volume
+          Fog::Logger.warning("OpenStack[:volume] is not recommended, use Volume[:openstack] for portability")
+          Fog::Volume.new(:provider => 'OpenStack')
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end

data/lib/fog/bluebox.rb

@@ -5,6 +5,7 @@ module Fog
 
     extend Fog::Provider
 
+    service(:blb,     'bluebox/blb',      'BLB')
     service(:compute, 'bluebox/compute',  'Compute')
     service(:dns,     'bluebox/dns',      'DNS')
 

data/lib/fog/bluebox/blb.rb

@@ -0,0 +1,85 @@
+require 'fog/bluebox'
+
+module Fog
+  module Bluebox
+    class BLB < Fog::Service
+
+      requires :bluebox_api_key, :bluebox_customer_id
+      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
+
+      model_path 'fog/bluebox/models/blb'
+
+      model      :lb_application
+      collection :lb_applications
+
+      model      :lb_service
+      collection :lb_services
+
+      model      :lb_backend
+      collection :lb_backends
+
+
+      request_path 'fog/bluebox/requests/blb'
+
+      request :get_lb_application
+      request :get_lb_applications
+
+      request :get_lb_service
+      request :get_lb_services
+
+      request :get_lb_backend
+      request :get_lb_backends
+
+      request :add_machine_to_lb_application
+
+      request :add_machine_to_lb_backend
+
+      request :remove_machine_from_lb_backend
+
+      request :update_lb_backend_machine
+
+      class Mock
+      end
+
+      class Real
+        def initialize(options={})
+          @bluebox_api_key      = options[:bluebox_api_key]
+          @bluebox_customer_id  = options[:bluebox_customer_id]
+          @connection_options   = options[:connection_options] || {}
+          @host       = options[:bluebox_host]    || "boxpanel.bluebox.net"
+          @persistent = options[:persistent]      || false
+          @port       = options[:bluebox_port]    || 443
+          @scheme     = options[:bluebox_scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        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? || params[:headers]['Accept'] == 'text/plain'
+            response.body = Fog::JSON.decode(response.body)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end