fog 1.0.0 → 1.5.0

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/vcloud.rb

@@ -1,4 +1,4 @@
-require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+require 'fog/core'
 
 module Fog
   module Vcloud

data/lib/fog/virtual_box/compute.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'virtual_box'))
+require 'fog/virtual_box'
 require 'fog/compute'
 
 module Fog
@@ -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/virtual_box/models/compute/server.rb

@@ -167,8 +167,8 @@ module Fog
         #     %{mkdir .ssh},
         #     %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
         #     %{passwd -l #{username}},
-        #     %{echo "#{MultiJson.encode(attributes)}" >> ~/attributes.json},
-        #     %{echo "#{MultiJson.encode(metadata)}" >> ~/metadata.json}
+        #     %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json},
+        #     %{echo "#{Fog::JSON.encode(metadata)}" >> ~/metadata.json}
         #   ])
         # rescue Errno::ECONNREFUSED
         #   sleep(1)

data/lib/fog/virtual_box.rb

@@ -1,4 +1,4 @@
-require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+require 'fog/core'
 
 module Fog
   module VirtualBox

data/lib/fog/vmfusion/compute.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'vmfusion'))
+require 'fog/vmfusion'
 require 'fog/compute'
 
 module Fog

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/vmfusion.rb

@@ -1,4 +1,4 @@
-require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+require 'fog/core'
 
 module Fog
   module Vmfusion

data/lib/fog/volume.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Volume
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # Prevent delete from having side effects
+      case provider = attributes.delete(:provider).to_s.downcase.to_sym
+      when :openstack
+        require 'fog/openstack/volume'
+        Fog::Volume::OpenStack.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} has no identity service")
+      end
+    end
+
+    def self.providers
+      Fog.services[:volume]
+    end
+
+  end
+end
+

data/lib/fog/voxel/compute.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'voxel'))
+require 'fog/voxel'
 require 'fog/compute'
 
 module Fog
@@ -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/voxel.rb

@@ -1,4 +1,4 @@
-require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+require 'fog/core'
 require 'digest/md5'
 
 module Fog

data/lib/fog/vsphere/compute.rb

@@ -20,7 +20,14 @@ 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
+      request :vm_config_vnc
 
       module Shared
 
@@ -29,36 +36,54 @@ module Fog
         attr_reader :vsphere_server
         attr_reader :vsphere_username
 
+        ATTR_TO_PROP = {
+          :id => 'config.instanceUuid',
+          :name => 'name',
+          :uuid => 'config.uuid',
+          :instance_uuid => 'config.instanceUuid',
+          :hostname => 'summary.guest.hostName',
+          :operatingsystem => 'summary.guest.guestFullName',
+          :ipaddress => 'guest.ipAddress',
+          :power_state => 'runtime.powerState',
+          :connection_state => 'runtime.connectionState',
+          :hypervisor => 'runtime.host',
+          :tools_state => 'guest.toolsStatus',
+          :tools_version => 'guest.toolsVersionStatus',
+          :is_a_template => 'config.template',
+          :memory_mb => 'config.hardware.memoryMB',
+          :cpus   => 'config.hardware.numCPU',
+        }
+
         # Utility method to convert a VMware managed object into an attribute hash.
         # This should only really be necessary for the real class.
         # This method is expected to be called by the request methods
         # in order to massage VMware Managed Object References into Attribute Hashes.
         def convert_vm_mob_ref_to_attr_hash(vm_mob_ref)
           return nil unless vm_mob_ref
-          # A cloning VM doesn't have a configuration yet.  Unfortuantely we just get
-          # a RunTime exception.
-          begin
-            is_ready = vm_mob_ref.config ? true : false
-          rescue RuntimeError
-            is_ready = nil
+
+          props = vm_mob_ref.collect!(*ATTR_TO_PROP.values.uniq)
+          # NOTE: Object.tap is in 1.8.7 and later.
+          # Here we create the hash object that this method returns, but first we need
+          # to add a few more attributes that require additional calls to the vSphere
+          # API. The hypervisor name and mac_addresses attributes may not be available
+          # so we need catch any exceptions thrown during lookup and set them to nil.
+          #
+          # The use of the "tap" method here is a convenience, it allows us to update the
+          # hash object without explicitly returning the hash at the end of the method.
+          Hash[ATTR_TO_PROP.map { |k,v| [k.to_s, props[v]] }].tap do |attrs|
+            attrs['id'] ||= vm_mob_ref._ref
+            attrs['mo_ref'] = vm_mob_ref._ref
+            # The name method "magically" appears after a VM is ready and
+            # finished cloning.
+            if attrs['hypervisor'].kind_of?(RbVmomi::VIM::HostSystem) then
+              # If it's not ready, set the hypervisor to nil
+              attrs['hypervisor'] = attrs['hypervisor'].name rescue nil
+            end
+            # This inline rescue catches any standard error.  While a VM is
+            # cloning, a call to the macs method will throw and NoMethodError
+            attrs['mac_addresses'] = vm_mob_ref.macs rescue nil
+            attrs['path'] = get_folder_path(vm_mob_ref.parent)
           end
-          {
-            'id'               => is_ready ? vm_mob_ref.config.instanceUuid : vm_mob_ref._ref,
-            'mo_ref'           => vm_mob_ref._ref,
-            'name'             => vm_mob_ref.name,
-            'uuid'             => is_ready ? vm_mob_ref.config.uuid : nil,
-            'instance_uuid'    => is_ready ? vm_mob_ref.config.instanceUuid : nil,
-            'hostname'         => vm_mob_ref.summary.guest.hostName,
-            'operatingsystem'  => vm_mob_ref.summary.guest.guestFullName,
-            'ipaddress'        => vm_mob_ref.summary.guest.ipAddress,
-            'power_state'      => vm_mob_ref.runtime.powerState,
-            'connection_state' => vm_mob_ref.runtime.connectionState,
-            'hypervisor'       => vm_mob_ref.runtime.host ? vm_mob_ref.runtime.host.name : nil,
-            'tools_state'      => vm_mob_ref.summary.guest.toolsStatus,
-            'tools_version'    => vm_mob_ref.summary.guest.toolsVersionStatus,
-            'mac_addresses'    => is_ready ? vm_mob_ref.macs : nil,
-            'is_a_template'    => is_ready ? vm_mob_ref.config.template : nil
-          }
         end
 
       end
@@ -68,6 +93,7 @@ module Fog
         include Shared
 
         def initialize(options={})
+          require 'rbvmomi'
           @vsphere_username = options[:vsphere_username]
           @vsphere_password = 'REDACTED'
           @vsphere_server   = options[:vsphere_server]

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

@@ -33,6 +33,24 @@ module Fog
         attribute :is_a_template
         attribute :connection_state
         attribute :mo_ref
+        attribute :path
+        attribute :memory_mb
+        attribute :cpus
+
+        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
@@ -40,7 +58,7 @@ module Fog
         end
 
         def stop(options = {})
-          options = { :force => false }.merge(options)
+          options = { :force => !tools_installed? }.merge(options)
           requires :instance_uuid
           connection.vm_power_off('instance_uuid' => instance_uuid, 'force' => options[:force])
         end
@@ -53,9 +71,66 @@ module Fog
 
         def destroy(options = {})
           requires :instance_uuid
+          stop if ready? # need to turn it off before destroying
           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
+
+        def ready?
+          power_state == "poweredOn"
+        end
+
+        def tools_installed?
+          tools_state != "toolsNotInstalled"
+        end
+
+        # defines VNC attributes on the hypervisor
+        def config_vnc(options = {})
+          requires :instance_uuid
+          connection.vm_config_vnc(options.merge('instance_uuid' => instance_uuid))
+        end
+
+        # returns a hash of VNC attributes required for connection
+        def vnc
+          requires :instance_uuid
+          connection.vm_get_vnc(instance_uuid)
+        end
+
+        def memory
+          memory_mb * 1024 * 1024
+        end
+
       end
 
     end