phpfog-fog 0.4.1

data/lib/fog/aws/requests/simpledb/put_attributes.rb

@@ -0,0 +1,78 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        # Put item attributes into a SimpleDB domain
+        #
+        # ==== Parameters
+        # * domain_name<~String> - Name of domain. Must be between 3 and 255 of the
+        # following characters: a-z, A-Z, 0-9, '_', '-' and '.'.
+        # * item_name<~String> - Name of the item.  May use any UTF-8 characters valid
+        #   in xml.  Control characters and sequences not allowed in xml are not
+        #   valid.  Can be up to 1024 bytes long.
+        # * attributes<~Hash> - Name/value pairs to add to the item.  Attribute names
+        #   and values may use any UTF-8 characters valid in xml. Control characters
+        #   and sequences not allowed in xml are not valid.  Each name and value can
+        #   be up to 1024 bytes long.
+        # * options<~Hash> - Accepts the following keys.
+        #   :replace => [Array of keys to replace]
+        #   :expect => {name/value pairs for performing conditional put}
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def put_attributes(domain_name, item_name, attributes, options = {})
+          options[:expect] = {} unless options[:expect]
+          options[:replace] = [] unless options[:replace]
+          request({
+            'Action'      => 'PutAttributes',
+            'DomainName'  => domain_name,
+            'ItemName'    => item_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          }.merge!(encode_attributes(attributes, options[:replace], options[:expect])))
+        end
+
+      end
+
+      class Mock
+
+        def put_attributes(domain_name, item_name, attributes, options = {})
+          options[:expect] = {} unless options[:expect]
+          options[:replace] = [] unless options[:replace]
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            options[:expect].each do |ck, cv|
+              if @data[:domains][domain_name][item_name][ck] != [cv]
+                response.status = 409
+                raise(Excon::Errors.status_error({:expects => 200}, response))
+              end
+            end
+            attributes.each do |key, value|
+              @data[:domains][domain_name][item_name] ||= {}
+              @data[:domains][domain_name][item_name][key.to_s] = [] unless @data[:domains][domain_name][item_name][key.to_s]
+              if options[:replace].include?(key.to_s)
+                @data[:domains][domain_name][item_name][key.to_s] = [*value].map {|x| x.to_s}
+              else
+                @data[:domains][domain_name][item_name][key.to_s] += [*value].map {|x| x.to_s}
+              end
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/select.rb

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    class SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/select'
+
+        # Select item data from SimpleDB
+        #
+        # ==== Parameters
+        # * select_expression<~String> - Expression to query domain with.
+        # * next_token<~String> - Offset token to start list, defaults to nil.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'<~Float>
+        #     * 'RequestId'<~String>
+        #     * 'Items'<~Hash> - list of attribute name/values for the items formatted as 
+        #       { 'item_name' => { 'attribute_name' => ['attribute_value'] }}
+        #     * 'NextToken'<~String> - offset to start with if there are are more domains to list
+        def select(select_expression, next_token = nil)
+          request(
+            'Action'            => 'Select',
+            'NextToken'         => next_token,
+            'SelectExpression'  => select_expression,
+            :idempotent         => true,
+            :parser             => Fog::Parsers::AWS::SimpleDB::Select.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def select(select_expression, next_token = nil)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/ses.rb

@@ -0,0 +1,99 @@
+module Fog
+  module AWS
+    class SES < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/aws/requests/ses'
+      request :delete_verified_email_address
+      request :verify_email_address
+      request :get_send_quota
+      request :get_send_statistics
+      request :list_verified_email_addresses
+      request :send_email
+      request :send_raw_email
+
+      class Mock
+
+        def initialize(options={})
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to SES
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   ses = SES.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
+        # * SES 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)
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+          when 'us-east-1'
+            'email.us-east-1.amazonaws.com'
+          else
+            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+          end
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", 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,
+              :path               => @path,
+              :port               => @port,
+              :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/simpledb.rb

@@ -0,0 +1,172 @@
+module Fog
+  module AWS
+    class SimpleDB < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :host, :nil_string, :path, :port, :scheme, :persistent
+      
+      request_path 'fog/aws/requests/simpledb'
+      request :batch_put_attributes
+      request :create_domain
+      request :delete_attributes
+      request :delete_domain
+      request :domain_metadata
+      request :get_attributes
+      request :list_domains
+      request :put_attributes
+      request :select
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :domains => {}
+            }
+          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]
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to SimpleDB
+        #
+        # ==== 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
+        # * SimpleDB 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]      || 'sdb.amazonaws.com'
+          @nil_string = options[:nil_string]|| 'nil'
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        private
+
+        def encode_attributes(attributes, replace_attributes = [], expected_attributes = {})
+          encoded_attributes = {}
+          if attributes
+
+            expected_attributes.keys.each_with_index do |exkey, index|
+              for value in Array(expected_attributes[exkey])
+                encoded_attributes["Expected.#{index}.Name"] = exkey.to_s
+                encoded_attributes["Expected.#{index}.Value"] = sdb_encode(value)
+              end
+            end
+
+            index = 0
+            for key in attributes.keys
+              for value in Array(attributes[key])
+                encoded_attributes["Attribute.#{index}.Name"] = key.to_s
+                if replace_attributes.include?(key)
+                  encoded_attributes["Attribute.#{index}.Replace"] = 'true'
+                end
+                encoded_attributes["Attribute.#{index}.Value"] = sdb_encode(value)
+                index += 1
+              end
+            end
+          end
+          encoded_attributes
+        end
+
+        def encode_attribute_names(attributes)
+          AWS.indexed_param('AttributeName', attributes.map {|attribute| attributes.to_s})
+        end
+
+        def encode_batch_attributes(items, replace_attributes = Hash.new([]))
+          encoded_attributes = {}
+          if items
+            item_index = 0
+            for item_key in items.keys
+              encoded_attributes["Item.#{item_index}.ItemName"] = item_key.to_s
+              for attribute_key in items[item_key].keys
+                attribute_index = 0
+                for value in Array(items[item_key][attribute_key])
+                  encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Name"] = attribute_key.to_s
+                  if replace_attributes[item_key].include?(attribute_key)
+                    encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Replace"] = 'true'
+                  end
+                  encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Value"] = sdb_encode(value)
+                  attribute_index += 1
+                end
+                item_index += 1
+              end
+            end
+          end
+          encoded_attributes
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        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            => '2009-04-15'
+            }
+          )
+
+          response = @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :host       => @host,
+            :idempotent => idempotent,
+            :method     => 'POST',
+            :parser     => parser
+          })
+
+          response
+        end
+
+        def sdb_encode(value)
+          if value.nil?
+            @nil_string
+          else
+            value.to_s
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/bin/aws.rb

@@ -0,0 +1,71 @@
+class AWS < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :cdn
+        Fog::AWS::CDN
+      when :compute, :ec2
+        Fog::AWS::Compute
+      when :dns
+        Fog::AWS::DNS
+      when :elb
+        Fog::AWS::ELB
+      when :iam
+        Fog::AWS::IAM
+      when :sdb
+        Fog::AWS::SimpleDB
+      when :eu_storage, :s3, :storage
+        Fog::AWS::Storage
+      else
+        # @todo Replace most instances of ArgumentError with NotImplementedError
+        # @todo For a list of widely supported Exceptions, see:
+        # => http://www.zenspider.com/Languages/Ruby/QuickRef.html#35
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :cdn
+          Fog::CDN.new(:provider => 'AWS')
+        when :compute
+          Fog::Compute.new(:provider => 'AWS')
+        when :dns
+          Fog::DNS.new(:provider => 'AWS')
+        when :ec2
+          location = caller.first
+          warning = "[yellow][WARN] AWS[:ec2] is deprecated, use AWS[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Compute.new(:provider => 'AWS')
+        when :elb
+          Fog::AWS::ELB.new
+        when :iam
+          Fog::AWS::IAM.new
+        when :eu_storage
+          Fog::Storage.new(:provider => 'AWS', :region => 'eu-west-1')
+        when :sdb
+          Fog::AWS::SimpleDB.new
+        when :s3
+          location = caller.first
+          warning = "[yellow][WARN] AWS[:s3] is deprecated, use AWS[:storage] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Storage.new(:provider => 'AWS')
+        when :storage
+          Fog::Storage.new(:provider => 'AWS')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:cdn, :compute, :dns, :elb, :iam, :sdb, :storage]
+    end
+
+  end
+end

data/lib/fog/bin/bluebox.rb

@@ -0,0 +1,36 @@
+class Bluebox < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :blocks, :compute
+        Fog::Bluebox::Compute
+      else 
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :blocks
+          location = caller.first
+          warning = "[yellow][WARN] Bluebox[:blocks] is deprecated, use Bluebox[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Compute.new(:provider => 'Bluebox')
+        when :compute
+          Fog::Compute.new(:provider => 'Bluebox')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:compute]
+    end
+
+  end
+end

data/lib/fog/bin/brightbox.rb

@@ -0,0 +1,34 @@
+class Brightbox < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Brightbox::Compute
+      else 
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Compute.new(:provider => 'Brightbox')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:compute]
+    end
+
+    def account
+      @@connections[:compute].account
+    end
+
+  end
+end

data/lib/fog/bin/go_grid.rb

@@ -0,0 +1,36 @@
+class GoGrid < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute, :servers
+        Fog::GoGrid::Compute
+      else 
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Compute.new(:provider => 'GoGrid')
+        when :servers
+          location = caller.first
+          warning = "[yellow][WARN] GoGrid[:servers] is deprecated, use GoGrid[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Compute.new(:provider => 'GoGrid')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:compute]
+    end
+
+  end
+end

data/lib/fog/bin/google.rb

@@ -0,0 +1,30 @@
+class Google < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :storage
+        Fog::Google::Storage
+      else 
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :storage
+          Fog::Storage.new(:provider => 'Google')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:storage]
+    end
+
+  end
+end

data/lib/fog/bin/linode.rb

@@ -0,0 +1,40 @@
+class Linode < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Linode::Compute
+      when :dns
+        Fog::Linode::DNS
+      else
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Compute.new(:provider => 'Linode')
+        when :dns
+          Fog::DNS.new(:provider => 'Linode')
+        when :linode
+          location = caller.first
+          warning = "[yellow][WARN] Linode[:linode] is deprecated, use Linode[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Compute.new(:provider => 'Linode')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:compute, :dns]
+    end
+
+  end
+end

data/lib/fog/bin/local.rb

@@ -0,0 +1,36 @@
+class Local < Fog::Bin
+  class << self
+
+    def class_for(key)
+      case key
+      when :files, :storage
+        Fog::Local::Storage
+      else 
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :files
+          location = caller.first
+          warning = "[yellow][WARN] Local[:files] is deprecated, use Local[:storage] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Storage.new(:provider => 'Local')
+        when :storage
+          Fog::Storage.new(:provider => 'Local')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:storage]
+    end
+
+  end
+end