/// <summary> /// </summary> /// <param name="sender"> /// </param> /// <param name="e"> /// </param> private void messageClient_MessageRecieved(object sender, MessageRecievedEventArgs e) { if (e.Message is WeatherMessage) { var message = (WeatherMessage)e.Message; this.Dispatcher.BeginInvoke(() => { this.Temperature.Text = message.Temperature.ToString(); }); } }
private void MessageRecieved(object sender, MessageRecievedEventArgs e) { if (e.Content.Equals("connected: true")) { Console.WriteLine("Connected"); } else { if (e.Content.Trim().Equals("ping")) { Console.WriteLine("PING"); Send("pong", "pong"); } } }
public static void IRCClient_OnMessageRecieved(object sender, MessageRecievedEventArgs e) { IRCMessage message = IRCMessage.Parse(e.RawMessage); if (message.Type == IRCMessageType.PRIVMSG) if (!message.Channel.Contains("#")) message = new IRCMessage(IRCMessageType.PRIVMSG, message.Sender, message.Sender, message.Body, message.RawMessage); try { MainClass.IRCClient.SendPRIVMSG(MainClass.MessageHandler.Handle(message), message.Channel, 1000); } catch (Exception ex) { MainClass.IRCClient.SendPRIVMSG(ex.Message, message.Channel, 2000); } finally { } }
/// <summary> /// this method is for the binding between the observable collection and the view /// its try to ask the server the log list and add them to the collection /// </summary> private void InitializedLog() { LogList = new List <MessageRecievedEventArgs>(); //if client connected to server send this command if (this.client.IsConnected) { CommandRecievedEventArgs commanToSent = new CommandRecievedEventArgs((int)CommandStateEnum.GET_ALL_LOG, new string[5], ""); client.SendCommandToServer(commanToSent); } else //client not connected - log list write this to the log { MessageRecievedEventArgs e = new MessageRecievedEventArgs { Message = "Failed to connect to the server", Status = MessageTypeEnum.FAIL }; LogList.Add(e); } }
/// <summary> /// Set logs via server request. /// </summary> /// <param name="channel">Web channel for request.</param> public void SetLogs(WebChannel channel) { ServiceLogs = new List <Log>(); if (channel.IsConnected()) { CommandMessage req = new CommandMessage((int)CommandEnum.LogCommand); channel.Write(req); CommandMessage answer = channel.Read(); // Iterate over every two arguments. First for message and second for type. for (int i = 0; i < answer.Args.Length; i += 2) { string m = answer.Args[i]; string t = MessageRecievedEventArgs.GetTypeEnum(Int32.Parse(answer.Args[i + 1])).ToString(); Log log = new Log(t, m); // Adds a single log to an observables logs list. ServiceLogs.Add(log); } } }
public void GetMessageFromClient(object sender, string message) { //If message if log - handle and notify, else ignore. CommandRecievedEventArgs command = CommandRecievedEventArgs.FromJson(message); if (command.CommandID == (int)CommandEnum.LogCommand) { ObservableCollection <LogType> list = new ObservableCollection <LogType>(); string[] logsStrings = command.Args[0].Split(';'); foreach (string s in logsStrings) { if (s.Contains("Status") && s.Contains("Message")) { try { MessageRecievedEventArgs m = MessageRecievedEventArgs.FromJson(s); list.Add(LogType.LogTypeFromMessageRecieved(m)); } catch (Exception e) { continue; } } } Logs = list; NotifyRefresh?.Invoke(); } else if (command.CommandID == (int)CommandEnum.NewLogEntryCommand) { try { MessageRecievedEventArgs m = MessageRecievedEventArgs.FromJson(command.Args[0]); ObservableCollection <LogType> tempList = new ObservableCollection <LogType>(Logs); tempList.Add(LogType.LogTypeFromMessageRecieved(m)); this.Logs = tempList; NotifyRefresh?.Invoke(); } catch (Exception e) { Console.WriteLine(e.ToString()); } } }
protected override void MessageRecieved(object sender, MessageRecievedEventArgs <AmpMessage> e) { if (e.Message == null) { throw new RpcBizException("empty message"); } if (e.Message.ServiceId == 0 && e.Message.MessageId == 0) { //心跳消息 Logger.Info("heart beat message Id{0}", e.Message.Id); return; } if (e.Message.InvokeMessageType == Rpc.Codes.InvokeMessageType.NotFound || e.Message.InvokeMessageType == Rpc.Codes.InvokeMessageType.ERROR) { Logger.Error("server response error msg ,type{0}", e.Message.InvokeMessageType); var message = e.Message; TaskCompletionSource <AmpMessage> task; if (_resultDictionary.ContainsKey(message.Id) && _resultDictionary.TryGetValue(message.Id, out task)) { task.TrySetException(new RpcRemoteException(string.Format("server response error msg ,type{0}", e.Message.InvokeMessageType))); // 移除字典 RemoveResultCallback(message.Id); } } if (e.Message.InvokeMessageType == Rpc.Codes.InvokeMessageType.Response) //只处理回复消息 { Logger.Info($"receive message, id:{e.Message.Id}"); var message = e.Message; TaskCompletionSource <AmpMessage> task; if (_resultDictionary.ContainsKey(message.Id) && _resultDictionary.TryGetValue(message.Id, out task)) { task.TrySetResult(message); Logger.Info("message {0},set result success", message.Id); // 移除字典 RemoveResultCallback(message.Id); } } }
private void ClientRequest(MessageRecievedEventArgs message) { switch (message.Status) { case MessageTypeEnum.REMOVE_HANDLER: OnRemoveDir?.Invoke(this, message); break; case MessageTypeEnum.P_SENDALL: SendAllPhotos?.Invoke(this, null); break; case MessageTypeEnum.P_DELETE: RemovePhoto?.Invoke(this, message); break; default: break; } }
public void HandleCommand(object sender, CommandRecievedEventArgs e) { if (e.CommandID == (int)CommandEnum.LogChangedCommand) { logs.Insert(0, MessageRecievedEventArgs.FromJSON(e.Args[0])); return; } else if (e.CommandID == (int)CommandEnum.LogHistoryCommand) { try { foreach (MessageRecievedEventArgs log in MessageRecievedEventArgs.LogFromJSON(e.Args[0])) { logs.Insert(0, log); } } catch { } } }
public void UpdatesListner() { try { NetworkStream stream = client.GetStream(); BinaryReader reader = new BinaryReader(stream); while (true) { // TODO - when client disconnect string command = reader.ReadString(); MessageRecievedEventArgs message = MessageRecievedEventArgs.Deserialize(command); ClientRequest(message); } } catch (Exception) { StopCommunication(this, null); } }
private void eventLog1_EntryWritten(object sender, MessageRecievedEventArgs e) { EventLogEntryType a = EventLogEntryType.Error; switch (e.Status) { case MessageTypeEnum.FAIL: a = EventLogEntryType.FailureAudit; break; case MessageTypeEnum.INFO: a = EventLogEntryType.Information; break; case MessageTypeEnum.WARNING: a = EventLogEntryType.Warning; break; } this.eventLog1.WriteEntry(e.Message, a); }
public static MessageRecievedEventArgs GetAllPhotos() { MessageRecievedEventArgs message = new MessageRecievedEventArgs(MessageTypeEnum.P_SEND, ""); Settings settings = Settings.Instance; PhotoList photos = new PhotoList(); string[] thumbnailsPath; try { thumbnailsPath = Directory.GetFiles(settings.OutputPath + "\\Thumbnails", "*.*", SearchOption.AllDirectories); } catch (Exception) { return(message); } foreach (var thumbPath in thumbnailsPath) { Image image; Image imageThumb; int index = thumbPath.IndexOf("\\Thumbnails"); string imagePath = (index < 0) ? thumbPath : thumbPath.Remove(index, "\\Thumbnails".Length); try { image = Image.FromFile(imagePath); imageThumb = Image.FromFile(thumbPath); } catch (Exception) { continue; } photos.Photos.Add(new PhotoPackage(imagePath, thumbPath, image, imageThumb)); } message.Message = photos.Serialize(); return(message); }
// Log handler - activated trough m_logging.MessageRecieved // writing to log acording to the message type private void LogHandler(object sender, MessageRecievedEventArgs args) { switch (args.Status) { case MessageTypeEnum.INFO: DirHanlerLogeer.WriteEntry(args.Message, EventLogEntryType.Information); break; case MessageTypeEnum.WARNING: DirHanlerLogeer.WriteEntry(args.Message, EventLogEntryType.Warning); break; case MessageTypeEnum.FAIL: DirHanlerLogeer.WriteEntry(args.Message, EventLogEntryType.FailureAudit); break; default: DirHanlerLogeer.WriteEntry(args.Message, EventLogEntryType.Information); break; } }
/// <summary> /// This functions is being invoked when the logging service send a log. /// </summary> /// <param name="sender">The logging service that send the log</param> /// <param name="args">Event args - contains the log that ilogging service has sent.</param> public void ReciveLog(object sender, MessageRecievedEventArgs args) { if (this.isListeningToLogger) { string[] logsToSend = new string[2]; logsToSend[0] = ((int)args.Status).ToString(); logsToSend[1] = args.Message; CommandRecievedEventArgs commandArgs = new CommandRecievedEventArgs((int)CommandEnum.LogCommand, logsToSend, ""); string command = JsonConvert.SerializeObject(commandArgs); try { this.writer.Write(command); } catch (IOException e) { this.CloseConnectionToClient(); this.logger.Log("Exeption with writing to client at client.ReciveLog , disconnectiong from client", MessageTypeEnum.FAIL); this.logger.Log(e.Message, MessageTypeEnum.FAIL); } } }
public static MessageRecievedEventArgs GetPhotos(string photoPath, string thumbPath) { MessageRecievedEventArgs message = new MessageRecievedEventArgs(MessageTypeEnum.P_SEND, ""); Image image; Image imageThumb; try { image = Image.FromFile(photoPath); imageThumb = Image.FromFile(thumbPath); } catch (Exception) { return(null); } message.Message = new PhotoPackage(photoPath, thumbPath, image, imageThumb).Serialize(); return(message); }
/// <summary> /// when file created /// </summary> /// <param name="source">event caller</param> /// <param name="e">the created file</param> public void OnChanged(object source, FileSystemEventArgs e) { // check if file is an image // if it is, backup string path = e.FullPath; logger.Log("New file detected in \"" + dirPath + "\"", MessageTypeEnum.L_INFO); if (!filters.Contains(Path.GetExtension(path))) { logger.Log("File \"" + Path.GetFileName(path) + "\" isnt an image", MessageTypeEnum.L_INFO); return; } logger.Log("Backup \"" + Path.GetFileName(path) + "\" is an image", MessageTypeEnum.L_INFO); string[] output = { "", "" }; ExitCode status = controller.ExecuteCommand(Command.BackupFile, new string[] { path }, output); if (status != ExitCode.Success) { logger.Log("Failed to back up \"" + Path.GetFileName(path) + "\" reson of failuer: " + GetFailedReson(status), MessageTypeEnum.L_FAIL); } else { logger.Log("Successfully Backup \"" + Path.GetFileName(path) + "\" and created thumbnail", MessageTypeEnum.L_INFO); MessageRecievedEventArgs message = PhotoExtractor.GetPhotos(output[0], output[1]); if (message != null) { photoUpdate.Log(message.Message, message.Status); } Settings settings = Settings.Instance; settings.PicturesCounter++; } }
void OnMessageReceived(object sender, MessageRecievedEventArgs e) { _logger.LogInformation($"Received Message: {e.MessageType}"); switch (e.MessageType) { case LoriotMessageType.UplinkMessage: HandleUplinkMessage(e); break; case LoriotMessageType.GatewayMessage: HandleGatewayInformation(e); break; case LoriotMessageType.CacheMessage: HandleCacheMessage(e); break; default: break; } }
public string Execute(string[] args, out bool result) { List <MessageRecievedEventArgs> logsList = new List <MessageRecievedEventArgs>(); string logName = ConfigurationManager.AppSettings["LogName"]; string sourceName = ConfigurationManager.AppSettings["SourceName"]; EventLog[] allLogs = EventLog.GetEventLogs(); EventLog log = null; foreach (EventLog currLog in allLogs) { if (currLog.Log == logName) { log = currLog; break; } } if (log == null) { result = false; return("Couldn't retreive log entries from Log: " + logName + "with Source " + sourceName); } EventLogEntryCollection entries = log.Entries; // foreach (EventLogEntry entry in entries) for (int i = entries.Count - 1; i >= 0; i--) { //sift through all enrties EventLogEntry entry = entries[i]; MessageRecievedEventArgs e = new MessageRecievedEventArgs(entry.Message, MessageRecievedEventArgs.ConvertType(entry.EntryType)); logsList.Add(e); if (entry.Message == "In OnStart") { break; } } result = true; return(Newtonsoft.Json.JsonConvert.SerializeObject(logsList)); }
private static void client_MessageRecieved(object sender, MessageRecievedEventArgs e) { IRCMessage message = IRCMessage.Parse(e.RawMessage); Console.WriteLine(e.RawMessage); switch (message.Type) { case IRCMessageType.EndOfMOTD: case IRCMessageType.MOTD: case IRCMessageType.NOTICE: Console.WriteLine(message.Body); break; case IRCMessageType.Names: Console.WriteLine("/NAMES " + message.Body); break; case IRCMessageType.EndOfNames: Console.WriteLine(message.Body); break; case IRCMessageType.Join: Console.WriteLine(message.Sender + " has joined " + message.Channel); break; case IRCMessageType.Part: Console.WriteLine(message.Sender + " has left " + message.Channel); break; case IRCMessageType.Nick: Console.WriteLine(message.Sender + " has changed nick to " + message.Body); break; case IRCMessageType.Quit: Console.WriteLine(message.Sender + " has quit " + message.Body); break; case IRCMessageType.PRIVMSG: Console.WriteLine("<" + message.Sender + ">" + message.Body); break; case IRCMessageType.Unknown: Console.WriteLine(message.Body); break; } // Console.WriteLine(message.Channel + " <" + message.Sender + "> " + message.Body); }
/// <summary> /// this method is for the binding between the observable collection and the view /// its try to ask the server the log list and add them to the collection /// </summary> private void InitializedLog() { LogList = new ObservableCollection <MessageRecievedEventArgs>(); Object thisLock = new Object(); BindingOperations.EnableCollectionSynchronization(LogList, thisLock); //if client connected to server send this command if (this.client.IsConnected) { CommandRecievedEventArgs commanToSent = new CommandRecievedEventArgs((int)CommandStateEnum.GET_ALL_LOG, new string[5], ""); client.SendCommandToServer(commanToSent); } else //client not connected - log list write this to the log { MessageRecievedEventArgs e = new MessageRecievedEventArgs { Message = "Failed to connect to the server", Status = MessageTypeEnum.FAIL }; LogList.Add(e); } }
private void HandleMessage(MessageRecievedEventArgs message) { switch (message.Status) { case MessageTypeEnum.SETTINGS: Settings settings = Settings.Deserialize(message.Message); SetSettings?.Invoke(this, settings); break; case MessageTypeEnum.REMOVE_HANDLER: OnHandelRemove?.Invoke(this, message.Message); break; case MessageTypeEnum.L_FAIL: case MessageTypeEnum.L_INFO: case MessageTypeEnum.L_WARNING: OnLogMessage?.Invoke(this, message); break; default: break; } }
/// <summary> /// Function that send log to client. /// </summary> /// <param name="g"> Message of the log. </param> public void SendLog(MessageRecievedEventArgs g) { try { //send all the new messages. foreach (MessageRecievedEventArgs m in path_list.ToList()) { if (!sended_logs.Contains(m)) { string b = m.Message; string c = m.Status.ToString(); string f = "$"; string colour = ""; if (c == "INFO") { colour = "Green"; } if (c == "ERROR") { colour = "Red"; } if (c == "WARNING") { colour = "Yello"; } imageServer.writeSocket("colour=" + colour + f + "log=" + c + f + "message=" + b + f, tCP); sended_logs.Add(m); } } } catch (Exception e) { } }
// start listening for server message that will send the server ip back to client private void UDPReceive(IAsyncResult ar) { try { IPEndPoint ip = new IPEndPoint(IPAddress.Any, PORT_NUMBER); byte[] bytes = udp.EndReceive(ar, ref ip); string message = Encoding.ASCII.GetString(bytes); Console.WriteLine("[UDP] From {0} received: {1} ", ip.Address.ToString(), message); MessageRecievedEventArgs args = new MessageRecievedEventArgs(); args.ipAddress = ip.Address.ToString(); args.message = message; OnMessageRecieved(args); if (!isClosed) { UDPStartListening(); } } catch (ObjectDisposedException e) { Console.Out.WriteLine(e); } }
public void SendLog(object sender, MessageRecievedEventArgs e) { }
public void OnLogMessageRecieved(object sender, MessageRecievedEventArgs e) { }
/// <summary> /// Call message from the client requesting information. /// </summary> /// <param name="request">Object representing the requested information</param> /// <returns>Response</returns> public ResponseMessage Call(RequestMessage request) { var arg = new MessageRecievedEventArgs(request); OnMessageRecieved(null, arg); return arg.Response; }
private void client_mesageRecieved(object sender, MessageRecievedEventArgs e) { IRCMessage message = IRCMessage.Parse(e.RawMessage); switch (message.Type) { case IRCMessageType.EndOfMOTD: case IRCMessageType.MOTD: case IRCMessageType.NOTICE: case IRCMessageType.Unknown: processOutput(message.Body); break; case IRCMessageType.Join: processOutput(message.Sender + " has joined " + message.Channel); break; case IRCMessageType.MODE: processOutput(message.Sender + " sets mode " + message.Body + " " + message.Channel); break; case IRCMessageType.Names: processOutput(message.Channel + " /NAMES"); processOutput(message.Body); foreach (string user in message.Body.Split(' ')) if (lbUsers.Items.Contains(user)) continue; else lbUsers.Invoke(new MethodInvoker(delegate { lbUsers.BeginUpdate(); lbUsers.Items.Add(user); lbUsers.EndUpdate(); })); break; case IRCMessageType.Nick: processOutput(message.Sender + " has changed nick to " + message.Body); lbUsers.Invoke(new MethodInvoker(delegate { lbUsers.BeginUpdate(); lbUsers.Items.Remove(message.Sender); lbUsers.Items.Add(message.Body); lbUsers.EndUpdate(); })); break; case IRCMessageType.Part: processOutput(message.Sender + " has left " + message.Channel); lbUsers.Invoke(new MethodInvoker(delegate { lbUsers.BeginUpdate(); lbUsers.Items.Remove(message.Sender); lbUsers.EndUpdate(); })); break; case IRCMessageType.Quit: processOutput(message.Sender + " has quit"); lbUsers.Invoke(new MethodInvoker(delegate { lbUsers.BeginUpdate(); lbUsers.Items.Remove(message.Sender); lbUsers.EndUpdate(); })); break; case IRCMessageType.PRIVMSG: string formatted = "<" + message.Sender + "> " + message.Body; processOutput(formatted); break; default: processOutput(message.Body); break; } }
/// <summary> /// add new log to the list of logs /// </summary> /// <param name="e"></param> public void addLogToList(MessageRecievedEventArgs e) { logMsgs.Insert(0, e); }
public void OnMessageRecieved(object sender, MessageRecievedEventArgs e) { this.BuildLogAndSendCommand(e.Message, e.Status.ToString()); }
public void Log(MessageRecievedEventArgs message) { MessageRecieved?.Invoke(this, message); }
protected abstract void MessageRecieved(object sender, MessageRecievedEventArgs <TMessage> e);
public LogMessage(MessageRecievedEventArgs message) : this(message.Status, message.Message) { }
public void NotifyRemoveHandler(string dir) { MessageRecievedEventArgs messageRecievedEventArgs = new MessageRecievedEventArgs(MessageTypeEnum.REMOVE_HANDLER, dir); NotifyHandlerChange?.Invoke(this, messageRecievedEventArgs); }
public void SendMessage(object sender, MessageRecievedEventArgs message) { client.WriteToServer(message.Serialize()); }
/// <summary> /// Send message from the client. /// </summary> /// <param name="request">Object representing the requested information</param> /// <remarks> /// This should be used either when you need a one way notification. /// </remarks> public void Post(RequestMessage request) { var arg = new MessageRecievedEventArgs(request); OnMessageRecieved(null, arg); }
public void RemoveHandler(string dir) { MessageRecievedEventArgs message = new MessageRecievedEventArgs(MessageTypeEnum.REMOVE_HANDLER, dir); client.WriteToServer(message.Serialize()); }
private void Message_Recieved(object sender, MessageRecievedEventArgs <TMessage> args) { Recieved?.Invoke(sender, args); }
/// <summary> /// </summary> /// <param name="e"> /// </param> private void OnMessageRecieved(MessageRecievedEventArgs e) { EventHandler<MessageRecievedEventArgs> handler = this.MessageRecieved; if (handler != null) { handler(this, e); } }