public void DeployResource(IResourceModel resource, string savePath)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
Dev2Logger.Info($"Deploy Resource. Resource:{resource.DisplayName} Environment:{_server.Name}");
var theResource = FindSingle(c => c.ResourceName.Equals(resource.ResourceName, StringComparison.CurrentCultureIgnoreCase));
if (theResource != null)
{
_resourceModels.Remove(theResource);
}
theResource = new ResourceModel(_server);
theResource.Update(resource);
_resourceModels.Add(theResource);
var comsController = new CommunicationController {
ServiceName = "DeployResourceService"
};
comsController.AddPayloadArgument("savePath", savePath);
comsController.AddPayloadArgument("ResourceDefinition", resource.ToServiceDefinition(true));
comsController.AddPayloadArgument("Roles", "*");
var con = _server.Connection;
var executeCommand = comsController.ExecuteCommand <ExecuteMessage>(con, GlobalConstants.ServerWorkspaceID);
if (executeCommand != null && executeCommand.HasError)
{
throw new Exception(executeCommand.Message.ToString());
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
if (values == null)
{
throw new InvalidDataContractException(ErrorResource.NoParameter);
}
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Trigger Queue Service", GlobalConstants.WarewolfInfo);
msg.HasError = false;
values.TryGetValue("TriggerQueue", out StringBuilder resourceDefinition);
var triggerQueue = serializer.Deserialize <ITriggerQueue>(resourceDefinition);
TriggersCatalog.Instance.SaveTriggerQueue(triggerQueue);
msg.SetMessage(triggerQueue.TriggerId.ToString());
return(serializer.SerializeToBuilder(msg));
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error("Save Queue Service Failed: " + err.Message, GlobalConstants.WarewolfError);
return(serializer.SerializeToBuilder(msg));
}
}
internal static async Task <int> RunMain(string[] arguments)
{
SetWorkingDirectory();
const int Result = 0;
if (Environment.UserInteractive || (arguments.Any() && arguments[0] == "--interactive"))
{
Dev2Logger.Info("** Starting In Interactive Mode **", GlobalConstants.WarewolfInfo);
var manager = new ServerLifecycleManager(new ServerEnvironmentPreparer());
var runTask = manager.Run(new LifeCycleInitializationList());
runTask.Wait();
WaitForUserExit(manager);
}
else
{
Dev2Logger.Info("** Starting In Service Mode **", GlobalConstants.WarewolfInfo);
using (var service = new ServerLifecycleManagerService())
{
ServiceBase.Run(service);
if (!service.RunSuccessful)
{
Dev2Logger.Warn("** Service Mode Failed to Start **", GlobalConstants.WarewolfWarn);
return(-1);
}
}
}
return(Result);
}
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 IExecutionEnvironment Execute(int update, bool handleErrors)
{
var wasTestExecution = _dataObject.IsServiceTestExecution;
_dataObject.IsSubExecution = true;
try
{
_dataObject.IsServiceTestExecution = false;
var principle = Thread.CurrentPrincipal;
Dev2Logger.Info("SUB-EXECUTION USER CONTEXT IS [ " + principle.Identity.Name + " ] FOR SERVICE [ " + _dataObject.ServiceName + " ]", _dataObject.ExecutionID.ToString());
_dataObject.StartTime = DateTime.Now;
var result = ExecuteWorkflow(wasTestExecution, update, handleErrors);
if (result != null)
{
return(result);
}
_dataObject.StartTime = _oldStartTime;
return(new ExecutionEnvironment());
}
finally
{
_dataObject.IsServiceTestExecution = wasTestExecution;
_dataObject.IsSubExecution = false;
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var result = new ExecuteMessage {
HasError = false
};
Dev2Logger.Info("Delete Scheduled Resource Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("Resource", out StringBuilder tmp);
var serializer = new Dev2JsonSerializer();
if (tmp != null)
{
var res = serializer.Deserialize <IScheduledResource>(tmp);
Dev2Logger.Info("Delete Scheduled Resource Service." + res, GlobalConstants.WarewolfInfo);
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
model.DeleteSchedule(res);
}
}
else
{
Dev2Logger.Info("Delete Scheduled Resource Service. No Resource Selected", GlobalConstants.WarewolfInfo);
result.Message.Append("No Resource Selected");
result.HasError = true;
}
return(serializer.SerializeToBuilder(result));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Trigger Queue Service", GlobalConstants.WarewolfInfo);
var triggerQueues = TriggersCatalog.Queues;
var message = new CompressedExecuteMessage
{
HasError = false
};
message.SetMessage(serializer.Serialize(triggerQueues));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
var msg = new ExecuteMessage
{
HasError = true,
Message = new StringBuilder(err.Message)
};
Dev2Logger.Error("Fetch Queue Service Failed: " + err.Message, GlobalConstants.WarewolfError);
return(serializer.SerializeToBuilder(msg));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Delete Test Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("resourceID", out StringBuilder resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
if (!Guid.TryParse(resourceIdString.ToString(), out Guid resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
TestCoverageCatalog.DeleteAllCoverageReports(resourceId);
var message = new CompressedExecuteMessage {
HasError = false
};
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Fetch Tests Service");
StringBuilder resourceIdString;
values.TryGetValue("resourceID", out resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
Guid resourceId;
if (!Guid.TryParse(resourceIdString.ToString(), out resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var tests = TestCatalog.Fetch(resourceId);
CompressedExecuteMessage message = new CompressedExecuteMessage();
message.SetMessage(serializer.Serialize(tests));
message.HasError = false;
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err);
var res = new CompressedExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
Dev2Logger.Info("Get Dll Listings", GlobalConstants.WarewolfInfo);
values.TryGetValue("currentDllListing", out StringBuilder dllListing);
if (dllListing != null)
{
var src = serializer.Deserialize(dllListing.ToString(), typeof(IFileListing)) as IFileListing;
try
{
msg.HasError = false;
var fileListings = GetDllListing(src);
msg.Message = serializer.SerializeToBuilder(fileListings);
}
catch (Exception ex)
{
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
msg.HasError = true;
msg.SetMessage(ex.Message);
}
}
return(serializer.SerializeToBuilder(msg));
}
protected void RaiseError(string error)
{
HasErrors = true;
Error = error;
Dev2Logger.Info(error);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
string directory = null;
var result = new StringBuilder();
if (values == null)
{
throw new InvalidDataContractException(ErrorResource.NoParameter);
}
values.TryGetValue("Directory", out StringBuilder tmp);
if (tmp != null)
{
directory = tmp.ToString();
}
if (string.IsNullOrEmpty(directory))
{
throw new InvalidDataContractException(ErrorResource.DirectoryIsRequired);
}
Dev2Logger.Info("Get Directories Relative to Server. " + directory, GlobalConstants.WarewolfInfo);
result.Append("<JSON>");
var explorerItem = ServerExplorerRepo.Load("Folder", string.Empty);
var jsonTreeNode = new JsonTreeNode(explorerItem);
var serializer = new Dev2JsonSerializer();
var directoryInfoAsJson = serializer.Serialize(jsonTreeNode);
result.Append(directoryInfoAsJson);
result.Append("</JSON>");
return(result);
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
throw;
}
}
internal void OpenCommand(ExplorerItemViewModel item, IServer server)
{
Dev2Logger.Info("Open resource: " + item.ResourceName + " - ResourceId: " + item.ResourceId, "Warewolf Info");
var applicationTracker = CustomContainer.Get <IApplicationTracker>();
if (applicationTracker != null)
{
if (item.ResourceName == "Shared Resources Server")
{
applicationTracker.TrackEvent(Resources.Languages.TrackEventExplorer.EventCategory,
Resources.Languages.TrackEventExplorer.SharedResourcesServer);
}
if (item.ResourceName == "Hello World")
{
applicationTracker.TrackEvent(Resources.Languages.TrackEventWorkflowTabs.EventCategory,
Resources.Languages.TrackEventWorkflowTabs.HelloWorld);
}
}
if (item.IsFolder)
{
item.IsExpanded = !item.IsExpanded;
}
else if (item.IsResourceVersion)
{
OpenVersionCommand(item.Parent.ResourceId, item.VersionInfo);
}
else
{
SetActiveStates(_shellViewModel, server);
_shellViewModel.OpenResource(item.ResourceId, server.EnvironmentID, server);
}
}
public virtual StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Workflow Resume Service", GlobalConstants.WarewolfInfo);
values.TryGetValue("resourceID", out StringBuilder resourceIdString);
if (resourceIdString == null)
{
throw new InvalidDataContractException("resourceID is missing");
}
if (!Guid.TryParse(resourceIdString.ToString(), out Guid resourceId))
{
throw new InvalidDataContractException("resourceID is not a valid GUID.");
}
var message = ExecuteImpl(serializer, resourceId, values);
return(serializer.SerializeToBuilder(message));
}
catch (Exception err)
{
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
var res = new ExecuteMessage {
HasError = true, Message = new StringBuilder(err.Message)
};
return(serializer.SerializeToBuilder(res));
}
}
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 TryExecute(Dictionary <string, StringBuilder> values, ExecuteMessage result, StringBuilder tmp, Dev2JsonSerializer serializer)
{
if (tmp != null)
{
var res = serializer.Deserialize <IScheduledResource>(tmp);
Dev2Logger.Info("Save Scheduled Resource. Scheduled Resource:" + res, GlobalConstants.WarewolfInfo);
using (var model = SchedulerFactory.CreateModel(GlobalConstants.SchedulerFolderId, SecurityWrapper))
{
values.TryGetValue("UserName", out StringBuilder userName);
values.TryGetValue("Password", out StringBuilder password);
if (userName == null || password == null)
{
result.Message.Append(ErrorResource.NoUserNameAndPassword);
result.HasError = true;
}
else
{
values.TryGetValue("PreviousResource", out StringBuilder previousTask);
model.Save(res, userName.ToString(), password.ToString());
if (!string.IsNullOrEmpty(previousTask?.ToString()) && previousTask.ToString() != res.Name)
{
model.DeleteSchedule(new ScheduledResource(previousTask.ToString(), SchedulerStatus.Disabled, DateTime.MaxValue, null, null, Guid.NewGuid().ToString()));
}
}
}
}
else
{
result.Message.Append(ErrorResource.NoResourceSelected);
result.HasError = true;
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test Elasticsearch Source", GlobalConstants.WarewolfInfo);
msg.HasError = false;
values.TryGetValue(Warewolf.Service.TestElasticsearchSource.ElasticsearchSource, out StringBuilder resourceDefinition);
var elasticsearchServiceSourceDefinition = serializer.Deserialize <ElasticsearchSourceDefinition>(resourceDefinition);
var con = new ElasticsearchSources();
var result = con.Test(new ElasticsearchSource
{
HostName = elasticsearchServiceSourceDefinition.HostName,
Port = elasticsearchServiceSourceDefinition.Port,
Password = elasticsearchServiceSourceDefinition.Password,
Username = elasticsearchServiceSourceDefinition.Username,
AuthenticationType = elasticsearchServiceSourceDefinition.AuthenticationType,
SearchIndex = elasticsearchServiceSourceDefinition.SearchIndex
});
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? serializer.Serialize(result.Result) : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Resource Service");
StringBuilder resourceDefinition;
values.TryGetValue("WcfSource", out resourceDefinition);
var src = serializer.Deserialize <WcfServiceSourceDefinition>(resourceDefinition);
var source = new WcfSource()
{
EndpointUrl = src.EndpointUrl
};
source.Execute();
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err);
}
return(serializer.SerializeToBuilder(msg));
}
public ResourceCatalogResult SaveResource(Guid workspaceID, StringBuilder resourceXml, string savedPath, string reason, string user)
{
try
{
if (resourceXml == null || resourceXml.Length == 0)
{
throw new ArgumentNullException(nameof(resourceXml));
}
var @lock = Common.GetWorkspaceLock(workspaceID);
lock (@lock)
{
var xml = resourceXml.ToXElement();
var resource = new Resource(xml);
GlobalConstants.InvalidateCache(resource.ResourceID);
Dev2Logger.Info("Save Resource." + resource, GlobalConstants.WarewolfInfo);
_serverVersionRepository.StoreVersion(resource, user, reason, workspaceID, savedPath);
resource.UpgradeXml(xml, resource);
var result = xml.ToStringBuilder();
return(CompileAndSave(workspaceID, resource, result, savedPath, reason));
}
}
catch (Exception err)
{
Dev2Logger.Error("Save Error", err, GlobalConstants.WarewolfError);
throw;
}
}
static int RunMain(string[] arguments)
{
const int Result = 0;
AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
{
Dev2Logger.Fatal("Server has crashed!!!", args.ExceptionObject as Exception, "Warewolf Fatal");
};
if (Environment.UserInteractive || (arguments.Count() > 0 && arguments[0] == "--interactive"))
{
Dev2Logger.Info("** Starting In Interactive Mode **", GlobalConstants.WarewolfInfo);
using (_singleton = new ServerLifecycleManager(arguments))
{
_singleton.Run(true);
}
_singleton = null;
}
else
{
Dev2Logger.Info("** Starting In Service Mode **", GlobalConstants.WarewolfInfo);
using (var service = new ServerLifecycleManagerService())
{
ServiceBase.Run(service);
}
}
return(Result);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
Dev2Logger.Info("Get COMDll Listings", GlobalConstants.WarewolfInfo);
try
{
List <DllListing> dllListings;
using (Isolated <ComDllLoaderHandler> isolated = new Isolated <ComDllLoaderHandler>())
{
var openBaseKey = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry32);
dllListings = ComDllLoaderHandler.TryGetListings(openBaseKey);
openBaseKey = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry64);
dllListings.AddRange(ComDllLoaderHandler.TryGetListings(openBaseKey));
}
msg.Message = serializer.SerializeToBuilder(dllListings);
}
catch (COMException ex)
{
msg.HasError = true;
msg.SetMessage(ex.Message);
}
catch (Exception ex)
{
Dev2Logger.Error(ex, GlobalConstants.WarewolfError);
msg.HasError = true;
msg.SetMessage(ex.Message);
}
return(serializer.SerializeToBuilder(msg));
}
public IList <IServer> LookupEnvironments(IServer defaultEnvironment, IList <string> environmentGuids)
{
if (defaultEnvironment == null)
{
throw new ArgumentNullException(nameof(defaultEnvironment));
}
var result = new List <IServer>();
try
{
defaultEnvironment.Connect();
}
catch (Exception err)
{
Dev2Logger.Info(err, "Warewolf Info");
//Swallow exception for localhost connection
}
if (!defaultEnvironment.IsConnected)
{
return(result);
}
var hasEnvironmentGuids = environmentGuids != null;
result = hasEnvironmentGuids ? LookupEnvironments(defaultEnvironment, environmentGuids, result) : LookupEnvironments(defaultEnvironment, result);
return(result);
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
ExecuteMessage msg = new ExecuteMessage();
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Get Computer Names");
var con = new Connections();
var result = con.GetNames();
msg.HasError = false;
msg.Message = serializer.SerializeToBuilder(result);
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err);
}
return(serializer.SerializeToBuilder(msg));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Wcf Service Source", GlobalConstants.WarewolfInfo);
values.TryGetValue("WcfSource", out StringBuilder resourceDefinition);
var src = serializer.Deserialize <WcfServiceSourceDefinition>(resourceDefinition);
var con = new WcfSource
{
EndpointUrl = src.EndpointUrl,
ResourceName = src.Name,
Name = src.Name,
ResourceID = src.Id,
Type = enSourceType.WcfSource,
ResourceType = "WcfSource"
};
ResourceCatalog.Instance.SaveResource(GlobalConstants.ServerWorkspaceID, con, src.Path);
ServerExplorerRepo.UpdateItem(con);
msg.HasError = false;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public static object CastWarewolfValueToCorrectType(object value, SharepointFieldType type)
{
object returnValue = null;
switch (type)
{
case SharepointFieldType.Boolean:
returnValue = Convert.ToBoolean(value);
break;
case SharepointFieldType.Number:
case SharepointFieldType.Currency:
returnValue = Convert.ToDecimal(value, CultureInfo.InvariantCulture.NumberFormat);
break;
case SharepointFieldType.DateTime:
returnValue = Convert.ToDateTime(value, CultureInfo.InvariantCulture);
break;
case SharepointFieldType.Integer:
returnValue = Convert.ToInt32(value);
break;
case SharepointFieldType.Text:
case SharepointFieldType.Note:
returnValue = value.ToString();
break;
default:
Dev2Logger.Info("No Cast type for the Sharepoint Property Name: " + type, GlobalConstants.WarewolfInfo);
break;
}
return(returnValue);
}
/// <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);
}
/// <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);
}
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
try
{
Dev2Logger.Info("Find Dependencies", GlobalConstants.WarewolfInfo);
var result = new ExecuteMessage {
HasError = false
};
string resourceId = null;
string dependsOnMeString = null;
var dependsOnMe = false;
values.TryGetValue("ResourceId", out StringBuilder tmp);
if (tmp != null)
{
resourceId = tmp.ToString();
}
values.TryGetValue("GetDependsOnMe", out tmp);
if (tmp != null)
{
dependsOnMeString = tmp.ToString();
}
if (string.IsNullOrEmpty(resourceId))
{
throw new InvalidDataContractException(ErrorResource.ResourceIdIsNull);
}
if (!Guid.TryParse(resourceId, out Guid resId))
{
throw new InvalidDataContractException(ErrorResource.ResourceIdNotAGUID);
}
var resource = ResourceCatalog.GetResource(theWorkspace.ID, resId);
if (!string.IsNullOrEmpty(dependsOnMeString) && !bool.TryParse(dependsOnMeString, out dependsOnMe))
{
dependsOnMe = false;
}
if (dependsOnMe)
{
result.Message.Append($"<graph title=\"Local Dependants Graph: {resourceId}\">");
result.Message.Append(FindWhatDependsOnMe(theWorkspace.ID, resource.ResourceID, new List <Guid>()));
result.Message.Append("</graph>");
}
else
{
result.Message.Append($"<graph title=\"Dependency Graph Of {resourceId}\">");
result.Message.Append(FindDependenciesRecursive(resource.ResourceID, theWorkspace.ID, new List <Guid>()));
result.Message.Append("</graph>");
}
var serializer = new Dev2JsonSerializer();
return(serializer.SerializeToBuilder(result));
}
catch (Exception e)
{
Dev2Logger.Error(e, GlobalConstants.WarewolfError);
throw;
}
}
public static void Main(string[] args)
{
ConfigureLogging();
Dev2Logger.Info("Studio " + Warewolf.Studio.AntiCorruptionLayer.Utils.FetchVersionInfo() + " Starting.", GlobalConstants.WarewolfInfo);
var wrapper = new SingleInstanceApplicationWrapper();
wrapper.Run(args);
}
private void LogWarewolfVersion()
{
var logger = _loggerFactory.New(new JsonSerializer(), _webSocketPool);
var wareWolfVersion = _systemInformationHelper.GetWareWolfVersion();
logger.Info("Warewolf Server Started Version: " + wareWolfVersion);
Dev2Logger.Info(wareWolfVersion, "Warewolf Server Version");
}