fog 0.0.3

data/lib/fog/aws.rb

@@ -0,0 +1,145 @@
+require 'rubygems'
+require 'base64'
+require 'cgi'
+require 'digest/md5'
+require 'hmac-sha1'
+require 'hmac-sha2'
+require 'mime/types'
+
+module Fog
+  module AWS
+
+    def self.reload
+      current_directory = File.dirname(__FILE__)
+      load "#{current_directory}/aws/ec2.rb"
+      load "#{current_directory}/aws/simpledb.rb"
+      load "#{current_directory}/aws/s3.rb"
+    end
+
+    if Fog.mocking?
+      srand(Time.now.to_i)
+
+      class Mock
+
+        def self.availability_zone
+          "us-east-1" << random_selection('abcd', 1)
+        end
+
+        def self.etag
+          hex(32)
+        end
+
+        def self.key_fingerprint
+          fingerprint = []
+          20.times do
+            fingerprint << hex(2)
+          end
+          fingerprint.join(':')
+        end
+
+        def self.image_id
+          "ami-#{hex(8)}"
+        end
+
+        def self.instance_id
+          "i-#{hex(8)}"
+        end
+
+        def self.ip_address
+          ip = []
+          4.times do
+            ip << numbers(rand(3) + 1).to_i.to_s # remove leading 0
+          end
+          ip.join('.')
+        end
+
+        def self.kernel_id
+          "aki-#{hex(8)}"
+        end
+
+        def self.key_material
+          key_material = ['-----BEGIN RSA PRIVATE KEY-----']
+          20.times do
+            key_material << base64(76)
+          end
+          key_material << base64(67) + '='
+          key_material << '-----END RSA PRIVATE KEY-----'
+          key_material.join("\n")
+        end
+
+        def self.owner_id
+          numbers(12)
+        end
+
+        def self.request_id
+          request_id = []
+          request_id << hex(8)
+          3.times do
+            request_id << hex(4)
+          end
+          request_id << hex(12)
+          request_id.join('-')
+        end
+
+        def self.ramdisk_id
+          "ari-#{hex(8)}"
+        end
+
+        def self.reservation_id
+          "r-#{hex(8)}"
+        end
+
+        def self.snapshot_id
+          "snap-#{hex(8)}"
+        end
+
+        def self.volume_id
+          "vol-#{hex(8)}"
+        end
+
+        private
+
+        def self.random_selection(characters, length)
+          selection = ''
+          length.times do
+            position = rand(characters.length)
+            selection << characters[position..position]
+          end
+          selection
+        end
+
+        def self.letters(length)
+          random_selection(
+            'abcdefghijklmnopqrstuvwxyz',
+            length
+          )
+        end
+
+        def self.numbers(length)
+          random_selection(
+            '0123456789',
+            length
+          )
+        end
+
+        def self.hex(length)
+          random_selection(
+            '0123456789abcdef',
+            length
+          )
+        end
+
+        def self.base64(length)
+          random_selection(
+            "ABCDEFGHIJKLMNOP QRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+            length
+          )
+        end
+
+      end
+    end
+
+  end
+end
+
+Fog::AWS.reload

data/lib/fog/aws/ec2.rb

@@ -0,0 +1,173 @@
+module Fog
+  module AWS
+    class EC2
+
+      if Fog.mocking?
+        def self.data
+          @data
+        end
+        def self.reset_data
+          @data = {
+            :deleted_at => {},
+            :addresses => {},
+            :instances => {},
+            :key_pairs => {},
+            :security_groups => {},
+            :snapshots => {},
+            :volumes => {}
+          }
+        end
+      end
+
+      def self.reload
+        current_directory = File.dirname(__FILE__)
+        load "#{current_directory}/../connection.rb"
+        load "#{current_directory}/../parser.rb"
+        load "#{current_directory}/../response.rb"
+
+        parsers_directory = "#{current_directory}/parsers/ec2"
+        load "#{parsers_directory}/allocate_address.rb"
+        load "#{parsers_directory}/attach_volume.rb"
+        load "#{parsers_directory}/basic.rb"
+        load "#{parsers_directory}/create_key_pair.rb"
+        load "#{parsers_directory}/create_snapshot.rb"
+        load "#{parsers_directory}/create_volume.rb"
+        load "#{parsers_directory}/describe_addresses.rb"
+        load "#{parsers_directory}/describe_availability_zones.rb"
+        load "#{parsers_directory}/describe_images.rb"
+        load "#{parsers_directory}/describe_instances.rb"
+        load "#{parsers_directory}/describe_key_pairs.rb"
+        load "#{parsers_directory}/describe_regions.rb"
+        load "#{parsers_directory}/describe_security_groups.rb"
+        load "#{parsers_directory}/describe_snapshots.rb"
+        load "#{parsers_directory}/describe_volumes.rb"
+        load "#{parsers_directory}/detach_volume.rb"
+        load "#{parsers_directory}/get_console_output.rb"
+        load "#{parsers_directory}/run_instances.rb"
+        load "#{parsers_directory}/terminate_instances.rb"
+
+        requests_directory = "#{current_directory}/requests/ec2"
+        load "#{requests_directory}/allocate_address.rb"
+        load "#{requests_directory}/associate_address.rb"
+        load "#{requests_directory}/attach_volume.rb"
+        load "#{requests_directory}/authorize_security_group_ingress.rb"
+        # TODO: require "#{requests_directory}/bundle_instance.rb"
+        # TODO: require "#{requests_directory}/cancel_bundle_task.rb"
+        # TODO: require "#{requests_directory}/confirm_product_instance.rb"
+        load "#{requests_directory}/create_key_pair.rb"
+        load "#{requests_directory}/create_security_group.rb"
+        load "#{requests_directory}/create_snapshot.rb"
+        load "#{requests_directory}/create_volume.rb"
+        load "#{requests_directory}/delete_key_pair.rb"
+        load "#{requests_directory}/delete_security_group.rb"
+        load "#{requests_directory}/delete_snapshot.rb"
+        load "#{requests_directory}/delete_volume.rb"
+        # TODO: require "#{requests_directory}/deregister_image.rb"
+        load "#{requests_directory}/describe_addresses.rb"
+        load "#{requests_directory}/describe_availability_zones.rb"
+        # TODO: require "#{requests_directory}/describe_bundle_tasks.rb"
+        # TODO: require "#{requests_directory}/describe_image_attribute.rb"
+        load "#{requests_directory}/describe_images.rb"
+        load "#{requests_directory}/describe_instances.rb"
+        load "#{requests_directory}/describe_key_pairs.rb"
+        load "#{requests_directory}/describe_regions.rb"
+        # TODO: require "#{requests_directory}/describe_reserved_instances.rb"
+        # TODO: require "#{requests_directory}/describe_reserved_instances_offerings.rb"
+        load "#{requests_directory}/describe_security_groups.rb"
+        load "#{requests_directory}/describe_snapshots.rb"
+        load "#{requests_directory}/describe_volumes.rb"
+        load "#{requests_directory}/detach_volume.rb"
+        load "#{requests_directory}/disassociate_address.rb"
+        load "#{requests_directory}/get_console_output.rb"
+        # TODO: require "#{requests_directory}/modify_image_attribute.rb"
+        # TODO: require "#{requests_directory}/monitor_instances.rb"
+        # TODO: require "#{requests_directory}/purchase_reserved_instances_offering.rb"
+        load "#{requests_directory}/reboot_instances.rb"
+        # TODO: require "#{requests_directory}/register_image.rb"
+        load "#{requests_directory}/release_address.rb"
+        load "#{requests_directory}/revoke_security_group_ingress.rb"
+        load "#{requests_directory}/run_instances.rb"
+        load "#{requests_directory}/terminate_instances.rb"
+        # TODO: require "#{requests_directory}/unmonitor_instances.rb"
+
+        if Fog.mocking?
+          reset_data
+        end
+
+      end
+
+      # Initialize connection to EC2
+      #
+      # ==== Notes
+      # options parameter must include values for :aws_access_key_id and 
+      # :aws_secret_access_key in order to create a connection
+      #
+      # ==== Examples
+      #   sdb = SimpleDB.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
+      # * EC2 object with connection to aws.
+      def initialize(options={})
+        @aws_access_key_id      = options[:aws_access_key_id]
+        @aws_secret_access_key  = options[:aws_secret_access_key]
+        @hmac       = HMAC::SHA256.new(@aws_secret_access_key)
+        @host       = options[:host]      || 'ec2.amazonaws.com'
+        @port       = options[:port]      || 443
+        @scheme     = options[:scheme]    || 'https'
+        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
+      end
+
+      private
+
+      def indexed_params(name, params)
+        indexed, index = {}, 1
+        for param in [*params]
+          indexed["#{name}.#{index}"] = param
+          index += 1
+        end
+        indexed
+      end
+
+      def request(params, parser)
+        params.merge!({
+          'AWSAccessKeyId' => @aws_access_key_id,
+          'SignatureMethod' => 'HmacSHA256',
+          'SignatureVersion' => '2',
+          'Timestamp' => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+          'Version' => '2009-04-04'
+        })
+
+        body = ''
+        for key in params.keys.sort
+          unless (value = params[key]).nil?
+            body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
+          end
+        end
+
+        string_to_sign = "POST\n#{@host}\n/\n" << body.chop
+        hmac = @hmac.update(string_to_sign)
+        body << "Signature=#{CGI.escape(Base64.encode64(hmac.digest).chomp!).gsub(/\+/, '%20')}"
+
+        response = @connection.request({
+          :body     => body,
+          :expects  => 200,
+          :headers  => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+          :host     => @host,
+          :method   => 'POST',
+          :parser   => parser
+        })
+
+        response
+      end
+
+    end
+  end
+end
+
+Fog::AWS::EC2.reload

data/lib/fog/aws/models/ec2/address.rb

@@ -0,0 +1,31 @@
+module Fog
+  module AWS
+    class EC2
+
+      class Address < Fog::Model
+
+        attr_accessor :instance_id,
+                      :public_ip
+
+        def initialize(attributes = {})
+          remap_attributes(attributes, {
+            'instanceId'  => :instance_id,
+            'publicIp'    => :public_ip
+          })
+          super
+        end
+
+        def delete
+          connection.release_address(@public_ip)
+        end
+
+        def save
+          data = connection.allocate_address
+          @public_ip = data.body['publicIp']
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/ec2/addresses.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class EC2
+
+      def addresses
+        Fog::AWS::EC2::Addresses.new(:connection => self)
+      end
+
+      class Addresses < Fog::Collection
+
+        def all(public_ip = [])
+          data = connection.describe_addresses(public_ip).body
+          addresses = []
+          data['addressesSet'].each do |address|
+            addresses << Fog::AWS::EC2::Address.new({
+              :connection => connection
+            }.merge!(address))
+          end
+          addresses
+        end
+
+        def create
+          address = new
+          address.save
+          address
+        end
+
+        def new
+          Fog::AWS::S3::Address.new(:connection => connection)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/ec2/key_pair.rb

@@ -0,0 +1,35 @@
+module Fog
+  module AWS
+    class EC2
+
+      class KeyPair < Fog::Model
+
+        attr_accessor :fingerprint,
+                      :material,
+                      :name
+
+        def initialize(attributes = {})
+          remap_attributes(attributes, {
+            'keyFingerprint'  => :fingerprint,
+            'keyMaterial'     => :material,
+            'keyName'         => :name
+          })
+          super
+        end
+
+        def delete
+          connection.delete_key_pair(@name)
+        end
+
+        def save
+          data = connection.create_key_pair(@name).body
+          new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
+          update_attributes(new_attributes)
+          data
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/ec2/key_pairs.rb

@@ -0,0 +1,36 @@
+module Fog
+  module AWS
+    class EC2
+
+      def key_pairs
+        Fog::AWS::EC2::KeyPairs.new(:connection => self)
+      end
+
+      class KeyPairs < Fog::Collection
+
+        def all(key_name = [])
+          data = connection.describe_key_pairs(key_name).body
+          key_pairs = []
+          data['keySet'].each do |key|
+            key_pairs << Fog::AWS::EC2::KeyPair.new({
+              :connection => connection
+            }.merge!(key))
+          end
+          key_pairs
+        end
+
+        def create(attributes = {})
+          bucket = new(attributes)
+          bucket.save
+          bucket
+        end
+
+        def new(attributes = {})
+          Fog::AWS::EC2::KeyPair.new(attributes.merge!(:connection => connection))
+        end
+
+      end
+
+    end
+  end
+end