internal RawServerSentEvent(ServerSentEvent serverSentEvent)
: this()
{
if (!String.IsNullOrWhiteSpace(serverSentEvent.Id))
{
Id = Encoding.UTF8.GetBytes(serverSentEvent.Id);
}
if (!String.IsNullOrWhiteSpace(serverSentEvent.Type))
{
Type = Encoding.UTF8.GetBytes(serverSentEvent.Type);
}
if (serverSentEvent.Data != null)
{
List <byte[]> data = new List <byte[]>(serverSentEvent.Data.Count);
foreach (string dataItem in serverSentEvent.Data)
{
if (dataItem != null)
{
data.Add(Encoding.UTF8.GetBytes(dataItem));
}
}
Data = data;
}
}
private static int GetEventMaxBytesCount(ServerSentEvent serverSentEvent)
{
int bytesCount = CRLF_LENGTH;
if (!String.IsNullOrWhiteSpace(serverSentEvent.Id))
{
bytesCount += GetFieldMaxBytesCount(_sseIdField, serverSentEvent.Id);
}
if (!String.IsNullOrWhiteSpace(serverSentEvent.Type))
{
bytesCount += GetFieldMaxBytesCount(_sseEventField, serverSentEvent.Type);
}
if (serverSentEvent.Data != null)
{
for (int dataItemIndex = 0; dataItemIndex < serverSentEvent.Data.Count; dataItemIndex++)
{
if (serverSentEvent.Data[dataItemIndex] != null)
{
bytesCount += GetFieldMaxBytesCount(_sseDataField, serverSentEvent.Data[dataItemIndex]);
}
}
}
return(bytesCount);
}
private void HandleSSEMessage(EventSource eventSource, Message m)
{
Debug.Log("Received message " + m);
MessageRepresentation message = JsonUtility.FromJson <MessageRepresentation>(m.Data);
ServerSentEvent?.Invoke(this, message);
}
internal static ServerSentEventBytes GetEventBytes(ServerSentEvent serverSentEvent)
{
int bytesCount = 0;
byte[] bytes = new byte[GetEventMaxBytesCount(serverSentEvent)];
if (!String.IsNullOrWhiteSpace(serverSentEvent.Id))
{
bytesCount = GetFieldBytes(_sseIdField, serverSentEvent.Id, bytes, bytesCount);
}
if (!String.IsNullOrWhiteSpace(serverSentEvent.Type))
{
bytesCount = GetFieldBytes(_sseEventField, serverSentEvent.Type, bytes, bytesCount);
}
if (serverSentEvent.Data != null)
{
for (int dataItemIndex = 0; dataItemIndex < serverSentEvent.Data.Count; dataItemIndex++)
{
if (serverSentEvent.Data[dataItemIndex] != null)
{
bytesCount = GetFieldBytes(_sseDataField, serverSentEvent.Data[dataItemIndex], bytes, bytesCount);
}
}
}
bytes[bytesCount++] = CR;
bytes[bytesCount++] = LF;
return(new ServerSentEventBytes(bytes, bytesCount));
}
protected override void Append(LoggingEvent loggingEvent)
{
var message = base.RenderLoggingEvent(loggingEvent);
var sse = new ServerSentEvent(loggingEvent.Level.DisplayName, message);
_channel.Send(sse, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token);
}
public Task SendEventAsync(ServerSentEvent serverSentEvent, string electronId)
{
if (_clients.TryGetValue(electronId, out var client))
{
return(client.SendEventAsync(serverSentEvent));
}
return(Task.FromResult(false));
}
protected override void Write(LogEventInfo logEvent)
{
if (Active)
{
var message = base.Layout.Render(logEvent);
var sse = new ServerSentEvent(logEvent.Level.Name.ToUpperInvariant(), message);
_channel.Send(sse, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token);
}
}
/// <summary>
/// Sends event to client.
/// </summary>
/// <param name="serverSentEvent">The event.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task <bool> SendEventAsync(ServerSentEvent serverSentEvent, CancellationToken cancellationToken)
{
bool success = await SendAsync(ServerSentEventsHelper.GetEventBytes(serverSentEvent), cancellationToken);
if (success)
{
LastEventId = serverSentEvent.Id;
}
return(success);
}
public IEnumerator PlayCard(int gameId, int turnCounter, int cardId, int targetPlayer, Action callback, Action errorHandler)
{
yield return(MakeRequest(UnityWebRequest.Put(Configuration.API_URL + HttpResources.DELIMITER + HttpResources.GAMES + HttpResources.DELIMITER + gameId + HttpResources.DELIMITER + HttpResources.TURNS + HttpResources.DELIMITER + turnCounter + HttpResources.DELIMITER + HttpResources.CARDS, JsonUtility.ToJson(new CardRequest(cardId, targetPlayer))),
"POST",
null,
callback,
response =>
{
errorHandler?.Invoke();
ServerSentEvent?.Invoke(this, new MessageRepresentation(response));
}));
}
// PUT: api/Subscriptions/5
public void Put(string id)
{
ServerSentEvent subscription = null;
lock (_subscriptions)
{
_subscriptions.TryGetValue(id, out subscription);
}
if (subscription != null)
{
subscription.Send("Event!");
}
}
// GET: api/Subscriptions/5
public HttpResponseMessage Get(string id)
{
lock (_subscriptions)
{
ServerSentEvent subscription;
if (!_subscriptions.TryGetValue(id, out subscription))
{
subscription = new ServerSentEvent(5);
_subscriptions[id] = subscription;
}
try
{
return(subscription.AddSubscriber(base.Request));
}
catch (Exception ex)
{
throw ex;
}
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
ServerSentEvent serverSentEvent = new ServerSentEvent()
{
Id = "xxx",
Type = "heartbeat",
Data = new List <string>()
{
String.Format(HEARTBEAT_MESSAGE_FORMAT, DateTime.UtcNow)
}
};
//await _serverSentEventsService.SendEventAsync(String.Format(HEARTBEAT_MESSAGE_FORMAT, DateTime.UtcNow));
string toSend = JsonConvert.SerializeObject(serverSentEvent);
await _serverSentEventsService.SendEventAsync(toSend);
await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
}
}
/// <summary>
/// Sends an server sent data event into the stream
/// </summary>
/// <param name="serverSentEvent">ServerSentEvent object representing the payload.</param>
/// <param name="response">HttpRepsonse representing the response stream.</param>
/// <returns>Task to be used to sync execution flow.</returns>
internal static async Task WriteSseEventAsync(this HttpResponse response, ServerSentEvent serverSentEvent)
{
if (!String.IsNullOrWhiteSpace(serverSentEvent.Id))
{
await response.WriteSseEventFieldAsync(Constants.SSE_ID_FIELD, serverSentEvent.Id);
}
if (!String.IsNullOrWhiteSpace(serverSentEvent.Type))
{
await response.WriteSseEventFieldAsync(Constants.SSE_EVENT_FIELD, serverSentEvent.Type);
}
if (serverSentEvent.Data != null)
{
foreach (string data in serverSentEvent.Data)
{
await response.WriteSseEventFieldAsync(Constants.SSE_DATA_FIELD, data);
}
}
await response.WriteSseEventBoundaryAsync();
await response.Body.FlushAsync();
}
internal static async Task WriteSseEventAsync(this HttpResponse response, ServerSentEvent serverSentEvent)
{
if (!string.IsNullOrWhiteSpace(serverSentEvent.Id))
{
await response.WriteSseEventFieldAsync("id", serverSentEvent.Id);
}
if (!string.IsNullOrWhiteSpace(serverSentEvent.Type))
{
await response.WriteSseEventFieldAsync("event", serverSentEvent.Type);
}
if (serverSentEvent.Data != null)
{
foreach (string data in serverSentEvent.Data)
{
await response.WriteSseEventFieldAsync("data", data);
}
}
await response.WriteSseEventBoundaryAsync();
response.Body.Flush();
}
/// <summary>
/// Sends event to client.
/// </summary>
/// <param name="serverSentEvent">The event.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task SendEventAsync(ServerSentEvent serverSentEvent)
{
return(SendEventAsync(new RawServerSentEvent(serverSentEvent)));
}
public ServerSentEventReceivedEventArgs(ServerSentEvent message)
{
this.Message = message;
}
/// <summary>
/// Sends event to client.
/// </summary>
/// <param name="serverSentEvent">The event.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task SendEventAsync(ServerSentEvent serverSentEvent, CancellationToken cancellationToken)
{
return(SendAsync(ServerSentEventsHelper.GetEventBytes(serverSentEvent), cancellationToken));
}
/// <summary>
/// Sends event to client.
/// </summary>
/// <param name="serverSentEvent">The event.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task SendEventAsync(ServerSentEvent serverSentEvent)
{
return(SendAsync(ServerSentEventsHelper.GetEventBytes(serverSentEvent)));
}
