示例#1
0
        private bool CheckCondition(DtoClientModuleCondition condition)
        {
            _conditionNextOrder = null;
            if (condition.Guid == null)
            {
                //no condition
                Logger.Debug($"No Conditions Found For Module");
                return(true);
            }
            //treat condition as script module
            var conditionJson = JsonConvert.SerializeObject(condition);
            var scriptModule  = JsonConvert.DeserializeObject <DtoClientScriptModule>(conditionJson);

            var conditionResult = new ModuleScriptManager(scriptModule).Run();

            if (conditionResult.Success)
            {
                if (conditionResult.ScriptOutput != null)
                {
                    _policyResult.ScriptOutputs.Add(conditionResult.ScriptOutput);
                }

                Logger.Debug($"Condition Evaluation Completed Successfully");
                return(true);
            }

            Logger.Debug("Condition Evaluation Was Not Satisfied");
            return(false);
        }
示例#2
0
        public DtoPolicyResult Execute()
        {
            Logger.Info(string.Format("Executing Policy {0} ({1})", _policy.Guid, _policy.Name));

            Logger.Debug($"Evaluating Conditions For {_policy.Name}");
            if (!CheckCondition(_policy.Condition))
            {
                if (_policy.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                {
                    _policyResult.PolicyResult = EnumPolicy.Result.Success;
                    return(_policyResult);
                }
                else if (_policy.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                {
                    _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                    return(_policyResult);
                }
                else if (_policy.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                {
                    _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                    return(_policyResult);
                }
                else if (_policy.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                {
                    _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                    return(_policyResult);
                }
            }

            if (_policy.Trigger != EnumPolicy.Trigger.Login)
            {
                if (_policy.IsLoginTracker)
                {
                    new ModuleUserLogins().Run();
                }

                if (_policy.IsApplicationMonitor)
                {
                    new ModuleApplicationMonitor().Run();
                }

                if (_policy.IsInventory == EnumPolicy.InventoryAction.Before || _policy.IsInventory == EnumPolicy.InventoryAction.Both)
                {
                    new ModuleInventory().Run();
                }

                if (_policy.WuType != EnumPolicy.WuType.Disabled)
                {
                    ModuleWuManager.InstallAllUpdates(_policy.WuType);
                }
            }

            var orderCounter = -1;

            foreach (var order in GetPolicyModuleOrder(_policy))
            {
                //handles a condition goto next step
                if (_conditionNextOrder != null)
                {
                    if (order != _conditionNextOrder)
                    {
                        continue;
                    }
                }

                orderCounter++;
                foreach (var module in _policy.SoftwareModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModuleSoftwareManager(module).Run();
                    if (result.Success)
                    {
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
                foreach (var module in _policy.ScriptModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModuleScriptManager(module).Run();
                    if (result.Success)
                    {
                        if (result.ScriptOutput != null)
                        {
                            _policyResult.ScriptOutputs.Add(result.ScriptOutput);
                        }
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
                foreach (var module in _policy.PrinterModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModulePrintManager(module, _policy.Trigger).Run();
                    if (result.Success)
                    {
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
                foreach (var module in _policy.FileCopyModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModuleFileCopy(module).Run();
                    if (result.Success)
                    {
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
                foreach (var module in _policy.CommandModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModuleCommandManager(module).Run();
                    if (result.Success)
                    {
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
                foreach (var module in _policy.WuModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModuleWuManager(module).Run();
                    if (result.Success)
                    {
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
                foreach (var module in _policy.MessageModules)
                {
                    if (module.Order != order)
                    {
                        continue;
                    }
                    Logger.Debug($"Evaluating Conditions For {module.DisplayName}");
                    if (!CheckCondition(module.Condition))
                    {
                        if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSuccess)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Success;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkFailed)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Failed;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkNotApplicable)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.NotApplicable;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.MarkSkipped)
                        {
                            _policyResult.PolicyResult = EnumPolicy.Result.Skipped;
                            return(_policyResult);
                        }
                        else if (module.ConditionFailedAction == EnumCondition.FailedAction.GotoModule)
                        {
                            _conditionNextOrder = module.ConditionNextOrder;
                            break;
                        }
                    }
                    var result = new ModuleMessage(module).Run();
                    if (result.Success)
                    {
                        continue;
                    }
                    if (IsPolicyStopError(result))
                    {
                        return(_policyResult);
                    }
                }
            }

            if (_policy.Trigger != EnumPolicy.Trigger.Login)
            {
                if (_policy.IsInventory == EnumPolicy.InventoryAction.After || _policy.IsInventory == EnumPolicy.InventoryAction.Both)
                {
                    new ModuleInventory().Run();
                }
            }

            Logger.Info(string.Format("Finished Executing Policy {0} ({1})", _policy.Guid, _policy.Name));

            return(_policyResult);
        }