public void FailMessageWaitingForAckAndClearOutgoingQueue(RealtimeChannel channel, ErrorInfo error)
{
error = error ?? new ErrorInfo($"Channel cannot publish messages whilst state is {channel.State}", 50000);
AckProcessor.FailChannelMessages(channel.Name, error);
//TODO: Clear messages from the outgoing queue
}
public void SendPendingMessages(bool resumed)
{
if (resumed)
{
//Resend any messages waiting an Ack Queue
foreach (var message in AckProcessor.GetQueuedMessages())
{
SendToTransport(message);
}
}
lock (_pendingQueueLock)
{
if (Logger.IsDebug)
{
Logger.Debug("Sending pending message: Count: " + PendingMessages.Count);
}
while (PendingMessages.Count > 0)
{
var queuedMessage = PendingMessages.Dequeue();
SendMessage(queuedMessage.Message, queuedMessage.Callback);
}
}
}
private async Task ProcessTransportMessage(ProtocolMessage message)
{
try
{
var handled = await State.OnMessageReceived(message);
handled |= AckProcessor.OnMessageReceived(message);
handled |= ConnectionHeartbeatRequest.CanHandleMessage(message);
Connection.UpdateSerial(message);
MessageReceived?.Invoke(message);
}
catch (Exception e)
{
Logger.Error("Error processing message: " + message, e);
throw new AblyException(e);
}
}
public void NullNamespace2Elements()
{
var processor = new AckProcessor();
int packetId = 0;
List <JsonElement> array = new();
processor.Process(new MessageContext
{
Message = "1[\"hi\",\"onAny\"]",
AckHandler = (id, arr) =>
{
packetId = id;
array = arr;
}
});
Assert.AreEqual(1, packetId);
Assert.AreEqual(2, array.Count);
Assert.AreEqual("hi", array[0].GetString());
Assert.AreEqual("onAny", array[1].GetString());
}
public void Namespace3Elements()
{
var processor = new AckProcessor();
int packetId = 0;
List <JsonElement> array = new();
processor.Process(new MessageContext
{
Namespace = "/nsp",
Message = "/nsp,2[\"hi\",\"onAny\", true]",
AckHandler = (id, arr) =>
{
packetId = id;
array = arr;
}
});
Assert.AreEqual(2, packetId);
Assert.AreEqual(3, array.Count);
Assert.AreEqual("hi", array[0].GetString());
Assert.AreEqual("onAny", array[1].GetString());
Assert.IsTrue(array[2].GetBoolean());
}
public void ClearAckQueueAndFailMessages(ErrorInfo error) => AckProcessor.ClearQueueAndFailMessages(error);
private void SendMessage(ProtocolMessage message, Action <bool, ErrorInfo> callback)
{
AckProcessor.QueueIfNecessary(message, callback);
SendToTransport(message);
}
static async Task Main(string[] args)
{
Init();
var ctrlPut = new PutProcessor(1);
var ctrlGet = new GetProcessor(3);
var ctrlAck = new AckProcessor(1);
TaskCompletionSource tcs = new();
var ss = new SocketServer(new IPEndPoint(IPAddress.Any, 88));
await Task.Factory.StartNew(async() =>
{
while (true)
{
var stream = new CStream(await ss.AcceptAsync());
//var stream = await ss.AcceptAsync();
var requestQueue = new BColl <Message>();
var responseQueue = new BColl <Message>();
_ = Task.Factory.StartNew(() =>
{
while (true)
{
requestQueue.Add(stream.ReadJ <Message>());
}
}, TaskCreationOptions.LongRunning);
_ = Task.Factory.StartNew(() =>
{
while (true)
{
foreach (var m in responseQueue.Take(1000))
{
stream.WriteJ(m);
}
if (responseQueue.Count == 0)
{
stream.Flush();
}
}
}, TaskCreationOptions.LongRunning);
_ = Task.Factory.StartNew(() =>
{
while (true)
{
var req = requestQueue.Take();
if (req.Params["method"] == "get")
{
ctrlGet
.Get(new MsgKey
{
QueueName = req.Params["queueName"],
Partition = req.Params["partition"],
Selector = req.Params["selector"]
})
.ContinueWith(t => {
var resp = new Message {
ID = req.ID
};
resp.Params["messageId"] = t.Result.ToString();
responseQueue.Add(resp);
});
}
if (req.Params["method"] == "put")
{
ctrlPut
.Put(new Msg
{
Key = new MsgKey
{
QueueName = req.Params["queueName"],
Partition = req.Params["partition"],
Selector = req.Params["selector"]
},
ID = Guid.Parse(req.Params["messageId"])
})
.ContinueWith(t => {
var resp = new Message {
ID = req.ID
};
resp.Params["result"] = t.Result.ToString();
responseQueue.Add(resp);
});
}
if (req.Params["method"] == "ack")
{
ctrlAck
.Ack(Guid.Parse(req.Params["messageId"]))
.ContinueWith(t => {
var resp = new Message {
ID = req.ID
};
resp.Params["result"] = t.Result.ToString();
responseQueue.Add(resp);
});
}
}
}, TaskCreationOptions.LongRunning);
}
});
await tcs.Task;
}
