Add user to options when queueing instance actions

app/controllers/api/base_controller/action.rb

@@ -32,6 +32,19 @@ def queue_object_action(object, summary, options)
 
         MiqTask.generic_action_with_callback(task_options, queue_options)
       end
+
+      def queue_options(method, role = nil)
+        current_user = User.current_user
+        {
+          :method_name => method,
+          :role        => role,
+          :user        => {
+            :user_id   => current_user.id,
+            :group_id  => current_user.current_group.id,
+            :tenant_id => current_user.current_tenant.id
+          }
+        }
+      end
     end
   end
 end

app/controllers/api/instances_controller.rb

@@ -5,6 +5,8 @@ class InstancesController < BaseController
     include Subcollections::SecurityGroups
     include Subcollections::Snapshots
 
+    DEFAULT_ROLE = 'ems_operations'.freeze
+
     def terminate_resource(type, id = nil, _data = nil)
       raise BadRequestError, "Must specify an id for terminating a #{type} resource" unless id
 
@@ -114,31 +116,31 @@ def instance_ident(instance)
 
     def terminate_instance(instance)
       desc = "#{instance_ident(instance)} terminating"
-      task_id = queue_object_action(instance, desc, :method_name => "vm_destroy", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("vm_destroy", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def stop_instance(instance)
       desc = "#{instance_ident(instance)} stopping"
-      task_id = queue_object_action(instance, desc, :method_name => "stop", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("stop", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def start_instance(instance)
       desc = "#{instance_ident(instance)} starting"
-      task_id = queue_object_action(instance, desc, :method_name => "start", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("start", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def pause_instance(instance)
       desc = "#{instance_ident(instance)} pausing"
-      task_id = queue_object_action(instance, desc, :method_name => "pause", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("pause", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
@@ -155,31 +157,31 @@ def validate_instance_for_action(instance, action)
 
     def suspend_instance(instance)
       desc = "#{instance_ident(instance)} suspending"
-      task_id = queue_object_action(instance, desc, :method_name => "suspend", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("suspend", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def shelve_instance(instance)
       desc = "#{instance_ident(instance)} shelving"
-      task_id = queue_object_action(instance, desc, :method_name => "shelve", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("shelve", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def reboot_guest_instance(instance)
       desc = "#{instance_ident(instance)} rebooting"
-      task_id = queue_object_action(instance, desc, :method_name => "reboot_guest", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("reboot_guest", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def reset_instance(instance)
       desc = "#{instance_ident(instance)} resetting"
-      task_id = queue_object_action(instance, desc, :method_name => "reset", :role => "ems_operations")
+      task_id = queue_object_action(instance, desc, queue_options("reset", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)

app/controllers/api/vms_controller.rb

@@ -323,55 +323,55 @@ def validate_vm_for_remote_console(vm, protocol = nil)
 
     def start_vm(vm)
       desc = "#{vm_ident(vm)} starting"
-      task_id = queue_object_action(vm, desc, queue_options("start"))
+      task_id = queue_object_action(vm, desc, queue_options("start", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def stop_vm(vm)
       desc = "#{vm_ident(vm)} stopping"
-      task_id = queue_object_action(vm, desc, queue_options("stop"))
+      task_id = queue_object_action(vm, desc, queue_options("stop", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def suspend_vm(vm)
       desc = "#{vm_ident(vm)} suspending"
-      task_id = queue_object_action(vm, desc, queue_options("suspend"))
+      task_id = queue_object_action(vm, desc, queue_options("suspend", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def pause_vm(vm)
       desc = "#{vm_ident(vm)} pausing"
-      task_id = queue_object_action(vm, desc, queue_options("pause"))
+      task_id = queue_object_action(vm, desc, queue_options("pause", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def shelve_vm(vm)
       desc = "#{vm_ident(vm)} shelving"
-      task_id = queue_object_action(vm, desc, queue_options("shelve"))
+      task_id = queue_object_action(vm, desc, queue_options("shelve", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def shelve_offload_vm(vm)
       desc = "#{vm_ident(vm)} shelve-offloading"
-      task_id = queue_object_action(vm, desc, queue_options("shelve_offload"))
+      task_id = queue_object_action(vm, desc, queue_options("shelve_offload", DEFAULT_ROLE))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
     end
 
     def destroy_vm(vm)
       desc = "#{vm_ident(vm)} deleting"
-      task_id = queue_object_action(vm, desc, queue_options("destroy").except(:role))
+      task_id = queue_object_action(vm, desc, queue_options("destroy"))
       action_result(true, desc, :task_id => task_id)
     rescue => err
       action_result(false, err.to_s)
@@ -478,18 +478,5 @@ def request_console_vm(vm, protocol)
     rescue => err
       action_result(false, err.to_s)
     end
-
-    def queue_options(method)
-      current_user = User.current_user
-      {
-        :method_name => method,
-        :role        => DEFAULT_ROLE,
-        :user        => {
-          :user_id   => current_user.id,
-          :group_id  => current_user.current_group.id,
-          :tenant_id => current_user.current_tenant.id
-        }
-      }
-    end
   end
 end

spec/requests/instances_spec.rb

@@ -61,6 +61,10 @@ def update_raw_power_state(state, *instances)
         :message => /#{instance.id}.* terminating/i,
         :href    => api_instance_url(nil, instance)
       )
+      expect(MiqQueue.where(:method_name => "vm_destroy",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "terminates multiple valid Instances" do
@@ -119,6 +123,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:stop))
 
       expect_single_action_result(:success => true, :message => "stopping", :href => api_instance_url(nil, instance), :task => true)
+      expect(MiqQueue.where(:method_name => "stop",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "stops multiple valid instances" do
@@ -163,6 +171,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:start))
 
       expect_single_action_result(:success => true, :message => "starting", :href => api_instance_url(nil, instance), :task => true)
+      expect(MiqQueue.where(:method_name => "start",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "starts multiple instances" do
@@ -217,6 +229,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:pause))
 
       expect_single_action_result(:success => true, :message => "pausing", :href => api_instance_url(nil, instance), :task => true)
+      expect(MiqQueue.where(:method_name => "pause",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "pauses multiple instances" do
@@ -270,6 +286,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:suspend))
 
       expect_single_action_result(:success => true, :message => "suspending", :href => api_instance_url(nil, instance), :task => true)
+      expect(MiqQueue.where(:method_name => "suspend",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "suspends multiple instances" do
@@ -324,6 +344,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:shelve))
 
       expect_single_action_result(:success => true, :message => 'shelving', :href => api_instance_url(nil, instance))
+      expect(MiqQueue.where(:method_name => "shelve",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "cannot shelve a shelved instance" do
@@ -392,6 +416,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:reboot_guest))
 
       expect_single_action_result(:success => true, :message => "rebooting", :href => api_instance_url(nil, instance), :task => true)
+      expect(MiqQueue.where(:method_name => "reboot_guest",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "reboots multiple valid instances" do
@@ -436,6 +464,10 @@ def update_raw_power_state(state, *instances)
       post(instance_url, :params => gen_request(:reset))
 
       expect_single_action_result(:success => true, :message => "resetting", :href => api_instance_url(nil, instance), :task => true)
+      expect(MiqQueue.where(:method_name => "reset",
+                            :user_id     => @user.id,
+                            :group_id    => @user.current_group.id,
+                            :tenant_id   => @user.current_tenant.id).count).to eq(1)
     end
 
     it "resets multiple valid instances" do