fog 0.0.29 → 0.0.30

data/lib/fog/aws/s3.rb

@@ -12,12 +12,6 @@ module Fog
       end
 
       def self.reload
-        load "fog/collection.rb"
-        load "fog/connection.rb"
-        load "fog/model.rb"
-        load "fog/parser.rb"
-        load "fog/response.rb"
-
         load "fog/aws/models/s3/bucket.rb"
         load "fog/aws/models/s3/buckets.rb"
         load "fog/aws/models/s3/object.rb"
@@ -105,7 +99,6 @@ module Fog
         response = @connection.request({
           :block    => params[:block],
           :body     => params[:body],
-          :error_parser => Fog::Errors::Parser.new,
           :expects  => params[:expects],
           :headers  => params[:headers],
           :host     => params[:host],

data/lib/fog/aws/simpledb.rb

@@ -12,10 +12,6 @@ module Fog
       end
 
       def self.reload
-        load "fog/connection.rb"
-        load "fog/parser.rb"
-        load "fog/response.rb"
-
         load "fog/aws/parsers/simpledb/basic.rb"
         load "fog/aws/parsers/simpledb/domain_metadata.rb"
         load "fog/aws/parsers/simpledb/get_attributes.rb"

data/lib/fog/collection.rb

@@ -5,12 +5,17 @@ module Fog
       class_eval <<-EOS, __FILE__, __LINE__
         attr_accessor :#{name}
       EOS
-      attributes << name
+      @attributes ||= []
+      @attributes |= [name]
       for other_name in [*other_names]
         aliases[other_name] = name
       end
     end
 
+    def self.model(new_model)
+      @model = new_model
+    end
+    
     def self.aliases
       @aliases ||= {}
     end
@@ -19,6 +24,20 @@ module Fog
       @attributes ||= []
     end
 
+    def attributes
+      attributes = {}
+      for attribute in self.class.attributes
+        attributes[attribute] = send("#{attribute}")
+      end
+      attributes
+    end
+
+    def create(attributes = {})
+      object = new(attributes)
+      object.save
+      object
+    end
+
     def initialize(attributes = {})
       merge_attributes(attributes)
     end
@@ -36,12 +55,8 @@ module Fog
       data << "]>"
     end
 
-    def attributes
-      attributes = {}
-      for attribute in self.class.attributes
-        attributes[attribute] = send("#{attribute}")
-      end
-      attributes
+    def model
+      self.class.instance_variable_get('@model')
     end
 
     def merge_attributes(new_attributes = {})
@@ -55,6 +70,19 @@ module Fog
       self
     end
 
+    def new(attributes = {})
+      model.new(
+        attributes.merge!(
+          :collection => self,
+          :connection => connection
+        )
+      )
+    end
+
+    def reload
+      self.clear.concat(all)
+    end
+
     private
 
     def connection=(new_connection)

data/lib/fog/connection.rb

@@ -1,7 +1,5 @@
 require 'rubygems'
-require 'openssl'
-require 'socket'
-require 'uri'
+require 'excon'
 
 require "fog/errors"
 require "fog/response"
@@ -11,142 +9,24 @@ unless Fog.mocking?
   module Fog
     class Connection
 
-      unless const_defined?(:CHUNK_SIZE)
-        CHUNK_SIZE = 1048576 # 1 megabyte
-      end
-
       def initialize(url)
-        @uri = URI.parse(url)
-      end
-
-      def connection
-        if @connection && !@connection.closed?
-          @connection
-        else
-          @connection = TCPSocket.open(@uri.host, @uri.port)
-          if @uri.scheme == 'https'
-            @ssl_context = OpenSSL::SSL::SSLContext.new
-            @ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-            @connection = OpenSSL::SSL::SSLSocket.new(@connection, @ssl_context)
-            @connection.sync_close = true
-            @connection.connect
-          end
-        end
+        @excon = Excon.new(url)
       end
 
       def request(params)
-        params[:path] ||= ''
-        unless params[:path][0..0] == '/'
-          params[:path] = '/' + params[:path].to_s
+        if parser = params.delete(:parser)
+          body = Nokogiri::XML::SAX::PushParser.new(parser)
+          params[:block] = lambda { |chunk| body << chunk }
         end
-        if params[:query] && !params[:query].empty?
-          params[:path] << "?#{params[:query]}"
-        end
-        request = "#{params[:method]} #{params[:path]} HTTP/1.1\r\n"
-        params[:headers] ||= {}
-        params[:headers]['Host'] = params[:host]
-        if params[:body] && !params[:headers]['Content-Length']
-          params[:headers]['Content-Length'] = params[:body].length
-        end
-        for key, value in params[:headers]
-          request << "#{key}: #{value}\r\n"
-        end
-        request << "\r\n"
-        connection.write(request)
 
-        if params[:body]
-          if params[:body].is_a?(String)
-            connection.write(params[:body])
-          else
-            while chunk = params[:body].read(CHUNK_SIZE)
-              connection.write(chunk)
-            end
-          end
-        end
+        response = @excon.request(params)
 
-        response = Fog::Response.new
-        response.request = params
-        response.status = connection.readline[9..11].to_i
-        if params[:expects] && ![*params[:expects]].include?(response.status)
-          error = true
-        end
-        while true
-          data = connection.readline.chomp!
-          if data == ""
-            break
-          end
-          header = data.split(': ')
-          response.headers[capitalize(header[0])] = header[1]
+        if parser
+          body.finish
+          response.body = parser.response
         end
 
-        unless params[:method] == 'HEAD' || [204, 304, *(100..199)].include?(response.status)
-          if (error && params[:error_parser]) || params[:parser]
-            if error
-              parser = params[:error_parser]
-            elsif params[:parser]
-              parser = params[:parser]
-            end
-            body = Nokogiri::XML::SAX::PushParser.new(parser)
-          elsif params[:block]
-            body = nil
-          else
-            body = ''
-          end
-
-          if response.headers['Content-Length']
-            if error || !params[:block]
-              body << connection.read(response.headers['Content-Length'].to_i)
-            else
-              remaining = response.headers['Content-Length'].to_i
-              while remaining > 0
-                params[:block].call(connection.read([CHUNK_SIZE, remaining].min))
-                remaining -= CHUNK_SIZE;
-              end
-            end
-          elsif response.headers['Transfer-Encoding'] == 'chunked'
-            while true
-              chunk_size = connection.readline.chomp!.to_i(16)
-              # 2 == "/r/n".length
-              chunk = connection.read(chunk_size + 2)[0...-2]
-              if chunk_size == 0
-                break
-              else
-                if error || !params[:block]
-                  body << chunk
-                else
-                  params[:block].call(chunk)
-                end
-              end
-            end
-          elsif response.headers['Connection'] == 'close'
-            body << connection.read
-            @connection = nil
-          end
-
-          if parser
-            body.finish
-            response.body = parser.response
-          else
-            response.body = body
-          end
-        end
-
-        if error
-          raise(Fog::Errors.status_error(params[:expects], response.status, response))
-        else
-          response
-        end
-      end
-
-      private
-
-      def capitalize(header)
-        words = header.split('-')
-        header = ''
-        for word in words
-          header << word[0..0].upcase << word[1..-1] << '-'
-        end
-        header.chop!
+        response
       end
 
     end

data/lib/fog/model.rb

@@ -5,7 +5,8 @@ module Fog
       class_eval <<-EOS, __FILE__, __LINE__
         attr_accessor :#{name}
       EOS
-      attributes << name
+      @attributes ||= []
+      @attributes |= [name]
       for other_name in [*other_names]
         aliases[other_name] = name
       end
@@ -24,6 +25,18 @@ module Fog
       @attributes ||= []
     end
 
+    def attributes
+      attributes = {}
+      for attribute in self.class.attributes
+        attributes[attribute] = send("#{attribute}")
+      end
+      attributes
+    end
+
+    def collection
+      @collection
+    end
+
     def identity
       send(self.class.instance_variable_get('@identity'))
     end
@@ -40,18 +53,6 @@ module Fog
       data << ">"
     end
 
-    def attributes
-      attributes = {}
-      for attribute in self.class.attributes
-        attributes[attribute] = send("#{attribute}")
-      end
-      attributes
-    end
-
-    def collection
-      @collection
-    end
-
     def merge_attributes(new_attributes = {})
       for key, value in new_attributes
         if aliased_key = self.class.aliases[key]
@@ -63,6 +64,10 @@ module Fog
       self
     end
 
+    def new_record?
+      !identity
+    end
+
     def reload
       new_attributes = collection.get(identity).attributes
       merge_attributes(new_attributes)

data/lib/fog/parser.rb

@@ -1,8 +1,3 @@
-require 'rubygems'
-require 'base64'
-require 'nokogiri'
-require 'time'
-
 module Fog
   module Parsers
     class Base < Nokogiri::XML::SAX::Document

data/lib/fog/rackspace.rb

@@ -6,23 +6,43 @@ module Fog
       load 'fog/rackspace/servers.rb'
     end
 
-    def self.authenticate(options)
-      connection = Fog::Connection.new("https://auth.api.rackspacecloud.com")
-      response = connection.request({
-        :expects  => 204,
-        :headers  => {
-          'X-Auth-Key'  => options[:rackspace_api_key],
-          'X-Auth-User' => options[:rackspace_username]
-        },
-        :host     => 'auth.api.rackspacecloud.com',
-        :method   => 'GET',
-        :path     => 'v1.0'
-      })
-      response.headers.reject do |key, value| 
-        !['X-Server-Management-Url', 'X-Storage-Url', 'X-CDN-Management-Url', 'X-Auth-Token'].include?(key)
+    unless Fog.mocking?
+
+      def self.authenticate(options)
+        connection = Fog::Connection.new("https://auth.api.rackspacecloud.com")
+        response = connection.request({
+          :expects  => 204,
+          :headers  => {
+            'X-Auth-Key'  => options[:rackspace_api_key],
+            'X-Auth-User' => options[:rackspace_username]
+          },
+          :host     => 'auth.api.rackspacecloud.com',
+          :method   => 'GET',
+          :path     => 'v1.0'
+        })
+        response.headers.reject do |key, value|
+          !['X-Server-Management-Url', 'X-Storage-Url', 'X-CDN-Management-Url', 'X-Auth-Token'].include?(key)
+        end
+      end
+
+    else
+
+      def self.authenticate(options)
+        {
+          'X-Auth_Token'            => '01234567-0123-0123-0123-01234',
+          'X-CDN-Management-Url'    => 'https://cdn.cloaddrive.com/v1/CloudFS_01234-0123',
+          'X-Server-Management-Url' => 'https://servers.api.rackspacecloud.com/v1.0/01234',
+          'X-Storage-Url'           => 'https://storage.clouddrive.com/v1/CloudFS_01234-0123'
+        }
       end
+
+      srand(Time.now.to_i)
+
+      class Mock
+      end
+
     end
 
   end
 end
-Fog::Rackspace.reload
+Fog::Rackspace.reload

data/lib/fog/rackspace/files.rb

@@ -3,7 +3,14 @@ module Fog
     class Files
 
       def self.reload
+        load "fog/rackspace/requests/files/delete_container.rb"
+        load "fog/rackspace/requests/files/delete_object.rb"
+        load "fog/rackspace/requests/files/get_container.rb"
         load "fog/rackspace/requests/files/get_containers.rb"
+        load "fog/rackspace/requests/files/head_container.rb"
+        load "fog/rackspace/requests/files/head_containers.rb"
+        load "fog/rackspace/requests/files/put_container.rb"
+        load "fog/rackspace/requests/files/put_object.rb"
       end
 
       def initialize(options={})
@@ -22,18 +29,40 @@ module Fog
         @connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}")
       end
 
+      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.read
+          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 cdn_request(params)
         response = @connection.request({
           :body     => params[:body],
           :expects  => params[:expects],
           :headers  => {
             'X-Auth-Token' => @auth_token
-          },
+          }.merge!(params[:headers] || {}),
           :host     => @cdn_host,
           :method   => params[:method],
-          :path     => "#{@cdn_path}/#{params[:path]}"
+          :path     => "#{@cdn_path}/#{params[:path]}",
+          :query    => params[:query]
         })
-        unless response.status == 204
+        unless response.body.empty?
           response.body = JSON.parse(response.body)
         end
         response
@@ -45,12 +74,13 @@ module Fog
           :expects  => params[:expects],
           :headers  => {
             'X-Auth-Token' => @auth_token
-          },
+          }.merge!(params[:headers] || {}),
           :host     => @storage_host,
           :method   => params[:method],
-          :path     => "#{@storage_path}/#{params[:path]}"
+          :path     => "#{@storage_path}/#{params[:path]}",
+          :query    => params[:query]
         })
-        unless response.status == 204
+        unless response.body.empty?
           response.body = JSON.parse(response.body)
         end
         response