public void Initialize(DataClassificationConfig dcDataClassificationValidationConfig)
{
if (dcDataClassificationValidationConfig == null)
{
throw new ArgumentNullException("dcDataClassificationValidationConfig");
}
this.distinctTermsFromCustomKeywordProcessorRefsCountLimit = dcDataClassificationValidationConfig.NumberOfKeywords;
}
public void Initialize(DataClassificationConfig dcDataClassificationValidationConfig)
{
if (dcDataClassificationValidationConfig == null)
{
throw new ArgumentNullException("dcDataClassificationValidationConfig");
}
this.anyBlocksCountLimit = dcDataClassificationValidationConfig.MaxAnyBlocks;
}
public void Initialize(DataClassificationConfig dcDataClassificationValidationConfig)
{
if (dcDataClassificationValidationConfig == null)
{
throw new ArgumentNullException("dcDataClassificationValidationConfig");
}
this.distinctRegexProcessorReferencesCountLimit = dcDataClassificationValidationConfig.DistinctRegExes;
}
public void Validate(ValidationContext context, XDocument rulePackXDocument)
{
if (context.DcValidationConfig == null || context.IsPayloadOobRuleCollection)
{
return;
}
DataClassificationConfig dcValidationConfig = context.DcValidationConfig;
List <KeyValuePair <string, RuleComplexityData> > rulePackComplexityData = this.GetRulePackComplexityData(rulePackXDocument).ToList <KeyValuePair <string, RuleComplexityData> >();
foreach (IDataClassificationComplexityValidator dataClassificationComplexityValidator in this.dataClassificationComplexityValidators)
{
dataClassificationComplexityValidator.Initialize(dcValidationConfig);
ComplexityValidator.ValidateRuleComplexity(rulePackComplexityData, dataClassificationComplexityValidator);
}
}
internal static bool OptimizeRulePackXDoc(XDocument rulePackXDoc, DataClassificationConfig dataClassificationConfig)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
bool result = false;
XElement xelement = rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Rules")).FirstOrDefault <XElement>();
if (xelement == null)
{
throw new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject);
}
List <XElement> list = (from versionElement in xelement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Version"))
where versionElement.IsEmpty
select versionElement).ToList <XElement>();
foreach (XElement xelement2 in list)
{
xelement2.Remove();
result = true;
}
List <string> list2 = (from versionedTextProcessorReference in TextProcessorUtils.GetTextProcessorReferences(rulePackXDoc.Root)
select versionedTextProcessorReference.Key).Distinct(ClassificationDefinitionConstants.TextProcessorIdComparer).ToList <string>();
List <XElement> list3 = XmlProcessingUtils.GetFingerprintProcessorsInRulePackage(rulePackXDoc).ToList <XElement>();
foreach (XElement xelement3 in list3)
{
XAttribute xattribute = xelement3.Attribute("id");
string item = (xattribute == null) ? string.Empty : xattribute.Value;
if (list2.Contains(item))
{
if (dataClassificationConfig != null)
{
XAttribute xattribute2 = xelement3.Attribute("threshold");
if (xattribute2 != null && !dataClassificationConfig.FingerprintThreshold.ToString().Equals(xattribute2.Value, StringComparison.Ordinal))
{
xattribute2.Value = dataClassificationConfig.FingerprintThreshold.ToString();
result = true;
}
}
}
else
{
xelement3.Remove();
result = true;
}
}
return(result);
}
private static void ValidateRegexProcessorsPerformance(XDocument rulePackXDocument, DataClassificationConfig dataClassificationConfig)
{
ExAssert.RetailAssert(dataClassificationConfig != null, "Must specify DataClassificationConfig instance when calling ValidateRegexProcessorsPerformance");
foreach (KeyValuePair <string, string> keyValuePair in XmlProcessingUtils.GetRegexesInRulePackage(rulePackXDocument))
{
try
{
if (keyValuePair.Value.Length > dataClassificationConfig.RegExLength)
{
LocalizedString localizedString = Strings.ClassificationRuleCollectionPatternTooLong(dataClassificationConfig.RegExLength);
throw new ValidationArgumentException(localizedString, null);
}
if (dataClassificationConfig.RegExGrammarLimit)
{
Pattern.ValidatePatternDoesNotBeginOrEndWithWildcards(keyValuePair.Value);
Pattern.ValidatePatternDoesNotContainGroupsOrAssertionsWithWildcards(keyValuePair.Value);
Pattern.ValidatePatternDoesNotContainMultiMatchOnGroupsOrAssertions(keyValuePair.Value);
Pattern.ValidatePatternDoesNotHaveSequentialIdenticalMultiMatches(keyValuePair.Value);
Pattern.ValidatePatternDoesNotContainEmptyAlternations(keyValuePair.Value);
}
}
catch (ValidationArgumentException ex)
{
LocalizedString message = Strings.ClassificationRuleCollectionRegexPerformanceValidationFailure(keyValuePair.Key, ex.Message);
throw new ClassificationRuleCollectionRegexValidationException(message, ex);
}
}
}
