protected override void InternalValidate() { if (base.OptionalIdentityData != null) { base.OptionalIdentityData.ConfigurationContainerRdn = ClassificationDefinitionConstants.ClassificationDefinitionsRdn; } base.InternalValidate(); if (base.HasErrors) { return; } ExAssert.RetailAssert(base.DataObject != null, "DataObject must not be null at this point as it should have been resolved by the base class."); if (!ClassificationDefinitionUtils.IsAdObjectAClassificationRuleCollection(base.DataObject)) { base.WriteError(new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject), ErrorCategory.InvalidOperation, null); } if (VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null).Global.MultiTenancy.Enabled&& OrganizationId.ForestWideOrgId.Equals(((IDirectorySession)base.DataSession).SessionSettings.CurrentOrganizationId) && !this.Identity.IsHierarchical) { base.WriteError(new ClassificationRuleCollectionIllegalScopeException(Strings.ClassificationRuleCollectionIllegalScopedRemoveOperation), ErrorCategory.InvalidOperation, null); } SortedSet <string> sortedSet = new SortedSet <string>(); IList <string> allRulesInUse = this.GetAllRulesInUse(base.DataObject, sortedSet); if (allRulesInUse.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionSharingViolationRemoveOperationVerbose(this.Identity.ToString(), string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, allRulesInUse), string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, sortedSet)); ClassificationRuleCollectionSharingViolationException exception = ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionSharingViolationException, IList <string> >(new ClassificationRuleCollectionSharingViolationException(message), allRulesInUse); base.WriteError(exception, ErrorCategory.InvalidOperation, null); } }
protected override IConfigurable PrepareDataObject() { TaskLogger.LogEnter(); TransportRule transportRule; if (this.InstallDefaultCollection && this.existingRulePack != null) { transportRule = this.existingRulePack; } else { transportRule = (TransportRule)base.PrepareDataObject(); transportRule.SetId(ClassificationDefinitionUtils.GetClassificationRuleCollectionContainerId(base.DataSession).GetChildId(this.rulePackageIdentifier)); transportRule.OrganizationId = base.CurrentOrganizationId; } byte[] replicationSignature = null; try { replicationSignature = ClassificationRuleCollectionValidationUtils.PackAndValidateCompressedRulePackage(this.FileData, this.validationContext); } catch (LocalizedException exception) { base.WriteError(exception, ErrorCategory.InvalidData, null); } transportRule.AdminDisplayName = this.defaultName; transportRule.Xml = null; transportRule.ReplicationSignature = replicationSignature; TaskLogger.LogExit(); return(transportRule); }
private static IEnumerable <QueryMatchResult> ExecuteQueryMatching(IEnumerable <QueryMatchResult> mainQuery, Func <Dictionary <string, QueryMatchResult>, IEnumerable <KeyValuePair <string, XElement> > > queryForResolvingRuleAssociation, Action <Dictionary <string, QueryMatchResult>, KeyValuePair <string, XElement> > setAssociationData, Func <string, LocalizedString> createErrorMessageForMissingAssociation) { Dictionary <string, QueryMatchResult> queryMatchResults; try { queryMatchResults = mainQuery.ToDictionary((QueryMatchResult queryMatchResult) => queryMatchResult.MatchingRuleId, ClassificationDefinitionConstants.RuleIdComparer); if (queryMatchResults.Count == 0) { return(Enumerable.Empty <QueryMatchResult>()); } Dictionary <string, XElement> matchingAssociatedElements = queryForResolvingRuleAssociation(queryMatchResults).ToDictionary((KeyValuePair <string, XElement> ruleIdRefAndResourceElement) => ruleIdRefAndResourceElement.Key, (KeyValuePair <string, XElement> ruleIdRefAndResourceElement) => ruleIdRefAndResourceElement.Value, ClassificationDefinitionConstants.RuleIdComparer); if (queryMatchResults.Count != matchingAssociatedElements.Count) { List <string> list = (from ruleId in queryMatchResults.Keys where !matchingAssociatedElements.ContainsKey(ruleId) select ruleId).ToList <string>(); LocalizedString value = createErrorMessageForMissingAssociation(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list)); throw ClassificationDefinitionUtils.PopulateExceptionSource <XmlException, List <string> >(new XmlException(value), list); } Parallel.ForEach <KeyValuePair <string, XElement> >(matchingAssociatedElements, delegate(KeyValuePair <string, XElement> matchingAssociation) { setAssociationData(queryMatchResults, matchingAssociation); }); } catch (AggregateException ex) { throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, ex.Flatten()); } return(queryMatchResults.Values); }
private XDocument TryGetRuleCollectionDocumentFromTransportRule(TransportRule transportRule) { XDocument result = null; try { result = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule); } catch (InvalidOperationException) { ClassificationDefinitionsDiagnosticsReporter.Instance.WriteInvalidObjectInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName); } catch (ArgumentException underlyingException) { ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName, underlyingException); } catch (AggregateException ex) { ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName, ex.Flatten()); } catch (XmlException ex2) { ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName, new AggregateException(new Exception[] { ex2 }).Flatten()); } return(result); }
private bool TryParseADRulePack(TransportRule adRulePack, out XDocument rulePackXDocument) { ArgumentValidator.ThrowIfNull("adRulePack", adRulePack); rulePackXDocument = null; Exception ex = null; try { rulePackXDocument = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(adRulePack); } catch (ArgumentException ex2) { ex = ex2; } catch (AggregateException ex3) { ex = ex3; } catch (XmlException ex4) { ex = ex4; } if (ex != null) { this.task.WriteWarning(Strings.WarningInvalidRuleCollectionADObject(adRulePack.Identity.ToString(), ex.Message)); } return(rulePackXDocument != null); }
protected virtual void Initialize() { ExAssert.RetailAssert(this.StoredRuleCollection != null, "The stored transport rule instance for classification rule collection presentation object must not be null"); XDocument ruleCollectionDocumentFromTransportRule = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(this.StoredRuleCollection); this.Initialize(ruleCollectionDocumentFromTransportRule); }
protected override void WriteResult(IConfigurable dataObject) { TaskLogger.LogEnter(); TransportRule transportRule = dataObject as TransportRule; if (transportRule != null) { XDocument ruleCollectionDocumentFromTransportRule = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule); if (ruleCollectionDocumentFromTransportRule != null) { string[] ruleIdQueries = new string[] { ((DataClassificationObjectId)this.implementation.DataClassificationPresentationObject.Identity).Name }; List <QueryMatchResult> list = XmlProcessingUtils.GetMatchingRulesById(ruleCollectionDocumentFromTransportRule, ruleIdQueries).ToList <QueryMatchResult>(); if (list.Count > 0) { ClassificationRuleCollectionPresentationObject rulePackPresentationObject = ClassificationRuleCollectionPresentationObject.Create(transportRule); DataClassificationPresentationObject result = DataClassificationPresentationObject.Create(list[0].MatchingRuleId, list[0].MatchingRuleXElement, list[0].MatchingResourceXElement, rulePackPresentationObject); this.WriteResult(result); } } } else { base.WriteResult(dataObject); } TaskLogger.LogExit(); }
internal static XDocument CreateRuleCollectionDocumentFromTemplate(string rulePackId, string organizationId, string organizationName) { ArgumentValidator.ThrowIfNullOrEmpty("rulePackId", rulePackId); ArgumentValidator.ThrowIfNullOrEmpty("organizationId", organizationId); ArgumentValidator.ThrowIfNullOrEmpty("organizationName", organizationName); string text = string.Empty; using (Stream stream = ClassificationDefinitionUtils.LoadStreamFromEmbeddedResource("FingerprintRulePackTemplate.xml")) { using (StreamReader streamReader = new StreamReader(stream)) { text = streamReader.ReadToEnd(); } } if (string.IsNullOrEmpty(text)) { throw new FingerprintRulePackTemplateCorruptedException("FingerprintRulePackTemplate.xml"); } XDocument xdocument = XDocument.Parse(text); XElement xelement = xdocument.Root.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("RulePack")); xelement.SetAttributeValue("id", rulePackId); XElement xelement2 = xelement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Publisher")); xelement2.SetAttributeValue("id", organizationId); foreach (XElement xelement3 in xelement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("PublisherName"))) { xelement3.SetValue(organizationName); } XmlProcessingUtils.SetRulePackVersionFromAssemblyFileVersion(xdocument); return(xdocument); }
private static bool HandleClassificationEngineValidatorException(Exception exception, OrganizationId currentOrganizationId) { COMException ex = exception as COMException; if (ex == null) { return(false); } int errorCode = ex.ErrorCode; if (errorCode == -2147220981) { throw new ClassificationRuleCollectionValidationException(Strings.ClassificationRuleCollectionEngineValidationFailure, ex); } if (errorCode == -2147220978) { List <string> list = (List <string>)ex.Data[ClassificationEngineValidator.BadRegexesKey]; string names = string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionRegexValidationException, List <string> >(new ClassificationRuleCollectionRegexValidationException(Strings.ClassificationRuleCollectionRegexValidationFailure(names), ex), list); } int errorCode2 = ex.ErrorCode; ClassificationDefinitionsDiagnosticsReporter.Instance.WriteClassificationEngineUnexpectedFailureInValidation(0, currentOrganizationId, errorCode2); throw new ClassificationRuleCollectionInternalValidationException(errorCode2, ex); }
public override string ToString() { if (!string.IsNullOrEmpty(this.organizationHierarchy)) { return(ClassificationDefinitionUtils.CreateHierarchicalIdentityString(this.organizationHierarchy, this.ruleId)); } return(this.ruleId); }
private static XmlSchema LoadSchemaFromEmbeddedResource(string schemaName) { XmlSchema result; using (Stream stream = ClassificationDefinitionUtils.LoadStreamFromEmbeddedResource(schemaName)) { result = XmlSchema.Read(stream, null); } return(result); }
internal static IEnumerable <DataClassificationPresentationObject> FilterHigherVersionRules(IEnumerable <DataClassificationPresentationObject> unfilteredRules) { if (unfilteredRules == null) { throw new ArgumentNullException("unfilteredRules"); } return(from rule in unfilteredRules where rule.MinEngineVersion <= ClassificationDefinitionUtils.GetCurrentAssemblyVersion() select rule); }
internal static string GetLocalMachineMceConfigDirectory(bool shouldHandleException = false) { string mceForAdminToolInstallBase = ClassificationDefinitionUtils.GetMceForAdminToolInstallBase(shouldHandleException); if (mceForAdminToolInstallBase != null) { return(Path.Combine(mceForAdminToolInstallBase, ClassificationDefinitionConstants.OnDiskMceConfigurationDirName)); } return(null); }
internal static string GetMceExecutablePath(bool shouldHandleException = false) { string mceForAdminToolInstallBase = ClassificationDefinitionUtils.GetMceForAdminToolInstallBase(shouldHandleException); if (mceForAdminToolInstallBase != null) { return(Path.Combine(mceForAdminToolInstallBase, ClassificationDefinitionConstants.MceExecutableFileName)); } return(null); }
private static string ReadRegexTestTemplate() { string result; using (Stream stream = ClassificationDefinitionUtils.LoadStreamFromEmbeddedResource("RegexTestTemplate.xml")) { StreamReader streamReader = new StreamReader(stream); result = streamReader.ReadToEnd(); } return(result); }
private static void ValidateKeywordProcessorsPerformance(XDocument rulePackXDocument, int keywordLengthLimit) { List <string> list = (from keywordProcessorDefinition in KeywordProcessorsValidator.GetKeywordProcessorsTerms(rulePackXDocument).AsParallel <KeyValuePair <string, List <string> > >() where keywordProcessorDefinition.Value.Any((string term) => term.Length > keywordLengthLimit) select keywordProcessorDefinition.Key).ToList <string>(); if (list.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionKeywordTooLong(keywordLengthLimit, string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionKeywordValidationException, List <string> >(new ClassificationRuleCollectionKeywordValidationException(message), list); } }
private static void ValidateRuleComplexity(IEnumerable <KeyValuePair <string, RuleComplexityData> > rulePackComplexityData, IDataClassificationComplexityValidator complexityValidator) { List <string> list = (from ruleComplexityData in rulePackComplexityData where complexityValidator.IsRuleComplexityLimitExceeded(ruleComplexityData.Value) select ruleComplexityData.Key).ToList <string>(); if (list.Count > 0) { LocalizedString message = complexityValidator.CreateExceptionMessage(list); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionComplexityValidationException, List <string> >(new ClassificationRuleCollectionComplexityValidationException(message), list); } }
public override string ToString() { string result; if (this.dataClassificationIdentityFilter != null) { result = (base.IsHierarchical ? ClassificationDefinitionUtils.CreateHierarchicalIdentityString(base.OrganizationName, this.dataClassificationIdentityFilter) : this.dataClassificationIdentityFilter); } else { result = base.ToString(); } return(result); }
private static void ValidateDefaultValueLangCodesConsistency(XDocument rulePackXDocument) { List <string> list = (from ruleResourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>() let defaultNameLangCode = ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")).Single((XElement nameElement) => nameElement.Attribute("default") != null && (bool)nameElement.Attribute("default")).Attribute("langcode").Value let defaultDescriptionLangCode = ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")).Single((XElement descriptionElement) => descriptionElement.Attribute("default") != null && (bool)descriptionElement.Attribute("default")).Attribute("langcode").Value where !new CultureInfo(defaultNameLangCode).Equals(new CultureInfo(defaultDescriptionLangCode)) select ruleResourceElement.Attribute("idRef").Value).ToList <string>(); if (list.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionInconsistentDefaultInRuleResource(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionLocalizationInfoValidationException, List <string> >(new ClassificationRuleCollectionLocalizationInfoValidationException(message), list); } }
private static void ValidateUpdatedOobRulePackIsSuperSet(IEnumerable <string> existingOobRuleIds, IEnumerable <string> updatedOobRuleIds) { if (existingOobRuleIds == null) { return; } List <string> list = existingOobRuleIds.Except(updatedOobRuleIds, ClassificationDefinitionConstants.RuleIdComparer).ToList <string>(); if (list.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionOobRulesRemoved(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionIdentifierValidationException, List <string> >(new ClassificationRuleCollectionIdentifierValidationException(message), list); } }
internal static IEnumerable <Tuple <TransportRule, XDocument> > AggregateOobAndCustomClassificationDefinitions(OrganizationId organizationId, IConfigurationSession openedDataSession = null, Func <TransportRule, bool> inclusiveFilter = null, QueryFilter additionalFilter = null, IClassificationDefinitionsDataReader dataReader = null, IClassificationDefinitionsDiagnosticsReporter classificationDefinitionsDiagnosticsReporter = null) { IClassificationDefinitionsDataReader dataReaderToUse = dataReader ?? ClassificationDefinitionsDataReader.DefaultInstance; IClassificationDefinitionsDiagnosticsReporter classificationDefinitionsDiagnosticsReporterToUse = classificationDefinitionsDiagnosticsReporter ?? ClassificationDefinitionsDiagnosticsReporter.Instance; foreach (TransportRule transportRule in dataReaderToUse.GetAllClassificationRuleCollection(organizationId, openedDataSession, additionalFilter)) { if (inclusiveFilter != null) { if (!inclusiveFilter(transportRule)) { continue; } } XDocument rulePackXDoc; try { rulePackXDoc = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule); } catch (InvalidOperationException) { classificationDefinitionsDiagnosticsReporterToUse.WriteInvalidObjectInformation(0, organizationId, transportRule.DistinguishedName); continue; } catch (ArgumentException underlyingException) { classificationDefinitionsDiagnosticsReporterToUse.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, transportRule.DistinguishedName, underlyingException); continue; } catch (AggregateException ex) { classificationDefinitionsDiagnosticsReporterToUse.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, transportRule.DistinguishedName, ex.Flatten()); continue; } catch (XmlException ex2) { classificationDefinitionsDiagnosticsReporterToUse.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, transportRule.DistinguishedName, new AggregateException(new Exception[] { ex2 }).Flatten()); continue; } yield return(new Tuple <TransportRule, XDocument>(transportRule, rulePackXDoc)); } yield break; }
private XDocument DeserializeMceConfig() { XmlReaderSettings xmlReaderSettings = ClassificationDefinitionUtils.CreateSafeXmlReaderSettings(); xmlReaderSettings.IgnoreComments = true; xmlReaderSettings.ValidationType = ValidationType.None; XDocument result; using (Stream stream = this.OpenSourceStream()) { using (XmlReader xmlReader = XmlReader.Create(stream, xmlReaderSettings)) { result = XDocument.Load(xmlReader); } } return(result); }
protected override void InternalValidate() { TaskLogger.LogEnter(); if (this.InstallDefaultCollection) { using (Stream stream = ClassificationDefinitionUtils.LoadStreamFromEmbeddedResource("DefaultClassificationDefinitions.xml")) { byte[] array = new byte[stream.Length]; stream.Read(array, 0, Convert.ToInt32(stream.Length)); this.FileData = array; goto IL_71; } } if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled) { this.ValidateOperationScope(); } IL_71: byte[] rulePackageRawData = null; byte[] array2 = null; try { this.isEncrypted = RulePackageDecrypter.DecryptRulePackage(this.FileData, out rulePackageRawData, out array2); } catch (Exception innerException) { base.WriteError(new ClassificationRuleCollectionDecryptionException(innerException), ErrorCategory.InvalidData, null); } if (this.isEncrypted) { ExAssert.RetailAssert(!this.InstallDefaultCollection, "Installation of encrypted default OOB rule pack is not supported due to versioning!"); string text = this.ValidateAndReadMetadata(rulePackageRawData); this.FileData = ((text == null) ? null : array2); } else { string text2 = this.ValidateAndReadMetadata(this.FileData); this.FileData = ((text2 == null) ? null : Encoding.Unicode.GetBytes(text2)); } if (this.FileData != null) { base.InternalValidate(); } TaskLogger.LogExit(); }
protected override void WriteResult <T>(IEnumerable <T> dataObjects) { TaskLogger.LogEnter(); if (dataObjects is IEnumerable <DataClassificationPresentationObject> ) { IEnumerable <DataClassificationPresentationObject> enumerable = ClassificationDefinitionUtils.FilterHigherVersionRules((IEnumerable <DataClassificationPresentationObject>)dataObjects); if (this.Identity != null) { enumerable = this.Identity.FilterResults(enumerable); } base.WriteResult <DataClassificationPresentationObject>(enumerable); } else { base.WriteResult <T>(dataObjects); } TaskLogger.LogExit(); }
private static void ValidateDefaultValueCount(XDocument rulePackXDocument) { List <string> list = (from ruleResourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>().Where(delegate(XElement ruleResourceElement) { if (ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")).Count((XElement nameElement) => nameElement.Attribute("default") != null && (bool)nameElement.Attribute("default")) == 1) { return(ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")).Count((XElement descriptionElement) => descriptionElement.Attribute("default") != null && (bool)descriptionElement.Attribute("default")) != 1); } return(true); }) select ruleResourceElement.Attribute("idRef").Value).ToList <string>(); if (list.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionIncorrectNumberOfDefaultInRuleResources(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionLocalizationInfoValidationException, List <string> >(new ClassificationRuleCollectionLocalizationInfoValidationException(message), list); } }
internal static void ValidateRulePackage(XDocument rulePackXDoc, string rulePackContents) { string mceExecutablePath = ClassificationDefinitionUtils.GetMceExecutablePath(true); if (mceExecutablePath == null || !File.Exists(mceExecutablePath)) { throw new COMException("Unable to locate the Microsoft Classification Engine", -2147287038); } try { using (ActivationContextActivator.FromInternalManifest(mceExecutablePath, Path.GetDirectoryName(mceExecutablePath))) { MicrosoftClassificationEngine microsoftClassificationEngine = new MicrosoftClassificationEngine(); PropertyBag propertyBag = new PropertyBag(); RulePackageLoader rulePackageLoader = new RulePackageLoader(); microsoftClassificationEngine.Init(propertyBag, rulePackageLoader); RULE_PACKAGE_DETAILS rule_PACKAGE_DETAILS = default(RULE_PACKAGE_DETAILS); rule_PACKAGE_DETAILS.RulePackageSetID = "not-used-here"; rule_PACKAGE_DETAILS.RulePackageID = "test-rule-pack"; rule_PACKAGE_DETAILS.RuleIDs = null; RULE_PACKAGE_DETAILS rule_PACKAGE_DETAILS2 = rule_PACKAGE_DETAILS; rulePackageLoader.SetRulePackage(rule_PACKAGE_DETAILS2.RulePackageID, rulePackContents); try { MicrosoftClassificationEngine microsoftClassificationEngine2 = microsoftClassificationEngine; RULE_PACKAGE_DETAILS rule_PACKAGE_DETAILS3 = rule_PACKAGE_DETAILS2; microsoftClassificationEngine2.GetClassificationDefinitions(ref rule_PACKAGE_DETAILS3); } catch (COMException ex) { if (ex.ErrorCode == -2147220978) { List <string> value = ClassificationEngineValidator.GetInvalidRegexes(microsoftClassificationEngine, rulePackageLoader, rulePackXDoc).ToList <string>(); ex.Data[ClassificationEngineValidator.BadRegexesKey] = value; } throw ex; } } } catch (ActivationContextActivatorException) { throw new COMException("Unable to instantiate the Microsoft Classification Engine", -2147164127); } }
protected override IConfigurable PrepareDataObject() { TaskLogger.LogEnter(); TransportRule transportRule = null; try { transportRule = this.TryGetDataObject(); XDocument rulePackXDoc; if (transportRule == null) { transportRule = (TransportRule)base.PrepareDataObject(); string rawIdentity = this.ClassificationRuleCollectionIdentity.RawIdentity; transportRule.SetId(ClassificationDefinitionUtils.GetClassificationRuleCollectionContainerId(base.DataSession).GetChildId(rawIdentity)); transportRule.OrganizationId = base.CurrentOrganizationId; transportRule.Xml = null; string organizationId; string name; if (base.CurrentOrganizationId != null && base.CurrentOrganizationId.OrganizationalUnit != null) { organizationId = base.CurrentOrganizationId.OrganizationalUnit.ObjectGuid.ToString(); name = base.CurrentOrganizationId.OrganizationalUnit.Name; } else { organizationId = base.CurrentOrgContainerId.ObjectGuid.ToString(); name = base.CurrentOrgContainerId.DomainId.Name; } rulePackXDoc = ClassificationDefinitionUtils.CreateRuleCollectionDocumentFromTemplate(rawIdentity, organizationId, name); } else { rulePackXDoc = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule); } this.implementation = new DataClassificationCmdletsImplementation(this); this.implementation.Initialize(transportRule, rulePackXDoc); } catch (LocalizedException exception) { base.WriteError(exception, ErrorCategory.InvalidOperation, null); } TaskLogger.LogExit(); return(transportRule); }
private void ValidateProcessorIdAndMatchReferences(XDocument rulePackXDocument) { ExAssert.RetailAssert(rulePackXDocument != null, "Extra rule package validation must take place after XML schema validation passed!"); IDictionary <string, ExchangeBuild> textProcessorsFromTextProcessorGrouping = TextProcessorUtils.GetTextProcessorsFromTextProcessorGrouping(this.cannedOobTextProcessorsGroupedByType, null); ICollection <string> keys = textProcessorsFromTextProcessorGrouping.Keys; Dictionary <TextProcessorType, TextProcessorGrouping> textProcessorsGroupings = TextProcessorUtils.GetRulePackScopedTextProcessorsGroupedByType(rulePackXDocument).ToDictionary((TextProcessorGrouping textProcessorGroup) => textProcessorGroup.Key); IDictionary <string, ExchangeBuild> textProcessorsFromTextProcessorGrouping2 = TextProcessorUtils.GetTextProcessorsFromTextProcessorGrouping(textProcessorsGroupings, null); ICollection <string> keys2 = textProcessorsFromTextProcessorGrouping2.Keys; List <string> list = keys.AsParallel <string>().Union(keys2.AsParallel <string>(), ClassificationDefinitionConstants.TextProcessorIdComparer).ToList <string>(); if (list.Count != keys.Count + keys2.Count) { List <string> list2 = keys.AsParallel <string>().Intersect(keys2.AsParallel <string>(), ClassificationDefinitionConstants.TextProcessorIdComparer).ToList <string>(); LocalizedString message = Strings.ClassificationRuleCollectionReservedProcessorIdViolation(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list2)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionIdentifierValidationException, List <string> >(new ClassificationRuleCollectionIdentifierValidationException(message), list2); } HashSet <string> hashSet = new HashSet <string>(ClassificationDefinitionConstants.TextProcessorIdComparer); IEnumerable <KeyValuePair <string, ExchangeBuild> > textProcessorReferences = TextProcessorUtils.GetTextProcessorReferences(rulePackXDocument.Root); foreach (KeyValuePair <string, ExchangeBuild> keyValuePair in textProcessorReferences) { ExchangeBuild objB; if ((!textProcessorsFromTextProcessorGrouping2.TryGetValue(keyValuePair.Key, out objB) && !textProcessorsFromTextProcessorGrouping.TryGetValue(keyValuePair.Key, out objB)) || !(keyValuePair.Value >= objB)) { hashSet.Add(keyValuePair.Key); } } IDictionary <string, ExchangeBuild> textProcessorsFromTextProcessorGrouping3 = TextProcessorUtils.GetTextProcessorsFromTextProcessorGrouping(this.cannedOobTextProcessorsGroupedByType, (TextProcessorType textProcessorType) => textProcessorType == TextProcessorType.Fingerprint); IDictionary <string, ExchangeBuild> textProcessorsFromTextProcessorGrouping4 = TextProcessorUtils.GetTextProcessorsFromTextProcessorGrouping(textProcessorsGroupings, (TextProcessorType textProcessorType) => textProcessorType == TextProcessorType.Fingerprint); IEnumerable <KeyValuePair <string, ExchangeBuild> > textProcessorReferences2 = TextProcessorUtils.GetTextProcessorReferences(rulePackXDocument.Root, ClassificationDefinitionConstants.MceIdMatchElementNames); foreach (KeyValuePair <string, ExchangeBuild> keyValuePair2 in textProcessorReferences2) { if (textProcessorsFromTextProcessorGrouping4.ContainsKey(keyValuePair2.Key) || textProcessorsFromTextProcessorGrouping3.ContainsKey(keyValuePair2.Key)) { hashSet.Add(keyValuePair2.Key); } } if (hashSet.Count > 0) { LocalizedString message2 = Strings.ClassificationRuleCollectionInvalidProcessorReferenceViolation(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, hashSet)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionProcessorReferenceValidationException, HashSet <string> >(new ClassificationRuleCollectionProcessorReferenceValidationException(message2), hashSet); } }
private string ValidateAgainstBusinessRulesAndReadMetadata(XDocument rulePackXDoc) { ExAssert.RetailAssert(this.rulePackageIdentifier != null && this.DataObject != null, "Business rules validation in Set-ClassificationRuleCollection must take place after the DataObject resolution"); string result = string.Empty; try { this.validationContext = new ValidationContext(ClassificationRuleCollectionOperationType.Update, base.CurrentOrganizationId, VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && this.OutOfBoxCollection, false, (IConfigurationSession)base.DataSession, this.DataObject, null, null); result = ClassificationRuleCollectionValidationUtils.ValidateRulePackageContents(this.validationContext, rulePackXDoc); ClassificationRuleCollectionLocalizableDetails classificationRuleCollectionLocalizableDetails = XmlProcessingUtils.ReadDefaultRulePackageMetadata(rulePackXDoc); this.defaultName = classificationRuleCollectionLocalizableDetails.Name; ClassificationRuleCollectionLocalizableDetails classificationRuleCollectionLocalizableDetails2 = XmlProcessingUtils.ReadRulePackageMetadata(rulePackXDoc, CultureInfo.CurrentCulture); this.localizedName = ((classificationRuleCollectionLocalizableDetails2 != null && classificationRuleCollectionLocalizableDetails2.Name != null) ? classificationRuleCollectionLocalizableDetails2.Name : this.defaultName); if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && OrganizationId.ForestWideOrgId.Equals(((IDirectorySession)base.DataSession).SessionSettings.CurrentOrganizationId)) { this.WriteWarning(Strings.ClassificationRuleCollectionIneffectiveSharingViolationCheck); } SortedSet <string> sortedSet = new SortedSet <string>(); IList <string> deletedRulesInUse = ClassificationRuleCollectionValidationUtils.GetDeletedRulesInUse(base.DataSession, this.DataObject, sortedSet, rulePackXDoc); if (deletedRulesInUse.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionSharingViolationSetOperationVerbose(this.localizedName ?? this.rulePackageIdentifier, string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, deletedRulesInUse), string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, sortedSet)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionSharingViolationException, IList <string> >(new ClassificationRuleCollectionSharingViolationException(message), deletedRulesInUse); } } catch (ClassificationRuleCollectionSharingViolationException exception) { base.WriteError(exception, ErrorCategory.InvalidOperation, null); } catch (ClassificationRuleCollectionInternalValidationException ex) { base.WriteError(ex, (-2147287038 == ex.Error) ? ErrorCategory.ObjectNotFound : ErrorCategory.InvalidResult, null); } catch (ClassificationRuleCollectionTimeoutException exception2) { base.WriteError(exception2, ErrorCategory.OperationTimeout, null); } catch (LocalizedException exception3) { base.WriteError(exception3, ErrorCategory.InvalidData, null); } return(result); }
private static void ValidateNoRuleIdentifiersConflicts(Dictionary <string, HashSet <string> > existingClassificationIdentifiers, IList <string> ruleIdentifiersToValidate) { ExAssert.RetailAssert(ruleIdentifiersToValidate != null, "Classification rule identifiers to be checked for conflicts with existing classification rule identifiers must not be null"); if (existingClassificationIdentifiers == null || existingClassificationIdentifiers.Count == 0 || ruleIdentifiersToValidate.Count == 0) { return; } List <string> list = new List <string>(); foreach (HashSet <string> @object in existingClassificationIdentifiers.Values) { list.AddRange(ruleIdentifiersToValidate.Where(new Func <string, bool>(@object.Contains))); } if (list.Count > 0) { LocalizedString message = Strings.ClassificationRuleCollectionExistingRuleIdViolation(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list)); throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionIdentifierValidationException, List <string> >(new ClassificationRuleCollectionIdentifierValidationException(message), list); } }