public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
IWebSocketWrapper client = null;
try
{
var serializer = new Dev2JsonSerializer();
var result = new List <IExecutionHistory>();
if (values == null)
{
throw new InvalidDataContractException(ErrorResource.NoParameter);
}
values.TryGetValue("ResourceId", out StringBuilder triggerID);
if (triggerID != null)
{
client = _webSocketPool.Acquire(Config.Auditing.Endpoint).Connect();
Dev2Logger.Info("Get Execution History Data from Logger Service. " + triggerID, GlobalConstants.WarewolfInfo);
var response = "";
var message = new AuditCommand
{
Type = "TriggerQuery",
Query = values
};
try
{
var ewh = new EventWaitHandle(false, EventResetMode.ManualReset);
client.OnMessage((msgResponse, socket) =>
{
response = msgResponse;
result.AddRange(serializer.Deserialize <List <ExecutionHistory> >(response));
ewh.Set();
});
client.SendMessage(serializer.Serialize(message));
ewh.WaitOne(_waitTimeOut);
return(serializer.SerializeToBuilder(result));
}
catch (Exception e)
{
Dev2Logger.Info("Get Execution History Data ServiceError", e, GlobalConstants.WarewolfInfo);
}
return(serializer.SerializeToBuilder(result));
}
Dev2Logger.Debug("No QueueName Provided", GlobalConstants.WarewolfDebug);
return(serializer.SerializeToBuilder(new List <IExecutionHistory>()));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
throw;
}
finally
{
if (client != null)
{
_webSocketPool.Release(client);
}
}
}
public static void SetupForRemoteInvoke(this IDSFDataObject dataObject, NameValueCollection headers)
{
Dev2Logger.Debug("Remote Invoke");
if (headers != null)
{
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;
}
}
}
private void AddResourceAsDynamicServiceObject(List <DynamicServiceObjectBase> result, IResource resource)
{
if (resource.ResourceType == "ReservedService")
{
var managementResource = resource as ManagementServiceResource;
if (managementResource != null)
{
result.Add(managementResource.Service);
}
}
else
{
List <DynamicServiceObjectBase> objects;
if (!FrequentlyUsedServices.TryGetValue(resource.ResourceName, out objects))
{
objects = GenerateObjectGraph(resource);
}
else
{
Dev2Logger.Debug($"{resource.ResourceName} -> Resource Catalog Cache HIT");
}
if (objects != null)
{
result.AddRange(objects);
}
}
}
override protected void EvalInner(IDSFDataObject dsfDataObject, IDev2Activity resource, int update)
{
try
{
AddExecutionToExecutionManager(dsfDataObject, resource);
WorkflowExecutionWatcher.HasAWorkflowBeenExecuted = true;
Dev2Logger.Debug("Starting Execute", GlobalConstants.WarewolfDebug);
var lastActivity = resource;
ExecuteNode(dsfDataObject, update, ref resource, ref lastActivity);
if (!dsfDataObject.StopExecution & dsfDataObject.ExecutionException is null)
{
dsfDataObject.StateNotifier?.LogExecuteCompleteState(lastActivity);
}
}
finally
{
dsfDataObject.StateNotifier?.Dispose();
_executionManager?.CompleteExecution();
}
}
public int WriteToSftp(Stream src, IActivityIOPath dst)
{
var result = -1;
if (dst != null)
{
var sftp = BuildSftpClient(dst);
if (src != null)
{
using (src)
{
try
{
var path = ExtractFileNameFromPath(dst.Path);
sftp.UploadFile(src, path);
result = (int)src.Length;
sftp.Disconnect();
sftp.Dispose();
}
catch (Exception e)
{
Dev2Logger.Debug(@"Exception WriteToSFTP", e, GlobalConstants.WarewolfDebug);
sftp.Disconnect();
sftp.Dispose();
throw new Exception(ErrorResource.FileNotCreated);
}
}
}
}
return(result);
}
void AddResourceAsDynamicServiceObject(List <DynamicServiceObjectBase> result, IResource resource)
{
if (resource.ResourceType == "ReservedService")
{
if (resource is ManagementServiceResource managementResource)
{
result.Add(managementResource.Service);
}
}
else
{
if (!FrequentlyUsedServices.TryGetValue(resource.ResourceName, out List <DynamicServiceObjectBase> objects))
{
objects = GenerateObjectGraph(resource);
}
else
{
Dev2Logger.Debug($"{resource.ResourceName} -> Resource Catalog Cache HIT", GlobalConstants.WarewolfDebug);
}
if (objects != null)
{
result.AddRange(objects);
}
}
}
protected override List <string> PerformExecution(Dictionary <string, string> evaluatedValues)
{
try
{
RedisSource = ResourceCatalog.GetResource <RedisSource>(GlobalConstants.ServerWorkspaceID, SourceId);
if (RedisSource == null || RedisSource.ResourceType != enSourceType.RedisSource.ToString())
{
_messages.Add(ErrorResource.RedisSourceHasBeenRemoved);
return(_messages);
}
_redisCache = new RedisCacheImpl(RedisSource.HostName, Convert.ToInt32(RedisSource.Port), RedisSource.Password);
if (CounterType == "Increment")
{
_result = _redisCache.Increment(Key, StepSize);
Dev2Logger.Debug($"Cache {Key} Incremented {StepSize}: {_result}", GlobalConstants.WarewolfDebug);
}
else
{
_result = _redisCache.Decrement(Key, StepSize);
Dev2Logger.Debug($"Cache {Key} Decremented {StepSize}: {_result}", GlobalConstants.WarewolfDebug);
}
return(new List <string> {
_result.ToString()
});
}
catch (Exception ex)
{
Dev2Logger.Error(nameof(RedisCounterActivity), ex, GlobalConstants.WarewolfError);
throw new Exception(ex.GetAllMessages());
}
}
protected override void Eval(Guid resourceID, IDSFDataObject dataObject)
{
var executionId = dataObject.ExecutionID.ToString();
var versionNumber = dataObject.VersionNumber;
Dev2Logger.Debug("Getting Resource to Execute", executionId);
var hasVersionOverride = false;
if (versionNumber != 0)
{
hasVersionOverride = true;
}
IDev2Activity startActivity;
if (hasVersionOverride)
{
var resumeVersionNumber = versionNumber;
if (resumeVersionNumber == 0)
{
resumeVersionNumber = _resourceCatalog.GetLatestVersionNumberForResource(resourceId: resourceID);
}
var resourceObject = _resourceCatalog.GetResource(GlobalConstants.ServerWorkspaceID, resourceID, resumeVersionNumber.ToString());
startActivity = _resourceCatalog.Parse(TheWorkspace.ID, resourceID, executionId, resourceObject);
}
else
{
startActivity = _resourceCatalog.Parse(TheWorkspace.ID, resourceID, executionId);
}
Dev2Logger.Debug("Got Resource to Execute", executionId);
EvalInner(dataObject, startActivity, dataObject.ForEachUpdateValue);
}
public IDev2Activity Parse(Guid workspaceID, Guid resourceID)
{
IResourceActivityCache parser = null;
Dev2Logger.Debug($"Fetching Execution Plan for {resourceID} for workspace {workspaceID}");
if (_parsers != null && !_parsers.TryGetValue(workspaceID, out parser))
{
parser = new ResourceActivityCache(CustomContainer.Get <IActivityParser>(), new ConcurrentDictionary <Guid, IDev2Activity>());
_parsers.Add(workspaceID, parser);
}
if (parser != null && parser.HasActivityInCache(resourceID))
{
var dev2Activity = parser.GetActivity(resourceID);
if (dev2Activity != null)
{
return(dev2Activity);
}
}
var resource = GetResource(workspaceID, resourceID);
var service = GetService(workspaceID, resourceID, resource.ResourceName);
if (service != null)
{
var sa = service.Actions.FirstOrDefault();
MapServiceActionDependencies(workspaceID, sa);
ServiceActionRepo.Instance.AddToCache(resourceID, service);
var activity = GetActivity(sa);
if (parser != null)
{
return(parser.Parse(activity, resourceID));
}
}
return(null);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2Logger.Debug("Start Security Read", GlobalConstants.WarewolfDebug);
var serverSecuritySettingsFile = EnvironmentVariables.ServerSecuritySettingsFile;
if (File.Exists(serverSecuritySettingsFile))
{
string encryptedData;
using (var inStream = new FileStream(serverSecuritySettingsFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (var reader = new StreamReader(inStream))
{
encryptedData = reader.ReadToEnd();
}
}
Dev2Logger.Debug("Security Data Read", GlobalConstants.WarewolfDebug);
try
{
return(Execute(encryptedData));
}
catch (Exception e)
{
Dev2Logger.Error("SecurityRead", e, GlobalConstants.WarewolfError);
}
}
var serializer = new Dev2JsonSerializer();
var securitySettingsTo = new SecuritySettingsTO(DefaultPermissions)
{
CacheTimeout = _cacheTimeout
};
return(serializer.SerializeToBuilder(securitySettingsTo));
}
public IDbConnection CreateConnection(string connectionString)
{
VerifyArgument.IsNotNull("connectionString", connectionString);
if (connectionString.CanBeDecrypted())
{
connectionString = DpapiWrapper.Decrypt(connectionString);
}
_sqlConnection = new SqlConnection(connectionString);
_sqlConnection.FireInfoMessageEventOnUserErrors = true;
_sqlConnection.StatisticsEnabled = true;
_sqlConnection.InfoMessage += (sender, args) =>
{
Dev2Logger.Debug("SQL Server:" + args.Message + " Source:" + args.Source);
foreach (SqlError error in args.Errors)
{
var errorMessages = new StringBuilder();
errorMessages.Append("Index #" + error.Number + Environment.NewLine +
"Message: " + error.Message + Environment.NewLine +
"LineNumber: " + error.LineNumber + Environment.NewLine +
"Source: " + error.Source + Environment.NewLine +
"Procedure: " + error.Procedure + Environment.NewLine);
Dev2Logger.Error("SQL Error:" + errorMessages.ToString());
}
};
return(_sqlConnection);
}
public override SerializableResource FetchRemoteResource(Guid serviceId, string serviceName, bool isDebugMode)
{
var connection = GetConnection(DataObject.EnvironmentID);
if (connection == null)
{
return(null);
}
try
{
var returnData = ExecuteGetRequest(connection, "FindResourceService", $"ResourceType=TypeWorkflowService&ResourceName={serviceName}&ResourceId={serviceId}", isDebugMode);
if (!string.IsNullOrEmpty(returnData))
{
var serializer = new Dev2JsonSerializer();
var serializableResources = serializer.Deserialize <IList <SerializableResource> >(returnData);
return(serializableResources.FirstOrDefault(resource => resource.ResourceType == "WorkflowService"));
}
}
catch (Exception e)
{
Dev2Logger.Debug(GlobalConstants.WarewolfDebug, "Error fetching remote resource: " + e.Message);
return(null);
}
return(null);
}
/// <summary>
/// Execute using workflow and parameters as defined in DataObject
/// </summary>
/// <param name="errors"></param>
/// <param name="update"></param>
/// <returns>Resulting DataListId</returns>
public override Guid Execute(out ErrorResultTO errors, int update)
{
SetDataObjectProperties();
var user = Thread.CurrentPrincipal;
var dataObjectExecutionId = DataObject.ExecutionID.ToString();
if (!DataObject.IsSubExecution)
{
var userIdentity = user?.Identity;
Dev2Logger.Debug(string.Format(GlobalConstants.ExecuteWebRequestString, DataObject.ServiceName, userIdentity?.Name, userIdentity?.AuthenticationType, userIdentity?.IsAuthenticated, DataObject.RawPayload), dataObjectExecutionId);
Dev2Logger.Debug("Request URL [ " + DataObject.WebUrl + " ]", dataObjectExecutionId);
}
Dev2Logger.Debug("Entered Wf Container", dataObjectExecutionId);
DataObject.ServiceName = ServiceAction.ServiceName;
var executionForServiceString = string.Format(GlobalConstants.ExecutionForServiceString, DataObject.ServiceName, DataObject.ResourceID, (DataObject.IsDebug ? "Debug" : $"Execute"));
Dev2Logger.Info("Started " + executionForServiceString, dataObjectExecutionId);
SetExecutionOrigin();
var userPrinciple = Thread.CurrentPrincipal; // TODO: can we remove this second call the get_CurrentPrincipal
var result = GlobalConstants.NullDataListID;
Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { result = ExecuteWf(); });
errors = AddErrors();
var executionTypeString = DataObject.IsSubExecution ? "Completed Sub " : "Completed ";
Dev2Logger.Info(executionTypeString + executionForServiceString, dataObjectExecutionId);
return(result);
}
public Guid ExecuteRequest(IDSFDataObject dataObject, EsbExecuteRequest request, Guid workspaceId, out ErrorResultTO errors)
{
var resultID = GlobalConstants.NullDataListID;
errors = new ErrorResultTO();
IWorkspace theWorkspace = null;
Common.Utilities.PerformActionInsideImpersonatedContext(Common.Utilities.ServerUser, () =>
{
theWorkspace = WorkspaceRepository.Instance.Get(workspaceId);
});
var dataListOkay = EnsureDataListIdIsSet(dataObject, workspaceId, errors);
if (!dataListOkay)
{
return(resultID);
}
try
{
Dev2Logger.Debug("Creating Invoker", dataObject.ExecutionID.ToString());
using (var invoker = new EsbServiceInvoker(this, theWorkspace, request))
{
resultID = invoker.Invoke(dataObject, out var invokeErrors);
errors.MergeErrors(invokeErrors);
}
}
catch (Exception ex)
{
errors.AddError(ex.Message);
}
return(resultID);
}
public ServerProxyWithoutChunking(string serverUri, ICredentials credentials, IAsyncWorker worker)
{
IsAuthorized = true;
VerifyArgument.IsNotNull("serverUri", serverUri);
ServerEvents = EventPublishers.Studio;
var uriString = serverUri;
if (!serverUri.EndsWith("dsf"))
{
uriString = serverUri + (serverUri.EndsWith("/") ? "" : "/") + "dsf";
}
Principal = ClaimsPrincipal.Current;
AppServerUri = new Uri(uriString);
WebServerUri = new Uri(uriString.Replace("/dsf", ""));
Dev2Logger.Debug(credentials);
Dev2Logger.Debug("***** Attempting Server Hub : " + uriString + " -> " + CredentialCache.DefaultNetworkCredentials.Domain + @"\" + Principal.Identity.Name);
HubConnection = new HubConnectionWrapper(uriString)
{
Credentials = credentials
};
HubConnection.Error += OnHubConnectionError;
HubConnection.Closed += HubConnectionOnClosed;
HubConnection.StateChanged += HubConnectionStateChanged;
InitializeEsbProxy();
AsyncWorker = worker;
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
values.TryGetValue("Resource", out StringBuilder tmp);
var serializer = new Dev2JsonSerializer();
if (tmp != null)
{
var res = serializer.Deserialize <IScheduledResource>(tmp);
Dev2Logger.Info("Get Scheduled History. " + tmp, GlobalConstants.WarewolfInfo);
IList <IResourceHistory> resources;
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
resources = model.CreateHistory(res);
}
return(serializer.SerializeToBuilder(resources));
}
Dev2Logger.Debug("No resource Provided", GlobalConstants.WarewolfDebug);
return(serializer.SerializeToBuilder(new List <IResourceHistory>()));
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
throw;
}
}
void AddItemToTreeImpl(IDebugState content)
{
if ((DebugStatus == DebugStatus.Stopping || DebugStatus == DebugStatus.Finished || _allDebugReceived) && string.IsNullOrEmpty(content.Message) && !_continueDebugDispatch && !_dispatchLastDebugState)
{
return;
}
Dev2Logger.Debug(string.Format("Debug content to be added ID: {0}" + Environment.NewLine + "Parent ID: {1}" + Environment.NewLine + "Name: {2}", content.ID, content.ParentID.GetValueOrDefault(), content.DisplayName), "Warewolf Debug");
if (_lastStep != null && DebugStatus == DebugStatus.Finished && content.StateType == StateType.Message)
{
var lastDebugStateProcessed = _lastStep;
_lastStep = null;
_dispatchLastDebugState = true;
AddItemToTreeImpl(new DebugState {
StateType = StateType.Message, Message = Resources.CompilerMessage_ExecutionInterrupted, ParentID = lastDebugStateProcessed.ParentID.GetValueOrDefault()
});
AddItemToTreeImpl(lastDebugStateProcessed);
_dispatchLastDebugState = false;
}
if (!string.IsNullOrWhiteSpace(SearchText) && !_debugOutputFilterStrategy.Filter(content, SearchText))
{
return;
}
if (AddTreeViewItemToRootItems(content))
{
return;
}
if (content.IsFinalStep())
{
DebugStatus = DebugStatus.Finished;
}
}
public virtual async Task ReadAsync()
{
if (EnvironmentConnection.IsConnected)
{
var communicationController = new CommunicationController
{
ServiceName = "SecurityReadService"
};
Dev2Logger.Debug("Getting Permissions from Server", "Warewolf Debug");
var securitySettingsTo = await communicationController.ExecuteCommandAsync <SecuritySettingsTO>(EnvironmentConnection, EnvironmentConnection.WorkspaceID).ConfigureAwait(true);
List <WindowsGroupPermission> newPermissions = null;
if (securitySettingsTo != null)
{
Permissions = securitySettingsTo.WindowsGroupPermissions;
newPermissions = securitySettingsTo.WindowsGroupPermissions;
Dev2Logger.Debug("Permissions from Server:" + Permissions, "Warewolf Debug");
}
if (newPermissions != null)
{
RaisePermissionsModified(new PermissionsModifiedEventArgs(newPermissions));
}
RaisePermissionsChanged();
}
}
protected virtual string ExecuteGetRequest(Connection connection, string serviceName, string payload, bool isDebugMode)
{
var result = string.Empty;
var serviceToExecute = GetServiceToExecute(connection, serviceName);
var requestUri = serviceToExecute + "?" + payload;
var req = BuildGetWebRequest(requestUri, connection.AuthenticationType, connection.UserName, connection.Password, isDebugMode)
?? BuildPostRequest(serviceToExecute, payload, connection.AuthenticationType, connection.UserName, connection.Password, isDebugMode);
Dev2Logger.Debug("Executing the remote request.", GlobalConstants.WarewolfDebug);
if (req != null)
{
using (var response = req.GetResponse())
{
if (response != null)
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
result = reader.ReadToEnd();
}
}
}
}
return(result);
}
protected bool TransferDirectoryContents(IActivityIOOperationsEndPoint src, IActivityIOOperationsEndPoint dst, IDev2CRUDOperationTO args)
{
if (!args.Overwrite)
{
ValidateSourceAndDestinationContents(src, dst, args);
}
if (args.DoRecursiveCopy)
{
RecursiveCopy(src, dst, args);
}
var srcContents = src.ListFilesInDirectory(src.IOPath);
var result = true;
var origDstPath = Dev2ActivityIOPathUtils.ExtractFullDirectoryPath(dst.IOPath.Path);
if (!dst.PathExist(dst.IOPath))
{
CreateDirectory(dst, args);
}
// TODO: cleanup this code so that result is easier to follow
foreach (var p in srcContents)
{
result = PerformTransfer(src, dst, args, origDstPath, p, result);
}
Dev2Logger.Debug($"Transfered: {src.IOPath.Path}", GlobalConstants.WarewolfDebug);
return(result);
}
/// <summary>
/// Adds the resource.
/// </summary>
/// <param name="res">The res.</param>
/// <param name="filePath">The file path.</param>
private void AddResource(IResource res, string filePath)
{
if (!_addedResources.Contains(res.ResourceID))
{
_resources.Add(res);
_addedResources.Add(res.ResourceID);
}
else
{
var dupRes = _resources.Find(c => c.ResourceID == res.ResourceID);
if (dupRes != null)
{
CreateDupResource(dupRes, filePath);
Dev2Logger.Debug(
string.Format(ErrorResource.ResourceAlreadyLoaded,
res.ResourceName, filePath, dupRes.FilePath));
}
else
{
Dev2Logger.Debug(string.Format(
"Resource '{0}' from file '{1}' wasn't loaded because a resource with the same name has already been loaded but cannot find its location.",
res.ResourceName, filePath));
}
}
}
private static void ExecuteNode(IDSFDataObject dsfDataObject, int update, ref IDev2Activity next, ref IDev2Activity lastActivity)
{
var environment = dsfDataObject.Environment;
try
{
Dev2Logger.Debug("Executing first node", GlobalConstants.WarewolfDebug);
while (next != null)
{
var current = next;
lastActivity = current;
next = ExecuteTool(dsfDataObject, current, update);
environment.AllErrors.UnionWith(environment.Errors);
if (dsfDataObject.StopExecution)
{
dsfDataObject.StateNotifier?.LogStopExecutionState(lastActivity);
dsfDataObject.ExecutionException = new Exception(dsfDataObject.Environment.FetchErrors());
break;
}
}
}
catch (Exception exception)
{
Dev2Logger.Error(exception.Message, GlobalConstants.WarewolfError);
dsfDataObject.ExecutionException = new Exception(dsfDataObject.Environment.FetchErrors());
dsfDataObject.StateNotifier?.LogExecuteException(exception, lastActivity);
}
}
protected virtual string ExecuteGetRequest(Connection connection, string serviceName, string payload, bool isDebugMode = true)
{
var result = string.Empty;
var serviceToExecute = GetServiceToExecute(connection, serviceName);
var requestUri = serviceToExecute + "?" + payload;
var req = BuildGetWebRequest(requestUri, connection.AuthenticationType, connection.UserName, connection.Password, isDebugMode) ?? BuildPostRequest(serviceToExecute, payload, connection.AuthenticationType, connection.UserName, connection.Password, isDebugMode);
Dev2Logger.Debug("Executing the remote request.");
if (req != null)
{
using (var response = req.GetResponse() as HttpWebResponse)
{
if (response != null)
{
// ReSharper disable AssignNullToNotNullAttribute
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
// ReSharper restore AssignNullToNotNullAttribute
{
result = reader.ReadToEnd();
}
}
}
}
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();
var result = GlobalConstants.NullDataListID;
DataObject.ExecutionID = DataObject.ExecutionID ?? Guid.NewGuid();
var user = Thread.CurrentPrincipal;
if (string.IsNullOrEmpty(DataObject.WebUrl))
{
DataObject.WebUrl = $"{EnvironmentVariables.WebServerUri}secure/{DataObject.ServiceName}.{DataObject.ReturnType}?" + DataObject.QueryString;
}
var dataObjectExecutionId = DataObject.ExecutionID.ToString();
if (!DataObject.IsSubExecution)
{
Dev2Logger.Debug(string.Format(GlobalConstants.ExecuteWebRequestString, DataObject.ServiceName, user?.Identity?.Name, user?.Identity?.AuthenticationType, user?.Identity?.IsAuthenticated, DataObject.RawPayload), dataObjectExecutionId);
Dev2Logger.Debug("Request URL [ " + DataObject.WebUrl + " ]", dataObjectExecutionId);
}
Dev2Logger.Debug("Entered Wf Container", dataObjectExecutionId);
DataObject.ServiceName = ServiceAction.ServiceName;
if (DataObject.ServerID == Guid.Empty)
{
DataObject.ServerID = HostSecurityProvider.Instance.ServerID;
}
var executionForServiceString = string.Format(GlobalConstants.ExecutionForServiceString, DataObject.ServiceName, DataObject.ResourceID, (DataObject.IsDebug ? "Debug" : "Execute"));
Dev2Logger.Info("Started " + executionForServiceString, dataObjectExecutionId);
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;
Common.Utilities.PerformActionInsideImpersonatedContext(userPrinciple, () => { result = ExecuteWf(); });
foreach (var err in DataObject.Environment.Errors)
{
errors.AddError(err, true);
}
foreach (var err in DataObject.Environment.AllErrors)
{
errors.AddError(err, true);
}
var executionTypeString = DataObject.IsSubExecution ? "Completed Sub " : "Completed ";
Dev2Logger.Info(executionTypeString + executionForServiceString, dataObjectExecutionId);
return(result);
}
void Eval(Guid resourceID, IDSFDataObject dataObject)
{
Dev2Logger.Debug("Getting Resource to Execute", dataObject.ExecutionID.ToString());
var resource = ResourceCatalog.Instance.Parse(TheWorkspace.ID, resourceID, dataObject.ExecutionID.ToString());
Dev2Logger.Debug("Got Resource to Execute", dataObject.ExecutionID.ToString());
EvalInner(dataObject, resource, dataObject.ForEachUpdateValue);
}
void RaisePermissionsModified(List <WindowsGroupPermission> args)
{
if (PermissionsModified != null)
{
Dev2Logger.Debug("Permissions Modified: " + args, "Warewolf Debug");
PermissionsModified(this, args);
}
}
private void Eval(Guid resourceID, IDSFDataObject dataObject)
{
Dev2Logger.Debug("Getting Resource to Execute");
IDev2Activity resource = ResourceCatalog.Instance.Parse(TheWorkspace.ID, resourceID);
Dev2Logger.Debug("Got Resource to Execute");
EvalInner(dataObject, resource, dataObject.ForEachUpdateValue);
}
private void ExecuteSaveDataFunc()
{
if (SaveDataFunc.Handler is IDev2Activity act)
{
_childUniqueId = act.UniqueID;
act.Execute(_dataObject, 0);
Dev2Logger.Debug("Save SuspensionId: Execute - " + act.GetDisplayName(), _dataObject.ExecutionID.ToString());
}
}
public static bool IsAuthenticated(this IPrincipal user)
{
if (user == null)
{
Dev2Logger.Debug("Null User");
}
return(user != null && user.Identity.IsAuthenticated);
}
public static bool IsAuthenticated(this IPrincipal user)
{
if (user == null)
{
Dev2Logger.Debug("Null User", GlobalConstants.WarewolfDebug);
}
return(user != null && user.Identity.IsAuthenticated);
}