tecnh-fog 0.2.23.vpc

data/lib/fog/aws/bin.rb

@@ -0,0 +1,73 @@
+module AWS
+  class << self
+    credential = (ARGV.first && :"#{ARGV.first}") || :default
+    if Fog.credentials[:aws_access_key_id] && Fog.credentials[:aws_secret_access_key]
+
+      def initialized?
+        true
+      end
+
+      def [](service)
+        @@connections ||= Hash.new do |hash, key|
+          credentials = Fog.credentials.reject do |k, v|
+            ![:aws_access_key_id, :aws_secret_access_key].include?(k)
+          end
+          hash[key] = case key
+          when :ec2
+            Fog::AWS::EC2.new(credentials)
+          when :elb
+            Fog::AWS::ELB.new(credentials)
+          when :simpledb
+            Fog::AWS::SimpleDB.new(credentials)
+          when :s3
+            Fog::AWS::S3.new(credentials)
+          end
+        end
+        @@connections[service]
+      end
+
+      def addresses
+        self[:ec2].addresses
+      end
+
+      def directories
+        self[:s3].directories
+      end
+
+      def flavors
+        self[:ec2].flavors
+      end
+
+      def images
+        self[:ec2].images
+      end
+
+      def servers
+        self[:ec2].servers
+      end
+
+      def key_pairs
+        self[:ec2].key_pairs
+      end
+
+      def security_groups
+        self[:ec2].security_groups
+      end
+
+      def snapshots
+        self[:ec2].snapshots
+      end
+
+      def volumes
+        self[:ec2].volumes
+      end
+
+    else
+
+      def initialized?
+        false
+      end
+
+    end
+  end
+end

data/lib/fog/aws/ec2.rb

@@ -0,0 +1,221 @@
+	module Fog
+  module AWS
+    module EC2
+      extend Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+
+      model_path 'fog/aws/models/ec2'
+      model 'address'
+      model 'addresses'
+      model 'flavor'
+      model 'flavors'
+      model 'image'
+      model 'images'
+      model 'key_pair'
+      model 'key_pairs'
+      model 'security_group'
+      model 'security_groups'
+      model 'server'
+      model 'servers'
+      model 'snapshot'
+      model 'snapshots'
+      model 'volume'
+      model 'volumes'
+
+      require 'fog/aws/parsers/ec2/basic'
+
+      request_path 'fog/aws/requests/ec2'
+      request 'allocate_address'
+      request 'associate_address'
+      request 'attach_volume'
+      request 'authorize_security_group_ingress'
+      request 'create_key_pair'
+      request 'create_security_group'
+      request 'create_snapshot'
+      request 'create_image'
+      request 'create_volume'
+      request 'delete_key_pair'
+      request 'delete_security_group'
+      request 'delete_snapshot'
+      request 'delete_volume'
+      request 'deregister_image'
+      request 'describe_addresses'
+      request 'describe_availability_zones'
+      request 'describe_images'
+      request 'describe_instances'
+      request 'describe_reserved_instances'
+      request 'describe_key_pairs'
+      request 'describe_regions'
+      request 'describe_security_groups'
+      request 'describe_snapshots'
+      request 'describe_volumes'
+      request 'detach_volume'
+      request 'disassociate_address'
+      request 'get_console_output'
+      request 'modify_image_attributes'
+      request 'modify_snapshot_attribute'
+      request 'reboot_instances'
+      request 'release_address'
+      request 'register_image'
+      request 'revoke_security_group_ingress'
+      request 'run_instances'
+      request 'terminate_instances'
+      request 'start_instances'
+      request 'stop_instances'
+
+      class Mock
+        include Collections
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            owner_id = Fog::AWS::Mock.owner_id
+            hash[key] = {
+              :deleted_at => {},
+              :addresses  => {},
+              :instances  => {},
+              :key_pairs  => {},
+              :limits     => { :addresses => 5 },
+              :owner_id   => owner_id,
+              :security_groups => {
+                'default' => {
+                  'groupDescription'  => 'default group',
+                  'groupName'         => 'default',
+                  'ipPermissions'     => [
+                    {
+                      'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
+                      'fromPort'    => -1,
+                      'toPort'      => -1,
+                      'ipProtocol'  => 'icmp',
+                      'ipRanges'    => []
+                    },
+                    {
+                      'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
+                      'fromPort'    => 0,
+                      'toPort'      => 65535,
+                      'ipProtocol'  => 'tcp',
+                      'ipRanges'    => []
+                    },
+                    {
+                      'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
+                      'fromPort'    => 0,
+                      'toPort'      => 65535,
+                      'ipProtocol'  => 'udp',
+                      'ipRanges'    => []
+                    }
+                  ],
+                  'ownerId'           => owner_id
+                }
+              },
+              :snapshots => {},
+              :volumes => {}
+            }
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @aws_access_key_id = options[:aws_access_key_id]
+          @data = self.class.data[@aws_access_key_id]
+          @owner_id = @data[:owner_id]
+        end
+
+      end
+
+      class Real
+        include Collections
+
+        # 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 {}.
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1']
+        #
+        # ==== 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 = Fog::HMAC.new('sha256', @aws_secret_access_key)
+          @host = options[:host] || case options[:region]
+            when 'ap-southeast-1'
+              'ec2.ap-southeast-1.amazonaws.com'
+            when 'eu-west-1'
+              'ec2.eu-west-1.amazonaws.com'
+            when 'us-east-1'
+              'ec2.us-east-1.amazonaws.com'
+            when 'us-west-1'
+              'ec2.us-west-1.amazonaws.com'
+            else
+              'ec2.amazonaws.com'
+            end
+          @port   = options[:port]      || 443
+          @scheme = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        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,
+              :version            => '2009-11-30'
+            }
+          )
+
+          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::Error => error
+            if match = error.message.match(/<Code>(.*)<\/Code><Message>(.*)<\/Message>/)
+              raise case match[1].split('.').last
+              when 'NotFound'
+                Fog::AWS::EC2::NotFound.slurp(error, match[2])
+              else
+                Fog::AWS::EC2::Error.slurp(error, "#{match[1]} => #{match[2]}")
+              end
+            else
+              raise error
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/elb.rb

@@ -0,0 +1,105 @@
+module Fog
+  module AWS
+    module ELB
+      extend Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+
+      request_path 'fog/aws/requests/elb'
+      request 'create_load_balancer'
+      request 'delete_load_balancer'
+      request 'deregister_instances_from_load_balancer'
+      request 'describe_instance_health'
+      request 'describe_load_balancers'
+      request 'disable_availability_zones_for_load_balancer'
+      request 'enable_availability_zones_for_load_balancer'
+      request 'register_instances_with_load_balancer'
+
+      class Mock
+        include Collections
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+        include Collections
+
+        # Initialize connection to ELB
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   elb = ELB.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, in ['eu-west-1', 'us-east-1', 'us-west-1'i, 'ap-southeast-1']
+        #
+        # ==== Returns
+        # * ELB 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 = Fog::HMAC.new('sha256', @aws_secret_access_key)
+          @host = options[:host] || case options[:region]
+          when 'ap-southeast-1'
+            'elasticloadbalancing.ap-southeast-1.amazonaws.com'
+          when 'eu-west-1'
+            'elasticloadbalancing.eu-west-1.amazonaws.com'
+          when 'us-east-1'
+            'elasticloadbalancing.us-east-1.amazonaws.com'
+          when 'us-west-1'
+            'elasticloadbalancing.us-west-1.amazonaws.com'
+          else
+            'elasticloadbalancing.amazonaws.com'
+          end
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        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,
+              :version            => '2009-11-25'
+            }
+          )
+
+          response = @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :idempotent => idempotent,
+            :host       => @host,
+            :method     => 'POST',
+            :parser     => parser
+          })
+
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'fog/model'
+
+module Fog
+  module AWS
+    module EC2
+
+      class Address < Fog::Model
+
+        identity  :public_ip,   'publicIp'
+
+        attribute :server_id, 'instanceId'
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with new_record?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :public_ip
+
+          connection.release_address(@public_ip)
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            associate(new_server)
+          else
+            disassociate
+          end
+        end
+
+        def save
+          data = connection.allocate_address
+          @public_ip = data.body['publicIp']
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        private
+
+        def associate(new_server)
+          if new_record?
+            @server = new_server
+          else
+            @server = nil
+            @server_id = new_server.id
+            connection.associate_address(@server_id, @public_ip)
+          end
+        end
+
+        def disassociate
+          @server = nil
+          @server_id = nil
+          unless new_record?
+            connection.disassociate_address(@public_ip)
+          end
+        end
+
+      end
+
+    end
+  end
+end