public string GenerateUserFriendlyModel(IExecutionEnvironment env, Dev2DecisionMode mode, out ErrorResultTO errors) { StringBuilder result = new StringBuilder(""); int cnt = 0; errors = new ErrorResultTO(); // build the output for decisions foreach(Dev2Decision dd in TheStack) { result.Append(dd.GenerateUserFriendlyModel(env, Mode, out errors)); // append mode if not at end if((cnt + 1) < TheStack.Count) { result.Append(Mode); } result.AppendLine(); cnt++; } // append the arms result.Append("THEN " + TrueArmText); result.AppendLine(); result.Append("ELSE " + FalseArmText); return result.ToString(); }
public System.Guid MockExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out DataList.Contract.ErrorResultTO tmpErrors) { tmpErrors = new ErrorResultTO(); tmpErrors.AddError("Something bad happened"); return Guid.Empty; }
public void Webservice_Test_WhenRequestShouldTimeout_ExpectTimeoutMessage() { //------------Setup for test-------------------------- var serviceXml = XmlResource.Fetch("WebService"); var sourceXml = XmlResource.Fetch("WebSource"); var response = JsonResource.Fetch("cryptsy_all_markets"); var service = new WebService(serviceXml) { Source = new WebSource(sourceXml) }; foreach(var parameter in service.Method.Parameters) { parameter.Value = parameter.DefaultValue; } var webExecuteHitCount = 0; var resourceCatalog = new Mock<IResourceCatalog>(); var services = new WebServicesMock(resourceCatalog.Object, (WebSource source, WebRequestMethod method, string uri, string data, bool error, out ErrorResultTO errors, string[] headers) => { webExecuteHitCount++; errors = new ErrorResultTO(); return response; }); //------------Execute Test--------------------------- var result = services.Test(service.ToString(), Guid.Empty, Guid.Empty); //------------Assert Results------------------------- Assert.AreEqual(1, webExecuteHitCount); Assert.AreEqual(GlobalConstants.WebServiceTimeoutMessage, result.RequestMessage); }
protected override Guid ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO errors, int update) { var execErrors = new ErrorResultTO(); errors = new ErrorResultTO(); errors.MergeErrors(execErrors); var databaseServiceExecution = ServiceExecution as DatabaseServiceExecution; if(databaseServiceExecution != null) { databaseServiceExecution.InstanceInputDefinitions = inputs; // set the output mapping for the instance ;) databaseServiceExecution.InstanceOutputDefintions = outputs; // set the output mapping for the instance ;) } //ServiceExecution.DataObj = dataObject; var result = ServiceExecution.Execute(out execErrors, update); var fetchErrors = execErrors.FetchErrors(); foreach(var error in fetchErrors) { dataObject.Environment.Errors.Add(error); } errors.MergeErrors(execErrors); // Adjust the remaining output mappings ;) return result; }
private void GenerateRequestDictionaryFromDataObject(out ErrorResultTO errors) { var compiler = DataListFactory.CreateDataListCompiler(); errors = new ErrorResultTO(); ErrorResultTO invokeErrors; IBinaryDataList bdl = compiler.FetchBinaryDataList(DataObject.DataListID, out invokeErrors); errors.MergeErrors(invokeErrors); if(!invokeErrors.HasErrors()) { foreach(IBinaryDataListEntry entry in bdl.FetchScalarEntries()) { IBinaryDataListItem itm = entry.FetchScalar(); if(!DataListUtil.IsSystemTag(itm.FieldName)) { var stringBuilder = new StringBuilder(""); try { stringBuilder = new StringBuilder(itm.TheValue); } // ReSharper disable EmptyGeneralCatchClause catch(Exception) // ReSharper restore EmptyGeneralCatchClause { } Request.AddArgument(itm.FieldName, stringBuilder); } } } }
public override Guid Execute(out ErrorResultTO errors, int update) { WebserviceExecution.InstanceInputDefinitions = InstanceInputDefinition; WebserviceExecution.InstanceOutputDefintions = InstanceOutputDefinition; var result = WebserviceExecution.Execute(out errors, update); return result; }
public DataTable ConvertToDataTable(IBinaryDataList input, string recsetName, out ErrorResultTO errors, PopulateOptions populateOptions) { if(String.IsNullOrEmpty(recsetName)) { throw new ArgumentNullException("recsetName"); } if(input == null) { throw new ArgumentNullException("input"); } var dbData = new DataTable(); IBinaryDataListEntry entry; errors = null; string error; if(input.TryGetEntry(recsetName, out entry, out error)) { if(entry.IsRecordset) { var cols = entry.Columns; var dataColumns = cols.ToList().ConvertAll(column => new DataColumn(column.ColumnName)); dbData.Columns.AddRange(dataColumns.ToArray()); var fetchRecordsetIndexes = entry.FetchRecordsetIndexes(); while(fetchRecordsetIndexes.HasMore()) { var binaryDataListItems = entry.FetchRowAt(fetchRecordsetIndexes.FetchNextIndex(), out error); if(populateOptions == PopulateOptions.IgnoreBlankRows && binaryDataListItems.All(item => { string theValue; try { theValue = item.TheValue; } catch(Exception) { theValue = null; } return String.IsNullOrEmpty(theValue); })) { continue; } dbData.LoadDataRow(binaryDataListItems.Select(item => { string theValue; try { theValue = item.TheValue; } catch(Exception) { theValue = null; } return theValue as object; }).ToArray(), LoadOption.OverwriteChanges); } } } return dbData; }
public override Guid Execute(out ErrorResultTO errors) { _pluginServiceExecution.InstanceInputDefinitions = InstanceInputDefinition; _pluginServiceExecution.InstanceOutputDefintions = InstanceOutputDefinition; var result = _pluginServiceExecution.Execute(out errors); return result; }
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update) { IList<OutputTO> outputs = new List<OutputTO>(); allErrors = new ErrorResultTO(); var colItr = new WarewolfListIterator(); //get all the possible paths for all the string variables var outputItr = new WarewolfIterator(dataObject.Environment.Eval(OutputPath, update)); colItr.AddVariableToIterateOn(outputItr); var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update)); colItr.AddVariableToIterateOn(unameItr); var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update)); colItr.AddVariableToIterateOn(passItr); var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update)); colItr.AddVariableToIterateOn(privateKeyItr); if(dataObject.IsDebugMode()) { AddDebugInputItem(new DebugEvalResult(OutputPath, "File or Folder", dataObject.Environment, update)); AddDebugInputItem(new DebugItemStaticDataParams(Overwrite.ToString(), "Overwrite")); AddDebugInputItemUserNamePassword(dataObject.Environment, update); if (!string.IsNullOrEmpty(PrivateKeyFile)) { AddDebugInputItem(PrivateKeyFile, "Destination Private Key File", dataObject.Environment, update); } } while(colItr.HasMoreData()) { IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker(); Dev2CRUDOperationTO opTo = new Dev2CRUDOperationTO(Overwrite); try { IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(outputItr), colItr.FetchNextValue(unameItr), colItr.FetchNextValue(passItr), true, colItr.FetchNextValue(privateKeyItr)); IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst); string result = broker.Create(dstEndPoint, opTo, true); outputs.Add(DataListFactory.CreateOutputTO(Result, result)); } catch(Exception e) { outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure")); allErrors.AddError(e.Message); break; } } return outputs; }
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors, int update) { IList<OutputTO> outputs = new List<OutputTO>(); allErrors = new ErrorResultTO(); var colItr = new WarewolfListIterator(); //get all the possible paths for all the string variables var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath, update)); colItr.AddVariableToIterateOn(inputItr); var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username, update)); colItr.AddVariableToIterateOn(unameItr); var passItr = new WarewolfIterator(dataObject.Environment.Eval(DecryptedPassword,update)); colItr.AddVariableToIterateOn(passItr); var privateKeyItr = new WarewolfIterator(dataObject.Environment.Eval(PrivateKeyFile, update)); colItr.AddVariableToIterateOn(privateKeyItr); outputs.Add(DataListFactory.CreateOutputTO(Result)); if(dataObject.IsDebugMode()) { AddDebugInputItem(InputPath, "Input Path", dataObject.Environment, update); AddDebugInputItemUserNamePassword(dataObject.Environment, update); if(!string.IsNullOrEmpty(PrivateKeyFile)) { AddDebugInputItem(PrivateKeyFile, "Private Key File", dataObject.Environment, update); } } while(colItr.HasMoreData()) { IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker(); IActivityIOPath ioPath = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr), colItr.FetchNextValue(unameItr), colItr.FetchNextValue(passItr), true, colItr.FetchNextValue(privateKeyItr)); IActivityIOOperationsEndPoint endpoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(ioPath); try { string result = broker.Get(endpoint); outputs[0].OutputStrings.Add(result); } catch(Exception e) { outputs[0].OutputStrings.Add(null); allErrors.AddError(e.Message); break; } } return outputs; }
protected override IList<OutputTO> ExecuteConcreteAction(IDSFDataObject dataObject, out ErrorResultTO allErrors) { IList<OutputTO> outputs = new List<OutputTO>(); allErrors = new ErrorResultTO(); var colItr = new WarewolfListIterator(); //get all the possible paths for all the string variables var inputItr = new WarewolfIterator(dataObject.Environment.Eval(InputPath)); colItr.AddVariableToIterateOn(inputItr); var unameItr = new WarewolfIterator(dataObject.Environment.Eval(Username)); colItr.AddVariableToIterateOn(unameItr); var passItr = new WarewolfIterator(dataObject.Environment.Eval(Password)); colItr.AddVariableToIterateOn(passItr); outputs.Add(DataListFactory.CreateOutputTO(Result)); if(dataObject.IsDebugMode()) { AddDebugInputItem(InputPath, "Input Path", dataObject.Environment); AddDebugInputItemUserNamePassword(dataObject.Environment); } while(colItr.HasMoreData()) { IActivityOperationsBroker broker = ActivityIOFactory.CreateOperationsBroker(); try { IActivityIOPath dst = ActivityIOFactory.CreatePathFromString(colItr.FetchNextValue(inputItr), colItr.FetchNextValue(unameItr), colItr.FetchNextValue(passItr), true); IActivityIOOperationsEndPoint dstEndPoint = ActivityIOFactory.CreateOperationEndPointFromIOPath(dst); string result = broker.Delete(dstEndPoint); outputs[0].OutputStrings.Add(result); } catch(Exception e) { outputs.Add(DataListFactory.CreateOutputTO(Result, "Failure")); //outputs[0].OutputStrings.Add(null); allErrors.AddError(e.Message); break; } } return outputs; }
public bool WriteDataList(Guid datalistID, IBinaryDataList datalist, ErrorResultTO errors) { bool result = false; if (datalistID != GlobalConstants.NullDataListID) { Repo[datalistID] = datalist; result = true; } return result; }
protected override Guid ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO tmpErrors, int update) { _errorsTo = new ErrorResultTO(); var pluginServiceExecution = GetNewPluginServiceExecution(dataObject); pluginServiceExecution.InstanceInputDefinitions = inputs; pluginServiceExecution.InstanceOutputDefintions = outputs; tmpErrors = new ErrorResultTO(); tmpErrors.MergeErrors(_errorsTo); var result = ExecutePluginService(pluginServiceExecution, update); tmpErrors.MergeErrors(_errorsTo); return result; }
public DataListTranslatedPayloadTO ConvertFrom(IBinaryDataList payload, out ErrorResultTO errors) { if(payload == null) { throw new ArgumentNullException("payload"); } StringBuilder result = new StringBuilder("<" + RootTag + ">"); errors = new ErrorResultTO(); var entries = payload.FetchAllEntries(); foreach(var entry in entries) { if(entry.IsRecordset) { AddEntryToBuilder(result, entry); result.Append(">"); foreach(var col in entry.Columns) { result.Append("<"); result.Append(col.ColumnName); result.Append(" " + Description + "=\""); result.Append(col.ColumnDescription); result.Append("\" "); result.Append(IsEditable + "=\""); result.Append(col.IsEditable); result.Append("\" "); // Travis.Frisinger - Added Column direction result.Append(GlobalConstants.DataListIoColDirection + "=\""); result.Append(col.ColumnIODirection); result.Append("\" "); result.Append("/>"); } result.Append("</"); result.Append(entry.Namespace); result.Append(">"); } else { AddEntryToBuilder(result, entry); result.Append("/>"); } } result.Append("</" + RootTag + ">"); DataListTranslatedPayloadTO tmp = new DataListTranslatedPayloadTO(result.ToString()); return tmp; }
internal static void DoRecordSetAppending(ErrorResultTO errors, IBinaryDataListEntry entry, StringBuilder result) { var cnt = entry.FetchLastRecordsetIndex(); var cols = entry.Columns; if(!cols.Any(c => c.ColumnIODirection == enDev2ColumnArgumentDirection.Both || c.ColumnIODirection == enDev2ColumnArgumentDirection.Input)) { return; } for(var i = 1; i <= cnt; i++) { string error; var rowData = entry.FetchRecordAt(i, out error); errors.AddError(error); result.Append("<"); result.Append(entry.Namespace); result.Append(">"); foreach(var col in rowData) { var fName = col.FieldName; if(cols.Any(c => c.ColumnName == fName && (c.ColumnIODirection == enDev2ColumnArgumentDirection.Both || c.ColumnIODirection == enDev2ColumnArgumentDirection.Input))) { result.Append("<"); result.Append(fName); result.Append(">"); try { result.Append(col.TheValue); } // ReSharper disable EmptyGeneralCatchClause catch (Exception) { } result.Append("</"); result.Append(fName); result.Append(">"); } } result.Append("</"); result.Append(entry.Namespace); result.Append(">"); } }
// ReSharper disable InconsistentNaming public void DsfPluginActivity_DsfPluginActivityUnitTest_ExecutePluginService_ServiceExecuted() // ReSharper restore InconsistentNaming { //init var pluginActivity = new MockDsfPluginActivity(); var errors = new ErrorResultTO(); var mockContainer = new Mock<PluginServiceExecution>(new DsfDataObject(It.IsAny<string>(), It.IsAny<Guid>()), It.IsAny<bool>()); mockContainer.Setup(c => c.Execute(out errors, 0)).Verifiable(); //exe pluginActivity.MockExecutePluginService(mockContainer.Object); //assert Assert.IsFalse(errors.HasErrors(), "Errors where thrown while executing a plugin service"); mockContainer.Verify(c => c.Execute(out errors, 0), Times.Once()); }
public override Guid Execute(out ErrorResultTO errors) { errors = new ErrorResultTO(); _databaseServiceExecution.BeforeExecution(errors); var databaseServiceExecution = _databaseServiceExecution as DatabaseServiceExecution; if(databaseServiceExecution != null) { databaseServiceExecution.InstanceInputDefinitions = InstanceInputDefinition; databaseServiceExecution.InstanceOutputDefintions = InstanceOutputDefinition; } var result = _databaseServiceExecution.Execute(out errors); _databaseServiceExecution.AfterExecution(errors); return result; }
/// <summary> /// Executes the specified errors. /// </summary> /// <param name="errors">The errors.</param> /// <param name="update"></param> /// <returns></returns> public override Guid Execute(out ErrorResultTO errors, int update) { errors = new ErrorResultTO(); // WorkflowApplicationFactory wfFactor = new WorkflowApplicationFactory(); Guid result = GlobalConstants.NullDataListID; Dev2Logger.Log.Debug("Entered Wf Container"); // Set Service Name DataObject.ServiceName = ServiceAction.ServiceName; // Set server ID, only if not set yet - original server; if(DataObject.ServerID == Guid.Empty) DataObject.ServerID = HostSecurityProvider.Instance.ServerID; // Set resource ID, only if not set yet - original resource; if(DataObject.ResourceID == Guid.Empty && ServiceAction != null && ServiceAction.Service != null) DataObject.ResourceID = ServiceAction.Service.ID; // Travis : Now set Data List DataObject.DataList = ServiceAction.DataListSpecification; // Set original instance ID, only if not set yet - original resource; if(DataObject.OriginalInstanceID == Guid.Empty) DataObject.OriginalInstanceID = DataObject.DataListID; Dev2Logger.Log.Info(String.Format("Started Execution for Service Name:{0} Resource Id:{1} Mode:{2}",DataObject.ServiceName,DataObject.ResourceID,DataObject.IsDebug?"Debug":"Execute")); //Set execution origin if(!string.IsNullOrWhiteSpace(DataObject.ParentServiceName)) { DataObject.ExecutionOrigin = ExecutionOrigin.Workflow; DataObject.ExecutionOriginDescription = DataObject.ParentServiceName; } else if(DataObject.IsDebug) { DataObject.ExecutionOrigin = ExecutionOrigin.Debug; } else { DataObject.ExecutionOrigin = ExecutionOrigin.External; } var userPrinciple = Thread.CurrentPrincipal; ErrorResultTO to = errors; Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple,()=>{result = ExecuteWf(to);}); Dev2Logger.Log.Info(String.Format("Completed Execution for Service Name:{0} Resource Id: {1} Mode:{2}",DataObject.ServiceName,DataObject.ResourceID,DataObject.IsDebug?"Debug":"Execute")); return result; }
/// <summary> /// Converts from a binary representation in the standard format to the specified <see cref="Format" />. /// </summary> /// <param name="input">The binary representation of the datalist.</param> /// <param name="errors">The errors.</param> /// <returns> /// An array of bytes that represent the datalist in the specified <see cref="Format" /> /// </returns> /// <exception cref="System.ArgumentNullException">input</exception> public DataListTranslatedPayloadTO ConvertFrom(IBinaryDataList input, out ErrorResultTO errors) { errors = new ErrorResultTO(); if(input == null) throw new ArgumentNullException("input"); IList<string> itemKeys = input.FetchAllUserKeys(); errors = new ErrorResultTO(); StringBuilder result = new StringBuilder("{"); int keyCnt = 0; foreach(string key in itemKeys) { IBinaryDataListEntry entry; // This check was never here - this means this method has no testing and was never sane ;) string error; if(input.TryGetEntry(key, out entry, out error)) { if(entry.IsRecordset) { result.Append(ProcessRecordSet(entry, out error)); errors.AddError(error); } else { result.Append(ProcessScalar(entry)); } } errors.AddError(error); // wack in , for field separator ;) keyCnt++; if(keyCnt < itemKeys.Count) { result.Append(","); } } result.Append("}"); DataListTranslatedPayloadTO tmp = new DataListTranslatedPayloadTO(result.ToString()); return tmp; }
/// <summary> /// Replaces a value in and entry with a new value. /// </summary> /// <param name="stringToSearch">The old string.</param> /// <param name="findString">The old string.</param> /// <param name="replacementString">The new string.</param> /// <param name="caseMatch">if set to <c>true</c> [case match].</param> /// <param name="errors">The errors.</param> /// <param name="replaceCount">The replace count.</param> /// <returns></returns> public string Replace(string stringToSearch, string findString, string replacementString, bool caseMatch, out ErrorResultTO errors, ref int replaceCount) { var oldString = stringToSearch; ErrorResultTO allErrors = new ErrorResultTO(); errors = new ErrorResultTO(); allErrors.MergeErrors(errors); var regexOptions = caseMatch ? NoneCompiled : IgnoreCaseCompiled; Regex regex = new Regex(Regex.Escape(findString), regexOptions); string tmpVal = oldString; replaceCount += regex.Matches(tmpVal).Count; var replaceValue = regex.Replace(tmpVal, replacementString); errors = allErrors; return replaceValue; }
protected override Guid ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO tmpErrors) { tmpErrors = new ErrorResultTO(); var webserviceExecution = GetNewWebserviceExecution(dataObject); if(webserviceExecution != null && !tmpErrors.HasErrors()) { webserviceExecution.InstanceOutputDefintions = outputs; // set the output mapping for the instance ;) webserviceExecution.InstanceInputDefinitions = inputs; ErrorResultTO invokeErrors; var result = webserviceExecution.Execute(out invokeErrors); dataObject.Environment.AddError(invokeErrors.MakeDataListReady()); return result; } return Guid.NewGuid(); }
public DataListTranslatedPayloadTO ConvertFrom(IBinaryDataList payload, out ErrorResultTO errors) { if(payload == null) { throw new ArgumentNullException("payload"); } StringBuilder result = new StringBuilder("<" + RootTag + ">"); errors = new ErrorResultTO(); var itemKeys = payload.FetchAllKeys(); foreach(var key in itemKeys) { IBinaryDataListEntry entry; string error; if(payload.TryGetEntry(key, out entry, out error)) { if(entry.IsRecordset && (entry.ColumnIODirection == enDev2ColumnArgumentDirection.Input || entry.ColumnIODirection == enDev2ColumnArgumentDirection.Both)) { DoRecordSetAppending(errors, entry, result); } else { var fName = entry.Namespace; var val = entry.FetchScalar(); if(val != null && (entry.ColumnIODirection == enDev2ColumnArgumentDirection.Input || entry.ColumnIODirection == enDev2ColumnArgumentDirection.Both)) { DoScalarAppending(result, fName, val); } } } } result.Append("</" + RootTag + ">"); DataListTranslatedPayloadTO tmp = new DataListTranslatedPayloadTO(result.ToString()); return tmp; }
protected override Guid ExecutionImpl(IEsbChannel esbChannel, IDSFDataObject dataObject, string inputs, string outputs, out ErrorResultTO tmpErrors) { _errorsTo = new ErrorResultTO(); var compiler = DataListFactory.CreateDataListCompiler(); ErrorResultTO invokeErrors; esbChannel.CorrectDataList(dataObject, dataObject.WorkspaceID, out invokeErrors, compiler); dataObject.DataListID = compiler.Shape(dataObject.DataListID, enDev2ArgumentType.Input, inputs, out invokeErrors); _errorsTo.MergeErrors(invokeErrors); _errorsTo.MergeErrors(invokeErrors); var pluginServiceExecution = GetNewPluginServiceExecution(dataObject); pluginServiceExecution.InstanceInputDefinitions = inputs; pluginServiceExecution.InstanceOutputDefintions = outputs; tmpErrors = new ErrorResultTO(); tmpErrors.MergeErrors(_errorsTo); var result = ExecutePluginService(pluginServiceExecution); tmpErrors.MergeErrors(_errorsTo); return result; }
public override Guid Execute(out ErrorResultTO errors, int update) { errors = new ErrorResultTO(); var invokeErrors = new ErrorResultTO(); Guid result = GlobalConstants.NullDataListID; try { EsbManagementServiceLocator emsl = new EsbManagementServiceLocator(); IEsbManagementEndpoint eme = emsl.LocateManagementService(ServiceAction.Name); if(eme != null) { // Web request for internal service ;) if(Request.Args == null) { GenerateRequestDictionaryFromDataObject(out invokeErrors); errors.MergeErrors(invokeErrors); } var res = eme.Execute(Request.Args, TheWorkspace); Request.ExecuteResult = res; errors.MergeErrors(invokeErrors); result = DataObject.DataListID; Request.WasInternalService = true; } else { errors.AddError("Could not locate management service [ " + ServiceAction.ServiceName + " ]"); } } catch(Exception ex) { errors.AddError(ex.Message); } return result; }
// ReSharper disable InconsistentNaming public void DsfDatabaseActivity_UnitTest_ExecutionImpl_InvokesDatabaseServiceExecution() // ReSharper restore InconsistentNaming { // ReSharper disable RedundantAssignment ErrorResultTO errors = new ErrorResultTO(); // ReSharper restore RedundantAssignment var dataObj = new Mock<IDSFDataObject>(); var dbServiceExecution = new Mock<IServiceExecution>(); dbServiceExecution.Setup(s => s.DataObj).Returns(dataObj.Object); dbServiceExecution.Setup(s => s.Execute(out errors, 0)).Verifiable(); var databaseActivity = new MockDsfDatabaseActivity(dbServiceExecution.Object); // ShapeForSubRequest var mockEsb = new Mock<IEsbChannel>(); //mockEsb.Setup(s => s.ShapeForSubRequest(It.IsAny<IDSFDataObject>(), It.IsAny<string>(), It.IsAny<string>(), out errors)).Returns(null); databaseActivity.MockExecutionImpl(mockEsb.Object, dataObj.Object, string.Empty, string.Empty, out errors); //assert dbServiceExecution.Verify(s => s.Execute(out errors, 0)); }
public override Guid Execute(out ErrorResultTO errors, int update) { Dev2Logger.Log.Info(String.Format("Starting Remote Execution. Service Name:{0} Resource Id:{1} Mode:{2}", DataObject.ServiceName, DataObject.ResourceID, DataObject.IsDebug ? "Debug" : "Execute")); var serviceName = DataObject.ServiceName; errors = new ErrorResultTO(); // get data in a format we can send ;) Dev2Logger.Log.Debug("Creating DataList fragment for remote execute"); var dataListFragment = ExecutionEnvironmentUtils.GetXmlInputFromEnvironment(DataObject, DataObject.RemoteInvokeResultShape.ToString(), update); string result = string.Empty; var connection = GetConnection(DataObject.EnvironmentID); if (connection == null) { errors.AddError("Server source not found."); return DataObject.DataListID; } try { // Invoke Remote WF Here ;) result = ExecuteGetRequest(connection, serviceName, dataListFragment); IList<IDebugState> msg = DataObject.IsDebug? FetchRemoteDebugItems(connection):new List<IDebugState>(); DataObject.RemoteDebugItems = msg; // set them so they can be acted upon } catch (Exception e) { var errorMessage = e.Message.Contains("Forbidden") ? "Executing a service requires Execute permissions" : e.Message; DataObject.Environment.Errors.Add(errorMessage); Dev2Logger.Log.Error(e); } // Create tmpDL ExecutionEnvironmentUtils.UpdateEnvironmentFromOutputPayload(DataObject,result.ToStringBuilder(),DataObject.RemoteInvokeResultShape.ToString(), update); Dev2Logger.Log.Info(String.Format("Completed Remote Execution. Service Name:{0} Resource Id:{1} Mode:{2}", DataObject.ServiceName, DataObject.ResourceID, DataObject.IsDebug ? "Debug" : "Execute")); return Guid.Empty; }
/// <summary> /// Invokes the workflow. /// </summary> /// <param name="workflowActivity">The workflow activity.</param> /// <param name="dataTransferObject">The data transfer object.</param> /// <param name="executionExtensions">The execution extensions.</param> /// <param name="instanceId">The instance id.</param> /// <param name="workspace">The workspace.</param> /// <param name="bookmarkName">Name of the bookmark.</param> /// <param name="errors">The errors.</param> /// <returns></returns> public IDSFDataObject InvokeWorkflow(Activity workflowActivity, IDSFDataObject dataTransferObject, IList<object> executionExtensions, Guid instanceId, IWorkspace workspace, string bookmarkName, out ErrorResultTO errors) { return InvokeWorkflowImpl(workflowActivity, dataTransferObject, executionExtensions, instanceId, workspace, bookmarkName, dataTransferObject.IsDebug, out errors); }
public WorkflowApplicationRun(WorkflowApplicationFactory owner, ManualResetEventSlim waitHandle, IDSFDataObject dataTransferObject, WorkflowApplication instance, IWorkspace workspace, IList<object> executionExtensions, Guid parentWorkflowInstanceId, bool isDebug, ErrorResultTO errors, IExecutionToken executionToken) { _owner = owner; _waitHandle = waitHandle; _result = dataTransferObject; _instance = instance; _workspace = workspace; _executionExtensions = executionExtensions; _isDebug = isDebug; _parentWorkflowInstanceID = parentWorkflowInstanceId; _executionToken = executionToken; _instance.PersistableIdle = OnPersistableIdle; _instance.Unloaded = OnUnloaded; _instance.Completed = OnCompleted; _instance.Aborted = OnAborted; _instance.OnUnhandledException = OnUnhandledException; AllErrors = errors; }
/// <summary> /// Invokes the workflow impl. /// </summary> /// <param name="workflowActivity">The workflow activity.</param> /// <param name="dataTransferObject">The data transfer object.</param> /// <param name="executionExtensions">The execution extensions.</param> /// <param name="instanceId">The instance id.</param> /// <param name="workspace">The workspace.</param> /// <param name="bookmarkName">Name of the bookmark.</param> /// <param name="isDebug">if set to <c>true</c> [is debug].</param> /// <param name="errors">The errors.</param> /// <returns></returns> private IDSFDataObject InvokeWorkflowImpl(Activity workflowActivity, IDSFDataObject dataTransferObject, IList<object> executionExtensions, Guid instanceId, IWorkspace workspace, string bookmarkName, bool isDebug, out ErrorResultTO errors) { Tracker.TrackEvent(TrackerEventGroup.Workflows, TrackerEventName.Executed, string.Format("RES-{0}", dataTransferObject.ResourceID)); if(AllErrors == null) { AllErrors = new ErrorResultTO(); } IExecutionToken exeToken = new ExecutionToken { IsUserCanceled = false }; ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.StartedCallback); WorkflowApplication wfApp = InitEntryPoint(workflowActivity, dataTransferObject, executionExtensions, instanceId, workspace, bookmarkName); errors = new ErrorResultTO(); if(wfApp != null) { // add termination token wfApp.Extensions.Add(exeToken); using(ManualResetEventSlim waitHandle = new ManualResetEventSlim(false)) { WorkflowApplicationRun run = new WorkflowApplicationRun(this, waitHandle, dataTransferObject, wfApp, workspace, executionExtensions, FetchParentInstanceId(dataTransferObject), isDebug, errors, exeToken); if(instanceId == Guid.Empty) { Interlocked.Increment(ref Balance); run.Run(); _runTime = DateTime.Now; waitHandle.Wait(); } else { Interlocked.Increment(ref Balance); try { if(!string.IsNullOrEmpty(bookmarkName)) { dataTransferObject.CurrentBookmarkName = bookmarkName; run.Resume(dataTransferObject); } else { run.Run(); _runTime = DateTime.Now; } waitHandle.Wait(); } catch(InstanceNotReadyException e1) { Interlocked.Decrement(ref Balance); ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback); errors.AddError(e1.Message); AllErrors.AddError(e1.Message); return null; } catch(InstancePersistenceException e2) { Interlocked.Decrement(ref Balance); ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback); errors.AddError(e2.Message); AllErrors.AddError(e2.Message); return run.DataTransferObject.Clone(); } catch(Exception ex) { Interlocked.Decrement(ref Balance); errors.AddError(ex.Message); AllErrors.AddError(ex.Message); ExecutionStatusCallbackDispatcher.Instance.Post(dataTransferObject.ExecutionCallbackID, ExecutionStatusCallbackMessageType.ErrorCallback); return run.DataTransferObject.Clone(); } } Interlocked.Decrement(ref Balance); dataTransferObject = run.DataTransferObject.Clone(); var wfappUtils = new WfApplicationUtils(); ErrorResultTO invokeErrors; if (dataTransferObject.IsDebugMode()) { wfappUtils.DispatchDebugState(dataTransferObject, StateType.End, AllErrors.HasErrors(), AllErrors.MakeDisplayReady(), out invokeErrors, _runTime, false, true); } //AllErrors.MergeErrors(invokeErrors); // avoid memory leak ;) run.Dispose(); } } else { errors.AddError("Internal System Error : Could not create workflow execution wrapper"); } return dataTransferObject; }
public abstract Guid Execute(out ErrorResultTO errors);