private string GetStorageObjectName(UnifiedPolicyStorageBase storage)
{
if (storage is PolicyStorage)
{
return(Strings.DisplayPolicyName(storage.Name));
}
if (storage is RuleStorage)
{
return(Strings.DisplayRuleName(storage.Name));
}
if (storage is BindingStorage)
{
return(Strings.DisplayBindingName(storage.Workload.ToString()));
}
if (!(storage is ScopeStorage))
{
return(string.Empty);
}
BindingMetadata bindingMetadata = BindingMetadata.FromStorage(((ScopeStorage)storage).Scope);
if (bindingMetadata != null)
{
return(bindingMetadata.Name);
}
return(string.Empty);
}
internal static Guid GetUniversalIdentity(UnifiedPolicyStorageBase storageObject)
{
ArgumentValidator.ThrowIfNull("storageObject", storageObject);
if (!(storageObject.MasterIdentity == Guid.Empty))
{
return(storageObject.MasterIdentity);
}
return(storageObject.Guid);
}
internal static IList <ChangeNotificationData> NotifyChange(Task task, UnifiedPolicyStorageBase policyStorageObject, IEnumerable <UnifiedPolicyStorageBase> relatedStorageObjects, IConfigurationSession dataSession, ExecutionLog logger)
{
Exception exception = null;
string text = string.Empty;
string empty = string.Empty;
ChangeNotificationData changeNotificationData = IntuneCompliancePolicySyncNotificationClient.CreateChangeData(Workload.Intune, policyStorageObject);
List <ChangeNotificationData> list = new List <ChangeNotificationData>
{
changeNotificationData
};
List <SyncChangeInfo> list2 = new List <SyncChangeInfo>();
foreach (UnifiedPolicyStorageBase policyStorageObject2 in relatedStorageObjects)
{
list.Add(IntuneCompliancePolicySyncNotificationClient.CreateChangeData(Workload.Intune, policyStorageObject2));
}
foreach (ChangeNotificationData changeNotificationData2 in list)
{
SyncChangeInfo syncChangeInfo = changeNotificationData2.ShouldNotify ? changeNotificationData2.CreateSyncChangeInfo(true) : null;
if (syncChangeInfo == null)
{
logger.LogOneEntry(task.GetType().Name, string.Empty, ExecutionLog.EventType.Warning, string.Format("We did not notify workload '{0}' for changes to objectId {1}", Workload.Intune, changeNotificationData2.Id), exception);
}
list2.Add(syncChangeInfo);
}
try
{
if (list2.Any <SyncChangeInfo>())
{
text = IntuneCompliancePolicySyncNotificationClient.MakeNotificationCall(task, list2, changeNotificationData.UseFullSync, changeNotificationData.ShouldNotify, dataSession, logger);
}
}
catch (Exception ex)
{
text = Strings.ErrorMessageForNotificationFailure(Workload.Intune.ToString(), ex.Message);
exception = ex;
}
if (!string.IsNullOrEmpty(text))
{
task.WriteWarning(Strings.WarningNotifyWorkloadFailed(changeNotificationData.ToString()));
logger.LogOneEntry(task.GetType().Name, string.Empty, ExecutionLog.EventType.Warning, string.Format("We failed to notify workload '{0}' with error message '{1}'", Workload.Intune, text), exception);
MonitoringItemErrorPublisher.Instance.PublishEvent("UnifiedPolicySync.SendNotificationError", UnifiedPolicyConfiguration.GetInstance().GetOrganizationIdKey(dataSession), string.Format("Workload={0};Timestamp={1}", Workload.Intune, DateTime.UtcNow), exception);
}
else
{
logger.LogOneEntry(ExecutionLog.EventType.Verbose, task.GetType().Name, empty, "Notification '{0}' was sent to workload '{1}' with sync change info: '{2}'", new object[]
{
empty,
Workload.Intune,
list2.First <SyncChangeInfo>().ToString()
});
}
AggregatedNotificationClients.SetNotificationResults(list, text);
return(list);
}
public static ConfigurationObjectType GetConfigurationObjectType(UnifiedPolicyStorageBase policyStorageObject)
{
ArgumentValidator.ThrowIfNull("policyStorageObject", policyStorageObject);
PolicyConfigConverterBase policyConfigConverterBase = PolicyConfigConverterTable.policyConverters.FirstOrDefault((PolicyConfigConverterBase entry) => policyStorageObject.GetType().Equals(entry.StorageType));
if (policyConfigConverterBase == null)
{
throw new InvalidOperationException(string.Format("Type {0} has no converter.", policyStorageObject.GetType()));
}
return(policyConfigConverterBase.ConfigurationObjectType);
}
private static ChangeNotificationData CreateChangeData(Workload workload, UnifiedPolicyStorageBase policyStorageObject)
{
Guid parentId = Guid.Empty;
ConfigurationObjectType objectType = (policyStorageObject is ScopeStorage) ? ConfigurationObjectType.Scope : PolicyConfigConverterTable.GetConfigurationObjectType(policyStorageObject);
if (policyStorageObject is RuleStorage)
{
parentId = ((RuleStorage)policyStorageObject).ParentPolicyId;
}
else if (policyStorageObject is BindingStorage)
{
parentId = ((BindingStorage)policyStorageObject).PolicyId;
}
return(new ChangeNotificationData(policyStorageObject.Id.ObjectGuid, parentId, objectType, (policyStorageObject.ObjectState == ObjectState.Deleted) ? ChangeType.Delete : ChangeType.Update, workload, PolicyVersion.Create(policyStorageObject.PolicyVersion), UnifiedPolicyErrorCode.Unknown, ""));
}
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);
}
public override UnifiedPolicyStorageBase ConvertToStorage(ExPolicyConfigProvider provider, PolicyConfigBase policyConfig)
{
ArgumentValidator.ThrowIfNull("provider", provider);
ArgumentValidator.ThrowIfNull("storageObject", policyConfig);
UnifiedPolicyStorageBase unifiedPolicyStorageBase = policyConfig.RawObject as TPolicyStorage;
if (unifiedPolicyStorageBase == null)
{
unifiedPolicyStorageBase = Activator.CreateInstance <TPolicyStorage>();
unifiedPolicyStorageBase.OrganizationId = provider.GetOrganizationId();
if (ExPolicyConfigProvider.IsFFOOnline)
{
unifiedPolicyStorageBase.SetId(new ADObjectId(PolicyStorage.PoliciesContainer.GetChildId(policyConfig.Name).DistinguishedName, policyConfig.Identity));
}
else
{
PolicyRuleConfig policyRuleConfig = policyConfig as PolicyRuleConfig;
ADObjectId policyConfigContainer = provider.GetPolicyConfigContainer((policyRuleConfig == null) ? null : new Guid?(policyRuleConfig.PolicyDefinitionConfigId));
unifiedPolicyStorageBase.SetId(policyConfigContainer.GetChildId(policyConfig.Name));
unifiedPolicyStorageBase.MasterIdentity = policyConfig.Identity;
}
}
else if ((ExPolicyConfigProvider.IsFFOOnline && policyConfig.Identity != unifiedPolicyStorageBase.Guid) || (!ExPolicyConfigProvider.IsFFOOnline && policyConfig.Identity != unifiedPolicyStorageBase.MasterIdentity))
{
throw new PolicyConfigProviderPermanentException(ServerStrings.ErrorCouldNotUpdateMasterIdentityProperty(policyConfig.Name));
}
if (policyConfig.Version != null)
{
unifiedPolicyStorageBase.PolicyVersion = policyConfig.Version.InternalStorage;
}
unifiedPolicyStorageBase.Name = policyConfig.Name;
if (unifiedPolicyStorageBase.Workload != policyConfig.Workload)
{
unifiedPolicyStorageBase.Workload = policyConfig.Workload;
}
this.copyPropertiesToStorageDelegate((TPolicyConfig)((object)policyConfig), (TPolicyStorage)((object)unifiedPolicyStorageBase));
return(unifiedPolicyStorageBase);
}
public static IList <ChangeNotificationData> NotifyChanges(Task task, IConfigurationSession configurationSession, UnifiedPolicyStorageBase policyStorageObject, ExecutionLog logger, Type client, IEnumerable <UnifiedPolicyStorageBase> bindingStorageObjects = null, IEnumerable <UnifiedPolicyStorageBase> ruleStorageObjects = null)
{
ArgumentValidator.ThrowIfNull("task", task);
ArgumentValidator.ThrowIfNull("configurationSession", configurationSession);
ArgumentValidator.ThrowIfNull("policyStorageObject", policyStorageObject);
if (!ExPolicyConfigProvider.IsFFOOnline)
{
return(new List <ChangeNotificationData>());
}
List <UnifiedPolicyStorageBase> list = new List <UnifiedPolicyStorageBase>
{
policyStorageObject
};
if (bindingStorageObjects != null)
{
list.AddRange(bindingStorageObjects);
}
if (ruleStorageObjects != null)
{
list.AddRange(ruleStorageObjects);
}
Dictionary <Workload, List <ChangeNotificationData> > dictionary = AggregatedNotificationClients.NotifyChanges(task, configurationSession, list, logger, client);
List <ChangeNotificationData> list2 = new List <ChangeNotificationData>();
foreach (KeyValuePair <Workload, List <ChangeNotificationData> > keyValuePair in dictionary)
{
list2.AddRange(keyValuePair.Value);
}
return(list2);
}
public abstract PolicyConfigBase ConvertFromStorage(ExPolicyConfigProvider provider, UnifiedPolicyStorageBase storageObject);
public override PolicyConfigBase ConvertFromStorage(ExPolicyConfigProvider provider, UnifiedPolicyStorageBase storageObject)
{
ArgumentValidator.ThrowIfNull("provider", provider);
ArgumentValidator.ThrowIfNull("storageObject", storageObject);
PolicyConfigBase policyConfigBase = provider.NewBlankConfigInstance <TPolicyConfig>();
if (!provider.ReadOnly)
{
policyConfigBase.RawObject = storageObject;
}
Guid identity = storageObject.Guid;
if (!ExPolicyConfigProvider.IsFFOOnline)
{
identity = storageObject.MasterIdentity;
}
policyConfigBase.Identity = identity;
policyConfigBase.Name = storageObject.Name;
policyConfigBase.Version = PolicyVersion.Create(storageObject.PolicyVersion);
policyConfigBase.Workload = storageObject.Workload;
policyConfigBase.WhenChangedUTC = storageObject.WhenChangedUTC;
policyConfigBase.WhenCreatedUTC = storageObject.WhenChangedUTC;
this.copyPropertiesToPolicyConfigDelegate((TPolicyStorage)((object)storageObject), (TPolicyConfig)((object)policyConfigBase));
policyConfigBase.ResetChangeTracking();
return(policyConfigBase);
}
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);
}
private static bool HasDistributionFailed(UnifiedPolicyStorageBase storageObject, UnifiedPolicySettingStatus status)
{
return(status.ObjectVersion == storageObject.PolicyVersion && status.ErrorCode != 0);
}
private static Dictionary <Workload, List <ChangeNotificationData> > GenerateSyncs(IEnumerable <UnifiedPolicySettingStatus> syncStatuses, IEnumerable <Workload> workloads, IConfigDataProvider dataSession, UnifiedPolicyStorageBase storageObject, ConfigurationObjectType objectType)
{
Dictionary <Workload, List <ChangeNotificationData> > dictionary = new Dictionary <Workload, List <ChangeNotificationData> >();
if (syncStatuses.Any((UnifiedPolicySettingStatus s) => SetCompliancePolicyBase.HasDistributionFailed(storageObject, s)))
{
storageObject.PolicyVersion = CombGuidGenerator.NewGuid();
dataSession.Save(storageObject);
foreach (Workload workload in workloads)
{
dictionary[workload] = new List <ChangeNotificationData>
{
AggregatedNotificationClients.CreateChangeData(workload, storageObject)
};
}
}
return(dictionary);
}
internal static IList <BindingStorage> LoadBindingStoragesByPolicy(IConfigDataProvider dataSession, UnifiedPolicyStorageBase policyStorage)
{
ArgumentValidator.ThrowIfNull("dataSession", dataSession);
ArgumentValidator.ThrowIfNull("policyStorage", policyStorage);
Guid universalIdentity = Utils.GetUniversalIdentity(policyStorage);
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ExPolicyConfigProvider.IsFFOOnline ? UnifiedPolicyStorageBaseSchema.ContainerProp : BindingStorageSchema.PolicyId, universalIdentity);
return(dataSession.Find <BindingStorage>(filter, null, false, null).Cast <BindingStorage>().ToList <BindingStorage>());
}
