/// <summary>
/// This event will be called each time a message arrives.
/// </summary>
/// <param name="message">Brokered Message</param>
/// <param name="cancel">Cancellation Token</param>
/// <returns>Task</returns>
public virtual async Task OnMessageArrived(Message message, CancellationToken cancel)
{
var queued = new Queued <T>(message);
var data = await queued.Data();
await this.Process(data);
}
private void Dequeue()
{
if (Queued.Count == 0)
{
Processing = "";
return;
}
Processing = Queued.Dequeue();
}
private void ReceiveHandle(object arg)
{
var line = arg as String;
try
{
var args = new Answer(line);
switch (args.Message)
{
case "Hello":
Reseted?.Invoke();
break;
case "dropped":
Dropped?.Invoke(int.Parse(args.Values["N"]));
break;
case "queued":
Queued?.Invoke(int.Parse(args.Values["N"]));
break;
case "started":
Started?.Invoke(int.Parse(args.Values["N"]));
break;
case "completed":
Completed?.Invoke(int.Parse(args.Values["N"]), args.Values);
break;
case "failed":
Failed?.Invoke(int.Parse(args.Values["N"]), line);
break;
case "debug":
Debug?.Invoke(line);
break;
case "error":
Error?.Invoke(line);
break;
default:
break;
}
if (args.Values.ContainsKey("Q"))
{
SetQ(int.Parse(args.Values["Q"]), int.Parse(args.Values["N"]));
}
}
catch
{
Logger.Instance.Error(this, "exception", line);
}
}
public async Task Complete()
{
var wait = TimeSpan.FromSeconds(10);
var expected = Guid.NewGuid();
await this.sender.Send(expected);
var msg = await this.reciever.Get(wait);
var queued = new Queued<object>(msg);
await queued.Complete();
}
public async Task Complete()
{
var wait = TimeSpan.FromSeconds(10);
var expected = Guid.NewGuid();
await this.sender.Send(expected);
var msg = await this.reciever.Get(wait);
var queued = new Queued <object>(msg);
await queued.Complete();
}
protected override void afterRestarting(ISender sender)
{
var toRetry = Queued.Where(x => !x.IsExpired()).ToArray();
Queued.Clear();
foreach (var envelope in toRetry)
{
// It's perfectly okay to not wait on the task here
_sender.Enqueue(envelope);
}
}
public async Task OnMessageArrived()
{
var data = Guid.NewGuid().ToString();
var msg = new BrokeredMessage(data)
{
ContentType = data.GetType().ToString(),
};
var queue = new Queued <string>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
public override Task EnqueueForRetry(OutgoingMessageBatch batch)
{
Queued.AddRange(batch.Messages);
Queued.RemoveAll(e => e.IsExpired());
if (Queued.Count > _settings.MaximumEnvelopeRetryStorage)
{
var toRemove = Queued.Count - _settings.MaximumEnvelopeRetryStorage;
Queued = Queued.Skip(toRemove).ToList();
}
return(Task.CompletedTask);
}
public async Task OnMessageArrived()
{
var data = Guid.NewGuid().ToString();
var msg = new BrokeredMessage(data)
{
ContentType = data.GetType().ToString(),
};
var queue = new Queued<string>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
public async Task OnMessageArrived()
{
var data = Guid.NewGuid().ToString();
var bytes = System.Text.Encoding.ASCII.GetBytes(data);
var msg = new Message(bytes)
{
ContentType = data.GetType().ToString(),
};
var queue = new Queued <string>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
public async Task OnMessageArrivedBinary()
{
var data = Guid.NewGuid();
var msg = new Message(data.ToByteArray())
{
ContentType = data.GetType().ToString(),
};
msg.UserProperties.Add(BusQueueClient.EncodingKey, Encoding.Binary);
var queue = new Queued <Guid>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
public async Task OnMessageArrived()
{
var formatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
var data = Guid.NewGuid();
formatter.Serialize(stream, data);
var msg = new Message(stream.ToArray());
var queue = new Queued <Guid>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
}
public async Task OnMessageArrivedJson()
{
var data = Guid.NewGuid();
var json = JsonConvert.SerializeObject(data);
var msg = new BrokeredMessage(json)
{
ContentType = data.GetType().ToString(),
};
msg.Properties.Add(BusQueueClient.EncodingKey, Encoding.Json);
var queue = new Queued <Guid>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
private void QueueThreadProc()
{
while (running)
{
if (commandsQueue.TryDequeue(out Command cmd))
{
Queued?.Invoke(cmd.id);
commandsRun.Enqueue(cmd);
if (commandsRun.Count >= maxLength)
{
EmptySlotsEnded?.Invoke();
}
SlotsNumberReceived?.Invoke(cmd.id);
}
Thread.Sleep(10);
}
}
public override async Task EnqueueForRetry(OutgoingMessageBatch batch)
{
var expiredInQueue = Queued.Where(x => x.IsExpired()).ToArray();
var expiredInBatch = batch.Messages.Where(x => x.IsExpired()).ToArray();
try
{
using (var session = _store.LightweightSession())
{
var expired = expiredInBatch.Concat(expiredInQueue).ToArray();
session.DeleteEnvelopes(_marker.Incoming, expired);
var all = Queued.Where(x => !expiredInQueue.Contains(x))
.Concat(batch.Messages.Where(x => !expiredInBatch.Contains(x)))
.ToList();
if (all.Count > _settings.MaximumEnvelopeRetryStorage)
{
var reassigned = all.Skip(_settings.MaximumEnvelopeRetryStorage).ToArray();
session.MarkOwnership(_marker.Incoming, TransportConstants.AnyNode, reassigned);
}
await session.SaveChangesAsync();
_logger.DiscardedExpired(expired);
Queued = all.Take(_settings.MaximumEnvelopeRetryStorage).ToList();
}
}
catch (Exception e)
{
_logger.LogException(e, message: "Failed while trying to enqueue a message batch for retries");
#pragma warning disable 4014
Task.Delay(100).ContinueWith(async _ => await EnqueueForRetry(batch));
#pragma warning restore 4014
}
}
public async Task OnMessageArrivedBinary()
{
var formatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
var data = Guid.NewGuid();
formatter.Serialize(stream, data);
var msg = new Message(stream.ToArray())
{
ContentType = data.GetType().ToString(),
};
msg.UserProperties.Add(BusQueueClient.EncodingKey, Encoding.Binary);
var queue = new Queued <Guid>(msg);
var result = await queue.Data();
Assert.AreEqual(result, data);
}
}
private DATA.Translation Proceed()
{
var Data = DATA.Translation.CreateOne();
while (Queued.Count > 0)
{
Dequeue();
if (Processing.IndexOf("#") == 0) // If it's a comment of any sort
{
continue;
}
if (Processing.IndexOf("msgid ") == 0) // If it's a MessageId
{
Data.MessageId = ReadText();
}
if (Processing.IndexOf("msgctxt ") == 0) // If it's a MessageContext
{
Data.MessageContext = ReadText();
}
if (Processing.IndexOf("msgid_plural ") == 0) // If it's a PluralMessageId
{
Data.MessagePluralId = ReadText();
}
if (Processing.IndexOf("msgstr") == 0) // If it's an Untranslated message
{
Data.AddTranslation(ReadText());
}
}
Queued.Clear();
Processing = "";
return(Data);
}
public List <DATA.Translation> Transform()
{
var WorkingPath = Path.Combine(".", "TOOLS", "TMP", DecodedFile);
if (!File.Exists(WorkingPath))
{
return(null);
}
var Data = new List <DATA.Translation>();
using (var Reader = new StreamReader(File.Open(WorkingPath, FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read) as Stream, Encoding.UTF8, true, 10240))
{
do
{
var Read = Reader.ReadLine();
if (string.IsNullOrWhiteSpace(Read))
{
if (Queued.Count > 0)
{
Data.Add(Proceed());
}
}
else
{
Queued.Enqueue(Read);
if (Reader.EndOfStream)
{
Data.Add(Proceed());
}
}
} while (!Reader.EndOfStream);
}
return(Data);
}
private void RTSender_Queued(int N)
{
Logger.Instance.Debug(this, "unlock", "queued");
waitResponse.Set();
Queued?.Invoke(N);
}
public void Queue(int letter_id, string user_name)
{
db_mssql db_mssql = new db_mssql();
db_mysql db_mysql = new db_mysql();
letter lucky = (from m in db_mysql.letters where m.Id.Equals(letter_id) select m).FirstOrDefault();
if (lucky != null)
{
edit new_edit = new edit();
new_edit.editComment = "Added to queue by " + user_name;
new_edit.editor = user_name;
new_edit.newLetter = lucky.letterMessage;
new_edit.previousLetter = lucky.letterMessage;
new_edit.status = "accepted";
new_edit.letterID = lucky.Id;
new_edit.editDate = DateTime.UtcNow;
Queued new_queued_letter = new Queued();
new_queued_letter.AddedToQueueDate = DateTime.UtcNow;
new_queued_letter.LetterID = lucky.Id;
new_queued_letter.PostDate = DateTime.UtcNow;
new_queued_letter.QueueID = lucky.Id;
new_queued_letter.State = 0;
db_mssql.Queueds.Add(new_queued_letter);
db_mssql.edits.Add(new_edit);
db_mssql.SaveChanges();
}
}
public void ReceiveMessage(object peer) {
NetIncomingMessage message;
while ((message = Client.ReadMessage()) != null) {
switch (message.MessageType) {
case NetIncomingMessageType.Data:
var packetType = (int)message.ReadByte();
Packet packet;
switch (packetType) {
case (int)PacketTypes.Disconnect:
packet = new DisconnectPacket();
packet.NetIncomingMessageToPacket(message);
Connected?.Invoke(false);
break;
case (int)PacketTypes.QueueForGame:
packet = new QueueForGamePacket();
packet.NetIncomingMessageToPacket(message);
Queued?.Invoke(true);
break;
case (int)PacketTypes.CancelQueueForGame:
packet = new CancelQueueForGamePacket();
packet.NetIncomingMessageToPacket(message);
Queued?.Invoke(false);
break;
case (int)PacketTypes.GameFound:
packet = new GameFoundPacket();
packet.NetIncomingMessageToPacket(message);
ConnectToGameServer((GameFoundPacket)packet);
break;
default:
break;
}
break;
case NetIncomingMessageType.DebugMessage:
Debug.Log("Debug Message: " + message.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.Log("Warning Message: " + message.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)message.ReadByte();
switch (status) {
case NetConnectionStatus.InitiatedConnect:
Debug.Log("Initiated contact with server");
break;
case NetConnectionStatus.Connected:
Connected?.Invoke(true);
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.Disconnected:
Connected?.Invoke(false);
break;
default:
Debug.Log("Unhandled Status Changed type: " + status);
break;
}
break;
default:
Debug.Log("Unhandled type: " + message.MessageType + " " + message.LengthBytes + "bytes");
break;
}
Client.Recycle(message);
}
}
/// <summary>
/// Invokes the <see cref="Queued" />-Event
/// </summary>
protected virtual void OnQueued()
{
Queued?.Invoke(this, new EventArgs());
}
