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