/// <summary>
/// Download file method
/// <param name="item">SyncQueueItem to download</param>
/// </summary>
public void DownloadFile(SyncQueueItem item)
{
try
{
_semaphoreDown.Wait();
var request = createRequest(combine(_host, item.Name), WebRequestMethods.Ftp.DownloadFile);
byte[] buffer = new byte[_bufferSize];
using (var response = (FtpWebResponse)request.GetResponse())
using (var stream = response.GetResponseStream())
using (var fs = new FileStream(combine(_dir, item.Name), FileMode.OpenOrCreate))
{
int readCount = stream.Read(buffer, 0, _bufferSize);
while (readCount > 0)
{
fs.Write(buffer, 0, readCount);
readCount = stream.Read(buffer, 0, _bufferSize);
}
//return response.StatusDescription;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
_semaphoreDown.Release();
}
}
/// <summary>
/// Upload file method
/// <param name="item">SyncQueueItem to Uplaod</param>
/// </summary>
public void UploadFile(SyncQueueItem item)
{
try
{
_semaphoreUp.Wait();
var request = createRequest(combine(_host, item.Name), WebRequestMethods.Ftp.UploadFile);
using (var stream = request.GetRequestStream())
using (var fileStream = File.Open(combine(_dir, item.Name), FileMode.Open))
{
int num;
byte[] buffer = new byte[_bufferSize];
while ((num = fileStream.Read(buffer, 0, buffer.Length)) > 0)
{
stream.Write(buffer, 0, num);
}
}
UploadHashFile(item);
//return getStatusDescription(request);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
_semaphoreUp.Release();
}
}
/// <summary>
/// Rename item handling
/// </summary>
private void OnRenamed(object source, RenamedEventArgs e)
{
// Check if file has allowed name
if (!FileHelper.IsAllowedFilename(e.Name))
{
return;
}
// Find if renamed from/to temporary file
var renamedFromTempFile = new FileInfo(e.OldFullPath).Attributes.HasFlag(FileAttributes.Temporary);
var renamedToTempFile = new FileInfo(e.FullPath).Attributes.HasFlag(FileAttributes.Temporary);
// Add to queue if not temporary file
if (!renamedFromTempFile || renamedToTempFile)
{
return;
}
var toSync = new SyncQueueItem
{
Name = e.Name,
OldName = e.OldName,
FullPath = e.FullPath,
OldFullPath = e.OldFullPath,
ChangeType = WatcherChangeTypes.Renamed,
Md5 = MyMd5.CalcMd5(e.FullPath),
SyncTo = ToSync.ToFtp
};
SyncQueue.Add(toSync, false);
//else
// AddToQueue(e, WatcherChangeTypes.Changed);
}
/// <summary>
/// Change event handling
/// </summary>
private void OnChanged(object source, FileSystemEventArgs e)
{
// Check if there is file and directory else return
if ((!File.Exists(e.FullPath) && !Directory.Exists(e.FullPath)))
{
return;
}
// Check if file has allowed name
if (!FileHelper.IsAllowedFilename(e.Name))
{
return;
}
var retries = 0;
if (File.Exists(e.FullPath))
{
// avoid queuing the same file multiple times
while (true)
{
// Check if file is used
if (!FileHelper.FileIsUsed(e.FullPath))
{
break;
}
// Exit after 5 retries
if (retries > 5)
{
return;
}
// Sleep for a 10th of a second, then check again
Thread.Sleep(100);
retries++;
}
}
// Add to queue
var actionType = e.ChangeType == WatcherChangeTypes.Changed ? WatcherChangeTypes.Changed : WatcherChangeTypes.Created;
var toSync = new SyncQueueItem
{
Name = e.Name,
FullPath = e.FullPath,
ChangeType = actionType,
Md5 = MyMd5.CalcMd5(e.FullPath),
SyncTo = ToSync.ToFtp
};
SyncQueue.Add(toSync, false);
}
/// <summary>
/// Creates structure of hash file, xml structure
/// <param name="item">Item to create hash structure to</param>
/// </summary>
public XElement CreateHashFile(SyncQueueItem item)
{
var result = new XElement("File");
try
{
result = new XElement("File", new XAttribute("FileName", item.Name),
new XAttribute("AddedOn", item.AddedOn.ToString()), new XAttribute("MD5", item.Md5));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(result);
}
/// <summary>
/// Delete file method
/// <param name="item">SyncQueueItem to delete</param>
/// </summary>
public string DeleteFile(SyncQueueItem item)
{
try
{
var request = createRequest(combine(_host, item.Name), WebRequestMethods.Ftp.DeleteFile);
DeleteHashFile(item.Name);
return(getStatusDescription(request));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
/// <summary>
/// Uploads hash file
/// <param name="item">Item to uploade hash file to</param>
/// </summary>
public void UploadHashFile(SyncQueueItem item)
{
try
{
var request = createRequest(combine(_host, GetHashFileName(item.Name)), WebRequestMethods.Ftp.UploadFile);
using (var s = request.GetRequestStream())
{
this.CreateHashFile(item).Save(s);
}
getStatusDescription(request);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Calls method according to item properties (if file should be uploaded to ftp, it will be..)
/// <param name="item">Item to process</param>
/// <param name="ftpClient">Client to process</param>
/// </summary>
public void Process(SyncQueueItem item, FtpClient ftpClient)
{
switch (item.ChangeType)
{
case WatcherChangeTypes.Deleted:
DeleteItem(item, ftpClient);
break;
case WatcherChangeTypes.Renamed:
RenameItem(item, ftpClient);
break;
case WatcherChangeTypes.Changed:
case WatcherChangeTypes.Created:
ChangeItem(item, ftpClient);
break;
}
}
/// <summary>
/// Renames name of hash file
/// <param name="item">Item to rename</param>
/// </summary>
public string RenameHashFile(SyncQueueItem item)
{
var result = "";
try
{
var request = createRequest(combine(_host, GetHashFileName(item.OldName)), WebRequestMethods.Ftp.Rename);
request.RenameTo = GetHashFileName(item.Name);
result = getStatusDescription(request);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(result);
}
/// <summary>
/// Handle files when indexing, not invoked by any event
/// <param name="item">Item to process</param>
/// <param name="ftpClient">Client to process</param>
/// </summary>
public void ProcessIndexing(SyncQueueItem item, FtpClient ftpClient)
{
switch (item.SyncTo)
{
case ToSync.ToFtp:
Task.Run(() => { ftpClient.UploadFile(item); });
break;
case ToSync.ToLocal:
Task.Run(() => { ftpClient.DownloadFile(item); });
break;
case ToSync.IsIdentical:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Ads item to queue
/// <param name="item">Item to add</param>
/// <param name="indexing">True if indexing, false if not</param>
/// </summary>
public void Add(SyncQueueItem item, bool indexing)
{
item.AddedOn = DateTime.Now;
_syncQueue.Enqueue(item);
StartQueue(indexing);
}
/// <summary>
/// Handles file change event and executes ftp client task for specific item
/// <param name="item">Item to process</param>
/// <param name="ftpClient">Client to process</param>
/// </summary>
public void ChangeItem(SyncQueueItem item, FtpClient ftpClient)
{
Task.Run(() => { ftpClient.UploadFile(item); });
}
/// <summary>
/// Handles file delete event and executes ftp client task for specific item
/// <param name="item">Item to process</param>
/// <param name="ftpClient">Client to process</param>
/// </summary>
public void DeleteItem(SyncQueueItem item, FtpClient ftpClient)
{
Task.Run(() => { ftpClient.DeleteFile(item); });
}
/// <summary>
/// Handles file rename event and executes ftp client task for specific item
/// <param name="item">Item to process</param>
/// <param name="ftpClient">Client to process</param>
/// </summary>
public void RenameItem(SyncQueueItem item, FtpClient ftpClient)
{
Task.Run(() => { ftpClient.Rename(item); });
}
