public void AddAuthenticationCrate(ActivityDTO activityDTO, int authType)
{
using (var crateStorage = _crate.UpdateStorage(() => activityDTO.CrateStorage))
{
var mode = authType == AuthenticationType.Internal ? AuthenticationMode.InternalMode : AuthenticationMode.ExternalMode;
switch (authType)
{
case AuthenticationType.Internal:
mode = AuthenticationMode.InternalMode;
break;
case AuthenticationType.External:
mode = AuthenticationMode.ExternalMode;
break;
case AuthenticationType.InternalWithDomain:
mode = AuthenticationMode.InternalModeWithDomain;
break;
default:
mode = AuthenticationMode.ExternalMode;
break;
}
crateStorage.Add("RequiresAuthentication", new StandardAuthenticationCM
{
Mode = mode,
Revocation = false
});
}
}
public static IUpdatableCrateStorage GetUpdatableStorage(this ICrateManager crateManager, PayloadDTO payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
return(crateManager.UpdateStorage(() => payload.CrateStorage));
}
public static IUpdatableCrateStorage GetUpdatableStorage(this ICrateManager crateManager, ActivityDTO activity)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
return(crateManager.UpdateStorage(() => activity.CrateStorage));
}
/**********************************************************************************/
public void Run(Guid id, ActivityExecutionMode executionMode, PayloadDTO payloadDto)
{
using (var storage = _crateManager.UpdateStorage(() => payloadDto.CrateStorage))
{
OperationalState = storage.CrateContentsOfType <OperationalStateCM>().First();
Run(id, executionMode);
}
}
/// <summary>
/// New Process object
/// </summary>
/// <param name="planId"></param>
/// <param name="envelopeId"></param>
/// <returns></returns>
public ContainerDO Create(IUnitOfWork uow, PlanDO curPlan, params Crate[] curPayload)
{
var containerDO = new ContainerDO {
Id = Guid.NewGuid()
};
containerDO.PlanId = curPlan.Id;
containerDO.Name = curPlan.Name;
containerDO.State = State.Unstarted;
using (var crateStorage = _crate.UpdateStorage(() => containerDO.CrateStorage))
{
if (curPayload?.Length > 0)
{
foreach (var crate in curPayload)
{
if (crate != null && !crate.IsOfType <OperationalStateCM>())
{
crateStorage.Add(crate);
}
}
}
var operationalState = new OperationalStateCM();
operationalState.CallStack.PushFrame(new OperationalStateCM.StackFrame
{
NodeName = "Starting subplan",
NodeId = curPlan.StartingSubPlanId,
});
crateStorage.Add(Crate.FromContent("Operational state", operationalState));
}
uow.ContainerRepository.Add(containerDO);
uow.SaveChanges();
EventManager.ContainerCreated(containerDO);
return(containerDO);
}
/**********************************************************************************/
// See https://maginot.atlassian.net/wiki/display/DDW/New+container+execution+logic for details
public async Task Run()
{
while (_callStack.Count > 0)
{
if (_callStack.Count > MaxStackSize)
{
throw new Exception($"Container execution stack overflow. Container: {_container.Id}. PlanId: {_container.PlanId}.");
}
var topFrame = _callStack.TopFrame;
var currentNode = _uow.PlanRepository.GetById <PlanNodeDO>(topFrame.NodeId);
if (currentNode == null)
{
throw new Exception($"PlanNode with id: {topFrame.NodeId} was not found. Container: {_container.Id}. PlanId: {_container.PlanId}.");
}
try
{
try
{
using (var payloadStorage = _crate.UpdateStorage(() => _container.CrateStorage))
{
_operationalState = GetOperationalState(payloadStorage);
_operationalState.CallStack = _callStack;
// reset current activity response
_operationalState.CurrentActivityResponse = null;
// update container's payload
payloadStorage.Flush();
if (!_activityRateLimiter.CheckActivityExecutionRate(currentNode.Fr8AccountId))
{
_callStack.Clear();
_container.State = State.Failed;
return;
}
if (topFrame.CurrentActivityExecutionPhase == OperationalStateCM.ActivityExecutionPhase.WasNotExecuted)
{
await ExecuteNode(currentNode, payloadStorage, ActivityExecutionMode.InitialRun);
topFrame.CurrentActivityExecutionPhase = OperationalStateCM.ActivityExecutionPhase.ProcessingChildren;
// process op codes
if (!ProcessActivityResponse(_operationalState.CurrentActivityResponse, OperationalStateCM.ActivityExecutionPhase.WasNotExecuted, topFrame))
{
break;
}
continue;
}
var nextChild = GetNextChildActivity(topFrame, currentNode);
// if there is a child that has not being executed yet - add it for execution by pushing to the call stack
if (nextChild != null)
{
AddNodeForExecution(nextChild.Id);
topFrame.CurrentChildId = nextChild.Id;
}
// or run current activity in ReturnFromChildren mode
else
{
if (currentNode.ChildNodes.Count > 0)
{
await ExecuteNode(currentNode, payloadStorage, ActivityExecutionMode.ReturnFromChildren);
}
_callStack.RemoveTopFrame();
// process op codes
if (!ProcessActivityResponse(_operationalState.CurrentActivityResponse, OperationalStateCM.ActivityExecutionPhase.ProcessingChildren, topFrame))
{
break;
}
}
}
}
catch
{
_container.State = State.Failed;
throw;
}
finally
{
_uow.SaveChanges();
}
}
catch (ErrorResponseException e)
{
throw new ActivityExecutionException(e.ContainerDTO, Mapper.Map <ActivityDO, ActivityDTO>((ActivityDO)currentNode), e.Message, e);
}
catch (InvalidTokenRuntimeException)
{
throw;
}
catch (Exception e)
{
var curActivity = currentNode as ActivityDO;
if (curActivity != null)
{
var activityDTO = Mapper.Map <ActivityDO, ActivityDTO>(curActivity);
activityDTO.ActivityTemplate = Mapper.Map <ActivityTemplateSummaryDTO>(_uow.ActivityTemplateRepository.GetByKey(curActivity.ActivityTemplateId));
throw new ActivityExecutionException(Mapper.Map <ContainerDO, ContainerDTO>(_container), activityDTO, string.Empty, e);
}
throw;
}
}
if (_container.State == State.Executing)
{
_container.State = State.Completed;
_uow.SaveChanges();
}
}
public async Task <PayloadDTO> Run(IUnitOfWork uow, ActivityDO curActivityDO, ActivityExecutionMode curActionExecutionMode, ContainerDO curContainerDO)
{
if (curActivityDO == null)
{
throw new ArgumentNullException(nameof(curActivityDO));
}
//FR-2642 Logic to skip execution of activities with "SkipAtRunTime" Tag
var template = _activityTemplate.GetByKey(curActivityDO.ActivityTemplateId);
if (template.Tags != null && template.Tags.Contains("SkipAtRunTime", StringComparison.InvariantCultureIgnoreCase))
{
return(null);
}
EventManager.ActionStarted(curActivityDO, curContainerDO);
// Explicitly extract authorization token to make AuthTokenDTO pass to activities.
curActivityDO.AuthorizationToken = uow.AuthorizationTokenRepository.FindTokenById(curActivityDO.AuthorizationTokenId);
try
{
IEnumerable <KeyValuePair <string, string> > parameters = null;
if (curActionExecutionMode != ActivityExecutionMode.InitialRun)
{
parameters = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("scope", "childActivities")
};
}
if (curActionExecutionMode != ActivityExecutionMode.ReturnFromChildren)
{
EventManager.ActivityRunRequested(curActivityDO, curContainerDO);
}
var activtiyClone = (ActivityDO)curActivityDO.Clone();
using (var storage = _crateManager.UpdateStorage(() => activtiyClone.CrateStorage))
{
var configurationControls = storage.CrateContentsOfType <StandardConfigurationControlsCM>().FirstOrDefault();
if (configurationControls != null)
{
var payloadStorage = _crateManager.GetStorage(curContainerDO.CrateStorage);
_upstreamDataExtractionService.ExtactAndAssignValues(configurationControls, payloadStorage);
}
}
var payloadDTO = await CallTerminalActivityAsync <PayloadDTO>(uow, "run", parameters, activtiyClone, curContainerDO.Id);
EventManager.ActivityResponseReceived(curActivityDO, ActivityResponse.RequestSuspend);
return(payloadDTO);
}
catch (Exception e)
{
ReportActivityInvocationError(curActivityDO, e.Message, curContainerDO.Id.ToString(), curActivityDO.Id.ToString(), EventManager.TerminalRunFailed);
throw;
}
}
