fog 0.2.0 → 0.2.1

data/lib/fog/parser.rb

@@ -41,6 +41,8 @@ module Fog
       last = @stack.pop
       if last.empty? && @value.empty?
         @stack.last[name.to_sym] = ''
+      elsif last == {:i_nil=>"true"}
+        @stack.last[name.to_sym] = nil
       elsif !@value.empty?
         @stack.last[name.to_sym] = @value
       end
@@ -51,6 +53,10 @@ module Fog
       @stack.first
     end
 
+    def response
+      body
+    end
+
     def start_element(name, attributes = [])
       @value = ''
       parsed_attributes = {}

data/lib/fog/rackspace/files.rb

@@ -78,20 +78,27 @@ module Fog
         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
+          @cdn_connection = Fog::Connection.new("#{@cdn_scheme}://#{@cdn_host}:#{@cdn_port}", options[:persistent])
+
           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
+          @storage_connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
         end
 
         def cdn_request(params)
-          @cdn_connection = Fog::Connection.new("#{@cdn_scheme}://#{@cdn_host}:#{@cdn_port}")
           response = @cdn_connection.request(params.merge!({
             :headers  => {
               'Content-Type' => 'application/json',
@@ -107,7 +114,6 @@ module Fog
         end
 
         def storage_request(params, parse_json = true, &block)
-          @storage_connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}")
           response = @storage_connection.request(params.merge!({
             :headers  => {
               'Content-Type' => 'application/json',

data/lib/fog/rackspace/models/servers/server.rb

@@ -20,6 +20,11 @@ module Fog
 
         attr_accessor :password, :private_key_path, :public_key_path
 
+        def initialize(attributes={})
+          @flavor_id ||= 1
+          super
+        end
+
         def destroy
           requires :id
           connection.delete_server(@id)

data/lib/fog/rackspace/servers.rb

@@ -73,10 +73,14 @@ module Fog
           @path   = uri.path
           @port   = uri.port
           @scheme = uri.scheme
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
         end
 
         def request(params)
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
           begin
             response = @connection.request(params.merge!({
               :headers  => {

data/lib/fog/service.rb

@@ -32,11 +32,16 @@ module Fog
             @required = true
           end
 
-          if Fog.mocking?
+          instance = if Fog.mocking?
             Mock.new(options)
           else
             Real.new(options)
           end
+
+          if self.respond_to?(:after_new)
+            instance = self.after_new(instance, options)
+          end
+          instance
         end
       EOS
     end

data/lib/fog/slicehost.rb

@@ -54,10 +54,14 @@ module Fog
         @host   = options[:host]    || "api.slicehost.com"
         @port   = options[:port]    || 443
         @scheme = options[:scheme]  || 'https'
+        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+      end
+
+      def reload
+        @connection.reset
       end
 
       def request(params)
-        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
         params[:headers] ||= {}
         params[:headers].merge!({
           'Authorization' => "Basic #{Base64.encode64(@slicehost_password).delete("\r\n")}"

data/lib/fog/terremark/ecloud.rb

@@ -42,6 +42,7 @@ module Fog
           @path   = options[:path]   || Fog::Terremark::Ecloud::Defaults::PATH
           @port   = options[:port]   || Fog::Terremark::Ecloud::Defaults::PORT
           @scheme = options[:scheme] || Fog::Terremark::Ecloud::Defaults::SCHEME
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
         end
 
       end

data/lib/fog/terremark/shared.rb

@@ -51,8 +51,11 @@ module Fog
           response.headers['Set-Cookie']
         end
 
+        def reload
+          @connection.reset
+        end
+
         def request(params)
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
           unless @cookie
             @cookie = auth_token
           end

data/lib/fog/terremark/vcloud.rb

@@ -42,6 +42,7 @@ module Fog
           @path   = options[:path]   || Fog::Terremark::Vcloud::Defaults::PATH
           @port   = options[:port]   || Fog::Terremark::Vcloud::Defaults::PORT
           @scheme = options[:scheme] || Fog::Terremark::Vcloud::Defaults::SCHEME
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
         end
 
         def default_vdc_id

data/lib/fog/vcloud.rb

@@ -1,3 +1,11 @@
+require 'builder'
+require 'fog/vcloud/model'
+require 'fog/vcloud/collection'
+require 'fog/vcloud/generators'
+require 'fog/vcloud/extension'
+require 'fog/vcloud/terremark/vcloud'
+require 'fog/vcloud/terremark/ecloud'
+
 module URI
   class Generic
     def host_url
@@ -8,19 +16,35 @@ end
 
 module Fog
   module Vcloud
+    extend Fog::Service
+
+    requires :username, :password, :versions_uri
+
+    model_path 'fog/vcloud/models'
+    model 'vdc'
+    model 'vdcs'
+
+    request_path 'fog/vcloud/requests'
+    request :login
+    request :get_versions
+    request :get_vdc
+    request :get_organization
+    request :get_network
+
+    def self.after_new(instance, options={})
+      if mod = options[:module]
+        instance.extend eval("#{mod}")
+      end 
+      instance
+    end
 
     class UnsupportedVersion < Exception ; end
 
-    module Options
-      REQUIRED = [:versions_uri, :username, :password]
-      OPTIONAL = [:module, :version]
-      ALL = REQUIRED + OPTIONAL
-    end
-
     class Real
+      extend Fog::Vcloud::Generators
 
       attr_accessor :login_uri
-      attr_reader :supported_versions
+      attr_reader :supported_versions, :versions_uri
 
       def initialize(options = {})
         @connections = {}
@@ -30,6 +54,7 @@ module Fog
         @username = options[:username]
         @password = options[:password]
         @login_uri = get_login_uri
+        @persistent = options[:persistent]
       end
 
       def default_organization_uri
@@ -37,39 +62,86 @@ module Fog
           unless @login_results
             do_login
           end
-          org_list = @login_results.body.organizations
-          if organization = @login_results.body.organizations.first
-            organization[:href]
+          case @login_results.body[:Org]
+          when Array
+            @login_results.body[:Org].first[:href]
+          when Hash
+            @login_results.body[:Org][:href]
           else
             nil
           end
         end
       end
 
+      def reload
+        @connections.each_value { |k,v| v.reset if v }
+      end
+
+      # If the cookie isn't set, do a get_organizations call to set it
+      # and try the request.
+      # If we get an Unauthorized error, we assume the token expired, re-auth and try again
+      def request(params)
+        unless @cookie
+          do_login
+        end
+        begin
+          do_request(params)
+        rescue Excon::Errors::Unauthorized => e
+          do_login
+          do_request(params)
+        end
+      end
+
+
       private
 
-      def supported_version_ids
-        @supported_versions.map { |version| version.version }
+      def ensure_parsed(uri)
+        if uri.is_a?(String)
+          URI.parse(uri)
+        else
+          uri
+        end
+      end
+
+      def ensure_unparsed(uri)
+        if uri.is_a?(String)
+          uri
+        else
+          uri.to_s
+        end
+      end
+
+      def supported_version_numbers
+        case @supported_versions
+        when Array
+          @supported_versions.map { |version| version[:Version] }
+        when Hash
+          @supported_versions[:Version]
+        end
       end
 
       def get_login_uri
         check_versions
-        URI.parse(@supported_versions.detect {|version| version.version == @version }.login_url)
+        URI.parse case @supported_versions
+        when Array
+          @supported_versions.detect {|version| version[:Version] == @version }[:LoginUrl]
+        when Hash
+          @supported_versions[:LoginUrl]
+        end
       end
 
       # Load up @all_versions and @supported_versions from the provided :versions_uri
       # If there are no supported versions raise an error
       # And choose a default version is none is specified
       def check_versions
-        @all_versions = get_versions.body
-        @supported_versions = @all_versions.select { |version| version.supported == true }
+        @supported_versions = get_versions(@versions_uri).body[:VersionInfo]
 
         if @supported_versions.empty?
           raise UnsupportedVersion.new("No supported versions found @ #{@version_uri}")
         end
 
         unless @version
-          @version = supported_version_ids.sort.first
+          @version = supported_version_numbers.first
         end
       end
 
@@ -90,39 +162,48 @@ module Fog
         @cookie = @login_results.headers['Set-Cookie']
       end
 
-      # If the cookie isn't set, do a get_organizations call to set it
-      # and try the request.
-      # If we get an Unauthoried error, we assume the token expired, re-auth and try again
-      def request(params)
-        unless @cookie
-          do_login
-        end
-        begin
-          do_request(params)
-        rescue Excon::Errors::Unauthorized => e
-          do_login
-          do_request(params)
-        end
-      end
-
       # Actually do the request
       def do_request(params)
+        # Convert the uri to a URI if it's a string.
         if params[:uri].is_a?(String)
           params[:uri] = URI.parse(params[:uri])
         end
-        @connections[params[:uri].host_url] ||= Fog::Connection.new(params[:uri].host_url)
+
+        # Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
+        # different hosts.
+        @connections[params[:uri].host_url] ||= Fog::Connection.new(params[:uri].host_url, @persistent)
+
+        # Set headers to an empty hash if none are set.
         headers = params[:headers] || {}
+
+        # Add our auth cookie to the headers
         if @cookie
           headers.merge!('Cookie' => @cookie)
         end
-        @connections[params[:uri].host_url].request({
-          :body     => params[:body],
-          :expects  => params[:expects],
+
+        # Make the request
+        response = @connections[params[:uri].host_url].request({
+          :body     => params[:body] || '',
+          :expects  => params[:expects] || 200,
           :headers  => headers,
-          :method   => params[:method],
-          :parser   => params[:parser],
+          :method   => params[:method] || 'GET',
           :path     => params[:uri].path
         })
+
+        # Parse the response body into a hash
+        #puts response.body
+        unless response.body.empty?
+          if params[:parse]
+            document = Fog::ToHashDocument.new
+            parser = Nokogiri::XML::SAX::PushParser.new(document)
+            parser << response.body
+            parser.finish
+
+            response.body = document.body
+          end
+        end
+
+        response
       end
     end
 
@@ -135,7 +216,7 @@ module Fog
         @mock_data = nil
       end
 
-      def self.data
+      def self.data( base_url = self.base_url )
         @mock_data ||=
         {
           :versions => [
@@ -166,32 +247,35 @@ module Fog
                 :name => "Boom Inc.",
               },
               :vdcs => [
+
                 { :href => "#{base_url}/vdc/21",
-                  :id => 21,
+                  :id => "21",
                   :name => "Boomstick",
-                  :storage => { :used => 105, :allocated => 200 },
-                  :cpu => { :allocated => 10000 },
-                  :memory => { :allocated => 20480 },
+                  :storage => { :used => "105", :allocated => "200" },
+                  :cpu => { :allocated => "10000" },
+                  :memory => { :allocated => "20480" },
                   :networks => [
-                    { :href => "#{base_url}/network/31",
+                    { :id => "31",
+                      :href => "#{base_url}/network/31",
                       :name => "1.2.3.0/24",
                       :subnet => "1.2.3.0/24",
                       :gateway => "1.2.3.1",
                       :netmask => "255.255.255.0",
                       :dns => "8.8.8.8",
                       :features => [
-                        { :type => :fencemode, :value => "isolated" }
+                        { :type => :FenceMode, :value => "isolated" }
                       ],
                       :ips => { "1.2.3.3" => "Broom 1", "1.2.3.4" => "Broom 2", "1.2.3.10" => "Email" }
                     },
-                    { :href => "#{base_url}/network/32",
+                    { :id => "32",
+                      :href => "#{base_url}/network/32",
                       :name => "4.5.6.0/24",
                       :subnet => "4.5.6.0/24",
                       :gateway => "4.5.6.1",
                       :netmask => "255.255.255.0",
                       :dns => "8.8.8.8",
                       :features => [
-                        { :type => :fencemode, :value => "isolated" }
+                        { :type => :FenceMode, :value => "isolated" }
                       ],
                       :ips => { }
                     },
@@ -206,43 +290,24 @@ module Fog
                     { :href => "#{base_url}/vap/43",
                       :name => "Email!"
                     }
-                  ],
-                  :public_ips => [
-                    { :id => 51,
-                      :name => "99.1.2.3",
-                      :services => [
-                        { :id => 71, :port => 80, :protocol => 'HTTP', :enabled => true, :timeout => 2, :name => 'Web Site', :description => 'Web Servers' },
-                        { :id => 72, :port => 7000, :protocol => 'HTTP', :enabled => true, :timeout => 2, :name => 'An SSH Map', :description => 'SSH 1' }
-                      ]
-                    },
-                    { :id => 52,
-                      :name => "99.1.2.4",
-                      :services => [
-                        { :id => 73, :port => 80, :protocol => 'HTTP', :enabled => true, :timeout => 2, :name => 'Web Site', :description => 'Web Servers' },
-                        { :id => 74, :port => 7000, :protocol => 'HTTP', :enabled => true, :timeout => 2, :name => 'An SSH Map', :description => 'SSH 2' }
-                      ]
-                    },
-                    { :id => 53,
-                      :name => "99.1.9.7",
-                      :services => []
-                    }
                   ]
                 },
                 { :href => "#{base_url}/vdc/22",
-                  :id => 22,
-                  :storage => { :used => 40, :allocated => 150 },
-                  :cpu => { :allocated => 1000 },
-                  :memory => { :allocated => 2048 },
+                  :id => "22",
+                  :storage => { :used => "40", :allocated => "150" },
+                  :cpu => { :allocated => "1000" },
+                  :memory => { :allocated => "2048" },
                   :name => "Rock-n-Roll",
                   :networks => [
-                    { :href => "#{base_url}/network/33",
+                    { :id => "33",
+                      :href => "#{base_url}/network/33",
                       :name => "7.8.9.0/24",
                       :subnet => "7.8.9.0/24",
                       :gateway => "7.8.9.1",
                       :dns => "8.8.8.8",
                       :netmask => "255.255.255.0",
                       :features => [
-                        { :type => :fencemode, :value => "isolated" }
+                        { :type => :FenceMode, :value => "isolated" }
                       ],
                       :ips => { "7.8.9.10" => "Master Blaster" }
                     }
@@ -251,12 +316,6 @@ module Fog
                     { :href => "#{base_url}/vap/44",
                       :name => "Master Blaster"
                     }
-                  ],
-                  :public_ips => [
-                    { :id => 54,
-                      :name => "99.99.99.99",
-                      :services => []
-                    }
                   ]
                 }
               ]
@@ -265,17 +324,17 @@ module Fog
         }
       end
 
-      def self.vdc_from_uri(uri)
+      def vdc_from_uri(uri)
         match = Regexp.new(%r:.*/vdc/(\d+):).match(uri.to_s)
         if match
-          Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:id] == match[1].to_i }
+          mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:id] == match[1] }
         end
       end
 
-      def self.ip_from_uri(uri)
+      def ip_from_uri(uri)
         match = Regexp.new(%r:.*/publicIp/(\d+):).match(uri.to_s)
         if match
-          Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |public_ip| public_ip[:id] == match[1].to_i }
+          mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |public_ip| public_ip[:id] == match[1] }
         end
       end
 
@@ -290,16 +349,16 @@ module Fog
           "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
       end
 
-      def mock_it(parser, status, mock_data, mock_headers = {})
+      def mock_it(status, mock_data, mock_headers = {})
         response = Excon::Response.new
-        if parser
-          body = Nokogiri::XML::SAX::PushParser.new(parser)
-          body << mock_data
-          body.finish
-          response.body = parser.response
-        else
-          response.body = mock_data
-        end
+
+        #Parse the response body into a hash
+        document = Fog::ToHashDocument.new
+        parser = Nokogiri::XML::SAX::PushParser.new(document)
+        parser << mock_data
+        parser.finish
+        response.body = document.body
+
         response.status = status
         response.headers = mock_headers
         response
@@ -314,55 +373,5 @@ module Fog
       end
 
     end
-
-    class <<self
-      def new(credentials = {})
-        unless @required
-          require 'fog/vcloud/model'
-          require 'fog/vcloud/collection'
-          require 'fog/vcloud/parser'
-          require 'fog/vcloud/models/vdc'
-          require 'fog/vcloud/models/vdcs'
-          require 'fog/vcloud/terremark/vcloud'
-          require 'fog/vcloud/terremark/ecloud'
-          require 'fog/vcloud/requests/get_network'
-          require 'fog/vcloud/requests/get_organization'
-          require 'fog/vcloud/requests/get_vdc'
-          require 'fog/vcloud/requests/get_versions'
-          require 'fog/vcloud/requests/login'
-          require 'fog/vcloud/parsers/get_organization'
-          require 'fog/vcloud/parsers/get_vdc'
-          require 'fog/vcloud/parsers/get_versions'
-          require 'fog/vcloud/parsers/login'
-          require 'fog/vcloud/parsers/network'
-
-          require 'builder'
-
-          Struct.new("VcloudLink", :rel, :href, :type, :name)
-          Struct.new("VcloudVdc", :links, :resource_entities, :networks, :cpu_capacity, :storage_capacity, :memory_capacity, :href, :type, :name, :xmlns,
-                                  :allocation_model, :network_quota, :nic_quota, :vm_quota, :enabled, :description)
-          Struct.new("VcloudOrganization", :links, :name, :href, :type, :xmlns, :description)
-          Struct.new("VcloudVersion", :version, :login_url, :supported)
-          Struct.new("VcloudOrgList", :organizations, :xmlns)
-          Struct.new("VcloudXCapacity", :units, :allocated, :used, :limit)
-          Struct.new("VcloudNetwork", :features, :configuration, :href, :type, :name, :xmlns, :description)
-          Struct.new("VcloudNetworkConfiguration", :gateway, :netmask, :dns)
-          Struct.new("VcloudNetworkFenceMode", :mode)
-          @required = true
-        end
-
-        instance = if Fog.mocking?
-          Fog::Vcloud::Mock.new(credentials)
-        else
-          Fog::Vcloud::Real.new(credentials)
-        end
-
-        if mod = credentials[:module]
-          instance.extend eval("#{mod}")
-        end
-
-        instance
-      end
-    end
   end
 end