示例#1
0
 /// <summary>
 /// Create the StartConditionMessage which is send to Hub and ResourceAgent
 /// </summary>
 /// <param name="operation"></param>
 /// <returns></returns>
 public static FUpdateStartCondition GetStartCondition(this FOperation operation, long customerDue)
 {
     return(new FUpdateStartCondition(operationKey: operation.Key
                                      , customerDue: customerDue
                                      , preCondition: operation.StartConditions.PreCondition
                                      , articlesProvided: operation.StartConditions.ArticlesProvided));
 }
示例#2
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="input"></param>
 /// <param name="durationSelector"></param>
 /// <typeparam name="TPayload"></typeparam>
 /// <returns></returns>
 public static FOperation <TPayload> AlterEventDuration <TPayload>(
     this FOperation <TPayload> input,
     Expression <Func <long, long, long> > durationSelector
     )
 {
     return(new AlterDurationFOperation <TPayload>(input, durationSelector));
 }
        private void EnqueueJob(FOperation fOperation)
        {
            var localItem = _operationList.FirstOrDefault(x => x.Key == fOperation.Key);

            // If item is not Already in Queue Add item to Queue
            // // happens i.e. Machine calls to Requeue item.
            if (localItem == null)
            {
                localItem = fOperation;
                localItem.UpdateHubAgent(hub: Agent.Context.Self);
                _operationList.Add(item: localItem);

                Agent.DebugMessage(msg: $"Got New Item to Enqueue: {fOperation.Operation.Name} | with start condition: {fOperation.StartConditions.Satisfied} with Id: {fOperation.Key}");
            }
            else
            {
                // reset Item.
                Agent.DebugMessage(msg: $"Got Item to Requeue: {fOperation.Operation.Name} | with start condition: {fOperation.StartConditions.Satisfied} with Id: {fOperation.Key}");
                fOperation.Proposals.Clear();
                localItem = fOperation;
                //localItem = fOperation.UpdateHubAgent(hub: Agent.Context.Self);
                _operationList.Replace(val: localItem);
            }

            var resourceToRequest = _resourceManager.GetResourceByTool(fOperation.Operation.ResourceTool);

            foreach (var actorRef in resourceToRequest)
            {
                Agent.DebugMessage(msg: $"Ask for proposal at resource {actorRef.Path.Name}");
                Agent.Send(instruction: Resource.Instruction.RequestProposal.Create(message: localItem, target: actorRef));
            }
        }
        private void EnqueueJob(FOperation fOperation)
        {
            var localItem = _operationList.FirstOrDefault(x => x.Key == fOperation.Key);

            // If item is not Already in Queue Add item to Queue
            // // happens i.e. Machine calls to Requeue item.
            if (localItem == null)
            {
                localItem = fOperation;
                localItem.UpdateHubAgent(hub: Agent.Context.Self);
                _operationList.Add(item: localItem);

                Agent.DebugMessage(msg: "Got New Item to Enqueue: " + fOperation.Operation.Name + " | with start condition:" + fOperation.StartConditions.Satisfied + " with Id: " + fOperation.Key);
            }
            else
            {
                // reset Item.
                Agent.DebugMessage(msg: "Got Item to Requeue: " + fOperation.Operation.Name + " | with start condition:" + fOperation.StartConditions.Satisfied + " with Id: " + fOperation.Key);
                fOperation.Proposals.Clear();
                localItem = fOperation;
                //localItem = fOperation.UpdateHubAgent(hub: Agent.Context.Self);
                _operationList.Replace(val: localItem);
            }

            foreach (var actorRef in _resourceAgents)
            {
                Agent.Send(instruction: Resource.Instruction.RequestProposal.Create(message: localItem, target: actorRef.Key));
            }
        }
示例#5
0
        public FEndStreamable(FOperation <TResult> fop)
            : base(new StreamProperties <Empty, TResult>(
                       false,
                       false, null,
                       false, null, null,
                       false, false,
                       false, false,
                       EqualityComparerExpression <Empty> .Default,
                       EqualityComparerExpression <TResult> .Default,
                       null,
                       null,
                       new Dictionary <Expression, object>(),
                       new Dictionary <Expression, Guid?>(),
                       null)
                   )
        {
            Contract.Requires(fop != null);
            this.pool = MemoryManager.GetMemoryPool <Empty, TResult>(false);
            this.pool.Get(out this.output);
            this.output.Allocate();

            var fwindow = fop.Compile(0, fop.Size * Config.FuseFactor);

            //Config.DataGranularity = fwindow.Size;
            owindow = new OutputFWindow <TResult>(fwindow);
        }
示例#6
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="input"></param>
 /// <param name="joiner"></param>
 /// <typeparam name="TPayload"></typeparam>
 /// <typeparam name="TResult"></typeparam>
 /// <returns></returns>
 public static FOperation <TResult> ConsecutivePairs <TPayload, TResult>(
     this FOperation <TPayload> input,
     PairFWindow <TPayload, TResult> .Joiner joiner
     )
 {
     return(new PairFOperation <TPayload, TResult>(input, joiner));
 }
示例#7
0
        public static FBucket ToBucketItem(this FOperation operation, long time)
        {
            // TO BE TESTET
            var prioRule = Extension.CreateFunc(
                // Lamda zur Func.
                func: (bucket, currentTime) => bucket.Operations.Min(selector: y => ((IJob)y).Priority(time))
                // ENDE
                );
            var operations = new List <FOperation>();

            operations.Add(item: operation);

            return(new FBucket(key: Guid.NewGuid()
                               //, prioRule: prioRule.ToFSharpFunc()
                               , priority: prioRule.ToFSharpFunc()
                               , name: $"{operation.Operation.ResourceSkill.Name}({BucketNumber++})"
                               , creationTime: time
                               , forwardStart: 0
                               , forwardEnd: 0
                               , backwardStart: 0
                               , backwardEnd: 0
                               , end: 0
                               , start: 0
                               , startConditions: new FStartCondition(preCondition: false, articlesProvided: false)
                               , maxBucketSize: 1
                               , minBucketSize: 1
                               , resourceAgent: ActorRefs.NoSender
                               , hubAgent: ActorRefs.NoSender
                               , operations: new FSharpSet <FOperation>(elements: operations)
                               , tool: operation.Tool
                               , proposals: new List <FProposal>()));
        }
示例#8
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="input"></param>
 /// <param name="window"></param>
 /// <param name="transform"></param>
 /// <typeparam name="TPayload"></typeparam>
 /// <typeparam name="TResult"></typeparam>
 /// <returns></returns>
 public static FOperation <TResult> Transform <TPayload, TResult>(
     this FOperation <TPayload> input,
     long window,
     Action <int, TPayload[], int, TResult[], int> transform
     )
 {
     return(new W2WFOperation <TPayload, TResult>(input, window, transform));
 }
示例#9
0
 public FBucket Add(FBucket bucket, FOperation fOperation)
 {
     if (bucket == null)
     {
         throw new Exception($"Bucket {bucket.Name} does not exits");
     }
     bucket = bucket.AddOperation(fOperation);
     return(bucket);
 }
示例#10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="source"></param>
        /// <param name="predicate"></param>
        /// <typeparam name="TPayload"></typeparam>
        /// <returns></returns>
        public static FOperation <TPayload> Where <TPayload>(
            this FOperation <TPayload> source,
            Expression <Func <TPayload, bool> > predicate
            )
        {
            Invariant.IsNotNull(source, nameof(source));
            Invariant.IsNotNull(predicate, nameof(predicate));

            return(new WhereFOperation <TPayload>(source, predicate));
        }
示例#11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="source"></param>
        /// <param name="selector"></param>
        /// <typeparam name="TPayload"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <returns></returns>
        public static FOperation <TResult> Multicast <TPayload, TResult>(
            this FOperation <TPayload> source,
            Func <FOperation <TPayload>, FOperation <TResult> > selector
            )
        {
            Invariant.IsNotNull(source, nameof(source));
            Invariant.IsNotNull(selector, nameof(selector));

            return(selector(new MulticastFOperation <TPayload>(source)));
        }
示例#12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="source"></param>
        /// <param name="selector"></param>
        /// <typeparam name="TPayload"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <returns></returns>
        public static FOperation <TResult> Select <TPayload, TResult>(
            this FOperation <TPayload> source,
            SelectFWindow <TPayload, TResult> .Selector selector
            )
        {
            Invariant.IsNotNull(source, nameof(source));
            Invariant.IsNotNull(selector, nameof(selector));

            return(new SelectFOperation <TPayload, TResult>(source, selector));
        }
示例#13
0
        public JobConfirmation CreateBucket(FOperation fOperation, Agent agent)
        {
            var bucketSize      = GetBucketSize(fOperation.RequiredCapability.Id);
            var bucket          = fOperation.ToBucketScopeItem(agent.Context.Self, agent.CurrentTime, bucketSize);
            var jobConfirmation = new JobConfirmation(bucket);

            jobConfirmation.SetJobAgent(agent.Context.ActorOf(Job.Props(agent.ActorPaths, jobConfirmation.ToImmutable(), agent.CurrentTime, agent.DebugThis, agent.Context.Self)
                                                              , $"JobAgent({bucket.Name.ToActorName()})"));
            _jobConfirmations.Add(jobConfirmation);
            return(jobConfirmation);
        }
示例#14
0
        /// <summary>
        /// Starts the next Job
        /// </summary>
        internal void DoWork(FOperation operation)
        {
            Agent.DebugMessage($"Call start Work for {_jobInProgress.JobName} {operation.Operation.Name} {operation.Key} to process for {operation.Operation.RandomizedDuration}", CustomLogger.JOB, LogLevel.Warn);
            _jobInProgress.SetupIsOngoing = false;
            _jobInProgress.StartProcessing(Agent.CurrentTime, _jobInProgress.JobDuration);

            _jobInProgress.CurrentOperation.Set(operation, Agent.CurrentTime);
            CreateProcessingTask(operation);

            Agent.Send(Resource.Instruction.Default.FinishTask.Create("PROCESSING", Agent.Context.Self), waitFor: operation.Operation.RandomizedDuration);
        }
示例#15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <param name="joiner"></param>
        /// <typeparam name="TLeft"></typeparam>
        /// <typeparam name="TRight"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <returns></returns>
        public static FOperation <TResult> Join <TLeft, TRight, TResult>(
            this FOperation <TLeft> left,
            FOperation <TRight> right,
            JoinFWindow <TLeft, TRight, TResult> .Joiner joiner
            )
        {
            Invariant.IsNotNull(left, nameof(left));
            Invariant.IsNotNull(right, nameof(right));

            return(new JoinFOperation <TLeft, TRight, TResult>(left, right, joiner));
        }
示例#16
0
 /// <summary>
 ///
 /// </summary>
 public AggregateFOperation(
     FOperation <TPayload> input,
     IAggregate <TPayload, TAggState, TResult> aggregate,
     long window, long period, long offset
     ) : base(input)
 {
     Invariant.IsTrue(window % period == 0, "Window must be a multiple of period");
     Invariant.IsTrue(period % Input.Period == 0, "Period must be a multiple of input period");
     _aggregate = aggregate;
     _window    = window;
     _period    = period;
     _offset    = offset;
 }
示例#17
0
        void CreateProcessingTask(FOperation item)
        {
            var pub = new FCreateTaskItem(
                type: JobType.OPERATION
                , resource: Agent.Name.Replace("Resource(", "").Replace(")", "")
                , start: Agent.CurrentTime
                , end: Agent.CurrentTime + item.Operation.RandomizedDuration
                , capability: _jobInProgress.RequiredCapabilityName
                , operation: item.Operation.Name
                , groupId: _jobInProgress.JobName);

            //TODO NO tracking
            Agent.Context.System.EventStream.Publish(@event: pub);
        }
示例#18
0
 public static FOperation <Signal> Resample(
     this FOperation <Signal> source,
     long iperiod,
     long operiod,
     long gap_tol
     )
 {
     return(source
            .ConsecutivePairs <Signal, SigPair>(ResampleJoiner)
            .AlterEventDuration((s, e) => (e - s > gap_tol) ? iperiod : e - s)
            .Chop(1)
            .Select <SigPair, Signal>(ResampleSelector)
            .AlterPeriod(operiod)
            );
 }
示例#19
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="source"></param>
        /// <param name="aggregate"></param>
        /// <param name="window"></param>
        /// <param name="period"></param>
        /// <param name="offset"></param>
        /// <typeparam name="TPayload"></typeparam>
        /// <typeparam name="TAggState"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <returns></returns>
        public static FOperation <TResult> Aggregate <TPayload, TAggState, TResult>(
            this FOperation <TPayload> source,
            Func <Window <Empty, TPayload>, IAggregate <TPayload, TAggState, TResult> > aggregate,
            long window, long period, long offset = 0
            )
        {
            Invariant.IsNotNull(source, nameof(source));
            Invariant.IsNotNull(aggregate, nameof(aggregate));
            var p = new StreamProperties <Empty, TPayload>(
                false, true, source.Period, true, period, offset, false, true, true, true,
                EqualityComparerExpression <Empty> .Default, EqualityComparerExpression <TPayload> .Default,
                ComparerExpression <Empty> .Default, ComparerExpression <TPayload> .Default, null, null, null
                );

            return(new AggregateFOperation <TPayload, TAggState, TResult>(
                       source, aggregate(new Window <Empty, TPayload>(p)), window, period, offset
                       ));
        }
示例#20
0
        internal void EnqueueOperation(FOperation fOperation)
        {
            Agent.DebugMessage(msg: $"Original FOperation before add to Bucket : {fOperation.Operation.Name} {fOperation.Key}" +
                               $"| with start condition: {fOperation.StartConditions.Satisfied} with Id: {fOperation.Key}" +
                               $"| ArticleProvided: {fOperation.StartConditions.ArticlesProvided} " +
                               $"| PreCondition: {fOperation.StartConditions.PreCondition}", CustomLogger.JOB, LogLevel.Warn);

            var operationInBucket = _bucketManager.GetBucketByOperationKey(fOperation.Key);

            if (operationInBucket != null)
            {
                Agent.DebugMessage($"{fOperation.Operation.Name} {fOperation.Key} is already in bucket", CustomLogger.ENQUEUE, LogLevel.Warn);
                return;
            }


            var jobConfirmation = _bucketManager.AddToBucket(fOperation, Agent.CurrentTime);

            if (jobConfirmation != null)
            {
                var bucket = ((FBucket)jobConfirmation.Job);
                var operationInsideBucket = bucket.Operations.Single(x => x.Key.Equals(fOperation.Key));

                Agent.DebugMessage(msg: $"FOperation {operationInsideBucket.Operation.Name} inside Bucket {bucket.Name} {bucket.Key}" +
                                   $"| with start condition: {operationInsideBucket.StartConditions.Satisfied} with Id: {operationInsideBucket.Key}" +
                                   $"| ArticleProvided: {operationInsideBucket.StartConditions.ArticlesProvided} " +
                                   $"| PreCondition: {operationInsideBucket.StartConditions.PreCondition}", CustomLogger.JOB, LogLevel.Warn);

                Agent.DebugMessage($"Operation {fOperation.Operation.Name} {fOperation.Key} was added to {bucket.Name} {bucket.Key} Send to {jobConfirmation.JobAgentRef.Path.Name}", CustomLogger.ENQUEUE, LogLevel.Warn);

                Agent.Send(instruction: BasicInstruction.UpdateJob.Create(message: bucket, target: jobConfirmation.JobAgentRef));

                return;//if no bucket to add exists create a new one
            }

            jobConfirmation = _bucketManager.CreateBucket(fOperation: fOperation, Agent);
            EnqueueBucket(jobConfirmation.Job.Key);

            Agent.DebugMessage($"New {jobConfirmation.Job.Name} has been created for Operation {fOperation.Operation.Name} {fOperation.Key}", CustomLogger.ENQUEUE, LogLevel.Warn);

            //after creating new bucket, modify subsequent buckets
            RequestDissolveBucket(fOperation);
        }
示例#21
0
        internal void RequestDissolveBucket(FOperation operation)
        {
            var bucketsToDissolve = _bucketManager.FindAllBucketsLaterForwardStart(operation);

            if (bucketsToDissolve.Count > 0)
            {
                foreach (var bucket in bucketsToDissolve)
                {
                    if (bucket.IsRequestedToDissolve)
                    {
                        continue;
                    }

                    bucket.IsRequestedToDissolve = true;
                    Agent.DebugMessage(msg: $"Asking Job Agent to start dissolve {bucket.Job.Key}");
                    Agent.Send(Job.Instruction.RequestDissolve.Create(bucket.JobAgentRef));
                }
            }
        }
示例#22
0
        public static FBucket ToBucketScopeItem(this FOperation operation, IActorRef hubAgent, long time, long maxBucketSize)
        {
            //Todo Abs of BackwardStart and ForwardStart, avoid negative values
            //var scope = Math.Abs(operation.BackwardStart - operation.ForwardStart);
            var scope = (operation.BackwardStart - operation.ForwardStart);
            // TO BE TESTET
            var prioRule = Extension.CreateFunc(
                // Lamda zur Func.
                func: (bucket, currentTime) => bucket.Operations.Min(selector: y => ((IJob)y).Priority(currentTime))
                // ENDE
                );

            var operations = new List <FOperation> {
                operation
            };

            return(new FBucket(key: Guid.NewGuid()
                               //, prioRule: prioRule.ToFSharpFunc()
                               , priority: prioRule.ToFSharpFunc()
                               , name: $"(Bucket({BucketNumber++})){operation.RequiredCapability.Name}"
                               , isFixPlanned: false
                               , creationTime: time
                               , forwardStart: operation.ForwardStart
                               , forwardEnd: operation.ForwardEnd
                               , backwardStart: operation.BackwardStart
                               , backwardEnd: operation.BackwardEnd
                               , scope: scope
                               , end: 0
                               , start: 0
                               , startConditions: new FStartCondition(preCondition: false, articlesProvided: false)
                               , maxBucketSize: maxBucketSize
                               , minBucketSize: 1000
                               , setupKey: -1 //unset
                               , hubAgent: hubAgent
                               , operations: new FSharpSet <FOperation>(elements: operations)
                               , requiredCapability: operation.RequiredCapability
                               , bucket: String.Empty));
        }
示例#23
0
        public static FCreateSimulationJob ToSimulationJob(this FOperation fOperation, string jobType, FArticle fArticle, string productionAgent)
        {
            var simulationJob = new FCreateSimulationJob(
                key: fOperation.Key.ToString()
                , dueTime: fOperation.DueTime
                , articleName: fOperation.Operation.Article.Name
                , operationName: fOperation.Operation.Name
                , operationHierarchyNumber: fOperation.Operation.HierarchyNumber
                , operationDuration: fOperation.Operation.Duration
                , requiredCapabilityName: fOperation.Operation.ResourceCapability.Name
                , jobType: jobType.ToString()
                , customerOrderId: fArticle.CustomerOrderId.ToString()
                , isHeadDemand: fArticle.IsHeadDemand
                , fArticleKey: fArticle.Key
                , fArticleName: fArticle.Article.Name
                , productionAgent: productionAgent
                , articleType: fArticle.Article.ArticleType.Name
                , start: fOperation.Start
                , end: fOperation.End
                );

            return(simulationJob);
        }
示例#24
0
        /// <summary>
        /// Add the operation to an existing matching bucket or otherwise creates a new one
        /// </summary>
        /// <param name="fOperation"></param>
        /// <param name="hubAgent"></param>
        /// <param name="currentTime"></param>
        /// <returns></returns>
        public JobConfirmation AddToBucket(FOperation fOperation, long time)
        {
            var matchingBuckets = FindAllWithEqualCapability(fOperation).Select(x => x.Job).Cast <FBucket>().ToList();

            if (matchingBuckets != null)
            {
                //Add
                var bucket = FindEarliestAndLatestScopeMatching(matchingBuckets, fOperation, time);
                if (bucket != null)
                {
                    bucket = Add(bucket: bucket, fOperation: fOperation);

                    var jobConfirmation = GetConfirmationByBucketKey(bucket.Key);
                    if (jobConfirmation == null)
                    {
                        throw new Exception("Tried to add bucket to unknown jobConfirmation");
                    }
                    jobConfirmation.Job = bucket;
                    return(jobConfirmation);
                }
            }
            //need to create a new one
            return(null);
        }
示例#25
0
        /// <summary>
        /// Return null if no matching bucket exits
        /// </summary>
        /// <param name="buckets">gets a List of all bi</param>
        /// <param name="operation"></param>
        /// <returns></returns>
        public FBucket FindEarliestAndLatestScopeMatching(List <FBucket> buckets, FOperation operation, long time)
        {
            List <FBucket> matchingBuckets = new List <FBucket>();

            foreach (var bucket in buckets)
            {
                var maxbucket = ExceedMaxBucketSize(bucket, operation);

                if (!maxbucket)
                {
                    //System.Diagnostics.Debug.WriteLine($"Max bucket size exceed");
                }

                if (HasCapacityLeft(bucket, operation) && HasLaterForwardStart(bucket, operation) && maxbucket)
                {
                    matchingBuckets.Add(bucket);
                }
            }

            //var matchingBucket = GetBucketWithMostLeftCapacity(matchingBuckets);
            var matchingBucket = matchingBuckets.OrderBy(x => x.Priority.Invoke(x).Invoke(time)).FirstOr(null);

            return(matchingBucket);
        }
 private DoWork(FOperation message, IActorRef target) : base(message: message, target: target)
 {
 }
 public static DoWork Create(FOperation message, IActorRef target)
 {
     return(new DoWork(message: message, target: target));
 }
示例#28
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="input"></param>
 /// <param name="filter"></param>
 public WhereFOperation(FOperation <TPayload> input, Expression <Func <TPayload, bool> > filter) : base(input)
 {
     _filter = filter;
 }
示例#29
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="input"></param>
 /// <param name="period"></param>
 /// <typeparam name="TPayload"></typeparam>
 /// <returns></returns>
 public static FOperation <TPayload> AlterPeriod <TPayload>(this FOperation <TPayload> input, long period)
 {
     return(new AlterPeriodFOperation <TPayload>(input, period));
 }
示例#30
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="fop"></param>
 /// <typeparam name="TResult"></typeparam>
 /// <returns></returns>
 public static IStreamable <Empty, TResult> FuseEnd <TResult>(this FOperation <TResult> fop)
 {
     return(new FEndStreamable <TResult>(fop));
 }