//
//
/// <summary>
/// Requests that the current drop file be copied to specified directory/filename.
/// (If either of these strings are string.Empty, then the current value is used;
/// that is, if you want to save the current drop file named, say, "Drop.txt" into a directory
/// called "C:\\Archive\\" with the same file name, call with arguments ("C:\\Archive\\",string.Empty)
/// </summary>
/// <param name="targetPath">Archival directory path (with trailing "\\")</param>
/// <param name="targetFileName">Archival file name.</param>
/// <returns></returns>
public bool RequestCopyTo(string targetPath, string targetFileName)
{
DropQueueWriterEventArgs eventArgs = GetRequest(DropQueueWriterRequestType.CopyTo);
eventArgs.Message.Append(targetFileName);
eventArgs.Message2.Append(targetPath);
return(this.HubEventEnqueue(eventArgs));
}
}// ProcessCopyAllFiles()
//
//
// *********************************************************************
// **** Process MoveTo() ****
// *********************************************************************
private void ProcessMoveTo(DropQueueWriterEventArgs eventArgs)
{
string currentFilePath = string.Format("{0}{1}", m_PathName, m_FileName);
// Set target path
string targetPath;
if (eventArgs.Message2.Length == 0) //string.IsNullOrEmpty(eventArgs.Message2))
{
targetPath = m_PathName; // keep original path.
}
else if (eventArgs.Message2[eventArgs.Message2.Length - 1].Equals('\\'))
{
targetPath = eventArgs.Message2.ToString(); // user provided a target path
}
else
{
targetPath = string.Format("{0}\\", eventArgs.Message2);
}
// Set target file name.
string targetFileName;
if (eventArgs.Message.Length == 0) //string.IsNullOrEmpty(eventArgs.Message))
{
targetFileName = m_FileName; // Keep original filename
}
else
{
targetFileName = eventArgs.Message.ToString(); // User provided filename also.
}
// Move the file now.
try
{
// Create directory
if (!System.IO.Directory.Exists(targetPath))
{
System.IO.Directory.CreateDirectory(targetPath);
}
// Move file
string outFilePath = string.Format("{0}{1}", targetPath, targetFileName);
if (System.IO.File.Exists(currentFilePath))
{
if (System.IO.File.Exists(outFilePath))
{
System.IO.File.Delete(outFilePath); // delete any existing file in backup output area
}
System.IO.File.Move(currentFilePath, outFilePath); // stick current file there - for recovery purposes.
}
}
catch (Exception e)
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{1}: ProcessMoveTo failed. Exception: {0}", e.Message, this.m_HubName);
}
}
// Exit.
m_Factory.Recycle(eventArgs);
}//ProcessMoveFile()
//
//
#endregion//Properties
#region Public Methods
// *****************************************************************
// **** Public Methods ****
// *****************************************************************
// Note: All these public methods, are assumed to be called by an outside thread.
//
//
/// <summary>
/// Users call this function to push a line to write onto queue.
/// Note that the order that requests are received, they are processed.
/// </summary>
/// <param name="aLineToWrite"></param>
/// <returns></returns>
public bool RequestEnqueue(string aLineToWrite)
{
if (base.ListenState == WaitListenState.Stopping)
{
return(false); // Queue no longer accepting new requests.
}
DropQueueWriterEventArgs eventArgs = GetRequest(DropQueueWriterRequestType.WriteLine);
eventArgs.Message.Append(aLineToWrite);
this.HubEventEnqueue(eventArgs); // doing it this way gives more work to hub thread, but maintains the ordering of all tasks.
return(true);
}// RequestEnqueue()
} // IsDirectoryExists
//
//
//
#endregion // private methods
#region HubEventHandler and Processing
// *********************************************************
// **** Hub Event Handler() ****
// *********************************************************
protected override void HubEventHandler(EventArgs[] eventArgList)
{
foreach (EventArgs eventArg in eventArgList)
{
Type eventType = eventArg.GetType();
if (eventType == typeof(DropQueueWriterEventArgs))
{
DropQueueWriterEventArgs e = (DropQueueWriterEventArgs)eventArg;
switch (e.Request)
{
case DropQueueWriterRequestType.WriteLine:
m_WriteQueue.Enqueue(e); // Store the entire eventArg containing message in queue (easier to recycle later).
break;
case DropQueueWriterRequestType.Stop:
ProcessFlushNow();
base.Stop();
break;
case DropQueueWriterRequestType.FlushNow:
ProcessFlushNow();
break;
case DropQueueWriterRequestType.CopyTo:
ProcessCopyTo(e);
break;
case DropQueueWriterRequestType.CopyAllFiles:
ProcessCopyAllFiles(e);
break;
case DropQueueWriterRequestType.MoveTo:
ProcessMoveTo(e);
break;
case DropQueueWriterRequestType.ChangeFileName:
ProcessTargetFileChange(e);
break;
default:
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{0}: Unknown request {1}.", this.m_HubName, e.Request);
}
break;
}//switch()
}
}
}// HubEventHandler()
}//ProcessMoveFile()
//
//
//
//
// *****************************************************************************
// **** Process Target File Change() ****
// *****************************************************************************
private void ProcessTargetFileChange(DropQueueWriterEventArgs eventArgs)
{
// Flush the buffer, before we change the output target.
if (m_WriteQueue.Count > 0)
{
ProcessFlushNow();
}
try
{
// Change target dir
if (eventArgs.Message2.Length > 0) //(!string. IsNullOrEmpty(eventArgs.Message2))
{ // User wants to change target directory.
if (IsDirectoryExists(eventArgs.Message2.ToString()))
{
m_PathName = eventArgs.Message2.ToString(); // todo: confirm the trailing \\
}
else if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{1}: Failed to created new directory {0}", eventArgs.Message2, this.m_HubName);
}
}
if (eventArgs.Message.Length > 0)//(!string.IsNullOrEmpty(eventArgs.Message))
{
m_FileName = eventArgs.Message.ToString();
}
// Check if file exists
string filePath = string.Format("{0}{1}", m_PathName, m_FileName);
if (!this.AppendToDropFile && System.IO.File.Exists(filePath))
{
if (Log != null)
{
Log.NewEntry(LogLevel.Minor, "{1}: Deleting pre-existing drop file {0}", filePath, this.m_HubName);
}
System.IO.File.Delete(filePath);
}
}
catch (Exception e)
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{1}: ProcessTargetFileChange failed. Exception: {0}", e.Message, this.m_HubName);
}
}
// Exit
m_Factory.Recycle(eventArgs);
} // ProcessTargetFileChange()
}// ProcessCopyTo()
//
//
//
/// <summary>
/// Copies all files in the local Path (that match a given filename pattern) to
/// another path.
/// </summary>
/// <param name="eventArgs"></param>
private void ProcessCopyAllFiles(DropQueueWriterEventArgs eventArgs)
{
// Create name for archival file.
string archiveDirPath;
if (eventArgs.Message2.Length == 0)
{
m_Factory.Recycle(eventArgs);
return; // User must provide a target DirPath!
}
else
{
if (eventArgs.Message2[eventArgs.Message2.Length - 1].Equals('\\')) // .EndsWith("\\"))
{
archiveDirPath = eventArgs.Message2.ToString(); // user provided a target path
}
else
{
archiveDirPath = string.Format("{0}\\", eventArgs.Message2);
}
}
try
{
if (!IsDirectoryExists(archiveDirPath)) // Confirm target directory exists.
{ // Cannot find/create target directory.
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{1}: Failed to copy all files to {0}. Failed to find/create that directory.", archiveDirPath, this.m_HubName);
}
m_Factory.Recycle(eventArgs);
return; // nothing we can do but quit.
}
// Get Local filenames to copy.
List <string> fileNamesWeCopied = new List <string>();
string[] localFileNameArray;
if (eventArgs.Message.Length > 0) // pattern provided in ".FileName" property
{
localFileNameArray = System.IO.Directory.GetFiles(this.m_PathName, eventArgs.Message.ToString());
}
else
{
localFileNameArray = System.IO.Directory.GetFiles(this.m_PathName);// no pattern provided.
}
foreach (string s in localFileNameArray)
{
string fileName = s.Substring(s.LastIndexOf('\\') + 1); // local file name.
string archiveFilePath = string.Format("{0}{1}", archiveDirPath, fileName); // archive file path
try
{
if (System.IO.File.Exists(archiveFilePath))
{ // This file already exists in the output directory.
System.IO.FileInfo infoRemote = new System.IO.FileInfo(archiveFilePath);
System.IO.FileInfo infoLocal = new System.IO.FileInfo(s);
if (infoLocal.Length > infoRemote.Length)
{ // The local file is bigger, so we better do the copy!
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{1}.ProcessCopyAllFiles: Local copy of {0} is larger than remote, so we will copy to remote.", fileName, this.m_HubName);
}
System.IO.File.Copy(s, archiveFilePath, true);
fileNamesWeCopied.Add(fileName);
}
}
else
{ // File doesn't already exist, so just copy it.
System.IO.File.Copy(s, archiveFilePath, true);
fileNamesWeCopied.Add(fileName);
}
}
catch (Exception e)
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{1}.ProcessCopyAllFiles: Failed to copy file to {0}. Exception {2}.", archiveDirPath, this.m_HubName, e.Message);
}
}
}
// Report our results
if (Log != null && Log.BeginEntry(LogLevel.Minor))
{
Log.AppendEntry("{1}.ProcessCopyAllFiles: Copied {0} files [", fileNamesWeCopied.Count, this.m_HubName);
foreach (string s in fileNamesWeCopied)
{
Log.AppendEntry(" {0}", s);
}
Log.AppendEntry("].");
Log.EndEntry();
}
}
catch (Exception e)
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{2}: Copying all files from {0} to {1} failed. Exception: {2}", this.FilePath, archiveDirPath, e.Message, this.m_HubName);
}
}
// Exit
m_Factory.Recycle(eventArgs);
}// ProcessCopyAllFiles()
}// ProcessWriteNow().
//
//
// *********************************************************************
// **** Process CopyTo() ****
// *********************************************************************
/// <summary>
///
/// </summary>
private void ProcessCopyTo(DropQueueWriterEventArgs eventArgs)
{
// Create name for archival file.
string archiveDirPath;
string archivalFileName;
if (eventArgs.Message2.Length == 0) // Check if user didn't provided path to copy file to
{
archiveDirPath = m_PathName; // keep the same old path, then.
}
else
{ // User copying to new dir.
if (eventArgs.Message2[eventArgs.Message2.Length - 1].Equals('\\'))
{
archiveDirPath = eventArgs.Message2.ToString();
}
else
{
eventArgs.Message2.Append("\\");
archiveDirPath = eventArgs.Message2.ToString();
}
}
if (eventArgs.Message.Length == 0) // If no fileName supplied, keep the current filename. //(string.IsNullOrEmpty(eventArgs.Message))
{
archivalFileName = m_FileName;
}
else
{
archivalFileName = eventArgs.Message.ToString();
}
// Confirm target directory exists.
if (!IsDirectoryExists(archiveDirPath))
{
if (Log != null) // Cannot find/create target directory. Just fail quietly.
{
Log.NewEntry(LogLevel.Major, "{1}: Failed to copying drop to {0}.", archiveDirPath, this.m_HubName);
}
}
else
{
// Copy current file to archival location.
string currentFilePath = this.FilePath;
if (System.IO.File.Exists(currentFilePath))
{
string archiveFilePath = string.Format("{0}{1}", archiveDirPath, archivalFileName);
try
{
if (System.IO.File.Exists(archiveFilePath))
{
System.IO.FileInfo fileInfoArchive = new System.IO.FileInfo(archiveFilePath);
System.IO.FileInfo fileInfoCurrent = new System.IO.FileInfo(currentFilePath);
if (fileInfoCurrent.Length > fileInfoArchive.Length)
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "DropQueueWriter: Copying drop to archive directory {0}.", archiveFilePath);
}
System.IO.File.Copy(currentFilePath, archiveFilePath, true);
}
else if (Log != null)
{
Log.NewEntry(LogLevel.Major, "DropQueueWriter: File in archival area seems bigger, will not over-write it!");
}
}
else
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "DropQueueWriter: Copying drop to archive directory {0}.", archiveFilePath);
}
System.IO.File.Copy(currentFilePath, archiveFilePath, true);
}
Log.NewEntry(LogLevel.Major, "DropQueueWriter: Copying drop successfully to {0}.", archiveFilePath);
}
catch (Exception ex)
{
if (Log != null)
{
Log.NewEntry(LogLevel.Major, "{2}: Failed to move drop to archive directory {0}. {1}", archiveFilePath, ex.Message, this.m_HubName);
}
}
}
else if (Log != null)
{
Log.NewEntry(LogLevel.Major, "DropQueueWriter.ProcessCopyTo: File to copy does not exist {0}.", currentFilePath);
}
}// if archiveDirPath exists
// Exit.
m_Factory.Recycle(eventArgs);
}// ProcessCopyTo()