Esempio n. 1
0
        public async Task PrepareToExecute_WithMockedExecute_WithoutPayload()
        {
            ActivityDO activityDo = FixtureData.TestActivityStateInProcess();

            activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO());

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);
                uow.PlanRepository.Add(new PlanDO()
                {
                    Name       = "sdfsdf",
                    PlanState  = PlanState.Executing,
                    ChildNodes = { activityDo }
                });
                uow.SaveChanges();
            }

            Activity    _activity   = ObjectFactory.GetInstance <Action>();
            ContainerDO containerDO = FixtureData.TestContainer1();

            EventManager.EventActionStarted += EventManager_EventActivityStarted;
            var executeActionMock = new Mock <IActivity>();

            executeActionMock.Setup(s => s.Run(It.IsAny <IUnitOfWork>(), activityDo, It.IsAny <ActivityExecutionMode>(), containerDO)).Returns <Task <PayloadDTO> >(null);

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                await _activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);
            }

            Assert.IsNull(containerDO.CrateStorage);
            Assert.IsTrue(_eventReceived);
            // Assert.AreEqual(actionDo.ActionState, ActionState.Active);
        }
Esempio n. 2
0
        public void Process_ActivityUnstarted_ShouldBeCompleted()
        {
            //Arrange
            ActivityDO activityDo = FixtureData.TestActivityUnstarted();

            activityDo.ActivityTemplate.Terminal.Endpoint = "http://localhost:53234/activities/configure";
            activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO());

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);
                uow.PlanRepository.Add(new PlanDO()
                {
                    Name       = "name",
                    PlanState  = PlanState.Executing,
                    ChildNodes = { activityDo }
                });
                uow.SaveChanges();
            }

            ActivityDTO activityDto = Mapper.Map <ActivityDTO>(activityDo);

            TerminalTransmitterMock.Setup(rc => rc.PostAsync(It.IsAny <Uri>(), It.IsAny <object>(), It.IsAny <string>(), It.IsAny <Dictionary <string, string> >()))
            .Returns(() => Task.FromResult <string>(JsonConvert.SerializeObject(activityDto)));

            ContainerDO containerDO = FixtureData.TestContainer1();

            //Act
            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                var task = _activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);
                //Assert
                Assert.That(task.Status, Is.EqualTo(TaskStatus.RanToCompletion));
            }
        }
Esempio n. 3
0
        public async Task ActivityStarted_EventRaisedSuccessfully()
        {
            ActivityDO activityDo = FixtureData.TestActivityStateInProcess();

            activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO());

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);

                uow.PlanRepository.Add(new PlanDO
                {
                    Name       = "name",
                    PlanState  = PlanState.Executing,
                    ChildNodes = { activityDo }
                });
                uow.SaveChanges();
            }


            Activity    activity    = ObjectFactory.GetInstance <Activity>();
            ContainerDO containerDO = FixtureData.TestContainer1();

            EventManager.EventActionStarted += EventManager_EventActivityStarted;

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                await activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);
            }

            Assert.IsTrue(_eventReceived, "Unable to receive event about activity start");
        }
Esempio n. 4
0
        public static ActionListDO TestActivityListHealth1()
        {
            //string envelopeId = "F02C3D55-F6EF-4B2B-B0A0-02BF64CA1E09";
            var containerDO = new ContainerDO
            {
                Id     = TestContainer_Id_1(),
                State  = 1,
                Name   = "test name",
                PlanId = TestPlanHealthDemo().Id
            };

            using (var crateStorage = ObjectFactory.GetInstance <ICrateManager>().UpdateStorage(() => containerDO.CrateStorage))
            {
                crateStorage.Add(GetEnvelopeIdCrate());
            }

            return(new ActionListDO
            {
//               Id = 88,
//               Name = "list1",
//               ActionListType = ActionListType.Immediate,
//               SubPlanID = 50,
//               CurrentActivity = TestActionHealth1(),
//               Process = processDo
            });
        }
            private void ConfigureProcess(ContainerDO container)
            {
                container.Name   = _name;
                container.PlanId = _ptId;
                container.State  = State.Executing;

                container.CrateStorage = JsonConvert.SerializeObject(CrateStorageSerializer.Default.ConvertToDto(new CrateStorage(_crates)));
            }
Esempio n. 6
0
        public static ContainerDO TestContainer()
        {
            var containerDO = new ContainerDO();

            containerDO.Id    = TestContainerGuid();
            containerDO.State = 1;
            return(containerDO);
        }
Esempio n. 7
0
        public static void ContainerReceived(ContainerDO containerDO, ActivityDO activityDO)
        {
            var handler = EventContainerReceived;

            if (handler != null)
            {
                handler(containerDO, activityDO);
            }
        }
        public static ContainerDO TestHealthDemoContainer1()
        {
            var containerDO = new ContainerDO();

            containerDO.Id     = TestContainer_Id_49();
            containerDO.PlanId = TestPlan2().Id;
            containerDO.State  = State.Executing;
            return(containerDO);
        }
        public static ContainerDO TestContainer1()
        {
            var containerDO = new ContainerDO();

            containerDO.Id     = TestContainer_Id_49();
            containerDO.PlanId = TestPlan2().Id;
            containerDO.State  = 1;
            return(containerDO);
        }
Esempio n. 10
0
        public static void ContainerExecutionCompleted(ContainerDO containerDO)
        {
            var handler = EventContainerExecutionCompleted;

            if (handler != null)
            {
                handler(containerDO);
            }
        }
Esempio n. 11
0
        public static void ActivityRunRequested(ActivityDO activityDo, ContainerDO containerDO)
        {
            var handler = EventActivityRunRequested;

            if (handler != null)
            {
                handler(activityDo, containerDO);
            }
        }
Esempio n. 12
0
        public static void ContainerCreated(ContainerDO containerDO)
        {
            var handler = EventContainerCreated;

            if (handler != null)
            {
                handler(containerDO);
            }
        }
Esempio n. 13
0
        public static void ProcessRequestReceived(ContainerDO containerDO)
        {
            var handler = EventProcessRequestReceived;

            if (handler != null)
            {
                handler(containerDO);
            }
        }
Esempio n. 14
0
        public static void ActionStarted(ActivityDO activity, ContainerDO container)
        {
            var handler = EventActionStarted;

            if (handler != null)
            {
                handler(activity, container);
            }
        }
Esempio n. 15
0
        public static void ContainerLaunched(ContainerDO launchedContainer)
        {
            var handler = EventContainerLaunched;

            if (handler != null)
            {
                handler(launchedContainer);
            }
        }
Esempio n. 16
0
        public static void ProcessingTerminatedPerActivityResponse(ContainerDO containerDO, ActivityResponse resposneType)
        {
            var handler = EventProcessingTerminatedPerActivityResponse;

            if (handler != null)
            {
                handler(containerDO, resposneType);
            }
        }
Esempio n. 17
0
//
        public static ActionListDO TestActivityList6()
        {
            ContainerDO containerDO = FixtureData.TestContainer1();

            containerDO.CrateStorage = "";
            return(new ActionListDO
            {
//               Id = 2,
//               ActionListType = ActionListType.Immediate,
//               ActionListState = ActionListState.Unstarted,
//               Process = processDO
            });
        }
Esempio n. 18
0
        public async Task Continue(IUnitOfWork uow, ContainerDO container)
        {
            if (container == null)
            {
                throw new ArgumentNullException(nameof(container));
            }

            if (container.State != State.Suspended)
            {
                throw new ApplicationException($"Attempted to Continue a Container {container.Id} that wasn't in pending state. Container state is {container.State}.");
            }

            //continue from where we left
            await Run(uow, container);
        }
Esempio n. 19
0
        private void ContainerExecutionCompleted(ContainerDO containerDO)
        {
            var factDO = new FactDO()
            {
                PrimaryCategory   = "Container Execution",
                SecondaryCategory = "Container",
                Activity          = "Launched",
                ObjectId          = containerDO.Id.ToString(),
                Fr8UserId         = _security.GetCurrentUser(),
                CreatedByID       = _security.GetCurrentUser(),
                Data = string.Join(Environment.NewLine, "Container Id: " + containerDO.Id, "Plan Id: " + containerDO.PlanId)
            };

            SaveAndLogFact(factDO);
        }
Esempio n. 20
0
        private void ProcessingTerminatedPerActivityResponse(ContainerDO containerDO, ActivityResponse resposneType)
        {
            var factDO = new FactDO()
            {
                PrimaryCategory   = "Container Execution",
                SecondaryCategory = "Container",
                Activity          = "Terminated",
                Status            = resposneType.ToString(),
                ObjectId          = containerDO.Id.ToString(),
                CreatedByID       = _security.GetCurrentUser(),
                Fr8UserId         = _security.GetCurrentUser(),
                Data = string.Join(Environment.NewLine, "Container Id: " + containerDO.Name)
            };

            SaveAndLogFact(factDO);
        }
Esempio n. 21
0
        private static object ExtractOperationStateData(
            ContainerDO container,
            Func <OperationalStateCM, object> extractor)
        {
            var crateStorageDTO = CrateStorageFromStringConverter.Convert(container.CrateStorage);
            var crateStorage    = CrateStorageSerializer.Default.ConvertFromDto(crateStorageDTO);
            var cm = crateStorage
                     .CrateContentsOfType <OperationalStateCM>()
                     .SingleOrDefault();

            if (cm == null)
            {
                return(null);
            }

            return(extractor(cm));
        }
            /**********************************************************************************/
            // Functions
            /**********************************************************************************/

            public ExecutionSession(IUnitOfWork uow,
                                    OperationalStateCM.ActivityCallStack callStack,
                                    ContainerDO container,
                                    IActivity activity,
                                    ICrateManager crateManager,
                                    IUtilizationMonitoringService utilizationMonitoringService,
                                    IActivityExecutionRateLimitingService activityRateLimiter)
            {
                _uow       = uow;
                _callStack = callStack;
                _container = container;

                _activity = activity;
                _crate    = crateManager;
                _utilizationMonitoringService = utilizationMonitoringService;
                _activityRateLimiter          = activityRateLimiter;
            }
Esempio n. 23
0
        public async Task Run_WithMockedExecute_WithPayload()
        {
            ActivityDO activityDo = FixtureData.TestActivityStateInProcess();

            activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO()
            {
                Label = "Test Action"
            });

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);
                uow.PlanRepository.Add(new PlanDO()
                {
                    Name       = "name",
                    PlanState  = PlanState.Executing,
                    ChildNodes = { activityDo }
                });
                uow.SaveChanges();
            }

            IActivity   _activity   = ObjectFactory.GetInstance <IActivity>();
            ContainerDO containerDO = FixtureData.TestContainer1();

            EventManager.EventActionStarted += EventManager_EventActivityStarted;

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                var terminalClientMock = new Mock <ITerminalTransmitter>();
                terminalClientMock.Setup(s => s.CallActivityAsync <PayloadDTO>(It.IsAny <string>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >(), It.IsAny <Fr8DataDTO>(), It.IsAny <string>()))
                .Returns(Task.FromResult(new PayloadDTO(containerDO.Id)
                {
                    CrateStorage = JsonConvert.DeserializeObject <CrateStorageDTO>(activityDo.CrateStorage)
                }));
                ObjectFactory.Configure(cfg => cfg.For <ITerminalTransmitter>().Use(terminalClientMock.Object));

                var payload = await _activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);

                Assert.IsNotNull(payload);
            }

            Assert.IsTrue(_eventReceived);
        }
Esempio n. 24
0
        private void LogEventProcessLaunched(ContainerDO launchedContainer)
        {
            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                var plan = uow.PlanRepository.GetById <PlanDO>(launchedContainer.PlanId);

                var fact = new FactDO
                {
                    Fr8UserId         = plan.Fr8AccountId,
                    Data              = launchedContainer.Id.ToStr(),
                    ObjectId          = launchedContainer.Id.ToStr(),
                    PrimaryCategory   = "Container Execution",
                    SecondaryCategory = "Container",
                    Activity          = "Launched"
                };

                SaveAndLogFact(fact);
            }
        }
Esempio n. 25
0
        private void EventManagerOnEventProcessRequestReceived(ContainerDO containerDO)
        {
            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                var plan = uow.PlanRepository.GetById <PlanDO>(containerDO.PlanId);

                var fact = new FactDO
                {
                    Fr8UserId         = plan.Fr8AccountId,
                    Data              = containerDO.Id.ToStr(),
                    ObjectId          = containerDO.Id.ToStr(),
                    PrimaryCategory   = "Process Access",
                    SecondaryCategory = "Process",
                    Activity          = "Requested"
                };

                SaveAndLogFact(fact);
            }
        }
Esempio n. 26
0
        /// <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);
        }
Esempio n. 27
0
        private void LogEventActivityStarted(ActivityDO curActivity, ContainerDO containerInExecution)
        {
            FactDO fact;

            using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
            {
                var plan = containerInExecution != null?uow.PlanRepository.GetById <PlanDO>(containerInExecution.PlanId) : null;

                fact = new FactDO
                {
                    Fr8UserId         = (containerInExecution != null) ? plan.Fr8AccountId : "unknown",
                    Data              = (containerInExecution != null) ? containerInExecution.Id.ToStr() : "unknown",
                    ObjectId          = curActivity.Id.ToStr(),
                    PrimaryCategory   = "Process Execution",
                    SecondaryCategory = "Action",
                    Activity          = "Started"
                };
            }

            SaveAndLogFact(fact);
        }
Esempio n. 28
0
        public void TrackActivityExecution(ActivityDO activity, ContainerDO container)
        {
            lock (_activityExecutionReports)
            {
                ActivityExecutionRate report;

                var user = ExtractUser(activity, container);

                if (!_activityExecutionReports.TryGetValue(user, out report))
                {
                    report = new ActivityExecutionRate
                    {
                        UserId = user
                    };

                    _activityExecutionReports.Add(user, report);
                }

                report.ActivitiesExecuted++;
            }
        }
Esempio n. 29
0
        private void ActivityRunRequested(ActivityDO activityDo, ContainerDO containerDO)
        {
            try
            {
                using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
                {
                    var template = _activityTemplate.GetByKey(activityDo.ActivityTemplateId);

                    var factDO = new FactDO()
                    {
                        PrimaryCategory   = "Container",
                        SecondaryCategory = "Activity",
                        Activity          = "Process Execution",
                        Status            = "Activity Execution Initiating",
                        ObjectId          = activityDo.Id.ToString(),
                        Fr8UserId         = _security.GetCurrentUser(),
                        CreatedByID       = _security.GetCurrentUser(),
                        Data = string.Join(Environment.NewLine, "Activity Name: " + template?.Name)
                    };
                    SaveAndLogFact(factDO);

                    // Create user notifications about activity execution
                    var _pusherNotifier = ObjectFactory.GetInstance <IPusherNotifier>();
                    _pusherNotifier.NotifyUser(new NotificationMessageDTO()
                    {
                        NotificationType = NotificationType.GenericInfo,
                        Subject          = "Executing Activity",
                        Message          = "For Plan: " + containerDO.Name + "\nContainer: " + containerDO.Id.ToString(),
                        ActivityName     = template.Label,
                        Collapsed        = true,
                    }, activityDo.Fr8Account.Id);
                }
            }
            catch (Exception exception)
            {
                EventManager.UnexpectedError(exception);
            }
        }
            public void Store(IUnitOfWork uow)
            {
                StoreTemplate(uow);

                var container = uow.ContainerRepository.GetQuery().FirstOrDefault(x => x.Name == _name);

                var add = container == null;

                if (add)
                {
                    container = new ContainerDO()
                    {
                        Id = Guid.NewGuid()
                    };
                }

                ConfigureProcess(container);

                if (add)
                {
                    uow.ContainerRepository.Add(container);
                }
            }