public async Task SetSelectorStrategy(GrainInterfaceType interfaceType, VersionSelectorStrategy strategy)
{
CheckIfIsExistingInterface(interfaceType);
await SetStrategy(
store => store.SetSelectorStrategy(interfaceType, strategy),
siloControl => siloControl.SetSelectorStrategy(interfaceType, strategy));
}
public VersionSelectorManager(IServiceProvider serviceProvider, IOptions <GrainVersioningOptions> options)
{
this.serviceProvider = serviceProvider;
this.strategyFromConfig = serviceProvider.GetRequiredServiceByName <VersionSelectorStrategy>(options.Value.DefaultVersionSelectorStrategy);
Default = ResolveVersionSelector(serviceProvider, this.strategyFromConfig);
versionSelectors = new Dictionary <GrainInterfaceType, IVersionSelector>();
}
private static IVersionSelector ResolveVersionSelector(IServiceProvider serviceProvider,
VersionSelectorStrategy strategy)
{
var policyType = strategy.GetType();
return(serviceProvider.GetRequiredServiceByKey <Type, IVersionSelector>(policyType));
}
public VersionSelectorManager(IServiceProvider serviceProvider, GlobalConfiguration configuration)
{
this.serviceProvider = serviceProvider;
this.strategyFromConfig = configuration.DefaultVersionSelectorStrategy;
Default = ResolveVersionSelector(serviceProvider, strategyFromConfig);
versionSelectors = new Dictionary <int, IVersionSelector>();
}
private static IVersionSelector ResolveVersionSelector(IServiceProvider serviceProvider,
VersionSelectorStrategy strategy)
{
var policyType = strategy.GetType();
var directorType = typeof(IVersionSelector <>).MakeGenericType(policyType);
return((IVersionSelector)serviceProvider.GetRequiredService(directorType));
}
public void SetSelector(GrainInterfaceType interfaceType, VersionSelectorStrategy strategy)
{
if (strategy == null)
{
versionSelectors.Remove(interfaceType);
}
else
{
var selector = ResolveVersionSelector(this.serviceProvider, strategy);
versionSelectors[interfaceType] = selector;
}
}
public void SetSelector(VersionSelectorStrategy strategy)
{
var selector = ResolveVersionSelector(this.serviceProvider, strategy ?? this.strategyFromConfig);
Default = selector;
}
public async Task SetSelectorStrategy(VersionSelectorStrategy strategy)
{
await SetStrategy(
store => store.SetSelectorStrategy(strategy),
siloControl => siloControl.SetSelectorStrategy(strategy));
}
public async Task SetSelectorStrategy(int interfaceId, VersionSelectorStrategy strategy)
{
ThrowIfNotEnabled();
await StoreGrain.SetSelectorStrategy(interfaceId, strategy);
}
public async Task SetSelectorStrategy(VersionSelectorStrategy strategy)
{
ThrowIfNotEnabled();
await StoreGrain.SetSelectorStrategy(strategy);
}
public Task SetSelectorStrategy(int interfaceId, VersionSelectorStrategy strategy)
{
this.selectorManager.SetSelector(interfaceId, strategy);
this.cachedVersionSelectorManager.ResetCache();
return(Task.CompletedTask);
}
public async Task SetSelectorStrategy(int ifaceId, VersionSelectorStrategy strategy)
{
this.State.VersionSelectorStrategies[ifaceId] = strategy;
await this.WriteStateAsync();
}
public async Task SetSelectorStrategy(VersionSelectorStrategy strategy)
{
this.State.SelectorOverride = strategy;
await this.WriteStateAsync();
}
