public async Task <DatabaseScavengeResult> StartScavengeAsync( int threadCount = 1, int startFromChunk = 0, UserCredentials userCredentials = default, 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), 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 Start() { _call = _client.Read(RequestMetadata.Create(_userCredentials), cancellationToken: _disposed.Token); try { await _call.RequestStream.WriteAsync(new ReadReq { Options = _options }); if (!await _call.ResponseStream.MoveNext(_disposed.Token) || _call.ResponseStream.Current.ContentCase != ReadResp.ContentOneofCase.Empty) { throw new InvalidOperationException(); } } catch (Exception ex) { SubscriptionDropped(SubscriptionDroppedReason.ServerError, ex); return; } finally { _started.SetResult(true); } #pragma warning disable 4014 Task.Run(Subscribe); #pragma warning restore 4014 }
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), cancellationToken : cancellationToken); }
public async Task EnableAsync(string name, UserCredentials userCredentials = default, CancellationToken cancellationToken = default) { using var call = _client.EnableAsync(new EnableReq { Options = new EnableReq.Types.Options { Name = name } }, RequestMetadata.Create(userCredentials), cancellationToken: cancellationToken); await call.ResponseAsync.ConfigureAwait(false); }
public async Task DeleteAsync(string streamName, string groupName, UserCredentials userCredentials = default, CancellationToken cancellationToken = default) { await _client.DeleteAsync(new DeleteReq { Options = new DeleteReq.Types.Options { StreamName = streamName, GroupName = groupName } }, RequestMetadata.Create(userCredentials), cancellationToken : cancellationToken); }
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), cancellationToken: cancellationToken); await call.ResponseAsync.ConfigureAwait(false); }
public async Task CreateOneTimeAsync(string query, UserCredentials userCredentials = default, CancellationToken cancellationToken = default) { using var call = _client.CreateAsync(new CreateReq { Options = new CreateReq.Types.Options { OneTime = new CreateReq.Types.Empty(), Query = query } }, RequestMetadata.Create(userCredentials), cancellationToken: cancellationToken); await call.ResponseAsync; }
public async Task CreateTransientAsync(string name, string query, UserCredentials userCredentials = default, CancellationToken cancellationToken = default) { using var call = _client.CreateAsync(new CreateReq { Options = new CreateReq.Types.Options { Transient = new CreateReq.Types.Options.Types.Transient { Name = name }, Query = query } }, RequestMetadata.Create(userCredentials), cancellationToken: cancellationToken); await call.ResponseAsync; }
public async Task CreateContinuousAsync(string name, string query, bool trackEmittedStreams = false, UserCredentials userCredentials = default, 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), cancellationToken: cancellationToken); await call.ResponseAsync; }
public async IAsyncEnumerable <UserDetails> ListAllAsync(UserCredentials userCredentials = null, [EnumeratorCancellation] CancellationToken cancellationToken = default) { using var call = _client.Details(new DetailsReq(), RequestMetadata.Create(userCredentials), 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), cancellationToken: cancellationToken); var response = await call.ResponseAsync.ConfigureAwait(false); return(response.State); }
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)); await foreach (var projectionDetails in call.ResponseStream .ReadAllAsync(cancellationToken) .Select(ConvertToProjectionDetails) .WithCancellation(cancellationToken)) { yield return(projectionDetails); } }
public async Task DeleteUserAsync(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)); } await _client.DeleteAsync(new DeleteReq { Options = new DeleteReq.Types.Options { LoginName = loginName } }, RequestMetadata.Create(userCredentials), cancellationToken : cancellationToken); }
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), cancellationToken : cancellationToken); }
public async Task CreateAsync(string streamName, string groupName, PersistentSubscriptionSettings settings, UserCredentials userCredentials = default, 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), cancellationToken : cancellationToken); }
private async Task Start() { _call = _client.Read(RequestMetadata.Create(_userCredentials), cancellationToken: _disposed.Token); try { await _call.RequestStream.WriteAsync(new ReadReq { Options = _options }).ConfigureAwait(false); if (!await _call.ResponseStream.MoveNext(_disposed.Token).ConfigureAwait(false) || _call.ResponseStream.Current.ContentCase != ReadResp.ContentOneofCase.SubscriptionConfirmation) { throw new InvalidOperationException(); } } catch (Exception ex) { SubscriptionDropped(SubscriptionDroppedReason.ServerError, ex); return; } finally { _started.SetResult(true); } _ = Subscribe(); }
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), cancellationToken: cancellationToken); await call.ResponseStream.MoveNext().ConfigureAwait(false); var userDetails = call.ResponseStream.Current.UserDetails; return(ConvertUserDetails(userDetails)); }
public async Task UpdateAsync(string name, string query, bool?emitEnabled = null, UserCredentials userCredentials = default, 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), cancellationToken: cancellationToken); await call.ResponseAsync.ConfigureAwait(false); }