ktheory-fog 1.1.2

data/lib/fog/aws/sts.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'aws'))
+
+module Fog
+  module AWS
+    class STS < Fog::Service
+
+      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
+
+      request_path 'fog/aws/requests/sts'
+      request :get_federation_token
+      request :get_session_token
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :owner_id => Fog::AWS::Mock.owner_id,
+              :server_certificates => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def self.server_certificate_id
+          Fog::Mock.random_hex(16)
+        end
+
+        def initialize(options={})
+          @aws_access_key_id = options[:aws_access_key_id]
+        end
+
+        def data
+          self.class.data[@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data.delete(@aws_access_key_id)
+        end
+      end
+
+      class Real
+
+        # Initialize connection to STS
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   iam = STS.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
+        # * STS object with connection to AWS.
+        def initialize(options={})
+          require 'fog/core/parser'
+          require 'multi_json'
+
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @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
+          @port       = options[:port]        || 443
+          @scheme     = options[:scheme]      || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+        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-06-15'
+            }
+          )
+
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :idempotent => idempotent,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :host       => @host,
+              :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
+          end
+
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/bin.rb

@@ -0,0 +1,84 @@
+require 'fog/core/credentials'
+
+module Fog
+  class << self
+
+    def available_providers
+      @available_providers ||= Fog.providers.values.select {|provider| Kernel.const_get(provider).available?}.sort
+    end
+
+  end
+
+  class Bin
+    class << self
+
+      def available?
+        availability = true
+        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
+
+      def collections
+        services.map {|service| self[service].collections}.flatten.sort_by {|service| service.to_s}
+      end
+
+    end
+  end
+
+end
+
+require 'fog/bin/aws'
+require 'fog/bin/bluebox'
+require 'fog/bin/brightbox'
+require 'fog/bin/cloudstack'
+require 'fog/bin/clodo'
+require 'fog/bin/dnsimple'
+require 'fog/bin/dnsmadeeasy'
+require 'fog/bin/dynect'
+require 'fog/bin/ecloud'
+require 'fog/bin/glesys'
+require 'fog/bin/go_grid'
+require 'fog/bin/google'
+require 'fog/bin/joyent'
+require 'fog/bin/libvirt'
+require 'fog/bin/linode'
+require 'fog/bin/local'
+require 'fog/bin/new_servers'
+require 'fog/bin/ninefold'
+require 'fog/bin/rackspace'
+require 'fog/bin/openstack'
+require 'fog/bin/ovirt'
+require 'fog/bin/slicehost'
+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/zerigo'

data/lib/fog/bin/aws.rb

@@ -0,0 +1,107 @@
+class AWS < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :auto_scaling
+        Fog::AWS::AutoScaling
+      when :cdn
+        Fog::CDN::AWS
+      when :cloud_formation
+        Fog::AWS::CloudFormation
+      when :cloud_watch
+        Fog::AWS::CloudWatch
+      when :compute
+        Fog::Compute::AWS
+      when :ddb, :dynamodb
+        Fog::AWS::DynamoDB
+      when :dns
+        Fog::DNS::AWS
+      when :elasticache
+        Fog::AWS::Elasticache
+      when :elb
+        Fog::AWS::ELB
+      when :emr
+        Fog::AWS::EMR
+      when :iam
+        Fog::AWS::IAM
+      when :sdb, :simpledb
+        Fog::AWS::SimpleDB
+      when :ses
+        Fog::AWS::SES
+      when :sqs
+        Fog::AWS::SQS
+      when :eu_storage, :storage
+        Fog::Storage::AWS
+      when :rds
+        Fog::AWS::RDS
+      when :sns
+        Fog::AWS::SNS
+      when :sts
+        Fog::AWS::STS
+      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 :auto_scaling
+          Fog::AWS::AutoScaling.new
+        when :cdn
+          Fog::Logger.warning("AWS[:cdn] is not recommended, use CDN[:aws] for portability")
+          Fog::CDN.new(:provider => 'AWS')
+        when :cloud_formation
+          Fog::AWS::CloudFormation.new
+        when :cloud_watch
+          Fog::AWS::CloudWatch.new
+        when :compute
+          Fog::Logger.warning("AWS[:compute] is not recommended, use Compute[:aws] for portability")
+          Fog::Compute.new(:provider => 'AWS')
+        when :ddb, :dynamodb
+          Fog::AWS::DynamoDB.new
+        when :dns
+          Fog::Logger.warning("AWS[:dns] is not recommended, use DNS[:aws] for portability")
+          Fog::DNS.new(:provider => 'AWS')
+        when :elasticache
+          Fog::AWS::Elasticache.new
+        when :elb
+          Fog::AWS::ELB.new
+        when :emr
+          Fog::AWS::EMR.new
+        when :iam
+          Fog::AWS::IAM.new
+        when :rds
+          Fog::AWS::RDS.new
+        when :eu_storage
+          Fog::Storage.new(:provider => 'AWS', :region => 'eu-west-1')
+        when :sdb, :simpledb
+          Fog::AWS::SimpleDB.new
+        when :ses
+          Fog::AWS::SES.new
+        when :sqs
+          Fog::AWS::SQS.new
+        when :storage
+          Fog::Logger.warning("AWS[:storage] is not recommended, use Storage[:aws] for portability")
+          Fog::Storage.new(:provider => 'AWS')
+        when :sns
+          Fog::AWS::SNS.new
+        when :sts
+          Fog::AWS::STS.new
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::AWS.services
+    end
+
+  end
+end

data/lib/fog/bin/bluebox.rb

@@ -0,0 +1,36 @@
+class Bluebox < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Bluebox
+      when :dns
+        Fog::DNS::Bluebox
+      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("Bluebox[:compute] is not recommended, use Compute[:bluebox] for portability")
+          Fog::Compute.new(:provider => 'Bluebox')
+        when :dns
+          Fog::Logger.warning("Bluebox[:dns] is not recommended, use DNS[:bluebox] for portability")
+          Fog::DNS.new(:provider => 'Bluebox')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Bluebox.services
+    end
+
+  end
+end

data/lib/fog/bin/brightbox.rb

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

data/lib/fog/bin/clodo.rb

@@ -0,0 +1,31 @@
+class Clodo < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Clodo
+      else 
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Formatador.display_line("[yellow][WARN] Clodo[:compute] is deprecated, use Compute[:clodo] instead[/]")
+          Fog::Compute.new(:provider => 'Clodo')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Clodo.services
+    end
+
+  end
+end

data/lib/fog/bin/cloudstack.rb

@@ -0,0 +1,30 @@
+class Cloudstack < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Cloudstack
+      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 => 'Cloudstack')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Cloudstack.services
+    end
+
+  end
+end