Beispiel #1
0
 public ContextManagerResident(
     string deploymentId,
     ContextDefinition contextDefinition)
 {
     ContextDefinition = contextDefinition;
     ContextRuntimeDescriptor = new ContextRuntimeDescriptor(contextDefinition.ContextName, deploymentId, this);
 }
Beispiel #2
0
        private static IDictionary<string, object> BuildContextPropertiesMap(
            int agentInstanceId,
            object[] allPartitionKeys,
            ContextDefinition contextDefinition)
        {
            IDictionary<string, object> props = new Dictionary<string, object>();
            props.Put(ContextPropertyEventType.PROP_CTX_NAME, contextDefinition.ContextName);
            props.Put(ContextPropertyEventType.PROP_CTX_ID, agentInstanceId);

            var controllerFactories = contextDefinition.ControllerFactories;

            if (controllerFactories.Length == 1) {
                controllerFactories[0].PopulateContextProperties(props, allPartitionKeys[0]);
                return props;
            }

            for (var level = 0; level < controllerFactories.Length; level++) {
                var nestedContextName = controllerFactories[level].FactoryEnv.ContextName;
                IDictionary<string, object> nestedProps = new Dictionary<string, object>();
                nestedProps.Put(ContextPropertyEventType.PROP_CTX_NAME, nestedContextName);
                if (level == controllerFactories.Length - 1) {
                    nestedProps.Put(ContextPropertyEventType.PROP_CTX_ID, agentInstanceId);
                }

                controllerFactories[level].PopulateContextProperties(nestedProps, allPartitionKeys[level]);
                props.Put(nestedContextName, nestedProps);
            }

            return props;
        }
Beispiel #3
0
 public static MappedEventBean BuildContextProperties(
     int agentInstanceId,
     object[] allPartitionKeys,
     ContextDefinition contextDefinition,
     StatementContext statementContextCreate)
 {
     var props = BuildContextPropertiesMap(agentInstanceId, allPartitionKeys, contextDefinition);
     return statementContextCreate.EventBeanTypedEventFactory.AdapterForTypedMap(
         props,
         contextDefinition.EventTypeContextProperties);
 }
        public void FromEnumTestNominal()
        {
            ContextDefinitionBuilder toTest = new ContextDefinitionBuilder();

            toTest.AnyOf("test", "test", typeof(testEnum), true);
            ContextDefinition ctx = toTest.definition;

            Assert.Equal(3, ctx.Items.Count);
            Assert.Contains("1", (from i in ctx.Items select i.Key));
            Assert.Contains("one", (from i in ctx.Items select i.Literal));
        }
Beispiel #5
0
        internal void ExtractContextRules()
        {
            //all evaluators used in this workflow
            List <string> evalIds = (from e in this.WorkflowManager.WorkFlow.Evaluators select e.Id).ToList();

            //all of the rules that use the evaluators
            List <Rule> evalRules = (from l in this.WorkflowManager.WorkFlow.Equations
                                     where evalIds.Contains(l.First.Id)
                                     select l.First)
                                    .Union(from r in this.WorkflowManager.WorkFlow.Equations
                                           where null != r.Second &&
                                           evalIds.Contains(r.Second.Id)
                                           select r.Second).ToList();


            //all rules that pass context
            List <string> rulesThatHaveContext = (from r in evalRules where r.Context != null select r.Id).Distinct().ToList();

            //all contexts used
            List <string> contextUsed = (from r in evalRules where r.Context != null select r.Context.Name.ToLower()).Distinct().ToList();

            //this is the inferred list
            this.ContextUsed = new List <ContextDefinition>(from c in this.WorkflowManager.WorkFlow.ContextDefinitions where contextUsed.Contains(c.Name.ToLower()) select(ContextDefinition) c.Clone());
            //clear all items, we will infer from rules
            //this is the basis for our test cases
            this.ContextUsed.ForEach(e => e.Items = new List <ContextItem>());

            //go through all of the rules, and define the contexts only for the keys used
            rulesThatHaveContext.ForEach(x =>
            {
                List <Rule> matchOnId = (from r in evalRules where r.Id.Equals(x, StringComparison.OrdinalIgnoreCase) select r).ToList();
                matchOnId.ForEach(e =>
                {
                    Context rulesContext   = e.Context;
                    ContextDefinition def  = ContextUsed.FirstOrDefault(c => c.Name.Equals(rulesContext.Name));
                    ContextDefinition full = this.WorkflowManager.GetContextDefinition(rulesContext.Name);

                    List <ContextItem> inferred = new List <ContextItem>(from z in rulesContext.Keys select new ContextItem()
                    {
                        Key = z, Literal = z
                    });
                    inferred.ForEach(i =>
                    {
                        ContextItem defined = full.Items.FirstOrDefault(g => g.Key.Equals(i.Key, StringComparison.OrdinalIgnoreCase));
                        i.Literal           = defined.Literal ?? i.Literal;
                        if (def.Items.Count(g => g.Key.Equals(i.Key, StringComparison.OrdinalIgnoreCase)) == 0)
                        {
                            def.Items.Add(i);
                        }
                    });
                });
            });
        }
Beispiel #6
0
        public void AddContext(
            ContextDefinition contextDefinition,
            EPStatementInitServices services)
        {
            var deployment = deployments.Get(services.DeploymentId);
            if (deployment == null) {
                deployment = new ContextDeployment();
                deployments.Put(services.DeploymentId, deployment);
            }

            deployment.Add(contextDefinition, services);
        }
Beispiel #7
0
        public void ActivateContext(
            string name,
            ContextDefinition definition)
        {
            // we are checking that all is resolved
            var detail = ModuleIncidentals.Contexts.Get(name);
            if (detail == null) {
                throw new ArgumentException("Failed to find context information for '" + name + "'");
            }

            ServicesContext.ContextManagementService.AddContext(definition, this);
        }
Beispiel #8
0
        public void Add(
            ContextDefinition contextDefinition,
            EPStatementInitServices services)
        {
            var contextName = contextDefinition.ContextName;
            var mgr = contexts.Get(contextName);
            if (mgr != null) {
                throw new EPException("Context by name '" + contextDefinition.ContextName + "' already exists");
            }

            var contextManager = new ContextManagerResident(services.DeploymentId, contextDefinition);
            contexts.Put(contextName, contextManager);
        }
 public IBuildIntention <IImplementationDefinition> GetBuildIntention(IConversionContext context)
 {
     var(toBuild, maker) = ImplementationDefinition.Create();
     return(new BuildIntention <IImplementationDefinition>(toBuild, () =>
     {
         maker.Build(
             TransformerExtensions.Convert <IVerifiableType>(OutputType.GetOrThrow(), context),
             ContextDefinition.IfIs(x => x.GetValue()).GetOrThrow().Convert(context),
             ParameterDefinition.IfIs(x => x.GetValue()).GetOrThrow().Convert(context),
             Scope.Convert(context),
             MethodBody.Select(x => x.GetOrThrow().ConvertElementOrThrow(context)).ToArray(),
             StaticInitialzers.Select(x => x.ConvertElementOrThrow(context)).ToArray());
     }));
 }
Beispiel #10
0
        private ArticulateEvaluator ArticulateEvaluator(LogicDefine.Rule x)
        {
            ArticulateEvaluator toBuild = new ArticulateEvaluator()
            {
                Id = x.Id
            };

            LogicDefine.Evaluator ev = this.workflow.Evaluators.FirstOrDefault(g => g.Id == x.Id);
            toBuild.Literal = ev.Description;

            toBuild.TrueCondition = x.TrueCondition;
            if (x.Context != null)
            {
                ContextDefinition ctxDef = this.workflow.ContextDefinitions.FirstOrDefault(g => g.Name.Equals(x.Context.Name, StringComparison.OrdinalIgnoreCase));

                string ctxLit = string.Join(",", (from i in ctxDef.Items where x.Context.Keys.Contains(i.Key) select i.Literal));

                ArticulateContext articulateContext = new ArticulateContext()
                {
                    Literal = ctxDef.Literal, Value = ctxLit
                };
                //var intent = this.logicIntents.FirstOrDefault(g => g.evaluatorId == x.Id);
                //if (intent != null && intent.Context != null)
                //{
                //    articulateContext.Literal = intent.Context.Literal;
                //    if (intent.Context.Values != null)
                //    {
                //        ContextItem match = intent.Context.Values.FirstOrDefault(k => k.Key == ctx.Key);
                //        if (!string.IsNullOrEmpty(match.Key))
                //        {
                //            ctx.Literal = match.Literal;
                //        }

                //    }


                //}
                //if (string.IsNullOrEmpty(ctx.Literal)) { ctx.Literal = "Inferred"; }
                //if (string.IsNullOrEmpty(articulateContext.Literal)) { articulateContext.Literal = "Inferred"; }
                //articulateContext.Context = ctx;
                toBuild.Context = articulateContext;
            }

            return(toBuild);
        }
Beispiel #11
0
        public IBuildIntention <IImplementationDefinition> GetBuildIntention(IConversionContext context)
        {
            var(toBuild, maker) = ImplementationDefinition.Create();



            return(new BuildIntention <IImplementationDefinition>(toBuild, () =>
            {
                var contextMember = ContextDefinition.Convert(context);

                maker.Build(
                    OutputType.Is1OrThrow().Convert(context),
                    contextMember,
                    ParameterDefinition.Convert(context),
                    Scope.GetValue().Convert(context),
                    MethodBody.GetValue().Select(x => x.Is1OrThrow().GetValue().ConvertElementOrThrow(context)).ToArray(),
                    StaticInitialzers.Select(x => x.ConvertElementOrThrow(context)).ToArray(),
                    Model.Instantiated.Scope.CreateAndBuild(new IsStatic[] {
                    new IsStatic(contextMember, false)
                }));
            }));
        }
Beispiel #12
0
 public IEnumerable <IError> Validate()
 {
     foreach (var error in OutputType.SwitchReturns(x => x.Validate(), x => new[] { x }))
     {
         yield return(error);
     }
     foreach (var error in ContextDefinition.Validate())
     {
         yield return(error);
     }
     foreach (var error in ParameterDefinition.Validate())
     {
         yield return(error);
     }
     foreach (var error in Scope.GetValue().Validate())
     {
         yield return(error);
     }
     foreach (var line in MethodBody.GetValue().OfType <IIsDefinately <IBox <IFrontendCodeElement> > >().Select(x => x.Value))
     {
         foreach (var error in line.GetValue().Validate())
         {
             yield return(error);
         }
     }
     foreach (var error in MethodBody.GetValue().OfType <IIsDefinately <IError> >().Select(x => x.Value))
     {
         yield return(error);
     }
     foreach (var line in StaticInitialzers)
     {
         foreach (var error in line.Validate())
         {
             yield return(error);
         }
     }
 }
 public DataInputOutputSerde[] GetContextPartitionKeyBindings(
     ContextDefinition contextDefinition)
 {
     return null;
 }