protected virtual Task <bool> OnMessageReceived(PersistentResponse response) { if (response == null) { throw new ArgumentNullException("response"); } response.Reconnect = HostShutdownToken.IsCancellationRequested; if (IsTimedOut || response.Aborted) { _busRegistration.Dispose(); if (response.Aborted) { // If this was a clean disconnect raise the event. return(Abort().Then(() => TaskAsyncHelper.False)); } } if (response.Terminal) { // End the request on the terminal response _transportLifetime.Complete(); return(TaskAsyncHelper.False); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(Send(response).Then(() => TaskAsyncHelper.True)); }
public void GroupTokenIsNotNullWhenGroupsChange() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { "a:1", "b:2", "c", "d" }); groupSet.DetectChanges(); groupSet.Add("g"); var serializer = JsonUtility.CreateDefaultSerializer(); string results = string.Empty; var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => { results = value; return value; }); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection"); Assert.NotNull(response.GroupsToken); var parts = response.GroupsToken.Split(new[] { ':' }, 2); Assert.Equal(2, parts.Length); Assert.Equal("myconnection", parts[0]); Assert.True(results.Contains("a:1")); Assert.True(results.Contains("b:2")); Assert.True(results.Contains("c")); Assert.True(results.Contains("d")); Assert.True(results.Contains("g")); }
private void AddTransportData(PersistentResponse response) { if (_pollDelay != TimeSpan.Zero) { response.LongPollDelay = (long)_pollDelay.TotalMilliseconds; } }
public void GroupTokenIsNotNullWhenGroupsChangeToEmpty() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { "b", "d" }); groupSet.DetectChanges(); groupSet.Remove("b"); groupSet.Remove("d"); var serializer = new Mock<IJsonSerializer>(); HashSet<string> results = null; serializer.Setup(m => m.Serialize(It.IsAny<object>(), It.IsAny<TextWriter>())) .Callback<object, TextWriter>((obj, tw) => { results = new HashSet<string>((IEnumerable<string>)obj); var jsonNet = new JsonNetSerializer(); jsonNet.Serialize(obj, tw); }); var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer.Object, protectedData.Object, connectionId: "myconnection"); Assert.NotNull(response.GroupsToken); var parts = response.GroupsToken.Split(new[] { ':' }, 2); Assert.Equal(2, parts.Length); Assert.Equal("myconnection", parts[0]); Assert.Equal(0, results.Count); }
public void GroupTokenIsNotNullWhenGroupsChange() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { "a", "b", "c", "d" }); groupSet.GetDiff(); groupSet.Add("g"); var serializer = new Mock<IJsonSerializer>(); HashSet<string> results = null; serializer.Setup(m => m.Serialize(It.IsAny<object>(), It.IsAny<TextWriter>())) .Callback<object, TextWriter>((obj, tw) => { results = new HashSet<string>((IEnumerable<string>)obj); var jsonNet = new JsonNetSerializer(); jsonNet.Serialize(obj, tw); }); var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer.Object, protectedData.Object); Assert.NotNull(response.GroupsToken); Assert.True(results.Contains("a")); Assert.True(results.Contains("b")); Assert.True(results.Contains("c")); Assert.True(results.Contains("d")); Assert.True(results.Contains("g")); }
private static void AddTransportData(PersistentResponse response) { if (LongPollDelay > 0) { response.LongPollDelay = LongPollDelay; } }
public Task Send(PersistentResponse response) { Heartbeat.MarkConnection(this); AddTransportData(response); return(Send((object)response)); }
protected virtual void OnSendingResponse(PersistentResponse response) { HeartBeat.MarkConnection(this); if (SendingResponse != null) { SendingResponse(response); } }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); var context = new ForeverFrameTransportContext(this, response); // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(EnqueueOperation(s => PerformSend(s), context)); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); var context = new SendContext(this, response); // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return EnqueueOperation(state => PerformSend(state), context); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); OutputWriter.Write("<script>r(c, "); JsonSerializer.Serialize(response, OutputWriter); OutputWriter.Write(");</script>\r\n"); OutputWriter.Flush(); return Context.Response.FlushAsync().Catch(IncrementErrorCounters); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); OutputWriter.Write("<script>r(c, "); JsonSerializer.Serialize(response, OutputWriter); OutputWriter.Write(");</script>\r\n"); OutputWriter.Flush(); return(Context.Response.FlushAsync().Catch(IncrementErrorCounters)); }
private void AddTransportData(PersistentResponse response) { if (LongPollDelay > 0) { if (response.TransportData == null) { response.TransportData = new Dictionary <string, object>(); } response.TransportData["LongPollDelay"] = LongPollDelay; } }
public override Task Send(PersistentResponse response) { Heartbeat.MarkConnection(this); AddTransportData(response); // This overload is only used in response to /connect, /poll and /reconnect requests, // so the response will have already been initialized by ProcessMessages. var context = new LongPollingTransportContext(this, response); return(EnqueueOperation(state => PerformPartialSend(state), context)); }
public virtual Task Send(PersistentResponse response) { Heartbeat.MarkConnection(this); if (SendingResponse != null) { SendingResponse(response); } AddTransportData(response); return(Send((object)response)); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); return(EnqueueOperation(() => { HTMLOutputWriter.WriteRaw("<script>r(c, "); JsonSerializer.Serialize(response, HTMLOutputWriter); HTMLOutputWriter.WriteRaw(");</script>\r\n"); HTMLOutputWriter.Flush(); return Context.Response.FlushAsync(); })); }
protected override Task <bool> OnMessageReceived(PersistentResponse response) { if (response == null) { throw new ArgumentNullException("response"); } response.Reconnect = HostShutdownToken.IsCancellationRequested; Task task = TaskAsyncHelper.Empty; if (response.Aborted) { // If this was a clean disconnect then raise the event task = Abort(); } if (response.Terminal) { // If the response wasn't sent, send it before ending the request if (!_responseSent) { // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(task.Then((transport, resp) => transport.Send(resp), this, response) .Then(() => { _transportLifetime.Complete(); return TaskAsyncHelper.False; })); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(task.Then(() => { _transportLifetime.Complete(); return TaskAsyncHelper.False; })); } // Mark the response as sent _responseSent = true; // Send the response and return false // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(task.Then((transport, resp) => transport.Send(resp), this, response) .Then(() => TaskAsyncHelper.False)); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); return(EnqueueOperation(() => { OutputWriter.Write("data: "); JsonSerializer.Serialize(response, OutputWriter); OutputWriter.WriteLine(); OutputWriter.WriteLine(); OutputWriter.Flush(); return Context.Response.FlushAsync().Catch(IncrementErrorCounters); })); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); OutputWriter.Write("id: "); OutputWriter.Write(response.MessageId); OutputWriter.WriteLine(); OutputWriter.Write("data: "); JsonSerializer.Serialize(response, OutputWriter); OutputWriter.WriteLine(); OutputWriter.WriteLine(); OutputWriter.Flush(); return Context.Response.FlushAsync().Catch(IncrementErrorCounters); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); OutputWriter.Write("id: "); OutputWriter.Write(response.MessageId); OutputWriter.WriteLine(); OutputWriter.Write("data: "); JsonSerializer.Serialize(response, OutputWriter); OutputWriter.WriteLine(); OutputWriter.WriteLine(); OutputWriter.Flush(); return(Context.Response.FlushAsync().Catch(IncrementErrorCounters)); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); return EnqueueOperation(() => { OutputWriter.Write("data: "); JsonSerializer.Serialize(response, OutputWriter); OutputWriter.WriteLine(); OutputWriter.WriteLine(); OutputWriter.Flush(); return Context.Response.Flush(); }); }
public void WriteJsonSkipsNullTransportDaa() { // Arrange var writer = new StringWriter(); var response = new PersistentResponse(m => m.Key == "key2"); response.Messages = new List<ArraySegment<Message>>(); response.MessageId = "Baz"; response.Messages.Add(new ArraySegment<Message>(new[] { new Message("1", "key", "value1"), new Message("1", "key2", "value2") }, 0, 2)); // Act ((IJsonWritable)response).WriteJson(writer); // Assert Assert.Equal(@"{""C"":""Baz"",""M"":[value1]}", writer.ToString()); }
public void GroupTokenIsNullWhenNoGroups() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { }); var serializer = JsonUtility.CreateDefaultSerializer(); var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: null); Assert.Null(response.GroupsToken); }
public void WriteJsonWritesSkipsCommands() { // Arrange var writer = new StringWriter(); var response = new PersistentResponse(m => false); response.Messages = new List<ArraySegment<Message>>(); response.MessageId = "Baz"; response.Messages.Add(new ArraySegment<Message>(new[] { new Message("1", "key", "value1") { CommandId = "something"}, new Message("1", "key2", "value2") }, 0, 2)); // Act ((IJsonWritable)response).WriteJson(writer); // Assert Assert.Equal(@"{""C"":""Baz"",""M"":[value2]}", writer.ToString()); }
private static Task <bool> OnMessageReceived(PersistentResponse response, object state) { var context = (MessageContext)state; response.TimedOut = context.Transport.IsTimedOut; Task task = TaskAsyncHelper.Empty; if (response.Aborted) { // If this was a clean disconnect then raise the event task = context.Transport.Abort(); } if (response.Terminal) { // If the response wasn't sent, send it before ending the request if (!context.ResponseSent) { // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(task.Then((ctx, resp) => ctx.Transport.Send(resp), context, response) .Then(() => { context.Lifetime.Complete(); return TaskAsyncHelper.False; })); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(task.Then(() => { context.Lifetime.Complete(); return TaskAsyncHelper.False; })); } // Mark the response as sent context.ResponseSent = true; // Send the response and return false // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(task.Then((ctx, resp) => ctx.Transport.Send(resp), context, response) .Then(() => TaskAsyncHelper.False)); }
public void WriteJsonWritesMessagesThatAreNotExcluded() { // Arrange var writer = new StringWriter(); var response = new PersistentResponse(m => m.Key == "key2"); response.Messages = new List<ArraySegment<Message>>(); response.AddedGroups = new List<string> { "g1" }; response.MessageId = "Baz"; response.Messages.Add(new ArraySegment<Message>(new[] { new Message("1", "key", "value1"), new Message("1", "key2", "value2") }, 0, 2)); // Act ((IJsonWritable)response).WriteJson(writer); // Assert Assert.Equal(@"{""C"":""Baz"",""G"":[""g1""],""M"":[value1]}", writer.ToString()); }
public void GroupTokenIsNullWhenNoNewGroups() { var response = new PersistentResponse(); var groupSet = new DiffSet<string>(new string[] { "a", "b", "c" }); // Get the first diff groupSet.GetDiff(); var serializer = new JsonNetSerializer(); var protectedData = new Mock<IProtectedData>(); protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>())) .Returns<string, string>((value, purpose) => value); Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object); Assert.Null(response.GroupsToken); }
private static Task <bool> OnMessageReceived(PersistentResponse response, object state) { var context = (MessageContext)state; response.Reconnect = context.Transport.HostShutdownToken.IsCancellationRequested; // If we're telling the client to disconnect then clean up the instantiated connection. if (response.Disconnect) { // Send the response before removing any connection data return(context.Transport.Send(response).Then(c => OnDisconnectMessage(c), context) .Then(() => TaskAsyncHelper.False)); } else if (context.Transport.IsTimedOut || response.Aborted) { context.Registration.Dispose(); if (response.Aborted) { // If this was a clean disconnect raise the event. return(context.Transport.Abort() .Then(() => TaskAsyncHelper.False)); } } if (response.Terminal) { // End the request on the terminal response context.Lifetime.Complete(); return(TaskAsyncHelper.False); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return(context.Transport.Send(response) .Then(() => TaskAsyncHelper.True)); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); return(Send((object)response)); }
public override Task Send(PersistentResponse response) { return(Send((object)response)); }
private PersistentResponse GetResponse(MessageResult result) { // Do a single sweep through the results to process commands and extract values ProcessResults(result); Debug.Assert(GetCursor != null, "Unable to resolve the cursor since the method is null"); // Resolve the cursor string id = GetCursor(); var response = new PersistentResponse(ExcludeMessage) { MessageId = id, Messages = result.Messages, Disconnect = _disconnected, Aborted = _aborted, TotalCount = result.TotalCount, }; PopulateResponseState(response); _counters.ConnectionMessagesReceivedTotal.IncrementBy(result.TotalCount); _counters.ConnectionMessagesReceivedPerSec.IncrementBy(result.TotalCount); return response; }
public Task Send(PersistentResponse response) { Heartbeat.MarkConnection(this); AddTransportData(response); return Send((object)response); }
private static void AddTransportData(PersistentResponse response) { if (LongPollDelay > 0) { response.LongPollDelay = LongPollDelay; } }
internal static void PopulateResponseState(PersistentResponse response, DiffSet<string> groupSet, IJsonSerializer serializer, IProtectedData protectedData, string connectionId) { bool anyChanges = groupSet.DetectChanges(); if (anyChanges) { // Create a protected payload of the sorted list IEnumerable<string> groups = groupSet.GetSnapshot(); // Remove group prefixes before any thing goes over the wire string groupsString = connectionId + ':' + serializer.Stringify(PrefixHelper.RemoveGroupPrefixes(groups)); ; // The groups token response.GroupsToken = protectedData.Protect(groupsString, Purposes.Groups); } }
private static void AssertEscaped(ForeverFrameTransport fft, MemoryStream ms, PersistentResponse input, string expectedOutput) { fft.Send(input).Wait(); string rawResponse = Encoding.UTF8.GetString(ms.ToArray()); // Doing contains due to all the stuff that gets sent through the buffer Assert.True(rawResponse.Contains(expectedOutput)); }
protected override Task<bool> OnMessageReceived(PersistentResponse response) { if (response == null) { throw new ArgumentNullException("response"); } response.Reconnect = HostShutdownToken.IsCancellationRequested; Task task = TaskAsyncHelper.Empty; if (response.Aborted) { // If this was a clean disconnect then raise the event task = Abort(); } if (response.Terminal) { // If the response wasn't sent, send it before ending the request if (!_responseSent) { // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return task.Then((transport, resp) => transport.Send(resp), this, response) .Then(() => { _transportLifetime.Complete(); return TaskAsyncHelper.False; }); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return task.Then(() => { _transportLifetime.Complete(); return TaskAsyncHelper.False; }); } // Mark the response as sent _responseSent = true; // Send the response and return false // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return task.Then((transport, resp) => transport.Send(resp), this, response) .Then(() => TaskAsyncHelper.False); }
protected virtual void OnSendingResponse(PersistentResponse response) { Heartbeat.MarkConnection(this); }
private static Task<bool> OnMessageReceived(PersistentResponse response, object state) { var context = (MessageContext)state; response.Reconnect = context.Transport.HostShutdownToken.IsCancellationRequested; // If we're telling the client to disconnect then clean up the instantiated connection. if (response.Disconnect) { // Send the response before removing any connection data return context.Transport.Send(response).Then(c => OnDisconnectMessage(c), context) .Then(() => TaskAsyncHelper.False); } else if (context.Transport.IsTimedOut || response.Aborted) { context.Registration.Dispose(); if (response.Aborted) { // If this was a clean disconnect raise the event. return context.Transport.Abort() .Then(() => TaskAsyncHelper.False); } } if (response.Terminal) { // End the request on the terminal response context.Lifetime.Complete(); return TaskAsyncHelper.False; } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return context.Transport.Send(response) .Then(() => TaskAsyncHelper.True); }
public virtual Task Send(PersistentResponse response) { Heartbeat.MarkConnection(this); if (SendingResponse != null) { SendingResponse(response); } AddTransportData(response); return Send((object)response); }
protected virtual void OnSendingResponse(PersistentResponse response) { Heartbeat.MarkConnection(this); }
private PersistentResponse GetResponse(MessageResult result) { // Do a single sweep through the results to process commands and extract values ProcessResults(result); Debug.Assert(WriteCursor != null, "Unable to resolve the cursor since the method is null"); var response = new PersistentResponse(ExcludeMessage, WriteCursor); response.Terminal = result.Terminal; if (!result.Terminal) { // Only set these properties if the message isn't terminal response.Messages = result.Messages; response.Disconnect = _disconnected; response.Aborted = _aborted; response.TotalCount = result.TotalCount; } PopulateResponseState(response); _counters.ConnectionMessagesReceivedTotal.IncrementBy(result.TotalCount); _counters.ConnectionMessagesReceivedPerSec.IncrementBy(result.TotalCount); return response; }
private void PopulateResponseState(PersistentResponse response) { PopulateResponseState(response, _groups, _serializer, _protectedData, _connectionId); }
public override Task Send(PersistentResponse response) { OnSendingResponse(response); return Send((object)response); }
private static PersistentResponse GetWrappedResponse(string raw) { var data = Encoding.Default.GetBytes(raw); var message = new Message("foo", "key", new ArraySegment<byte>(data)); var response = new PersistentResponse { Messages = new List<ArraySegment<Message>> { new ArraySegment<Message>(new Message[] { message }) } }; return response; }
public override Task Send(PersistentResponse response) { Heartbeat.MarkConnection(this); AddTransportData(response); // This overload is only used in response to /connect, /poll and /reconnect requests, // so the response will have already been initialized by ProcessMessages. var context = new LongPollingTransportContext(this, response); return EnqueueOperation(state => PerformPartialSend(state), context); }
private static Task<bool> OnMessageReceived(PersistentResponse response, object state) { var context = (MessageContext)state; response.Reconnect = context.Transport.HostShutdownToken.IsCancellationRequested; Task task = TaskAsyncHelper.Empty; if (response.Aborted) { // If this was a clean disconnect then raise the event task = context.Transport.Abort(); } if (response.Terminal) { // If the response wasn't sent, send it before ending the request if (!context.ResponseSent) { // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return task.Then((ctx, resp) => ctx.Transport.Send(resp), context, response) .Then(() => { context.Lifetime.Complete(); return TaskAsyncHelper.False; }); } // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return task.Then(() => { context.Lifetime.Complete(); return TaskAsyncHelper.False; }); } // Mark the response as sent context.ResponseSent = true; // Send the response and return false // Ensure delegate continues to use the C# Compiler static delegate caching optimization. return task.Then((ctx, resp) => ctx.Transport.Send(resp), context, response) .Then(() => TaskAsyncHelper.False); }
private void AddTransportData(PersistentResponse response) { if (_pollDelay != TimeSpan.Zero) { response.LongPollDelay = (long)_pollDelay.TotalMilliseconds; } }
public abstract Task Send(PersistentResponse response);
protected virtual void OnSendingResponse(PersistentResponse response) { HeartBeat.MarkConnection(this); if (SendingResponse != null) { SendingResponse(response); } }
public abstract Task Send(PersistentResponse response);