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); }