/// <summary> /// handling the situation of closing the directory /// </summary> public void HandleClosing() { string message; try { //make each watcher stop filtering and watching foreach (FileSystemWatcher watcher in this.m_dirWatcher) { watcher.EnableRaisingEvents = false; } //log that this directory is closed message = m_path + "is no longer watched"; DirectoryCloseEventArgs closing = new DirectoryCloseEventArgs(m_path, message); DirectoryClose?.Invoke(this, closing); } catch (Exception e) { //couldnt close the directory - log it message = "Error while trying to close " + m_path; m_logging.Log(message, MessageTypeEnum.INFO); } finally { //unsubscribe the "onCreated" func from the event foreach (FileSystemWatcher watch in this.m_dirWatcher) { watch.Created -= new FileSystemEventHandler(OnCreated); } } }
/// <summary> /// The function closes the handler /// </summary> /// <param name="logMessage">the message that will be shown when closing the handler</param> public void CloseHandler(string logMessage) { m_dirWatcher.EnableRaisingEvents = false; m_dirWatcher.Created -= OnFileCreated; m_dirWatcher.Dispose(); DirectoryClose.Invoke(this, new DirectoryCloseEventArgs(m_path, logMessage)); }
/// <summary> /// when close command recieved /// </summary> public void OnClose() { // unsubscribe to event this.m_dirWatcher.Created -= OnCreated; // envoke DirectoryClose event DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, "close directory")); }
/*********************************************************************/ public void closeHandler(string path) { //– close FileSystemWatcher and invoke onClose event watcher.EnableRaisingEvents = false; DirectoryClose.Invoke(this, new DirectoryCloseEventArgs(path, "Directory Closed")); //DirectoryClose -= new FileSystemWatcher(OnCommandRecieved); }
public void StartHandleDirectory(string dirPath) { // If The Directory Doesn't Exists if (!Directory.Exists(dirPath)) { DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(dirPath, String.Format(MessageInfrastructure.ERROR_DirNotFound, dirPath))); return; // Finishing the Task Of Listening to the file } m_path = dirPath; // Storing the Path of Directory m_dirWatcher = new FileSystemWatcher(); m_dirWatcher.Path = dirPath; /* Watch for changes in LastAccess and LastWrite times, and * the renaming of files or directories. */ m_dirWatcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; m_dirWatcher.EnableRaisingEvents = true; // Setting that the Watcher is active for Events m_dirWatcher.Created += new FileSystemEventHandler(OnChanged); // m_dirWatcher.Filter = "*.bmp;*.jpg;*.gif;*.png"; // Setting the Filter m_logging.Log(String.Format(MessageInfrastructure.INFO_StartDirHandler, dirPath), MessageTypeEnum.INFO); }
/// <summary> /// The event occur upon receiving a command. /// </summary> /// <param name="sender"></param> The command sender (invoker). /// <param name="e"></param> The argumetns. public void OnCommandRecieved(object sender, CommandReceivedEventArgs e) { string msg; bool result = true; if (e.CommandID == CommandEnum.CloseCommand) { if (e.RequestDirPath != dirPath) { return; } msg = "Directory " + dirPath + " is closing"; dirWatcher.EnableRaisingEvents = false; DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(e.RequestDirPath, msg)); //logger.Log(msg, MessageTypeEnum.INFO); } else { if (!IsSubFile(e.RequestDirPath)) { return; } msg = controller.ExecuteCommand(e.CommandID, e.Args, out result); } logger.Log(msg, GetMessageType(result)); }
/// <summary> /// When a command comes- checks what kind it is: if closing- its closes the service, /// otherwise its calls to ExecuteCommand and writes to the log sucsess\failure /// </summary> /// <param name="sender">the object called to the event</param> /// <param name="e">the event args required for this event</param> public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) { bool result; string message; if (e.CommandID == (int)CommandEnum.CloseCommand) { if (e.RequestDirPath.Equals("*") || e.RequestDirPath.Equals(m_path)) { m_dirWatcher.EnableRaisingEvents = false; DirectoryCloseEventArgs dirCloseArgs = new DirectoryCloseEventArgs(m_path, "CLOSE"); DirectoryClose?.Invoke(this, dirCloseArgs); } return; } else { if (m_path == null || !e.RequestDirPath.Contains(m_path)) { return; } message = m_controller.ExecuteCommand(e.CommandID, e.Args, out result); } // write to the log if (result) { m_logging.Log(message, MessageTypeEnum.INFO); } else { m_logging.Log(message, MessageTypeEnum.FAIL); } }
public void OnCloseService(object send, DirectoryCloseEventArgs e) { m_logging.Log("closing handler for directory: " + m_path, MessageTypeEnum.INFO); m_dirWatcher.EnableRaisingEvents = false; m_dirWatcher.Dispose(); DirectoryClose?.Invoke(this, e); }
/// <summary> /// This method is called when command is received. /// </summary> /// <param name="sender">The command sender.</param> /// <param name="e">The command's arguments.</param> public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) // The Event that will be activated upon new Command { //checking if our path is the one the server intended to handle the command if (e.RequestDirPath.Equals(m_path) || e.RequestDirPath.Equals("*")) // Equals compares content { // if CloseCommand if (e.CommandID == (int)CommandEnum.CloseCommand) // == better for numbers { m_dirWatcher.EnableRaisingEvents = false; // stop watching. string exitMsg = "Stoped handling the directory in path: " + m_path; DirectoryCloseEventArgs directoryCloseEventArgs = new DirectoryCloseEventArgs(m_path, exitMsg); DirectoryClose?.Invoke(this, directoryCloseEventArgs); } else // if other command { bool success; string msg = m_controller.ExecuteCommand(e.CommandID, e.Args, out success); if (success) { m_logging.Log(msg, MessageTypeEnum.INFO); } else { m_logging.Log(msg, MessageTypeEnum.FAIL); } } } }
public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) { Task task = new Task(() => { bool success; // Indication if the Command Was Successful // If The Command is directed to the given Path if (e.RequestDirPath.Equals("*") || e.RequestDirPath.Equals(m_path)) { // If The User Wishes to close the file if (e.CommandID == (int)CommandEnum.CloseCommand) { if (m_dirWatcher != null) { m_dirWatcher.EnableRaisingEvents = false; } DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, String.Format(MessageInfrastructure.INFO_CloseCommand, m_path))); // Invoking the Server Close } // Logging the Command Being Recieved m_logging.Log(String.Format(MessageInfrastructure.INFO_RecievedCommand, e.CommandID, String.Join(",", e.Args)), Logging.Modal.MessageTypeEnum.INFO); // Execute command string result = m_controller.ExecuteCommand(e.CommandID, e.Args, out success); MessageTypeEnum type = (success) ? MessageTypeEnum.INFO : MessageTypeEnum.FAIL; m_logging.Log(String.Format(MessageInfrastructure.INFO_SuccessfulCommand, e.CommandID, String.Join(",", e.Args), result), type); } }); task.Start(); }
/// <summary> /// This function is invoked when filewatcher has an error /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnFileWatcherError(object sender, ErrorEventArgs e) { m_logging.Log(DateTime.Now.ToString() + " Error Detected In Handler Of Directory " + m_path, MessageTypeEnum.FAIL); DirectoryCloseEventArgs args = new DirectoryCloseEventArgs(m_path, e.GetException().ToString()); DirectoryClose?.Invoke(this, args); CloseHandler(); }
/// <summary> /// EndHandle function. /// stop handle directory. /// </summary> public void EndHandle() { //disable watcher this.m_dirWatcher.EnableRaisingEvents = false; //raising DirectoryClose event DirectoryCloseEventArgs args = new DirectoryCloseEventArgs(this.m_path, "closing directory: " + this.m_path); DirectoryClose?.Invoke(this, args); }
///</summary> ///the event that will be activated when service needs to be close ///// </summary> /// <param name="sender">the notifyer</param name> ///<pararm name="e">arguments of the command</param name> public void OnCloseSevice(object sender, CommandRecievedEventArgs e) { m_dirWatcher.EnableRaisingEvents = false; //ImageServer server = (ImageServer)sender; m_dirWatcher.Dispose(); m_logging.Log("Handler closed " + m_path, MessageTypeEnum.INFO); //server.CloseService -= OnCommandRecieved; DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, "message")); }
//Closing the handler, the watcher and the end of the service. public void HandlerClose() { foreach (FileSystemWatcher watcher in m_listWatchers) { watcher.EnableRaisingEvents = false; watcher.Dispose(); } DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, "dir " + m_path + " directory closed")); }
/// <summary> /// Stop handling the given dir. /// </summary> public void StopHandleDirectory() { // Stop handling the directory and make sure FileSystemWatcher isn't watching anymore var stopDirectoryMessage = "Stopped handling folder:" + _pathToDir; var closeEventArgs = new DirectoryCloseEventArgs(_pathToDir, stopDirectoryMessage); DirectoryClose?.Invoke(this, closeEventArgs); _watchers.Clear(); // Log it to the logger _logger.Log("Stopped handling the directory " + _pathToDir, MessageTypeEnum.INFO); }
/// <summary> /// Ends the handler. /// </summary> private void EndHandler() { m_dirWatcher.EnableRaisingEvents = false; m_dirWatcher.Created -= new FileSystemEventHandler(Create); m_dirWatcher.Changed -= new FileSystemEventHandler(Create); DirectoryCloseEventArgs d = new DirectoryCloseEventArgs(m_path, "Closing directory" + m_path); DirectoryClose?.Invoke(this, d); }
// The Event that will be activated upon new Command public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) { if (e.RequestDirPath == this.m_path) { if (e.CommandID == (int)CommandEnum.CloseCommand) { OnCloseHandlerCommand(); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(this.m_path, "Closing Handler")); this.m_logging.Log("Closing handler for folder:" + this.m_path, MessageTypeEnum.INFO); } } }
/// <summary> /// Close file watcher (called before service ends /// or if for some reason we need to close the listening it beforehand). /// </summary> /// <param name="source"></param> /// <param name="args"></param> public void CloseFileWatcher(object source, DirectoryCloseEventArgs args) { if (args.DirectoryPath.Equals(this.directoryPath) || args.DirectoryPath.Equals("*")) { // set watchers' raising event status to false foreach (FileSystemWatcher fileSystemWatcher in this.directoryWatchers) { fileSystemWatcher.EnableRaisingEvents = false; } this.loggingService.Log(this, new MessageRecievedEventArgs(MessageTypeEnum.INFO, "Closing directory " + this.directoryPath)); DirectoryClose.Invoke(this, new DirectoryCloseEventArgs(this.directoryPath, "Received handler-closing message")); } }
/// <summary> /// close this directory handler close FileSystemWatcher and invoke the DirectoryClose event . /// </summary> public void CloseHandle() { try { m_dirWatcher.EnableRaisingEvents = false; m_dirWatcher.Created -= new FileSystemEventHandler(OnCreated); DirectoryCloseEventArgs closeEventArgs = new DirectoryCloseEventArgs(m_path, "closing directory" + m_path); // we invoke to the server that it will know this directory was clossed: CommandRecieved -= this.OnCommandRecieved; DirectoryClose?.Invoke(this, closeEventArgs); } catch (Exception e) { m_logging.Log("couldnt close handler" + m_path + " " + e.Message, MessageTypeEnum.FAIL); } }
/// <summary> /// Closes the handler and commit to logger. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="DirectoryCloseEventArgs"/> instance containing the event data.</param> public void CloseHandler(object sender, DirectoryCloseEventArgs e) { try { m_dirWatcher.EnableRaisingEvents = false; DirectoryCloseEventArgs directoryCloseArgs = new DirectoryCloseEventArgs(m_path, "Closing handler for: " + m_path); DirectoryClose?.Invoke(this, directoryCloseArgs); m_logging.Log("Closing handler for: " + m_path, MessageTypeEnum.INFO); } catch (Exception e1) { m_logging.Log("Failed to closed handler for: " + m_path, MessageTypeEnum.INFO); } finally { m_dirWatcher.Created -= new FileSystemEventHandler(NewEvent); } }
public void OnCloseHandler(object sender, DirectoryCloseEventArgs e) { try { this.m_watcher.EnableRaisingEvents = false; Watcher.Created -= new FileSystemEventHandler(OnCreated); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(direcPath, "Directory " + this.direcPath + " closed")); } catch (Exception ex) { this.m_logging.Log("Error closing the handler: " + this.direcPath + "due to " + ex.Message, MessageTypeEnum.FAIL); } }
/// <summary> /// Called when [command recieved]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="CommandRecievedEventArgs"/> instance containing the event data.</param> public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) { //debug.write("on command recived"); bool result; string message = m_controller.ExecuteCommand(e.CommandID, e.Args, out result); m_logging.Log(message, MessageTypeEnum.INFO); if ((string.Compare(message, "closeDirectory") == 0) || ((string.Compare(m_path, e.RequestDirPath) == 0))) { DirectoryCloseEventArgs close = new DirectoryCloseEventArgs(m_path, "directory has been closed"); DirectoryClose.Invoke(this, close); } //return message; }
/// <summary> /// Stops listening for changes in the file, closes the handler. /// Param: Object sender, CommandRecievedArgs args. /// </summary> void CloseHandler(object sender, CommandRecievedEventArgs args) { DirectoryCloseEventArgs eventArgs; try { m_dirWatcher.EnableRaisingEvents = false; eventArgs = new DirectoryCloseEventArgs(m_path, " Handler closed"); } catch (Exception e) { eventArgs = new DirectoryCloseEventArgs(m_path, " Problem with closeing handler"); m_logging.Log(e.ToString(), Logging.Modal.MessageTypeEnum.FAIL); } DirectoryClose?.Invoke(this, eventArgs); }
/// <summary> /// Handles the <see cref="E:CommandReceived" /> event. /// </summary> /// <param name="sender">The object which gave the command (the server).</param> /// <param name="e">The <see cref="CommandReceivedEventArgs"/> instance containing the event data.</param> public void OnCommandReceived(object sender, CommandReceivedEventArgs e) { // if the command is to close all handlers, or this particular one if (e.CommandID == 1 || (e.CommandID == 2 && e.RequestDirPath == m_path)) { DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, "closed handler")); m_dirWatcher.Dispose(); m_logging.Log("closing handler for " + m_path, MessageTypeEnum.INFO); } else { //empty for now, since only close commands can come from server } }
/// <summary> /// Raises the Close event. /// </summary> public void OnClose() { try { this.m_dirWatcher.EnableRaisingEvents = false; // this.m_dirWatcher.Created -= new FileSystemEventHandler(OnCreated); m_dirWatcher.Dispose(); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, "close handler at path " + m_path)); this.m_logging.Log("handler of " + this.m_path + " was closed", MessageTypeEnum.INFO); } catch (Exception exception) { this.m_logging.Log(exception.Data.ToString(), MessageTypeEnum.FAIL); } }
/// <summary> /// Stops the listening to the directory. invokes the DirectoryClose event and informs /// the ILogging. /// </summary> /// <param name="e"> the arguments for the event </param> void OnClose(DirectoryCloseEventArgs args) { try { if (path == args.DirectoryPath) { stopWatching(args); removeFromAppConfig(args.DirectoryPath); DirectoryClose?.Invoke(this, args); } } catch (Exception e) { logger.Log(e.Message, MessageTypeEnum.FAIL); } }
/// <summary> /// OnCommandRecieved of this handler actually tells the server that this handler is being closed /// and when the last handler is closed the server can finally stop. /// </summary> /// <param name="sender"> sender </param> /// <param name="e"> CommandRecievedEventArgs </param> public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) { switch (e.CommandID) { case (int)CommandEnum.CloseHandlerCommand: this.m_logging.Log("closing Directory Handler of directory in path: " + this.m_path, MessageTypeEnum.INFO); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(this.m_path, "closing")); for (int i = 0; i < 4; i++) { this.m_dirWatchers[i].Dispose(); } break; default: throw new ArgumentException(); } }
/// <summary> /// closing the handler - closing m_dirWatcher & invoking DirectoryClose event. /// </summary> public void CloseHandler() { try { m_dirWatcher.EnableRaisingEvents = false; m_dirWatcher.Changed -= OnChanged; m_dirWatcher.Created -= OnChanged; m_dirWatcher.Deleted -= OnChanged; m_dirWatcher.Dispose(); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, Messages.ClosedHandlerSuccessfully(m_path))); m_logging.Log(Messages.ClosedHandlerSuccessfully(m_path), MessageTypeEnum.INFO); } catch (Exception e) { m_logging.Log(Messages.FailedClosingHandler(e.Message), MessageTypeEnum.FAIL); } }
public event EventHandler <DirectoryCloseEventArgs> DirectoryClose; // The Event That Notifies that the Directory is being closed /// <summary> /// method handling commands being sent to the directory handler object /// </summary> /// <param name="sender">the sender of the command</param> /// <param name="e">arguments and info of the sent command</param> public void OnCommandRecieved(object sender, CommandRecievedEventArgs e) { m_logging.Log("In directory handler received command with id: " + e.CommandID, MessageTypeEnum.INFO); //right now with switch case because its a general command and not only close switch (e.CommandID) { //close command case CommandEnum.CloseCommand: this.CloseDirectory(); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(this.m_path, "closing")); break; default: throw new ArgumentException(); } }
/// <summary> /// This function is called when an image is created /// it reports to the log and executes the command /// in the controller /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OnCreated(object sender, FileSystemEventArgs e) { string[] args = { e.FullPath }; bool result; string res; res = m_controller.ExecuteCommand((int)CommandEnum.NewFileCommand, args, out result); // if command was unsuccessful if (!result) { m_logging.Log(DateTime.Now.ToString() + " " + res, MessageTypeEnum.FAIL); DirectoryClose?.Invoke(this, new DirectoryCloseEventArgs(m_path, res)); CloseHandler(); return; } m_logging.Log(DateTime.Now.ToString() + " Image Created: " + res, MessageTypeEnum.INFO); }