public void EsbServicesEndpoint_ShapeForSubRequest_RemoteServiceTypeIsWorkflowTypeAndHasOutputDefinitions_ShapedData() { //------------Setup for test-------------------------- var esb = new EsbServicesEndpoint(); var dataObject = new Mock <IDSFDataObject>(); dataObject.Setup(d => d.RemoteInvokerID).Returns(Guid.NewGuid().ToString()); dataObject.Setup(d => d.IsRemoteWorkflow()).Returns(true); dataObject.Setup(d => d.RemoteServiceType).Returns("Workflow"); dataObject.Setup(d => d.ServiceName).Returns("xxxx"); ErrorResultTO error; const string outputDefs = @"<Outputs><Output Name=""MapLocationID"" MapsTo=""[[MapLocationID]]"" Value=""[[mapRecSet(*).LocationID]]"" Recordset=""dbo_proc_GetAllMapLocations"" /></Outputs>"; const string inputDefs = @""; //------------Execute Test--------------------------- var result = esb.ShapeForSubRequest(dataObject.Object, inputDefs, outputDefs, out error); //------------Assert Results----------------- -------- Assert.AreEqual(1, result.Count); Assert.AreEqual(enDev2ArgumentType.Output, result[0].Key); Assert.AreEqual(1, result[0].Value.Count); var val = result[0].Value[0]; Assert.IsNotNull(val); Assert.AreEqual("MapLocationID", val.MapsTo); Assert.AreEqual("MapLocationID", val.Name); Assert.AreEqual("[[mapRecSet(*).LocationID]]", val.RawValue); Assert.AreEqual("dbo_proc_GetAllMapLocations", val.RecordSetName); }
public static Task <IServiceTestModelTO> ExecuteTestAsync(string serviceName, IPrincipal userPrinciple, Guid workspaceGuid, Dev2JsonSerializer serializer, IDSFDataObject dataObjectClone) { var lastTask = Task <IServiceTestModelTO> .Factory.StartNew(() => { var interTestRequest = new EsbExecuteRequest { ServiceName = serviceName }; var dataObjectToUse = dataObjectClone; Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { var esbEndpointClone = new EsbServicesEndpoint(); esbEndpointClone.ExecuteRequest(dataObjectToUse, interTestRequest, workspaceGuid, out _); }); var result = serializer.Deserialize <ServiceTestModelTO>(interTestRequest.ExecuteResult); if (result == null && interTestRequest.ExecuteResult != null) { var r = serializer.Deserialize <TestRunResult>(interTestRequest.ExecuteResult.ToString()) ?? new TestRunResult { TestName = dataObjectToUse.TestName }; result = new ServiceTestModelTO { Result = r, TestName = r.TestName }; } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObjectToUse.DataListID); dataObjectToUse.Environment = null; return(result); }); lastTask.ConfigureAwait(true); return(lastTask); }
void PerformExecution() { var esbChannel = new EsbServicesEndpoint(); var testDebugWriter = new TestDebugWriter(); var debugWriter = DebugDispatcher.Instance.Get(Guid.Empty); if (debugWriter != null) { DebugDispatcher.Instance.Remove(Guid.Empty); } DebugDispatcher.Instance.Add(Guid.Empty, testDebugWriter); var result = ExecuteProcess(isDebug: true, channel: esbChannel, throwException: false); Thread.Sleep(2000); var states = testDebugWriter.DebugStates; var debugStates = states.Where(a => a.StateType != StateType.Duration).ToList(); var duration = states.Where(a => a.StateType == StateType.Duration).ToList(); scenarioContext.Add("duration", duration); scenarioContext.Add("result", result); CheckDebugStates(debugStates); try { DebugDispatcher.Instance.Remove(Guid.Empty); } catch (Exception) { //May already been removed } }
void PerformExecution() { var esbChannel = new EsbServicesEndpoint(); var testDebugWriter = new TestDebugWriter(); var debugWriter = DebugDispatcher.Instance.Get(Guid.Empty); if (debugWriter != null) { DebugDispatcher.Instance.Remove(Guid.Empty); } DebugDispatcher.Instance.Add(Guid.Empty, testDebugWriter); IDSFDataObject result = ExecuteProcess(isDebug: true, channel: esbChannel, throwException: false); try { DebugDispatcher.Instance.Remove(Guid.Empty); } // ReSharper disable EmptyGeneralCatchClause catch (Exception) // ReSharper restore EmptyGeneralCatchClause { //May already been removed } var debugStates = testDebugWriter.DebugStates.Where(a => a.StateType != StateType.Duration).ToList(); var duration = testDebugWriter.DebugStates.Where(a => a.StateType == StateType.Duration).ToList(); ScenarioContext.Current.Add("duration", duration); testDebugWriter.DebugStates.Clear(); ScenarioContext.Current.Add("result", result); CheckDebugStates(debugStates); }
public void EsbServicesEndpoint_ExecuteSubRequest_GivenExecuteWorkflowAsync_ShouldCheckIsRemoteWorkflow() { //---------------Set up test pack------------------- var dataObj = new Mock <IDSFDataObject>(); var dataObjClon = new Mock <IDSFDataObject>(); dataObjClon.Setup(o => o.ServiceName).Returns("Service Name"); var rCat = new Mock <IResourceCatalog>(); var mock = new Mock <IResource>(); rCat.Setup(catalog => catalog.GetResource(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(mock.Object); var workRepo = new Mock <IWorkspaceRepository>(); workRepo.Setup(repository => repository.Get(It.IsAny <Guid>(), It.IsAny <bool>(), It.IsAny <bool>())).Returns(new Workspace(Guid.NewGuid())); dataObj.SetupAllProperties(); dataObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dataObj.Setup(o => o.IsRemoteWorkflow()); dataObj.Setup(o => o.RunWorkflowAsync).Returns(true); dataObj.Setup(o => o.Clone()).Returns(dataObjClon.Object); var esbServicesEndpoint = new EsbServicesEndpoint(); //---------------Assert Precondition---------------- Assert.IsNotNull(esbServicesEndpoint); //---------------Execute Test ---------------------- esbServicesEndpoint.ExecuteSubRequest(dataObj.Object, Guid.NewGuid(), "", "", out var err, 1, true); //---------------Test Result ----------------------- dataObj.Verify(o => o.IsRemoteWorkflow(), Times.Once); var contains = err.FetchErrors().Contains(ErrorResource.ResourceNotFound); Assert.IsTrue(contains); }
public static async Task GetTaskForTestExecution(string serviceName, IPrincipal userPrinciple, Guid workspaceGuid, Dev2JsonSerializer serializer, ICollection <IServiceTestModelTO> testResults, IDSFDataObject dataObjectClone) { var lastTask = Task.Run(() => { var interTestRequest = new EsbExecuteRequest { ServiceName = serviceName }; var dataObjectToUse = dataObjectClone; Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { var esbEndpointClone = new EsbServicesEndpoint(); ErrorResultTO errs; esbEndpointClone.ExecuteRequest(dataObjectToUse, interTestRequest, workspaceGuid, out errs); }); var result = serializer.Deserialize <ServiceTestModelTO>(interTestRequest.ExecuteResult); if (result == null) { if (interTestRequest.ExecuteResult != null) { var r = serializer.Deserialize <TestRunResult>(interTestRequest.ExecuteResult.ToString()) ?? new TestRunResult { TestName = dataObjectToUse.TestName }; result = new ServiceTestModelTO { Result = r, TestName = r.TestName }; } } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObjectToUse.DataListID); dataObjectToUse.Environment = null; testResults.Add(result); }); await lastTask; }
public void EsbServicesEndpoint_ExecuteLogErrorRequest_GivenCorrectUri_ShouldNoThrowException() { //---------------Set up test pack------------------- var dataObj = new Mock <IDSFDataObject>(); var rCat = new Mock <IResourceCatalog>(); rCat.Setup(catalog => catalog.GetResource(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Verifiable(); var workRepo = new Mock <IWorkspaceRepository>(); workRepo.Setup(repository => repository.Get(It.IsAny <Guid>(), It.IsAny <bool>(), It.IsAny <bool>())).Returns(new Workspace(Guid.NewGuid())); dataObj.SetupAllProperties(); dataObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); var esbServicesEndpoint = new EsbServicesEndpoint(); //---------------Assert Precondition---------------- Assert.IsNotNull(esbServicesEndpoint); //---------------Execute Test ---------------------- try { esbServicesEndpoint.ExecuteLogErrorRequest(dataObj.Object, It.IsAny <Guid>(), "http://example.com/", out var err, 1); } catch (Exception ex) { //---------------Test Result ----------------------- Assert.Fail(ex.Message); } }
public void EsbServicesEndpoint_ExecuteWorkflow_ResourceIsNull_ExpectNothing() { var esbServicesEndpoint = new EsbServicesEndpoint(); var mockPrincipal = new Mock <IPrincipal>(); mockPrincipal.Setup(o => o.Identity).Returns(WindowsIdentity.GetCurrent()); var dataObject = new DsfDataObject("", Guid.NewGuid()) { ResourceID = Guid.Parse("2311e5fb-3eaa-4986-b946-5a687f33fd51"), ExecutingUser = mockPrincipal.Object, IsDebug = true, RunWorkflowAsync = true, }; dataObject.Environment.Assign("[[Name]]", "somename", 0); var request = new EsbExecuteRequest(); var workspaceId = Guid.NewGuid(); var resultId = esbServicesEndpoint.ExecuteRequest(dataObject, request, workspaceId, out var errors); Assert.AreEqual(Guid.Empty, resultId); }
public void WhenAWorkflowRequestIsReceived(string wfName) { var workflow = _scenarioContext.Get <IResourceModel>(wfName); var dataObject = _scenarioContext.Get <DsfDataObject>("dataObject"); var mockStateNotifier = SetupMockStateNotifier(); var mockExecutionManager = new Mock <IExecutionManager>(); var executionManager = mockExecutionManager.Object; var esbServicesEndpoint = new EsbServicesEndpoint(); CustomContainer.Register <IWarewolfPerformanceCounterLocater>(_performanceCounterLocater); CustomContainer.Register <IExecutionManager>(executionManager); var mockLogManager = new Mock <IStateNotifierFactory>(); mockLogManager.Setup(o => o.New(dataObject)).Returns(mockStateNotifier.Object); CustomContainer.Register <IStateNotifierFactory>(mockLogManager.Object); var workspaceId = Guid.NewGuid(); var request = new EsbExecuteRequest(); var resultId = esbServicesEndpoint.ExecuteRequest(dataObject, request, workspaceId, out var errors); Assert.IsNotNull(resultId); _scenarioContext.Add(nameof(mockExecutionManager), mockExecutionManager); }
public void WhenTheDataSplitToolIsExecuted() { BuildDataList(); var esbChannel = new EsbServicesEndpoint(); var result = ExecuteProcess(isDebug: true, channel: esbChannel, throwException: false); scenarioContext.Add("result", result); }
public void CheckOutputFormatOfDataListForViewInBrowserForOneColumnInARecordset() { EsbServicesEndpoint endPoint = new EsbServicesEndpoint(); var result = endPoint.ManipulateDataListShapeForOutput(ServiceShapeWithSingleColumn); Assert.IsTrue(result.IndexOf("<recset", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset></recset>"); Assert.IsTrue(result.IndexOf("<f2", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f2/></recset>"); }
public void OnConstruction_ShouldNotThrowException() { //---------------Set up test pack------------------- //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var esbServicesEndpoint = new EsbServicesEndpoint(); //---------------Test Result ----------------------- Assert.IsNotNull(esbServicesEndpoint, "Cannot create new EsbServicesEndpoint object."); }
public void CheckOutputFormatOfDataListForViewInBrowserForOneEntireRecordsetOutputRegion() { // This test the core of the output shaping based upon IODirection ;) EsbServicesEndpoint endPoint = new EsbServicesEndpoint(); var result = endPoint.ManipulateDataListShapeForOutput(ServiceShapeWithEntireRs); Assert.IsTrue(result.IndexOf("<recset", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset></recset>"); Assert.IsTrue(result.IndexOf("<f1", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f1/></recset>"); Assert.IsTrue(result.IndexOf("<f2", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f2/></recset>"); }
private void TryExecuteRequest(EsbExecuteRequest request, Guid workspaceId, EsbServicesEndpoint channel, IDSFDataObject dataObject, bool isManagementResource) { Thread.CurrentPrincipal = ExecutingUser; if (isManagementResource) { Thread.CurrentPrincipal = Common.Utilities.ServerUser; ExecutingUser = Common.Utilities.ServerUser; dataObject.ExecutingUser = Common.Utilities.ServerUser; } else { IsAuthorizedForServiceTestRun(dataObject); } channel.ExecuteRequest(dataObject, request, workspaceId, out ErrorResultTO errors); }
static void ShapeForSubRequest(string serviceType) { var esb = new EsbServicesEndpoint(); var dataObject = new Mock <IDSFDataObject>(); dataObject.Setup(d => d.RemoteInvokerID).Returns(Guid.NewGuid().ToString()); dataObject.Setup(d => d.IsRemoteWorkflow()).Returns(true); dataObject.Setup(d => d.RemoteServiceType).Returns(serviceType); dataObject.Setup(d => d.ServiceName).Returns("xxxx"); ErrorResultTO error; const string outputDefs = @"<Outputs><Output Name=""MapLocationID"" MapsTo=""[[MapLocationID]]"" Value=""[[mapRecSet(*).LocationID]]"" Recordset=""dbo_proc_GetAllMapLocations"" /></Outputs>"; const string inputDefs = @""; //------------Execute Test--------------------------- var result = esb.ShapeForSubRequest(dataObject.Object, inputDefs, outputDefs, out error); //------------Assert Results----------------- -------- Assert.AreEqual(0, result.Count); }
public void EsbServicesEndpoint_CreateNewEnvironmentFromInputMappings_GivenInputsDefs_ShouldCreateNewEnvWithMappings() { //---------------Set up test pack------------------- var dataObj = new Mock <IDSFDataObject>(); dataObj.SetupAllProperties(); IExecutionEnvironment executionEnvironment = new ExecutionEnvironment(); dataObj.Setup(o => o.Environment).Returns(executionEnvironment).Verifiable(); dataObj.Setup(o => o.PushEnvironment(It.IsAny <IExecutionEnvironment>())).Verifiable(); const string inputMappings = @"<Inputs><Input Name=""f1"" Source=""[[recset1(*).f1a]]"" Recordset=""recset1"" /><Input Name=""f2"" Source=""[[recset2(*).f2a]]"" Recordset=""recset2"" /></Inputs>"; var esbServicesEndpoint = new EsbServicesEndpoint(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- esbServicesEndpoint.CreateNewEnvironmentFromInputMappings(dataObj.Object, inputMappings, 0); //---------------Test Result ----------------------- dataObj.Verify(o => o.PushEnvironment(It.IsAny <IExecutionEnvironment>()), Times.Once); }
public void ExecuteSubRequest_GivenExecuteWorkflowAsync_ShouldCheckIsRemoteWorkflow2() { //---------------Set up test pack------------------- var dataObj = new Mock <IDSFDataObject>(); var dataObjClon = new Mock <IDSFDataObject>(); dataObjClon.Setup(o => o.ServiceName).Returns("Service Name"); var rCat = new Mock <IResourceCatalog>(); var mock = new Mock <IResource>(); rCat.Setup(catalog => catalog.GetResource(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .Returns(mock.Object); var workRepo = new Mock <IWorkspaceRepository>(); workRepo.Setup(repository => repository.Get(It.IsAny <Guid>(), It.IsAny <bool>(), It.IsAny <bool>())).Returns(new Workspace(Guid.NewGuid())); dataObj.SetupAllProperties(); dataObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dataObj.Setup(o => o.IsRemoteWorkflow()); dataObj.Setup(o => o.RunWorkflowAsync).Returns(true); dataObj.Setup(o => o.Clone()).Returns(dataObjClon.Object); var mapManager = new Mock <IEnvironmentOutputMappingManager>(); var esbServicesEndpoint = new EsbServicesEndpoint(); var privateObject = new PrivateObject(esbServicesEndpoint); var invokerMock = new Mock <IEsbServiceInvoker>(); var remoteWorkflowExecutionContainer = new RemoteWorkflowExecutionContainer(new ServiceAction(), dataObj.Object, new Mock <IWorkspace>().Object, new Mock <IEsbChannel>().Object); invokerMock.Setup(invoker => invoker.GenerateInvokeContainer(It.IsAny <IDSFDataObject>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <Guid>())).Returns(remoteWorkflowExecutionContainer); var err = new ErrorResultTO(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- object[] args = { dataObj.Object, "inputs", invokerMock.Object, false, Guid.Empty, err, 0 }; privateObject.Invoke("ExecuteRequestAsync", args); Assert.IsNotNull(esbServicesEndpoint); var errorResultTO = args[5] as ErrorResultTO; //---------------Test Result ----------------------- var errors = errorResultTO?.FetchErrors(); Assert.IsNotNull(errors); Assert.IsTrue(errors.Count > 0); Assert.IsTrue(errors.Any(p => p.Contains("Asynchronous execution failed: Remote server unreachable"))); Assert.IsTrue(errors.Any(p => p.Contains("Service not found"))); }
public void RemoteWorkflowExecutionContainer_UnitTest_ServerIsUp_PongNotReturned_ShouldError() { //---------------Set up test pack------------------- var dataObj = new Mock <IDSFDataObject>(); var dataObjClon = new Mock <IDSFDataObject>(); dataObjClon.Setup(o => o.ServiceName).Returns("Service Name"); var mock = new Mock <IResource>(); var workRepo = new Mock <IWorkspaceRepository>(); workRepo.Setup(repository => repository.Get(It.IsAny <Guid>(), It.IsAny <bool>(), It.IsAny <bool>())).Returns(new Workspace(Guid.NewGuid())); dataObj.SetupAllProperties(); dataObj.Setup(o => o.Environment).Returns(new ExecutionEnvironment()); dataObj.Setup(o => o.EnvironmentID).Returns(_connection.ResourceID); dataObj.Setup(o => o.IsRemoteWorkflow()); dataObj.Setup(o => o.RunWorkflowAsync).Returns(true); dataObj.Setup(o => o.Clone()).Returns(dataObjClon.Object); var mapManager = new Mock <IEnvironmentOutputMappingManager>(); var esbServicesEndpoint = new EsbServicesEndpoint(); var privateObject = new PrivateObject(esbServicesEndpoint); var invokerMock = new Mock <IEsbServiceInvoker>(); var resourceCatalog = new Mock <IResourceCatalog>(); resourceCatalog.Setup(c => c.GetResourceContents(It.IsAny <Guid>(), It.IsAny <Guid>())).Returns(new StringBuilder(_connectionXml.ToString())); var container = CreateExecutionContainer(resourceCatalog.Object, "<DataList><Errors><Err></Err></Errors></DataList>", "<root><ADL><Errors><Err>Error Message</Err></Errors></ADL></root>"); invokerMock.Setup(invoker => invoker.GenerateInvokeContainer(It.IsAny <IDSFDataObject>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <Guid>())).Returns(container); var err = new ErrorResultTO(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- object[] args = { dataObj.Object, "inputs", invokerMock.Object, false, Guid.Empty, err, 0 }; privateObject.Invoke("ExecuteRequestAsync", args); Assert.IsNotNull(esbServicesEndpoint); var errorResultTO = args[5] as ErrorResultTO; //---------------Test Result ----------------------- var errors = errorResultTO?.FetchErrors(); Assert.IsNotNull(errors); Assert.IsTrue(errors.Count > 0); Assert.IsTrue(errors.Any(p => p.Contains("Asynchronous execution failed: Remote server unreachable"))); }
public void UpdatePreviousEnvironmentWithSubExecutionResultUsingOutputMappings_GivenOutPuts_ShouldReturnCorrectly() { //---------------Set up test pack------------------- const string outPuts = "<Outputs><Output Name=\"n1\" MapsTo=\"[[n1]]\" Value=\"[[n1]]\" IsObject=\"False\" /></Outputs>"; var dataObj = new Mock <IDSFDataObject>(); dataObj.SetupAllProperties(); var mapManager = new Mock <IEnvironmentOutputMappingManager>(); mapManager.Setup(manager => manager.UpdatePreviousEnvironmentWithSubExecutionResultUsingOutputMappings(It.IsAny <IDSFDataObject>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), It.IsAny <ErrorResultTO>())).Returns(new ExecutionEnvironment()); var esbServicesEndpoint = new EsbServicesEndpoint(mapManager.Object); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var executionEnvironment = esbServicesEndpoint.UpdatePreviousEnvironmentWithSubExecutionResultUsingOutputMappings(dataObj.Object, outPuts, 0, true, new ErrorResultTO()); //---------------Test Result ----------------------- Assert.IsNotNull(executionEnvironment); mapManager.VerifyAll(); }
/// <summary> /// The ForEach Activity requires the data returned from an activity /// We will mock the DSF channel to return something that we expect is shaped. /// </summary> /// <returns></returns> public void ExecuteForEachProcessForReal(out IDSFDataObject dataObject) { var svc = new ServiceAction { Name = "ForEachTestAction", ServiceName = "UnitTestService" }; IEsbChannel channel = new EsbServicesEndpoint(); svc.SetActivity(FlowchartProcess); if (CurrentDl == null) { CurrentDl = TestData; } Compiler = DataListFactory.CreateDataListCompiler(); ErrorResultTO errors; Guid exId = Compiler.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), new StringBuilder(TestData), new StringBuilder(CurrentDl), out errors); if (errors.HasErrors()) { string errorString = errors.FetchErrors().Aggregate(string.Empty, (current, item) => current + item); throw new Exception(errorString); } dataObject = new DsfDataObject(CurrentDl, exId) { // NOTE: WorkflowApplicationFactory.InvokeWorkflowImpl() will use HostSecurityProvider.Instance.ServerID // if this is NOT provided which will cause the tests to fail! ServerID = Guid.NewGuid(), ParentThreadID = 1 }; // we need to set this now ;) WfExecutionContainer wfec = new WfExecutionContainer(svc, dataObject, Dev2.Workspaces.WorkspaceRepository.Instance.ServerWorkspace, channel); errors.ClearErrors(); dataObject.DataListID = wfec.Execute(out errors); }
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceId, Guid dataListId, string connectionId) { var channel = new EsbServicesEndpoint(); var isManagementResource = ProcessDsfDataObject(request, workspaceId, dataListId, connectionId, channel); if (!DsfDataObject.Environment.HasErrors()) { return(ProcessRequest(request, workspaceId, channel, DsfDataObject, isManagementResource)); } var msg = new ExecuteMessage { HasError = true }; msg.SetMessage(string.Join(Environment.NewLine, DsfDataObject.Environment.Errors)); var serializer = new Dev2JsonSerializer(); return(serializer.SerializeToBuilder(msg)); }
public void CheckOutputFormatOfDataListForViewInBrowserForOneRecordsetOutputRegion() { IDataListCompiler comp = DataListFactory.CreateDataListCompiler(); ErrorResultTO errors; Guid dlId = comp.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), string.Empty.ToStringBuilder(), ServiceShape.ToStringBuilder(), out errors); var resource = ResourceCatalog.Instance.GetResource(_workspaceId, ServiceName); IDSFDataObject dataObj = new DsfDataObject(string.Empty, dlId) { WorkspaceID = _workspaceId, DataListID = dlId, ServiceName = ServiceName, ResourceID = resource.ResourceID }; EsbServicesEndpoint endPoint = new EsbServicesEndpoint(); string result = endPoint.FetchExecutionPayload(dataObj, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), out errors); DeleteDataList(dlId); Assert.IsTrue(result.IndexOf("<outputScalar", StringComparison.Ordinal) > 0, "Output format missing required tag of <outputScalar>"); Assert.IsTrue(result.IndexOf("<bothScalar", StringComparison.Ordinal) > 0, "Output format missing required tag of <bothScalar"); Assert.IsTrue(result.IndexOf("<recset", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset></recset>"); Assert.IsTrue(result.IndexOf("<f2", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f2/></recset>"); Assert.IsTrue(result.IndexOf("<f3", StringComparison.Ordinal) > 0, "Output format missing required tag of <recset><f3/></recset>"); }
public void CheckOutputFormatOfDataListForViewInBrowserForAllInputRegions() { IDataListCompiler comp = DataListFactory.CreateDataListCompiler(); ErrorResultTO errors; Guid dlId = comp.ConvertTo(DataListFormat.CreateFormat(GlobalConstants._XML), string.Empty, ServiceShape.ToStringBuilder(), out errors); IDSFDataObject dataObj = new DsfDataObject(string.Empty, dlId) { WorkspaceID = _workspaceId, DataListID = dlId, ServiceName = ServiceName }; EsbServicesEndpoint endPoint = new EsbServicesEndpoint(); string result = endPoint.FetchExecutionPayload(dataObj, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), out errors); DeleteDataList(dlId); Assert.IsTrue(result.IndexOf("<inputScalar", StringComparison.Ordinal) < 0, "Output format contains additional tag, <inputScalar>"); Assert.IsTrue(result.IndexOf("<noneScalar", StringComparison.Ordinal) < 0, "Output format contains additional tag, <noneScalar>"); Assert.IsTrue(result.IndexOf("<f1", StringComparison.Ordinal) < 0, "Output format contains additional tag, <recset><f1/></recset>"); Assert.IsTrue(result.IndexOf("<f4", StringComparison.Ordinal) < 0, "Output format contains additional tag, <recset><f4/></recset>"); Assert.IsTrue(result.IndexOf("<newrecset", StringComparison.Ordinal) < 0, "Output format contains additional tag, <newrecset></newrecset>"); Assert.IsTrue(result.IndexOf("<field1", StringComparison.Ordinal) < 0, "Output format contains additional tag, <newrecset><f1/></newrecset>"); Assert.IsTrue(result.IndexOf("<field2", StringComparison.Ordinal) < 0, "Output format contains additional tag, <newrecset><f1/></newrecset>"); }
protected static IResponseWriter CreateForm(WebRequestTO webRequest, string serviceName, string workspaceId, NameValueCollection headers, IPrincipal user) { var executePayload = ""; var workspaceRepository = _repository ?? WorkspaceRepository.Instance; var workspaceGuid = SetWorkspaceId(workspaceId, workspaceRepository); var allErrors = new ErrorResultTO(); var dataObject = CreateNewDsfDataObject(webRequest, serviceName, user, workspaceGuid); dataObject.SetupForWebDebug(webRequest); webRequest.BindRequestVariablesToDataObject(ref dataObject); dataObject.SetupForRemoteInvoke(headers); dataObject.SetEmitionType(webRequest, serviceName, headers); dataObject.SetupForTestExecution(serviceName, headers); if (dataObject.ServiceName == null) { dataObject.ServiceName = serviceName; } dataObject.SetResourceNameAndId(_resourceCatalog, serviceName, out IResource resource); dataObject.SetTestResourceIds(_resourceCatalog, webRequest, serviceName); dataObject.WebUrl = webRequest.WebServerUrl; var serializer = new Dev2JsonSerializer(); var esbEndpoint = new EsbServicesEndpoint(); dataObject.EsbChannel = esbEndpoint; var instance = _authorizationService ?? ServerAuthorizationService.Instance; var canExecute = dataObject.CanExecuteCurrentResource(resource, instance); // Build EsbExecutionRequest - Internal Services Require This ;) var esbExecuteRequest = new EsbExecuteRequest { ServiceName = serviceName }; foreach (string key in webRequest.Variables) { esbExecuteRequest.AddArgument(key, new StringBuilder(webRequest.Variables[key])); } var executionDlid = GlobalConstants.NullDataListID; var formatter = DataListFormat.CreateFormat("XML", EmitionTypes.XML, "text/xml"); if (canExecute && dataObject.ReturnType != EmitionTypes.SWAGGER) { ErrorResultTO errors = null; Thread.CurrentPrincipal = user; var userPrinciple = user; if ((dataObject.ReturnType == EmitionTypes.TEST || dataObject.ReturnType == EmitionTypes.TRX) && dataObject.TestName == "*") { formatter = ServiceTestExecutor.ExecuteTests(serviceName, dataObject, formatter, userPrinciple, workspaceGuid, serializer, _testCatalog, _resourceCatalog, ref executePayload); return(new StringResponseWriter(executePayload, formatter.ContentType)); } Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { executionDlid = esbEndpoint.ExecuteRequest(dataObject, esbExecuteRequest, workspaceGuid, out errors); }); } else { if (!canExecute) { dataObject.Environment.AddError(string.Format(Warewolf.Resource.Errors.ErrorResource.UserNotAuthorizedToExecuteOuterWorkflowException, dataObject.ExecutingUser.Identity.Name, dataObject.ServiceName)); } } formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json"); if (dataObject.IsServiceTestExecution) { executePayload = ServiceTestExecutor.SetupForTestExecution(serializer, esbExecuteRequest, dataObject); if (!canExecute) { return(new StringResponseWriter(dataObject.Environment.FetchErrors(), formatter.ContentType)); } return(new StringResponseWriter(executePayload, formatter.ContentType)); } if (dataObject.IsDebugFromWeb) { var serialize = SetupForWebExecution(dataObject, serializer); return(new StringResponseWriter(serialize, formatter.ContentType)); } var unionedErrors = dataObject.Environment?.Errors?.Union(dataObject.Environment?.AllErrors) ?? new List <string>(); foreach (var error in unionedErrors) { if (error.Length > 0) { allErrors.AddError(error, true); } } var executionDto = new ExecutionDto { WebRequestTO = webRequest, ServiceName = serviceName, DataObject = dataObject, Request = esbExecuteRequest, DataListIdGuid = executionDlid, WorkspaceID = workspaceGuid, Resource = resource, DataListFormat = formatter, PayLoad = executePayload, Serializer = serializer, ErrorResultTO = allErrors }; return(executionDto.CreateResponseWriter()); }
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceID, Guid dataListID, string connectionId) { var channel = new EsbServicesEndpoint(); var xmlData = string.Empty; if(request.Args != null && request.Args.ContainsKey("DebugPayload")) { xmlData = request.Args["DebugPayload"].ToString(); xmlData = xmlData.Replace("<DataList>", "<XmlData>").Replace("</DataList>", "</XmlData>"); } // we need to adjust for the silly xml structure this system was init built on ;( if(string.IsNullOrEmpty(xmlData)) { xmlData = "<DataList></DataList>"; } IDSFDataObject dataObject = new DsfDataObject(xmlData, dataListID); dataObject.StartTime = DateTime.Now; dataObject.EsbChannel = channel; dataObject.ServiceName = request.ServiceName; var resource = ResourceCatalog.Instance.GetResource(workspaceID, request.ServiceName); if(resource != null) { dataObject.ResourceID = resource.ResourceID; } dataObject.ClientID = Guid.Parse(connectionId); dataObject.ExecutingUser = ExecutingUser; // we need to assign new ThreadID to request coming from here, because it is a fixed connection and will not change ID on its own ;) if(!dataObject.Environment.HasErrors()) { ErrorResultTO errors; if(ExecutingUser == null) { throw new Exception("Null Executing User"); } try { // Execute in its own thread to give proper context ;) var t = new Thread(() => { Thread.CurrentPrincipal = ExecutingUser; channel.ExecuteRequest(dataObject, request, workspaceID, out errors); }); t.Start(); t.Join(); } catch(Exception e) { Dev2Logger.Log.Error(e.Message,e); } if(request.ExecuteResult.Length > 0) { return request.ExecuteResult; } return new StringBuilder(); } ExecuteMessage msg = new ExecuteMessage { HasError = true }; msg.SetMessage(String.Join(Environment.NewLine, dataObject.Environment.Errors)); Dev2JsonSerializer serializer = new Dev2JsonSerializer(); return serializer.SerializeToBuilder(msg); }
protected static IResponseWriter CreateForm(WebRequestTO webRequest, string serviceName, string workspaceId, NameValueCollection headers, List<DataListFormat> publicFormats, IPrincipal user = null) { //lock(ExecutionObject) { string executePayload = ""; IDataListCompiler compiler = DataListFactory.CreateDataListCompiler(); Guid workspaceGuid; if(workspaceId != null) { if(!Guid.TryParse(workspaceId, out workspaceGuid)) { workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID; } } else { workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID; } var allErrors = new ErrorResultTO(); var dataObject = new DsfDataObject(webRequest.RawRequestPayload, GlobalConstants.NullDataListID, webRequest.RawRequestPayload) { IsFromWebServer = true, ExecutingUser = user, ServiceName = serviceName, WorkspaceID = workspaceGuid }; // now bind any variables that are part of the path arguments ;) BindRequestVariablesToDataObject(webRequest, ref dataObject); // now process headers ;) if(headers != null) { Dev2Logger.Log.Debug("Remote Invoke"); var isRemote = headers.Get(HttpRequestHeader.Cookie.ToString()); var remoteId = headers.Get(HttpRequestHeader.From.ToString()); if(isRemote != null && remoteId != null) { if(isRemote.Equals(GlobalConstants.RemoteServerInvoke)) { // we have a remote invoke ;) dataObject.RemoteInvoke = true; } dataObject.RemoteInvokerID = remoteId; } } // now set the emition type ;) int loc; if(!String.IsNullOrEmpty(serviceName) && (loc = serviceName.LastIndexOf(".", StringComparison.Ordinal)) > 0) { // default it to xml dataObject.ReturnType = EmitionTypes.XML; if(loc > 0) { var typeOf = serviceName.Substring((loc + 1)).ToUpper(); EmitionTypes myType; if(Enum.TryParse(typeOf, out myType)) { dataObject.ReturnType = myType; } // adjust the service name to drop the type ;) // avoid .wiz amendments ;) if(!typeOf.ToLower().Equals(GlobalConstants.WizardExt)) { serviceName = serviceName.Substring(0, loc); dataObject.ServiceName = serviceName; } } } else { // default it to xml dataObject.ReturnType = EmitionTypes.XML; } // ensure service gets set ;) if(dataObject.ServiceName == null) { dataObject.ServiceName = serviceName; } IResource resource = null; if(!String.IsNullOrEmpty(dataObject.ServiceName)) { resource = ResourceCatalog.Instance.GetResource(dataObject.WorkspaceID, dataObject.ServiceName); if(resource != null) { dataObject.ResourceID = resource.ResourceID; } } var esbEndpoint = new EsbServicesEndpoint(); dataObject.EsbChannel = esbEndpoint; var canExecute = true; if(ServerAuthorizationService.Instance != null) { var authorizationService = ServerAuthorizationService.Instance; var hasView = authorizationService.IsAuthorized(AuthorizationContext.View, dataObject.ResourceID.ToString()); var hasExecute = authorizationService.IsAuthorized(AuthorizationContext.Execute, dataObject.ResourceID.ToString()); canExecute = (hasExecute && hasView) || (dataObject.RemoteInvoke && hasExecute) || (resource != null && resource.ResourceType == ResourceType.ReservedService); } // Build EsbExecutionRequest - Internal Services Require This ;) EsbExecuteRequest esbExecuteRequest = new EsbExecuteRequest { ServiceName = serviceName }; Dev2Logger.Log.Debug("About to execute web request [ " + serviceName + " ] DataObject Payload [ " + dataObject.RawPayload + " ]"); var executionDlid = GlobalConstants.NullDataListID; if(canExecute) { ErrorResultTO errors; executionDlid = esbEndpoint.ExecuteRequest(dataObject, esbExecuteRequest, workspaceGuid, out errors); allErrors.MergeErrors(errors); } else { allErrors.AddError("Executing a service externally requires View and Execute permissions"); } foreach(var error in dataObject.Environment.Errors) { allErrors.AddError(error,true); } // Fetch return type ;) var formatter = publicFormats.FirstOrDefault(c => c.PublicFormatName == dataObject.ReturnType) ?? publicFormats.FirstOrDefault(c => c.PublicFormatName == EmitionTypes.XML); // force it to XML if need be ;) // Fetch and convert DL ;) if(executionDlid != GlobalConstants.NullDataListID && !dataObject.Environment.HasErrors()) { // a normal service request if(!esbExecuteRequest.WasInternalService) { dataObject.DataListID = executionDlid; dataObject.WorkspaceID = workspaceGuid; dataObject.ServiceName = serviceName; // some silly chicken thinks web request where a good idea for debug ;( if(!dataObject.IsDebug || dataObject.RemoteInvoke) { if (dataObject.ReturnType == EmitionTypes.JSON) { executePayload = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, workspaceGuid,resource.DataList.ToString()); } else if (dataObject.ReturnType == EmitionTypes.XML) { executePayload = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, workspaceGuid,resource.DataList.ToString()); } dataObject.Environment.AddError(allErrors.MakeDataListReady()); } else { executePayload = string.Empty; } } else { // internal service request we need to return data for it from the request object ;) var serializer = new Dev2JsonSerializer(); executePayload = string.Empty; var msg = serializer.Deserialize<ExecuteMessage>(esbExecuteRequest.ExecuteResult); if(msg != null) { executePayload = msg.Message.ToString(); } // out fail safe to return different types of data from services ;) if(string.IsNullOrEmpty(executePayload)) { executePayload = esbExecuteRequest.ExecuteResult.ToString(); } } } else { if(dataObject.ReturnType == EmitionTypes.XML) { executePayload = "<FatalError> <Message> An internal error occurred while executing the service request </Message>"; executePayload += allErrors.MakeDataListReady(); executePayload += "</FatalError>"; } else { // convert output to JSON ;) executePayload = "{ \"FatalError\": \"An internal error occurred while executing the service request\","; executePayload += allErrors.MakeDataListReady(false); executePayload += "}"; } } Dev2Logger.Log.Debug("Execution Result [ " + executePayload + " ]"); // Clean up the datalist from the server if(!dataObject.WorkflowResumeable && executionDlid != GlobalConstants.NullDataListID) { compiler.ForceDeleteDataListByID(executionDlid); if(dataObject.IsDebug && !dataObject.IsRemoteInvoke && !dataObject.RunWorkflowAsync) { DataListRegistar.ClearDataList(); } else { foreach(var thread in dataObject.ThreadsToDispose) { DataListRegistar.DisposeScope(thread.Key, executionDlid); } DataListRegistar.DisposeScope(Thread.CurrentThread.ManagedThreadId, executionDlid); } } // old HTML throw back ;) if(dataObject.ReturnType == EmitionTypes.WIZ) { int start = (executePayload.IndexOf("<Dev2System.FormView>", StringComparison.Ordinal) + 21); int end = (executePayload.IndexOf("</Dev2System.FormView>", StringComparison.Ordinal)); int len = (end - start); if(len > 0) { if(dataObject.ReturnType == EmitionTypes.WIZ) { string tmp = executePayload.Substring(start, (end - start)); string result = CleanupHtml(tmp); const string DocType = @"<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Strict//EN"" ""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"">"; return new StringResponseWriter(String.Format("{0}\r\n{1}", DocType, result), ContentTypes.Html); } } } // JSON Data ;) if(executePayload.IndexOf("</JSON>", StringComparison.Ordinal) >= 0) { int start = executePayload.IndexOf(GlobalConstants.OpenJSON, StringComparison.Ordinal); if(start >= 0) { int end = executePayload.IndexOf(GlobalConstants.CloseJSON, StringComparison.Ordinal); start += GlobalConstants.OpenJSON.Length; executePayload = CleanupHtml(executePayload.Substring(start, (end - start))); if(!String.IsNullOrEmpty(executePayload)) { return new StringResponseWriter(executePayload, ContentTypes.Json); } } } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObject.DataListID); dataObject.Environment = null; // else handle the format requested ;) return new StringResponseWriter(executePayload, formatter.ContentType); } }
protected static IResponseWriter CreateForm(WebRequestTO webRequest, string serviceName, string workspaceId, NameValueCollection headers, IPrincipal user = null) { //lock(ExecutionObject) { string executePayload = ""; Guid workspaceGuid; if(workspaceId != null) { if(!Guid.TryParse(workspaceId, out workspaceGuid)) { workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID; } } else { workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID; } var allErrors = new ErrorResultTO(); var dataObject = new DsfDataObject(webRequest.RawRequestPayload, GlobalConstants.NullDataListID, webRequest.RawRequestPayload) { IsFromWebServer = true, ExecutingUser = user, ServiceName = serviceName, WorkspaceID = workspaceGuid }; // now bind any variables that are part of the path arguments ;) BindRequestVariablesToDataObject(webRequest, ref dataObject); // now process headers ;) if(headers != null) { Dev2Logger.Log.Debug("Remote Invoke"); var isRemote = headers.Get(HttpRequestHeader.Cookie.ToString()); var remoteId = headers.Get(HttpRequestHeader.From.ToString()); if(isRemote != null && remoteId != null) { if (isRemote.Equals(GlobalConstants.RemoteServerInvoke) ) { // we have a remote invoke ;) dataObject.RemoteInvoke = true; } if (isRemote.Equals(GlobalConstants.RemoteDebugServerInvoke)) { // we have a remote invoke ;) dataObject.RemoteNonDebugInvoke = true; } dataObject.RemoteInvokerID = remoteId; } } // now set the emition type ;) int loc; if(!String.IsNullOrEmpty(serviceName) && (loc = serviceName.LastIndexOf(".", StringComparison.Ordinal)) > 0) { // default it to xml dataObject.ReturnType = EmitionTypes.XML; if(loc > 0) { var typeOf = serviceName.Substring((loc + 1)).ToUpper(); EmitionTypes myType; if(Enum.TryParse(typeOf, out myType)) { dataObject.ReturnType = myType; } // adjust the service name to drop the type ;) // avoid .wiz amendments ;) if(!typeOf.ToLower().Equals(GlobalConstants.WizardExt)) { serviceName = serviceName.Substring(0, loc); dataObject.ServiceName = serviceName; } if(typeOf.Equals("api", StringComparison.OrdinalIgnoreCase)) { dataObject.ReturnType = EmitionTypes.SWAGGER; } } } else { // default it to xml dataObject.ReturnType = EmitionTypes.XML; } // ensure service gets set ;) if(dataObject.ServiceName == null) { dataObject.ServiceName = serviceName; } IResource resource = null; if(!String.IsNullOrEmpty(dataObject.ServiceName)) { resource = ResourceCatalog.Instance.GetResource(dataObject.WorkspaceID, dataObject.ServiceName); if(resource != null) { dataObject.ResourceID = resource.ResourceID; } } var esbEndpoint = new EsbServicesEndpoint(); dataObject.EsbChannel = esbEndpoint; var canExecute = true; if(ServerAuthorizationService.Instance != null) { var authorizationService = ServerAuthorizationService.Instance; var hasView = authorizationService.IsAuthorized(AuthorizationContext.View, dataObject.ResourceID.ToString()); var hasExecute = authorizationService.IsAuthorized(AuthorizationContext.Execute, dataObject.ResourceID.ToString()); canExecute = (hasExecute && hasView) || ((dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) && hasExecute) || (resource != null && resource.ResourceType == ResourceType.ReservedService); } // Build EsbExecutionRequest - Internal Services Require This ;) EsbExecuteRequest esbExecuteRequest = new EsbExecuteRequest { ServiceName = serviceName }; foreach(string key in webRequest.Variables) { esbExecuteRequest.AddArgument(key, new StringBuilder(webRequest.Variables[key])); } Dev2Logger.Log.Debug("About to execute web request [ " + serviceName + " ] DataObject Payload [ " + dataObject.RawPayload + " ]"); var executionDlid = GlobalConstants.NullDataListID; if (canExecute && dataObject.ReturnType != EmitionTypes.SWAGGER) { ErrorResultTO errors = null; // set correct principle ;) Thread.CurrentPrincipal = user; var userPrinciple = user; Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { executionDlid = esbEndpoint.ExecuteRequest(dataObject, esbExecuteRequest, workspaceGuid, out errors); }); allErrors.MergeErrors(errors); } else if(!canExecute) { allErrors.AddError("Executing a service externally requires View and Execute permissions"); } foreach(var error in dataObject.Environment.Errors) { allErrors.AddError(error,true); } // Fetch return type ;) var formatter = DataListFormat.CreateFormat("XML", EmitionTypes.XML, "text/xml"); // force it to XML if need be ;) // Fetch and convert DL ;) if(!dataObject.Environment.HasErrors()) { // a normal service request if(!esbExecuteRequest.WasInternalService) { dataObject.DataListID = executionDlid; dataObject.WorkspaceID = workspaceGuid; dataObject.ServiceName = serviceName; if(!dataObject.IsDebug || dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) { if (dataObject.ReturnType == EmitionTypes.JSON) { formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json"); executePayload = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, resource.DataList.ToString(),0); } else if (dataObject.ReturnType == EmitionTypes.XML) { executePayload = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject,Guid.Empty , resource.DataList.ToString(),0); }else if(dataObject.ReturnType == EmitionTypes.SWAGGER) { formatter = DataListFormat.CreateFormat("SWAGGER", EmitionTypes.SWAGGER, "application/json"); executePayload = ExecutionEnvironmentUtils.GetSwaggerOutputForService(resource, resource.DataList.ToString()); } } else { executePayload = string.Empty; } } else { // internal service request we need to return data for it from the request object ;) var serializer = new Dev2JsonSerializer(); executePayload = string.Empty; var msg = serializer.Deserialize<ExecuteMessage>(esbExecuteRequest.ExecuteResult); if(msg != null) { executePayload = msg.Message.ToString(); } // out fail safe to return different types of data from services ;) if(string.IsNullOrEmpty(executePayload)) { executePayload = esbExecuteRequest.ExecuteResult.ToString(); } } } else { if(dataObject.ReturnType == EmitionTypes.XML) { executePayload = "<FatalError> <Message> An internal error occurred while executing the service request </Message>"; executePayload += allErrors.MakeDataListReady(); executePayload += "</FatalError>"; } else { // convert output to JSON ;) executePayload = "{ \"FatalError\": \"An internal error occurred while executing the service request\","; executePayload += allErrors.MakeDataListReady(false); executePayload += "}"; } } Dev2Logger.Log.Debug("Execution Result [ " + executePayload + " ]"); // JSON Data ;) if(executePayload.IndexOf("</JSON>", StringComparison.Ordinal) >= 0) { int start = executePayload.IndexOf(GlobalConstants.OpenJSON, StringComparison.Ordinal); if(start >= 0) { int end = executePayload.IndexOf(GlobalConstants.CloseJSON, StringComparison.Ordinal); start += GlobalConstants.OpenJSON.Length; executePayload = CleanupHtml(executePayload.Substring(start, (end - start))); if(!String.IsNullOrEmpty(executePayload)) { return new StringResponseWriter(executePayload, ContentTypes.Json); } } } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObject.DataListID); dataObject.Environment = null; return new StringResponseWriter(executePayload, formatter.ContentType); } }
void PerformExecution() { var esbChannel = new EsbServicesEndpoint(); var testDebugWriter = new TestDebugWriter(); var debugWriter = DebugDispatcher.Instance.Get(Guid.Empty); if(debugWriter != null) { DebugDispatcher.Instance.Remove(Guid.Empty); } DebugDispatcher.Instance.Add(Guid.Empty, testDebugWriter); IDSFDataObject result = ExecuteProcess(isDebug: true, channel: esbChannel, throwException: false); try { DebugDispatcher.Instance.Remove(Guid.Empty); } // ReSharper disable EmptyGeneralCatchClause catch(Exception) // ReSharper restore EmptyGeneralCatchClause { //May already been removed } var debugStates = testDebugWriter.DebugStates.Where(a=>a.StateType!=StateType.Duration).ToList(); var duration = testDebugWriter.DebugStates.Where(a => a.StateType == StateType.Duration).ToList(); ScenarioContext.Current.Add("duration", duration); testDebugWriter.DebugStates.Clear(); ScenarioContext.Current.Add("result", result); CheckDebugStates(debugStates); }
protected static IResponseWriter CreateForm(WebRequestTO webRequest, string serviceName, string workspaceId, NameValueCollection headers, IPrincipal user = null) { //lock(ExecutionObject) { string executePayload = ""; Guid workspaceGuid; if (workspaceId != null) { if (!Guid.TryParse(workspaceId, out workspaceGuid)) { workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID; } } else { workspaceGuid = WorkspaceRepository.Instance.ServerWorkspace.ID; } var allErrors = new ErrorResultTO(); var dataObject = new DsfDataObject(webRequest.RawRequestPayload, GlobalConstants.NullDataListID, webRequest.RawRequestPayload) { IsFromWebServer = true, ExecutingUser = user, ServiceName = serviceName, WorkspaceID = workspaceGuid }; // now bind any variables that are part of the path arguments ;) BindRequestVariablesToDataObject(webRequest, ref dataObject); // now process headers ;) if (headers != null) { Dev2Logger.Log.Debug("Remote Invoke"); var isRemote = headers.Get(HttpRequestHeader.Cookie.ToString()); var remoteId = headers.Get(HttpRequestHeader.From.ToString()); if (isRemote != null && remoteId != null) { if (isRemote.Equals(GlobalConstants.RemoteServerInvoke)) { // we have a remote invoke ;) dataObject.RemoteInvoke = true; } if (isRemote.Equals(GlobalConstants.RemoteDebugServerInvoke)) { // we have a remote invoke ;) dataObject.RemoteNonDebugInvoke = true; } dataObject.RemoteInvokerID = remoteId; } } // now set the emition type ;) int loc; if (!String.IsNullOrEmpty(serviceName) && (loc = serviceName.LastIndexOf(".", StringComparison.Ordinal)) > 0) { // default it to xml dataObject.ReturnType = EmitionTypes.XML; if (loc > 0) { var typeOf = serviceName.Substring((loc + 1)).ToUpper(); EmitionTypes myType; if (Enum.TryParse(typeOf, out myType)) { dataObject.ReturnType = myType; } // adjust the service name to drop the type ;) // avoid .wiz amendments ;) if (!typeOf.ToLower().Equals(GlobalConstants.WizardExt)) { serviceName = serviceName.Substring(0, loc); dataObject.ServiceName = serviceName; } if (typeOf.Equals("api", StringComparison.OrdinalIgnoreCase)) { dataObject.ReturnType = EmitionTypes.SWAGGER; } } } else { // default it to xml dataObject.ReturnType = EmitionTypes.XML; } // ensure service gets set ;) if (dataObject.ServiceName == null) { dataObject.ServiceName = serviceName; } IResource resource = null; if (!String.IsNullOrEmpty(dataObject.ServiceName)) { resource = ResourceCatalog.Instance.GetResource(dataObject.WorkspaceID, dataObject.ServiceName); if (resource != null) { dataObject.ResourceID = resource.ResourceID; } } var esbEndpoint = new EsbServicesEndpoint(); dataObject.EsbChannel = esbEndpoint; var canExecute = true; if (ServerAuthorizationService.Instance != null) { var authorizationService = ServerAuthorizationService.Instance; var hasView = authorizationService.IsAuthorized(AuthorizationContext.View, dataObject.ResourceID.ToString()); var hasExecute = authorizationService.IsAuthorized(AuthorizationContext.Execute, dataObject.ResourceID.ToString()); canExecute = (hasExecute && hasView) || ((dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) && hasExecute) || (resource != null && resource.ResourceType == ResourceType.ReservedService); } // Build EsbExecutionRequest - Internal Services Require This ;) EsbExecuteRequest esbExecuteRequest = new EsbExecuteRequest { ServiceName = serviceName }; foreach (string key in webRequest.Variables) { esbExecuteRequest.AddArgument(key, new StringBuilder(webRequest.Variables[key])); } Dev2Logger.Log.Debug("About to execute web request [ " + serviceName + " ] DataObject Payload [ " + dataObject.RawPayload + " ]"); var executionDlid = GlobalConstants.NullDataListID; if (canExecute && dataObject.ReturnType != EmitionTypes.SWAGGER) { ErrorResultTO errors; executionDlid = esbEndpoint.ExecuteRequest(dataObject, esbExecuteRequest, workspaceGuid, out errors); allErrors.MergeErrors(errors); } else if (!canExecute) { allErrors.AddError("Executing a service externally requires View and Execute permissions"); } foreach (var error in dataObject.Environment.Errors) { allErrors.AddError(error, true); } // Fetch return type ;) var formatter = DataListFormat.CreateFormat("XML", EmitionTypes.XML, "text/xml"); // force it to XML if need be ;) // Fetch and convert DL ;) if (!dataObject.Environment.HasErrors()) { // a normal service request if (!esbExecuteRequest.WasInternalService) { dataObject.DataListID = executionDlid; dataObject.WorkspaceID = workspaceGuid; dataObject.ServiceName = serviceName; if (!dataObject.IsDebug || dataObject.RemoteInvoke || dataObject.RemoteNonDebugInvoke) { if (dataObject.ReturnType == EmitionTypes.JSON) { formatter = DataListFormat.CreateFormat("JSON", EmitionTypes.JSON, "application/json"); executePayload = ExecutionEnvironmentUtils.GetJsonOutputFromEnvironment(dataObject, resource.DataList.ToString(), 0); } else if (dataObject.ReturnType == EmitionTypes.XML) { executePayload = ExecutionEnvironmentUtils.GetXmlOutputFromEnvironment(dataObject, Guid.Empty, resource.DataList.ToString(), 0); } else if (dataObject.ReturnType == EmitionTypes.SWAGGER) { formatter = DataListFormat.CreateFormat("SWAGGER", EmitionTypes.SWAGGER, "application/json"); executePayload = ExecutionEnvironmentUtils.GetSwaggerOutputForService(resource, resource.DataList.ToString()); } } else { executePayload = string.Empty; } } else { // internal service request we need to return data for it from the request object ;) var serializer = new Dev2JsonSerializer(); executePayload = string.Empty; var msg = serializer.Deserialize <ExecuteMessage>(esbExecuteRequest.ExecuteResult); if (msg != null) { executePayload = msg.Message.ToString(); } // out fail safe to return different types of data from services ;) if (string.IsNullOrEmpty(executePayload)) { executePayload = esbExecuteRequest.ExecuteResult.ToString(); } } } else { if (dataObject.ReturnType == EmitionTypes.XML) { executePayload = "<FatalError> <Message> An internal error occurred while executing the service request </Message>"; executePayload += allErrors.MakeDataListReady(); executePayload += "</FatalError>"; } else { // convert output to JSON ;) executePayload = "{ \"FatalError\": \"An internal error occurred while executing the service request\","; executePayload += allErrors.MakeDataListReady(false); executePayload += "}"; } } Dev2Logger.Log.Debug("Execution Result [ " + executePayload + " ]"); // JSON Data ;) if (executePayload.IndexOf("</JSON>", StringComparison.Ordinal) >= 0) { int start = executePayload.IndexOf(GlobalConstants.OpenJSON, StringComparison.Ordinal); if (start >= 0) { int end = executePayload.IndexOf(GlobalConstants.CloseJSON, StringComparison.Ordinal); start += GlobalConstants.OpenJSON.Length; executePayload = CleanupHtml(executePayload.Substring(start, (end - start))); if (!String.IsNullOrEmpty(executePayload)) { return(new StringResponseWriter(executePayload, ContentTypes.Json)); } } } Dev2DataListDecisionHandler.Instance.RemoveEnvironment(dataObject.DataListID); dataObject.Environment = null; return(new StringResponseWriter(executePayload, formatter.ContentType)); } }
private bool ProcessDsfDataObject(EsbExecuteRequest request, Guid workspaceId, Guid dataListId, string connectionId, EsbServicesEndpoint channel) { var(xmlData, queryString) = FormatXmlData(request); DsfDataObject = new DsfDataObject(xmlData, dataListId); if (!DsfDataObject.ExecutionID.HasValue) { DsfDataObject.ExecutionID = Guid.NewGuid(); } DsfDataObject.QueryString = queryString; if (IsDebugRequest(request)) { DsfDataObject.IsDebug = true; } DsfDataObject.StartTime = DateTime.Now; DsfDataObject.EsbChannel = channel; DsfDataObject.ServiceName = request.ServiceName; DsfDataObject.Settings = new Dev2WorkflowSettingsTO { ExecutionLogLevel = Config.Server.ExecutionLogLevel, EnableDetailedLogging = Config.Server.EnableDetailedLogging, LoggerType = LoggerType.JSON, KeepLogsForDays = 2, CompressOldLogFiles = true }; var resource = request.ResourceID != Guid.Empty ? _catalog.GetResource(workspaceId, request.ResourceID) : _catalog.GetResource(workspaceId, request.ServiceName); var isManagementResource = false; if (!string.IsNullOrEmpty(request.TestName)) { DsfDataObject.TestName = request.TestName; DsfDataObject.IsServiceTestExecution = true; } if (resource != null) { DsfDataObject.ResourceID = resource.ResourceID; DsfDataObject.SourceResourceID = resource.ResourceID; isManagementResource = _catalog.ManagementServices.ContainsKey(resource.ResourceID); } else { if (request.ResourceID != Guid.Empty) { DsfDataObject.ResourceID = request.ResourceID; } } DsfDataObject.ClientID = Guid.Parse(connectionId); Common.Utilities.OrginalExecutingUser = ExecutingUser; DsfDataObject.ExecutingUser = ExecutingUser; return(isManagementResource); }
private StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceId, EsbServicesEndpoint channel, IDSFDataObject dataObject, bool isManagementResource) { if (ExecutingUser == null) { throw new Exception(ErrorResource.NullExecutingUser); } try { // Execute in its own thread to give proper context var t = new Thread(() => { try { Thread.CurrentPrincipal = ExecutingUser; if (isManagementResource) { Thread.CurrentPrincipal = Common.Utilities.ServerUser; ExecutingUser = Common.Utilities.ServerUser; dataObject.ExecutingUser = Common.Utilities.ServerUser; } else { IsAuthorizedForServiceTestRun(dataObject); } channel.ExecuteRequest(dataObject, request, workspaceId, out var errors); } catch (Exception e) { Dev2Logger.Error(e.Message, e, GlobalConstants.WarewolfError); } }); t.Start(); t.Join(); } catch (Exception e) { Dev2Logger.Error(e.Message, e, GlobalConstants.WarewolfError); } if (request.ExecuteResult.Length > 0) { return(request.ExecuteResult); } return(new StringBuilder()); }
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceID, Guid dataListID, string connectionId) { var channel = new EsbServicesEndpoint(); var xmlData = string.Empty; if (request.Args != null && request.Args.ContainsKey("DebugPayload")) { xmlData = request.Args["DebugPayload"].ToString(); xmlData = xmlData.Replace("<DataList>", "<XmlData>").Replace("</DataList>", "</XmlData>"); } // we need to adjust for the silly xml structure this system was init built on ;( if (string.IsNullOrEmpty(xmlData)) { xmlData = "<DataList></DataList>"; } IDSFDataObject dataObject = new DsfDataObject(xmlData, dataListID); dataObject.EsbChannel = channel; dataObject.ServiceName = request.ServiceName; var resource = ResourceCatalog.Instance.GetResource(workspaceID, request.ServiceName); if (resource != null) { dataObject.ResourceID = resource.ResourceID; } dataObject.ClientID = Guid.Parse(connectionId); dataObject.ExecutingUser = ExecutingUser; // we need to assign new ThreadID to request coming from here, because it is a fixed connection and will not change ID on its own ;) if (!dataObject.Errors.HasErrors()) { var dlID = Guid.Empty; ErrorResultTO errors; if (ExecutingUser == null) { throw new Exception("Null Executing User"); } try { // Execute in its own thread to give proper context ;) var t = new Thread(() => { Thread.CurrentPrincipal = ExecutingUser; dlID = channel.ExecuteRequest(dataObject, request, workspaceID, out errors); }); t.Start(); t.Join(); } catch (Exception e) { Dev2Logger.Log.Error(e.Message, e); } var compiler = DataListFactory.CreateDataListCompiler(); if (request.ExecuteResult.Length > 0) { return(request.ExecuteResult); } // return the datalist ;) if (dataObject.IsDebugMode()) { compiler.ForceDeleteDataListByID(dlID); return(new StringBuilder("Completed Debug")); } var result = compiler.ConvertFrom(dlID, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), enTranslationDepth.Data, out errors); compiler.ForceDeleteDataListByID(dlID); return(result); } ExecuteMessage msg = new ExecuteMessage { HasError = true }; msg.SetMessage(dataObject.Errors.MakeDisplayReady()); Dev2JsonSerializer serializer = new Dev2JsonSerializer(); return(serializer.SerializeToBuilder(msg)); }
public void WhenTheDataSplitToolIsExecuted() { BuildDataList(); var esbChannel = new EsbServicesEndpoint(); IDSFDataObject result = ExecuteProcess(isDebug: true,channel:esbChannel, throwException: false); ScenarioContext.Current.Add("result", result); }
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceID, Guid dataListID, string connectionId) { var channel = new EsbServicesEndpoint(); var xmlData = string.Empty; if(request.Args != null && request.Args.ContainsKey("DebugPayload")) { xmlData = request.Args["DebugPayload"].ToString(); xmlData = xmlData.Replace("<DataList>", "<XmlData>").Replace("</DataList>", "</XmlData>"); } // we need to adjust for the silly xml structure this system was init built on ;( if(string.IsNullOrEmpty(xmlData)) { xmlData = "<DataList></DataList>"; } IDSFDataObject dataObject = new DsfDataObject(xmlData, dataListID); dataObject.EsbChannel = channel; dataObject.ServiceName = request.ServiceName; var resource = ResourceCatalog.Instance.GetResource(workspaceID, request.ServiceName); if(resource != null) { dataObject.ResourceID = resource.ResourceID; } dataObject.ClientID = Guid.Parse(connectionId); dataObject.ExecutingUser = ExecutingUser; // we need to assign new ThreadID to request coming from here, because it is a fixed connection and will not change ID on its own ;) if(!dataObject.Errors.HasErrors()) { var dlID = Guid.Empty; ErrorResultTO errors; if(ExecutingUser == null) { throw new Exception("Null Executing User"); } try { // Execute in its own thread to give proper context ;) var t = new Thread(() => { Thread.CurrentPrincipal = ExecutingUser; dlID = channel.ExecuteRequest(dataObject, request, workspaceID, out errors); }); t.Start(); t.Join(); } catch(Exception e) { Dev2Logger.Log.Error(e.Message,e); } var compiler = DataListFactory.CreateDataListCompiler(); if(request.ExecuteResult.Length > 0) { return request.ExecuteResult; } // return the datalist ;) if(dataObject.IsDebugMode()) { compiler.ForceDeleteDataListByID(dlID); return new StringBuilder("Completed Debug"); } var result = compiler.ConvertFrom(dlID, DataListFormat.CreateFormat(GlobalConstants._XML_Without_SystemTags), enTranslationDepth.Data, out errors); compiler.ForceDeleteDataListByID(dlID); return result; } ExecuteMessage msg = new ExecuteMessage { HasError = true }; msg.SetMessage(dataObject.Errors.MakeDisplayReady()); Dev2JsonSerializer serializer = new Dev2JsonSerializer(); return serializer.SerializeToBuilder(msg); }
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceID, Guid dataListID, string connectionId) { var channel = new EsbServicesEndpoint(); var xmlData = string.Empty; if (request.Args != null && request.Args.ContainsKey("DebugPayload")) { xmlData = request.Args["DebugPayload"].ToString(); xmlData = xmlData.Replace("<DataList>", "<XmlData>").Replace("</DataList>", "</XmlData>"); } // we need to adjust for the silly xml structure this system was init built on ;( if (string.IsNullOrEmpty(xmlData)) { xmlData = "<DataList></DataList>"; } IDSFDataObject dataObject = new DsfDataObject(xmlData, dataListID); dataObject.StartTime = DateTime.Now; dataObject.EsbChannel = channel; dataObject.ServiceName = request.ServiceName; var resource = ResourceCatalog.Instance.GetResource(workspaceID, request.ServiceName); var isManagementResource = false; if (resource != null) { dataObject.ResourceID = resource.ResourceID; isManagementResource = ResourceCatalog.Instance.ManagementServices.ContainsKey(resource.ResourceID); } dataObject.ClientID = Guid.Parse(connectionId); dataObject.ExecutingUser = ExecutingUser; // we need to assign new ThreadID to request coming from here, because it is a fixed connection and will not change ID on its own ;) if (!dataObject.Environment.HasErrors()) { ErrorResultTO errors; if (ExecutingUser == null) { throw new Exception("Null Executing User"); } try { // Execute in its own thread to give proper context ;) var t = new Thread(() => { Thread.CurrentPrincipal = ExecutingUser; if (isManagementResource) { Thread.CurrentPrincipal = Common.Utilities.ServerUser; ExecutingUser = Common.Utilities.ServerUser; dataObject.ExecutingUser = Common.Utilities.ServerUser; } channel.ExecuteRequest(dataObject, request, workspaceID, out errors); }); t.Start(); t.Join(); } catch (Exception e) { Dev2Logger.Log.Error(e.Message, e); } if (request.ExecuteResult.Length > 0) { return(request.ExecuteResult); } return(new StringBuilder()); } ExecuteMessage msg = new ExecuteMessage { HasError = true }; msg.SetMessage(String.Join(Environment.NewLine, dataObject.Environment.Errors)); Dev2JsonSerializer serializer = new Dev2JsonSerializer(); return(serializer.SerializeToBuilder(msg)); }
public StringBuilder ProcessRequest(EsbExecuteRequest request, Guid workspaceId, Guid dataListId, string connectionId) { var channel = new EsbServicesEndpoint(); var xmlData = string.Empty; var queryString = ""; if (request.Args != null && request.Args.ContainsKey("DebugPayload")) { xmlData = request.Args["DebugPayload"].ToString(); queryString = BuildStudioUrl(xmlData); xmlData = xmlData.Replace("<DataList>", "<XmlData>").Replace("</DataList>", "</XmlData>"); } if (string.IsNullOrEmpty(xmlData)) { xmlData = "<DataList></DataList>"; } var isDebug = false; if (request.Args != null && request.Args.ContainsKey("IsDebug")) { var debugString = request.Args["IsDebug"].ToString(); if (!bool.TryParse(debugString, out isDebug)) { isDebug = false; } } var serializer = new Dev2JsonSerializer(); IDSFDataObject dataObject = new DsfDataObject(xmlData, dataListId); if (!dataObject.ExecutionID.HasValue) { dataObject.ExecutionID = Guid.NewGuid(); } dataObject.QueryString = queryString; if (isDebug) { dataObject.IsDebug = true; } dataObject.StartTime = DateTime.Now; dataObject.EsbChannel = channel; dataObject.ServiceName = request.ServiceName; var resource = request.ResourceID != Guid.Empty ? _catalog.GetResource(workspaceId, request.ResourceID) : _catalog.GetResource(workspaceId, request.ServiceName); var isManagementResource = false; if (!string.IsNullOrEmpty(request.TestName)) { dataObject.TestName = request.TestName; dataObject.IsServiceTestExecution = true; } if (resource != null) { dataObject.ResourceID = resource.ResourceID; dataObject.SourceResourceID = resource.ResourceID; isManagementResource = _catalog.ManagementServices.ContainsKey(resource.ResourceID); } else { if (request.ResourceID != Guid.Empty) { dataObject.ResourceID = request.ResourceID; } } dataObject.ClientID = Guid.Parse(connectionId); Common.Utilities.OrginalExecutingUser = ExecutingUser; dataObject.ExecutingUser = ExecutingUser; if (!dataObject.Environment.HasErrors()) { if (ExecutingUser == null) { throw new Exception(ErrorResource.NullExecutingUser); } try { var t = new Thread(() => { Thread.CurrentPrincipal = ExecutingUser; if (isManagementResource) { Thread.CurrentPrincipal = Common.Utilities.ServerUser; ExecutingUser = Common.Utilities.ServerUser; dataObject.ExecutingUser = Common.Utilities.ServerUser; } else { IsAuthorizedForServiceTestRun(dataObject); } channel.ExecuteRequest(dataObject, request, workspaceId, out ErrorResultTO errors); }); t.Start(); t.Join(); } catch (Exception e) { Dev2Logger.Error(e.Message, e, GlobalConstants.WarewolfError); } if (request.ExecuteResult.Length > 0) { return(request.ExecuteResult); } return(new StringBuilder()); } var msg = new ExecuteMessage { HasError = true }; msg.SetMessage(string.Join(Environment.NewLine, dataObject.Environment.Errors)); return(serializer.SerializeToBuilder(msg)); }