/// <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);
}
}
