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