/// <summary>
/// Fetches the execute payload fragment.
/// </summary>
/// <param name="receipt">The receipt.</param>
/// <returns></returns>
public async Task <string> FetchExecutePayloadFragment(FutureReceipt receipt)
{
// Set Requesting User as per what is authorized ;)
// Sneaky people may try to forge packets to get payload ;)
if (Context.User.Identity.Name != null)
{
receipt.User = Context.User.Identity.Name;
}
try
{
var value = ResultsCache.Instance.FetchResult(receipt);
var task = new Task <string>(() => value);
task.Start();
return(await task);
}
catch (Exception e)
{
// ReSharper disable InvokeAsExtensionMethod
Dev2Logger.Log.Error(this, e);
// ReSharper restore InvokeAsExtensionMethod
}
return(null);
}
static FutureReceipt GenerateReciept()
{
var reciept = new FutureReceipt {
PartID = 1, RequestID = Guid.NewGuid(), User = "******"
};
return(reciept);
}
public void FutureReceipt_ToKey_WhenUserEmpty_ExpectException()
{
//------------Setup for test--------------------------
var futureReciept = new FutureReceipt {
PartID = 1, RequestID = RequestID, User = string.Empty
};
//------------Execute Test---------------------------
futureReciept.ToKey();
}
public void FutureReceipt_ToKey_WhenRequestIDNotSet_ExpectException()
{
//------------Setup for test--------------------------
var futureReciept = new FutureReceipt {
PartID = 1, User = "******"
};
//------------Execute Test---------------------------
futureReciept.ToKey();
}
public void FutureReceipt_ToKey_WhenPartIDLessThenZero_ExpectException()
{
//------------Setup for test--------------------------
var futureReciept = new FutureReceipt {
PartID = -1, RequestID = RequestID, User = "******"
};
//------------Execute Test---------------------------
futureReciept.ToKey();
}
public void FutureReceipt_ToKey_WhenValidKeyParts_ExpectKey()
{
//------------Setup for test--------------------------
var futureReciept = new FutureReceipt {
PartID = 1, RequestID = RequestID, User = "******"
};
//------------Execute Test---------------------------
var result = futureReciept.ToKey();
//------------Assert Results-------------------------
StringAssert.Contains(result, RequestID + "-1-Bob!");
}
public async Task <string> FetchExecutePayloadFragment(FutureReceipt receipt)
{
if (Context.User.Identity.Name != null)
{
receipt.User = Context.User.Identity.Name;
}
try
{
var value = ResultsCache.Instance.FetchResult(receipt);
var task = new Task <string>(() => value);
task.Start();
return(await task.ConfigureAwait(true));
}
catch (Exception e)
{
Dev2Logger.Error(this, e, GlobalConstants.WarewolfError);
}
return(null);
}
public void ServerAuthorizationService_IsAuthorized_RequestWhenNotAllowedButResultsPendingAndHubConnect_AuthorizationCalculatedAndNotCachedIsTrue()
{
//------------Setup for test--------------------------
var securityService = new Mock <ISecurityService>();
securityService.SetupGet(p => p.Permissions).Returns(new List <WindowsGroupPermission>());
var authorizationService = new TestServerAuthorizationService(securityService.Object);
var reciept = new FutureReceipt {
PartID = 0, RequestID = Guid.NewGuid(), User = "******"
};
ResultsCache.Instance.AddResult(reciept, "<x>hello world</x>");
var request = new Mock <IAuthorizationRequest>();
request.Setup(r => r.User.Identity.Name).Returns("TestUser");
request.Setup(r => r.User.IsInRole(It.IsAny <string>())).Returns(false);
request.Setup(r => r.Key).Returns(new AuthorizationRequestKey("User", "Url", AuthorizationContext.Any));
request.Setup(r => r.RequestType).Returns(WebServerRequestType.HubConnect);
request.Setup(r => r.QueryString[It.IsAny <string>()]).Returns(string.Empty);
Assert.AreEqual(0, authorizationService.CachedRequestCount);
//------------Execute Test---------------------------
var result = authorizationService.IsAuthorized(request.Object);
// Clear the cache out ;)
ResultsCache.Instance.FetchResult(reciept);
//------------Assert Results-------------------------
securityService.VerifyGet(p => p.Permissions, Times.AtLeast(1));
Assert.AreEqual(0, authorizationService.CachedRequestCount);
Assert.IsTrue(result);
}
/// <summary>
/// Executes the command.
/// </summary>
/// <param name="envelope">The envelope.</param>
/// <param name="endOfStream">if set to <c>true</c> [end of stream].</param>
/// <param name="workspaceId">The workspace unique identifier.</param>
/// <param name="dataListId">The data list unique identifier.</param>
/// <param name="messageId">The message unique identifier.</param>
/// <returns></returns>
public async Task <Receipt> ExecuteCommand(Envelope envelope, bool endOfStream, Guid workspaceId, Guid dataListId, Guid messageId)
{
var internalServiceRequestHandler = new InternalServiceRequestHandler {
ExecutingUser = Context.User
};
try
{
var task = new Task <Receipt>(() =>
{
try
{
StringBuilder sb;
if (!MessageCache.TryGetValue(messageId, out sb))
{
sb = new StringBuilder();
MessageCache.TryAdd(messageId, sb);
}
sb.Append(envelope.Content);
MessageCache.TryRemove(messageId, out sb);
var request = _serializer.Deserialize <EsbExecuteRequest>(sb);
var user = string.Empty;
// ReSharper disable ConditionIsAlwaysTrueOrFalse
var userPrinciple = Context.User;
if (Context.User.Identity != null)
// ReSharper restore ConditionIsAlwaysTrueOrFalse
{
user = Context.User.Identity.Name;
// set correct principle ;)
userPrinciple = Context.User;
Thread.CurrentPrincipal = userPrinciple;
Dev2Logger.Log.Debug("Execute Command Invoked For [ " + user + " ] For Service [ " + request.ServiceName + " ]");
}
StringBuilder processRequest = null;
Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { processRequest = internalServiceRequestHandler.ProcessRequest(request, workspaceId, dataListId, Context.ConnectionId); });
// always place requesting user in here ;)
var future = new FutureReceipt
{
PartID = 0,
RequestID = messageId,
User = user
};
var value = processRequest.ToString();
if (!string.IsNullOrEmpty(value))
{
if (!ResultsCache.Instance.AddResult(future, value))
{
Dev2Logger.Log.Error(new Exception("Failed to build future receipt for [ " + Context.ConnectionId + " ] Value [ " + value + " ]"));
}
}
return(new Receipt {
PartID = envelope.PartID, ResultParts = 1
});
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
}
return(null);
});
task.Start();
return(await task);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
Dev2Logger.Log.Info("Is End of Stream:" + endOfStream);
}
return(null);
}
/// <summary>
/// Executes the command.
/// </summary>
/// <param name="envelope">The envelope.</param>
/// <param name="endOfStream">if set to <c>true</c> [end of stream].</param>
/// <param name="workspaceId">The workspace unique identifier.</param>
/// <param name="dataListId">The data list unique identifier.</param>
/// <param name="messageId">The message unique identifier.</param>
/// <returns></returns>
public async Task <Receipt> ExecuteCommand(Envelope envelope, bool endOfStream, Guid workspaceId, Guid dataListId, Guid messageId)
{
var internalServiceRequestHandler = new InternalServiceRequestHandler {
ExecutingUser = Context.User
};
try
{
var task = new Task <Receipt>(() =>
{
try
{
StringBuilder sb;
if (!MessageCache.TryGetValue(messageId, out sb))
{
sb = new StringBuilder();
MessageCache.TryAdd(messageId, sb);
}
sb.Append(envelope.Content);
if (endOfStream)
{
MessageCache.TryRemove(messageId, out sb);
var request = _serializer.Deserialize <EsbExecuteRequest>(sb);
var user = string.Empty;
// ReSharper disable ConditionIsAlwaysTrueOrFalse
if (Context.User.Identity != null)
// ReSharper restore ConditionIsAlwaysTrueOrFalse
{
user = Context.User.Identity.Name;
// set correct principle ;)
Thread.CurrentPrincipal = Context.User;
Dev2Logger.Log.Debug("Execute Command Invoked For [ " + user + " ] For Service [ " + request.ServiceName + " ]");
}
var processRequest = internalServiceRequestHandler.ProcessRequest(request, workspaceId, dataListId, Context.ConnectionId);
// Convert to chunked msg store for fetch ;)
var length = processRequest.Length;
var startIdx = 0;
var rounds = (int)Math.Ceiling(length / GlobalConstants.MAX_SIZE_FOR_STRING);
for (var q = 0; q < rounds; q++)
{
var len = (int)GlobalConstants.MAX_SIZE_FOR_STRING;
if (len > (length - startIdx))
{
len = (length - startIdx);
}
// always place requesting user in here ;)
var future = new FutureReceipt
{
PartID = q,
RequestID = messageId,
User = user
};
var value = processRequest.Substring(startIdx, len);
if (!ResultsCache.Instance.AddResult(future, value))
{
Dev2Logger.Log.Error(new Exception("Failed to build future receipt for [ " + Context.ConnectionId + " ] Value [ " + value + " ]"));
}
startIdx += len;
}
return(new Receipt {
PartID = envelope.PartID, ResultParts = rounds
});
}
return(new Receipt {
PartID = envelope.PartID, ResultParts = -1
});
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
}
return(null);
});
task.Start();
return(await task);
}
catch (Exception e)
{
Dev2Logger.Log.Error(e);
}
return(null);
}
public async Task <Receipt> ExecuteCommand(Envelope envelope, bool endOfStream, Guid workspaceId, Guid dataListId, Guid messageId)
{
var internalServiceRequestHandler = new InternalServiceRequestHandler {
ExecutingUser = Context.User
};
try
{
var task = new Task <Receipt>(() =>
{
try
{
if (!MessageCache.TryGetValue(messageId, out StringBuilder sb))
{
sb = new StringBuilder();
MessageCache.TryAdd(messageId, sb);
}
sb.Append(envelope.Content);
MessageCache.TryRemove(messageId, out sb);
var request = _serializer.Deserialize <EsbExecuteRequest>(sb);
var user = string.Empty;
var userPrinciple = Context.User;
if (Context.User.Identity != null)
{
user = Context.User.Identity.Name;
userPrinciple = Context.User;
Thread.CurrentPrincipal = userPrinciple;
Dev2Logger.Debug("Execute Command Invoked For [ " + user + " : " + userPrinciple?.Identity?.AuthenticationType + " : " + userPrinciple?.Identity?.IsAuthenticated + " ] For Service [ " + request.ServiceName + " ]", GlobalConstants.WarewolfDebug);
}
StringBuilder processRequest = null;
Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { processRequest = internalServiceRequestHandler.ProcessRequest(request, workspaceId, dataListId, Context.ConnectionId); });
var future = new FutureReceipt
{
PartID = 0,
RequestID = messageId,
User = user
};
var value = processRequest?.ToString();
if (!string.IsNullOrEmpty(value) && !ResultsCache.Instance.AddResult(future, value))
{
Dev2Logger.Error(new Exception(string.Format(ErrorResource.FailedToBuildFutureReceipt, Context.ConnectionId, value)), GlobalConstants.WarewolfError);
}
return(new Receipt {
PartID = envelope.PartID, ResultParts = 1
});
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
}
return(null);
});
task.Start();
return(await task.ConfigureAwait(true));
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
Dev2Logger.Info("Is End of Stream:" + endOfStream, GlobalConstants.WarewolfInfo);
}
return(null);
}
