fog 0.0.3

data/lib/fog/connection.rb

@@ -0,0 +1,130 @@
+require 'rubygems'
+require 'openssl'
+require 'socket'
+require 'uri'
+
+require "#{File.dirname(__FILE__)}/errors"
+require "#{File.dirname(__FILE__)}/response"
+
+unless Fog.mocking?
+
+  module Fog
+    class Connection
+
+      def initialize(url)
+        @uri = URI.parse(url)
+        @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
+
+      def request(params)
+        params[:path] ||= ''
+        unless params[:path][0] == '/'
+          params[:path] = '/' + params[:path].to_s
+        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[:body].length
+        end
+        for key, value in params[:headers]
+          request << "#{key}: #{value}\r\n"
+        end
+        request << "\r\n#{params[:body]}"
+        @connection.write(request)
+
+        response = Fog::Response.new
+        response.request = params
+        response.status = @connection.readline[9..11].to_i
+        if params[:expects] && params[:expects] != 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]
+        end
+
+        if error || params[:parser]
+          if error
+            parser = Fog::Errors::Parser.new
+          elsif params[:parser]
+            parser = params[:parser]
+          end
+          body = Nokogiri::XML::SAX::PushParser.new(parser)
+        else
+          body = ''
+        end
+
+        unless params[:method] == 'HEAD'
+          if response.headers['Content-Length']
+            body << @connection.read(response.headers['Content-Length'].to_i)
+          elsif response.headers['Transfer-Encoding'] == 'chunked'
+            while true
+              # 2 == "/r/n".length
+              chunk_size = @connection.readline.chomp!.to_i(16) + 2
+              chunk = @connection.read(chunk_size)
+              body << chunk[0...-2]
+              if chunk_size == 2
+                break
+              end
+            end
+          end
+        end
+
+        if parser
+          body.finish
+          response.body = parser.response
+        else
+          response.body = body
+        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!
+      end
+
+    end
+  end
+
+else
+
+  module Fog
+    class Connection
+
+      def initialize(url)
+      end
+
+      def request(params)
+      end
+
+    end
+  end
+
+end

data/lib/fog/errors.rb

@@ -0,0 +1,145 @@
+require "#{File.dirname(__FILE__)}/parser"
+
+module Fog
+  module Errors
+    class Continue < StandardError; end # 100
+    class SwitchingProtocols < StandardError; end # 101
+    class OK < StandardError; end # 200
+    class Created < StandardError; end # 201
+    class Accepted < StandardError; end # 202
+    class NonAuthoritativeInformation < StandardError; end # 203
+    class NoContent < StandardError; end # 204
+    class ResetContent < StandardError; end # 205
+    class PartialContent < StandardError; end # 206
+    class MultipleChoices < StandardError; end # 300
+    class MovedPermanently < StandardError; end # 301
+    class Found < StandardError; end # 302
+    class SeeOther < StandardError; end # 303
+    class NotModified < StandardError; end # 304
+    class UseProxy < StandardError; end # 305
+    class TemporaryRedirect < StandardError; end # 307
+    class BadRequest < StandardError; end # 400
+    class Unauthorized < StandardError; end # 401
+    class PaymentRequired < StandardError; end # 402
+    class Forbidden < StandardError; end # 403
+    class NotFound < StandardError; end # 404
+    class MethodNotAllowed < StandardError; end # 405
+    class NotAcceptable < StandardError; end #406
+    class ProxyAuthenticationRequired < StandardError; end #407
+    class RequestTimeout < StandardError; end # 408
+    class Conflict < StandardError; end # 409
+    class Gone < StandardError; end # 410
+    class LengthRequired < StandardError; end # 411
+    class PreconditionFailed < StandardError; end # 412
+    class RequestEntityTooLarge < StandardError; end # 412
+    class RequestURITooLong < StandardError; end # 414
+    class UnsupportedMediaType < StandardError; end # 415
+    class RequestedRangeNotSatisfiable < StandardError; end # 416
+    class ExpectationFailed < StandardError; end # 417
+    class InternalServerError < StandardError; end # 500
+    class NotImplemented < StandardError; end # 501
+    class BadGateway < StandardError; end # 502
+    class ServiceUnavailable < StandardError; end # 503
+    class GatewayTimeout < StandardError; end # 504
+
+    # Messages for nicer exceptions, from rfc2616
+    def self.status_error(expected, actual, response)
+      @errors ||= { 
+        100 => Fog::Errors::Continue, 
+        101 => Fog::Errors::SwitchingProtocols,
+        200 => Fog::Errors::OK,
+        201 => Fog::Errors::Created,
+        202 => Fog::Errors::Accepted,
+        203 => Fog::Errors::NonAuthoritativeInformation,
+        204 => Fog::Errors::NoContent,
+        205 => Fog::Errors::ResetContent,
+        206 => Fog::Errors::PartialContent,
+        300 => Fog::Errors::MultipleChoices,
+        301 => Fog::Errors::MovedPermanently,
+        302 => Fog::Errors::Found,
+        303 => Fog::Errors::SeeOther,
+        304 => Fog::Errors::NotModified,
+        305 => Fog::Errors::UseProxy,
+        307 => Fog::Errors::TemporaryRedirect,
+        400 => Fog::Errors::BadRequest,
+        401 => Fog::Errors::Unauthorized,
+        402 => Fog::Errors::PaymentRequired,
+        403 => Fog::Errors::Forbidden,
+        404 => Fog::Errors::NotFound,
+        405 => Fog::Errors::MethodNotAllowed,
+        406 => Fog::Errors::NotAcceptable,
+        407 => Fog::Errors::ProxyAuthenticationRequired,
+        408 => Fog::Errors::RequestTimeout,
+        409 => Fog::Errors::Conflict,
+        410 => Fog::Errors::Gone,
+        411 => Fog::Errors::LengthRequired,
+        412 => Fog::Errors::PreconditionFailed,
+        413 => Fog::Errors::RequestEntityTooLarge,
+        414 => Fog::Errors::RequestURITooLong,
+        415 => Fog::Errors::UnsupportedMediaType,
+        416 => Fog::Errors::RequestedRangeNotSatisfiable,
+        417 => Fog::Errors::ExpectationFailed,
+        500 => Fog::Errors::InternalServerError,
+        501 => Fog::Errors::NotImplemented,
+        502 => Fog::Errors::BadGateway,
+        503 => Fog::Errors::ServiceUnavailable,
+        504 => Fog::Errors::GatewayTimeout
+      }
+      @messages ||= { 
+        100 => 'Continue', 
+        101 => 'Switching Protocols',
+        200 => 'OK',
+        201 =>'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        307 => 'Temporary Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout'
+      }
+      response = "#{response.body['Code']} => #{response.body['Message']}"
+      @errors[actual].new("Expected(#{expected} #{@messages[expected]}) <=> Actual(#{actual} #{@messages[actual]}): #{response}")
+    end
+
+    class Parser < Fog::Parsers::Base
+
+      def end_element(name)
+        case name
+        when 'Code', 'Message'
+          @response[name] = @value
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fog/model.rb

@@ -0,0 +1,72 @@
+module Fog
+  class Model
+
+    def self.attribute(name, other_names = [])
+      class_eval <<-EOS, __FILE__, __LINE__
+        attr_accessor :#{name}
+      EOS
+      attributes << name
+      for other_name in [*other_names]
+        aliases[other_name] = name
+      end
+    end
+
+    def self.aliases
+      @aliases ||= {}
+    end
+
+    def self.attributes
+      @attributes ||= []
+    end
+
+    def initialize(new_attributes = {})
+      merge_attributes(new_attributes)
+    end
+
+    def inspect
+      data = "#<#{self.class.name}"
+      for attribute in self.class.attributes
+        data << " #{attribute}=#{send(attribute).inspect}"
+      end
+      data << ">"
+    end
+
+    def attributes
+      attributes = {}
+      for attribute in self.class.attributes
+        attributes[attribute] = send(:"#{attribute}")
+      end
+      attributes
+    end
+
+    def merge_attributes(new_attributes = {})
+      for key, value in new_attributes
+        if aliased_key = self.class.aliases[key]
+          send(:"#{aliased_key}=", value)
+        else
+          send(:"#{key}=", value)
+        end
+      end
+      self
+    end
+
+    private
+
+    def connection=(new_connection)
+      @connection = new_connection
+    end
+
+    def connection
+      @connection
+    end
+
+    def remap_attributes(attributes, mapping)
+      for key, value in mapping
+        if attributes.key?(key)
+          attributes[value] = attributes.delete(key)
+        end
+      end
+    end
+
+  end
+end

data/lib/fog/parser.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'base64'
+require 'nokogiri'
+require 'time'
+
+module Fog
+  module Parsers
+    class Base < Nokogiri::XML::SAX::Document
+
+      attr_reader :response
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @response = {}
+      end
+
+      def characters(string)
+        @value << string.strip
+      end
+
+      def start_element(name, attrs = [])
+        @value = ''
+      end
+
+    end
+  end
+end

data/lib/fog/response.rb

@@ -0,0 +1,12 @@
+module Fog  
+  class Response
+
+    attr_accessor :body, :headers, :request, :status
+
+    def initialize
+      @body = ''
+      @headers = {}
+    end
+
+  end
+end

data/spec/aws/models/s3/bucket_spec.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe 'Fog::AWS::S3::Bucket' do
+
+  describe "#initialize" do
+
+    it "should remap attributes from parser" do
+      now = Time.now
+      bucket = Fog::AWS::S3::Bucket.new(
+        'CreationDate' => now,
+        'Name'         => 'bucketname'
+      )
+      bucket.creation_date.should == now
+      bucket.name.should == 'bucketname'
+    end
+
+  end
+
+  describe "#buckets" do
+
+    it "should return a Fog::AWS::S3::Buckets" do
+      s3.buckets.new.buckets.should be_a(Fog::AWS::S3::Buckets)
+    end
+
+    it "should be the buckets the bucket is related to" do
+      buckets = s3.buckets
+      buckets.new.buckets.should == buckets
+    end
+
+  end
+
+  describe "#destroy" do
+
+    it "should return true if the bucket is deleted" do
+      bucket = s3.buckets.create(:name => 'fogmodelbucket')
+      bucket.destroy.should be_true
+    end
+
+    it "should return false if the bucket does not exist" do
+      bucket = s3.buckets.new(:name => 'fogmodelbucket')
+      bucket.destroy.should be_false
+    end
+
+  end
+
+  describe "#location" do
+
+    it "should return the location constraint" do
+      bucket = s3.buckets.create(:name => 'fogmodeleubucket', :location => 'EU')
+      bucket.location.should == 'EU'
+      eu_s3.buckets.new(:name => 'fogmodeleubucket').destroy
+    end
+
+  end
+
+  describe "#objects" do
+
+    it "should return a Fog::AWS::S3::Objects" do
+      bucket = s3.buckets.new(:name => 'fogmodelbucket')
+      bucket.objects.should be_an(Fog::AWS::S3::Objects)
+    end
+
+  end
+
+  describe "#payer" do
+
+    it "should return the request payment value" do
+      bucket = s3.buckets.create(:name => 'fogmodelbucket')
+      bucket.payer.should == 'BucketOwner'
+      bucket.destroy.should be_true
+    end
+
+  end
+
+  describe "#payer=" do
+
+    it "should set the request payment value" do
+      bucket = s3.buckets.create(:name => 'fogmodelbucket')
+      (bucket.payer = 'Requester').should == 'Requester'
+      bucket.destroy.should
+    end
+
+  end
+
+  describe "#reload" do
+
+    before(:each) do
+      @bucket = s3.buckets.create(:name => 'fogmodelbucket')
+      @reloaded = @bucket.reload
+    end
+
+    after(:each) do
+      @bucket.destroy
+    end
+
+    it "should return a Fog::AWS::S3::Bucket" do
+      @reloaded.should be_a(Fog::AWS::S3::Bucket)
+    end
+
+    it "should reset attributes to remote state" do
+      @bucket.creation_date = Time.now
+      @bucket.attributes.should == @reloaded.attributes
+    end
+
+  end
+
+  describe "#save" do
+
+    before(:each) do
+      @bucket = s3.buckets.new(:name => 'fogmodelbucket')
+    end
+
+    it "should return true when it succeeds" do
+      @bucket.save.should be_true
+      @bucket.destroy
+    end
+
+    it "should not exist in buckets before save" do
+      @bucket.buckets.key?(@bucket.name).should be_false
+    end
+
+    it "should exist in buckets after save" do
+      @bucket.save
+      @bucket.buckets.key?(@bucket.name).should be_true
+      @bucket.destroy
+    end
+
+  end
+
+end