private async Task HandleMessageAsync(IAsyncBusEntity bus, VersionMoveAndConfirmNotification notification)
{
_log.LogInformation($"received 'VersionMoveAndConfirm(new=#{notification.VersionNumber}, old=#{notification.OldVersion}, b=#{notification.BaseVersionNumber})' notification from Vendor #{notification.FactoryInstanceId}");
if (notification.FactoryInstanceId == FactoryInstanceId)
{
_log.LogInformation($"skip processing of self generated notification");
return;
}
UpdateGlobalLatestVersionNumber(notification.VersionNumber);
var rejectedVersionAccumulator = _versions.AddOrUpdate(notification.OldVersion,
v => new MovedVersionAccumulator(v, notification.BaseVersionNumber, notification.VersionNumber),
a => a.MoveVersion(notification.BaseVersionNumber, notification.VersionNumber));
_log.LogVerbose($"rejected version #{rejectedVersionAccumulator.VersionNumber} for base #{notification.BaseVersionNumber}");
var versionAccumulator = _versions.AddOrUpdate(notification.VersionNumber,
v => new SingleVersionAccumulator(v, notification.BaseVersionNumber),
a => a.ConfirmVersion(notification.BaseVersionNumber));
_log.LogVerbose($"accumulated version #{versionAccumulator.VersionNumber} for base #{notification.BaseVersionNumber}");
await ProcessConfirmedVersions(bus);
_log.LogInformation($"finished processing 'VersionMoveAndConfirm(new=#{notification.VersionNumber}, old=#{notification.OldVersion}, b=#{notification.BaseVersionNumber})' notification from Vendor #{notification.FactoryInstanceId}");
}
public Task StartAsync(IAsyncBusBroker busBroker)
{
_log.LogInformation($"Start Troll actor '{FactoryInstanceId}' of factory '{FactoryId}'");
_bus = _busConfigFunc(busBroker);
return(Task.FromResult(0));
}
protected Task OnMessage(IAsyncBusEntity entity, string messageId, IDictionary <string, string> headers, object data)
{
_log.LogTrace($"Fabric Async Bus Listener received message '{messageId}' from '{entity.EntityId}': {data}");
// TBD
return(Task.FromResult(0));
}
public async Task <Tuple <long, Task <long> > > PromoteNewVersion(IAsyncBusEntity bus, long baseVersionNumber)
{
var versionAccumulator = _versions.AddOrUpdate(Interlocked.Increment(ref _versionNumber), v => new SingleVersionAccumulator(v, baseVersionNumber), a => a.ConfirmVersion(baseVersionNumber));
_log.LogVerbose($"Vendor actor instance #{FactoryInstanceId} of factory '{FactoryId}' promote new version #{versionAccumulator.VersionNumber} for base #{baseVersionNumber}");
await bus.PublishMessageAsync(new VersionConfirmNotification(FactoryId, FactoryInstanceId, versionAccumulator.VersionNumber, baseVersionNumber));
return(new Tuple <long, Task <long> >(versionAccumulator.VersionNumber, versionAccumulator.ConfirmTask));
}
public Task HandleMessageAsync(IAsyncBusEntity sender, VersionCumulativeUpdateNotification <T> notification)
{
_log.LogInformation($"Librarian actor #{FactoryInstanceId} of factory '{FactoryId}' received notification of type '{notification.GetType()}' from async bus entity '{sender.EntityId}'");
_log.LogVerbose($"VersionCumulativeUpdate: base=#{notification.CumulativeUpdate.BaseVersionNumber}, version=#{notification.VersionNumber}, cumulativeUpdate='{notification.CumulativeUpdate.GetType()}'");
_updates.AddOrUpdate(notification.CumulativeUpdate.BaseVersionNumber,
v => new Dictionary <long, ICumulativeUpdate <T> > {
{ notification.FactoryInstanceId, notification.CumulativeUpdate }
},
d => { d.Add(notification.FactoryInstanceId, notification.CumulativeUpdate); return(d); });
return(Task.FromResult(0));
}
protected override IEnumerable <ServiceInstanceListener> CreateServiceInstanceListeners()
{
_log.LogInformation("Create Service Listeners");
var asyncBusConfig = _config.Sections["AsyncBus"];
if (asyncBusConfig == null)
{
throw new ArgumentException("Configuration section 'AsyncBus' not found");
}
_actionsEntity = _asyncBusBroker.GetEntity(asyncBusConfig.Parameters["ActionsEntity"].Value);
return(new[]
{
new ServiceInstanceListener(ctx => new AsyncBusListener(_actionsEntity, ctx, _loggerFactory.CreateLogger("ActionsEntityListener")), _actionsEntity.EntityId)
});
}
public async Task StartAsync(IAsyncBusBroker busBroker)
{
_log.LogInformation((int)Events.Start, $"Start Vendor actor instance #{FactoryInstanceId} of factory '{FactoryId}'");
if (Interlocked.CompareExchange(ref _isInitialized, 1, 0) != 0)
{
_log.LogWarning($"Vendor actor #{FactoryInstanceId} of factory '{FactoryId}' already started");
return;
}
_log.LogVerbose($"Start internal Vendor actor instance #{_librarian.FactoryInstanceId} of factory '{FactoryId}'");
await _librarian.StartAsync(busBroker);
_log.LogVerbose($"Get async bus entity for Vendor actor #{FactoryInstanceId} of factory '{FactoryId}'");
_busEntity = _busEntityFunc(busBroker);
_log.LogVerbose($"Subscribe for notifications from async bus entity '{_busEntity.EntityId}', Vendor actor #{FactoryInstanceId} of factory '{FactoryId}'");
await Task.WhenAll(
_busEntity.SubscribeAsync <VersionConfirmNotification>(HandleMessageAsync),
_busEntity.SubscribeAsync <VersionMoveAndConfirmNotification>(HandleMessageAsync));
_log.LogInformation($"Vendor actor instance #{FactoryInstanceId} of factory '{FactoryId}' has been successfully started");
}
public AsyncBusListener(IAsyncBusEntity asyncBusEntity, StatelessServiceContext serviceContext, ILogger log)
{
_asyncBusEntity = asyncBusEntity;
_serviceContext = serviceContext;
_log = log;
}
protected abstract Task ExecuteHandler(IAsyncBusEntity entity, string messageId, IDictionary <string, string> headers, object message);
public static Task <IAsyncBusEntitySubscription> SubscribeAsync <T>(this IAsyncBusEntity entity, Func <T, Task> messageHandler) where T : class
{
return(entity.SubscribeAsync((s, i, h, d) => d is T ? messageHandler((T)d) : DefaultResultTask));
}
public static Task PublishMessageAsync <T>(this IAsyncBusEntity entity, T message) where T : class
{
return(entity.PublishMessageAsync(new Dictionary <string, string>(), message));
}
private Task OnActionReceived(IAsyncBusEntity entity, string messageId, IDictionary <string, string> headers, object data)
{
_log.LogInformation($"Received message '{messageId}' from '{entity.EntityId}' with Action");
return(Task.FromResult(0));
}
public CitizensController(IAsyncBusEntity asyncBusEntity)
{
_asyncBusEntity = asyncBusEntity;
}
protected override Task ExecuteHandler(IAsyncBusEntity entity, string messageId, IDictionary <string, string> headers, object message)
{
return(_asyncHandler(entity, messageId, headers, message));
}
private async Task ProcessConfirmedVersions(IAsyncBusEntity bus)
{
Func <long, VersionAccumulator> moveVersionFunc = null;
var confirmedVersionNumber = Volatile.Read(ref _confirmedVersionNumber);
var versionNumber = Volatile.Read(ref _versionNumber);
_log.LogVerbose($"Start process confirmed versions from #{confirmedVersionNumber} to #{versionNumber}");
while (confirmedVersionNumber <= versionNumber)
{
_log.LogInformation($"Processing version #{confirmedVersionNumber}");
VersionAccumulator originalAccumulator;
var versionAccumulator = _versions.AddOrUpdate(confirmedVersionNumber, v => null, a => a.ApproveOrMoveVersion(out moveVersionFunc), out originalAccumulator);
if (versionAccumulator == null)
{
_log.LogInformation($"Version #{confirmedVersionNumber} doesn't exist");
return;
}
if (versionAccumulator.IsCompleted && originalAccumulator?.IsCompleted == true)
{
_log.LogVerbose($"Version #{confirmedVersionNumber} has been already approved or moved");
confirmedVersionNumber = Interlocked.Increment(ref _confirmedVersionNumber);
continue;
}
if (versionAccumulator.IsCompleted || (!versionAccumulator.IsCompleted && confirmedVersionNumber == versionNumber))
{
var baseVersion = (versionAccumulator as BaseVersionAccumulator)?.BaseVersionNumber;
if (baseVersion == null)
{
throw new InvalidOperationException($"Version accumulator #{versionAccumulator.VersionNumber} cannot be completed with multiple base versions");
}
if (moveVersionFunc != null)
{
_log.LogInformation((int)Events.Moving, $"Moving version #{versionAccumulator.VersionNumber} for base #{baseVersion}");
VersionAccumulator currentAccumulator;
do
{
versionNumber = Interlocked.Increment(ref _versionNumber);
_versions.AddOrUpdate(versionNumber, moveVersionFunc, a => a, out currentAccumulator);
} while (currentAccumulator != null);
_log.LogInformation((int)Events.Moved, $"Moved version #{versionAccumulator.VersionNumber} for base #{baseVersion} to version #{versionNumber}");
await bus.PublishMessageAsync(new VersionMoveAndConfirmNotification(FactoryId, FactoryInstanceId, versionNumber, baseVersion.Value, versionAccumulator.VersionNumber));
}
else
{
_log.LogInformation((int)Events.Approved, $"Approved version #{versionAccumulator.VersionNumber} for base #{baseVersion}");
await bus.PublishMessageAsync(new VersionConfirmNotification(FactoryId, FactoryInstanceId, versionAccumulator.VersionNumber, baseVersion.Value));
}
confirmedVersionNumber = Interlocked.Increment(ref _confirmedVersionNumber);
if (confirmedVersionNumber > versionNumber)
{
if (Interlocked.CompareExchange(ref _versionNumber, confirmedVersionNumber, versionNumber) == versionNumber)
{
_log.LogInformation((int)Events.SetVersion, $"Set last version number #{confirmedVersionNumber}");
}
return;
}
}
}
}
