public SiloOrchestrator(ISolutionGrain solutionManager)
{
this.solutionManager = solutionManager;
//this.messageWorkList = new HashSet<Message>();
//this.messageWorkList = new Queue<Message>();
this.messageWorkList = new ConcurrentQueue <Message>();
}
/// <summary>
/// This auxiliary constructor is used only then a SolutionManager (e.g. SolutionGrain, already exists)
/// This is the case when we want to query an existing system
/// </summary>
/// <param name="solutionManager"></param>
/// <param name="machines"></param>
/// <param name="subject"></param>
public AnalysisClient(ISolutionGrain solutionManager, int machines, string subject = "")
{
this.analyzer = null;
this.solutionManager = solutionManager;
this.machines = machines;
this.subject = subject;
Environment.SetEnvironmentVariable("MyInstanceCount", machines.ToString());
AnalysisConstants.SetInstanceCount(machines);
}
public static ISolutionGrain GetSolutionGrain(IGrainFactory grainFactory)
{
if (solutionCache == null)
{
solutionCache = new SolutionGrainCache(grainFactory.GetGrain <ISolutionGrain>("Solution"));
}
var grain = solutionCache;
#if COMPUTE_STATS
grain = new SolutionGrainCallerWrapper(grain);
#endif
return(grain);
}
public static async Task PerformDeactivation(IGrainFactory grainFactory, ISolutionGrain solutionGrain)
{
//var solutionGrain = this.SolutionManager as ISolutionGrain;
await ForceDispatchersDeactivationAsync(grainFactory);
await solutionGrain.ForceDeactivationAsync();
//var systemManagement = grainFactory.GetGrain<IManagementGrain>(SYSTEM_MANAGEMENT_ID);
//await systemManagement.ForceActivationCollection(new System.TimeSpan(0,0,5));
// EmptyTable("OrleansGrainState");
}
public override async Task OnActivateAsync()
{
await StatsHelper.RegisterActivation("EffectsDispatcherGrain", this.GrainFactory);
this.isDispatchingEffects = false;
this.status = EffectsDispatcherStatus.Inactive;
this.lastProcessingTime = DateTime.UtcNow; // DateTime.MinValue; // DateTime.MaxValue;
this.solutionGrain = OrleansSolutionManager.GetSolutionGrain(this.GrainFactory);
this.effectsDispatcher = new OrleansEffectsDispatcherManager(this.GrainFactory, this.solutionGrain);
this.subscriptionManager = new ObserverSubscriptionManager <IAnalysisObserver>();
var streamProvider = this.GetStreamProvider(AnalysisConstants.StreamProvider);
var stream = streamProvider.GetStream <PropagationEffects>(this.GetPrimaryKey(), AnalysisConstants.StreamNamespace);
//await stream.SubscribeAsync(this);
// Explicit subscription code
var subscriptionHandles = await stream.GetAllSubscriptionHandles();
if (subscriptionHandles != null && subscriptionHandles.Count > 0)
{
var tasks = new List <Task>();
foreach (var subscriptionHandle in subscriptionHandles)
{
var task = subscriptionHandle.ResumeAsync(this);
//await task;
tasks.Add(task);
}
await Task.WhenAll(tasks);
}
else
{
await stream.SubscribeAsync(this);
}
var period = TimeSpan.FromMilliseconds(AnalysisConstants.DispatcherTimerPeriod);
this.timer = this.RegisterTimer(this.OnTimerTick, null, period, period);
await base.OnActivateAsync();
}
private async Task CreateMethodEntityAsync(MethodDescriptor methodDescriptor)
{
// This is a private method. We must not register this as a grain callee
// await StatsHelper.RegisterMsg("MethodEntityGrain::CreateMethodEntity", this.GrainFactory);
this.solutionGrain = OrleansSolutionManager.GetSolutionGrain(this.GrainFactory);
this.State.MethodDescriptor = methodDescriptor;
var methodDescriptorToSearch = methodDescriptor.BaseDescriptor;
var codeProviderGrain = await solutionGrain.GetProjectCodeProviderAsync(methodDescriptorToSearch);
// This wrapper caches some of the queries to codeProvider
//this.codeProvider = new ProjectCodeProviderWithCache(codeProviderGrain);
this.codeProvider = codeProviderGrain;
//Logger.LogWarning(this.GetLogger(), "MethodEntityGrain", "CreateMethodEntity", "{0} calls to proivder {1}", methodDescriptor, this.codeProvider);
var sw = new Stopwatch();
sw.Start();
this.methodEntity = (MethodEntity)await codeProvider.CreateMethodEntityAsync(methodDescriptorToSearch);
sw.Stop();
Logger.LogInfo(this.GetLogger(), "MethodEntityGrain", "CreateMethodEntity", "{0};call to provider;{1};ms;{2};ticks", methodDescriptor, sw.ElapsedMilliseconds, sw.ElapsedTicks);
if (methodDescriptor.IsAnonymousDescriptor)
{
this.methodEntity = this.methodEntity.GetAnonymousMethodEntity((AnonymousMethodDescriptor)methodDescriptor);
}
//// this is for RTA analysis
//await solutionGrain.AddInstantiatedTypesAsync(this.methodEntity.InstantiatedTypes);
// This take cares of doing the progation of types
this.methodEntityPropagator = new MethodEntityWithPropagator(methodEntity, codeProvider);
await this.WriteStateAsync();
//Logger.LogWarning(this.GetLogger(), "MethodEntityGrain", "CreateMethodEntity", "Exit {0}", methodDescriptor);
}
internal SolutionGrainCache(ISolutionGrain solutionGrain)
{
this.solutionGrain = solutionGrain;
}
internal SolutionGrainCallerWrapper(ISolutionGrain solutionGrain)
{
this.solutionGrain = solutionGrain;
}
