private static async Task <IClusterClient> InitializeWithRetries(ClientBuilderContext context)
{
var attempt = 0;
var stopwatch = Stopwatch.StartNew();
var clientClusterConfig = new ClientConfiguration();
await Task.Delay(TimeSpan.FromSeconds(clientClusterConfig.DelayInitialConnectSeconds));
var clientConfig = new ClientBuilder()
.UseConfiguration(context);
context.ConfigureClientBuilder?.Invoke(clientConfig);
var client = clientConfig.Build();
await client.Connect(async ex =>
{
attempt++;
if (attempt > clientClusterConfig.ConnectionRetry.TotalRetries)
{
Console.WriteLine(ex.Message);
return(false);
}
var delay = RandomUtils.GenerateNumber(clientClusterConfig.ConnectionRetry.MinDelaySeconds, clientClusterConfig.ConnectionRetry.MaxDelaySeconds);
Console.WriteLine("Client cluster {0} failed to connect. Attempt {1} of {2}. Retrying in {3}s.",
context.ClusterId, attempt, clientClusterConfig.ConnectionRetry.TotalRetries, delay);
await Task.Delay(TimeSpan.FromSeconds(delay));
return(true);
});
Console.WriteLine("Client cluster connected successfully to silo {0} in {1:#.##}s.",
context.ClusterId, stopwatch.Elapsed.TotalSeconds);
return(client);
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
_hubContext = GrainFactory.GetHub <IUserNotificationHub>();
var item = new UserNotification
{
MessageCount = 0
};
await Set(item);
RegisterTimer(async x =>
{
State.UserNotification.MessageCount = RandomUtils.GenerateNumber(1, 100);
await Set(State.UserNotification);
var userNotification = new UserNotification
{
MessageCount = item.MessageCount
};
await _hubContext.User(PrimaryKey).SendSignalRMessage("Broadcast", userNotification);
}, State, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3));
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
_hubContext = GrainFactory.GetHub <IHeroHub>();
if (State.Hero == null)
{
// todo: use key data
var keySplit = PrimaryKey.Split('/');
_keyData.Tenant = keySplit[1];
_keyData.HeroKey = keySplit[2];
var hero = await _heroDataClient.GetByKey(_keyData.HeroKey);
await Set(hero);
}
var hubGroup = _hubContext.Group($"hero:{_keyData.HeroKey}");
var hubAllGroup = _hubContext.Group($"hero:all");
var streamProvider = GetStreamProvider(Constants.STREAM_PROVIDER);
var stream = streamProvider.GetStream <Hero>(StreamConstants.HeroStream, $"hero:{_keyData.HeroKey}");
RegisterTimer(async x =>
{
State.Hero.Health = RandomUtils.GenerateNumber(1, 100);
await Task.WhenAll(
Set(State.Hero),
stream.OnNextAsync(State.Hero),
hubGroup.SendSignalRMessage("HeroChanged", State.Hero),
hubAllGroup.SendSignalRMessage("HeroChanged", State.Hero)
);
}, State, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3));
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
if (State.Hero == null)
{
// todo: use key data
var keySplit = PrimaryKey.Split('/');
_keyData.Tenant = keySplit[1];
_keyData.HeroKey = keySplit[2];
var hero = await _heroDataClient.GetByKey(_keyData.HeroKey);
await Set(hero);
}
var streamProvider = GetStreamProvider(Constants.STREAM_PROVIDER);
var stream = streamProvider.GetStream <Hero>(StreamConstants.HeroStream, $"hero:{PrimaryKey}");
RegisterTimer(async x =>
{
State.Hero.Health = RandomUtils.GenerateNumber(1, 100);
await Task.WhenAll(
Set(State.Hero),
stream.OnNextAsync(State.Hero)
);
}, State, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3));
}
private static ISiloHostBuilder UseDockerSwarm(this ISiloHostBuilder siloHost)
{
var ips = Dns.GetHostAddressesAsync(Dns.GetHostName()).Result;
var defaultIp = ips.FirstOrDefault();
return(siloHost
.ConfigureEndpoints(
defaultIp,
RandomUtils.GenerateNumber(30001, 30100), // todo: really needed random?
RandomUtils.GenerateNumber(20001, 20100), // todo: really needed random?
listenOnAnyHostAddress: true
));
}
public override async Task OnActivateAsync()
{
await base.OnActivateAsync();
_hubContext = GrainFactory.GetHub <IHeroHub>();
_keyData = this.ParseKey <HeroKeyData>(HeroKeyData.Template);
if (State.Entity == null)
{
var entity = await _heroDataClient.GetByKey(_keyData.Id);
if (entity == null)
{
return;
}
await Set(entity);
}
var hubGroup = _hubContext.Group($"{_keyData.Tenant}/hero/{_keyData.Id}");
var hubAllGroup = _hubContext.Group($"{_keyData.Tenant}/hero"); // all
var streamProvider = GetStreamProvider(Constants.STREAM_PROVIDER);
var stream = streamProvider.GetStream <Hero>(StreamConstants.HeroStream, $"hero:{_keyData.Id}");
RegisterTimer(async x =>
{
State.Entity.Health = RandomUtils.GenerateNumber(1, 100);
await Task.WhenAll(
Set(State.Entity),
stream.OnNextAsync(State.Entity),
hubGroup.Send("HeroChanged", State.Entity),
hubAllGroup.Send("HeroChanged", State.Entity)
);
}, State, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(3));
}
