ktheory-fog 1.1.2

data/fog.gemspec

@@ -0,0 +1,65 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'ktheory-fog'
+  s.version           = '1.1.2'
+  s.date              = '2011-03-06'
+  s.rubyforge_project = 'fog'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "brings clouds to you"
+  s.description = "The Ruby cloud services library. Supports all major cloud providers including AWS, Rackspace, Linode, Blue Box, StormOnDemand, and many others. Full support for most AWS services including EC2, S3, CloudWatch, SimpleDB, ELB, and RDS."
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["geemus (Wesley Beary)"]
+  s.email    = 'geemus@gmail.com'
+  s.homepage = 'http://github.com/fog/fog'
+
+  ## This sections is only necessary if you have C extensions.
+  # s.require_paths << 'ext'
+  # s.extensions = %w[ext/extconf.rb]
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ["fog"]
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.rdoc]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('builder')
+  s.add_dependency('excon', '~>0.9.0')
+  s.add_dependency('formatador', '~>0.2.0')
+  s.add_dependency('multi_json', '~>1.0')
+  s.add_dependency('mime-types')
+  s.add_dependency('net-scp', '~>1.0.4')
+  s.add_dependency('net-ssh', '>=2.1.3')
+  s.add_dependency('nokogiri', '~>1.5.0')
+  s.add_dependency('ruby-hmac')
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('jekyll')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rbvmomi')
+  s.add_development_dependency('rdoc')
+  s.add_development_dependency('thor')
+  s.add_development_dependency('rspec', '~>1.3.1')
+  s.add_development_dependency('rbovirt', '>=0.0.7')
+  s.add_development_dependency('shindo', '~>0.3.4')
+  s.add_development_dependency('virtualbox', '~>0.9.1')
+  s.add_development_dependency('fission')
+#  s.add_development_dependency('ruby-libvirt','~>0.4.0')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {spec,tests}/*`.split("\n")
+end

data/lib/fog.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'fog', 'core')
+
+module Fog
+
+  unless const_defined?(:VERSION)
+    VERSION = '1.1.2'
+  end
+
+end
+
+# FIXME: these should go away (force usage of Fog::[Compute, CDN, DNS, Storage]  etc)
+require 'fog/providers'
+require 'fog/terremark'
+
+require 'fog/compute'
+require 'fog/cdn'
+require 'fog/dns'
+require 'fog/storage'

data/lib/fog/aws.rb

@@ -0,0 +1,234 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module AWS
+
+    extend Fog::Provider
+
+    service(:auto_scaling,    'aws/auto_scaling',     'AutoScaling')
+    service(:cdn,             'aws/cdn',              'CDN')
+    service(:compute,         'aws/compute',          'Compute')
+    service(:cloud_formation, 'aws/cloud_formation',  'CloudFormation')
+    service(:cloud_watch,     'aws/cloud_watch',      'CloudWatch')
+    service(:dynamodb,        'aws/dynamodb',         'DynamoDB')
+    service(:dns,             'aws/dns',              'DNS')
+    service(:elasticache,     'aws/elasticache',      'Elasticache')
+    service(:elb,             'aws/elb',              'ELB')
+    service(:emr,             'aws/emr',              'EMR')
+    service(:iam,             'aws/iam',              'IAM')
+    service(:rds,             'aws/rds',              'RDS')
+    service(:ses,             'aws/ses',              'SES')
+    service(:simpledb,        'aws/simpledb',         'SimpleDB')
+    service(:sns,             'aws/sns',              'SNS')
+    service(:sqs,             'aws/sqs',              'SQS')
+    service(:sts,             'aws/sts',              'STS')
+    service(:storage,         'aws/storage',          'Storage')
+
+    def self.indexed_param(key, values)
+      params = {}
+      unless key.include?('%d')
+        key << '.%d'
+      end
+      [*values].each_with_index do |value, index|
+        if value.respond_to?('keys')
+          k = format(key, index + 1)
+          value.each do | vkey, vvalue |
+            params["#{k}.#{vkey}"] = vvalue
+          end
+        else
+          params[format(key, index + 1)] = value
+        end
+      end
+      params
+    end
+
+    def self.serialize_keys(key, value, options = {})
+      case value
+      when Hash
+        value.each do | k, v |
+          options.merge!(serialize_keys("#{key}.#{k}", v))
+        end
+        return options
+      when Array
+        value.each_with_index do | it, idx |
+          options.merge!(serialize_keys("#{key}.member.#{(idx + 1)}", it))
+        end
+        return options
+      else
+        return {key => value}
+      end
+    end
+
+    def self.indexed_filters(filters)
+      params = {}
+      filters.keys.each_with_index do |key, key_index|
+        key_index += 1
+        params[format('Filter.%d.Name', key_index)] = key
+        [*filters[key]].each_with_index do |value, value_index|
+          value_index += 1
+          params[format('Filter.%d.Value.%d', key_index, value_index)] = value
+        end
+      end
+      params
+    end
+
+    def self.escape(string)
+      string.gsub(/([^a-zA-Z0-9_.\-~]+)/) {
+        "%" + $1.unpack("H2" * $1.bytesize).join("%").upcase
+      }
+    end
+
+    def self.signed_params(params, options = {})
+      params.merge!({
+        'AWSAccessKeyId'    => options[:aws_access_key_id],
+        'SignatureMethod'   => 'HmacSHA256',
+        'SignatureVersion'  => '2',
+        'Timestamp'         => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        'Version'           => options[:version]
+      })
+
+      params.merge!({
+        'SecurityToken'     => options[:aws_session_token]
+      }) if options[:aws_session_token]
+
+      body = ''
+      for key in params.keys.sort
+        unless (value = params[key]).nil?
+          body << "#{key}=#{escape(value.to_s)}&"
+        end
+      end
+      string_to_sign = "POST\n#{options[:host]}:#{options[:port]}\n#{options[:path]}\n" << body.chop
+      signed_string = options[:hmac].sign(string_to_sign)
+      body << "Signature=#{escape(Base64.encode64(signed_string).chomp!)}"
+
+      body
+    end
+
+    class Mock
+
+      def self.arn(vendor, account_id, path, region = nil)
+        "arn:aws:#{vendor}:#{region}:#{account_id}:#{path}"
+      end
+
+      def self.availability_zone(region)
+        "#{region}#{Fog::Mock.random_selection('abcd', 1)}"
+      end
+
+      def self.box_usage
+        sprintf("%0.10f", rand / 100).to_f
+      end
+
+      def self.console_output
+        # "[ 0.000000] Linux version 2.6.18-xenU-ec2-v1.2 (root@domU-12-31-39-07-51-82) (gcc version 4.1.2 20070626 (Red Hat 4.1.2-13)) #2 SMP Wed Aug 19 09:04:38 EDT 2009"
+        Base64.decode64("WyAwLjAwMDAwMF0gTGludXggdmVyc2lvbiAyLjYuMTgteGVuVS1lYzItdjEu\nMiAocm9vdEBkb21VLTEyLTMxLTM5LTA3LTUxLTgyKSAoZ2NjIHZlcnNpb24g\nNC4xLjIgMjAwNzA2MjYgKFJlZCBIYXQgNC4xLjItMTMpKSAjMiBTTVAgV2Vk\nIEF1ZyAxOSAwOTowNDozOCBFRFQgMjAwOQ==\n")
+      end
+
+      def self.dns_name_for(ip_address)
+        "ec2-#{ip_address.gsub('.','-')}.compute-1.amazonaws.com"
+      end
+
+      def self.private_dns_name_for(ip_address)
+        "ip-#{ip_address.gsub('.','-')}.ec2.internal"
+      end
+
+      def self.image
+        path = []
+        (rand(3) + 2).times do
+          path << Fog::Mock.random_letters(rand(9) + 8)
+        end
+        {
+          "imageOwnerId"   => Fog::Mock.random_letters(rand(5) + 4),
+          "blockDeviceMapping" => [],
+          "productCodes"   => [],
+          "kernelId"       => kernel_id,
+          "ramdiskId"      => ramdisk_id,
+          "imageState"     => "available",
+          "imageId"        => image_id,
+          "architecture"   => "i386",
+          "isPublic"       => true,
+          "imageLocation"  => path.join('/'),
+          "imageType"      => "machine",
+          "rootDeviceType" => ["ebs","instance-store"][rand(2)],
+          "rootDeviceName" => "/dev/sda1"
+        }
+      end
+
+      def self.image_id
+        "ami-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.key_fingerprint
+        fingerprint = []
+        20.times do
+          fingerprint << Fog::Mock.random_hex(2)
+        end
+        fingerprint.join(':')
+      end
+
+      def self.instance_id
+        "i-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.ip_address
+        ip = []
+        4.times do
+          ip << Fog::Mock.random_numbers(rand(3) + 1).to_i.to_s # remove leading 0
+        end
+        ip.join('.')
+      end
+
+      def self.kernel_id
+        "aki-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.key_material
+        OpenSSL::PKey::RSA.generate(1024).to_s
+      end
+
+      def self.owner_id
+        Fog::Mock.random_numbers(12)
+      end
+
+      def self.ramdisk_id
+        "ari-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.request_id
+        request_id = []
+        request_id << Fog::Mock.random_hex(8)
+        3.times do
+          request_id << Fog::Mock.random_hex(4)
+        end
+        request_id << Fog::Mock.random_hex(12)
+        request_id.join('-')
+      end
+      class << self
+        alias :reserved_instances_id :request_id
+        alias :reserved_instances_offering_id :request_id
+        alias :sqs_message_id :request_id
+        alias :sqs_sender_id :request_id
+      end
+
+      def self.reservation_id
+        "r-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.snapshot_id
+        "snap-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.volume_id
+        "vol-#{Fog::Mock.random_hex(8)}"
+      end
+
+      def self.key_id(length=21)
+        #Probably close enough
+        Fog::Mock.random_selection('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',length)
+      end
+
+      def self.rds_address(db_name,region)
+        "#{db_name}.#{Fog::Mock.random_letters(rand(12) + 4)}.#{region}.rds.amazonaws.com"
+      end
+    end
+  end
+end

data/lib/fog/aws/auto_scaling.rb

@@ -0,0 +1,212 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'aws'))
+
+module Fog
+  module AWS
+    class AutoScaling < Fog::Service
+
+      class IdentifierTaken < Fog::Errors::Error; end
+      class ResourceInUse < Fog::Errors::Error; end
+      class ValidationError < Fog::Errors::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent, :region
+
+      request_path 'fog/aws/requests/auto_scaling'
+      request :create_auto_scaling_group
+      request :create_launch_configuration
+      request :delete_auto_scaling_group
+      request :delete_launch_configuration
+      request :delete_policy
+      request :delete_scheduled_action
+      request :describe_adjustment_types
+      request :describe_auto_scaling_groups
+      request :describe_auto_scaling_instances
+      request :describe_launch_configurations
+      request :describe_metric_collection_types
+      request :describe_policies
+      request :describe_scaling_activities
+      request :describe_scaling_process_types
+      request :describe_scheduled_actions
+      request :disable_metrics_collection
+      request :enable_metrics_collection
+      request :execute_policy
+      request :put_scaling_policy
+      request :put_scheduled_update_group_action
+      request :resume_processes
+      request :set_desired_capacity
+      request :set_instance_health
+      request :suspend_processes
+      request :terminate_instance_in_auto_scaling_group
+      request :update_auto_scaling_group
+
+      model_path 'fog/aws/models/auto_scaling'
+      model      :activity
+      collection :activities
+      model      :configuration
+      collection :configurations
+      model      :group
+      collection :groups
+      model      :instance
+      collection :instances
+
+      class Real
+
+        # Initialize connection to AutoScaling
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   as = AutoScaling.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
+        # * AutoScaling object with connection to AWS.
+        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]
+          @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
+          @connection_options = options[:connection_options] || {}
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || "autoscaling.#{options[:region]}.amazonaws.com"
+          @path       = options[:path]        || '/'
+          @port       = options[:port]        || 443
+          @persistent = options[:persistent]  || false
+          @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 = AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2010-08-01'
+            }
+          )
+
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :idempotent => idempotent,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*)<\/Code>.*<Message>(.*)<\/Message>/)
+              case match[1]
+              when 'AlreadyExists'
+                #raise Fog::AWS::AutoScaling::IdentifierTaken.new(match[2])
+                raise Fog::AWS::AutoScaling::IdentifierTaken.slurp(error, match[2])
+              when 'ResourceInUse'
+                raise Fog::AWS::AutoScaling::ResourceInUse.slurp(error, match[2])
+              when 'ValidationError'
+                raise Fog::AWS::AutoScaling::ValidationError.slurp(error, match[2])
+              else
+                raise Fog::Compute::AWS::Error.slurp(error, "#{match[1]} => #{match[2]}")
+              end
+            else
+             raise
+            end
+          end
+
+          response
+        end
+
+      end
+
+      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] = {
+                :adjustment_types => [
+                  'ChangeInCapacity',
+                  'ExactCapacity',
+                  'PercentChangeInCapacity'
+                ],
+                :auto_scaling_groups => {},
+                :health_states => ['Healthy', 'Unhealthy'],
+                :launch_configurations => {},
+                :metric_collection_types => {
+                  :granularities => [ '1Minute' ],
+                  :metrics => [
+                    'GroupMinSize',
+                    'GroupMaxSize',
+                    'GroupDesiredCapacity',
+                    'GroupInServiceInstances',
+                    'GroupPendingInstances',
+                    'GroupTerminatingInstances',
+                    'GroupTotalInstances'
+                  ],
+                },
+                :process_types => [
+                  'AZRebalance',
+                  'AlarmNotification',
+                  'HealthCheck',
+                  'Launch',
+                  'ReplaceUnhealthy',
+                  'ScheduledActions',
+                  'Terminate'
+                ]
+              }
+            end
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+
+          @aws_access_key_id = options[:aws_access_key_id]
+
+          @region = options[:region] || 'us-east-1'
+
+          unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'sa-east-1', 'us-east-1', 'us-west-1', 'us-west-2'].include?(@region)
+            raise ArgumentError, "Unknown region: #{@region.inspect}"
+          end
+
+        end
+
+        def data
+          self.class.data[@region][@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data[@region].delete(@aws_access_key_id)
+        end
+
+      end
+
+    end
+  end
+end