chef-provisioning-opennebula 0.3.4 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83946a6cacda760aea3647d4a9d7ca929da411be
-  data.tar.gz: f6c1ae25e0f01c63048bfe38f7721932b4483961
+  metadata.gz: 8609a2bdd368fd8004c7451eec93e7f4801cae99
+  data.tar.gz: bb88358b632d8f75e45ed1d3e6f0719302428499
 SHA512:
-  metadata.gz: a63666bb3a258be1fb452934670697170d7cb4e3bfbae8769a0ac810fb5c855f6dc0dcbabc041d3b0997c93b5df86695714f9dfddd86a8f79de7f70b006b4528
-  data.tar.gz: a1d9bb1a0b235c0659c3f7373d4805bf03a93b3d3c741cf7123534e634ffd2ab5435a507c75d3e216ac9eac8eae052783e44ee83919c5f0b03bb0c438c0fe7d6
+  metadata.gz: 0c6633a838fb95a2d98183088b7e1c64939cf1efd4f5f161937dd74fd46472b4fb4a15ef6127be71ce0a039d3397b3f534b755cfcebbfedb60608fd3327ae31e
+  data.tar.gz: 6932c9456a158bd2b32a805462b25037f54889399e1941779e8a2f17e08f8846195066701d37a55f46280728519506a687e4d0040113868b556527735d754379

data/README.md

@@ -45,27 +45,6 @@ A sample one_config file would look like this:
 }
 ```
 
-If no profile is specified the driver will attempt to read and use the ```ENV['ONE_AUTH']``` file or ```~/.one/one_auth``` or ```/var/lib/one/.one/one_auth```.
-The driver is still backward compatible with previous format and passing ```:secret_file``` or ```:credentials``` in```:driver_options```.
-
-Additional options to OpenNebual client can be passed vi ```:one_options```.
-
-```ruby
-with_driver "opennebula:http://1.2.3.4/endpoint:port",
-  :credentials => "<username>:<text_password>",
-  :one_options => { :timeout => 3 }
-```
-
-or
-
-```ruby
-with_driver "opennebula:http://1.2.3.4/endpoint:port",
-  :secret_file => "<local_path_to_file_with_credentials>",
-  :one_options => { :timeout => 3 }
-```
-
-If additional OpenNebula client options need to be passed they can be specified as a hash ```:one_options => {}```.  
-
 In context of OpenNebula ```machine``` resource will take the following additional options:
 
 ```ruby
@@ -76,12 +55,13 @@ machine_options {
 		:template_name => String name of the OpenNebula template to use
 		:template_id => Integer id of the OpenNebula template to use
 		:template_options => Hash values to be merged with VM template
-		:enforce_chef_fqdn => [TrueClass, FalseClass] flag indicating if fqdn names should be used for machine names
 		:is_shutdown => [TrueClass, FalseClass] call vm.shutodwn instead of vm.stop during :stop action
 		:shutdown_hard => [TrueClass, FalseClass] flag indicating hard or soft shutdown
+    :mode => String octed to set permissions to the machine
 	},
 	:sudo => true,
 	:ssh_username => 'local',
+	:ssh_gateway => 'gary@myproxy.net',
 	:ssh_options => {
 	  Hash containing SSH options as specified by net-ssh gem
 	  please see https://github.com/net-ssh/net-ssh for all options
@@ -91,9 +71,16 @@ machine_options {
 	  :keys => [ File.open(File.expand_path('~/.ssh/id_rsa_new')).read ]
 	  :keys_only => false,
 	  :forward_agent => true,
+	  :proxy => 'ssh myproxy.net nc %h %p',
 	  :use_agent => true,
 	  :user_known_hosts_file => '/dev/null'
 	}
+  :vm_name => [Symbol, String] Change how the machine shows up in OpenNebula UI and CLI tools.
+			       Use :short to rename the machine to the short hostname.
+			       Use a string to rename the machine to an arbitrary name.
+			       Note this does not change the hostname of the machine, it
+			       simply renames the VM in OpenNebula.
+  :connection_timeout => [Integer] max wait time to establish connection
 }
 ```
 
@@ -109,6 +96,7 @@ This resource will allow to create and delete OpenNebula templates.
 ```ruby
   :template => Hash defining OpenNebula template
   :template_file => String location of the VM template file
+  :mode => String octet to set permissions
 ```
 
 ### Actions
@@ -201,6 +189,8 @@ This resource will manage images within OpenNebula.
   :driver => String Image driver eq. 'qcow2'
   :machine_id => [String, Integer] id of the machine (VM) for disk attach
   :disk_id => [String, Integer] id or name of the disk to attach/snapshot
+  :mode => String octet to set permissions
+  :http_port => Integer port number to start local HTTP server at, for :image_file uploads. Default: 8066
 ```
 
 ### Actions
@@ -272,20 +262,31 @@ one_image "snapshot-img" do
 end
 ```
 
-#### 6. Upload a local qcow2 image file to OpenNebula
+#### 6. Upload a local qcow2 image file to OpenNebula, starting HTTP server on port 4567
 
 ```ruby
-one_image "snapshot-img" do
+one_image "upload-img" do
   datastore_id 103
   image_file "/local/path/to/qcow/image/file"
   img_driver "qcow2"
   type "OS"
+  http_port 4567
   description "This is my cool qcow image"
   action :upload
 end
 ```
 
-#### 7. Download a 'boggi-test-img' and store it in /home/local/my-image.qcow2.  Download URL read from ENV[ONE_DOWNLOAD] variable. It will be stored locally in Chef::Config[:file_cache_path]/boggi-test-img.qcow2.
+#### 7. Upload a qcow2 image file residing on a different host to OpenNebula
+
+```ruby
+one_image "upload-img" do
+  datastore_id 103
+  download_url "http://my.image.host/path/to/qcow/image/file"
+  action :upload
+end
+```
+
+#### 8. Download a 'boggi-test-img' and store it in /home/local/my-image.qcow2.  Download URL is read from ENV[ONE_DOWNLOAD] variable. It will be stored locally in Chef::Config[:file_cache_path]/boggi-test-img.qcow2.
 
 ```ruby
 one_image "boggi-test-img" do
@@ -293,7 +294,7 @@ one_image "boggi-test-img" do
 end
 ```
 
-#### 8. Download image ID 12345 and store it in /tmp/image.qcow2.
+#### 9. Download image ID 12345 and store it in /tmp/image.qcow2.
 
 ```ruby
 one_image "boggi-test-img" do
@@ -319,6 +320,7 @@ This resource will allow to create and delete OpenNebula vnets.
   :mac_ip => String ip or mac address
   :template_file => String local file containing the template of a new vnet
   :cluster_id => Integer cluster in which to create a vnet
+  :mode => String octet to set permissions
 ```
 
 ### Actions
@@ -507,24 +509,21 @@ example:
 
 ## <a name="authors"></a> Authors
 
-Created by [Bogdan Buczynski][author] (<bbuczynski@blackberry.com>)
+Created by [Bogdan Buczynski](https://github.com/bbuczynski) (<pikus1@gmail.com>)
 
 ## <a name="maintainers"></a> Maintainers
 
 Maintained by
-  * [Bogdan Buczynski][author] (<bbuczynski@blackberry.com>)
-  * [Philip Oliva][maintainer] (<philoliva8@gmail.com>)
-  * [Andrew J. Brown][maintainer] (<anbrown@blackberry.com>)
-  * [Evgeny Yurchenko][maintainer] (<eyurchenko@blackberry.com>)
+  * [Andrew J. Brown](https://github.com/andrewjamesbrown) (<anbrown@blackberry.com>)
+  * [Bogdan Buczynski](https://github.com/bbuczynski) (<pikus1@gmail.com>)
+  * [Dongyu 'Gary' Zheng](https://github.com/dongyuzheng) (<garydzheng@gmail.com>)
+  * [Evgeny Yurchenko](https://github.com/EYurchenko) (<eyurchenko@blackberry.com>)
+  * [Phil Oliva](https://github.com/poliva83) (<philoliva8@gmail.com>)
 
 ## <a name="license"></a> License
 
 Apache 2.0 (see [LICENSE][license])
 
-[author]:           https://github.com/bbuczynski
-[maintainer]:       https://github.com/poliva83
-[maintainer]:       https://github.com/andrewjamesbrown
-[maintainer]:       https://github.com/EYurchenko
 [issues]:           https://github.com/blackberry/chef-provisioning-opennebula/issues
 [license]:          https://github.com/blackberry/chef-provisioning-opennebula/blob/master/LICENSE
 [repo]:             https://github.com/blackberry/chef-provisioning-opennebula

data/lib/chef/provider/one_image.rb

@@ -43,7 +43,7 @@ class Chef
 
       def exists?
         new_driver = driver
-        @image = new_driver.one.get_resource('img', :name => new_resource.name)
+        @image = new_driver.one.get_resource(:image, :name => @new_resource.name)
         !@image.nil?
       end
 
@@ -56,14 +56,15 @@ class Chef
 
           action_handler.perform_action "allocated image '#{new_resource.name}'" do
             @image = new_driver.one.allocate_img(
-              new_resource.name,
-              new_resource.size,
-              new_resource.datastore_id,
-              new_resource.type || 'OS',
-              new_resource.fs_type || 'ext2',
-              new_resource.img_driver || 'qcow2',
-              new_resource.prefix || 'vd',
-              new_resource.persistent || false)
+              :name => new_resource.name,
+              :size => new_resource.size,
+              :datastore_id => new_resource.datastore_id,
+              :type => new_resource.type || 'OS',
+              :fs_type => new_resource.fs_type || 'ext2',
+              :driver => new_resource.img_driver || 'qcow2',
+              :prefix => new_resource.prefix || 'vd',
+              :persistent => new_resource.persistent || false)
+            new_driver.one.chmod_resource(@image, new_resource.mode)
             Chef::Log.info("Image '#{new_resource.name}' allocate in initial state #{@image.state_str}")
             @new_resource.updated_by_last_action(true)
           end
@@ -91,7 +92,7 @@ class Chef
           action_handler.perform_action "deleted image '#{new_resource.name}'" do
             rc = @image.delete
             fail "Failed to delete image '#{new_resource.name}' : #{rc.message}" if OpenNebula.is_error?(rc)
-            until new_driver.one.get_resource('img', :name => new_resource.name).nil?
+            until new_driver.one.get_resource(:image, :name => new_resource.name).nil?
               Chef::Log.debug("Waiting for delete image to finish...")
               sleep 1
             end
@@ -106,8 +107,8 @@ class Chef
         fail "Missing attribute 'machine_id'" unless new_resource.machine_id
         fail "Failed to attach disk - image '#{new_resource.name}' does not exist" unless exists?
 
-        vm = new_driver.one.get_resource('vm', new_resource.machine_id.is_a?(Integer) ? :id : :name => new_resource.machine_id)
-        fail "Failed to attach disk - VM '#{new_resource.machine}' does not exist" if vm.nil?
+        vm = new_driver.one.get_resource(:virtualmachine, new_resource.machine_id.is_a?(Integer) ? :id : :name => new_resource.machine_id)
+        fail "Failed to attach disk - VM '#{new_resource.machine_id}' does not exist" if vm.nil?
         action_handler.perform_action "attached disk #{new_resource.name} to #{vm.name}" do
           disk_hash = @image.to_hash
           disk_tpl = "DISK = [ "
@@ -133,16 +134,16 @@ class Chef
       action :snapshot do
         fail "Missing attribute 'machine_id'" unless new_resource.machine_id
         fail "snapshot '#{new_resource.name}' already exists" if exists?
-        vm = new_driver.one.get_resource('vm', new_resource.machine_id.is_a?(Integer) ? :id : :name => new_resource.machine_id)
+        vm = new_driver.one.get_resource(:virtualmachine, new_resource.machine_id.is_a?(Integer) ? :id : :name => new_resource.machine_id)
         fail "Failed to create snapshot - VM '#{new_resource.machine_id}' does not exist" if vm.nil?
         action_handler.perform_action "created snapshot from '#{new_resource.machine_id}'" do
           disk_id = new_resource.disk_id.is_a?(Integer) ? new_resource.disk_id : new_driver.one.get_disk_id(vm, new_resource.disk_id)
           fail "No disk '#{new_resource.disk_id}' found on '#{vm.name}'" if disk_id.nil?
-
-          @image = vm.disk_snapshot(disk_id, new_resource.name, "", true)
+          @image = new_driver.one.version_ge_4_14 ? vm.disk_saveas(disk_id, new_resource.name) : vm.disk_snapshot(disk_id, new_resource.name, "", true)
           fail "Failed to create snapshot '#{new_resource.name}': #{@image.message}" if OpenNebula.is_error?(@image)
 
           @image = new_driver.one.wait_for_img(new_resource.name, @image)
+          new_driver.one.chmod_resource(image, new_resource.mode)
           if new_resource.persistent
             action_handler.report_progress "make image '#{new_resource.name}' persistent"
             @image.persistent
@@ -153,47 +154,67 @@ class Chef
 
       action :upload do
         fail "'datastore_id' is required" unless new_resource.datastore_id
-        fail "'image_file' is required" unless new_resource.image_file
-        fail "image_file #{new_resource.image_file} does not exist" unless ::File.exist? new_resource.image_file
+        fail "'image_file' or 'download_url' attribute is required" unless new_resource.image_file || new_resource.download_url
 
-        file_url = "http://#{node['ipaddress']}/#{::File.basename(@new_resource.image_file)}"
-        description = @new_resource.description || "#{@new_resource.name} image"
-        image_driver = @new_resource.img_driver || 'qcow2'
+        file_url = nil
+        if new_resource.image_file
+          fail "image_file #{new_resource.image_file} does not exist" unless ::File.exist? new_resource.image_file
+          file_url = "http://#{node['ipaddress']}:#{@new_resource.http_port}/#{::File.basename(@new_resource.image_file)}"
+        else
+          file_url = new_resource.download_url
+        end
+        image_config = {
+          :name => @new_resource.name,
+          :datastore_id => @new_resource.datastore_id.to_s,
+          :path => file_url,
+          :driver => @new_resource.img_driver || 'qcow2',
+          :description => @new_resource.description || "#{@new_resource.name} image",
+          :type => @new_resource.type,
+          :mode => @new_resource.mode,
+          :prefix => @new_resource.prefix,
+          :persistent => @new_resource.persistent,
+          :public => @new_resource.public,
+          :target => @new_resource.target,
+          :disk_type => @new_resource.disk_type,
+          :source => @new_resource.source,
+          :size => @new_resource.size,
+          :fs_type => @new_resource.fs_type
+        }
 
         if exists?
-          if @image.name == @new_resource.name &&
-             @image['PATH'] == file_url &&
-             @image['TEMPLATE/DRIVER'] == image_driver &&
-             @image['TEMPLATE/DESCRIPTION'] == description &&
-             @image['DATASTORE_ID'] == @new_resource.datastore_id.to_s
+          if @image.name == image_config[:name] &&
+             @image['PATH'] == image_config[:path] &&
+             @image['TEMPLATE/DRIVER'] == image_config[:driver] &&
+             @image['TEMPLATE/DESCRIPTION'] == image_config[:description] &&
+             @image['DATASTORE_ID'] == image_config[:datastore_id]
             action_handler.report_progress("image '#{@new_resource.name}' (ID: #{@image.id}) already exists - nothing to do")
           else
             fail "image '#{new_resource.name}' already exists, but it is not the same image"
           end
         else
-          action_handler.perform_action "upload image '#{@new_resource.image_file}'" do
-            begin
-              pid = Process.spawn("sudo python -m SimpleHTTPServer 80", :chdir => ::File.dirname(@new_resource.image_file), STDOUT => "/dev/null", STDERR => "/dev/null", :pgroup => true)
-              fail "Failed to start 'SimpleHTTPServer'" if pid.nil?
-              new_driver.one.upload_img(
-                @new_resource.name,
-                @new_resource.datastore_id,
-                file_url,
-                image_driver,
-                description,
-                @new_resource.type,
-                @new_resource.prefix,
-                @new_resource.persistent,
-                @new_resource.public,
-                @new_resource.target,
-                @new_resource.disk_type,
-                @new_resource.source,
-                @new_resource.size,
-                @new_resource.fs_type)
-
+          action_handler.perform_action "upload image '#{@new_resource.name}'" do
+            if @new_resource.image_file
+              begin
+                success = false
+                pid = nil
+                trap("CLD") do
+                  cpid = Process.wait
+                  fail "Could not start HTTP server on port #{@new_resource.http_port}" if cpid == pid && !success
+                end
+                pid = Process.spawn("python -m SimpleHTTPServer #{@new_resource.http_port}",
+                  :chdir => ::File.dirname(@new_resource.image_file),
+                  STDOUT => "/dev/null",
+                  STDERR => "/dev/null",
+                  :pgroup => true)
+                new_driver.one.upload_img(image_config)
+                success = true
+                @new_resource.updated_by_last_action(true)
+              ensure
+                system("sudo kill -9 -#{pid}")
+              end
+            else
+              new_driver.one.upload_img(image_config)
               @new_resource.updated_by_last_action(true)
-            ensure
-              system("sudo kill -9 -#{pid}")
             end
           end
         end
@@ -208,7 +229,7 @@ class Chef
             You can get the value for 'download_url' by loging into your OpenNebula CLI
             and reading the ONE_DOWNLOAD environment variable) if download_url.nil?
           # You can get the value for 'download_url' by loging into your OpenNebula CLI and reading the ONE_DOWNLOAD environment variable" if download_url.nil?
-          image = new_driver.one.get_resource('img', !@new_resource.image_id.nil? ? { :id => @new_resource.image_id } : { :name => @new_resource.name })
+          image = new_driver.one.get_resource(:image, !@new_resource.image_id.nil? ? { :id => @new_resource.image_id } : { :name => @new_resource.name })
           fail "Image 'NAME: #{@new_resource.name}/ID: #{@new_resource.image_id}' does not exist" if image.nil?
           local_path = @new_resource.image_file || ::File.join(Chef::Config[:file_cache_path], "#{@new_resource.name}.qcow2")
           fail "Will not overwrite an existing file: #{local_path}" if ::File.exist?(local_path)

data/lib/chef/provider/one_template.rb

@@ -1,4 +1,4 @@
-# Copyright 2015, BlackBerry, Inc.
+# Copyright 2015, BlackBerry, Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,67 +28,145 @@ class Chef
 
       provides :one_template
 
-      attr_reader :template
+      attr_reader :uname
+      attr_reader :equal_template
+      attr_reader :equal_mode
+      attr_reader :current_id
 
       def whyrun_supported?
         true
       end
 
       def load_current_resource
-      end
+        driver = self.driver
+        @uname = uname
+        @current_resource = Chef::Resource::OneTemplate.new(new_resource.name,
+                                                            run_context)
+        @current_resource.name(new_resource.name)
+        template = driver.one.get_resource(:template,
+                                           :name => @current_resource.name,
+                                           :uname => @uname)
+        @current_resource.exists = !template.nil?
 
-      def action_handler
-        @action_handler ||= Chef::Provisioning::ChefProviderActionHandler.new(self)
-      end
+        return unless @current_resource.exists
+
+        new_resource_template = @new_resource.template_file.nil? ?
+            @new_resource.template :
+            driver.one.template_from_file(@new_resource.template_file)
 
-      def exists?
-        new_driver = driver
-        @template = new_driver.one.get_resource('tpl', :name => new_resource.name)
-        !@template.nil?
+        @current_id = template.to_hash['VMTEMPLATE']['ID'].to_i
+        @current_resource.template(template.to_hash['VMTEMPLATE']['TEMPLATE'])
+        @current_resource.mode(get_mode(template))
+        @equal_template = @current_resource.template == new_resource_template
+        @equal_mode = @current_resource.mode == new_resource.mode
+        @current_resource.equal = @equal_template && @equal_mode
       end
 
       action :create do
-        if exists?
-          action_handler.report_progress "template '#{new_resource.name}' already exists - nothing to do"
-        else
-          fail "Missing attribute 'template_file' or 'template'" if !new_resource.template_file && !new_resource.template
-          action_handler.perform_action "create template '#{new_resource.name}'" do
-            template_str = File.read(new_resource.template_file) if new_resource.template_file
-            template_str = new_driver.one.create_template(new_resource.template) if new_resource.template
-            template_str << "\nNAME=\"#{new_resource.name}\""
-            @template = new_driver.one.allocate_template(template_str)
-            @new_resource.updated_by_last_action(true)
+        template_str = create_template
+
+        unless @current_resource.equal
+          if @current_resource.exists
+            unless @equal_template
+              converge_by "update template content on '#{new_resource.name}'" do
+                driver.one.update_template(@current_id, template_str)
+              end
+            end
+            unless @equal_mode
+              converge_by('update template permissions on ' \
+                "'#{new_resource.name}' to #{new_resource.mode}") do
+                template = driver.one.get_resource(:template,
+                                                   :name => @current_resource.name,
+                                                   :uname => @uname)
+                driver.one.chmod_resource(template, new_resource.mode)
+              end
+            end
+          else
+            converge_by("create template '#{new_resource.name}'") do
+              create_one_template(template_str)
+            end
           end
+          new_resource.updated_by_last_action(true)
         end
       end
 
-      action :delete do
-        if !exists?
-          action_handler.report_progress "template '#{new_resource.name}' does not exists - nothing to do"
-        else
-          action_handler.perform_action "delete template '#{new_resource.name}'" do
-            @template.delete
-            @new_resource.updated_by_last_action(true)
+      action :create_if_missing do
+        template_str = create_template
+
+        unless @current_resource.exists
+          converge_by("create template '#{new_resource.name}'") do
+            create_one_template(template_str)
           end
+          new_resource.updated_by_last_action(true)
         end
       end
 
+      action :delete do
+        converge_by("delete template '#{new_resource.name}'") do
+          template = driver.one.get_resource(:template,
+                                             :name => @current_resource.name,
+                                             :uname => @uname)
+          template.delete
+          new_resource.updated_by_last_action(true)
+        end if @current_resource.exists
+      end
+
       protected
 
       def driver
-        if current_driver && current_driver.driver_url != new_driver.driver_url
-          fail "Cannot move '#{machine_spec.name}' from #{current_driver.driver_url} to #{new_driver.driver_url}: machine moving is not supported.  Destroy and recreate."
+        current_driver = begin
+          if new_resource.driver
+            run_context.chef_provisioning.driver_for(new_resource.driver)
+          elsif run_context.chef_provisioning.current_driver
+            run_context.chef_provisioning.driver_for(run_context.chef_provisioning.current_driver)
+          end
+        end
+        fail "Driver not specified for one_template  #{new_resource.name}" unless current_driver
+        current_driver
+      end
+
+      def create_one_template(template_str)
+        unless new_resource.template.key?('NAME')
+          template_str << "\n" << 'NAME="' << new_resource.name << '"'
         end
-        fail "Driver not specified for one_image #{new_resource.name}" unless new_driver
-        new_driver
+        driver.one.allocate_template(template_str)
+        template = driver.one.get_resource(:template,
+                                           :name => @current_resource.name,
+                                           :uname => @uname)
+        driver.one.chmod_resource(template, new_resource.mode)
       end
 
-      def new_driver
-        run_context.chef_provisioning.driver_for(new_resource.driver)
+      def create_template
+        if new_resource.template_file && new_resource.template.size > 0
+          fail("Attributes 'template_file' and 'template' are mutually " \
+               'exclusive.')
+        elsif new_resource.template_file
+          ::File.read(new_resource.template_file)
+        elsif new_resource.template.size > 0
+          driver.one.create_template(new_resource.template)
+        else
+          fail("Missing attribute 'template_file' or 'template' in " \
+               'resource block.')
+        end
+      end
+
+      def get_mode(template)
+        perms = template.to_hash['VMTEMPLATE']['PERMISSIONS']
+        mode = 0
+        %w(OWNER_U OWNER_M OWNER_A GROUP_U GROUP_M GROUP_A
+           OTHER_U OTHER_M OTHER_A).each do |m|
+          mode += perms[m].to_i
+          mode = mode << 1
+        end
+        mode = mode >> 1
+        mode.to_s(8)
       end
 
-      def current_driver
-        run_context.chef_provisioning.driver_for(run_context.chef_provisioning.current_driver) if run_context.chef_provisioning.current_driver
+      def uname
+        xml = OpenNebula::User.build_xml(OpenNebula::User::SELF)
+        my_user = OpenNebula::User.new(xml, driver.one.client)
+        my_user.info!
+        my_user.to_hash['USER']['NAME']
       end
     end
   end