fog 0.9.0 → 0.10.0

data/lib/fog/compute/requests/vcloud/login.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Vcloud
+    class Compute
+
+      class Real
+
+
+        def login
+          unauthenticated_request({
+            :expects  => 200,
+            :headers  => {
+              'Authorization' => authorization_header
+            },
+            :method   => 'POST',
+            :parse    => true,
+            :uri      => "#{base_url}/login"
+          })
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/power_off.rb

@@ -0,0 +1,10 @@
+module Fog
+  module Vcloud
+    class Compute
+
+      class Real
+        basic_request :power_off, 202, 'POST'
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/power_on.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Vcloud
+    class Compute
+
+      class Real
+        basic_request :power_on, 202, 'POST'
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/power_reset.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Vcloud
+    class Compute
+
+      class Real
+        basic_request :power_reset, 202, 'POST'
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/power_shutdown.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Vcloud
+    class Compute
+
+      class Real
+        basic_request :power_shutdown, 204, 'POST'
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/vcloud/undeploy.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Vcloud
+    class Compute
+      class Real
+        def undeploy(vapp_uri, save_state = false)
+          # builder = Builder::XmlMarkup.new
+          # builder.UndeployVAppParams(:xmlns => 'http://www.vmware.com/vcloud/v1',
+          #                            :saveState => save_state) {}
+          builder = "<UndeployVAppParams saveState=\"#{save_state.to_s}\" xmlns=\"http://www.vmware.com/vcloud/v1\"/>"
+
+          request(
+                  :body     => builder,
+                  :expects  => 202,
+                  :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.undeployVAppParams+xml' },
+                  :method   => 'POST',
+                  :uri      => vapp_uri + '/action/undeploy',
+                  :parse    => true
+                  )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/storm_on_demand.rb

@@ -82,7 +82,7 @@ module Fog
       class Real
 
         def initialize(options={})
-          require 'json'
+          require 'multi_json'
           uri = URI.parse(options[:storm_on_demand_auth_url] ||= API_URL)
           @host   = uri.host
           @path   = uri.path
@@ -118,7 +118,7 @@ module Fog
             end
           end
           unless response.body.empty?
-            response.body = JSON.parse(response.body)
+            response.body = MultiJson.decode(response.body)
           end
           if response.body.keys.include?('full_error')
             raise(Fog::Compute::StormOnDemand::Error, response.body.inspect)

data/lib/fog/compute/vcloud.rb

@@ -0,0 +1,310 @@
+require 'fog/core'
+
+module Fog
+  module Vcloud
+    class Collection < Fog::Collection
+
+      def load(objects)
+        objects = [ objects ] if objects.is_a?(Hash)
+        super
+      end
+
+      def check_href!(opts = {})
+        self.href = connection.default_vdc_href unless href
+        unless href
+          if opts.is_a?(String)
+            t = Hash.new
+            t[:parent] = opts
+            opts = t
+          end
+          msg = ":href missing, call with a :href pointing to #{if opts[:message]
+                  opts[:message]
+                elsif opts[:parent]
+                  "the #{opts[:parent]} whos #{self.class.to_s.split('::').last.downcase} you want to enumerate"
+                else
+                  "the resource"
+                end}"
+          raise Fog::Errors::Error.new(msg)
+        end
+      end
+
+    end
+  end
+end
+
+module Fog
+  module Vcloud
+    class Model < Fog::Model
+
+      attr_accessor :loaded
+      alias_method :loaded?, :loaded
+
+      def reload
+        instance = super
+        @loaded = true
+        instance
+      end
+
+      def load_unless_loaded!
+        unless @loaded
+          reload
+        end
+      end
+
+    end
+  end
+end
+
+module Fog
+  module Vcloud
+    class Compute < Fog::Service
+
+      PATH   = '/api/v1.0'
+      PORT   = 443
+      SCHEME = 'https'
+
+      requires   :vcloud_username, :vcloud_password, :vcloud_host
+      recognizes :vcloud_port, :vcloud_scheme, :vcloud_path, :vcloud_default_vdc
+      recognizes :provider # remove post deprecation
+
+      model_path 'fog/compute/models/vcloud'
+      model :catalog
+      require 'fog/compute/models/vcloud/catalog' # why do I need to do this?
+      collection :catalogs
+      model :catalog_item
+      model :catalog_items
+      model :ip
+      collection :ips
+      model :network
+      collection :networks
+      model :server
+      collection :servers
+      model :task
+      collection :tasks
+      model :vdc
+      collection :vdcs
+
+      request_path 'fog/compute/requests/vcloud'
+      request :clone_vapp
+      request :configure_network
+      request :configure_network_ip
+      request :configure_vapp
+      request :configure_vm_memory
+      request :configure_vm_name_description
+      request :configure_vm_disks
+      request :delete_vapp
+      request :get_catalog
+      request :get_catalog_item
+      request :get_customization_options
+      request :get_network
+      request :get_network_ip
+      request :get_network_ips
+      request :get_network_extensions
+      request :get_organization
+      request :get_task
+      request :get_task_list
+      request :get_vapp
+      request :get_vapp_template
+      request :get_vm_disks
+      request :get_vm_memory
+      request :get_vdc
+      request :instantiate_vapp_template
+      request :login
+      request :power_off
+      request :power_on
+      request :power_reset
+      request :power_shutdown
+      request :undeploy
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        class << self
+
+          def basic_request(*args)
+            self.class_eval <<-EOS, __FILE__,__LINE__
+              def #{args[0]}(uri)
+                request({
+                  :expects => #{args[1] || 200},
+                  :method  => '#{args[2] || 'GET'}',
+                  :headers => #{args[3] ? args[3].inspect : '{}'},
+                  :body => '#{args[4] ? args[4] : ''}',
+                  :parse => true,
+                  :uri     => uri })
+              end
+            EOS
+          end
+
+          def unauthenticated_basic_request(*args)
+            self.class_eval <<-EOS, __FILE__,__LINE__
+              def #{args[0]}(uri)
+                unauthenticated_request({
+                  :expects => #{args[1] || 200},
+                  :method  => '#{args[2] || 'GET'}',
+                  :headers => #{args[3] ? args[3].inspect : '{}'},
+                  :parse => true,
+                  :uri     => uri })
+              end
+            EOS
+          end
+
+        end
+
+        def initialize(options = {})
+          require 'builder'
+          require 'fog/core/parser'
+
+          @connections = {}
+          @persistent = options[:persistent]
+
+          @username = options[:vcloud_username]
+          @password = options[:vcloud_password]
+          @host     = options[:vcloud_host]
+          @vdc_href     = options[:vcloud_default_vdc]
+          @path     = options[:vcloud_path]   || Fog::Vcloud::Compute::PATH
+          @port     = options[:vcloud_port]   || Fog::Vcloud::Compute::PORT
+          @scheme   = options[:vcloud_scheme] || Fog::Vcloud::Compute::SCHEME
+        end
+
+        def reload
+          @connections.each_value { |k,v| v.reset if v }
+        end
+
+        def default_organization_uri
+          @default_organization_uri ||= begin
+            unless @login_results
+              do_login
+            end
+            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 default_vdc_href
+          @vdc_href
+        end
+
+        # login handles the auth, but we just need the Set-Cookie
+        # header from that call.
+        def do_login
+          @login_results = login
+          @cookie = @login_results.headers['Set-Cookie']
+        end
+
+        def ensure_unparsed(uri)
+          if uri.is_a?(String)
+            uri
+          else
+            uri.to_s
+          end
+        end
+
+        def xmlns
+          { "xmlns" => "http://www.vmware.com/vcloud/v1",
+            "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+            "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+            "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
+        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 ensure_parsed(uri)
+          if uri.is_a?(String)
+            URI.parse(uri)
+          else
+            uri
+          end
+        end
+
+        # Don't need to  set the cookie for these or retry them if the cookie timed out
+        def unauthenticated_request(params)
+          do_request(params)
+        end
+
+        def base_url
+          "#{@scheme}://#{@host}:#{@port}#{@path}"
+        end
+
+        # Use this to set the Authorization header for login
+        def authorization_header
+          "Basic #{Base64.encode64("#{@username}:#{@password}").chomp!}"
+        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
+          host_url = "#{params[:uri].scheme}://#{params[:uri].host}#{params[:uri].port ? ":#{params[:uri].port}" : ''}"
+
+          # Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
+          # different hosts.
+          @connections[host_url] ||= Fog::Connection.new(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
+
+          # Make the request
+          response = @connections[host_url].request({
+            :body     => params[:body] || '',
+            :expects  => params[:expects] || 200,
+            :headers  => headers,
+            :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
+
+    end
+  end
+end

data/lib/fog/core.rb

@@ -25,10 +25,11 @@ require 'fog/core/errors'
 require 'fog/core/hmac'
 require 'fog/core/model'
 require 'fog/core/mock'
-# require 'fog/core/parser'
+require 'fog/core/parser' # FIXME: would be better to only load when nokogiri is required
 require 'fog/core/provider'
 require 'fog/core/service'
 require 'fog/core/ssh'
 require 'fog/core/scp'
 require 'fog/core/time'
+require 'fog/core/timeout'
 require 'fog/core/wait_for'

data/lib/fog/core/attributes.rb

@@ -71,8 +71,10 @@ module Fog
             class_eval <<-EOS, __FILE__, __LINE__
               def #{name}=(new_data)
                 if new_data.is_a?(Hash)
-                  if new_data[:#{squash}] || new_data["#{squash}"]
-                    attributes[:#{name}] = new_data[:#{squash}] || new_data["#{squash}"]
+                  if new_data.has_key?(:#{squash})
+                    attributes[:#{name}] = new_data[:#{squash}]
+                  elsif new_data.has_key?("#{squash}")
+                    attributes[:#{name}] = new_data["#{squash}"]
                   else
                     attributes[:#{name}] = [ new_data ]
                   end
@@ -156,23 +158,33 @@ module Fog
 
       # check that the attributes specified in args exist and is not nil
       def requires(*args)
+        missing = missing_attributes(args)
+        if missing.length == 1
+          raise(ArgumentError, "#{missing.first} is required for this operation")
+        elsif missing.any?
+          raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+        end
+      end
+
+      def requires_one(*args)
+        missing = missing_attributes(args)
+        if missing.length == args.length
+          raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
+        end
+      end
+
+      protected
+
+      def missing_attributes(args)
         missing = []
         for arg in [:connection] | args
           unless send("#{arg}") || attributes.has_key?(arg)
             missing << arg
           end
         end
-        unless missing.empty?
-          if missing.length == 1
-            raise(ArgumentError, "#{missing.first} is required for this operation")
-          else
-            raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
-          end
-        end
+        missing
       end
 
-      protected
-
       def dup_attributes!
         @attributes = @attributes.dup
       end