/// <summary> /// Returns the hardcoded client revision string from the Outgoing[4000] message class. /// </summary> /// <returns></returns> public string GetClientRevision() { if (!string.IsNullOrWhiteSpace(_clientRevision)) { return(_clientRevision); } if (!(OutgoingMessages?.ContainsKey(4000) ?? false)) { return(string.Empty); } ASInstance outgoingInstance = OutgoingMessages[4000].Instance; ASMethod method = outgoingInstance.FindFirstMethod(null, "Array"); if (method == null) { return(string.Empty); } using (var inCode = new FlashReader(method.Body.Bytecode)) { object[] values = inCode.ReadValuesUntil(OPCode.PushString); var pushStringIndex = (int)values[0]; _clientRevision = method.ABC.Constants.Strings[pushStringIndex]; } return(_clientRevision); }
protected void Send(BytePacket <T> packet) { OutgoingMessages.Enqueue(new NetworkMessage <T> { Packet = packet }); LatestSendTimestamp = DateTime.Now; }
private void FlushOutgoingPackets() { int outQCount = OutgoingMessages.Count; // write out queued messages for (int i = 0; i < outQCount; i++) { NetworkMessage <T> packet; bool have = OutgoingMessages.TryDequeue(out packet); if (have) { if (packet.TargetAddress == null) { packet.Packet.Send(UdpSocket); } else { packet.Packet.Send(UdpSocket, packet.TargetAddress); } PacketsSent++; TotalBytesSent += packet.Packet.Payload.Length; InternalSendCount += packet.Packet.Payload.Length; } } }
protected async void Run(CancellationToken cancellationToken, Uri uri) { WebSocket = new ClientWebSocket(); OnConnecting(); WebSocket = await Connection.OpenConnection(WebSocket, uri); if (WebSocket.State == WebSocketState.Open) { OnConnected(); } while (WebSocket.State == WebSocketState.Open) { if (cancellationToken.IsCancellationRequested) { await Cancel(WebSocket); break; } ICommand message = null; lock (queueLock) { message = OutgoingMessages.Any() ? OutgoingMessages.Dequeue() : null; } if (message != null) { await SendMessage(WebSocket, message); } } System.Diagnostics.Trace.WriteLine($"Connection closed. Reason: {WebSocket.CloseStatus}, Details: {WebSocket.CloseStatusDescription}"); OnDisconnect(); }
public void AddMessage(ICommand message) { lock (queueLock) { OutgoingMessages.Enqueue(message); } }
private void Send() { while (IsRunning) { var message = OutgoingMessages.Take(); } }
protected void Send(BytePacket <T> packet, IPEndPoint target) { OutgoingMessages.Enqueue(new NetworkMessage <T> { Packet = packet, TargetAddress = target, }); LatestSendTimestamp = DateTime.Now; }
/// <summary> /// Gets the outgoing messages for the incoming message with the given ID /// </summary> public IEnumerable <OutgoingMessage> GetOutgoingMessages(string messageId) { var outgoingMessages = OutgoingMessages.FirstOrDefault(o => o.MessageId == messageId); return(outgoingMessages != null ? outgoingMessages.MessagesToSend : Enumerable.Empty <OutgoingMessage>()); }
void IDataStore.Save(OutgoingSmsMessage msg) { if (!OutgoingMessages.Any(m => m.Id == msg.Id)) { OutgoingMessages.Add(msg); } SaveChanges(); }
public void Send() { var message = OutgoingMessages.Take(TokenSource.Token); MessageWaitHandle.WaitOne(); TwitchClient.SendMessage(message.Msg); MessageWaitHandle.Reset(); MessageTimer.Start(); }
public void ProcessOutgoingQueue() { StringBuilder s = new StringBuilder(); s.Append(Comms.Base64NetID + Comms.myClient.IDBase64 + '?'); foreach (RawMessage m in OutgoingMessages) { s.Append(FormatMessageToString(m) + '\n'); } Comms.TransmitString(s.ToString()); OutgoingMessages.Clear(); }
/// <summary> /// Enqueue message thread safe /// </summary> /// <param name="message"></param> internal void AddMessageToQueue(SinricMessage message) { var payloadJson = JsonConvert.SerializeObject(message.Payload); message.RawPayload = new JRaw(payloadJson); // compute the signature using our secret key so that the service can verify authenticity message.Signature.Hmac = HmacSignature.Signature(payloadJson, SecretKey); OutgoingMessages.Enqueue(message); Debug.Print("Queued websocket message for sending"); }
void IDataStore.Remove(OutgoingSmsMessage message) { if (message != null) { foreach (OutgoingSmsMessage msg in OutgoingMessages.Where(m => m.Id == message.Id)) { OutgoingMessages.Remove(msg); } SaveChanges(); } }
void IDataStore.ScheduleMessage(OutgoingSmsMessage msg, Subscription sub) { OutgoingMessages.Add(msg); Subscription toUpdate = Subscriptions.Where(s => s.Id == sub.Id).FirstOrDefault(); if (toUpdate != null) { toUpdate.Next = DateTime.Today.AddDays(1).AddHours(4).ToUniversalTime(); } SaveChanges(); }
void IDataStore.RemoveAllForPhone(string phone) { foreach (OutgoingSmsMessage msg in OutgoingMessages.Where(m => m.Destination == phone)) { OutgoingMessages.Remove(msg); } foreach (Subscription sub in Subscriptions.Where(s => s.Phone == phone)) { Subscriptions.Remove(sub); } SaveChanges(); }
/// <summary> /// Creates the idempotency data object, initializing it with the given list of outgoing message lists and record of handled message IDs /// </summary> public IdempotencyData(IEnumerable <OutgoingMessages> outgoingMessages = null, IEnumerable <string> handledMessageIds = null) { if (outgoingMessages != null) { OutgoingMessages.AddRange(outgoingMessages); } if (handledMessageIds != null) { foreach (var id in handledMessageIds) { HandledMessageIds.Add(id); } } }
OutgoingMessages GetOrCreate(string messageId) { HandledMessageIds.Add(messageId); var outgoingMessages = OutgoingMessages.FirstOrDefault(o => o.MessageId == messageId); if (outgoingMessages != null) { return(outgoingMessages); } outgoingMessages = new OutgoingMessages(messageId, new List <OutgoingMessage>()); OutgoingMessages.Add(outgoingMessages); return(outgoingMessages); }
public void SendNewState <T>(T stateEnumValue) where T : Enum { // actionVerb will be the description of the enum, ie. setContactState var actionVerb = SinricActionAttribute.GetActionVerb(stateEnumValue.GetType()); var newState = SetLocalState(stateEnumValue); // send a message to the server indicating new state var message = NewMessage(SinricPayload.MessageType.Event); message.Payload.SetCause(SinricCause.CauseType, SinricCause.PhysicalInteraction); message.Payload.SetValue(SinricValue.State, newState); message.Payload.Action = actionVerb; // queue for sending OutgoingMessages.Enqueue(message); }
/// <summary> /// This should be call before doing final storage, will reduce the size of /// unused fields /// </summary> public void SetEmptyValueToNull() { foreach (var err in ErrorMessages) { err.SetEmptyValueToNull(); } if (String.IsNullOrEmpty(MediaItemId)) { MediaItemId = null; } if (String.IsNullOrEmpty(MessageId)) { MessageId = null; } if (!Log.Any()) { Log = null; } if (!OutputCommands.Any()) { OutputCommands = null; } if (!OutgoingMessages.Any()) { OutgoingMessages = null; } if (!ErrorMessages.Any()) { ErrorMessages = null; } if (!InfoMessages.Any()) { InfoMessages = null; } if (!WarningMessages.Any()) { WarningMessages = null; } if (Envelope.SetEmptyValueToNull()) { Envelope = null; } }
public void RemoveAllForPhone(string phone) { lock (_lock) { IList <OutgoingSmsMessage> outgoing = OutgoingMessages.Where(m => m.Destination == phone).ToList(); foreach (OutgoingSmsMessage msg in outgoing) { Remove(msg); } IList <Subscription> subs = Subscriptions.Where(s => s.Phone == phone).ToList(); foreach (Subscription sub in subs) { Remove(sub); } } }
/// <summary> /// Main sending thread /// </summary> public static void SendMain() { try { while (!MainSystem.Singleton.Quit) { IMessageBase sendMessage; if (OutgoingMessages.TryDequeue(out sendMessage)) { SendNetworkMessage(sendMessage); } else { Thread.Sleep(SettingsSystem.CurrentSettings.SendReceiveMsInterval); } } } catch (Exception e) { Debug.LogError("[LMP]: Send thread error: " + e); } }
public void SendHeartbeatToAll() { RawMessage m = new RawMessage(Comms.myClient.ID, true, MessageType.HEARTBEAT, new byte[0]); OutgoingMessages.Add(m); }
public void SendDisconnectMessage() { OutgoingMessages.Add(new RawMessage(0, true, MessageType.DISCONNECT, new byte[0])); }
/// <summary> /// Adds a new message to the queue /// </summary> /// <param name="message"></param> public static void QueueOutgoingMessage(IMessageBase message) { OutgoingMessages.Enqueue(message); }
public void SetMessageHandlers(IKeyboardMouseInput keyboardMouse) { OutgoingMessages = new OutgoingMessages(Connection); MessageHandlers.ApplyConnectionHandlers(Connection, this, keyboardMouse); }
public void SendClientStatusUpdate(Client receiver) { RawMessage m = new RawMessage(receiver.AvailableID, false, MessageType.UPDATESTATUS, Comms.myClient.SerializeClientData()); OutgoingMessages.Add(m); }
public static void AddParameter(this List <byte> source, OutgoingMessages msgId) { AddParameter(source, (int)msgId); }
public void AddMessage(IKalos message) { OutgoingMessages.Add(message); }
public static void AddParameter(this BinaryWriter source, OutgoingMessages msgId) { AddParameter(source, (int)msgId); }
public void SendConnectMessage() { RawMessage m = new RawMessage(0, true, MessageType.CONNECT, Comms.myClient.SerializeClientData()); OutgoingMessages.Add(m); }