public void TestExecutor_Fail_BadExpression()
{
this.UserContext.Foo = "Bar";
ExpressionExecutor ex = new ExpressionExecutor(session: null, userContext: this.UserContext);
string expression = "UserContext.Foo";
Assert.ThrowsException <InvalidCastException>(() =>
{
ex.Execute <bool>(expression).GetAwaiter().GetResult();
}, "Expected ExpressionExecutor to fail evaluating an expression that cannot be evaluated.");
}
public void TestExecutor_Success_ChangingFunctionReturnType()
{
ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null);
// Changing return type of GetCount
string expression = "UserContext.GetCount = new Func<string>(() => \"Test\")";
Assert.AreEqual(this.UserContext.GetCount(), 1);
// Since expected return type has been updated, this should pass
ex.Execute <Func <string> >(expression).GetAwaiter().GetResult();
Assert.AreEqual(this.UserContext.GetCount(), "Test");
}
public void TestExecutor_Success_CompileExpressionWithMissingDependenciesButOtherExternalTypesInSameNamespace()
{
this.UserContext.Foo = ExternalTestType.TestEnum;
this.UserContext.Bar = TestType.Test;
List <Type> dependencies = new List <Type>();
dependencies.Add(typeof(ExternalTestType));
ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, dependencies);
string expression = "UserContext.Foo.ToString() == ExternalTestType.TestEnum.ToString() && UserContext.Bar.ToString() == TestType.Test.ToString()";
Assert.IsTrue(ex.Execute <bool>(expression).GetAwaiter().GetResult(), "Expected ExpressionExecutor to successfully evaluate a true expression.");
}
public void TestExecutor_ScriptCacheContainsKey()
{
this.UserContext.Foo = "Bar";
string expression = "UserContext.Foo == \"Bar\" && UserContext.GetTopic(\"TopicName\").ResourceType == \"Node\"";
// Test - confirm ExpressionExecutor script cache does not contain script before executing.
ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null);
Assert.IsFalse(ex.ScriptCacheContainsKey(expression));
// Test - confirm ExpressionExecutor script cache does contain script after executing.
Assert.IsTrue(ex.Execute <bool>(expression).GetAwaiter().GetResult());
Assert.IsTrue(ex.ScriptCacheContainsKey(expression));
}
public void TestExecutor_Success_CompileExpressionWithForgeDefaultDependenciesBeingPassedInExternally()
{
this.UserContext.Foo = "Foo";
List <Type> dependencies = new List <Type>();
// Tasks dependency needed by Forge by default.
dependencies.Add(typeof(Task));
// Reflection dependency needed by Forge for runtime compilation.
dependencies.Add(typeof(Type));
// Default dependencies are expected to be tossed away internally in ExpressionExecutor.
ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null);
string expression = "UserContext.Foo == \"Foo\"";
Assert.IsTrue(ex.Execute <bool>(expression).GetAwaiter().GetResult(), "Expected ExpressionExecutor to successfully evaluate a true expression.");
}
public void Invoke(ExpressionExecutor executor, string messageContent)
{
Exception exception = null;
try
{
OnBeforeExecution();
executor.Execute(messageContent);
}
catch (Exception e)
{
exception = e;
throw;
}
finally
{
OnAfterExecution(exception);
}
}
public void TestExecutor_Success_WaitForDelegateAsync()
{
this.UserContext.Foo = "Bar";
string expression = "(Func<Task<bool>>)(() => {return Task.FromResult(UserContext.Foo == \"Bar\");})";
// Casting the expression to Func<bool> since the executor will return a delegate of type Func<bool>
ExpressionExecutor ex = new ExpressionExecutor(null, this.UserContext, null);
dynamic expressionResult = ex.Execute <Delegate>(expression).GetAwaiter().GetResult();
if (expressionResult.GetType() == typeof(Func <Task <bool> >))
{
// expressionResult() return Task<bool>, doing .GetAwaiter().GetResult() again returns bool
Assert.IsTrue(expressionResult().GetAwaiter().GetResult());
this.UserContext.Foo = "Far";
Assert.IsFalse(expressionResult().GetAwaiter().GetResult());
}
else
{
Assert.Fail(string.Format("Expected expression to be of type Task<bool> but was {0}", expressionResult.GetType()));
}
}
private ResultState ProcessQueueMessages(int queueId, int batchSize, bool archiveMessages)
{
var state = new ResultState
{
IsFailed = false
};
var messages = Repository.FetchQueueMessages(queueId, batchSize);
if (messages != null)
{
foreach (var message in messages)
{
var timer = Stopwatch.StartNew();
var messageId = message.MessageId;
state.LastMessageId = messageId;
try
{
var messageContext = GetMessageContext(message.Context);
state.MaxRetries = messageContext.Settings.MaxRetriesBeforeFail.GetValueOrDefault();
state.RecoveryMode = messageContext.Settings.RecoveryMode;
PublishSettings settings = messageContext.Settings;
using (var transaction = Repository.CreateProcessingTransaction(settings.JobIsolationLevel, settings.JobTimeout))
{
var executor = new ExpressionExecutor(_serializer, _jobActivator);
if (!string.IsNullOrWhiteSpace(message.ContextFactory))
{
using (var context = executor.Execute<ExecutionContext>(message.ContextFactory))
{
if (context != null)
{
context.Invoke(executor, message.Content);
}
else
{
executor.Execute(message.Content);
}
}
}
else
{
executor.Execute(message.Content);
}
if (transaction.TransactionStatus.HasValue)
{
var transactionStatus = transaction.TransactionStatus.Value;
if (transactionStatus == TransactionStatus.Aborted ||
transactionStatus == TransactionStatus.InDoubt)
{
throw new Exception($"Invalid transaction status: [{transactionStatus}]! Unable to commit!");
}
}
Repository.RemoveMessage(messageId, archiveMessages && !settings.DiscardWhenComplete, transaction);
transaction.Complete();
}
state.ProcessedMessages += 1;
}
catch (Exception e)
{
var error = e.GetFormattedError(messageId);
Logger.Error(error);
state.Error = error;
state.IsFailed = true;
}
finally
{
timer.Stop();
Logger.Trace("Message {0} processed in {1}", messageId, timer.Elapsed);
}
if (Canceled || state.IsFailed)
{
break;
}
}
}
return state;
}
public object Execute(Expression expression)
{
return(ExpressionExecutor.Execute(expression));
}
