示例#1
0
        public virtual Task <PlacementResult> OnAddActivation(
            PlacementStrategy strategy, PlacementTarget target, IPlacementContext context)
        {
            var grainType = context.GetGrainTypeName(target.GrainId);
            var allSilos  = context.GetCompatibleSiloList(target);

            return(Task.FromResult(
                       PlacementResult.SpecifyCreation(allSilos[random.Next(allSilos.Count)], strategy, grainType)));
        }
        public Task <PlacementResult> SelectSiloPowerOfK(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
        {
            var compatibleSilos = context.GetCompatibleSiloList(grain);
            // Exclude overloaded and non-compatible silos
            var relevantSilos = new List <CachedLocalStat>();

            foreach (CachedLocalStat current in localCache.Values)
            {
                if (IsSiloOverloaded(current.SiloStats))
                {
                    continue;
                }
                if (!compatibleSilos.Contains(current.Address))
                {
                    continue;
                }

                relevantSilos.Add(current);
            }

            if (relevantSilos.Count > 0)
            {
                int chooseFrom           = Math.Min(relevantSilos.Count, chooseHowMany);
                var chooseFromThoseSilos = new List <CachedLocalStat>();
                while (chooseFromThoseSilos.Count < chooseFrom)
                {
                    int index      = random.Next(relevantSilos.Count);
                    var pickedSilo = relevantSilos[index];
                    relevantSilos.RemoveAt(index);
                    chooseFromThoseSilos.Add(pickedSilo);
                }

                CachedLocalStat minLoadedSilo = chooseFromThoseSilos.First();
                foreach (CachedLocalStat s in chooseFromThoseSilos)
                {
                    if (SiloLoad_ByRecentActivations(s) < SiloLoad_ByRecentActivations(minLoadedSilo))
                    {
                        minLoadedSilo = s;
                    }
                }

                return(MakePlacement(strategy, grain, context, minLoadedSilo));
            }

            var debugLog = string.Format("Unable to select a candidate from {0} silos: {1}", localCache.Count,
                                         Utils.EnumerableToString(
                                             localCache,
                                             kvp => String.Format("SiloAddress = {0} -> {1}", kvp.Key.ToString(), kvp.Value.ToString())));

            logger.Warn(ErrorCode.Placement_ActivationCountBasedDirector_NoSilos, debugLog);
            throw new OrleansException(debugLog);
        }
        OnAddActivation(PlacementStrategy strategy, GrainId grain, IPlacementContext context)
        {
            // if local silo is not active or does not support this type of grain, revert to random placement
            if (context.LocalSiloStatus != SiloStatus.Active || !context.GetCompatibleSiloList(grain).Contains(context.LocalSilo))
            {
                return(base.OnAddActivation(strategy, grain, context));
            }

            var grainType = context.GetGrainTypeName(grain);

            return(Task.FromResult(
                       PlacementResult.SpecifyCreation(context.LocalSilo, strategy, grainType)));
        }