/// <inheritdoc /> public Task Send(MailMessage message) { var data = new Dictionary <string, object>(); bool cancel = false; // run pre process interceptors foreach (var interceptor in interceptors) { interceptor.Sending(message, data, ref cancel); if (cancel) { return(Task.CompletedTask); } } // send email and run post process interceptors return(ExecutionStrategy.Execute(Process, message, data, CancellationToken).ContinueWith((task) => { if (task.IsFaulted == false) { foreach (var interceptor in interceptors) { interceptor.Sent(message, data); } } })); }
private void onNewInstanceCreated(ActiveInstance activeInstance) { newInstanceSet.Add(activeInstance); ExecutionStrategy ex = activeInstance.IndexedMType.Type.ExecutionStrategy; while (ex != null && ex.Rules.Count == 0) { ex = ex.Next; } if (ex != null) { allOperationalInstances.Add(activeInstance); } if (RegisterNewInstance != null) { RegisterNewInstance(activeInstance.Instance); } if (step >= startStep) { if (recordInstanceCreation) { if (NewInstanceCreated != null) { NewInstanceCreated(activeInstance.Instance, activeInstance.Type); } } } }
public List <int> Guards(ExecutionStrategy es) { List <int> list = new List <int>(); List <int> pos = new List <int>(); foreach (Rule r in es.Rules) { if (r.Guard != null) { pos.Add(list.Count); List <int> g = new List <int>(); Guard(g, r.Guard); list.AddRange(g); list.Add(-1); } else { pos.Add(-1); } } int n = es.Rules.Count; pos = pos.Select(a => a > -1 ? a + n + 1:0).ToList(); pos.Insert(0, n); list.InsertRange(0, pos); return(list); }
private void Dispatch(WorkItem work, ExecutionStrategy strategy) { log.Debug("Using {0} strategy for {1}", strategy, work.Name); switch (strategy) { default: case ExecutionStrategy.Direct: work.Execute(); break; case ExecutionStrategy.Parallel: if (work.TargetApartment == ApartmentState.STA) { ParallelSTAQueue.Enqueue(work); } else { ParallelQueue.Enqueue(work); } break; case ExecutionStrategy.NonParallel: if (work.TargetApartment == ApartmentState.STA) { NonParallelSTAQueue.Enqueue(work); } else { NonParallelQueue.Enqueue(work); } break; } }
public void ExtendedRootTypesWillHonorGlobalSerialSetting(ExecutionStrategy defaultStrategy) { // arrange ISchema schema = SchemaBuilder.New() .AddQueryType(c => c.Name(OperationTypeNames.Query)) .AddType <BarQueries>() .ModifyOptions(o => o.DefaultResolverStrategy = defaultStrategy) .Create(); DocumentNode document = Utf8GraphQLParser.Parse( @"{ bars }"); OperationDefinitionNode operationDefinition = document.Definitions.OfType <OperationDefinitionNode>().Single(); IPreparedOperation operation = OperationCompiler.Compile( "a", document, operationDefinition, schema, schema.QueryType, new(new DefaultTypeConverter())); // act QueryPlanNode root = QueryPlanBuilder.Prepare(operation); // assert Snapshot(root, defaultStrategy); }
public void CreateReviewForEpisode_Plan(ExecutionStrategy defaultStrategy) { // arrange ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .ModifyOptions(o => o.DefaultResolverStrategy = defaultStrategy) .Create(); DocumentNode document = Utf8GraphQLParser.Parse( @"mutation CreateReviewForEpisode( $ep: Episode!, $review: ReviewInput!) { createReview(episode: $ep, review: $review) { stars commentary } }"); OperationDefinitionNode operationDefinition = document.Definitions.OfType <OperationDefinitionNode>().Single(); IPreparedOperation operation = OperationCompiler.Compile( "a", document, operationDefinition, schema, schema.MutationType !, new(new DefaultTypeConverter())); // act QueryPlanNode root = QueryPlanBuilder.Prepare(operation); // assert Snapshot(root, defaultStrategy); }
public void ParallelAttributeWillBeHonored(ExecutionStrategy defaultStrategy) { // arrange ISchema schema = SchemaBuilder.New() .AddQueryType <ParallelQuery>() .Create(); DocumentNode document = Utf8GraphQLParser.Parse( @"{ foo }"); OperationDefinitionNode operationDefinition = document.Definitions.OfType <OperationDefinitionNode>().Single(); IPreparedOperation operation = OperationCompiler.Compile( "a", document, operationDefinition, schema, schema.QueryType, new(new DefaultTypeConverter())); // act QueryPlanNode root = QueryPlanBuilder.Prepare(operation); // assert Snapshot(root, defaultStrategy); }
public override void Dispose() { _executionStrategy = null; _messageBus = null; base.Dispose(); }
/// <summary> /// 创建定时任务 /// </summary> /// <param name="crontabType">定时任务类型</param> /// <param name="strategy">执行策略</param> /// <returns>定时任务</returns> public static ICrontab CreateCrontab(Type crontabType, ExecutionStrategy strategy) { #region # 验证 if (crontabType == null) { throw new ArgumentNullException(nameof(crontabType), "定时任务类型不可为空!"); } if (strategy == null) { throw new ArgumentNullException(nameof(strategy), "执行策略不可为空!"); } if (!typeof(ICrontab).IsAssignableFrom(crontabType)) { throw new ArgumentOutOfRangeException(nameof(crontabType), "给定类型不是定时任务类型!"); } #endregion object instance = Activator.CreateInstance(crontabType, strategy); #region # 验证 if (instance == null) { throw new NullReferenceException("给定类型的定时任务不存在!"); } #endregion ICrontab crontab = (ICrontab)instance; return(crontab); }
public static void generateDivisionRules(MType type, Module paramModule) { if (paramModule != null) { module = paramModule; } //get all division rules List <KpCore.Rule> divisionRules = new List <KpCore.Rule>(); ExecutionStrategy eS = type.ExecutionStrategy; while (eS != null) { foreach (var rule in eS.Rules) { if (rule.Type == RuleType.MEMBRANE_DIVISION) { divisionRules.Add(rule); } } eS = eS.Next; } if (divisionRules.Count > 0) { //or each parent instance, generate a permutation of rules. ParentInstance parentInstance = null; Instance smvInstance = module.Instance; if (smvInstance.DivisionType == DIVISIONTYPE.PARENT) { parentInstance = (ParentInstance)smvInstance; generateDivisionInstances(parentInstance, divisionRules); } } }
private static IResolveFieldContext CreateResolveFieldContext(ISchema schema, string query) { var documentBuilder = new GraphQLDocumentBuilder(); var document = documentBuilder.Build(query); schema.Initialize(); var executionContext = new ExecutionContext { Document = document, Schema = schema, Fragments = document.Fragments, Operation = document.Operations.First() }; var root = new RootExecutionNode(schema.Query) { Result = executionContext.RootValue }; var fields = ExecutionHelper.CollectFields(executionContext, schema.Query, executionContext.Operation.SelectionSet); ExecutionStrategy.SetSubFieldNodes(executionContext, root, fields); var subNode = root.SubFields.FirstOrDefault(); return(new ReadonlyResolveFieldContext(subNode.Value, executionContext)); }
/// <inheritdoc /> public Task SendAsync(MailMessage message) { var data = new Dictionary <string, object>(); bool cancel = false; // Run pre process interceptors. foreach (var interceptor in interceptors) { interceptor.Sending(message, data, ref cancel); if (cancel) { #if NET452 var tcs = new TaskCompletionSource <bool>(); tcs.SetResult(true); return(tcs.Task); #else return(Task.CompletedTask); #endif } } // Send email and run post process interceptors. return(ExecutionStrategy.Execute(Process, message, data, CancellationToken).ContinueWith(task => { if (!task.IsFaulted) { foreach (var interceptor in interceptors) { interceptor.Sent(message, data); } } }, CancellationToken)); }
/// <summary> /// 无参构造器 /// </summary> protected Crontab(ExecutionStrategy executionStrategy) { //默认值 this.Id = Guid.NewGuid().ToString(); this.AddedTime = DateTime.Now; this.ExecutionStrategy = executionStrategy; }
/// <summary> /// Constructor. /// </summary> public ActiveClient(ClientId id) { _id = id; _executionStrategy = null; _messageBus = null; }
public IWhenDoCommand CreateCommandFromDefinition(CommandDefinition definition, List <ExpressionProviderInfo> providerInfos) { ExecutionStrategy strategy = null; if (definition.Execution.Mode == ExecutionMode.Default || definition.Execution.Mode == ExecutionMode.Reliable) { strategy = new ExecutionStrategy() { Mode = definition.Execution.Mode, Time = null } } ; else { strategy = CreateExecutionStrategyFromDefinition(definition.Execution, providerInfos); } var command = new WhenDoCommand() { Id = Guid.NewGuid().ToString("N").ToLower(), Type = definition.Type, MethodName = definition.Command, Parameters = definition.Parameters, ExecutionStrategy = strategy }; return(command); }
//Private #region # 获取触发器 —— static ITrigger GetTrigger(ExecutionStrategy strategy) /// <summary> /// 获取触发器 /// </summary> /// <param name="strategy">执行策略</param> /// <returns>触发器</returns> private static ITrigger GetTrigger(ExecutionStrategy strategy) { if (strategy is FixedTimeStrategy fixedTimeStrategy) { string cronExpression = fixedTimeStrategy.TriggerTime.ToCronExpression(); ITrigger trigger = TriggerBuilder.Create().WithCronSchedule(cronExpression).Build(); return(trigger); } if (strategy is RepeatedTimeStrategy repeatedTimeStrategy) { string cronExpression = repeatedTimeStrategy.TriggerTime.ToCronExpression(); ITrigger trigger = TriggerBuilder.Create().WithCronSchedule(cronExpression).Build(); return(trigger); } if (strategy is RecurrenceStrategy recurrenceStrategy) { ITrigger trigger = TriggerBuilder.Create().WithSimpleSchedule(x => x.WithInterval(recurrenceStrategy.RecurrenceTimeInterval).RepeatForever()).Build(); return(trigger); } if (strategy is CronExpressionStrategy cronExpressionStrategy) { ITrigger trigger = TriggerBuilder.Create().WithCronSchedule(cronExpressionStrategy.CronExpression).Build(); return(trigger); } throw new NotSupportedException("无当前类型执行策略!"); }
/// <summary> /// Sets an ID to each rule. Generate name for unnamed instances. /// </summary> /// <param name="kpSystem"></param> private static void prepareKpSystem(KPsystem kpSystem) { foreach (var kpType in kpSystem.Types) { ExecutionStrategy kpES = kpType.ExecutionStrategy; while (kpES != null) { int id = 1; foreach (var kpRule in kpES.Rules) { kpRule.Id = id; id++; } kpES = kpES.Next; } //produce a name for unnamed instances int count = 0; foreach (var kpInstance in kpType.Instances) { if (String.IsNullOrWhiteSpace(kpInstance.Name)) { kpInstance.Name = "_" + kpType.Name.ToLower() + count; count++; } } } }
/// <summary> /// Determines how many child instances will eventually be generated after running all division rules. For each child /// instance, it generates KPChildInstance (sub class of MInstance) object and adds them as MInstance(regular /// instances) to MType. For each MInstance (including KPChildInstances) an SMV module will be generated. /// </summary> /// <param name="type">KP type (MType)</param> /// <returns>List of child instance of KPChildInstance type</returns> internal static List <KPChildInstance> generateKPChildInstances(MType type) { List <KPChildInstance> kpChildInstances = new List <KPChildInstance>(); //After all divisions, how many child will be generated. int totalChildNumber = 1; ExecutionStrategy eS = type.ExecutionStrategy; while (eS != null) { foreach (var rule in eS.Rules) { if (rule.Type == RuleType.MEMBRANE_DIVISION) { DivisionRule divisionRule = (DivisionRule)rule; totalChildNumber *= divisionRule.Rhs.Count; } } eS = eS.Next; } //for each parent instance, totalChildNumber, child instance will be generated foreach (MInstance kpInstance in type.Instances) { for (int childCount = 1; childCount <= totalChildNumber; childCount++) { KPChildInstance kpChildInstance = new KPChildInstance(kpInstance); kpChildInstance.Order = childCount; kpChildInstance.Name = kpInstance.Name + SMVPreFix.CHILD + childCount; kpChildInstances.Add(kpChildInstance); } } return(kpChildInstances); }
private void writeExecutionStrategy(ExecutionStrategy strategy) { owt.Write("{"); if (strategy != null && !strategy.IsEmpty()) { owt.Write("\"rules\":["); int i = 1; foreach (Rule rule in strategy.Rules) { writeRule(rule); if (i++ < strategy.Rules.Count) { owt.Write(", "); } } owt.Write("]"); owt.Write(", \"operator\":"); writeStrategyOperator(strategy.Operator); if (strategy.Next != null) { owt.Write(", \"next\":"); writeExecutionStrategy(strategy.Next); } } owt.Write("}"); }
ResolveFieldContext ResolveFieldContext( MyDataContext ctx, CancellationToken token, Document document, ISchema schema) { var operation = document.Operations.FirstOrDefault(); var variableValues = ExecutionHelper.GetVariableValues(document, schema, operation?.Variables, null); var executionContext = new ExecutionContext { Document = document, Schema = schema, UserContext = ctx, Variables = variableValues, Fragments = document.Fragments, CancellationToken = token, Listeners = new IDocumentExecutionListener[0], Operation = operation, ThrowOnUnhandledException = true // DEBUG }; var operationRootType = ExecutionHelper.GetOperationRootType( executionContext.Document, executionContext.Schema, executionContext.Operation); var node = ExecutionStrategy.BuildExecutionRootNode(executionContext, operationRootType); return(GetContext(executionContext, node.SubFields["companies"])); }
public ArrayExecutionNode BuildEdgesArrayExecutionNode(ExecutionContext context, ExecutionNode node) { if (node is ObjectExecutionNode objectNode) { ExecutionStrategy.SetSubFieldNodes(context, objectNode); // Reference: // https://github.com/graphql-dotnet/graphql-dotnet/blob/master/src/GraphQL/Execution/ExecutionStrategy.cs#L167 var fields = CollectFields(context, objectNode.GraphType, node.Field.SelectionSet); if (fields.ContainsKey("edges")) { var edgesField = fields["edges"]; var schema = context.Schema; var edgesFieldDefinition = GetFieldDefinition( context.Document, schema, objectNode.GetObjectGraphType(schema), edgesField); var edgesNode = ExecutionStrategy.BuildExecutionNode(objectNode, edgesFieldDefinition.ResolvedType, edgesField, edgesFieldDefinition); if (objectNode.Result is Connection <TNode> connection) { if (edgesNode is ArrayExecutionNode edgesArrayNode) { edgesArrayNode.Result = connection.Edges; ExecutionStrategy.SetArrayItemNodes(context, edgesArrayNode); return(edgesArrayNode); } } } } return(null); }
public async Task <ActivityResponse> ExecuteAsync(Activity activity, ActivityArgs activityArgs, CancellationToken cancellationToken) { var executionStrategy = ExecutionStrategy.CreateFor(_executeMethod); var parameters = _executeMethod.BuildParametersFrom(activityArgs, cancellationToken); return(await executionStrategy.Execute(this, activity, parameters, activityArgs.TaskToken)); }
public ExecutionNode BuildExecutionNode(ExecutionNode node, IGraphType resolvedType, Field nodeField, FieldType fieldType) { return(ExecutionStrategy.BuildExecutionNode( node, resolvedType, nodeField, fieldType)); }
/// <summary> /// 创建定时任务构造器 /// </summary> /// <param name="strategy">执行策略</param> protected Crontab(ExecutionStrategy strategy) { //默认值 this.Id = Guid.NewGuid().ToString(); this.ExecutionStrategy = strategy; this.Status = CrontabStatus.Pending; this.AddedTime = DateTime.Now; }
public StreamingModul(IndicatorCollection indicators, Strategy strategy, ExecutionStrategy execStrat, ITradingAPI tradingApi, string instrument) { this.indicators = indicators; this.strategy = strategy; this.execStrat = execStrat; this.tradingApi = tradingApi; this.instrument = instrument; }
/// <summary> /// 调度任务 /// </summary> /// <typeparam name="T">任务类型</typeparam> /// <param name="delay">延迟时间(毫秒)</param> /// <remarks>适用于没有参数,只有策略的任务</remarks> public static void Schedule <T>(int delay = 1000) where T : class, ICrontab { //调度任务 Type crontabType = typeof(T); #region # 验证 if (!CrontabSetting.CrontabStrategies.ContainsKey(crontabType.Name)) { throw new InvalidOperationException($"没有为定时任务\"{crontabType.Name}\"配置执行策略"); } #endregion ExecutionStrategy executionStrategy = CrontabSetting.CrontabStrategies[crontabType.Name]; ICrontab crontab = CrontabFactory.CreateCrontab(crontabType, executionStrategy); IEnumerable <ICrontabExecutor> crontabExecutors = CrontabExecutorFactory.GetCrontabExecutorsFor(crontabType); foreach (ICrontabExecutor crontabExecutor in crontabExecutors) { JobKey jobKey = new JobKey(crontab.Id); if (!_Scheduler.CheckExists(jobKey).Result) { Type jobType = crontabExecutor.GetType(); JobBuilder jobBuilder = JobBuilder.Create(jobType); //设置任务数据 IDictionary <string, object> dictionary = new Dictionary <string, object>(); dictionary.Add(crontab.Id, crontab); jobBuilder.SetJobData(new JobDataMap(dictionary)); //创建任务明细 IJobDetail jobDetail = jobBuilder.WithIdentity(jobKey).Build(); //创建触发器 ITrigger trigger = GetTrigger(crontab.ExecutionStrategy); //为调度者添加任务明细与触发器 _Scheduler.ScheduleJob(jobDetail, trigger).Wait(); //开始调度 _Scheduler.StartDelayed(TimeSpan.FromMilliseconds(delay)).Wait(); } else { _Scheduler.ResumeJob(jobKey).Wait(); } } //保存任务 using (ICrontabStore crontabStore = ResolveMediator.ResolveOptional <ICrontabStore>()) { crontab.Status = CrontabStatus.Scheduled; crontabStore?.Store(crontab); } }
static void RunPatternBasedOnSelectedOption(string option) { switch (option) { case "1": ExecutionBuilderPattern.Run(); break; case "2": ExecutionAbstractFactory.Run(); break; case "3": ExecutionFactoryMethod.Run(); break; case "4": ExecutionSingleton.Run(); break; case "5": ExecutionAdapter.Run(); break; case "6": ExecutionFacade.Run(); break; case "7": ExecutionComposite.Run(); break; case "8": ExecutionDecorator.Run(); break; case "9": ExecutionCommand.Run(); break; case "10": ExecutionStrategy.Run(); break; case "11": ExecutionObserver.Run(); break; case "12": ExecutionMediator.Run(); break; default: throw new InvalidOperationException(); } }
/// <summary> /// 静态构造器 /// </summary> static CrontabSetting() { _CrontabLoginId = FrameworkSection.Setting.CrontabAccountLoginId.Value; _CrontabPassword = FrameworkSection.Setting.CrontabAccountPassword.Value; _CrontabStrategies = new ConcurrentDictionary <string, ExecutionStrategy>(); foreach (CrontabStrategyElement element in FrameworkSection.Setting.CrontabStrategyElements) { ExecutionStrategy strategy = GetExecutionStrategy(element.StrategyType, element.Strategy); _CrontabStrategies.Add(element.Type, strategy); } }
/// <summary> /// Receive an envelope for executing. /// </summary> internal override bool Receive(Envelope envelope) { ExecutionStrategy executionStrategy = _executionStrategy; if (executionStrategy != null) { executionStrategy.Execute(envelope); } RaiseEnvelopeReceivedEvent(envelope); return(true); }
public ResolverStep( ExecutionStrategy strategy, IReadOnlyList <ISelection> selections) { if (selections is null) { throw new ArgumentNullException(nameof(selections)); } Strategy = strategy; _selections = selections.ToArray(); }