fog 1.1.0 → 1.2.0

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

@@ -5,7 +5,7 @@ module Fog
 
         def validate_clone_vapp_options(options)
           valid_opts = [:name, :poweron]
-          unless valid_opts.all? { |opt| options.keys.include?(opt) }
+          unless valid_opts.all? { |opt| options.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
           end
         end

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

@@ -5,7 +5,7 @@ module Fog
 
         def validate_network_data(network_data, configure=false)
           valid_opts = [:id, :href, :name, :address, :broadcast, :gateway]
-          unless valid_opts.all? { |opt| network_data.keys.include?(opt) }
+          unless valid_opts.all? { |opt| network_data.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(valid_opts - network_data.keys).map(&:inspect).join(", ")}")
           end
         end

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

@@ -6,7 +6,7 @@ module Fog
 
         def validate_network_ip_data(network_ip_data)
           valid_opts = [:id, :href, :name, :status, :server]
-          unless valid_opts.all? { |opt| network_ip_data.keys.include?(opt) }
+          unless valid_opts.all? { |opt| network_ip_data.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(valid_opts - network_ip_data.keys).map(&:inspect).join(", ")}")
           end
         end

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

@@ -6,7 +6,7 @@ module Fog
 
         def validate_vapp_data(vapp_data)
           valid_opts = [:name, :cpus, :memory, :disks]
-          unless valid_opts.all? { |opt| vapp_data.keys.include?(opt) }
+          unless valid_opts.all? { |opt| vapp_data.has_key?(opt) }
             raise ArgumentError.new("Required Vapp data missing: #{(valid_opts - vapp_data.keys).map(&:inspect).join(", ")}")
           end
         end

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

@@ -138,7 +138,7 @@ module Fog
 
         def validate_vm_data(vm_data)
           valid_opts = [:name, :cpus, :memory, :disks]
-          unless valid_opts.all? { |opt| vm_data.keys.include?(opt) }
+          unless valid_opts.all? { |opt| vm_data.has_key?(opt) }
             raise ArgumentError.new("Required vm data missing: #{(valid_opts - vm_data.keys).map(&:inspect).join(", ")}")
           end
         end

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

@@ -0,0 +1,10 @@
+module Fog
+  module Vcloud
+    class Compute
+
+      class Real
+        basic_request :get_server
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module Fog
         def validate_instantiate_vapp_template_options options
           # :network_uri removed, if not specified will use template network config.
           valid_opts = [:catalog_item_uri, :name, :vdc_uri]
-          unless valid_opts.all? { |opt| options.keys.include?(opt) }
+          unless valid_opts.all? { |opt| options.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
           end
           

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

@@ -6,14 +6,18 @@ module Fog
 
 
         def login
+          headers = { 'Authorization' => authorization_header }
+          uri = if version == '1.0'
+            "#{base_url}/login"
+          else
+            "#{base_path_url}/sessions"
+          end
           unauthenticated_request({
             :expects  => 200,
-            :headers  => {
-              'Authorization' => authorization_header
-            },
+            :headers  => headers,
             :method   => 'POST',
             :parse    => true,
-            :uri      => "#{base_url}/login"
+            :uri      => uri
           })
         end
 

data/lib/fog/virtual_box/compute.rb

@@ -34,6 +34,10 @@ module Fog
           @connection = ::VirtualBox::Global.global.lib.virtualbox
         end
 
+        def respond_to?(method, *)
+          super or @connection.respond_to? method
+        end
+
         # hack to provide 'requests'
         def method_missing(method_sym, *arguments, &block)
           if @connection.respond_to?(method_sym)

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

@@ -8,150 +8,209 @@ module Fog
 
         identity :name
 
-        attribute :name
-        attribute :state
+        attribute :ipaddress
+        attribute :power_state
+        attribute :mac_addresses
+        attribute :path
 
         attr_accessor :password
         attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
 
-        def initalize(attributes={})
-        end
-
+        # There is currently no documented model of creating VMs from scratch
+        # sans Fusion's wizard.
         def save
           raise Fog::Errors::Error.new('Creating a new vm is not yet supported')
         end
 
+        # Fussion doesn't have the concept of templates so one just clones
+        # regular VMs.
         def clone(name)
           requires :raw
 
-          ::Fission::VM.clone(@raw.name,name)
+          ::Fission::VM.clone(@raw[:fission].name,name)
           return connection.servers.get(name)
         end
 
-        def destroy(options={ :force => false})
+        # Destroy, deletes the VM from the local disk but only hard stops the VM
+        # before doing so if you set :force to true.
+        def destroy(options = { :force => false })
           requires :raw
 
-          if state=="running"
+          if ready?
             if options[:force]
-              @raw.stop
+              stop
             end
           end
 
-          ::Fission::VM.delete @raw.name
+          @raw[:fission].delete
         end
 
-        def start
+        # Start is pretty self explanatory...if you pass :headless as true you
+        # won't get a console on launch.
+        def start(options = { :headless => false })
           requires :raw
 
-          unless state=="running"
-            @raw.start
+          unless ready?
+            @raw[:fission].start(:headless => options[:headless])
             return true
           else
             return false
           end
         end
 
+        # We're covering a lot of bases here with the different ways one can
+        # stop a VM from running.
+
+        # Stop is a hard stop, like pulling out the power cord.
         def stop
           requires :raw
 
-          if state=="running"
-            @raw.stop
+          if ready?
+            @raw[:fission].stop(:hard => true)
             return true
           else
             return false
           end
         end
 
-        def reboot
+        # Halt and poweroff are just synonyms for stop.
+        def halt
+          stop
+        end
+
+        def poweroff
+          stop
+        end
+
+        # This is a graceful shutdown but Fusion is only capable of a graceful
+        # shutdown if tools are installed.  Fusion does the right thing though
+        # and if graceful can't be initiated it just does a hard stop.
+        def shutdown
           requires :raw
-          if state=="running"
-            @raw.stop
-            wait_for { state!="running"}
-            @raw.start
+          if ready?
+            @raw[:fission].stop
             return true
           else
             return false
           end
         end
 
-        def halt
-          requires :raw
-          if state=="running"
-            @raw.halt
+        # Attempt a graceful shutdown, wait for the VM to completely shutdown
+        # and then start it again.
+        def reboot
+          if ready?
+            shutdown
+            wait_for { ! ready? }
+            start
             return true
           else
             return false
           end
+        end
 
+        # Resuming from suspend is the same thing as start to Fusion.
+        def resume
+          start
         end
 
-        def poweroff
+        def suspend
           requires :raw
-          halt
+          if ready?
+            @raw[:fission].suspend
+            return true
+          else
+            return false
+          end
         end
 
-        def shutdown
+        # Fusion VM Metadata.
+
+        # The power state of the VM is commonly going to be three values;
+        # running, not running, or suspended.
+        def power_state
           requires :raw
-          stop
+          @raw[:fission].state.data
         end
 
-        def resume
+        def ready?
           requires :raw
-          @raw.resume
+          @raw[:fission].running?.data
         end
 
-        def suspend
+        # Path to the VM's vmx file on the local disk.
+        def path
           requires :raw
-          @raw.suspend
+          @raw[:fission].path
         end
 
-        def state
+        # We obtain the first ipaddress.  This should generally be a safe
+        # assumption for Fusion.  Even if an address is provided via NAT,
+        # bridge, or host only it will by accessible from the host machine the
+        # VM resides on.
+        def ipaddress
           requires :raw
-          @raw.state
+          ip(@raw[:fission])
         end
 
-        def ready?
-          state == "running"
+        # Keeping these three methods around for API compatibility reasons.
+        # Makes the vmfusion provider function similar to cloud providers and
+        # the vsphere provider.  Future goal is to add an actual private and
+        # public concept.  Needs changes to fission and a determination what is
+        # a public or private address here; bridge, nat, host-only.
+        def public_ip_address
+          ipaddress
         end
 
         def private_ip_address
-          ip_address(:private)
+          ipaddress
         end
 
-        def public_ip_address
-          ip_address(:public)
+        def state
+          power_state
+        end
+
+        # Collecting all mac_addresses the VM has...mostly just because we are
+        # doing the same thing for the vSphere provider.
+        def mac_addresses
+          requires :raw
+          macs(@raw[:fission])
         end
 
+        # Sets up a conveinent way to SSH into a Fusion VM using credentials
+        # stored in your .fog file.
 
         def username
           @username ||= 'root'
         end
 
+        # Simply spawn an SSH session.
         def ssh(commands)
-          requires :public_ip_address, :username
+          requires :ipaddress, :username
 
           #requires :password, :private_key
           ssh_options={}
           ssh_options[:password] = password unless password.nil?
           ssh_options[:key_data] = [private_key] if private_key
 
-          Fog::SSH.new(public_ip_address, @username, ssh_options).run(commands)
+          Fog::SSH.new(ipaddress, @username, ssh_options).run(commands)
 
         end
 
+        # SCP something to our VM.
         def scp(local_path, remote_path, upload_options = {})
-          requires :public_ip_address, :username
+          requires :ipaddress, :username
 
           scp_options = {}
           scp_options[:password] = password unless self.password.nil?
           scp_options[:key_data] = [private_key] if self.private_key
 
-          Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+          Fog::SCP.new(ipaddress, username, scp_options).upload(local_path, remote_path, upload_options)
         end
 
-        # Sets up a new key
+        # 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, :public_ip_address, :username
+          requires :public_key, :ipaddress, :username
 
           credentials[:password] = password unless self.password.nil?
           credentails[:key_data] = [private_key] if self.private_key
@@ -167,7 +226,7 @@ module Fog
           Timeout::timeout(360) do
             begin
               Timeout::timeout(8) do
-                Fog::SSH.new(public_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
+                Fog::SSH.new(ipaddress, username, credentials.merge(:timeout => 4)).run('pwd')
               end
             rescue Errno::ECONNREFUSED
               sleep(2)
@@ -176,9 +235,11 @@ module Fog
               retry
             end
           end
-          Fog::SSH.new(public_ip_address, username, credentials).run(commands)
+          Fog::SSH.new(ipaddress, username, credentials).run(commands)
         end
 
+        # Just setting local versions of some variables that were going to use
+        # for SSH operations.
         def private_key_path
           @private_key_path ||= Fog.credentials[:private_key_path]
           @private_key_path &&= File.expand_path(@private_key_path)
@@ -198,8 +259,13 @@ module Fog
         end
 
         private
-        def ip_address(key)
-          @raw.ip_address
+        def ip(fission)
+          first_int = fission.network_info.data.keys.first
+          fission.network_info.data[first_int]['ip_address']
+        end
+
+        def macs(fission)
+          fission.mac_addresses.data
         end
 
         def raw
@@ -210,13 +276,15 @@ module Fog
           @raw = new_raw
 
           raw_attributes = {
-            :name => new_raw.name,
-            :state => new_raw.state
+            :name            => new_raw[:fission].name,
+            :power_state     => new_raw[:state],
+            :ipaddress       => ip(new_raw[:fission]),
+            :mac_addresses   => macs(new_raw[:fission]),
+            :path            => new_raw[:fission].path
           }
 
           merge_attributes(raw_attributes)
         end
-
       end
     end
   end

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

@@ -9,18 +9,22 @@ module Fog
 
         model Fog::Compute::Vmfusion::Server
 
-        def all(filter=nil)
+        def all(filter = nil)
 
-          data=[]
+          data = []
 
-          filter={} if filter.nil?
+          states = ::Fission::VM.all_with_status.data
+
+          filter = {} if filter.nil?
           unless filter.has_key?(:name)
-            vms=::Fission::VM.all
+            vms=::Fission::VM.all.data
             vms.each do |vm|
-              data << { :raw => vm}
+              data << { :raw =>  { :fission => vm,
+                                   :state   => states[vm.name] } }
             end
           else
-            data << { :raw => ::Fission::VM.new(filter[:name])}
+            data << { :raw => { :fission => ::Fission::VM.new(filter[:name]),
+                                :state   => states[filter[:name]] } }
           end
 
           load(data)
@@ -28,7 +32,7 @@ module Fog
         end
 
         def get(name)
-          self.all(:name =>name).first
+          self.all(:name => name).first
         end
 
       end

data/lib/fog/voxel/compute.rb

@@ -85,7 +85,7 @@ module Fog
           @scheme             = options[:scheme]  || 'https'
           @persistent         = options[:persistent] || false
 
-          Excon.ssl_verify_peer = false
+          @connection_options[:ssl_verify_peer] = false
 
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end

data/lib/fog/vsphere/compute.rb

@@ -20,7 +20,13 @@ module Fog
       request :vm_power_on
       request :vm_reboot
       request :vm_clone
+      request :vm_create
       request :vm_destroy
+      request :vm_migrate
+      request :datacenters
+      request :vm_reconfig_hardware
+      request :vm_reconfig_memory
+      request :vm_reconfig_cpus
 
       module Shared
 

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

@@ -35,6 +35,18 @@ module Fog
         attribute :mo_ref
         attribute :path
 
+        def vm_reconfig_memory(options = {})
+          requires :instance_uuid, :memory
+          connection.vm_reconfig_memory('instance_uuid' => instance_uuid, 'memory' => memory)
+        end
+        def vm_reconfig_cpus(options = {})
+          requires :instance_uuid, :cpus
+          connection.vm_reconfig_cpus('instance_uuid' => instance_uuid, 'cpus' => cpus)
+        end
+        def vm_reconfig_hardware(options = {})
+          requires :instance_uuid, :hardware_spec
+          connection.vm_reconfig_hardware('instance_uuid' => instance_uuid, 'hardware_spec' => hardware_spec)
+        end
         def start(options = {})
           requires :instance_uuid
           connection.vm_power_on('instance_uuid' => instance_uuid)
@@ -57,6 +69,37 @@ module Fog
           connection.vm_destroy('instance_uuid' => instance_uuid)
         end
 
+        def migrate(options = {})
+          options = { :priority => 'defaultPriority' }.merge(options)
+          requires :instance_uuid
+          connection.vm_migrate('instance_uuid' => instance_uuid, 'priority' => options[:priority])
+        end
+
+        def create(options ={})
+          requires :name, :path
+          new_vm = self.class.new(create_results['vm_attributes'])
+          new_vm.collection = self.collection
+          new_vm.connection = self.connection
+          new_vm
+        end
+        def clone(options = {})
+          requires :name, :path
+          # Convert symbols to strings
+          req_options = options.inject({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
+          # Give our path to the request
+          req_options['path'] ="#{path}/#{name}"
+          # Perform the actual clone
+          clone_results = connection.vm_clone(req_options)
+          # Create the new VM model.
+          new_vm = self.class.new(clone_results['vm_attributes'])
+          # We need to assign the collection and the connection otherwise we
+          # cannot reload the model.
+          new_vm.collection = self.collection
+          new_vm.connection = self.connection
+          # Return the new VM model.
+          new_vm
+        end
+
       end
 
     end

data/lib/fog/vsphere/models/compute/servers.rb

@@ -9,8 +9,14 @@ module Fog
 
         model Fog::Compute::Vsphere::Server
 
-        def all
-          response = connection.list_virtual_machines
+        # 'path' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
+        # than simply listing everything.
+        def all(filters = {})
+          # REVISIT: I'm not sure if this is the best way to implement search
+          # filters on a collection but it does work.  I need to study the AWS
+          # code more to make sure this matches up.
+          filters['folder'] ||= attributes['folder']
+          response = connection.list_virtual_machines(filters)
           load(response['virtual_machines'])
         end
 

data/lib/fog/vsphere/requests/compute/datacenters.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def datacenters
+          @datacenters ||= datacenters_reload
+          # Hide the values which are the RbVmomi instances
+          @datacenters.keys
+        end
+
+        private
+
+        def datacenters_reload
+          @rootfolder  ||= @connection.rootFolder
+          inventory = @rootfolder.inventory(:Datacenter => [ 'name' ])[@rootfolder]
+          # Convert the inventory into a Hash of the form: We remove the
+          # property selectors.  { "<dc_name>" => #<RbVmomi::VIM::Datacenter> }
+          # The Datacenter instance itself is at index 0 and the properties we
+          # collected are at index 1.
+          inventory.inject({}) do |memo, (name,dc_ary)|
+            memo[name] = dc_ary[0]
+            memo
+          end
+        end
+      end
+
+      class Mock
+        def datacenters
+          [ "Solutions", "Solutions2", "Solutions3" ]
+        end
+      end
+    end
+  end
+end