Merge pull request #17951 from d-m-u/fixing_system_retirement_user

Add retirement initiator context

app/models/mixins/process_tasks_mixin.rb

@@ -7,7 +7,7 @@ module ClassMethods
     def process_tasks(options)
       raise _("No ids given to process_tasks") if options[:ids].blank?
       if options[:task] == 'retire_now'
-        name.constantize.make_retire_request(*options[:ids])
+        name.constantize.make_retire_request(*options[:ids], User.current_user)
       elsif options[:task] == "refresh_ems" && respond_to?("refresh_ems")
         refresh_ems(options[:ids])
         msg = "'#{options[:task]}' initiated for #{options[:ids].length} #{ui_lookup(:table => base_class.name).pluralize}"

app/models/mixins/retirement_mixin.rb

@@ -10,10 +10,10 @@ module RetirementMixin
   end
 
   module ClassMethods
-    def make_retire_request(*src_ids)
+    def make_retire_request(*src_ids, requester)
       klass = (name.demodulize + "RetireRequest").constantize
-      options = {:src_ids => src_ids.presence || id, :__request_type__ => klass.request_types.first}
-      klass.make_request(nil, options, User.current_user, true)
+      options = {:src_ids => src_ids.presence, :__request_type__ => klass.request_types.first}
+      klass.make_request(nil, options, requester, true)
     end
 
     def retire(ids, options = {})
@@ -112,18 +112,19 @@ def raise_retire_audit_event(message)
 
   def retirement_check
     return if retired? || retiring? || retirement_initialized?
+    requester = system_context_requester
 
     if !retirement_warned? && retirement_warning_due?
       begin
         self.retirement_last_warn = Time.now.utc
         save
-        raise_retirement_event(retire_warn_event_name)
+        raise_retirement_event(retire_warn_event_name, requester)
       rescue => err
         _log.log_backtrace(err)
       end
     end
 
-    self.class.make_retire_request(self.id) if retirement_due?
+    self.class.make_retire_request(id, requester) if retirement_due?
   end
 
   def retire_now(requester = nil)
@@ -140,7 +141,7 @@ def retire_now(requester = nil)
           event_name = "request_#{retirement_event_prefix}_retire"
           _log.info("calling #{event_name}")
           begin
-            raise_retirement_event(event_name, requester)
+            raise_retirement_event(event_name, requester ||= current_user)
           rescue => err
             _log.log_backtrace(err)
           end
@@ -201,14 +202,12 @@ def retired_event_name
   end
 
   def raise_retirement_event(event_name, requester = nil)
-    requester ||= User.current_user.try(:userid)
-    q_options = retire_queue_options
-    $log.info("Requester [#{requester}] raising Retirement Event for [#{name}] with queue options: #{q_options.inspect}")
+    q_options = q_user_info(retire_queue_options, requester)
+    $log.info("Raising Retirement Event for [#{name}] with queue options: #{q_options.inspect}")
     MiqEvent.raise_evm_event(self, event_name, setup_event_hash(requester), q_options)
   end
 
   def raise_audit_event(event_name, message, requester = nil)
-    requester ||= User.current_user.try(:userid)
     event_hash = {
       :target_class => retirement_base_model_name,
       :target_id    => id.to_s,
@@ -237,15 +236,39 @@ def valid_zone?
     respond_to?(:my_zone) && my_zone.present?
   end
 
+  def system_context_requester
+    if try(:evm_owner_id).present?
+      User.find(evm_owner_id)
+    else
+      $log.info("System context defaulting to admin user because owner of #{name} not set.")
+      User.find_by(:userid => 'admin')
+    end
+  end
+
+  def current_user
+    User.find_by(:userid => User.current_user.try(:userid))
+  end
+
+  def q_user_info(q_options, requester)
+    if requester.present?
+      if requester.kind_of?(String)
+        requester = User.find_by(:userid => requester)
+      end
+      q_options[:user_id] = requester.id
+      if requester.current_group.present? && requester.current_tenant.present?
+        q_options[:group_id] = requester.current_group.id
+        q_options[:tenant_id] = requester.current_tenant.id
+      end
+    end
+    q_options
+  end
+
   def setup_event_hash(requester)
-    event_hash = {:retirement_initiator => "system"}
-    event_hash[retirement_base_model_name.underscore.to_sym] = self
-    event_hash[:host] = host if self.respond_to?(:host)
-    if requester
-      event_hash[:userid] = requester
-      event_hash[:retirement_initiator] = "user"
+    {}.tap do |event|
+      event[:userid] = requester
+      event[retirement_base_model_name.underscore.to_sym] = self
+      event[:host] = host if respond_to?(:host)
+      event[:type] ||= self.class.name
     end
-    event_hash[:type] ||= self.class.name
-    event_hash
   end
 end

spec/models/orchestration_stack/retirement_management_spec.rb

@@ -1,153 +1,162 @@
 describe "Service Retirement Management" do
-  let(:user) { FactoryGirl.create(:user_miq_request_approver, :userid => "admin") }
-  before do
-    @miq_server = EvmSpecHelper.local_miq_server
-    @stack = FactoryGirl.create(:orchestration_stack)
-  end
+  let!(:user) { FactoryGirl.create(:user_miq_request_approver, :userid => "admin") }
+  context "with zone/ems" do
+    before do
+      @miq_server = EvmSpecHelper.local_miq_server
+      @zone = @miq_server.zone
+      ems = FactoryGirl.create(:ext_management_system, :zone => @zone)
+      @stack = FactoryGirl.create(:orchestration_stack, :ext_management_system => ems)
+    end
 
-  it "#retirement_check" do
-    User.with_user(user) do
+    it "#retirement_check" do
       expect(MiqEvent).to receive(:raise_evm_event)
       @stack.update_attributes(:retires_on => 90.days.ago, :retirement_warn => 60, :retirement_last_warn => nil)
       expect(@stack.retirement_last_warn).to be_nil
       @stack.retirement_check
       @stack.reload
       expect(@stack.retirement_last_warn).not_to be_nil
     end
-  end
 
-  it "#start_retirement" do
-    expect(@stack.retirement_state).to be_nil
-    @stack.start_retirement
-    @stack.reload
-    expect(@stack.retirement_state).to eq("retiring")
-  end
-
-  it "#retire_now" do
-    expect(@stack.retirement_state).to be_nil
-    expect(OrchestrationStackRetireRequest).to_not receive(:make_request)
-    @stack.retire_now
-    @stack.reload
-  end
+    it "#start_retirement" do
+      expect(@stack.retirement_state).to be_nil
+      @stack.start_retirement
+      @stack.reload
+      expect(@stack.retirement_state).to eq("retiring")
+    end
 
-  it "#retire_now with userid" do
-    expect(@stack.retirement_state).to be_nil
-    event_name = 'request_orchestration_stack_retire'
-    event_hash = {:orchestration_stack => @stack, :type => "OrchestrationStack",
-                  :retirement_initiator => "user", :userid => "freddy"}
+    it "#retire_now" do
+      expect(@stack.retirement_state).to be_nil
+      expect(OrchestrationStackRetireRequest).to_not receive(:make_request)
+      @stack.retire_now
+      @stack.reload
+    end
 
-    expect(OrchestrationStackRetireRequest).to_not receive(:make_request)
+    it "#retire_now with userid" do
+      expect(@stack.retirement_state).to be_nil
+      expect(OrchestrationStackRetireRequest).to_not receive(:make_request)
 
-    @stack.retire_now('freddy')
-    @stack.reload
-  end
+      @stack.retire_now('freddy')
+      @stack.reload
+    end
 
-  it "#retire_now without userid" do
-    expect(@stack.retirement_state).to be_nil
-    event_name = 'request_orchestration_stack_retire'
-    event_hash = {:orchestration_stack => @stack, :type => "OrchestrationStack",
-                  :retirement_initiator => "system"}
+    it "#retire_now without userid" do
+      expect(@stack.retirement_state).to be_nil
+      expect(OrchestrationStackRetireRequest).to_not receive(:make_request)
 
-    expect(OrchestrationStackRetireRequest).to_not receive(:make_request)
+      @stack.retire_now
+      @stack.reload
+    end
 
-    @stack.retire_now
-    @stack.reload
-  end
+    it "#retire warn" do
+      expect(AuditEvent).to receive(:success).once
+      options = {}
+      options[:warn] = 2.days.to_i
+      @stack.retire(options)
+      @stack.reload
+      expect(@stack.retirement_warn).to eq(options[:warn])
+    end
 
-  it "#retire warn" do
-    expect(AuditEvent).to receive(:success).once
-    options = {}
-    options[:warn] = 2.days.to_i
-    @stack.retire(options)
-    @stack.reload
-    expect(@stack.retirement_warn).to eq(options[:warn])
-  end
+    it "#retire date" do
+      expect(AuditEvent).to receive(:success).once
+      options = {}
+      options[:date] = Time.zone.today
+      @stack.retire(options)
+      @stack.reload
+      expect(@stack.retires_on).to eq(options[:date])
+    end
 
-  it "#retire date" do
-    expect(AuditEvent).to receive(:success).once
-    options = {}
-    options[:date] = Time.zone.today
-    @stack.retire(options)
-    @stack.reload
-    expect(@stack.retires_on).to eq(options[:date])
-  end
+    it "#finish_retirement" do
+      expect(@stack.retirement_state).to be_nil
+      @stack.finish_retirement
+      @stack.reload
+      expect(@stack.retired).to be_truthy
+      expect(@stack.retires_on).to be_between(Time.zone.now - 1.hour, Time.zone.now + 1.second)
+      expect(@stack.retirement_state).to eq("retired")
+    end
 
-  it "#finish_retirement" do
-    expect(@stack.retirement_state).to be_nil
-    @stack.finish_retirement
-    @stack.reload
-    expect(@stack.retired).to be_truthy
-    expect(@stack.retires_on).to be_between(Time.zone.now - 1.hour, Time.zone.now + 1.second)
-    expect(@stack.retirement_state).to eq("retired")
-  end
+    it "#retiring - false" do
+      expect(@stack.retirement_state).to be_nil
+      expect(@stack.retiring?).to be_falsey
+    end
 
-  it "#retiring - false" do
-    expect(@stack.retirement_state).to be_nil
-    expect(@stack.retiring?).to be_falsey
-  end
+    it "#retiring - true" do
+      @stack.update_attributes(:retirement_state => 'retiring')
+      expect(@stack.retiring?).to be_truthy
+    end
 
-  it "#retiring - true" do
-    @stack.update_attributes(:retirement_state => 'retiring')
-    expect(@stack.retiring?).to be_truthy
-  end
+    it "#error_retiring - false" do
+      expect(@stack.retirement_state).to be_nil
+      expect(@stack.error_retiring?).to be_falsey
+    end
 
-  it "#error_retiring - false" do
-    expect(@stack.retirement_state).to be_nil
-    expect(@stack.error_retiring?).to be_falsey
-  end
+    it "#error_retiring - true" do
+      @stack.update_attributes(:retirement_state => 'error')
+      expect(@stack.error_retiring?).to be_truthy
+    end
 
-  it "#error_retiring - true" do
-    @stack.update_attributes(:retirement_state => 'error')
-    expect(@stack.error_retiring?).to be_truthy
-  end
+    it "#retires_on - today" do
+      expect(@stack.retirement_due?).to be_falsey
+      @stack.retires_on = Time.zone.today
+      expect(@stack.retirement_due?).to be_truthy
+    end
 
-  it "#retires_on - today" do
-    expect(@stack.retirement_due?).to be_falsey
-    @stack.retires_on = Time.zone.today
-    expect(@stack.retirement_due?).to be_truthy
-  end
+    it "#retires_on - tomorrow" do
+      expect(@stack.retirement_due?).to be_falsey
+      @stack.retires_on = Time.zone.today + 1
+      expect(@stack.retirement_due?).to be_falsey
+    end
 
-  it "#retires_on - tomorrow" do
-    expect(@stack.retirement_due?).to be_falsey
-    @stack.retires_on = Time.zone.today + 1
-    expect(@stack.retirement_due?).to be_falsey
-  end
+    it "#retirement_due?" do
+      expect(@stack.retirement_due?).to be_falsey
 
-  it "#retirement_due?" do
-    expect(@stack.retirement_due?).to be_falsey
+      @stack.update_attributes(:retires_on => Time.zone.today + 1.day)
+      expect(@stack.retirement_due?).to be_falsey
 
-    @stack.update_attributes(:retires_on => Time.zone.today + 1.day)
-    expect(@stack.retirement_due?).to be_falsey
+      @stack.update_attributes(:retires_on => Time.zone.today)
+      expect(@stack.retirement_due?).to be_truthy
 
-    @stack.update_attributes(:retires_on => Time.zone.today)
-    expect(@stack.retirement_due?).to be_truthy
+      @stack.update_attributes(:retires_on => Time.zone.today - 1.day)
+      expect(@stack.retirement_due?).to be_truthy
+    end
 
-    @stack.update_attributes(:retires_on => Time.zone.today - 1.day)
-    expect(@stack.retirement_due?).to be_truthy
-  end
+    it "#raise_retirement_event" do
+      event_name = 'foo'
+      event_hash = {
+        :userid              => nil,
+        :orchestration_stack => @stack,
+        :type                => "OrchestrationStack",
+      }
 
-  it "#raise_retirement_event" do
-    event_name = 'foo'
-    event_hash = {
-      :orchestration_stack  => @stack,
-      :type                 => "OrchestrationStack",
-      :retirement_initiator => "system"
-    }
+      expect(MiqEvent).to receive(:raise_evm_event).with(@stack, event_name, event_hash, :zone => @zone.name)
+      @stack.raise_retirement_event(event_name)
+    end
 
-    expect(MiqEvent).to receive(:raise_evm_event).with(@stack, event_name, event_hash, {})
-    @stack.raise_retirement_event(event_name)
+    it "#raise_audit_event" do
+      event_name = 'foo'
+      message = 'bar'
+      event_hash = {
+        :target_class => "OrchestrationStack",
+        :target_id    => @stack.id.to_s,
+        :event        => event_name,
+        :message      => message
+      }
+      expect(AuditEvent).to receive(:success).with(event_hash)
+      @stack.raise_audit_event(event_name, message)
+    end
   end
 
-  it "#raise_audit_event" do
-    event_name = 'foo'
-    message = 'bar'
-    event_hash = {
-      :target_class => "OrchestrationStack",
-      :target_id    => @stack.id.to_s,
-      :event        => event_name,
-      :message      => message
-    }
-    expect(AuditEvent).to receive(:success).with(event_hash)
-    @stack.raise_audit_event(event_name, message)
+  context "without zone/ems" do
+    it "#raise_retirement_event" do
+      stack_without_zone = FactoryGirl.create(:orchestration_stack, :ext_management_system => nil)
+      event_name = 'foo'
+      event_hash = {
+        :userid              => nil,
+        :orchestration_stack => stack_without_zone,
+        :type                => "OrchestrationStack",
+      }
+
+      expect(MiqEvent).to receive(:raise_evm_event).with(stack_without_zone, event_name, event_hash, {})
+      stack_without_zone.raise_retirement_event(event_name)
+    end
   end
 end