rackspace-fog 1.4.2

data/lib/rackspace-fog/aws/emr.rb

@@ -0,0 +1,134 @@
+require 'rackspace-fog/aws'
+
+module Fog
+  module AWS
+    class EMR < Fog::Service
+      extend Fog::AWS::CredentialFetcher::ServiceMethods
+
+      class IdentifierTaken < Fog::Errors::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at
+
+      request_path 'rackspace-fog/aws/requests/emr'
+
+      request :add_instance_groups
+      request :add_job_flow_steps
+      request :describe_job_flows
+      request :modify_instance_groups
+      request :run_job_flow
+      request :set_termination_protection
+      request :terminate_job_flows
+
+      # model_path 'rackspace-fog/aws/models/rds'
+      # model       :server
+      # collection  :servers
+      # model       :snapshot
+      # collection  :snapshots
+      # model       :parameter_group
+      # collection  :parameter_groups
+      #
+      # model       :parameter
+      # collection  :parameters
+      #
+      # model       :security_group
+      # collection  :security_groups
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
+        # Initialize connection to EMR
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   emr = EMR.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. For instance, in 'eu-west-1', 'us-east-1' and etc.
+        #
+        # ==== Returns
+        # * EMR object with connection to AWS.
+        def initialize(options={})
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
+          @connection_options     = options[:connection_options] || {}
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || "elasticmapreduce.#{options[:region]}.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)
+          @region = options[:region]
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        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)
+          refresh_credentials_if_expired
+
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = Fog::AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :aws_session_token  => @aws_session_token,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2009-03-31' #'2010-07-28'
+            }
+          )
+
+          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
+            raise
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/rackspace-fog/aws/iam.rb

@@ -0,0 +1,219 @@
+require 'rackspace-fog/aws'
+
+module Fog
+  module AWS
+    class IAM < Fog::Service
+
+      class EntityAlreadyExists < Fog::AWS::IAM::Error; end
+      class KeyPairMismatch < Fog::AWS::IAM::Error; end
+      class LimitExceeded < Fog::AWS::IAM::Error; end
+      class MalformedCertificate < Fog::AWS::IAM::Error; end
+      class ValidationError < Fog::AWS::IAM::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent
+
+      request_path 'rackspace-fog/aws/requests/iam'
+      request :add_user_to_group
+      request :add_role_to_instance_profile
+      request :create_access_key
+      request :create_account_alias
+      request :create_group
+      request :create_instance_profile
+      request :create_login_profile
+      request :create_role
+      request :create_user
+      request :delete_access_key
+      request :delete_account_alias
+      request :delete_group
+      request :delete_group_policy
+      request :delete_instance_profile
+      request :delete_login_profile
+      request :delete_role
+      request :delete_role_policy
+      request :delete_server_certificate
+      request :delete_signing_certificate
+      request :delete_user
+      request :delete_user_policy
+      request :get_group
+      request :get_group_policy
+      request :get_instance_profile
+      request :get_role_policy
+      request :get_login_profile
+      request :get_server_certificate
+      request :get_role
+      request :get_user
+      request :get_user_policy
+      request :list_access_keys
+      request :list_account_aliases
+      request :list_group_policies
+      request :list_groups
+      request :list_groups_for_user
+      request :list_instance_profiles
+      request :list_instance_profiles_for_role
+      request :list_roles
+      request :list_role_policies
+      request :list_server_certificates
+      request :list_signing_certificates
+      request :list_user_policies
+      request :list_users
+      request :put_group_policy
+      request :put_role_policy
+      request :put_user_policy
+      request :remove_role_from_instance_profile
+      request :remove_user_from_group
+      request :update_access_key
+      request :update_group
+      request :update_login_profile
+      request :update_server_certificate
+      request :update_signing_certificate
+      request :update_user
+      request :upload_server_certificate
+      request :upload_signing_certificate
+      
+      model_path 'rackspace-fog/aws/models/iam'
+      model       :user
+      collection  :users
+      model       :policy
+      collection  :policies      
+      model       :access_key
+      collection  :access_keys
+      
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :owner_id => Fog::AWS::Mock.owner_id,
+              :server_certificates => {},
+              :users => Hash.new do |uhash, ukey|
+                uhash[ukey] = {
+                  :user_id     => Fog::AWS::Mock.key_id,
+                  :arn         => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:user/#{ukey}",
+                  :access_keys => [],
+                  :policies    => {}
+                }
+              end,
+              :groups => Hash.new do |ghash, gkey|
+                ghash[gkey] = {
+                  :group_id   => Fog::AWS::Mock.key_id,
+                  :arn        => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:group/#{gkey}",
+                  :members    => []
+                }
+              end
+            }
+          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 IAM
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   iam = IAM.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
+        # * IAM object with connection to AWS.
+        def initialize(options={})
+          require 'rackspace-fog/core/parser'
+
+          @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]        || 'iam.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            => '2010-05-08'
+            }
+          )
+
+          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 'CertificateNotFound', 'NoSuchEntity'
+                raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
+              when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
+                raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
+              else
+                raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
+                raise
+              end
+            else
+              raise
+            end
+          end
+
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rackspace-fog/aws/models/auto_scaling/activities.rb

@@ -0,0 +1,30 @@
+require 'rackspace-fog/aws/models/auto_scaling/activity'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Activities < Fog::Collection
+
+        model Fog::AWS::AutoScaling::Activity
+
+        def all
+          data = []
+          next_token = nil
+          loop do
+            result = connection.describe_scaling_activities('NextToken' => next_token).body['DescribeScalingActivitiesResult']
+            data += result['Activities']
+            next_token = result['NextToken']
+            break if next_token.nil?
+          end
+          load(data)
+        end
+
+        def get(identity)
+          data = connection.describe_scaling_activities('ActivityId' => identity).body['DescribeScalingActivitiesResult']['Activities'].first
+          new(data) unless data.nil?
+        end
+
+      end
+    end
+  end
+end

data/lib/rackspace-fog/aws/models/auto_scaling/activity.rb

@@ -0,0 +1,29 @@
+require 'rackspace-fog/core/model'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Activity < Fog::Model
+
+        identity  :id,                      :aliases => 'ActivityId'
+        attribute :auto_scaling_group_name, :aliases => 'AutoScalingGroupName'
+        attribute :cause,                   :aliases => 'Cause'
+        attribute :description,             :aliases => 'Description'
+        attribute :end_time,                :aliases => 'EndTime'
+        attribute :progress,                :aliases => 'Progress'
+        attribute :start_time,              :aliases => 'StartTime'
+        attribute :status_code,             :aliases => 'StatusCode'
+        attribute :status_message,          :aliases => 'StatusMessage'
+
+        def group
+          connection.groups.get(attributes['AutoScalingGroupName'])
+        end
+
+        def save
+          raise "Operation not supported"
+        end
+
+      end
+    end
+  end
+end

data/lib/rackspace-fog/aws/models/auto_scaling/configuration.rb

@@ -0,0 +1,63 @@
+require 'rackspace-fog/core/model'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Configuration < Fog::Model
+
+        identity  :id,                    :aliases => 'LaunchConfigurationName'
+        attribute :arn,                   :aliases => 'LaunchConfigurationARN'
+        attribute :block_device_mappings, :aliases => 'BlockDeviceMappings'
+        attribute :created_at,            :aliases => 'CreatedTime'
+        attribute :image_id,              :aliases => 'ImageId'
+        #attribute :instance_monitoring,   :aliases => 'InstanceMonitoring'
+        attribute :instance_monitoring,   :aliases => 'InstanceMonitoring', :squash => 'Enabled'
+        attribute :instance_type,         :aliases => 'InstanceType'
+        attribute :kernel_id,             :aliases => 'KernelId'
+        attribute :key_name,              :aliases => 'KeyName'
+        attribute :ramdisk_id,            :aliases => 'RamdiskId'
+        attribute :security_groups,       :aliases => 'SecurityGroups'
+        attribute :user_data,             :aliases => 'UserData'
+
+        def initialize(attributes={})
+          #attributes[:availability_zones] ||= %w(us-east-1a us-east-1b us-east-1c us-east-1d)
+          #attributes['ListenerDescriptions'] ||= [{
+          #  'Listener' => {'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'http'},
+          #  'PolicyNames' => []
+          #}]
+          #attributes['Policies'] ||= {'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => []}
+          super
+        end
+
+        def ready?
+          # AutoScaling requests are synchronous
+          true
+        end
+
+        def save
+          requires :id
+          requires :image_id
+          requires :instance_type
+
+          connection.create_launch_configuration(image_id, instance_type, id) #, listeners.map{|l| l.to_params})
+
+          # reload instead of merge attributes b/c some attrs (like HealthCheck)
+          # may be set, but only the DNS name is returned in the create_load_balance
+          # API call
+          reload
+        end
+
+        def reload
+          super
+          self
+        end
+
+        def destroy
+          requires :id
+          connection.delete_launch_configuration(id)
+        end
+
+      end
+    end
+  end
+end