fog 0.0.84 → 0.0.85

data/lib/fog/aws/requests/elb/describe_load_balancers.rb

@@ -0,0 +1,57 @@
+module Fog
+  module AWS
+    module ELB
+      class Real
+
+        # Describe all or specified load balancers
+        #
+        # ==== Parameters
+        # * lb_name<~Array> - List of load balancer names to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancersResult'<~Hash>:
+        #       * 'LoadBalancerDescriptions'<~Array>
+        #         * 'LoadBalancerName'<~String> - name of load balancer
+        #         * 'DNSName'<~String> - external DNS name of load balancer
+        #         * 'CreatedTime'<~Time> - time load balancer was created
+        #         * 'ListenerDescriptions'<~Array>
+        #           * 'PolicyNames'<~Array> - list of policies enabled
+        #           * 'Listener'<~Hash>:
+        #             * 'InstancePort'<~Integer> - port on instance that requests are sent to
+        #             * 'Protocol'<~String> - transport protocol used for routing in [TCP, HTTP]
+        #             * 'LoadBalancerPort'<~Integer> - port that load balancer listens on for requests
+        #         * 'HealthCheck'<~Hash>:
+        #           * 'HealthyThreshold'<~Integer> - number of consecutive health probe successes required before moving the instance to the Healthy state
+        #           * 'Timeout'<~Integer> - number of seconds after which no response means a failed health probe
+        #           * 'Interval'<~Integer> - interval (in seconds) between health checks of an individual instance
+        #           * 'UnhealthyThreshold'<~Integer> - number of consecutive health probe failures that move the instance to the unhealthy state
+        #           * 'Target'<~String> - string describing protocol type, port and URL to check
+        #         * 'Policies'<~Hash>:
+        #           * 'LBCookieStickinessPolicies'<~Array> - list of Load Balancer Generated Cookie Stickiness policies for the LoadBalancer
+        #           * 'AppCookieStickinessPolicies'<~Array> - list of Application Generated Cookie Stickiness policies for the LoadBalancer
+        #         * 'AvailabilityZones'<~Array> - list of availability zones covered by this load balancer
+        #         * 'Instances'<~Array> - list of instances that the load balancer balances between
+        def describe_load_balancers(lb_name = [])
+          params = ELB.indexed_param('LoadBalancerNames.member', [*lb_name], 1)
+          request({
+            'Action'  => 'DescribeLoadBalancers',
+            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancers.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_load_balancers(lb_name = [])
+          raise MockNotImplemented.new("Contributions welcome!")
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/disable_availability_zones_for_load_balancer.rb

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    module ELB
+      class Real
+
+        # Disable an availability zone for an existing ELB
+        #
+        # ==== Parameters
+        # * availability_zones<~Array> - List of availability zones to disable on ELB
+        # * lb_name<~String> - Load balancer to disable availability zones on
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DisableAvailabilityZonesForLoadBalancerResult'<~Hash>:
+        #       * 'AvailabilityZones'<~Array> - array of strings describing instances currently enabled
+        def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          params = ELB.indexed_param('AvailabilityZones.member', [*availability_zones], 1)
+          request({
+            'Action'           => 'DisableAvailabilityZonesForLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::DisableAvailabilityZonesForLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :disable_zones :disable_availability_zones_for_load_balancer
+
+      end
+
+      class Mock
+
+        def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          raise MockNotImplemented.new("Contributions welcome!")
+        end
+
+        alias :disable_zones :disable_availability_zones_for_load_balancer
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/enable_availability_zones_for_load_balancer.rb

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    module ELB
+      class Real
+
+        # Enable an availability zone for an existing ELB
+        #
+        # ==== Parameters
+        # * availability_zones<~Array> - List of availability zones to enable on ELB
+        # * lb_name<~String> - Load balancer to enable availability zones on
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'EnableAvailabilityZonesForLoadBalancerResult'<~Hash>:
+        #       * 'AvailabilityZones'<~Array> - array of strings describing instances currently enabled
+        def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          params = ELB.indexed_param('AvailabilityZones.member', [*availability_zones], 1)
+          request({
+            'Action'           => 'EnableAvailabilityZonesForLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::EnableAvailabilityZonesForLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :enable_zones :enable_availability_zones_for_load_balancer
+
+      end
+
+      class Mock
+
+        def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          raise MockNotImplemented.new("Contributions welcome!")
+        end
+
+        alias :enable_zones :enable_availability_zones_for_load_balancer
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/register_instances_with_load_balancer.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    module ELB
+      class Real
+
+        # Register an instance with an existing ELB
+        #
+        # ==== Parameters
+        # * instance_ids<~Array> - List of instance IDs to associate with ELB
+        # * lb_name<~String> - Load balancer to assign instances to
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'RegisterInstancesWithLoadBalancerResult'<~Hash>:
+        #       * 'Instances'<~Array> - array of hashes describing instances currently enabled
+        #         * 'InstanceId'<~String>
+        def register_instances_with_load_balancer(instance_ids, lb_name)
+          params = ELB.indexed_param('Instances.member.%.InstanceId', [*instance_ids], 1)
+          request({
+            'Action'           => 'RegisterInstancesWithLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::RegisterInstancesWithLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :register_instances :register_instances_with_load_balancer
+
+      end
+
+      class Mock
+
+        def register_instances_with_load_balancer(instance_ids, lb_name)
+          raise MockNotImplemented.new("Contributions welcome!")
+        end
+
+        alias :register_instances :register_instances_with_load_balancer
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/s3.rb

@@ -127,7 +127,14 @@ module Fog
             raise ArgumentError.new('aws_secret_access_key is required to access ec2')
           end
           @hmac       = HMAC::SHA1.new(@aws_secret_access_key)
-          @host       = options[:host]      || 's3.amazonaws.com'
+          @host       = options[:host] || case options[:region]
+            when 'ap-southeast-1'
+              's3-ap-southeast-1.amazonaws.com'
+            when 'us-west-1'
+              's3-us-west-1.amazonaws.com'
+            else
+              's3.amazonaws.com'
+            end
           @port       = options[:port]      || 443
           @scheme     = options[:scheme]    || 'https'
         end

data/lib/fog/aws/simpledb.rb

@@ -136,24 +136,15 @@ module Fog
           idempotent = params.delete(:idempotent)
           parser = params.delete(:parser)
 
-          params.merge!({
-            'AWSAccessKeyId' => @aws_access_key_id,
-            'SignatureMethod' => 'HmacSHA256',
-            'SignatureVersion' => '2',
-            'Timestamp' => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            'Version' => '2007-11-07'
-          })
-
-          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')}"
+          body = AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :version            => '2007-11-07'
+            }
+          )
 
           response = @connection.request({
             :body       => body,

data/lib/fog/bin.rb

@@ -5,7 +5,7 @@ module Fog
 
     def services
       services = []
-      [::AWS, ::Rackspace, ::Slicehost, ::Terremark].each do |service|
+      [::AWS, ::Local, ::Rackspace, ::Slicehost, ::Terremark].each do |service|
         if service.initialized?
           services << service
         end
@@ -13,6 +13,16 @@ module Fog
       services
     end
 
+    def directories
+      directories = {}
+      services.each do |service|
+        if service.respond_to?(:directories)
+          directories[service] = service.directories
+        end
+      end
+      directories
+    end
+
     def flavors
       flavors = {}
       services.each do |service|

data/lib/fog/credentials.rb

@@ -27,6 +27,7 @@ module Fog
 :#{credential}:
   :aws_access_key_id:     INTENTIONALLY_LEFT_BLANK
   :aws_secret_access_key: INTENTIONALLY_LEFT_BLANK
+  :local_root:            INTENTIONALLY_LEFT_BLANK
   :rackspace_api_key:     INTENTIONALLY_LEFT_BLANK
   :rackspace_username:    INTENTIONALLY_LEFT_BLANK
   :slicehost_password:    INTENTIONALLY_LEFT_BLANK

data/lib/fog/local.rb

@@ -0,0 +1,72 @@
+module Fog
+  module Local
+
+    def self.new(options={})
+
+      unless @required
+        require 'fog/local/models/directories'
+        require 'fog/local/models/directory'
+        require 'fog/local/models/file'
+        require 'fog/local/models/files'
+        @required = true
+      end
+
+      unless options[:local_root]
+        raise ArgumentError.new('local_root is required to access local')
+      end
+      if Fog.mocking?
+        Fog::Local::Mock.new(options)
+      else
+        Fog::Local::Real.new(options)
+      end
+    end
+
+    def self.reset_data(keys=Mock.data.keys)
+      Mock.reset_data(keys)
+    end
+
+    class Mock
+
+      def self.data
+        @data ||= Hash.new do |hash, key|
+          hash[key] = {}
+        end
+      end
+
+      def self.reset_data(keys=data.keys)
+        for key in [*keys]
+          data.delete(key)
+        end
+      end
+
+      def initialize(options={})
+        @local_root = ::File.expand_path(options[:local_root])
+        @data       = self.class.data[@local_root]
+      end
+
+      def local_root
+        @local_root
+      end
+
+      def path(partial)
+        partial
+      end
+    end
+
+    class Real
+
+      def initialize(options={})
+        @local_root = ::File.expand_path(options[:local_root])
+      end
+
+      def local_root
+        @local_root
+      end
+
+      def path_to(partial)
+        ::File.join(@local_root, partial)
+      end
+    end
+
+  end
+end

data/lib/fog/local/bin.rb

@@ -0,0 +1,34 @@
+module Local
+  class << self
+    if Fog.credentials[:local_root]
+
+      def initialized?
+        true
+      end
+
+      def [](service)
+        @@connections ||= Hash.new do |hash, key|
+          credentials = Fog.credentials.reject do |k,v|
+            ![:local_root].include?(k)
+          end
+          hash[key] = case key
+          when :files
+            Fog::Local.new(credentials)
+          end
+        end
+        @@connections[service]
+      end
+
+      def directories
+        self[:files].directories
+      end
+
+    else
+
+      def initialized?
+        false
+      end
+
+    end
+  end
+end

data/lib/fog/local/models/directories.rb

@@ -0,0 +1,43 @@
+require 'fog/collection'
+require 'fog/local/models/directory'
+
+module Fog
+  module Local
+
+    class Real
+      def directories
+        Fog::Local::Directories.new(:connection => self)
+      end
+    end
+
+    class Mock
+      def directories
+        Fog::Local::Directories.new(:connection => self)
+      end
+    end
+
+    class Directories < Fog::Collection
+
+      model Fog::Local::Directory
+
+      def all
+        data = Dir.entries(connection.local_root).select do |entry|
+          entry[0...1] != '.' && ::File.directory?(connection.path_to(entry))
+        end.map do |entry| 
+          {:name => entry}
+        end
+        load(data)
+      end
+
+      def get(name)
+        if ::File.directory?(connection.path_to(name))
+          new(:name => name)
+        else
+          nil
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fog/local/models/directory.rb

@@ -0,0 +1,47 @@
+require 'fog/model'
+# require 'fog/local/models/files'
+
+module Fog
+  module Local
+
+    class Directory < Fog::Model
+
+      identity  :name
+
+      def destroy
+        requires :name
+
+        if ::File.directory?(path)
+          Dir.rmdir(path)
+          true
+        else
+          false
+        end
+      end
+
+      def files
+        @files ||= begin
+          Fog::Local::Files.new(
+            :directory    => self,
+            :connection   => connection
+          )
+        end
+      end
+
+      def save
+        requires :name
+
+        Dir.mkdir(path)
+        true
+      end
+
+      private
+
+      def path
+        connection.path_to(name)
+      end
+
+    end
+
+  end
+end