chef-provisioning-opennebula 0.3.4 → 0.4.3

data/lib/chef/provider/one_user.rb

@@ -36,7 +36,7 @@ class Chef
 
       def exists?(filter)
         new_driver = driver
-        @current_user = new_driver.one.get_resource('user', filter)
+        @current_user = new_driver.one.get_resource(:user, filter)
         Chef::Log.debug("user '#{filter}' exists: #{!@current_user.nil?}")
         !@current_user.nil?
       end

data/lib/chef/provider/one_vnet.rb

@@ -36,7 +36,7 @@ class Chef
 
       def exists?(filter)
         new_driver = driver
-        @current_vnet = new_driver.one.get_resource('vnet', filter)
+        @current_vnet = new_driver.one.get_resource(:virtualnetwork, filter)
         Chef::Log.debug("VNET '#{filter}' exists: #{!@current_vnet.nil?}")
         !@current_vnet.nil?
       end
@@ -53,6 +53,7 @@ class Chef
             vnet = new_driver.one.allocate_vnet(template_str, @new_resource.cluster_id)
             Chef::Log.debug(template_str)
             fail "failed to create vnet '#{@new_resource.name}': #{vnet.message}" if OpenNebula.is_error?(vnet)
+            new_driver.one.chmod_resource(vnet, new_resource.mode)
             @new_resource.updated_by_last_action(true)
           end
         end

data/lib/chef/provider/one_vnet_lease.rb

@@ -37,7 +37,7 @@ class Chef
       def exists?
         new_driver = driver
         filter = { @new_resource.vnet.is_a?(Integer) ? :id : :name => @new_resource.vnet }
-        @current_vnet = new_driver.one.get_resource('vnet', filter)
+        @current_vnet = new_driver.one.get_resource(:virtualnetwork, filter)
         fail "vnet '#{@new_resource.vnet}' does not exist" if @current_vnet.nil?
         @current_vnet.info!
         hash = @current_vnet.to_hash
@@ -49,22 +49,7 @@ class Chef
           ar_pool = get_ar_pool(ar_pool, @new_resource.ar_id.to_s)
           fail "ar_id not found '#{@new_resource.ar_id}'" if ar_pool.nil?
         end
-        available = lease_available?(ar_pool, lookup)
-        fail "'#{name}' is already allocated to a VM (ID: #{vm})" unless available
-        available
-        # ar_pool.each do |a|
-        #   if a['AR']['LEASES']['LEASE']
-        #     [a['AR']['LEASES']['LEASE']].flatten.each do |l|
-        #       if l[lookup] && l[lookup] == @new_resource.name
-        #         exists = true
-        #         vm = l['VM'].to_i
-        #         break
-        #       end
-        #     end
-        #   end
-        # end
-        # fail "'#{name}' is already allocated to a VM (ID: #{vm})" if exists && vm > -1
-        # (exists && vm == -1)
+        lease_available?(ar_pool, lookup)
       end
 
       action :hold do

data/lib/chef/provisioning/opennebula_driver/credentials.rb

@@ -69,8 +69,12 @@ class Chef
           begin
             content_hash = JSON.parse(File.read(file), :symbolize_names => true)
             content_hash.each { |k, v| json[k.to_s] = v }
-          rescue Exception => e
-            Chef::Log.warn("Failed to read and parse config file #{file}: #{e.message}")
+          rescue StandardError => e_file
+            Chef::Log.warn("Failed to read config file #{file}: #{e_file.message}")
+          rescue JSON::ParserError => e_json
+            Chef::Log.warn("Failed to parse config file #{file}: #{e_json.message}")
+          rescue
+            Chef::Log.warn("Failed to read or parse config file #{file}: #{$!}")
           end
           @credentials.merge!(json)
         end

data/lib/chef/provisioning/opennebula_driver/driver.rb

@@ -21,6 +21,7 @@ require 'chef/provisioning/transport/ssh'
 require 'chef/provisioning/opennebula_driver/version'
 require 'chef/provisioning/opennebula_driver/one_lib'
 require 'chef/provisioning/opennebula_driver/credentials'
+require 'net/ssh/proxy/command'
 
 class Chef
   module Provisioning
@@ -84,14 +85,7 @@ class Chef
         #
         def initialize(driver_url, config)
           super
-          scan = driver_url.match(%r/(opennebula):(https?:\/\/[^:\/]+ (?::[0-9]{2,5})? (?:\/[^:\s]+) ) :?([^:\s]+)?/x)
-          endpoint = scan[2]
-          profile_name = scan[3]
-          fail "OpenNebula endpoint must be specified in 'driver_url': #{driver_url}" if endpoint.nil?
-
-          profile = profile_name ? one_credentials[profile_name] : one_credentials.default
-          Chef::Log.warn("':credentials' and ':secret_file' will be deprecated in next version in favour of 'opennebula:<endpoint>:<profile_name>'") if profile_name.nil?
-          @one = OneLib.new(profile[:credentials], endpoint, profile[:options] || {})
+          @one = OneLib.new(:driver_url => driver_url)
         end
 
         def self.from_url(driver_url, config)
@@ -127,27 +121,34 @@ class Chef
         #   saved back after allocate_machine completes.
         #
         def allocate_machine(action_handler, machine_spec, machine_options)
-          fqdn = begin
-            machine_options.bootstrap_options[:enforce_chef_fqdn]
-          rescue NoMethodError
-            false
-          end
-          fail "Machine 'name' must be a FQDN" if fqdn && machine_spec.name.scan(/([a-z0-9-]+\.)/i).length == 0
           instance = instance_for(machine_spec)
+          return machine_spec unless instance.nil?
 
-          if instance.nil?
-            fail "'bootstrap_options' must be specified" unless machine_options.bootstrap_options
-            check_unique_names(machine_options.bootstrap_options, machine_spec)
-            action_handler.perform_action "created vm '#{machine_spec.name}'" do
-              Chef::Log.debug(machine_options)
-              tpl = @one.get_template(machine_spec.name, machine_options.bootstrap_options)
-              vm = @one.allocate_vm(tpl)
-              populate_node_object(machine_spec, machine_options, vm)
+          unless machine_options.bootstrap_options
+            fail "'bootstrap_options' must be specified"
+          end
+          check_unique_names(machine_options, machine_spec)
+          action_handler.perform_action "created vm '#{machine_spec.name}'" do
+            Chef::Log.debug(machine_options)
+            tpl = @one.get_template(machine_spec.name,
+                                    machine_options.bootstrap_options)
+            vm = @one.allocate_vm(tpl)
+            populate_node_object(machine_spec, machine_options, vm)
+            @one.chmod_resource(vm, machine_options.bootstrap_options[:mode])
+
+            # This option allows to manipulate how the machine shows up
+            # in the OpenNebula UI and CLI tools.  We either set the VM
+            # name to the short hostname of the machine, rename it
+            # to the String passed to us, or leave it alone.
+            if machine_options[:vm_name] == :short
+              @one.rename_vm(vm, machine_spec.name.split('.').first)
+            elsif machine_options[:vm_name].is_a?(String)
+              @one.rename_vm(vm, machine_options[:vm_name])
+              # else use machine_spec.name for name in OpenNebula
             end
-            Chef::Log.debug(machine_spec.reference)
-          else
-            Chef::Log.info("vm '#{machine_spec.name}' already exists - nothing to do")
           end
+          Chef::Log.debug(machine_spec.reference)
+
           machine_spec
         end
 
@@ -178,8 +179,9 @@ class Chef
             deployed = @one.wait_for_vm(instance.id)
             machine_spec.reference['name'] = deployed.name
             machine_spec.reference['state'] = deployed.state_str
-            nic_hash = deployed.to_hash
-            ip = [nic_hash['VM']['TEMPLATE']['NIC']].flatten[0]['IP']
+            if deployed.to_hash['VM']['TEMPLATE']['NIC']
+              ip = [deployed.to_hash['VM']['TEMPLATE']['NIC']].flatten.first['IP']
+            end
             fail "Could not get IP from VM '#{deployed.name}'" if ip.nil? || ip.to_s.empty?
             machine_spec.reference['ip'] = ip
             machine = machine_for(machine_spec, machine_options)
@@ -241,8 +243,8 @@ class Chef
           instance = instance_for(machine_spec)
           if !instance.nil?
             action_handler.perform_action "powered off machine #{machine_spec.name} (#{machine_spec.reference['instance_id']})" do
-              if machine_spec.reference[:is_shutdown] || machine_options.bootstrap_options[:is_shutdown]
-                hard = machine_spec.reference[:shutdown_hard] || machine_options.bootstrap_options[:shutdown_hard] || false
+              if machine_spec.reference[:is_shutdown] || (machine_options[:bootstrap_options] && machine_options[:bootstrap_options][:is_shutdown])
+                hard = machine_spec.reference[:shutdown_hard] || machine_options[:bootstrap_options][:shutdown_hard] || false
                 instance.shutdown(hard)
               else
                 instance.stop
@@ -264,19 +266,19 @@ class Chef
         def allocate_image(action_handler, image_spec, image_options, machine_spec)
           if image_spec.reference
             # check if image already exists
-            image = @one.get_resource('img', :id => image_spec.reference['image_id'].to_i)
+            image = @one.get_resource(:image, :id => image_spec.reference['image_id'].to_i)
             action_handler.report_progress "image #{image_spec.name} (ID: #{image_spec.reference['image_id']}) already exists" unless image.nil?
           else
             action_handler.perform_action "create image #{image_spec.name} from machine ID #{machine_spec.reference['instance_id']} with options #{image_options.inspect}" do
-              vm = @one.get_resource('vm', :id => machine_spec.reference['instance_id'])
+              vm = @one.get_resource(:virtualmachine, :id => machine_spec.reference['instance_id'])
               fail "allocate_image: VM does not exist" if vm.nil?
               # set default disk ID
               disk_id = 1
               if image_options.disk_id
                 disk_id = image_options.disk_id.is_a?(Integer) ? image_options.disk_id : @one.get_disk_id(vm, new_resource.disk_id)
               end
+              new_img = @one.version_ge_4_14 ? vm.disk_saveas(disk_id, image_spec.name) : vm.disk_snapshot(disk_id, image_spec.name, "", true)
 
-              new_img = vm.disk_snapshot(disk_id, image_spec.name, "", true)
               fail "Failed to create snapshot '#{new_resource.name}': #{new_img.message}" if OpenNebula.is_error?(new_img)
               populate_img_object(image_spec, new_image)
             end
@@ -292,7 +294,7 @@ class Chef
         # @param [Hash] image_options
         #     A set of options representing the desired state of the machine
         def ready_image(action_handler, image_spec, _image_options)
-          img = @one.get_resource('img', :id => image_spec.reference['image_id'].to_i)
+          img = @one.get_resource(:image, :id => image_spec.reference['image_id'].to_i)
           fail "Image #{image_spec.name} (#{image_spec.reference['image_id']}) does not exist" if img.nil?
           action_handler.perform_action "image #{image_spec.name} is ready" do
             deployed = @one.wait_for_img(img.name, img.id)
@@ -310,7 +312,7 @@ class Chef
         # @param [Hash] image_options
         #     A set of options representing the desired state of the machine
         def destroy_image(action_handler, image_spec, _image_options)
-          img = @one.get_resource('img', :id => image_spec.location['image_id'].to_i)
+          img = @one.get_resource(:image, :id => image_spec.location['image_id'].to_i)
           if img.nil?
             action_handler.report_progress "image #{image_spec.name} (#{image_spec.location['image_id']}) does not exist - nothing to do"
           else
@@ -441,8 +443,18 @@ class Chef
                                end
         end
 
-        def check_unique_names(bootstrap_options, machine_spec)
-          fail "VM with name '#{machine_spec.name}' already exists" unless @one.get_resource('vm', :name => machine_spec.name).nil? if bootstrap_options[:unique_names]
+        def check_unique_names(machine_options, machine_spec)
+          return unless machine_options.bootstrap_options[:unique_names]
+          hostname = if machine_options[:vm_name] == :short
+                       machine_spec.name.split('.').first
+                     elsif machine_options[:vm_name].is_a?(String)
+                       machine_options[:vm_name]
+                     else
+                       machine_spec.name
+                     end
+
+          return if @one.get_resource(:virtualmachine, :name => hostname).nil?
+          fail "VM with name '#{hostname}' already exists"
         end
 
         def populate_node_object(machine_spec, machine_options, vm)
@@ -482,11 +494,11 @@ class Chef
           if machine_spec.reference
             fail "Switching a machine's driver from #{machine_spec.driver_url} to #{driver_url} is not supported!" \
                 "  Use machine :destroy and then :create the machine on the new driver." if machine_spec.driver_url != driver_url
-            instance = @one.get_resource('vm', :id => machine_spec.reference['instance_id'].to_i)
+            instance = @one.get_resource(:virtualmachine, :id => machine_spec.reference['instance_id'].to_i)
           elsif machine_spec.location
             fail "Switching a machine's driver from #{machine_spec.driver_url} to #{driver_url} is not supported!" \
                 "  Use machine :destroy and then :create the machine on the new driver." if machine_spec.driver_url != driver_url
-            instance = @one.get_resource('vm', :id => machine_spec.location['server_id'].to_i)
+            instance = @one.get_resource(:virtualmachine, :id => machine_spec.location['server_id'].to_i)
             unless instance.nil?
               # Convert from previous driver
               machine_spec.reference = {
@@ -506,7 +518,9 @@ class Chef
           instance = instance_for(machine_spec)
           fail "#{machine_spec.name} (#{machine_spec.reference['instance_id']}) does not exist!" if instance.nil?
           # TODO: Support Windoze VMs (see chef-provisioning-vagrant)
-          Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport_for(machine_spec, machine_options, instance), convergence_strategy_for(machine_spec, machine_options))
+          Chef::Provisioning::Machine::UnixMachine.new(machine_spec,
+                                                       transport_for(machine_spec, machine_options, instance),
+                                                       convergence_strategy_for(machine_spec, machine_options))
         end
 
         def get_ssh_user(machine_spec, machine_options)
@@ -516,33 +530,37 @@ class Chef
         end
 
         def transport_for(machine_spec, machine_options, _instance)
-          # TODO: Store ssh_options in machine_spec.reference ???
           ssh_options = {
             :keys_only => false,
             :forward_agent => true,
             :use_agent => true,
-            :user_known_hosts_file => '/dev/null'
+            :user_known_hosts_file => '/dev/null',
+            :timeout => 10
           }.merge(machine_options[:ssh_options] || {})
+          ssh_options[:proxy] = Net::SSH::Proxy::Command.new(ssh_options[:proxy]) if ssh_options.key?(:proxy)
+
+          connection_timeout = machine_options[:connection_timeout] || 300
           username = get_ssh_user(machine_spec, machine_options)
-          conf = machine_options[:ssh_config] || config
+
           options = {}
           if machine_spec.reference[:sudo] || (!machine_spec.reference.key?(:sudo) && username != 'root')
             options[:prefix] = 'sudo '
           end
+          options[:ssh_pty_enable] = machine_options[:ssh_pty_enable] || true
+          # User provided ssh_gateway takes precedence over machine_spec value
+          options[:ssh_gateway] = machine_options[:ssh_gateway] || machine_spec.reference['ssh_gateway']
 
-          # Enable pty by default
-          options[:ssh_pty_enable] = true
-          options[:ssh_gateway] = machine_spec.reference['ssh_gateway'] if machine_spec.reference.key?('ssh_gateway')
-
-          transport = Chef::Provisioning::Transport::SSH.new(machine_spec.reference['ip'], username, ssh_options, options, conf)
+          transport = Chef::Provisioning::Transport::SSH.new(machine_spec.reference['ip'], username, ssh_options, options, config)
 
           # wait up to 5 min to establish SSH connection
-          100.times do
+          connect_sleep = 3
+          start = Time.now
+          loop do
             break if transport.available?
-            sleep 3
-            Chef::Log.debug("Waiting for SSH server ...")
+            fail "Failed to establish SSH connection to '#{machine_spec.name}'" if Time.now > start + connection_timeout.to_i
+            Chef::Log.info("Waiting for SSH server ...")
+            sleep connect_sleep
           end
-          fail "Failed to establish SSH connection to '#{machine_spec.name}'" unless transport.available?
           transport
         end
 

data/lib/chef/provisioning/opennebula_driver/one_lib.rb

@@ -33,11 +33,11 @@ end
 #
 class Chef
   #
-  # Module extention.
+  # Module extension.
   #
   module Provisioning
     #
-    # Module extention.
+    # Module extension.
     #
     module OpenNebulaDriver
       #
@@ -50,17 +50,63 @@ class Chef
       # Implementation.
       #
       class OneLib
-        attr_accessor :client
-
-        def initialize(credentials, endpoint, options = {})
+        attr_accessor :client, :version_ge_4_14
+
+        def initialize(args)
+          credentials = args[:credentials]
+          endpoint = args[:endpoint]
+          options = args[:options] || {}
+          if args[:driver_url]
+            scan = args[:driver_url].match(%r/(opennebula):(https?:\/\/[^:\/]+ (?::[0-9]{2,5})? (?:\/[^:\s]+) ) :?([^:\s]+)?/x)
+            endpoint = scan[2]
+            profile = scan[3]
+            fail "'driver_url' option has invalid format: #{args[:driver_url]}" if endpoint.nil? || profile.nil?
+            one_profile = Chef::Provisioning::OpenNebulaDriver::Credentials.new[profile]
+            credentials = one_profile[:credentials]
+            options = one_profile[:options] || {}
+          end
           @client = OpenNebula::Client.new(credentials, endpoint, options)
           rc = @client.get_version
           raise OpenNebulaException, rc.message if OpenNebula.is_error?(rc)
+
+          server_version = rc.split('.').map(&:to_i)
+          gem_version = Gem.loaded_specs["opennebula"].version.to_s.split('.').map(&:to_i)
+          @version_ge_4_14 = gem_version[0] > 4 || (gem_version[0] == 4 && gem_version[1] >= 14)
+
+          version_mismatch_warning(server_version, gem_version) if server_version != gem_version
         end
 
-        # TODO: add filtering to pool retrieval (type, start, end, user)
+        # This function provides a more readable way to return a
+        # OpenNebula::*Pool back to a caller.  The caller simply needs
+        # to pass the pool type in symbol form to us, and we send back
+        # the pool.  The idea is that passing :template will give us
+        # back OpenNebula::TemplatePool, etc. for consistency with
+        # the OpenNebula API calls.  Note that we are still supporting
+        # the old API, while logging a warning that the old format
+        # is deprecated.  Users should expect the old format to disappear
+        # in a future release.
         def get_pool(type)
           fail "pool type must be specified" if type.nil?
+          key = type.capitalize
+          key = :SecurityGroup  if key == :Securitygroup
+          key = :VirtualMachine if key == :Virtualmachine
+          key = :VirtualNetwork if key == :Virtualnetwork
+          if key == :Documentpooljson # Doesn't match the template below
+            return OpenNebula::DocumentPoolJSON.new(@client)
+          end
+
+          pool_class = Object.const_get("OpenNebula::#{key}Pool")
+          pool_class.new(@client)
+        rescue NameError
+          _get_pool(type.to_s) # This will raise an exception if invalid.
+        end
+
+        # TODO: add filtering to pool retrieval (type, start, end, user)
+        def _get_pool(type)
+          Chef::Log.warn("Use of deprecated pool type '#{type}' detected. " \
+                         "Switch to symbol form; i.e. '[:#{type}]' to use the " \
+                         "'OpenNebula::#{type}Pool'.")
+
           case type
           when 'acl'
             OpenNebula::AclPool.new(@client)
@@ -76,11 +122,11 @@ class Chef
             OpenNebula::GroupPool.new(@client)
           when 'host'
             OpenNebula::HostPool.new(@client)
-          when 'img'
+          when 'image', 'img'
             OpenNebula::ImagePool.new(@client, -1)
           when 'secgroup'
             OpenNebula::SecurityGroupPool.new(@client)
-          when 'tpl'
+          when 'tpl', 'vmtemplate', 'template'
             OpenNebula::TemplatePool.new(@client, -1)
           when 'user'
             OpenNebula::UserPool.new(@client)
@@ -91,30 +137,40 @@ class Chef
           when 'vnet'
             OpenNebula::VirtualNetworkPool.new(@client)
           else
-            fail "Invalid pool type specified."
+            fail "Invalid pool type '#{type}' specified."
           end
         end
+        private :_get_pool
 
+        # TODO: Always return an array
         def get_resource(resource_type, filter = {})
+          fail "resource_type must be specified" if resource_type.nil?
+
+          # Ensure the hash key is correct when searching
+          hash_key = resource_type.to_s.upcase
+          hash_key = 'VMTEMPLATE' if hash_key == 'TPL' || hash_key == 'TEMPLATE'
+
           if filter.empty?
             Chef::Log.warn("get_resource: 'name' or 'id' must be provided")
             return nil
           end
           pool = get_pool(resource_type)
 
-          if resource_type != 'user' && filter[:id] && !filter[:id].nil?
+          if resource_type.to_s != 'user' && filter[:id] && !filter[:id].nil?
             pool.info!(-2, filter[:id].to_i, filter[:id].to_i)
             return pool.first
           end
 
-          if resource_type == 'user'
+          if resource_type.to_s == 'user'
             pool.info
           else
-            pool.info!(-2, -1, -1) if resource_type != 'user'
+            pool.info!(-2, -1, -1)
           end
           resources = []
           pool.each do |res|
-            resources << res if res.name == filter[:name]
+            next unless res.name == filter[:name]
+            next if filter[:uname] && res.to_hash[hash_key]['UNAME'] != filter[:uname]
+            resources << res
           end
           return nil if resources.size == 0
           return resources[0] if resources.size == 1
@@ -133,7 +189,7 @@ class Chef
 
         def wait_for_vm(id, end_state = nil)
           end_state ||= 'RUNNING'
-          vm = get_resource('vm', :id => id)
+          vm = get_resource(:virtualmachine, :id => id)
           fail "Did not find VM with ID: #{id}" unless vm
           while vm.lcm_state_str != end_state.upcase
             vm.info
@@ -144,53 +200,63 @@ class Chef
           vm
         end
 
-        def upload_img(name, ds_id, path, driver, description, type, prefix, persistent, pub, target, disk_type, source, size, fstype)
+        def rename_vm(res, name)
+          rc = res.rename(name)
+          raise OpenNebulaException, rc.message if OpenNebula.is_error?(rc)
+        end
+
+        def upload_img(img_config)
           template = <<-EOTPL
-NAME        = #{name}
-PATH        = \"#{path}\"
-DRIVER      = #{driver}
-DESCRIPTION = \"#{description}\"
-EOTPL
-
-          template << "TYPE        = #{type}\n" unless type.nil?
-          template << "PERSISTENT  = YES\n" if !persistent.nil? && persistent
-          template << "DEV_PREFIX  = #{prefix}\n" unless prefix.nil?
-          template << "PUBLIC      = YES\n" if !pub.nil? && pub
-          template << "TARGET      = #{target}\n" unless target.nil?
-          template << "DISK_TYPE   = #{disk_type}\n" unless disk_type.nil?
-          template << "SOURCE      = #{source}\n" unless source.nil?
-          template << "SIZE        = #{size}" unless size.nil?
-          template << "FSTYPE      = #{fstype}\n" unless fstype.nil?
+NAME        = #{img_config[:name]}
+PATH        = \"#{img_config[:path]}\"
+DRIVER      = #{img_config[:driver]}
+DESCRIPTION = \"#{img_config[:description]}\"
+          EOTPL
+
+          template << "TYPE        = #{img_config[:type]}\n" unless img_config[:type].nil?
+          template << "DEV_PREFIX  = #{img_config[:prefix]}\n" unless img_config[:prefix].nil?
+          template << "TARGET      = #{img_config[:target]}\n" unless img_config[:target].nil?
+          template << "DISK_STYPE  = #{img_config[:disk_type]}\n" unless img_config[:disk_type].nil?
+          template << "SOURCE      = #{img_config[:source]}\n" unless img_config[:source].nil?
+          template << "SIZE        = #{img_config[:size]}\n" unless img_config[:size].nil?
+          template << "FSTYPE      = #{img_config[:fs_type]}\n" unless img_config[:fs_type].nil?
+          template << "PUBLIC      = #{img_config[:public] ? 'YES' : 'NO'}\n" unless img_config[:public].nil?
+          template << "PERSISTENT  = #{img_config[:persistent] ? 'YES' : 'NO'}\n" unless img_config[:persistent].nil?
 
           Chef::Log.debug("\n#{template}")
-
           image = OpenNebula::Image.new(OpenNebula::Image.build_xml, @client)
           raise OpenNebulaException, image.message if OpenNebula.is_error?(image)
-          rc = image.allocate(template, ds_id)
+          rc = image.allocate(template, img_config[:datastore_id].to_i)
+          raise OpenNebulaException, rc.message if OpenNebula.is_error?(rc)
+          Chef::Log.debug("Waiting for image '#{img_config[:name]}' (#{image.id}) to be ready")
+          wait_for_img(img_config[:name], image.id)
+          chmod_resource(image, img_config[:mode])
+        end
+
+        def chmod_resource(res = nil, octet = nil)
+          rc = res.chmod_octet(octet) unless res.nil? || octet.nil?
           raise OpenNebulaException, rc.message if OpenNebula.is_error?(rc)
-          Chef::Log.debug("Waiting for image '#{name}' (#{image.id}) to be ready")
-          wait_for_img(name, image.id)
         end
 
-        def allocate_img(name, size, ds_id, type, fstype, driver, prefix, persistent)
+        def allocate_img(img_config)
           template = <<-EOT
-NAME       = #{name}
-TYPE       = #{type}
-FSTYPE     = #{fstype}
-SIZE       = #{size}
-PERSISTENT = #{persistent ? 'YES' : 'NO'}
+NAME       = #{img_config[:name]}
+TYPE       = #{img_config[:type]}
+FSTYPE     = #{img_config[:fstype]}
+SIZE       = #{img_config[:size]}
+PERSISTENT = #{img_config[:persistent] ? 'YES' : 'NO'}
 
-DRIVER     = #{driver}
-DEV_PREFIX = #{prefix}
-EOT
+DRIVER     = #{img_config[:driver]}
+DEV_PREFIX = #{img_config[:prefix]}
+          EOT
 
           img = OpenNebula::Image.new(OpenNebula::Image.build_xml, @client)
           raise OpenNebulaException, img.message if OpenNebula.is_error?(img)
 
-          rc = img.allocate(template, ds_id)
+          rc = img.allocate(template, img_config[:datastore_id])
           raise OpenNebulaException, rc.message if OpenNebula.is_error?(rc)
 
-          Chef::Log.debug("Allocated disk image #{name} (#{img.id})")
+          Chef::Log.debug("Allocated disk image #{img_config[:name]} (#{img.id})")
           img
         end
 
@@ -198,7 +264,7 @@ EOT
           cur_state = nil
           image = nil
           state = 'INIT'
-          pool = get_pool('img')
+          pool = get_pool(:image)
           while state == 'INIT' || state == 'LOCKED'
             pool.info!(-2, img_id, img_id)
             pool.each do |img|
@@ -230,6 +296,13 @@ EOT
           vnet
         end
 
+        def update_template(template_id, template_str)
+          template = OpenNebula::Template.new(OpenNebula::Template.build_xml(template_id), @client)
+          rc = template.update(template_str) unless OpenNebula.is_error?(template)
+          raise OpenNebulaException, rc.message if OpenNebula.is_error?(rc)
+          rc
+        end
+
         def allocate_template(template_str)
           tpl = OpenNebula::Template.new(OpenNebula::Template.build_xml, @client)
           rc = tpl.allocate(template_str) unless OpenNebula.is_error?(tpl)
@@ -270,24 +343,39 @@ EOT
           elsif !options[:template].nil?
             t_hash = template_from_hash(options)
           else
-            fail "To create a VM you must specify one of ':template', ':template_id', ':template_name', or ':template' options in ':bootstrap_options'"
+            fail "To create a VM you must specify one of ':template', " \
+                 "':template_id', or ':template_name' option " \
+                 "in ':bootstrap_options'"
           end
           fail "Inavlid VM template : #{t_hash}" if t_hash.nil? || t_hash.empty?
           tpl_updates = options[:template_options] || {}
           if options[:user_variables]
-            Chef::Log.warn("':user_variables' will be deprecated in next version in favour of ':template_options'") if options.key?(:user_variables)
+            Chef::Log.warn("':user_variables' will be deprecated in next " \
+                           "version in favour of ':template_options'")
             recursive_merge(tpl_updates, options[:user_variables])
           end
           recursive_merge(t_hash, tpl_updates) unless tpl_updates.empty?
-          t_hash['NAME'] = options[:enforce_chef_fqdn] ? name : name.split('.')[0]
+          if options[:enforce_chef_fqdn]
+            Chef::Log.warn(':enforce_chef_fqdn has been deprecated.  VM name ' \
+                           'will be set to the machine resource name.')
+          end
+          # FQDN is the machine resource name, unless overridden by e.g. cloud-init
+          t_hash['NAME'] = name
+          unless t_hash['CONTEXT']['SSH_PUBLIC_KEY']
+            t_hash['CONTEXT']['SSH_PUBLIC_KEY'] = "$USER[SSH_PUBLIC_KEY]"
+          end
+          unless t_hash['CONTEXT']['USER_DATA']
+            t_hash['CONTEXT']['USER_DATA'] = "#cloud-config\n" \
+                                             "manage_etc_hosts: true\n"
+          end
           tpl = create_template(t_hash)
           Chef::Log.debug(tpl)
           tpl
         end
 
         def template_from_one(options)
-          t = get_resource('tpl', :name => options[:template_name]) if options[:template_name]
-          t = get_resource('tpl', :id => options[:template_id]) if options[:template_id]
+          t = get_resource(:template, :name => options[:template_name]) if options[:template_name]
+          t = get_resource(:template, :id => options[:template_id]) if options[:template_id]
           fail "Template '#{options}' does not exist" if t.nil?
           t.to_hash["VMTEMPLATE"]["TEMPLATE"]
         end
@@ -306,7 +394,6 @@ EOT
         end
 
         def template_from_hash(options)
-          Chef::Log.debug("TEMPLATE_JSON: #{options[:template]}")
           options[:template]
         end
 
@@ -315,6 +402,49 @@ EOT
         # in the 't' Hash.  The hash must have equivalent structure as the
         # VM template.
         #
+        # We considered using OpenNebulaHelper::create_template for this,
+        # however it would require a backwards compatibility shim and/or
+        # making breaking changes to the API.  In particular, our method is
+        # more attractive due to the nested nature of our Hash, versus specifying
+        # a long string for the :context attribute with embedded newlines.
+        # Our strategy provides a way to override specific values, while this is
+        # difficult to accomplish with OpenNebulaHelper::create_template.
+        #
+        # Current template hash:
+        # {
+        #   "NAME" => "baz"
+        #   "CPU" => "1",
+        #   "VCPU" => "1",
+        #   "MEMORY" => "512",
+        #   "OS" => {
+        #     "ARCH" => "x86_64"
+        #   },
+        #   "GRAPHICS" => {
+        #     "LISTEN" => "0.0.0.0",
+        #     "TYPE" => "vnc"
+        #   },
+        #   "CONTEXT" => {
+        #     "FOO" => "BAR",
+        #     "BAZ" => "QUX"
+        #     "HOSTNAME" => "$NAME",
+        #     "SSH_PUBLIC_KEY" => "$USER[SSH_PUBLIC_KEY]",
+        #     "NETWORK" => "YES"
+        #   }
+        # }
+        #
+        # Using OpenNebulaHelper::create_template:
+        # {
+        #   :name => 'baz'
+        #   :cpu => 1,
+        #   :vcpu => 1,
+        #   :memory => 512,
+        #   :arch => 'x86_64',
+        #   :vnc => true,
+        #   :context => "FOO=\"BAR\"\nBAZ=\"QUX\"\nHOSTNAME=\"$NAME\"",
+        #   :ssh => true,
+        #   :net_context => true
+        # }
+        #
         def create_template(t, level = 0)
           tpl = ""
           count = t.size
@@ -340,12 +470,21 @@ EOT
             else
               comma = (index < count) && level > 0
               level.times { tpl << "  " }
-              tpl << "#{k} = \"#{v}\"" << (comma ? ",\n" : "\n")
+              # Escape quotation marks to fix MAND-1394:
+              #    template does not support embedded quotation marks
+              # Escaping of " only happens if " is not already escaped, preceded by \\
+              tpl << "#{k} = \"#{v.gsub(/(?<!\\)\"/, '\"')}\"" << (comma ? ",\n" : "\n")
               index += 1
             end
           end
           tpl
         end
+
+        def version_mismatch_warning(server, gem)
+          Chef::Log.warn('GEM / SERVER VERSION MISMATCH')
+          Chef::Log.warn("Your gem version is #{gem.join('.')} and the server version is #{server.join('.')}")
+          Chef::Log.warn('Users may experience issues with this gem.')
+        end
       end
     end
   end