fog 0.0.58 → 0.0.59

data/lib/fog/aws/ec2.rb

@@ -76,7 +76,36 @@ module Fog
               :addresses => {},
               :instances => {},
               :key_pairs => {},
-              :security_groups => {},
+              :security_groups => {
+                'default' => {
+                  'groupDescription'  => 'default group',
+                  'groupName'         => 'default',
+                  'ipPermissions'     => [
+                    {
+                      'groups'      => [{'groupName' => 'default', 'userId' => @owner_id}],
+                      'fromPort'    => -1,
+                      'toPort'      => -1,
+                      'ipProtocol'  => 'icmp',
+                      'ipRanges'    => []
+                    },
+                    {
+                      'groups'      => [{'groupName' => 'default', 'userId' => @owner_id}],
+                      'fromPort'    => 0,
+                      'toPort'      => 65535,
+                      'ipProtocol'  => 'tcp',
+                      'ipRanges'    => []
+                    },
+                    {
+                      'groups'      => [{'groupName' => 'default', 'userId' => @owner_id}],
+                      'fromPort'    => 0,
+                      'toPort'      => 65535,
+                      'ipProtocol'  => 'udp',
+                      'ipRanges'    => []
+                    }
+                  ],
+                  'ownerId'           => @owner_id
+                }
+              },
               :snapshots => {},
               :volumes => {}
             }
@@ -91,6 +120,7 @@ module Fog
 
         def initialize(options={})
           @aws_access_key_id = options[:aws_access_key_id]
+          @owner_id = Fog::AWS::Mock.owner_id
           @data = self.class.data[@aws_access_key_id]
         end
 

data/lib/fog/aws/requests/ec2/authorize_security_group_ingress.rb

@@ -41,10 +41,9 @@ module Fog
           group['ipPermissions'] ||= []
 
           if options['GroupName'] && options['SourceSecurityGroupName'] && options['SourceSecurityGroupOwnerId']
-            owner = Fog::AWS::Mock.owner_id
             ['icmp', 'tcp', 'udp'].each do |protocol|
               group['ipPermissions'] << {
-                'groups'      => [{'groupName' => options['GroupName'], 'userId' => owner}],
+                'groups'      => [{'groupName' => options['GroupName'], 'userId' => @owner_id}],
                 'fromPort'    => 1,
                 'ipRanges'    => [],
                 'ipProtocol'  => protocol,

data/lib/fog/aws/requests/ec2/create_security_group.rb

@@ -36,7 +36,7 @@ module Fog
               'groupDescription'  => description,
               'groupName'         => name,
               'ipPermissions'     => [],
-              'ownerId'           => Fog::AWS::Mock.owner_id
+              'ownerId'           => @owner_id
             }
             @data[:security_groups][name] = data
             response.body = {

data/lib/fog/aws/requests/ec2/run_instances.rb

@@ -102,7 +102,7 @@ module Fog
 
           group_set = [ (options['GroupId'] || 'default') ]
           instances_set = []
-          owner_id = Fog::AWS::Mock.owner_id
+          owner_id = @owner_id
           reservation_id = Fog::AWS::Mock.reservation_id
 
           min_count.times do |i|

data/lib/fog/connection.rb

@@ -1,43 +1,25 @@
-unless Fog.mocking?
+module Fog
+  class Connection
 
-  module Fog
-    class Connection
+    def initialize(url)
+      @excon = Excon.new(url)
+    end
 
-      def initialize(url)
-        @excon = Excon.new(url)
+    def request(params)
+      if parser = params.delete(:parser)
+        body = Nokogiri::XML::SAX::PushParser.new(parser)
+        params[:block] = lambda { |chunk| body << chunk }
       end
 
-      def request(params)
-        if parser = params.delete(:parser)
-          body = Nokogiri::XML::SAX::PushParser.new(parser)
-          params[:block] = lambda { |chunk| body << chunk }
-        end
-
-        response = @excon.request(params)
-
-        if parser
-          body.finish
-          response.body = parser.response
-        end
+      response = @excon.request(params)
 
-        response
+      if parser
+        body.finish
+        response.body = parser.response
       end
 
+      response
     end
-  end
-
-else
-
-  module Fog
-    class Connection
 
-      def initialize(url)
-      end
-
-      def request(params)
-      end
-
-    end
   end
-
 end

data/lib/fog/rackspace.rb

@@ -1,61 +1,31 @@
+require 'fog/rackspace/files'
+require 'fog/rackspace/servers'
+
 module Fog
   module Rackspace
 
-    def self.dependencies
-      [
-        'fog/rackspace/files.rb',
-        'fog/rackspace/servers.rb'
-      ]
-    end
-
-    def self.reload
-      self.dependencies.each {|dependency| load(dependency)}
-    end
-
-    unless Fog.mocking?
-
-      def self.authenticate(options)
-        unless @rackspace_api_key = options[:rackspace_api_key]
-          raise ArgumentError.new('rackspace_api_key is required to access rackspace')
-        end
-        unless @rackspace_username = options[:rackspace_username]
-          raise ArgumentError.new('rackspace_username is required to access rackspace')
-        end
-        connection = Fog::Connection.new("https://auth.api.rackspacecloud.com")
-        response = connection.request({
-          :expects  => 204,
-          :headers  => {
-            'X-Auth-Key'  => @rackspace_api_key,
-            'X-Auth-User' => @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
+    def self.authenticate(options)
+      unless @rackspace_api_key = options[:rackspace_api_key]
+        raise ArgumentError.new('rackspace_api_key is required to access rackspace')
       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'
-        }
+      unless @rackspace_username = options[:rackspace_username]
+        raise ArgumentError.new('rackspace_username is required to access rackspace')
       end
-
-      srand(Time.now.to_i)
-
-      class Mock
+      connection = Fog::Connection.new("https://auth.api.rackspacecloud.com")
+      response = connection.request({
+        :expects  => 204,
+        :headers  => {
+          'X-Auth-Key'  => @rackspace_api_key,
+          'X-Auth-User' => @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
 
   end
 end
-
-Fog::Rackspace.reload

data/lib/fog/rackspace/files.rb

@@ -1,51 +1,36 @@
+require 'fog/rackspace/models/files/directory'
+require 'fog/rackspace/models/files/directories'
+require 'fog/rackspace/models/files/file'
+require 'fog/rackspace/models/files/files'
+require 'fog/rackspace/requests/files/delete_container'
+require 'fog/rackspace/requests/files/delete_object'
+require 'fog/rackspace/requests/files/get_container'
+require 'fog/rackspace/requests/files/get_containers'
+require 'fog/rackspace/requests/files/get_object'
+require 'fog/rackspace/requests/files/head_container'
+require 'fog/rackspace/requests/files/head_containers'
+require 'fog/rackspace/requests/files/head_object'
+require 'fog/rackspace/requests/files/put_container'
+require 'fog/rackspace/requests/files/put_object'
+
 module Fog
   module Rackspace
-    class Files
-
-      def self.dependencies
-        [
-          "fog/rackspace/models/files/directory.rb",
-          "fog/rackspace/models/files/directories.rb",
-          "fog/rackspace/models/files/file.rb",
-          "fog/rackspace/models/files/files.rb",
-          "fog/rackspace/requests/files/delete_container.rb",
-          "fog/rackspace/requests/files/delete_object.rb",
-          "fog/rackspace/requests/files/get_container.rb",
-          "fog/rackspace/requests/files/get_containers.rb",
-          "fog/rackspace/requests/files/get_object.rb",
-          "fog/rackspace/requests/files/head_container.rb",
-          "fog/rackspace/requests/files/head_containers.rb",
-          "fog/rackspace/requests/files/head_object.rb",
-          "fog/rackspace/requests/files/put_container.rb",
-          "fog/rackspace/requests/files/put_object.rb"
-        ]
-      end
+    module Files
 
-      def self.reload
-        self.dependencies.each {|dependency| load(dependency)}
-      end
-
-      def initialize(options={})
-        credentials = Fog::Rackspace.authenticate(options)
-        @auth_token = credentials['X-Auth-Token']
-        cdn_uri = URI.parse(credentials['X-CDN-Management-Url'])
-        @cdn_host   = cdn_uri.host
-        @cdn_path   = cdn_uri.path
-        @cdn_port   = cdn_uri.port
-        @cdn_scheme = cdn_uri.scheme
-        storage_uri = URI.parse(credentials['X-Storage-Url'])
-        @storage_host   = storage_uri.host
-        @storage_path   = storage_uri.path
-        @storage_port   = storage_uri.port
-        @storage_scheme = storage_uri.scheme
+      def self.new(options={})
+        if Fog.mocking?
+          Fog::Rackspace::Files::Mock.new(options)
+        else
+          Fog::Rackspace::Files::Real.new(options)
+        end
       end
 
-      def parse_data(data)
+      def self.parse_data(data)
         metadata = {
           :body => nil,
           :headers => {}
         }
-      
+
         if data.is_a?(String)
           metadata[:body] = data
           metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
@@ -61,48 +46,89 @@ module Fog
         metadata
       end
 
-      def cdn_request(params)
-        @cdn_connection = Fog::Connection.new("#{@cdn_scheme}://#{@cdn_host}:#{@cdn_port}")
-        response = @cdn_connection.request({
-          :body     => params[:body],
-          :expects  => params[:expects],
-          :headers  => {
-            'Content-Type' => 'application/json',
-            'X-Auth-Token' => @auth_token
-          }.merge!(params[:headers] || {}),
-          :host     => @cdn_host,
-          :method   => params[:method],
-          :path     => "#{@cdn_path}/#{params[:path]}",
-          :query    => params[:query]
-        })
-        unless response.body.empty?
-          response.body = JSON.parse(response.body)
-        end
-        response
+      def self.reset_data(keys=Mock.data.keys)
+        Mock.reset_data(keys)
       end
 
-      def storage_request(params, parse_json = true)
-        @storage_connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}")
-        response = @storage_connection.request({
-          :body     => params[:body],
-          :expects  => params[:expects],
-          :headers  => {
-            'Content-Type' => 'application/json',
-            'X-Auth-Token' => @auth_token
-          }.merge!(params[:headers] || {}),
-          :host     => @storage_host,
-          :method   => params[:method],
-          :path     => "#{@storage_path}/#{params[:path]}",
-          :query    => params[:query]
-        })
-        if !response.body.empty? && parse_json
-          response.body = JSON.parse(response.body)
+      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={})
+          @rackspace_username = options[:rackspace_username]
+          @data = self.class.data[@rackspace_username]
         end
-        response
+
       end
 
+      class Real
+
+        def initialize(options={})
+          credentials = Fog::Rackspace.authenticate(options)
+          @auth_token = credentials['X-Auth-Token']
+          cdn_uri = URI.parse(credentials['X-CDN-Management-Url'])
+          @cdn_host   = cdn_uri.host
+          @cdn_path   = cdn_uri.path
+          @cdn_port   = cdn_uri.port
+          @cdn_scheme = cdn_uri.scheme
+          storage_uri = URI.parse(credentials['X-Storage-Url'])
+          @storage_host   = storage_uri.host
+          @storage_path   = storage_uri.path
+          @storage_port   = storage_uri.port
+          @storage_scheme = storage_uri.scheme
+        end
+
+        def cdn_request(params)
+          @cdn_connection = Fog::Connection.new("#{@cdn_scheme}://#{@cdn_host}:#{@cdn_port}")
+          response = @cdn_connection.request({
+            :body     => params[:body],
+            :expects  => params[:expects],
+            :headers  => {
+              'Content-Type' => 'application/json',
+              'X-Auth-Token' => @auth_token
+            }.merge!(params[:headers] || {}),
+            :host     => @cdn_host,
+            :method   => params[:method],
+            :path     => "#{@cdn_path}/#{params[:path]}",
+            :query    => params[:query]
+          })
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+
+        def storage_request(params, parse_json = true)
+          @storage_connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}")
+          response = @storage_connection.request({
+            :body     => params[:body],
+            :expects  => params[:expects],
+            :headers  => {
+              'Content-Type' => 'application/json',
+              'X-Auth-Token' => @auth_token
+            }.merge!(params[:headers] || {}),
+            :host     => @storage_host,
+            :method   => params[:method],
+            :path     => "#{@storage_path}/#{params[:path]}",
+            :query    => params[:query]
+          })
+          if !response.body.empty? && parse_json
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+
+      end
     end
   end
 end
-
-Fog::Rackspace::Files.reload

data/lib/fog/rackspace/models/files/directories.rb

@@ -1,9 +1,20 @@
+require 'fog/collection'
+require 'fog/rackspace/models/files/directory'
+
 module Fog
   module Rackspace
-    class Files
+    module Files
 
-      def directories
-        Fog::Rackspace::Files::Directories.new(:connection => self)
+      class Real
+        def directories
+          Fog::Rackspace::Files::Directories.new(:connection => self)
+        end
+      end
+
+      class Mock
+        def directories
+          Fog::Rackspace::Files::Directories.new(:connection => self)
+        end
       end
 
       class Directories < Fog::Collection

data/lib/fog/rackspace/models/files/directory.rb

@@ -1,6 +1,8 @@
+require 'fog/model'
+
 module Fog
   module Rackspace
-    class Files
+    module Files
 
       class Directory < Fog::Model