/************************************************************************
* The Input: sender and an event.
* The Output: -
* The Function operation: The function is called when the handler is closed.
*************************************************************************/
public void OnHandlerClose(object sender, DirectoryCloseEventArgs e)
{
IDirectoryHandler dirHandler = (IDirectoryHandler)sender;
CommandReceived -= dirHandler.OnCommandRecieved;
m_logging.Log("Stop handle directory " + e.Message, Logging.Modal.MessageTypeEnum.INFO);
}
/// <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);
}
}
}
}
/// <summary>
/// Delegate Commad, send the clients which directory was closed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void SendCloseHandler(object sender, DirectoryCloseEventArgs e)
{
JObject closeObj = new JObject
{
["CommandEnum"] = (int)CommandEnum.CloseCommand,
["Directory"] = e.DirectoryPath
};
string message = closeObj.ToString();
int size = activeClients.Count;
for (int i = 0; i < size; i++)
{
try
{
{
activeClients[i].Item4.Write(message);
}
}
catch
{
activeClients[i].Item2.Close();
activeClients.Remove(activeClients[i]);
}
}
}
/// <summary>
/// close specific handler
/// </summary>
/// <param name="sender"> the object calling to this function </param>
/// <param name="eventArgs"> the event args of closing a handler </param>
private void CloseHandler(object sender, DirectoryCloseEventArgs eventArgs)
{
IDirectoryHandler dirHandler = (IDirectoryHandler)sender;
CommandRecieved -= dirHandler.OnCommandRecieved;
dirHandler.DirectoryClose -= CloseHandler;
}
/// <summary>
/// Raises the Close event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="DirectoryCloseEventArgs" /> instance containing the event data.</param>
public void OnClose(object sender, DirectoryCloseEventArgs e)
{
this.logging.Log("in on close of server", MessageTypeEnum.INFO);
//
this.CommandRecieved?.Invoke(this, new CommandRecievedEventArgs((int)CommandEnum.CloseCommand, null, null));
this.logging.Log("after closing handlers", MessageTypeEnum.INFO);
}
/**
* the function close server after call to the close
*/
public void closeServer(object sender, DirectoryCloseEventArgs e)
{
IDirectoryHandler h = (IDirectoryHandler)sender;
CommandRecieved -= h.OnCommandRecieved;
m_logging.Log("close service: " + e.Message, MessageTypeEnum.INFO);
}
/// <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 is a method for stopping a handler.
/// </summary>
/// <param name="sender">Raising object</param>
/// <param name="eventArgs">Event arguments</param>
private void StopHandler(object sender, DirectoryCloseEventArgs eventArgs)
{
var handler = (IDirectoryHandler)sender;
// Stop the handler:
CommandRecieved -= handler.OnCommandRecieved;
}
/// <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 stops the handling of a specific directiory
/// </summary>
/// <param name= sender> the object that sent the request </param>
/// <param name= e> the event that occured </param>
public void CloseHandler(object sender, DirectoryCloseEventArgs e)
{
List <IDirectoryHandler> list = getHandlers();
foreach (IDirectoryHandler handler in list)
{
if (e.DirectoryPath.Equals("*") || handler.GetPath().Equals(e.DirectoryPath))
{
this.CommandRecieved -= handler.OnCommandRecieved;
this.logging.Log("Closing handler for " + e.DirectoryPath, MessageTypeEnum.INFO);
handler.DirectoryClose -= CloseHandler;
// delete handler
handler.StopHandleDirectory(e.DirectoryPath);
this.logging.Log("Closed handler for " + e.DirectoryPath, MessageTypeEnum.INFO);
string path = e.DirectoryPath;
string[] args = { path };
// create info args
InfoEventArgs info = new InfoEventArgs((int)InfoEnums.CloseHandlerInfo, args);
// remove the handler from the app config handler list
ServiceInfo serviceInfo = ServiceInfo.CreateServiceInfo();
serviceInfo.RemoveHandler(e.DirectoryPath);
// notify all of the clients that the handler was closed
NotifyClients?.Invoke(this, info);
}
}
}
/// <summary>
/// removeHandler.
/// remove handler from CommandRecieved event.
/// </summary>
/// <param name="source">source</param>
/// <param name="args">arguments</param>
public void removeHandler(object source, DirectoryCloseEventArgs args)
{
IDirectoryHandler toRemove = (IDirectoryHandler)source;
this.CommandRecieved -= toRemove.OnCommandRecieved;
this.m_logging.Log(args.Message, MessageTypeEnum.INFO);
this.m_logging.Log("Handler closed", MessageTypeEnum.INFO);
}
/// <summary>
/// This function is called when the Handler is closed.
/// </summary>
/// <param name="sender"> The Hendler that was closed</param>
/// <param name="args"></param>
public void OnDirctoryClose(object sender, DirectoryCloseEventArgs args)
{
this.m_logging.Log("Close hendler", MessageTypeEnum.INFO);
IDirectoyHandler handler = (IDirectoyHandler)sender;
CommandRecieved -= handler.OnCommandRecieved;
appConfigManager.Instance.clickRemove -= handler.OnRemove;
}
/// <summary>
/// Deletes the handler.
/// </summary>
/// <param name="sender"> Sender. </param>
/// <param name="e"> Event. </param>
public void DeleteHandler(object sender, DirectoryCloseEventArgs e)
{
IDirectoryHandler handler = (IDirectoryHandler)sender;
CommandRecieved -= handler.OnCommandRecieved;
handler.DirectoryClose -= DeleteHandler;
m_logging.Log(e.Message + "directory is closed", Logging.Modal.MessageTypeEnum.INFO);
}
/// <summary>
/// close specific handler
/// </summary>
/// <param name="sender"> the object calling to this function </param>
/// <param name="eventArgs"> the event args of closing a handler </param>
private void CloseHandler(object sender, DirectoryCloseEventArgs eventArgs)
{
IDirectoryHandler dirHandler = (IDirectoryHandler)sender;
CommandRecieved -= dirHandler.OnCommandRecieved;
dirHandler.DirectoryClose -= CloseHandler;
AppConfig.Instance.Folders.Remove(eventArgs.DirectoryPath);
}
/// <summary>
/// The function inform the server that a handler is done handle the dir.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void closeServer(object sender, DirectoryCloseEventArgs args)
{
_mLogging.Log(args.Message, MessageTypeEnum.INFO);
IDirectoryHandler handler = (IDirectoryHandler)sender;
CommandRecieved -= handler.OnCommandRecieved;
handler.DirectoryClose -= closeServer;
}
/// <summary>
/// this method remove handler.
/// </summary>
/// <param name="source">object that send the event</param>
/// <param name="e">args for the event</param>
public void RemoveHandler(object source, DirectoryCloseEventArgs e)
{
IDirectoryHandler handler = (IDirectoryHandler)source;
CommandRecieved -= handler.OnCommandRecieved;
handler.DirectoryClose -= RemoveHandler;
m_logging.Log(e.Message, MessageTypeEnum.INFO);
}
/// <summary>
/// Closes the server and logs the result.
/// Param: Object sender, DirectoryCloseEventArgs args.
/// </summary>
public void OnCloseServer(Object sender, DirectoryCloseEventArgs args)
{
IDirectoryHandler h = (IDirectoryHandler)sender;
CommandRecieved -= h.OnCommandRecieved;
h.DirectoryClose -= OnCloseServer;
m_logging.Log(args.DirectoryPath + args.Message, Logging.Modal.MessageTypeEnum.INFO);
}
/// <summary>
/// Closing the server - handler will call this function to tell server it closed.
/// </summary>
/// <param name="sender"> Handler as sender. </param>
/// <param name="e"> Information on the handler - dir and a message. </param>
public void OnCloseServer(object sender, DirectoryCloseEventArgs e)
{
DirectoyHandler dh = (DirectoyHandler)sender;
CommandRecieved -= dh.OnCommandRecieved;
dh.DirectoryClose -= OnCloseServer;
CloseCommand -= dh.OnClose;
}
/// <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();
}
//informs the server that the handler has been closed
public void OnCloseServer(object sender, DirectoryCloseEventArgs e)
{
IDirectoryHandler closeHandler = (IDirectoryHandler)sender;
this.CommandRecieved -= closeHandler.OnCommandRecieved; //removes the delegate of the current closed handler
//informs the current handler has been closed
this.m_logging.Log("The handler that handles the directory " + e.DirectoryPath + " has been closed", Logging.Modal.MessageTypeEnum.INFO);
}
/// <summary>
/// Closes the handler.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="d">The <see cref="DirectoryCloseEventArgs"/> instance containing the close command.</param>
public void CloseHandler(object sender, DirectoryCloseEventArgs d)
{
IDirectoryHandler idh = (IDirectoryHandler)sender;
CommandReceived -= idh.OnCommandReceived;
idh.DirectoryClose -= CloseHandler;
handlersDict.Remove(d.DirectoryPath);
}
/// <summary>
/// This method is called when a directory is closing.
/// </summary>
/// <param name="sender">The command sender.</param>
/// <param name="args">The directory close event arguments.</param>
private void OnDirectoryClose(object sender, DirectoryCloseEventArgs args)
{
if (sender is IDirectoryHandler)
{
IDirectoryHandler directoryHandler = (IDirectoryHandler)sender;
CommandRecieved -= directoryHandler.OnCommandRecieved;
m_logging.Log(args.Message, MessageTypeEnum.INFO);
}
}
/// <summary>
/// When a handler is closed, he will raise a event and this function will remove it from the CommandRecieved
/// </summary>
/// <param name="sender"> who was sent the event </param>
/// <param name="d"> details about the handler </param>
private void OnCloseHandler(object sender, DirectoryCloseEventArgs d)
{
IDirectoryHandler handler = (IDirectoryHandler)sender;
CommandRecieved -= handler.OnCommandRecieved;
m_appParsing.RemoveDir(handler.DirPath);
RemoveHandlerFromClients(handler.DirPath);
m_logging.Log(d.DirectoryPath + " " + d.Message, MessageTypeEnum.INFO);
}
protected virtual void OnDirectoryClose(DirectoryCloseEventArgs e)
{
EventHandler <DirectoryCloseEventArgs> handler = DirectoryClose;
if (handler != null)
{
handler(this, e);
}
}
/// <summary>
/// Removes a handler
/// </summary>
/// <param name="object_sender">object sender</param>
/// <param name="event_arguments">event data</param>
public void RemoveHandler(object object_sender, DirectoryCloseEventArgs event_arguments)
{
DirectoryHandler dir_handler = (DirectoryHandler)object_sender;
CommandReceived -= dir_handler.OnCommandReceived;
CloseServer -= dir_handler.OnCloseHandler;
dir_handler.CloseDirectory -= RemoveHandler;
model_logging.Log("The " + event_arguments.Message + " dir was closed", MessageTypeEnum.INFO);
}
/// <summary>
/// Removes the handler.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="DirectoryCloseEventArgs"/> instance containing the event data.</param>
public void RemoveHandler(object sender, DirectoryCloseEventArgs e)
{
DirectoryHandler handler = (DirectoryHandler)sender;
CommandReceived -= handler.OnCommandReceived;
CloseServer -= handler.OnCloseHandler;
handler.DirectoryClose -= RemoveHandler;
m_logging.Log("The " + e.Message + " directory has been closed.", MessageTypeEnum.INFO);
}
/// <summary>
/// Closes the directory handler when required..
/// </summary>
/// <param name="source"></param>
/// <param name="args"></param>
public void CloseHandler(object source, DirectoryCloseEventArgs args)
{
if (source is IDirectoryHandler)
{
IDirectoryHandler handler = (IDirectoryHandler)source;
// future
//HandlerDispatchCommand -= handler.OnCommandRecieved;
}
}
/// <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>
/// Delegate to run when the handler is being closed.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void OnHandlerClose(object sender, DirectoryCloseEventArgs e)
{
IDirectoryHandler dirHandler = (IDirectoryHandler)sender;
CommandRecieved -= dirHandler.OnCommandRecieved;
this.handlers.Remove(dirHandler);
m_logging.Log("Stop handle directory " + e.Message, Logging.Model.MessageTypeEnum.INFO);
this.server.SendClose(sender, e);
}
