fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

data/lib/fog/aws/sts.rb

@@ -3,16 +3,18 @@ require 'fog/aws'
 module Fog
   module AWS
     class STS < Fog::Service
+      extend Fog::AWS::CredentialFetcher::ServiceMethods
 
       class EntityAlreadyExists < Fog::AWS::STS::Error; end
       class ValidationError < Fog::AWS::STS::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent
+      recognizes :host, :path, :port, :scheme, :persistent, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at
 
       request_path 'fog/aws/requests/sts'
       request :get_federation_token
       request :get_session_token
+      request :assume_role
 
       class Mock
         def self.data
@@ -33,7 +35,8 @@ module Fog
         end
 
         def initialize(options={})
-          @aws_access_key_id = options[:aws_access_key_id]
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
         end
 
         def data
@@ -43,10 +46,14 @@ module Fog
         def reset_data
           self.class.data.delete(@aws_access_key_id)
         end
+
+        def setup_credentials(options)
+          @aws_access_key_id = options[:aws_access_key_id]
+        end
       end
 
       class Real
-
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
         # Initialize connection to STS
         #
         # ==== Notes
@@ -67,10 +74,10 @@ module Fog
         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]
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
           @connection_options     = options[:connection_options] || {}
-          @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
           @host       = options[:host]        || 'sts.amazonaws.com'
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
@@ -85,6 +92,14 @@ module Fog
 
         private
 
+        def setup_credentials(options)
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @aws_session_token      = options[:aws_session_token]
+          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+        end
+
         def request(params)
           idempotent  = params.delete(:idempotent)
           parser      = params.delete(:parser)
@@ -93,6 +108,7 @@ module Fog
             params,
             {
               :aws_access_key_id  => @aws_access_key_id,
+              :aws_session_token  => @aws_session_token,
               :hmac               => @hmac,
               :host               => @host,
               :path               => @path,
@@ -102,7 +118,7 @@ module Fog
           )
 
           begin
-            response = @connection.request({
+            @connection.request({
               :body       => body,
               :expects    => 200,
               :idempotent => idempotent,
@@ -111,23 +127,17 @@ module Fog
               :method     => 'POST',
               :parser     => parser
             })
-
-            response
           rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/<Code>(.*)<\/Code>(?:.*<Message>(.*)<\/Message>)?/m)
-              case match[1]
-              when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
-                raise Fog::AWS::STS.const_get(match[1]).slurp(error, match[2])
-              else
-                raise Fog::AWS::STS::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
-                raise
-              end
-            else
-              raise
-            end
+            match = Fog::AWS::Errors.match_error(error)
+            raise if match.empty?
+            raise case match[:code]
+                  when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
+                    Fog::AWS::STS.const_get(match[:code]).slurp(error, match[:message])
+                  else
+                    Fog::AWS::STS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                  end
           end
 
-
         end
 
       end

data/lib/fog/billing.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Billing
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+      if provider == :stormondemand
+        require 'fog/storm_on_demand/billing'
+        Fog::Billing::StormOnDemand.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} has no billing service")
+      end
+    end
+
+    def self.providers
+      Fog.services[:billing]
+    end
+  end
+end

data/lib/fog/bin.rb

@@ -4,7 +4,6 @@ module Fog
   class << self
 
     def available_providers
-	  Kernel.const_get('Ninefold')
       @available_providers ||= Fog.providers.values.select {|provider| Kernel.const_get(provider).available?}.sort
     end
 
@@ -63,8 +62,10 @@ require 'fog/bin/bluebox'
 require 'fog/bin/brightbox'
 require 'fog/bin/cloudstack'
 require 'fog/bin/clodo'
+require 'fog/bin/digitalocean'
 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'
@@ -79,15 +81,17 @@ require 'fog/bin/local'
 require 'fog/bin/bare_metal_cloud'
 require 'fog/bin/ninefold'
 require 'fog/bin/rackspace'
+require 'fog/bin/riakcs'
 require 'fog/bin/openstack'
 require 'fog/bin/ovirt'
 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'
 require 'fog/bin/xenserver'
 require 'fog/bin/zerigo'
+require 'fog/bin/cloudsigma'
+require 'fog/bin/openvz'

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/cloudsigma.rb

@@ -0,0 +1,29 @@
+class CloudSigma < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+        when :compute
+          Fog::Compute::CloudSigma
+        else
+          raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+                      when :compute
+                        Fog::Compute.new(:provider => 'CloudSigma')
+                      else
+                        raise ArgumentError, "Unrecognized service: #{key.inspect}"
+                    end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::CloudSigma.services
+    end
+  end
+end

data/lib/fog/bin/digitalocean.rb

@@ -0,0 +1,31 @@
+class DigitalOcean < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::DigitalOcean
+      else
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Logger.warning("DigitalOcean[:compute] is not recommended, use Compute[:digitalocean] for portability")
+          Fog::Compute.new(:provider => 'DigitalOcean')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::DigitalOcean.services
+    end
+
+  end
+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/google.rb

@@ -1,8 +1,10 @@
-class Google < Fog::Bin
+module Google # deviates from other bin stuff to accomodate gem
   class << self
 
     def class_for(key)
       case key
+      when :compute
+        Fog::Compute::Google
       when :storage
         Fog::Storage::Google
       else 
@@ -16,6 +18,9 @@ class Google < Fog::Bin
         when :storage
           Fog::Logger.warning("Google[:storage] is not recommended, use Storage[:google] for portability")
           Fog::Storage.new(:provider => 'Google')
+        when :compute
+          Fog::Logger.warning("Google[:compute] is not recommended, use Compute[:google] for portability")
+          Fog::Compute.new(:provider => 'Google')
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end
@@ -23,9 +28,50 @@ class Google < Fog::Bin
       @@connections[service]
     end
 
+    def account
+      @@connections[:compute].account
+    end
+
     def services
       Fog::Google.services
     end
 
+    # based off of virtual_box.rb
+    def available?
+      # Make sure the gem we use is enabled.
+      availability = if Gem::Specification.respond_to?(:find_all_by_name)
+        !Gem::Specification.find_all_by_name('google-api-client').empty? # newest rubygems
+      else
+        !Gem.source_index.find_name('google-api-client').empty? # legacy
+      end
+
+      # Then make sure we have all of the requirements
+      for service in services
+        begin
+          service = self.class_for(service)
+          availability &&= service.requirements.all? { |requirement| Fog.credentials.include?(requirement) }
+        rescue ArgumentError => e
+          Fog::Logger.warning(e.message)
+          availability = false
+        rescue => e
+          availability = false
+        end
+      end
+
+      if availability
+        for service in services
+          for collection in self.class_for(service).collections
+            unless self.respond_to?(collection)
+              self.class_eval <<-EOS, __FILE__, __LINE__
+                def self.#{collection}
+                  self[:#{service}].#{collection}
+                end
+              EOS
+            end
+          end
+        end
+      end
+      availability
+    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