fog 0.2.30 → 0.3.0

data/lib/fog/aws/simpledb.rb

@@ -1,23 +1,21 @@
 module Fog
   module AWS
-    module SimpleDB
-      extend Fog::Service
+    class SimpleDB < Fog::Service
 
       requires :aws_access_key_id, :aws_secret_access_key
 
       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'
+      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
-        include Collections
 
         def self.data
           @data ||= Hash.new do |hash, key|
@@ -41,7 +39,6 @@ module Fog
       end
 
       class Real
-        include Collections
 
         # Initialize connection to SimpleDB
         #

data/lib/fog/aws/storage.rb

@@ -0,0 +1,209 @@
+module Fog
+  module AWS
+    class Storage < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+
+      model_path 'fog/aws/models/storage'
+      collection  :directories
+      model       :directory
+      collection  :files
+      model       :file
+
+      request_path 'fog/aws/requests/storage'
+      request :copy_object
+      request :delete_bucket
+      request :delete_object
+      request :get_bucket
+      request :get_bucket_acl
+      request :get_bucket_location
+      request :get_bucket_logging
+      request :get_bucket_object_versions
+      request :get_bucket_versioning
+      request :get_object
+      request :get_object_acl
+      request :get_object_torrent
+      request :get_object_url
+      request :get_request_payment
+      request :get_service
+      request :head_object
+      request :put_bucket
+      request :put_bucket_acl
+      request :put_bucket_logging
+      request :put_bucket_versioning
+      request :put_object
+      request :put_object_url
+      request :put_request_payment
+
+      module Utils
+
+        def parse_data(data)
+          metadata = {
+            :body => nil,
+            :headers => {}
+          }
+
+          if data.is_a?(String)
+            metadata[:body] = data
+            metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
+          else
+            filename = ::File.basename(data.path)
+            unless (mime_types = MIME::Types.of(filename)).empty?
+              metadata[:headers]['Content-Type'] = mime_types.first.content_type
+            end
+            metadata[:body] = data
+            metadata[:headers]['Content-Length'] = ::File.size(data.path).to_s
+          end
+          # metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
+          metadata
+        end
+
+        def url(params, expires)
+          params[:headers]['Date'] = expires.to_i
+          query = [params[:query]].compact
+          query << "AWSAccessKeyId=#{@aws_access_key_id}"
+          query << "Signature=#{CGI.escape(signature(params))}"
+          query << "Expires=#{params[:headers]['Date']}"
+          "http://#{params[:host]}/#{params[:path]}?#{query.join('&')}"
+        end
+
+      end
+
+      class Mock
+        include Utils
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :buckets => {}
+            }
+          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
+
+        def signature(params)
+          "foo"
+        end
+      end
+
+      class Real
+        include Utils
+        extend Fog::Deprecation
+        deprecate(:reset, :reload)
+
+        # Initialize connection to S3
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and 
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   s3 = S3.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
+        # * S3 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('sha1', @aws_secret_access_key)
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+            when 'us-east-1'
+              's3.amazonaws.com'
+            when 'ap-southeast-1'
+              's3-ap-southeast-1.amazonaws.com'
+            when 'us-west-1'
+              's3-us-west-1.amazonaws.com'
+            else
+              raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+            end
+          @port   = options[:port]      || 443
+          @scheme = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent] || true)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params, &block)
+          params[:headers]['Date'] = Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+          params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature(params)}"
+
+          response = @connection.request(params, &block)
+
+          response
+        end
+
+        def signature(params)
+          string_to_sign =
+<<-DATA
+#{params[:method]}
+#{params[:headers]['Content-MD5']}
+#{params[:headers]['Content-Type']}
+#{params[:headers]['Date']}
+DATA
+
+          amz_headers, canonical_amz_headers = {}, ''
+          for key, value in params[:headers]
+            if key[0..5] == 'x-amz-'
+              amz_headers[key] = value
+            end
+          end
+          amz_headers = amz_headers.sort {|x, y| x[0] <=> y[0]}
+          for key, value in amz_headers
+            canonical_amz_headers << "#{key}:#{value}\n"
+          end
+          string_to_sign << "#{canonical_amz_headers}"
+
+          subdomain = params[:host].split(".#{@host}").first
+          unless subdomain =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
+            Formatador.display_line("[yellow][WARN] fog: the specified s3 bucket name(#{subdomain}) is not a valid dns name, which will negatively impact performance.  For details see: http://docs.amazonwebservices.com/AmazonS3/latest/dev/BucketRestrictions.html[/]")
+            params[:host] = params[:host].split("#{subdomain}.")[-1]
+            if params[:path]
+              params[:path] = "#{subdomain}/#{params[:path]}"
+            else
+              params[:path] = "#{subdomain}"
+            end
+            subdomain = nil
+          end
+
+          canonical_resource  = "/"
+          unless subdomain.nil? || subdomain == @host
+            canonical_resource << "#{CGI.escape(subdomain).downcase}/"
+          end
+          canonical_resource << "#{params[:path]}"
+          canonical_resource << '?'
+          for key in (params[:query] || {}).keys
+            if ['acl', 'location', 'logging', 'requestPayment', 'torrent', 'versions', 'versioning'].include?(key)
+              canonical_resource << "#{key}&"
+            end
+          end
+          canonical_resource.chop!
+          string_to_sign << "#{canonical_resource}"
+
+          signed_string = @hmac.sign(string_to_sign)
+          signature = Base64.encode64(signed_string).chomp!
+        end
+      end
+    end
+  end
+end

data/lib/fog/bin.rb

@@ -1,68 +1,77 @@
 require 'fog/credentials'
 
-require 'fog/aws/bin'
-require 'fog/go_grid/bin'
-require 'fog/linode/bin'
-require 'fog/local/bin'
-require 'fog/new_servers/bin'
-require 'fog/rackspace/bin'
-require 'fog/slicehost/bin'
-require 'fog/terremark/bin'
-require 'fog/vcloud/bin'
-require 'fog/bluebox/bin'
-
 module Fog
   class << self
 
-    def services
-      services = []
-      [::AWS, ::GoGrid, ::Linode, ::Local, ::NewServers, ::Rackspace, ::Slicehost, ::Terremark, ::Vcloud, ::Bluebox].each do |service|
-        if service.initialized?
-          services << service
-        end
-      end
-      services
+    def providers
+      [
+        ::AWS,
+        ::Bluebox,
+        ::GoGrid,
+        ::Linode,
+        ::Local,
+        ::NewServers,
+        ::Rackspace,
+        ::Slicehost,
+        ::Terremark
+      ].select {|provider| provider.available?}
     end
 
-    def directories
-      directories = {}
-      services.each do |service|
-        if service.respond_to?(:directories)
-          directories[service] = service.directories
-        end
-      end
-      directories
+    def modules
+      [
+        ::Vcloud
+      ].select {|_module_| _module_.initialized?}
     end
 
-    def flavors
-      flavors = {}
-      services.each do |service|
-        if service.respond_to?(:flavors)
-          flavors[service] = service.flavors
+  end
+
+  class Bin
+    class << self
+
+      def available?
+        availability = true
+        for service in services
+          begin
+            service = eval(self[service].class.to_s.split('::')[0...-1].join('::'))
+            availability &&= service.requirements.all? {|requirement| Fog.credentials.include?(requirement)}
+          rescue
+            availability = false
+          end
         end
-      end
-      flavors
-    end
 
-    def images
-      images = {}
-      services.each do |service|
-        if service.respond_to?(:images)
-          images[service] = service.images
+        if availability
+          for service in services
+            for collection in self[service].collections
+              unless self.respond_to?(collection)
+                self.class_eval <<-EOS, __FILE__, __LINE__
+                  def self.#{collection}
+                    self[:#{service}].#{collection}
+                  end
+                EOS
+              end
+            end
+          end
         end
+
+        availability
       end
-      images
-    end
 
-    def servers
-      servers = {}
-      services.each do |service|
-        if service.respond_to?(:servers)
-          servers[service] = service.servers
-        end
+      def collections
+        services.map {|service| self[service].collections}.flatten.sort_by {|service| service.to_s}
       end
-      servers
-    end
 
+    end
   end
+
 end
+
+require 'fog/aws/bin'
+require 'fog/bluebox/bin'
+require 'fog/go_grid/bin'
+require 'fog/linode/bin'
+require 'fog/local/bin'
+require 'fog/new_servers/bin'
+require 'fog/rackspace/bin'
+require 'fog/slicehost/bin'
+require 'fog/terremark/bin'
+require 'fog/vcloud/bin'

data/lib/fog/bluebox.rb

@@ -1,87 +1,18 @@
 module Fog
   module Bluebox
-    extend Fog::Service
 
-    requires :bluebox_api_key, :bluebox_customer_id
+    extend Fog::Provider
 
-    model_path 'fog/bluebox/models'
-    model 'flavor'
-    model 'flavors'
-    model 'images'
-    model 'server'
-    model 'servers'
-
-    request_path 'fog/bluebox/requests'
-    request 'create_block'
-    request 'destroy_block'
-    request 'get_block'
-    request 'get_blocks'
-    request 'get_product'
-    request 'get_products'
-    request 'get_template'
-    request 'get_templates'
-    request 'reboot_block'
-
-    class Mock
-      include Collections
-
-      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={})
-        @bluebox_api_key = options[:bluebox_api_key]
-        @data = self.class.data[@bluebox_api_key]
-      end
+    service_path 'fog/bluebox'
+    service :compute
 
+    def self.new(attributes = {})
+      location = caller.first
+      warning = "[yellow][WARN] Fog::Bluebox#new is deprecated, use Fog::Bluebox::Compute#new instead[/]"
+      warning << " [light_black](" << location << ")[/] "
+      Formatador.display_line(warning)
+      Fog::Bluebox::Compute.new(attributes)
     end
 
-    class Real
-      include Collections
-
-      def initialize(options={})
-        @bluebox_api_key      = options[:bluebox_api_key]
-        @bluebox_customer_id  = options[:bluebox_customer_id]
-        @host   = options[:bluebox_host]    || "boxpanel.blueboxgrp.com"
-        @port   = options[:bluebox_port]    || 443
-        @scheme = options[:bluebox_scheme]  || 'https'
-        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
-      end
-
-      def reload
-        @connection.reset
-      end
-
-      def request(params)
-        params[:headers] ||= {}
-        params[:headers].merge!({
-          'Authorization' => "Basic #{Base64.encode64([@bluebox_customer_id, @bluebox_api_key].join(':')).delete("\r\n")}"
-        })
-
-        begin
-          response = @connection.request(params.merge!({:host => @host}))
-        rescue Excon::Errors::Error => error
-          raise case error
-          when Excon::Errors::NotFound
-            Fog::Bluebox::NotFound.slurp(error)
-          else
-            error
-          end
-        end
-        unless response.body.empty?
-          response.body = JSON.parse(response.body)
-        end
-        response
-      end
-
-    end
   end
 end