public async Task ShutdownAsync(
UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
await _client.ShutdownAsync(EmptyResult, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
cancellationToken : cancellationToken);
}
public async Task <UserDetails> GetUserAsync(string loginName, UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
if (loginName == null)
{
throw new ArgumentNullException(nameof(loginName));
}
if (loginName == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(loginName));
}
using var call = _client.Details(new DetailsReq {
Options = new DetailsReq.Types.Options {
LoginName = loginName
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
await call.ResponseStream.MoveNext().ConfigureAwait(false);
var userDetails = call.ResponseStream.Current.UserDetails;
return(ConvertUserDetails(userDetails));
}
public async Task ResetPasswordAsync(string loginName, string newPassword,
UserCredentials?userCredentials = null, CancellationToken cancellationToken = default)
{
if (loginName == null)
{
throw new ArgumentNullException(nameof(loginName));
}
if (newPassword == null)
{
throw new ArgumentNullException(nameof(newPassword));
}
if (loginName == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(loginName));
}
if (newPassword == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(newPassword));
}
await _client.ResetPasswordAsync(new ResetPasswordReq {
Options = new ResetPasswordReq.Types.Options {
NewPassword = newPassword,
LoginName = loginName
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken : cancellationToken);
}
public async Task <DatabaseScavengeResult> StartScavengeAsync(
int threadCount = 1,
int startFromChunk = 0,
UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
if (threadCount <= 0)
{
throw new ArgumentOutOfRangeException(nameof(threadCount));
}
if (startFromChunk < 0)
{
throw new ArgumentOutOfRangeException(nameof(startFromChunk));
}
var result = await _client.StartScavengeAsync(new StartScavengeReq {
Options = new StartScavengeReq.Types.Options {
ThreadCount = threadCount,
StartFromChunk = startFromChunk
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
cancellationToken : cancellationToken);
return(result.ScavengeResult switch {
ScavengeResp.Types.ScavengeResult.Started => DatabaseScavengeResult.Started(result.ScavengeId),
ScavengeResp.Types.ScavengeResult.Stopped => DatabaseScavengeResult.Stopped(result.ScavengeId),
ScavengeResp.Types.ScavengeResult.InProgress => DatabaseScavengeResult.InProgress(result.ScavengeId),
_ => throw new InvalidOperationException()
});
private async Task <DeleteResult> DeleteInternal(DeleteReq request, UserCredentials userCredentials,
CancellationToken cancellationToken)
{
var result = await _client.DeleteAsync(request, RequestMetadata.Create(userCredentials),
cancellationToken : cancellationToken);
return(new DeleteResult(new Position(result.Position.CommitPosition, result.Position.PreparePosition)));
}
public async Task SetNodePriorityAsync(int nodePriority,
UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
await _client.SetNodePriorityAsync(new SetNodePriorityReq { Priority = nodePriority },
RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
cancellationToken : cancellationToken);
}
private async Task <DeleteResult> TombstoneInternal(TombstoneReq request,
EventStoreClientOperationOptions operationOptions, UserCredentials userCredentials,
CancellationToken cancellationToken)
{
var result = await _client.TombstoneAsync(request, RequestMetadata.Create(userCredentials),
deadline : DeadLine.After(operationOptions.TimeoutAfter), cancellationToken);
return(new DeleteResult(new Position(result.Position.CommitPosition, result.Position.PreparePosition)));
}
public async Task EnableAsync(string name, UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
using var call = _client.EnableAsync(new EnableReq {
Options = new EnableReq.Types.Options {
Name = name
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
await call.ResponseAsync.ConfigureAwait(false);
}
private async Task <DeleteResult> DeleteInternal(DeleteReq request, EventStoreClientOperationOptions operationOptions,
UserCredentials?userCredentials,
CancellationToken cancellationToken)
{
_log.LogDebug("Deleting stream {streamName}.", request.Options.StreamName);
var result = await _client.DeleteAsync(request, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
deadline : DeadLine.After(operationOptions.TimeoutAfter), cancellationToken);
return(new DeleteResult(new Position(result.Position.CommitPosition, result.Position.PreparePosition)));
}
public async Task DeleteAsync(string streamName, string groupName, UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
await _client.DeleteAsync(new DeleteReq {
Options = new DeleteReq.Types.Options {
StreamIdentifier = streamName,
GroupName = groupName
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken : cancellationToken);
}
public async Task CreateOneTimeAsync(string query, UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
using var call = _client.CreateAsync(new CreateReq {
Options = new CreateReq.Types.Options {
OneTime = new Empty(),
Query = query
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
await call.ResponseAsync.ConfigureAwait(false);
}
private async Task DisableInternalAsync(string name, bool writeCheckpoint, UserCredentials?userCredentials,
CancellationToken cancellationToken)
{
using var call = _client.DisableAsync(new DisableReq {
Options = new DisableReq.Types.Options {
Name = name,
WriteCheckpoint = writeCheckpoint
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
await call.ResponseAsync.ConfigureAwait(false);
}
private async Task <WriteResult> AppendToStreamInternal(
AppendReq header,
IEnumerable <EventData> eventData,
EventStoreClientOperationOptions operationOptions,
UserCredentials userCredentials,
CancellationToken cancellationToken)
{
using var call = _client.Append(RequestMetadata.Create(userCredentials),
deadline: DeadLine.After(operationOptions.TimeoutAfter), cancellationToken: cancellationToken);
try {
await call.RequestStream.WriteAsync(header).ConfigureAwait(false);
foreach (var e in eventData)
{
_log.LogTrace("Appending event to stream - {streamName}@{eventId} {eventType}.",
header.Options.StreamName, e.EventId, e.Type);
await call.RequestStream.WriteAsync(new AppendReq {
ProposedMessage = new AppendReq.Types.ProposedMessage {
Id = e.EventId.ToDto(),
Data = ByteString.CopyFrom(e.Data.Span),
CustomMetadata = ByteString.CopyFrom(e.Metadata.Span),
Metadata =
{
{ Constants.Metadata.Type, e.Type },
{ Constants.Metadata.ContentType, e.ContentType }
}
}
}).ConfigureAwait(false);
}
await call.RequestStream.CompleteAsync().ConfigureAwait(false);
} catch (InvalidOperationException exc) {
_log.LogTrace(exc, "Got InvalidOperationException when appending events to stream - {streamName}. This is perfectly normal if the connection was closed from the server-side.", header.Options.StreamName);
} catch (RpcException exc) {
_log.LogTrace(exc, "Got RpcException when appending events to stream - {streamName}. This is perfectly normal if the connection was closed from the server-side.", header.Options.StreamName);
}
var response = await call.ResponseAsync.ConfigureAwait(false);
var writeResult = new WriteResult(
response.CurrentRevisionOptionCase == AppendResp.CurrentRevisionOptionOneofCase.NoStream
? AnyStreamRevision.NoStream.ToInt64()
: new StreamRevision(response.CurrentRevision).ToInt64(),
response.PositionOptionCase == AppendResp.PositionOptionOneofCase.Position
? new Position(response.Position.CommitPosition, response.Position.PreparePosition)
: default);
_log.LogDebug("Append to stream succeeded - {streamName}@{logPosition}/{nextExpectedVersion}.",
header.Options.StreamName, writeResult.LogPosition, writeResult.NextExpectedVersion);
return(writeResult);
}
public async Task CreateContinuousAsync(string name, string query, bool trackEmittedStreams = false,
UserCredentials?userCredentials = null, CancellationToken cancellationToken = default)
{
using var call = _client.CreateAsync(new CreateReq {
Options = new CreateReq.Types.Options {
Continuous = new CreateReq.Types.Options.Types.Continuous {
Name = name,
TrackEmittedStreams = trackEmittedStreams
},
Query = query
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
await call.ResponseAsync.ConfigureAwait(false);
}
public async Task DisableUserAsync(string loginName, UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
if (loginName == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(loginName));
}
await _client.DisableAsync(new DisableReq {
Options = new DisableReq.Types.Options {
LoginName = loginName
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken : cancellationToken);
}
public async IAsyncEnumerable <UserDetails> ListAllAsync(UserCredentials?userCredentials = null,
[EnumeratorCancellation] CancellationToken cancellationToken = default)
{
using var call = _client.Details(new DetailsReq(), RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
cancellationToken: cancellationToken);
await foreach (var userDetail in call.ResponseStream
.ReadAllAsync(cancellationToken)
.Select(x => ConvertUserDetails(x.UserDetails))
.WithCancellation(cancellationToken)
.ConfigureAwait(false))
{
yield return(userDetail);
}
}
private async ValueTask <Value> GetStateInternalAsync(string name, string?partition,
UserCredentials?userCredentials,
CancellationToken cancellationToken)
{
using var call = _client.StateAsync(new StateReq {
Options = new StateReq.Types.Options {
Name = name,
Partition = partition ?? string.Empty
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
var response = await call.ResponseAsync.ConfigureAwait(false);
return(response.State);
}
public Task <PersistentSubscription> SubscribeAsync(string streamName, string groupName,
Func <PersistentSubscription, ResolvedEvent, int?, CancellationToken, Task> eventAppeared,
Action <PersistentSubscription, SubscriptionDroppedReason, Exception?>?subscriptionDropped = null,
UserCredentials?userCredentials = null, int bufferSize = 10, bool autoAck = true,
CancellationToken cancellationToken = default)
{
if (streamName == null)
{
throw new ArgumentNullException(nameof(streamName));
}
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
if (eventAppeared == null)
{
throw new ArgumentNullException(nameof(eventAppeared));
}
if (streamName == string.Empty)
{
throw new ArgumentException($"{nameof(streamName)} may not be empty.", nameof(streamName));
}
if (groupName == string.Empty)
{
throw new ArgumentException($"{nameof(groupName)} may not be empty.", nameof(groupName));
}
if (bufferSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(bufferSize));
}
var call = _client.Read(RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
return(PersistentSubscription.Confirm(call, new ReadReq.Types.Options {
BufferSize = bufferSize,
GroupName = groupName,
StreamName = streamName,
UuidOption = new ReadReq.Types.Options.Types.UUIDOption {
Structured = new Empty()
}
}, autoAck, eventAppeared,
subscriptionDropped ?? delegate { }, cancellationToken));
}
private async IAsyncEnumerable <ProjectionDetails> ListInternalAsync(StatisticsReq.Types.Options options,
UserCredentials?userCredentials,
[EnumeratorCancellation] CancellationToken cancellationToken)
{
using var call = _client.Statistics(new StatisticsReq {
Options = options
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials));
await foreach (var projectionDetails in call.ResponseStream
.ReadAllAsync(cancellationToken)
.Select(ConvertToProjectionDetails)
.WithCancellation(cancellationToken)
.ConfigureAwait(false))
{
yield return(projectionDetails);
}
}
public async Task CreateUserAsync(string loginName, string fullName, string[] groups, string password,
UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
if (loginName == null)
{
throw new ArgumentNullException(nameof(loginName));
}
if (fullName == null)
{
throw new ArgumentNullException(nameof(fullName));
}
if (groups == null)
{
throw new ArgumentNullException(nameof(groups));
}
if (password == null)
{
throw new ArgumentNullException(nameof(password));
}
if (loginName == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(loginName));
}
if (fullName == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(fullName));
}
if (password == string.Empty)
{
throw new ArgumentOutOfRangeException(nameof(password));
}
await _client.CreateAsync(new CreateReq {
Options = new CreateReq.Types.Options {
LoginName = loginName,
FullName = fullName,
Password = password,
Groups = { groups }
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken : cancellationToken);
}
public async Task CreateAsync(string streamName, string groupName,
PersistentSubscriptionSettings settings, UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
if (streamName == null)
{
throw new ArgumentNullException(nameof(streamName));
}
if (groupName == null)
{
throw new ArgumentNullException(nameof(groupName));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
await _client.CreateAsync(new CreateReq {
Options = new CreateReq.Types.Options {
StreamName = streamName,
GroupName = groupName,
Settings = new CreateReq.Types.Settings {
Revision = settings.StartFrom,
CheckpointAfter = settings.CheckPointAfter.Ticks,
ExtraStatistics = settings.ExtraStatistics,
MessageTimeout = settings.MessageTimeout.Ticks,
ResolveLinks = settings.ResolveLinkTos,
HistoryBufferSize = settings.HistoryBufferSize,
LiveBufferSize = settings.LiveBufferSize,
MaxCheckpointCount = settings.MaxCheckPointCount,
MaxRetryCount = settings.MaxRetryCount,
MaxSubscriberCount = settings.MaxSubscriberCount,
MinCheckpointCount = settings.MinCheckPointCount,
NamedConsumerStrategy = NamedConsumerStrategyToCreateProto[settings.NamedConsumerStrategy],
ReadBatchSize = settings.ReadBatchSize
}
}
}, RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken : cancellationToken);
}
private async Task <WriteResult> AppendToStreamInternal(
AppendReq header,
IEnumerable <EventData> eventData,
UserCredentials userCredentials,
CancellationToken cancellationToken)
{
using var call = _client.Append(RequestMetadata.Create(userCredentials),
cancellationToken: cancellationToken);
await call.RequestStream.WriteAsync(header).ConfigureAwait(false);
foreach (var e in eventData)
{
await call.RequestStream.WriteAsync(new AppendReq {
ProposedMessage = new AppendReq.Types.ProposedMessage {
Id = new Streams.UUID {
String = e.EventId.ToString("n")
},
Data = ByteString.CopyFrom(e.Data),
CustomMetadata = ByteString.CopyFrom(e.Metadata),
Metadata =
{
{ Constants.Metadata.Type, e.Type },
{ Constants.Metadata.IsJson, e.IsJson.ToString().ToLowerInvariant() }
}
}
}).ConfigureAwait(false);
}
await call.RequestStream.CompleteAsync().ConfigureAwait(false);
var response = await call.ResponseAsync.ConfigureAwait(false);
return(new WriteResult(
response.CurrentRevisionOptionCase == AppendResp.CurrentRevisionOptionOneofCase.NoStream
? AnyStreamRevision.NoStream.ToInt64()
: new StreamRevision(response.CurrentRevision).ToInt64(),
response.PositionOptionCase == AppendResp.PositionOptionOneofCase.Position
? new Position(response.Position.CommitPosition, response.Position.PreparePosition)
: default));
}
public async Task UpdateAsync(string name, string query, bool?emitEnabled = null,
UserCredentials?userCredentials = null, CancellationToken cancellationToken = default)
{
var options = new UpdateReq.Types.Options {
Name = name,
Query = query
};
if (emitEnabled.HasValue)
{
options.EmitEnabled = emitEnabled.Value;
}
else
{
options.NoEmitOptions = new Empty();
}
using var call = _client.UpdateAsync(new UpdateReq {
Options = options
},
RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials), cancellationToken: cancellationToken);
await call.ResponseAsync.ConfigureAwait(false);
}
public async Task RestartSubsystemAsync(UserCredentials?userCredentials = null,
CancellationToken cancellationToken = default)
{
await _client.RestartSubsystemAsync(new Empty(), RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
cancellationToken : cancellationToken);
}
private async Task <IWriteResult> AppendToStreamInternal(
AppendReq header,
IEnumerable <EventData> eventData,
EventStoreClientOperationOptions operationOptions,
UserCredentials?userCredentials,
CancellationToken cancellationToken)
{
using var call = _client.Append(RequestMetadata.Create(userCredentials ?? Settings.DefaultCredentials),
DeadLine.After(operationOptions.TimeoutAfter), cancellationToken);
IWriteResult writeResult;
try {
await call.RequestStream.WriteAsync(header).ConfigureAwait(false);
foreach (var e in eventData)
{
_log.LogTrace("Appending event to stream - {streamName}@{eventId} {eventType}.",
header.Options.StreamIdentifier, e.EventId, e.Type);
await call.RequestStream.WriteAsync(new AppendReq {
ProposedMessage = new AppendReq.Types.ProposedMessage {
Id = e.EventId.ToDto(),
Data = ByteString.CopyFrom(e.Data.Span),
CustomMetadata = ByteString.CopyFrom(e.Metadata.Span),
Metadata =
{
{ Constants.Metadata.Type, e.Type },
{ Constants.Metadata.ContentType, e.ContentType }
}
}
}).ConfigureAwait(false);
}
await call.RequestStream.CompleteAsync().ConfigureAwait(false);
} finally {
var response = await call.ResponseAsync.ConfigureAwait(false);
if (response.Success != null)
{
writeResult = new SuccessResult(
response.Success.CurrentRevisionOptionCase ==
AppendResp.Types.Success.CurrentRevisionOptionOneofCase.NoStream
? StreamState.NoStream.ToInt64()
: new StreamRevision(response.Success.CurrentRevision).ToInt64(),
response.Success.PositionOptionCase == AppendResp.Types.Success.PositionOptionOneofCase.Position
? new Position(response.Success.Position.CommitPosition,
response.Success.Position.PreparePosition)
: default);
_log.LogDebug("Append to stream succeeded - {streamName}@{logPosition}/{nextExpectedVersion}.",
header.Options.StreamIdentifier, writeResult.LogPosition, writeResult.NextExpectedVersion);
}
else
{
if (response.WrongExpectedVersion != null)
{
var expectedRevision = response.WrongExpectedVersion.ExpectedRevisionOptionCase switch {
AppendResp.Types.WrongExpectedVersion.ExpectedRevisionOptionOneofCase.Any =>
StreamState.Any.ToInt64(),
AppendResp.Types.WrongExpectedVersion.ExpectedRevisionOptionOneofCase.StreamExists =>
StreamState.StreamExists.ToInt64(),
_ => new StreamRevision(response.WrongExpectedVersion.ExpectedRevision).ToInt64()
};
var currentRevision = response.WrongExpectedVersion.CurrentRevisionOptionCase switch {
AppendResp.Types.WrongExpectedVersion.CurrentRevisionOptionOneofCase.NoStream =>
StreamState.NoStream.ToInt64(),
_ => new StreamRevision(response.WrongExpectedVersion.CurrentRevision).ToInt64()
};
_log.LogDebug(
"Append to stream failed with Wrong Expected Version - {streamName}/{expectedRevision}/{currentRevision}",
header.Options.StreamIdentifier, expectedRevision, currentRevision);
if (operationOptions.ThrowOnAppendFailure)
{
throw new WrongExpectedVersionException(header.Options.StreamIdentifier, expectedRevision,
currentRevision);
}
writeResult = new WrongExpectedVersionResult(
header.Options.StreamIdentifier, expectedRevision, currentRevision);
}
else
{
throw new InvalidOperationException("The operation completed with an unexpected result.");
}
}
}
return(writeResult);
}
