fog-maestrodev 1.19.0.20140212012611 → 1.20.0.20140305101305

data/lib/fog/vcloud_director.rb

@@ -1,67 +1 @@
-require 'fog/core'
-
-module Fog
-  module VcloudDirector
-    extend Fog::Provider
-
-    module Errors
-      class ServiceError < Fog::Errors::Error
-        attr_reader :minor_error_code
-        attr_reader :major_error_code
-        attr_reader :stack_trace
-        attr_reader :status_code
-        attr_reader :vendor_specific_error_code
-
-        def self.slurp(error, service=nil)
-          major_error_code = nil
-          message = nil
-          minor_error_code = nil
-          stack_trace = nil
-          status_code = nil
-          vendor_specific_error_code = nil
-
-          if error.response
-            status_code = error.response.status
-            unless error.response.body.empty?
-              _, media_type = error.response.headers.detect {|k,v| k.downcase == 'content-type'}
-              if media_type =~ /vnd\.vmware\.vcloud\.error\+xml/i
-                begin
-                  document = Fog::ToHashDocument.new
-                  Nokogiri::XML::SAX::Parser.new(document).parse_memory(error.response.body)
-                  major_error_code = document.body[:majorErrorCode]
-                  message = document.body[:message]
-                  minor_error_code = document.body[:minorErrorCode]
-                  stack_trace = document.body[:stackTrace]
-                  vendor_specific_error_code = document.body[:vendorSpecificErrorCode]
-                rescue => e
-                  Fog::Logger.warning("Received exception '#{e}' while decoding>> #{error.response.body}")
-                  message = error.response.body
-                end
-              else
-                message = CGI::unescapeHTML(error.response.body)
-              end
-            end
-          end
-
-          new_error = super(error, message)
-          new_error.instance_variable_set(:@major_error_code, major_error_code)
-          new_error.instance_variable_set(:@minor_error_code, minor_error_code)
-          new_error.instance_variable_set(:@stack_trace, stack_trace)
-          new_error.instance_variable_set(:@status_code, status_code)
-          new_error.instance_variable_set(:@vendor_specific_error_code, vendor_specific_error_code)
-          new_error
-        end
-      end
-
-      class BadRequest < ServiceError; end
-      class Unauthorized < ServiceError; end
-      class Forbidden < ServiceError; end
-      class Conflict < ServiceError; end
-
-      class DuplicateName < ServiceError; end
-      class TaskError < ServiceError; end
-    end
-
-    service(:compute, 'vcloud_director/compute', 'Compute')
-  end
-end
+require 'fog/vcloud_director/compute'

data/lib/fog/vcloud_director/compute.rb

@@ -1,4 +1,4 @@
-require 'fog/vcloud_director'
+require 'fog/vcloud_director/core'
 require 'fog/compute'
 
 class VcloudDirectorParser < Fog::Parsers::Base

data/lib/fog/vcloud_director/core.rb

@@ -0,0 +1,67 @@
+require 'fog/core'
+
+module Fog
+  module VcloudDirector
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error
+        attr_reader :minor_error_code
+        attr_reader :major_error_code
+        attr_reader :stack_trace
+        attr_reader :status_code
+        attr_reader :vendor_specific_error_code
+
+        def self.slurp(error, service=nil)
+          major_error_code = nil
+          message = nil
+          minor_error_code = nil
+          stack_trace = nil
+          status_code = nil
+          vendor_specific_error_code = nil
+
+          if error.response
+            status_code = error.response.status
+            unless error.response.body.empty?
+              _, media_type = error.response.headers.detect {|k,v| k.downcase == 'content-type'}
+              if media_type =~ /vnd\.vmware\.vcloud\.error\+xml/i
+                begin
+                  document = Fog::ToHashDocument.new
+                  Nokogiri::XML::SAX::Parser.new(document).parse_memory(error.response.body)
+                  major_error_code = document.body[:majorErrorCode]
+                  message = document.body[:message]
+                  minor_error_code = document.body[:minorErrorCode]
+                  stack_trace = document.body[:stackTrace]
+                  vendor_specific_error_code = document.body[:vendorSpecificErrorCode]
+                rescue => e
+                  Fog::Logger.warning("Received exception '#{e}' while decoding>> #{error.response.body}")
+                  message = error.response.body
+                end
+              else
+                message = CGI::unescapeHTML(error.response.body)
+              end
+            end
+          end
+
+          new_error = super(error, message)
+          new_error.instance_variable_set(:@major_error_code, major_error_code)
+          new_error.instance_variable_set(:@minor_error_code, minor_error_code)
+          new_error.instance_variable_set(:@stack_trace, stack_trace)
+          new_error.instance_variable_set(:@status_code, status_code)
+          new_error.instance_variable_set(:@vendor_specific_error_code, vendor_specific_error_code)
+          new_error
+        end
+      end
+
+      class BadRequest < ServiceError; end
+      class Unauthorized < ServiceError; end
+      class Forbidden < ServiceError; end
+      class Conflict < ServiceError; end
+
+      class DuplicateName < ServiceError; end
+      class TaskError < ServiceError; end
+    end
+
+    service(:compute, 'Compute')
+  end
+end

data/lib/fog/vcloud_director/generators/compute/edge_gateway_service_configuration.rb

@@ -75,7 +75,7 @@ module Fog
                       xml.Protocol service_profile[:Protocol]
                       xml.Port service_profile[:Port]
                       xml.Persistence {
-                        xml.Method service_profile[:Persistence][:method]
+                        xml.Method service_profile[:Persistence][:Method]
                         if service_profile[:Persistence][:Method] == 'COOKIE'
                           xml.CookieName service_profile[:Persistence][:CookieName]
                           xml.CookieMode service_profile[:Persistence][:CookieMode]

data/lib/fog/version.rb

@@ -1,3 +1,3 @@
 module Fog
-  VERSION = '1.19.0'
+  VERSION = '1.20.0'
 end

data/lib/fog/vmfusion.rb

@@ -1,11 +1 @@
-require 'fog/core'
-
-module Fog
-  module Vmfusion
-
-    extend Fog::Provider
-
-    service(:compute, 'vmfusion/compute', 'Compute')
-
-  end
-end
+require 'fog/vmfusion/compute'

data/lib/fog/vmfusion/compute.rb

@@ -1,4 +1,4 @@
-require 'fog/vmfusion'
+require 'fog/vmfusion/core'
 require 'fog/compute'
 
 module Fog

data/lib/fog/vmfusion/core.rb

@@ -0,0 +1,11 @@
+require 'fog/core'
+
+module Fog
+  module Vmfusion
+
+    extend Fog::Provider
+
+    service(:compute, 'Compute')
+
+  end
+end

data/lib/fog/vmfusion/models/compute/server.rb

@@ -185,19 +185,19 @@ module Fog
 
         # SCP something to our VM.
         def scp(local_path, remote_path, upload_options = {})
-          requires :ipaddress, :username
+          requires :ssh_ip_address, :username
 
           scp_options = {}
           scp_options[:password] = password unless self.password.nil?
           scp_options[:key_data] = [private_key] if self.private_key
 
-          Fog::SCP.new(ipaddress, username, scp_options).upload(local_path, remote_path, upload_options)
+          Fog::SCP.new(ssh_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
         end
 
         # Sets up a new SSH key on the VM so one doesn't need to use a password
         # ever again.
         def setup(credentials = {})
-          requires :public_key, :ipaddress, :username
+          requires :public_key, :ssh_ip_address, :username
 
           credentials[:password] = password unless self.password.nil?
           credentails[:key_data] = [private_key] if self.private_key
@@ -213,7 +213,7 @@ module Fog
           Timeout::timeout(360) do
             begin
               Timeout::timeout(8) do
-                Fog::SSH.new(ipaddress, username, credentials.merge(:timeout => 4)).run('pwd')
+                Fog::SSH.new(ssh_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
               end
             rescue Errno::ECONNREFUSED
               sleep(2)
@@ -222,7 +222,7 @@ module Fog
               retry
             end
           end
-          Fog::SSH.new(ipaddress, username, credentials).run(commands)
+          Fog::SSH.new(ssh_ip_address, username, credentials).run(commands)
         end
 
         private

data/lib/fog/voxel.rb

@@ -1,16 +1 @@
-require 'fog/core'
-require 'digest/md5'
-
-module Fog
-  module Voxel
-
-    extend Fog::Provider
-
-    service(:compute, 'voxel/compute', 'Compute')
-
-    def self.create_signature(secret, options)
-      to_sign = options.keys.map { |k| k.to_s }.sort.map { |k| "#{k}#{options[k.to_sym]}" }.join("")
-      Digest::MD7.hexdigest( secret + to_sign )
-    end
-  end
-end
+require 'fog/voxel/compute'

data/lib/fog/voxel/compute.rb

@@ -1,4 +1,4 @@
-require 'fog/voxel'
+require 'fog/voxel/core'
 require 'fog/compute'
 
 module Fog

data/lib/fog/voxel/core.rb

@@ -0,0 +1,16 @@
+require 'fog/core'
+require 'digest/md5'
+
+module Fog
+  module Voxel
+
+    extend Fog::Provider
+
+    service(:compute, 'Compute')
+
+    def self.create_signature(secret, options)
+      to_sign = options.keys.map { |k| k.to_s }.sort.map { |k| "#{k}#{options[k.to_sym]}" }.join("")
+      Digest::MD7.hexdigest( secret + to_sign )
+    end
+  end
+end

data/lib/fog/vsphere.rb

@@ -1,17 +1 @@
-require 'fog/core'
-
-module Fog
-  module Vsphere
-
-    extend Fog::Provider
-
-    module Errors
-      class ServiceError < Fog::Errors::Error; end
-      class SecurityError < ServiceError; end
-      class NotFound < ServiceError; end
-    end
-
-    service(:compute, 'vsphere/compute', 'Compute')
-
-  end
-end
+require 'fog/vsphere/compute'

data/lib/fog/vsphere/compute.rb

@@ -1,3 +1,4 @@
+require 'fog/vsphere/core'
 require 'digest/sha2'
 
 module Fog

data/lib/fog/vsphere/core.rb

@@ -0,0 +1,17 @@
+require 'fog/core'
+
+module Fog
+  module Vsphere
+
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error; end
+      class SecurityError < ServiceError; end
+      class NotFound < ServiceError; end
+    end
+
+    service(:compute, 'Compute')
+
+  end
+end

data/lib/fog/xenserver.rb

@@ -1,83 +1 @@
-require 'fog/core'
-
-module Fog
-  module XenServer 
-
-    class InvalidLogin < Fog::Errors::Error; end
-    class NotFound < Fog::Errors::Error; end
-    class RequestFailed < Fog::Errors::Error; end
-
-    extend Fog::Provider
-    
-    service(:compute, 'xenserver/compute', 'Compute')  
-    
-    class Connection
-      require 'xmlrpc/client'
-    
-      def initialize(host, timeout)
-        @factory = XMLRPC::Client.new(host, '/')
-        @factory.set_parser(NokogiriStreamParser.new)
-        @factory.timeout = timeout
-      end
-    
-      def authenticate( username, password )
-        response = @factory.call('session.login_with_password', username.to_s, password.to_s)
-        raise Fog::XenServer::InvalidLogin.new unless response["Status"] =~ /Success/
-        @credentials = response["Value"]
-      end
-    
-      def request(options, *params)
-        begin
-          parser   = options.delete(:parser)
-          method   = options.delete(:method)
-          
-          if params.empty?
-            response = @factory.call(method, @credentials)
-          else
-            if params.length.eql?(1) and params.first.is_a?(Hash)
-              response = @factory.call(method, @credentials, params.first)
-            elsif params.length.eql?(2) and params.last.is_a?(Array)
-              response = @factory.call(method, @credentials, params.first, params.last)
-            else
-              response = eval("@factory.call('#{method}', '#{@credentials}', #{params.map {|p|  p.is_a?(String) ? "'#{p}'" : p}.join(',')})")
-            end
-          end
-          raise RequestFailed.new("#{method}: " + response["ErrorDescription"].to_s) unless response["Status"].eql? "Success"
-          if parser
-            parser.parse( response["Value"] )
-            response = parser.response
-          end
-          
-          response
-        end
-      end
-    end
-
-    class NokogiriStreamParser < XMLRPC::XMLParser::AbstractStreamParser
-      
-      def initialize
-        require 'nokogiri/xml/sax/document'
-        require 'nokogiri/xml/sax/parser'
-
-        @parser_class = Class.new(Nokogiri::XML::SAX::Document) do
-          
-          include XMLRPC::XMLParser::StreamParserMixin
-
-          alias_method :start_element, :startElement
-          alias_method :end_element,   :endElement
-          alias_method :characters,    :character
-          alias_method :cdata_block,   :character
-
-          def parse(str)
-            Nokogiri::XML::SAX::Parser.new(self).parse(str)
-          end
-          
-        end
-      end
-      
-    end
-
-  end
-end
-
-
+require 'fog/xenserver/compute'

data/lib/fog/xenserver/compute.rb

@@ -1,4 +1,4 @@
-require 'fog/xenserver'
+require 'fog/xenserver/core'
 require 'fog/compute'
 
 module Fog

data/lib/fog/xenserver/core.rb

@@ -0,0 +1,83 @@
+require 'fog/core'
+
+module Fog
+  module XenServer 
+
+    class InvalidLogin < Fog::Errors::Error; end
+    class NotFound < Fog::Errors::Error; end
+    class RequestFailed < Fog::Errors::Error; end
+
+    extend Fog::Provider
+    
+    service(:compute, 'Compute')  
+    
+    class Connection
+      require 'xmlrpc/client'
+    
+      def initialize(host, timeout)
+        @factory = XMLRPC::Client.new(host, '/')
+        @factory.set_parser(NokogiriStreamParser.new)
+        @factory.timeout = timeout
+      end
+    
+      def authenticate( username, password )
+        response = @factory.call('session.login_with_password', username.to_s, password.to_s)
+        raise Fog::XenServer::InvalidLogin.new unless response["Status"] =~ /Success/
+        @credentials = response["Value"]
+      end
+    
+      def request(options, *params)
+        begin
+          parser   = options.delete(:parser)
+          method   = options.delete(:method)
+          
+          if params.empty?
+            response = @factory.call(method, @credentials)
+          else
+            if params.length.eql?(1) and params.first.is_a?(Hash)
+              response = @factory.call(method, @credentials, params.first)
+            elsif params.length.eql?(2) and params.last.is_a?(Array)
+              response = @factory.call(method, @credentials, params.first, params.last)
+            else
+              response = eval("@factory.call('#{method}', '#{@credentials}', #{params.map {|p|  p.is_a?(String) ? "'#{p}'" : p}.join(',')})")
+            end
+          end
+          raise RequestFailed.new("#{method}: " + response["ErrorDescription"].to_s) unless response["Status"].eql? "Success"
+          if parser
+            parser.parse( response["Value"] )
+            response = parser.response
+          end
+          
+          response
+        end
+      end
+    end
+
+    class NokogiriStreamParser < XMLRPC::XMLParser::AbstractStreamParser
+      
+      def initialize
+        require 'nokogiri/xml/sax/document'
+        require 'nokogiri/xml/sax/parser'
+
+        @parser_class = Class.new(Nokogiri::XML::SAX::Document) do
+          
+          include XMLRPC::XMLParser::StreamParserMixin
+
+          alias_method :start_element, :startElement
+          alias_method :end_element,   :endElement
+          alias_method :characters,    :character
+          alias_method :cdata_block,   :character
+
+          def parse(str)
+            Nokogiri::XML::SAX::Parser.new(self).parse(str)
+          end
+          
+        end
+      end
+      
+    end
+
+  end
+end
+
+