protected override async Task Given()
{
foreach (var @event in CreateTestEvents(10))
{
await StreamsClient.AppendToStreamAsync("non-system-stream-" + Guid.NewGuid(),
StreamState.Any, new[] { @event });
}
await Client.CreateToAllAsync(Group, new PersistentSubscriptionSettings(startFrom : Position.End), TestCredentials.Root);
_subscription = await Client.SubscribeToAllAsync(Group,
(subscription, e, r, ct) => {
if (SystemStreams.IsSystemStream(e.OriginalStreamId))
{
return(Task.CompletedTask);
}
_firstNonSystemEventSource.TrySetResult(e);
return(Task.CompletedTask);
}, (subscription, reason, ex) => {
if (reason != SubscriptionDroppedReason.Disposed)
{
_firstNonSystemEventSource.TrySetException(ex !);
}
}, TestCredentials.Root);
}
/// <summary>
/// Initializes an instance of <see cref="VideoClient"/>.
/// </summary>
internal VideoClient(YoutubeHttpClient httpClient)
{
_httpClient = httpClient;
Streams = new StreamsClient(httpClient);
ClosedCaptions = new ClosedCaptionClient(httpClient);
}
protected override async Task When()
{
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.Any, new[] { e });
}
}
public override Task DisposeAsync()
{
StreamsClient?.Dispose();
UserManagementClient?.Dispose();
Client?.Dispose();
return(base.DisposeAsync());
}
protected override async Task Given()
{
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.Any, new[] { e });
}
await Client.CreateAsync(Stream, Group,
new PersistentSubscriptionSettings(startFrom : StreamPosition.Start, resolveLinkTos : true),
TestCredentials.Root);
_subscription = await Client.SubscribeAsync(Stream, Group,
(subscription, e, retryCount, ct) => {
if (Interlocked.Increment(ref _eventReceivedCount) == _events.Length)
{
_eventsReceived.TrySetResult(true);
}
return(Task.CompletedTask);
}, (s, r, e) => {
if (e != null)
{
_eventsReceived.TrySetException(e);
}
},
bufferSize : BufferCount,
userCredentials : TestCredentials.Root);
}
protected override async Task Given()
{
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync("test-" + Guid.NewGuid(), StreamState.Any, new[] { e });
}
await Client.CreateToAllAsync(Group,
new PersistentSubscriptionSettings(startFrom : Position.Start, resolveLinkTos : true),
TestCredentials.Root);
_subscription = await Client.SubscribeToAllAsync(Group,
async(subscription, e, retryCount, ct) => {
await subscription.Ack(e);
if (e.OriginalStreamId.StartsWith("test-") &&
Interlocked.Increment(ref _eventReceivedCount) == _events.Length)
{
_eventsReceived.TrySetResult(true);
}
}, (s, r, e) => {
if (e != null)
{
_eventsReceived.TrySetException(e);
}
},
autoAck : false,
bufferSize : BufferCount,
userCredentials : TestCredentials.Root);
}
/// <summary>
/// Initializes an instance of <see cref="StreamConverter"/>.
/// </summary>
public StreamConverter(StreamsClient client, string ffmpegFilePath)
{
Platform.EnsureDesktop();
_client = client;
_ffmpeg = new FFmpeg(ffmpegFilePath);
}
protected override async Task Given()
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.NoStream, Events);
await Client.CreateAsync(Stream, Group,
new PersistentSubscriptionSettings(startFrom : StreamPosition.Start), TestCredentials.Root);
_subscription = await Client.SubscribeAsync(Stream, Group,
async (subscription, e, r, ct) => {
if (r > 4)
{
_retryCountSource.TrySetResult(r.Value);
await subscription.Ack(e.Event.EventId);
}
else
{
await subscription.Nack(PersistentSubscriptionNakEventAction.Retry,
"Not yet tried enough times", e);
}
}, autoAck : false, subscriptionDropped : (subscription, reason, ex) => {
if (reason != SubscriptionDroppedReason.Disposed)
{
_retryCountSource.TrySetException(ex !);
}
}, userCredentials : TestCredentials.TestUser1);
}
protected override async Task Given()
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.NoStream, CreateTestEvents());
await Client.CreateAsync(Stream, Group, new PersistentSubscriptionSettings(),
TestCredentials.Root);
}
protected override async Task Given()
{
var lastEvent = await StreamsClient.ReadAllAsync(Direction.Backwards, Position.End, 1,
userCredentials : TestCredentials.Root).FirstAsync();
LastCommitPosition = lastEvent.OriginalPosition?.CommitPosition ?? throw new Exception();
}
protected override async Task Given()
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.NoStream, Events);
await Client.CreateAsync(Stream, Group,
new PersistentSubscriptionSettings(startFrom : StreamPosition.End), TestCredentials.Root);
}
protected override async Task OnServerUpAsync()
{
await StreamsClient.WarmUpAsync();
await UserManagementClient.CreateUserWithRetry(TestCredentials.TestUser1.Username !,
TestCredentials.TestUser1.Username !, Array.Empty <string>(), TestCredentials.TestUser1.Password !,
TestCredentials.Root);
}
protected override async Task Given()
{
await StreamsClient.AppendToStreamAsync(Guid.NewGuid().ToString(), StreamState.NoStream,
CreateTestEvents(256));
await StreamsClient.SetStreamMetadataAsync(SystemStreams.AllStream, StreamState.Any,
new StreamMetadata(acl : new StreamAcl(SystemRoles.All)), userCredentials : TestCredentials.Root);
}
protected override async Task When()
{
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync("filtered-out-stream-" + Guid.NewGuid(),
StreamState.Any, new[] { e });
}
}
protected override async Task Given()
{
var events = await StreamsClient.ReadAllAsync(Direction.Forwards, Position.Start, 10,
userCredentials : TestCredentials.Root).ToArrayAsync();
ExpectedEvent = events[events.Length / 2]; //just a random event in the middle of the results
await Client.CreateToAllAsync(Group,
new PersistentSubscriptionSettings(startFrom : ExpectedEvent.OriginalPosition), TestCredentials.Root);
}
protected override async Task When()
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.Any, CreateTestEvents());
await Client.CreateAsync(Stream, "existing",
new PersistentSubscriptionSettings(), TestCredentials.Root);
await Client.DeleteAsync(Stream, "existing",
TestCredentials.Root);
}
public override async Task DisposeAsync()
{
await UserManagementClient.DisposeAsync();
await StreamsClient.DisposeAsync();
await Client.DisposeAsync();
await base.DisposeAsync();
}
protected override async Task When()
{
await Client.CreateToAllAsync(Group,
new PersistentSubscriptionSettings(),
TestCredentials.Root);
var lastEvent = await StreamsClient.ReadAllAsync(Direction.Backwards, Position.End, 1,
userCredentials : TestCredentials.Root).FirstAsync();
LastCommitPosition = lastEvent.OriginalPosition?.CommitPosition ?? throw new Exception();
}
protected override async Task Given()
{
foreach (var @event in CreateTestEvents(10))
{
await StreamsClient.AppendToStreamAsync("non-system-stream-" + Guid.NewGuid(),
StreamState.Any, new[] { @event });
}
await Client.CreateToAllAsync(Group,
new PersistentSubscriptionSettings(startFrom : Position.End), TestCredentials.Root);
}
protected override async Task Given()
{
//append 10 events to random streams to make sure we have at least 10 events in the transaction file
foreach (var @event in CreateTestEvents(10))
{
await StreamsClient.AppendToStreamAsync(Guid.NewGuid().ToString(), StreamState.NoStream, new [] { @event });
}
Events = await StreamsClient.ReadAllAsync(Direction.Forwards, Position.Start, 10, userCredentials : TestCredentials.Root).ToArrayAsync();
await Client.CreateToAllAsync(Group,
new PersistentSubscriptionSettings(startFrom : Position.Start), TestCredentials.Root);
}
/// <summary>
/// Connect to a StreamsDB server.
/// </summary>
/// <param name="connectionString">The connection string that helps</param>
/// <returns></returns>
public static async Task <StreamsDBClient> Connect(string connectionString = null)
{
if (string.IsNullOrEmpty(connectionString))
{
connectionString = Environment.GetEnvironmentVariable("SDB_HOST");
}
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException(nameof(connectionString), "connection string not specified and SDB_HOST environment variable is empty");
}
if (!connectionString.StartsWith("sdb://"))
{
throw new ArgumentOutOfRangeException(nameof(connectionString), "invalid streamsdb connection string: not starting with 'sdb://'");
}
var uri = new Uri(connectionString);
var options = HttpUtility.ParseQueryString(uri.Query);
ChannelCredentials cred = new SslCredentials();
var value = options.Get("insecure");
if (value != null && value == "1")
{
cred = ChannelCredentials.Insecure;
}
var channel = new Channel(uri.Host, uri.Port, cred);
var apiClient = new StreamsClient(channel.Intercept(new ExceptionInterceptor()));
String defaultDb = null;
if (!string.IsNullOrEmpty(uri.AbsolutePath))
{
defaultDb = uri.AbsolutePath.Trim('/');
}
var sdbClient = new StreamsDBClient(channel, apiClient, defaultDb);
if (!string.IsNullOrEmpty(uri.UserInfo))
{
var items = uri.UserInfo.Split(new char[] { ':' });
var username = HttpUtility.UrlDecode(items[0]);
var password = HttpUtility.UrlDecode(items[1]);
await sdbClient.Login(username, password);
}
return(sdbClient);
}
/// <summary>Snippet for StreamCall</summary>
public async Task StreamCall()
{
// Snippet: StreamCall(CallSettings, BidirectionalStreamingSettings)
// Create client
StreamsClient streamsClient = StreamsClient.Create();
// Initialize streaming call, retrieving the stream object
StreamsClient.StreamCallStream response = streamsClient.StreamCall();
// Sending requests and retrieving responses can be arbitrarily interleaved
// Exact sequence will depend on client/server behavior
// Create task to do something with responses from server
Task responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <StreamCallResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamCallResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamCallRequest request = new StreamCallRequest
{
Setup = new StreamSetup(),
InputAudio = new InputAudio(),
UpdateRequestParameters = new UpdateRequestParameters(),
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
protected override async Task OnServerUpAsync()
{
await StreamsClient.WarmUpAsync();
await UserManagementClient.CreateUserWithRetry(TestCredentials.TestUser1.Username !,
TestCredentials.TestUser1.Username !, Array.Empty <string>(), TestCredentials.TestUser1.Password !,
TestCredentials.Root).WithTimeout();
await StandardProjections.Created(Client).WithTimeout(TimeSpan.FromMinutes(5));
if (RunStandardProjections)
{
await Task.WhenAll(StandardProjections.Names.Select(name =>
Client.EnableAsync(name, TestCredentials.Root)));
}
}
protected override async Task When()
{
// Force restart of the subscription
await Client.UpdateAsync(Stream, Group, new PersistentSubscriptionSettings(), TestCredentials.Root);
await _droppedSource.Task.WithTimeout();
_secondSubscription = await Client.SubscribeAsync(Stream, Group,
eventAppeared : (s, e, r, ct) => {
_resumedSource.TrySetResult(e);
return(Task.CompletedTask);
},
userCredentials : TestCredentials.Root);
await StreamsClient.AppendToStreamAsync(Stream, StreamState.Any, CreateTestEvents(1));
}
protected override async Task Given()
{
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync("test-" + Guid.NewGuid(), StreamState.Any, new[] { e });
}
await Client.CreateToAllAsync(Group,
StreamFilter.Prefix("test"),
new PersistentSubscriptionSettings(
minCheckPointCount : 5,
checkPointAfter : TimeSpan.FromSeconds(1),
startFrom : Position.Start),
TestCredentials.Root);
_checkPointSubscription = await StreamsClient.SubscribeToStreamAsync(_checkPointStream,
(s, e, ct) => {
if (_checkPoints.Count == 0)
{
_firstCheckPointSource.TrySetResult(e);
}
else
{
_secondCheckPointSource.TrySetResult(e);
}
_checkPoints.Add(e);
return(Task.CompletedTask);
},
userCredentials : TestCredentials.Root);
_subscription = await Client.SubscribeToAllAsync(Group,
eventAppeared : (s, e, r, ct) => {
_appearedEvents.Add(e);
if (_appearedEvents.Count == _events.Length)
{
_appeared.TrySetResult(true);
}
return(Task.CompletedTask);
},
userCredentials : TestCredentials.Root);
await Task.WhenAll(_appeared.Task, _firstCheckPointSource.Task).WithTimeout();
FirstCheckPoint = _firstCheckPointSource.Task.Result.Event.Data.ParsePosition();
}
protected override async Task Given()
{
using var call = StreamsClient.Append(GetCallOptions());
await call.RequestStream.WriteAsync(new() {
Options = new() { NoStream = new(), StreamIdentifier = _metadataStreamName }
});
await call.RequestStream.WriteAsync(new() {
ProposedMessage = new() {
Id = Uuid.NewUuid().ToDto(),
Metadata =
{
{ Metadata.Type, SystemEventTypes.StreamMetadata },
{ Metadata.ContentType, Metadata.ContentTypes.ApplicationJson }
},
Data = ByteString.CopyFromUtf8(StreamMetadata.Build().Build().AsJsonString())
}
protected override async Task Given()
{
await StreamsClient.AppendToStreamAsync(Stream, StreamState.NoStream, Events.Take(11));
await Client.CreateAsync(Stream, Group,
new PersistentSubscriptionSettings(startFrom : new StreamPosition(11)), TestCredentials.Root);
_subscription = await Client.SubscribeAsync(Stream, Group,
(subscription, e, r, ct) => {
_firstEventSource.TrySetResult(e);
return(Task.CompletedTask);
}, (subscription, reason, ex) => {
if (reason != SubscriptionDroppedReason.Disposed)
{
_firstEventSource.TrySetException(ex !);
}
}, TestCredentials.TestUser1);
}
protected override async Task When()
{
// Force restart of the subscription
await Client.UpdateToAllAsync(Group, new PersistentSubscriptionSettings(), TestCredentials.Root);
await _droppedSource.Task.WithTimeout();
_secondSubscription = await Client.SubscribeToAllAsync(Group,
eventAppeared : (s, e, r, ct) => {
_resumedSource.TrySetResult(e);
return(Task.CompletedTask);
},
userCredentials : TestCredentials.Root);
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync("test-" + Guid.NewGuid(), StreamState.Any, new[] { e });
}
}
protected override async Task Given()
{
foreach (var e in _events)
{
await StreamsClient.AppendToStreamAsync("test-" + Guid.NewGuid(), StreamState.Any, new[] { e });
}
await Client.CreateToAllAsync(Group,
new PersistentSubscriptionSettings(
minCheckPointCount : 5,
checkPointAfter : TimeSpan.FromSeconds(1),
startFrom : Position.Start),
TestCredentials.Root);
var checkPointStream = $"$persistentsubscription-$all::{Group}-checkpoint";
_checkPointSubscription = await StreamsClient.SubscribeToStreamAsync(checkPointStream,
(s, e, ct) => {
_checkPointSource.TrySetResult(e);
return(Task.CompletedTask);
},
userCredentials : TestCredentials.Root);
_firstSubscription = await Client.SubscribeToAllAsync(Group,
eventAppeared : (s, e, r, ct) => {
_appearedEvents.Add(e);
if (_appearedEvents.Count == _events.Length)
{
_appeared.TrySetResult(true);
}
return(Task.CompletedTask);
},
(subscription, reason, ex) => _droppedSource.TrySetResult((reason, ex)),
TestCredentials.Root);
await Task.WhenAll(_appeared.Task, _checkPointSource.Task).WithTimeout();
CheckPoint = _checkPointSource.Task.Result.Event.Data.ParsePosition();
}
protected override Task When() => StreamsClient.AppendToStreamAsync(Stream, new StreamRevision(10), Events.Skip(11));
