/// <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); }