private static void HandleByteCode(
ConfigurationCompiler compiler,
XmlElement element)
{
var codegen = compiler.ByteCode;
ParseOptionalBoolean(element, "include-debugsymbols", v => codegen.IncludeDebugSymbols = v);
ParseOptionalBoolean(element, "include-comments", v => codegen.IncludeComments = v);
ParseOptionalBoolean(element, "attach-epl", v => codegen.AttachEPL = v);
ParseOptionalBoolean(element, "attach-module-epl", v => codegen.AttachModuleEPL = v);
ParseOptionalBoolean(element, "instrumented", v => codegen.Instrumented = v);
ParseOptionalBoolean(element, "allow-subscriber", v => codegen.AllowSubscriber = v);
ParseOptionalAccessMod(element, "access-modifier-context", v => codegen.AccessModifierContext = v);
ParseOptionalAccessMod(element, "access-modifier-event-type", v => codegen.AccessModifierEventType = v);
ParseOptionalAccessMod(element, "access-modifier-expression", v => codegen.AccessModifierExpression = v);
ParseOptionalAccessMod(element, "access-modifier-named-window", v => codegen.AccessModifierNamedWindow = v);
ParseOptionalAccessMod(element, "access-modifier-script", v => codegen.AccessModifierScript = v);
ParseOptionalAccessMod(element, "access-modifier-table", v => codegen.AccessModifierTable = v);
ParseOptionalAccessMod(element, "access-modifier-variable", v => codegen.AccessModifierVariable = v);
var busModifierEventType = DOMExtensions.GetOptionalAttribute(element, "bus-modifier-event-type");
if (busModifierEventType != null) {
try {
codegen.BusModifierEventType = EnumHelper.Parse<EventTypeBusModifier>(busModifierEventType.Trim());
}
catch (Exception t) {
throw new ConfigurationException(t.Message, t);
}
}
}
private void VerifyReleaseNotesOnPkg(string expectedNotes, string packageName)
{
var wait = new WebDriverWait(this.Driver, TimeSpan.FromSeconds(15));
var row = this.GetUpdatesTableTopRow(wait, packageName);
var id = row.FindElements(By.TagName("td"))[1].Text;
var showBtn = DOMExtensions.TryFind(() => row.FindElement(By.ClassName("expand"))
, TimeSpan.FromSeconds(15));
Assert.IsNotNull(showBtn);
Actions actions = new Actions(this.Driver);
actions.MoveToElement(showBtn);
actions.Perform();
wait.Until(ExpectedConditions.ElementToBeClickable(showBtn));
showBtn.ClickWrapper(this.Driver);
var nextRow = row.FindElement(By.XPath("following-sibling::*[1]"));
IWebElement notesSection =
DOMExtensions.TryFind(
() => nextRow.FindElements(By.TagName("pre")).ToList()
.FirstOrDefault(x => x.GetAttribute("data-pkg-id") == id), TimeSpan.FromSeconds(1));
Assert.AreEqual(expectedNotes, notesSection.Text);
}
private static void HandlePlugInMultiFunctionAggregation(
ConfigurationCompiler configuration,
XmlElement element)
{
var functionNames = DOMExtensions.GetRequiredAttribute(element, "function-names");
var forgeClassName = DOMExtensions.GetOptionalAttribute(element, "forge-class");
var nodeEnumerator = DOMElementEnumerator.Create(element.ChildNodes);
IDictionary<string, object> additionalProps = null;
while (nodeEnumerator.MoveNext()) {
XmlElement subElement = nodeEnumerator.Current;
if (subElement.Name == "init-arg") {
var name = DOMExtensions.GetRequiredAttribute(subElement, "name");
var value = DOMExtensions.GetRequiredAttribute(subElement, "value");
if (additionalProps == null) {
additionalProps = new Dictionary<string, object>();
}
additionalProps.Put(name, value);
}
}
var config = new ConfigurationCompilerPlugInAggregationMultiFunction(
functionNames.SplitCsv(),
forgeClassName);
config.AdditionalConfiguredProperties = additionalProps;
configuration.AddPlugInAggregationMultiFunction(config);
}
private static void HandleStreamSelection(
ConfigurationCompiler compiler,
XmlElement element)
{
var nodeEnumerator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeEnumerator.MoveNext()) {
XmlElement subElement = nodeEnumerator.Current;
if (subElement.Name == "stream-selector") {
var valueText = DOMExtensions.GetRequiredAttribute(subElement, "value");
if (valueText == null) {
throw new ConfigurationException("No value attribute supplied for stream-selector element");
}
StreamSelector defaultSelector;
if (valueText.ToUpperInvariant().Trim() == "ISTREAM") {
defaultSelector = StreamSelector.ISTREAM_ONLY;
}
else if (valueText.ToUpperInvariant().Trim() == "RSTREAM") {
defaultSelector = StreamSelector.RSTREAM_ONLY;
}
else if (valueText.ToUpperInvariant().Trim() == "IRSTREAM") {
defaultSelector = StreamSelector.RSTREAM_ISTREAM_BOTH;
}
else {
throw new ConfigurationException(
"Value attribute for stream-selector element invalid, " +
"expected one of the following keywords: istream, irstream, rstream");
}
compiler.StreamSelection.DefaultStreamSelector = defaultSelector;
}
}
}
private static void HandleSerdeSettings(
ConfigurationCompiler configuration,
XmlElement parentElement)
{
String text = DOMExtensions.GetOptionalAttribute(parentElement, "enable-serializable");
if (text != null) {
configuration.Serde.IsEnableSerializable = bool.Parse(text);
}
text = DOMExtensions.GetOptionalAttribute(parentElement, "enable-externalizable");
if (text != null) {
configuration.Serde.IsEnableExternalizable = bool.Parse(text);
}
text = DOMExtensions.GetOptionalAttribute(parentElement, "enable-extended-builtin");
if (text != null) {
configuration.Serde.IsEnableExtendedBuiltin = bool.Parse(text);
}
text = DOMExtensions.GetOptionalAttribute(parentElement, "enable-serialization-fallback");
if (text != null) {
configuration.Serde.IsEnableSerializationFallback = bool.Parse(text);
}
var nodeEnumerator = DOMElementEnumerator.Create(parentElement.ChildNodes);
while (nodeEnumerator.MoveNext()) {
var subElement = nodeEnumerator.Current;
if (subElement.Name == "serde-provider-factory") {
text = DOMExtensions.GetRequiredAttribute(subElement, "class");
configuration.Serde.AddSerdeProviderFactory(text);
}
}
}
private static void HandlePlugInAggregation(
ConfigurationCompiler configuration,
XmlElement element)
{
var name = DOMExtensions.GetRequiredAttribute(element, "name");
var forgeClassName = DOMExtensions.GetRequiredAttribute(element, "forge-class");
configuration.AddPlugInAggregationFunctionForge(name, forgeClassName);
}
private static void HandlePlugInEnumMethod(
ConfigurationCompiler configuration,
XmlElement element)
{
String methodName = DOMExtensions.GetRequiredAttribute(element, "method-name");
String forgeClassName = DOMExtensions.GetRequiredAttribute(element, "forge-class");
configuration.AddPlugInEnumMethod(methodName, forgeClassName);
}
private static void HandleScripts(
ConfigurationCompiler compiler,
XmlElement element)
{
var defaultDialect = DOMExtensions.GetOptionalAttribute(element, "default-dialect");
if (defaultDialect != null) {
compiler.Scripts.DefaultDialect = defaultDialect;
}
}
private static void HandlePlugInPatternObserver(
ConfigurationCompiler configuration,
XmlElement element)
{
var @namespace = DOMExtensions.GetRequiredAttribute(element, "namespace");
var name = DOMExtensions.GetRequiredAttribute(element, "name");
var forgeClassName = DOMExtensions.GetRequiredAttribute(element, "forge-class");
configuration.AddPlugInPatternObserver(@namespace, name, forgeClassName);
}
private static void HandlePlugInVirtualDW(
ConfigurationCompiler configuration,
XmlElement element)
{
var @namespace = DOMExtensions.GetRequiredAttribute(element, "namespace");
var name = DOMExtensions.GetRequiredAttribute(element, "name");
var forgeClassName = DOMExtensions.GetRequiredAttribute(element, "forge-class");
var config = DOMExtensions.GetOptionalAttribute(element, "config");
configuration.AddPlugInVirtualDataWindow(@namespace, name, forgeClassName, config);
}
private static void HandleScripts(
ConfigurationCompiler compiler,
XmlElement element)
{
var defaultDialect = DOMExtensions.GetOptionalAttribute(element, "default-dialect");
if (defaultDialect != null) {
compiler.Scripts.DefaultDialect = defaultDialect;
}
ParseOptionalBoolean(element, "enabled", b => compiler.Scripts.IsEnabled = b);
}
private static void HandleLogging(
ConfigurationCompiler compiler,
XmlElement element)
{
var nodeEnumerator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeEnumerator.MoveNext()) {
XmlElement subElement = nodeEnumerator.Current;
if (subElement.Name == "code") {
ParseRequiredBoolean(subElement, "enabled", b => compiler.Logging.EnableCode = b);
} else if (subElement.Name == "audit-directory") {
compiler.Logging.AuditDirectory = DOMExtensions.GetRequiredAttribute(subElement, "value");
}
}
}
private static void ParseOptionalAccessMod(
XmlElement element,
string name,
Consumer<NameAccessModifier> accessModifier)
{
var value = DOMExtensions.GetOptionalAttribute(element, name);
if (value != null) {
try {
accessModifier.Invoke(EnumHelper.Parse<NameAccessModifier>(value.Trim()));
}
catch (Exception t) {
throw new ConfigurationException(t.Message, t);
}
}
}
private static void HandleExecution(
ConfigurationCompiler compiler,
XmlElement element)
{
var filterServiceMaxFilterWidthStr =
DOMExtensions.GetOptionalAttribute(element, "filter-service-max-filter-width");
if (filterServiceMaxFilterWidthStr != null) {
compiler.Execution.FilterServiceMaxFilterWidth = int.Parse(filterServiceMaxFilterWidthStr);
}
ParseOptionalBoolean(
element,
"enable-declared-expr-value-cache",
b => compiler.Execution.EnabledDeclaredExprValueCache = b);
}
private static void HandleViewResources(
ConfigurationCompiler compiler,
XmlElement element)
{
var nodeEnumerator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeEnumerator.MoveNext()) {
XmlElement subElement = nodeEnumerator.Current;
if (subElement.Name == "iterable-unbound") {
var valueText = DOMExtensions.GetRequiredAttribute(subElement, "enabled");
var value = bool.Parse(valueText);
compiler.ViewResources.IterableUnbound = value;
}
if (subElement.Name == "outputlimitopt") {
ParseRequiredBoolean(subElement, "enabled", b => compiler.ViewResources.OutputLimitOpt = b);
}
}
}
private void SetReleaseNotesOnExistingPkg(string notes, string packageName)
{
var wait = new WebDriverWait(this.Driver, TimeSpan.FromSeconds(15));
var row = this.GetUpdatesTableTopRow(wait, packageName);
var setBtn = DOMExtensions.TryFind(() => row.FindElement(By.ClassName(Strings.Css.PrepareReleaseNotesButton))
, TimeSpan.FromSeconds(15));
Actions actions = new Actions(this.Driver);
actions.MoveToElement(setBtn);
actions.Perform();
wait.Until(ExpectedConditions.ElementToBeClickable(setBtn));
setBtn.ClickWrapper(this.Driver);
this.FillInReleaseNotesModal(wait, notes);
}
private Task <DateTime> GetLatestUsageFromTable(string callerMethodName)
{
try
{
this.GoToAdminHomePage();
WebDriverWait wait = new WebDriverWait(this.Driver, TimeSpan.FromSeconds(15));
this.Driver.FindElement(By.Id(Apps.Names.AutomaticTestsClient + "_menu")).ClickWrapper(this.Driver);
IWebElement statLink = wait.Until(ExpectedConditions.ElementIsVisible(By.Id(Apps.Names.AutomaticTestsClient + "_statsLink")));
statLink.ClickWrapper(this.Driver);
IWebElement programsTable = wait.Until(ExpectedConditions.ElementIsVisible(By.Id(Strings.Id.ViewUsageTable)));
wait.Until(ExpectedConditions.ElementToBeClickable(By.Id(Strings.Id.ViewUsageTable)));
wait.Until(ExpectedConditions.InvisibilityOfElementLocated(By.Id("ProgramUsageTable_processing")));
IWebElement latestRow = DOMExtensions.TryFind(() => programsTable.FindElement(By.TagName("tbody")).FindElements(By.TagName("tr")).FirstOrDefault()
, TimeSpan.FromSeconds(2));
if (latestRow == null)
{
throw new InvalidOperationException("Latest row is null");
}
string dateTime = "Not initialized";
try
{
dateTime = latestRow.FindElements(By.TagName("td")).FirstOrDefault()?.Text;
DateTime parsed = DateTime.ParseExact(dateTime, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
return(Task.FromResult(parsed));
}
catch (Exception ex)
{
throw new InvalidOperationException($"Cannot parse [{dateTime}] as DateTime", ex);
}
}
catch (Exception ex)
{
this.HandleError(ex, callerMethodName, this.outputs, this.errors);
return(Task.FromResult(default(DateTime)));
}
}
private static void HandleExpression(
ConfigurationCompiler compiler,
XmlElement element)
{
var integerDivision = DOMExtensions.GetOptionalAttribute(element, "integer-division");
if (integerDivision != null) {
var isIntegerDivision = bool.Parse(integerDivision);
compiler.Expression.IntegerDivision = isIntegerDivision;
}
var divZero = DOMExtensions.GetOptionalAttribute(element, "division-by-zero-is-null");
if (divZero != null) {
var isDivZero = bool.Parse(divZero);
compiler.Expression.DivisionByZeroReturnsNull = isDivZero;
}
var udfCache = DOMExtensions.GetOptionalAttribute(element, "udf-cache");
if (udfCache != null) {
var isUdfCache = bool.Parse(udfCache);
compiler.Expression.UdfCache = isUdfCache;
}
var extendedAggregationStr = DOMExtensions.GetOptionalAttribute(element, "extended-agg");
if (extendedAggregationStr != null) {
var extendedAggregation = bool.Parse(extendedAggregationStr);
compiler.Expression.ExtendedAggregation = extendedAggregation;
}
var duckTypingStr = DOMExtensions.GetOptionalAttribute(element, "ducktyping");
if (duckTypingStr != null) {
compiler.Expression.DuckTyping = bool.Parse(duckTypingStr);
}
var mathContextStr = DOMExtensions.GetOptionalAttribute(element, "math-context");
if (mathContextStr != null) {
try {
compiler.Expression.MathContext = new MathContext(mathContextStr);
}
catch (ArgumentException) {
throw new ConfigurationException("Failed to parse '" + mathContextStr + "' as a MathContext");
}
}
}
private static void HandlePlugInSingleRow(
ConfigurationCompiler configuration,
XmlElement element)
{
var name = element.Attributes.GetNamedItem("name").InnerText;
var functionClassName = element.Attributes.GetNamedItem("function-class").InnerText;
var functionMethodName = element.Attributes.GetNamedItem("function-method").InnerText;
var valueCache = ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.DISABLED;
var filterOptimizable = ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.ENABLED;
var valueCacheStr = DOMExtensions.GetOptionalAttribute(element, "value-cache");
if (valueCacheStr != null) {
valueCache =
EnumHelper.Parse<ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum>(valueCacheStr);
}
var filterOptimizableStr = DOMExtensions.GetOptionalAttribute(element, "filter-optimizable");
if (filterOptimizableStr != null) {
filterOptimizable =
EnumHelper.Parse<ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum>(
filterOptimizableStr);
}
var rethrowExceptionsStr = DOMExtensions.GetOptionalAttribute(element, "rethrow-exceptions");
var rethrowExceptions = false;
if (rethrowExceptionsStr != null) {
rethrowExceptions = bool.Parse(rethrowExceptionsStr);
}
var eventTypeName = DOMExtensions.GetOptionalAttribute(element, "event-type-name");
configuration.AddPlugInSingleRowFunction(
new ConfigurationCompilerPlugInSingleRowFunction(
name,
functionClassName,
functionMethodName,
valueCache,
filterOptimizable,
rethrowExceptions,
eventTypeName));
}
private static void HandleLogging(
ConfigurationCompiler compiler,
XmlElement element)
{
var nodeEnumerator = DOMElementEnumerator.Create(element.ChildNodes);
while (nodeEnumerator.MoveNext()) {
XmlElement subElement = nodeEnumerator.Current;
switch (subElement.Name) {
case "code":
ParseRequiredBoolean(subElement, "enabled", b => compiler.Logging.EnableCode = b);
break;
case "audit-directory":
compiler.Logging.AuditDirectory = DOMExtensions.GetRequiredAttribute(subElement, "value");
break;
case "filter-plan":
ParseRequiredBoolean(subElement, "enabled", b => compiler.Logging.IsEnableFilterPlan = b);
break;
}
}
}
