protected void PopulateDistributionStatus(PsCompliancePolicyBase psPolicy, PolicyStorage policyStorage)
{
if (ExPolicyConfigProvider.IsFFOOnline)
{
PolicySettingStatusHelpers.PopulatePolicyDistributionStatus(psPolicy, policyStorage, base.DataSession, this, this.executionLogger);
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (this.RetryDistribution)
{
this.RetryPolicyDistribution();
}
else
{
foreach (BindingStorage bindingStorage in this.PsPolicyPresentationObject.StorageBindings)
{
if (bindingStorage.AppliedScopes.Any <ScopeStorage>())
{
base.DataSession.Save(bindingStorage);
base.WriteVerbose(Strings.VerboseSaveBindingStorageObjects(bindingStorage.ToString(), this.PsPolicyPresentationObject.Name));
}
else
{
base.DataSession.Delete(bindingStorage);
base.WriteVerbose(Strings.VerboseDeleteBindingStorageObjects(bindingStorage.ToString(), this.PsPolicyPresentationObject.Name));
}
}
IEnumerable <RuleStorage> enumerable = Utils.LoadRuleStoragesByPolicy(base.DataSession, this.DataObject, this.RootId);
foreach (RuleStorage ruleStorage in enumerable)
{
base.WriteVerbose(Strings.VerboseLoadRuleStorageObjectsForPolicy(ruleStorage.ToString(), this.DataObject.ToString()));
}
Utils.ThrowIfRulesInPolicyAreTooAdvanced(enumerable, this.DataObject, this, base.DataSession as IConfigurationSession);
base.InternalProcessRecord();
PolicySettingStatusHelpers.CheckNotificationResultsAndUpdateStatus(this, (IConfigurationSession)base.DataSession, this.OnNotifyChanges());
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
this.RuleStorages = Utils.LoadRuleStoragesByPolicy(base.DataSession, base.DataObject, this.RootId);
IList <BindingStorage> list = Utils.LoadBindingStoragesByPolicy(base.DataSession, base.DataObject);
foreach (RuleStorage ruleStorage in this.RuleStorages)
{
base.WriteVerbose(Strings.VerboseLoadRuleStorageObjectsForPolicy(ruleStorage.ToString(), base.DataObject.ToString()));
}
if (!this.ShouldSoftDeleteObject())
{
Utils.RemovePolicyStorageBase(base.DataSession, new WriteVerboseDelegate(base.WriteVerbose), this.RuleStorages);
Utils.RemovePolicyStorageBase(base.DataSession, new WriteVerboseDelegate(base.WriteVerbose), list);
}
else
{
list = null;
}
base.InternalProcessRecord();
if (this.ShouldSoftDeleteObject())
{
PolicySettingStatusHelpers.CheckNotificationResultsAndUpdateStatus(this, (IConfigurationSession)base.DataSession, this.OnNotifyChanges(list, this.RuleStorages));
}
TaskLogger.LogExit();
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
base.InternalProcessRecord();
PolicySettingStatusHelpers.CheckNotificationResultsAndUpdateStatus(this, (IConfigurationSession)base.DataSession, this.OnNotifyChanges());
TaskLogger.LogExit();
}
public static PolicyApplyStatus GetPolicyDistributionStatus(PolicyStorage policyStorage, IList <BindingStorage> bindingStorages, IConfigDataProvider dataSession, out List <PolicyDistributionErrorDetails> distributionErrors, out DateTime?lastStatusUpdateTime)
{
ArgumentValidator.ThrowIfNull("policyStorage", policyStorage);
ArgumentValidator.ThrowIfNull("bindingStorages", bindingStorages);
ArgumentValidator.ThrowIfNull("dataSession", dataSession);
PolicySettingStatusHelpers policySettingStatusHelpers = new PolicySettingStatusHelpers(dataSession, null, null);
return(policySettingStatusHelpers.CalculatePolicyDistributionStatus(policyStorage, bindingStorages, dataSession, out distributionErrors, out lastStatusUpdateTime));
}
private void HandleNotificationErrors(string notificationError, IEnumerable <ChangeNotificationData> syncData)
{
if (!string.IsNullOrEmpty(notificationError))
{
base.WriteWarning(notificationError);
AggregatedNotificationClients.SetNotificationResults(syncData, notificationError);
PolicySettingStatusHelpers.CheckNotificationResultsAndUpdateStatus(this, (IConfigurationSession)base.DataSession, syncData);
}
}
public static void PopulatePolicyDistributionStatus(PsCompliancePolicyBase psPolicy, PolicyStorage policyStorage, IConfigDataProvider dataSession, Task task = null, ExecutionLog logger = null)
{
ArgumentValidator.ThrowIfNull("psPolicy", psPolicy);
ArgumentValidator.ThrowIfNull("policyStorage", policyStorage);
ArgumentValidator.ThrowIfNull("dataSession", dataSession);
PolicySettingStatusHelpers policySettingStatusHelpers = new PolicySettingStatusHelpers(dataSession, task, logger);
List <PolicyDistributionErrorDetails> value;
DateTime?lastStatusUpdateTime;
psPolicy.DistributionStatus = policySettingStatusHelpers.CalculatePolicyDistributionStatus(policyStorage, psPolicy.StorageBindings, dataSession, out value, out lastStatusUpdateTime);
psPolicy.LastStatusUpdateTime = lastStatusUpdateTime;
psPolicy.DistributionResults = new MultiValuedProperty <PolicyDistributionErrorDetails>(value);
}
private bool CalculatePolicyDistributionStatus(IEnumerable <UnifiedPolicyStorageBase> storageObjects, Workload?appliedWorkload, ref List <PolicyDistributionErrorDetails> distributionErrors, ref DateTime?lastStatusUpdateTime)
{
bool result = false;
if (storageObjects != null)
{
foreach (UnifiedPolicyStorageBase unifiedPolicyStorageBase in storageObjects)
{
IEnumerable <UnifiedPolicySettingStatus> statuses = PolicySettingStatusHelpers.LoadSyncStatuses(this.dataSession, Utils.GetUniversalIdentity(unifiedPolicyStorageBase), unifiedPolicyStorageBase.GetType().Name);
if (this.CalculatePolicyDistributionStatus(unifiedPolicyStorageBase, (appliedWorkload != null) ? appliedWorkload.Value : unifiedPolicyStorageBase.Workload, statuses, ref distributionErrors, ref lastStatusUpdateTime))
{
result = true;
}
}
}
return(result);
}
private Dictionary <Workload, List <ChangeNotificationData> > GenerateSyncsForFailedBindings()
{
Dictionary <Workload, List <ChangeNotificationData> > dictionary = new Dictionary <Workload, List <ChangeNotificationData> >();
using (IEnumerator <BindingStorage> enumerator = this.PsPolicyPresentationObject.StorageBindings.GetEnumerator())
{
while (enumerator.MoveNext())
{
BindingStorage bindingStorage = enumerator.Current;
IEnumerable <UnifiedPolicySettingStatus> source = PolicySettingStatusHelpers.LoadSyncStatuses(base.DataSession, Utils.GetUniversalIdentity(bindingStorage), typeof(BindingStorage).Name);
bool flag = false;
if (source.Any((UnifiedPolicySettingStatus s) => SetCompliancePolicyBase.HasDistributionFailed(bindingStorage, s)))
{
flag = true;
bindingStorage.PolicyVersion = CombGuidGenerator.NewGuid();
if (!dictionary.ContainsKey(bindingStorage.Workload))
{
dictionary[bindingStorage.Workload] = new List <ChangeNotificationData>();
}
dictionary[bindingStorage.Workload].Add(AggregatedNotificationClients.CreateChangeData(bindingStorage.Workload, bindingStorage));
}
List <ChangeNotificationData> list = this.GenerateSyncsForFailedScopes(bindingStorage.AppliedScopes);
list.AddRange(this.GenerateSyncsForFailedScopes(bindingStorage.RemovedScopes));
if (list.Any <ChangeNotificationData>())
{
if (!dictionary.ContainsKey(bindingStorage.Workload))
{
dictionary[bindingStorage.Workload] = new List <ChangeNotificationData>();
}
dictionary[bindingStorage.Workload].AddRange(list);
if (!flag)
{
flag = true;
bindingStorage.PolicyVersion = CombGuidGenerator.NewGuid();
base.DataSession.Save(bindingStorage);
dictionary[bindingStorage.Workload].Add(AggregatedNotificationClients.CreateChangeData(bindingStorage.Workload, bindingStorage));
}
}
if (flag)
{
base.DataSession.Save(bindingStorage);
}
}
}
return(dictionary);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
this.PsPolicyPresentationObject.UpdateStorageProperties(this, base.DataSession as IConfigurationSession, true);
base.InternalProcessRecord();
foreach (BindingStorage bindingStorage in this.PsPolicyPresentationObject.StorageBindings)
{
base.DataSession.Save(bindingStorage);
base.WriteVerbose(Strings.VerboseSaveBindingStorageObjects(bindingStorage.ToString(), this.PsPolicyPresentationObject.ToString()));
}
if (!base.HasErrors)
{
this.WriteResult();
}
PolicySettingStatusHelpers.CheckNotificationResultsAndUpdateStatus(this, (IConfigurationSession)base.DataSession, this.OnNotifyChanges());
TaskLogger.LogExit();
}
private List <ChangeNotificationData> GenerateSyncsForFailedScopes(IEnumerable <ScopeStorage> scopeStorages)
{
List <ChangeNotificationData> list = new List <ChangeNotificationData>();
foreach (ScopeStorage scopeStorage in scopeStorages)
{
IEnumerable <UnifiedPolicySettingStatus> enumerable = PolicySettingStatusHelpers.LoadSyncStatuses(base.DataSession, Utils.GetUniversalIdentity(scopeStorage), typeof(ScopeStorage).Name);
foreach (UnifiedPolicySettingStatus status in enumerable)
{
if (SetCompliancePolicyBase.HasDistributionFailed(scopeStorage, status))
{
scopeStorage.PolicyVersion = CombGuidGenerator.NewGuid();
list.Add(AggregatedNotificationClients.CreateChangeData(scopeStorage.Workload, scopeStorage));
}
}
}
return(list);
}
protected override void WriteResult(IConfigurable dataObject)
{
PsCompliancePolicyBase psCompliancePolicyBase = this.CreatePolicyByScenario(dataObject as PolicyStorage);
if (psCompliancePolicyBase != null)
{
psCompliancePolicyBase.StorageBindings = Utils.LoadBindingStoragesByPolicy(base.DataSession, dataObject as PolicyStorage);
foreach (BindingStorage bindingStorage in psCompliancePolicyBase.StorageBindings)
{
base.WriteVerbose(Strings.VerboseLoadBindingStorageObjects(bindingStorage.ToString(), psCompliancePolicyBase.ToString()));
}
psCompliancePolicyBase.PopulateTaskProperties(this, base.DataSession as IConfigurationSession);
if (psCompliancePolicyBase.ReadOnly)
{
this.WriteWarning(Strings.WarningTaskPolicyIsTooAdvancedToRead(psCompliancePolicyBase.Name));
}
PolicySettingStatusHelpers.PopulatePolicyDistributionStatus(psCompliancePolicyBase, dataObject as PolicyStorage, base.DataSession, this, this.executionLogger);
base.WriteResult(psCompliancePolicyBase);
}
}
internal bool CalculatePolicyDistributionStatus(UnifiedPolicyStorageBase storage, Workload appliedWorkload, IEnumerable <UnifiedPolicySettingStatus> statuses, ref List <PolicyDistributionErrorDetails> distributionErrors, ref DateTime?lastStatusUpdateTime)
{
bool flag = false;
Dictionary <Workload, UnifiedPolicySettingStatus> dictionary = new Dictionary <Workload, UnifiedPolicySettingStatus>();
Guid policyVersion = storage.PolicyVersion;
foreach (UnifiedPolicySettingStatus unifiedPolicySettingStatus in statuses)
{
this.WriteVerbose(Strings.VerboseDumpStatusObject(unifiedPolicySettingStatus.Container, unifiedPolicySettingStatus.SettingType, storage.Guid.ToString(), storage.PolicyVersion.ToString(), ((UnifiedPolicyErrorCode)unifiedPolicySettingStatus.ErrorCode).ToString(), unifiedPolicySettingStatus.ObjectVersion.ToString()), false);
if (unifiedPolicySettingStatus.ObjectVersion == policyVersion)
{
Workload workloadFromString = PolicySettingStatusHelpers.GetWorkloadFromString(unifiedPolicySettingStatus.Container);
if (!dictionary.ContainsKey(workloadFromString))
{
dictionary.Add(workloadFromString, unifiedPolicySettingStatus);
}
}
}
IEnumerable <Workload> enumerable = Enum.GetValues(typeof(Workload)).Cast <Workload>();
foreach (Workload workload in enumerable)
{
if (workload != Workload.None && appliedWorkload.HasFlag(workload))
{
UnifiedPolicySettingStatus unifiedPolicySettingStatus2;
dictionary.TryGetValue(workload, out unifiedPolicySettingStatus2);
PolicyDistributionErrorDetails policyDistributionErrorDetails = this.CreatePolicyDistributionError(workload, storage, unifiedPolicySettingStatus2);
flag = (flag || (unifiedPolicySettingStatus2 == null && policyDistributionErrorDetails == null));
if (policyDistributionErrorDetails != null)
{
distributionErrors.Add(policyDistributionErrorDetails);
}
if (unifiedPolicySettingStatus2 != null && (lastStatusUpdateTime == null || lastStatusUpdateTime.Value < unifiedPolicySettingStatus2.WhenProcessedUTC))
{
lastStatusUpdateTime = new DateTime?(unifiedPolicySettingStatus2.WhenProcessedUTC);
}
}
}
return(flag);
}
protected override void InternalValidate()
{
Utils.ThrowIfNotRunInEOP();
Utils.ValidateNotForestWideOrganization(base.CurrentOrganizationId);
base.InternalValidate();
if (this.DataObject.IsModified(ADObjectSchema.Name) && Utils.LoadPolicyStorages(base.DataSession, this.DataObject.Scenario).Any((PolicyStorage p) => p.Name.Equals((string)this.DataObject[ADObjectSchema.Name], StringComparison.InvariantCultureIgnoreCase)))
{
throw new CompliancePolicyAlreadyExistsException((string)this.DataObject[ADObjectSchema.Name]);
}
if (base.Fields.IsModified("Enabled") && this.Enabled)
{
IEnumerable <RuleStorage> enumerable = Utils.LoadRuleStoragesByPolicy(base.DataSession, this.DataObject, Utils.GetRootId(base.DataSession));
foreach (RuleStorage ruleStorage in enumerable)
{
base.WriteVerbose(Strings.VerboseLoadRuleStorageObjectsForPolicy(ruleStorage.ToString(), this.DataObject.ToString()));
}
if (enumerable.Any((RuleStorage x) => !x.IsEnabled))
{
this.WriteWarning(Strings.WarningPolicyContainsDisabledRules(this.DataObject.Name));
}
}
if (!this.RetryDistribution)
{
this.ValidateBindingParameter();
return;
}
List <PolicyDistributionErrorDetails> source;
DateTime?dateTime;
PolicySettingStatusHelpers.GetPolicyDistributionStatus(this.DataObject, Utils.LoadBindingStoragesByPolicy(base.DataSession, this.DataObject), base.DataSession, out source, out dateTime);
if (!source.Any((PolicyDistributionErrorDetails error) => error.ResultCode != UnifiedPolicyErrorCode.PolicySyncTimeout))
{
this.WriteWarning(Strings.ErrorCompliancePolicyHasNoObjectsToRetry(this.DataObject.Name));
this.IsRetryDistributionAllowed = false;
return;
}
this.IsRetryDistributionAllowed = true;
}
private Dictionary <Workload, List <ChangeNotificationData> > GenerateSyncsForFailedRules(IEnumerable <Workload> workloads)
{
Dictionary <Workload, List <ChangeNotificationData> > dictionary = new Dictionary <Workload, List <ChangeNotificationData> >();
IList <RuleStorage> list = Utils.LoadRuleStoragesByPolicy(base.DataSession, this.DataObject, Utils.GetRootId(base.DataSession));
foreach (RuleStorage storageObject in list)
{
IEnumerable <UnifiedPolicySettingStatus> syncStatuses = PolicySettingStatusHelpers.LoadSyncStatuses(base.DataSession, Utils.GetUniversalIdentity(storageObject), typeof(RuleStorage).Name);
Dictionary <Workload, List <ChangeNotificationData> > dictionary2 = SetCompliancePolicyBase.GenerateSyncs(syncStatuses, workloads, base.DataSession, storageObject, ConfigurationObjectType.Rule);
foreach (Workload key in dictionary2.Keys)
{
if (dictionary.ContainsKey(key))
{
dictionary[key].AddRange(dictionary2[key]);
}
else
{
dictionary[key] = dictionary2[key];
}
}
}
return(dictionary);
}
private Dictionary <Workload, List <ChangeNotificationData> > GenerateSyncsForFailedPolicies(IEnumerable <Workload> workloads)
{
IEnumerable <UnifiedPolicySettingStatus> syncStatuses = PolicySettingStatusHelpers.LoadSyncStatuses(base.DataSession, Utils.GetUniversalIdentity(this.DataObject), typeof(PolicyStorage).Name);
return(SetCompliancePolicyBase.GenerateSyncs(syncStatuses, workloads, base.DataSession, this.DataObject, ConfigurationObjectType.Policy));
}
internal PolicyDistributionErrorDetails CreatePolicyDistributionError(Workload singleWorkload, UnifiedPolicyStorageBase storage, UnifiedPolicySettingStatus status)
{
bool flag = false;
UnifiedPolicyErrorCode errorCode = UnifiedPolicyErrorCode.Unknown;
string empty = string.Empty;
DateTime lastErrorTime = DateTime.UtcNow;
string additionalDiagnostics = string.Empty;
if (status == null)
{
if (storage is ScopeStorage)
{
flag = true;
errorCode = UnifiedPolicyErrorCode.PolicySyncTimeout;
empty = string.Empty;
lastErrorTime = DateTime.UtcNow;
additionalDiagnostics = (this.includeDiagnosticInfo ? Strings.DiagnoseMissingStatusForScope(storage.WhenChangedUTC.Value) : string.Empty);
}
else if (storage.WhenChangedUTC != null)
{
DateTime dateTime = storage.WhenChangedUTC.Value.Add(PolicySettingStatusHelpers.policySyncTimeoutInterval);
if (dateTime < DateTime.UtcNow)
{
flag = true;
errorCode = UnifiedPolicyErrorCode.PolicySyncTimeout;
empty = string.Empty;
lastErrorTime = dateTime;
additionalDiagnostics = (this.includeDiagnosticInfo ? Strings.DiagnosePendingStatusTimeout(storage.WhenChangedUTC.Value, PolicySettingStatusHelpers.policySyncTimeoutInterval) : string.Empty);
}
}
}
else if (status.ErrorCode != 0)
{
flag = true;
errorCode = (UnifiedPolicyErrorCode)status.ErrorCode;
empty = string.Empty;
lastErrorTime = status.WhenProcessedUTC;
additionalDiagnostics = (this.includeDiagnosticInfo ? status.AdditionalDiagnostics : string.Empty);
}
if (flag)
{
return(new PolicyDistributionErrorDetails(this.GetStorageObjectName(storage), storage.Guid, PolicySettingStatusHelpers.GetConfigurationObjectTypeFromString(storage.GetType().Name), singleWorkload, errorCode, empty, lastErrorTime, additionalDiagnostics));
}
return(null);
}
