/// <summary> /// Initializes new instance of data. /// </summary> /// <param name="client">The client who has connected.</param> /// <param name="httpRequest">The httpRequest of the request which initiated this event.</param> /// <param name="lastEventId">The identifier of last event which client has received.</param> public ServerSentEventsClientConnectedArgs(IServerSentEventsClient client, HttpRequest httpRequest, string lastEventId = null) : this() { Client = client; HttpRequest = httpRequest; LastEventId = lastEventId; }
/// <summary> /// Initializes new instance of data. /// </summary> /// <param name="request">The request which has been made in order to establish the connection.</param> /// <param name="client">The client who has connected.</param> /// <param name="lastEventId">The identifier of last event which client has received.</param> public ServerSentEventsClientConnectedArgs(HttpRequest request, IServerSentEventsClient client, string lastEventId) : this() { Request = request; Client = client; LastEventId = lastEventId; }
/// <summary> /// Initializes new instance of data. /// </summary> /// <param name="request">The request which has been made in order to establish the connection.</param> /// <param name="client">The client who has connected.</param> public ServerSentEventsClientConnectedArgs(HttpRequest request, IServerSentEventsClient client) : this() { Request = request; Client = client; LastEventId = null; }
/// <summary> /// When overriden in delivered class allows for recovery when client has reestablished the connection. /// </summary> /// <param name="client">The client who has reestablished the connection.</param> /// <param name="lastEventId">The identifier of last event which client has received.</param> /// <returns>The task object representing the asynchronous operation.</returns> public virtual Task OnReconnectAsync(IServerSentEventsClient client, string lastEventId) { if (_logger != null && _logger.IsEnabled(LogLevel.Trace)) { _logger.LogTrace(Constants.c_eventServiceTraceId, Constants.m_initiateSSEReconnect); } return(System.Threading.TaskHelper.GetCompletedTask()); }
internal void RemoveClient(ServerSentEventsClient client) { // If the client has a userId, check if the same client is stored in _userClients for the same userId, remove if match found if (client.UserId.HasValue) { IServerSentEventsClient userClient = GetUserClient(client.UserId.Value); if (userClient != null && userClient.Id.Equals(client.Id)) { _userClients.TryRemove(client.UserId.Value, out userClient); } } client.IsConnected = false; _clients.TryRemove(client.Id, out client); }
public async Task Start_WhenEventStreamClientStartedSuccessfully_ReturnsSelf() { var stream = new MemoryStream(); m_mockedEventStreamClient.Setup(c => c.StartAsync()).ReturnsAsync(stream); m_mockedEventStreamProcessor.Setup(p => p.ProcessAsync(stream, It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask); m_mockedEventStreamProcessor.SetupSet(p => p.OnMessage = It.IsAny <Action <ServerSentEventsMessage> >()); IServerSentEventsClient result = await m_sut.Start(); Assert.That(result, Is.EqualTo(m_sut)); m_mockRepository.VerifyAll(); }
public void SetUp() { m_mockRepository = new MockRepository(MockBehavior.Strict); m_mockedEventStreamClient = m_mockRepository.Create <IEventStreamClient>(); m_mockedEventStreamProcessor = m_mockRepository.Create <IEventStreamProcessor>(); m_mockedLoggerFactory = new Mock <ILoggerFactory>(); m_mockedLoggerFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(Mock.Of <ILogger>()); m_sut = new ServerSentEventsClient( m_mockedEventStreamClient.Object, m_mockedEventStreamProcessor.Object, m_mockedLoggerFactory.Object ); }
public override Task OnConnectAsync(HttpRequest request, IServerSentEventsClient client) { IList <Claim> claimCollection = new List <Claim> { new Claim(ClaimTypes.Name, "Andras") , new Claim(ClaimTypes.Country, "Sweden") , new Claim(ClaimTypes.Gender, "M") , new Claim(ClaimTypes.Surname, "Nemes") , new Claim(ClaimTypes.Email, "*****@*****.**") , new Claim(ClaimTypes.Role, "IT") }; ClaimsIdentity claimsIdentity = new ClaimsIdentity(claimCollection); client.User.AddIdentity(claimsIdentity); return(base.OnConnectAsync(request, client)); }
private async Task pushDockerBuildStream(IServerSentEventsClient client, Stream buildOutput) { using (var reader = new StreamReader(buildOutput)) { while (!reader.EndOfStream) { var result = await reader.ReadLineAsync(); if (result.Contains("Success")) { } await client.SendEventAsync(new ServerSentEvent() { Type = "BuildOutput", Data = new string[] { result } }); } } }
/// <summary> /// Adds a new IServerSentEventsClient to the list of connected clients /// </summary> /// <param name="client">IServerSentEventsClient implementation representing the client.</param> /// <returns>Guid that can be used to track the client.</returns> Guid IServerSentEventsService.AddClient(IServerSentEventsClient client) { Guid clientId = Guid.NewGuid(); if (_clients.TryAdd(clientId, client)) { if (_clients.Count > 0 && UseHeartbeat && (_heartbeat == null || _heartbeat.IsCanceled || _heartbeat.IsCompleted)) { this._hearbeatCancellation = new CancellationTokenSource(); this._hearbeatCancellation.Token.Register(this.OnHeartbeatCancellation); this._heartbeat = Heartbeat(this._hearbeatCancellation.Token); } } if (_logger != null && _logger.IsEnabled(LogLevel.Trace)) { _logger.LogTrace(Constants.c_eventServiceTraceId, Constants.m_registerSSEClient, clientId, _clients.Count); } return(clientId); }
async Task <IServerSentEventsClient> IServerSentEventsClient.Start() { IServerSentEventsClient @this = this; m_eventStreamProcessor.OnMessage = message => { @this.OnMessage?.Invoke(message); if (m_eventListeners.TryGetValue(message.Event, out var handlers)) { foreach (var handler in handlers) { handler.Invoke(message); } } }; using (m_logger.BeginScope("Stratring SSE client")) { m_logger.LogInformation("Configuring HttpClient"); @this.Configure?.Invoke(m_eventStreamClient.HttpClient); m_logger.LogInformation("Connecting..."); Stream stream; try { stream = await m_eventStreamClient.StartAsync().ConfigureAwait(false); } catch (Exception e) { m_logger.LogError(0, e, "Failed to connect"); throw; } m_cts = new CancellationTokenSource(); #pragma warning disable 4014 // Fire & forget m_eventStreamProcessor.ProcessAsync(stream, m_cts.Token); #pragma warning restore 4014 m_logger.LogInformation("Processing SSE stream has started"); } return(this); }
/// <summary> /// Adds a client to the specified group. /// </summary> /// <param name="groupName">The group name.</param> /// /// <param name="client">The client to add to a group.</param> /// <returns>The task object representing the result of asynchronous operation</returns> public async Task <ServerSentEventsAddToGroupResult> AddToGroupAsync(string groupName, IServerSentEventsClient client) { ServerSentEventsAddToGroupResult result = ServerSentEventsAddToGroupResult.AddedToExistingGroup; if (!_groups.ContainsKey(groupName)) { await CreateGroupAsync(groupName); result = ServerSentEventsAddToGroupResult.AddedToNewGroup; } _groups[groupName].TryAdd(client.Id, client); return(result); }
/// <summary> /// Method which is called when client is disconnecting. The base implementation raises the <see cref="ClientDisconnected"/> event. /// </summary> /// <param name="client">The client who is disconnecting.</param> /// <returns>The task object representing the asynchronous operation.</returns> public virtual Task OnDisconnectAsync(IServerSentEventsClient client) { ClientDisconnected?.Invoke(this, new ServerSentEventsClientDisconnectedArgs(client)); return(TaskHelper.GetCompletedTask()); }
/// <summary> /// Method which is called when client is reestablishing the connection. The base implementation raises the <see cref="ClientConnected"/> event. /// </summary> /// <param name="client">The client who is reestablishing the connection.</param> /// <param name="httpRequest">The httpRequest of the request which initiated this event.</param> /// <param name="lastEventId">The identifier of last event which client has received.</param> /// <returns>The task object representing the asynchronous operation.</returns> public virtual Task OnReconnectAsync(IServerSentEventsClient client, HttpRequest httpRequest, string lastEventId) { ClientConnected?.Invoke(this, new ServerSentEventsClientConnectedArgs(client, httpRequest, lastEventId)); return(TaskHelper.GetCompletedTask()); }
public override Task OnDisconnectAsync(HttpRequest request, IServerSentEventsClient client) { return(base.OnDisconnectAsync(request, client)); }
/// <summary> /// Initializes new instance of data. /// </summary> /// <param name="request">The original request which has been made in order to establish the connection.</param> /// <param name="client">The client who has disconnected.</param> public ServerSentEventsClientDisconnectedArgs(HttpRequest request, IServerSentEventsClient client) : this() { Request = request; Client = client; }
/// <summary> /// Initializes new instance of data. /// </summary> /// <param name="client">The client who has disconnected.</param> public ServerSentEventsClientDisconnectedArgs(IServerSentEventsClient client) : this() { Client = client; }
/// <summary> /// When overriden in delivered class allows for recovery when client has reestablished the connection. /// </summary> /// <param name="client">The client who has reestablished the connection.</param> /// <param name="lastEventId">The identifier of last event which client has received.</param> /// <returns>The task object representing the asynchronous operation.</returns> public virtual Task OnReconnectAsync(IServerSentEventsClient client, string lastEventId) { return(TaskHelper.GetCompletedTask()); }
/// <summary> /// Method which is called when client is reestablishing the connection. The base implementation raises the <see cref="ClientConnected"/> event. /// </summary> /// <param name="request">The request which has been made in order to establish the connection.</param> /// <param name="client">The client who is reestablishing the connection.</param> /// <param name="lastEventId">The identifier of last event which client has received.</param> /// <returns>The task object representing the asynchronous operation.</returns> public virtual Task OnReconnectAsync(HttpRequest request, IServerSentEventsClient client, string lastEventId) { ClientConnected?.Invoke(this, new ServerSentEventsClientConnectedArgs(request, client, lastEventId)); return(Task.CompletedTask); }
/// <summary> /// Method which is called when client is disconnecting. The base implementation raises the <see cref="ClientDisconnected"/> event. /// </summary> /// <param name="request">The original request which has been made in order to establish the connection.</param> /// <param name="client">The client who is disconnecting.</param> /// <returns>The task object representing the asynchronous operation.</returns> public virtual Task OnDisconnectAsync(HttpRequest request, IServerSentEventsClient client) { ClientDisconnected?.Invoke(this, new ServerSentEventsClientDisconnectedArgs(request, client)); return(Task.CompletedTask); }
void IServerSentEventsClient.Stop() { IServerSentEventsClient @this = this; @this.Dispose(); }