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