/// <summary>
/// Calculates MD5 hash of required resource.
///
/// Method has to run asynchronous.
/// Resource can be any of type: http page, ftp file or local file.
/// </summary>
/// <param name="resource">Uri of resource</param>
/// <returns>MD5 hash</returns>
public static async Task <string> GetMD5Async(this Uri resource)
{
Stream stream;
if (resource.Scheme == "ftp")
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(resource);
request.Method = WebRequestMethods.Ftp.DownloadFile;
FtpWebResponse response = (FtpWebResponse)await request.GetResponseAsync();
stream = response.GetResponseStream();
}
else
{
stream = await new HttpClient().GetStreamAsync(resource);
}
MD5 md5 = new MD5CryptoServiceProvider();
byte[] res = md5.ComputeHash(stream);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < res.Length; i++)
{
sb.Append(res[i].ToString("X"));
}
return(sb.ToString());
}
public async Task <ServerResponse> DownloadDataFromFtpToLocalDisk(string sourceUrl, string protocol)
{
var serverResponse = ServerResponse.OK;
try
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(sourceUrl);
request.Method = WebRequestMethods.Ftp.DownloadFile;
request.KeepAlive = true;
request.UsePassive = true;
request.UseBinary = true; // use true for .zip file or false for a text file
request.Credentials = new NetworkCredential(_appSettings.FtpNetworkCredential.UserName, _appSettings.FtpNetworkCredential.Password);
WebResponse response = await request.GetResponseAsync();
await _fileManager.GetDataFromResponseAndWriteLocalDisk(sourceUrl, response, protocol);
return(serverResponse);
}
catch (Exception ex)
{
return(new ServerResponse()
{
RespCode = 400, RespDesc = ex.Message
});
}
}
public void UploadFile(FtpWebRequest request, Stream stream)
{
Stream requestStream = null;
try
{
// Copy the contents of the file to the request stream.
requestStream = request.GetRequestStream();
byte[] fileContents = null;
using (var br = new BinaryReader(stream))
{
fileContents = br.ReadBytes((int)stream.Length);
}
requestStream.Write(fileContents, 0, fileContents.Length);
request.GetResponseAsync().ContinueWith(t =>
{
var response = t.Result as FtpWebResponse;
Sitecore.Diagnostics.Log.Info(string.Format("Sitecore FTP request sent to: {0}, Upload File Complete, status {1}", request.RequestUri.ToString(), response.StatusDescription), this);
requestStream.Close();
response.Close();
});
}
catch (Exception ex)
{
if (requestStream != null)
{
requestStream.Close();
}
Sitecore.Diagnostics.Log.Error(string.Format("Sitecore FtpClient Utility threw an error while uploading a file. Request: {0}", request.RequestUri.ToString()), ex, this);
throw ex;
}
}
public async Task CreateDirectoryAsync(string newDirectory)
{
try
{
var remoteFilePathResult = PrepareRemoteFilePath(Os.Linux, _host, newDirectory);
if (remoteFilePathResult.IsFailure)
{
return;
}
_ftpRequest = (FtpWebRequest)WebRequest.Create(remoteFilePathResult.Value);
_ftpRequest.Credentials = new NetworkCredential(_user, _pass);
_ftpRequest.UseBinary = true;
_ftpRequest.UsePassive = true;
_ftpRequest.KeepAlive = true;
_ftpRequest.Method = WebRequestMethods.Ftp.MakeDirectory;
_ftpResponse = (FtpWebResponse)await _ftpRequest.GetResponseAsync();
}
finally
{
_ftpResponse?.Close();
_ftpRequest = null;
}
}
public async Task <bool> DownloadAsync(string sourceFile, string targetFile)
{
try
{
_ftp = InitailizeFTP(sourceFile);
_ftp.Method = WebRequestMethods.Ftp.DownloadFile;
using (var ostrm = new FileStream(targetFile, FileMode.OpenOrCreate))
using (var response = (FtpWebResponse)(await _ftp.GetResponseAsync()))
using (var strm = response.GetResponseStream())
{
var bufferSize = 2048;
int readCount;
byte[] buffer = new byte[bufferSize];
readCount = strm.Read(buffer, 0, bufferSize);
while (readCount > 0)
{
ostrm.Write(buffer, 0, readCount);
readCount = strm.Read(buffer, 0, bufferSize);
}
}
return(true);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
}
public async Task DownloadFileAsync(string fileName, string localPath)
{
var buffer = new byte[2048];
FtpWebRequest request = CreateDownloadFtpRequest(RemoteUri + fileName, Port, User, Password);
using (WebResponse response = await request.GetResponseAsync())
{
Stream responseStream = response.GetResponseStream();
if (responseStream == null)
{
throw new ArgumentNullException(nameof(responseStream));
}
using (var fileStream = new FileStream(localPath + fileName, FileMode.Create))
{
while (true)
{
int bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
break;
}
await fileStream.WriteAsync(buffer, 0, bytesRead);
}
}
}
}
/* Get the Date/Time a File was Created */
public async Task <DateTime> GetLastModifiedDateOfFile(string fileName)
{
try
{
_ftpRequest = (FtpWebRequest)WebRequest.Create(_host + fileName);
_ftpRequest.Credentials = new NetworkCredential(_user, _pass);
_ftpRequest.UseBinary = true;
_ftpRequest.UsePassive = true;
_ftpRequest.KeepAlive = true;
_ftpRequest.Method = WebRequestMethods.Ftp.GetDateTimestamp;
_ftpResponse = (FtpWebResponse)await _ftpRequest.GetResponseAsync();
}
finally
{
_ftpStream?.Close();
_ftpResponse?.Close();
_ftpRequest = null;
}
if (_ftpResponse == null)
{
return(DateTime.MinValue);
}
return(_ftpResponse.LastModified);
}
/// <summary>
/// 异步下载文件
/// </summary>
/// <param name="ftpPath">ftp路径</param>
/// <param name="ftpUserId">用户名</param>
/// <param name="ftpPassword">密码</param>
/// <param name="relativeFilePath">文件相对路径</param>
public static async Task <MemoryStream> DownloadFileAsync(string ftpPath, string ftpUserId, string ftpPassword, string relativeFilePath)
{
try
{
FtpWebRequest request = null;
LogTimeUtil log = new LogTimeUtil();
request = (FtpWebRequest)WebRequest.Create(new Uri(Path.Combine(ftpPath, relativeFilePath).Replace("\\", "/")));
request.Credentials = new NetworkCredential(ftpUserId, ftpPassword);
request.Method = "RETR";
FtpWebResponse response = (FtpWebResponse)(await request.GetResponseAsync());
Stream responseStream = response.GetResponseStream();
MemoryStream stream = new MemoryStream();
byte[] bArr = new byte[1024 * 1024];
int size = await responseStream.ReadAsync(bArr, 0, (int)bArr.Length);
while (size > 0)
{
stream.Write(bArr, 0, size);
size = await responseStream.ReadAsync(bArr, 0, (int)bArr.Length);
}
stream.Seek(0, SeekOrigin.Begin);
responseStream.Close();
log.LogTime("FtpUtil.DownloadFileAsync 下载 filePath=" + relativeFilePath);
return(stream);
}
catch (Exception ex)
{
LogUtil.Error("FtpUtil.DownloadFileAsync 异步下载文件 错误");
throw ex;
}
}
/// <summary>
/// Delete file
/// </summary>
/// <param name="url">The URI.</param>
/// <returns>Returns <c>true</c> if operation is successfull; otherwise, <c>false</c>.</returns>
public async Task <bool> DeleteFileAsync(Uri url)
{
bool result = true;
try
{
FtpWebRequest request = this.CreateFtpWebRequest(url, WebRequestMethods.Ftp.DeleteFile);
using (FtpWebResponse response = (FtpWebResponse)await request.GetResponseAsync())
{
Stream data = response.GetResponseStream();
}
System.Diagnostics.Debug.WriteLine($"Deleted {url.AbsoluteUri}");
}
catch (OperationCanceledException)
{
System.Diagnostics.Debug.WriteLine("Delete file cancelled!");
result = false;
}
catch (WebException e)
{
System.Diagnostics.Debug.WriteLine($"Failed to delete {url.AbsoluteUri}");
System.Diagnostics.Debug.WriteLine(e);
result = false;
//throw;
}
return(result);
}
public async Task <bool> AuthorizeFTPConnectionsAsync()
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(Uri);
request.Method = WebRequestMethods.Ftp.ListDirectory;
request.Credentials = credentials;
request.UsePassive = true;
request.UseBinary = true;
request.KeepAlive = false;
try
{
WebResponse webResponse = await request.GetResponseAsync();
//FtpWebResponse response = (FtpWebResponse)webResponse;
return(true);
}
catch (WebException e)
{
if (e.Status == WebExceptionStatus.ProtocolError)
{
return(false);
}
else
{
return(true);
}
}
}
/// <summary>
/// Retrieve the object asynchronously.
/// </summary>
/// <param name="token">Cancellation token to cancel the request.</param>
/// <returns>Crawl result.</returns>
public async Task <CrawlResult> GetAsync(CancellationToken token = default)
{
CrawlResult ret = new CrawlResult();
try
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(SourceUrl);
request.Method = WebRequestMethods.Ftp.DownloadFile;
request.Credentials = new NetworkCredential(Username, Password);
FtpWebResponse response = (FtpWebResponse)(await request.GetResponseAsync().ConfigureAwait(false));
Stream responseStream = response.GetResponseStream();
await responseStream.CopyToAsync(ret.DataStream, _StreamBufferSize, token).ConfigureAwait(false);
ret.ContentLength = responseStream.Length;
response.Close();
ret.Success = true;
}
catch (Exception e)
{
ret.Exception = e;
}
ret.Time.End = DateTime.UtcNow;
return(ret);
}
public async Task DownloadFileAsync(string ftpFilePath)
{
try
{
_ftpRequest = (FtpWebRequest)WebRequest.Create(_host + ftpFilePath);
_ftpRequest.Credentials = new NetworkCredential(_user, _pass);
_ftpRequest.UseBinary = true;
_ftpRequest.UsePassive = true;
_ftpRequest.KeepAlive = true;
_ftpRequest.Method = WebRequestMethods.Ftp.DownloadFile;
using (_ftpResponse = (FtpWebResponse)await _ftpRequest.GetResponseAsync())
{
using (_ftpStream = _ftpResponse.GetResponseStream())
{
FileBytes = await ReadBytesAsync(_ftpResponse.GetResponseStream());
}
}
}
finally
{
_ftpStream?.Close();
_ftpResponse?.Close();
_ftpRequest = null;
}
}
public async Task <bool> Exists(string fileName, DirectoryEnum directoryEnum = DirectoryEnum.Published)
{
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(GetFilePath(fileName, directoryEnum));
request.Credentials = Credentials;
request.UseBinary = true;
request.KeepAlive = true;
request.Method = WebRequestMethods.Ftp.GetFileSize;
FtpWebResponse response = null;
try
{
response = (FtpWebResponse)(await request.GetResponseAsync());
return(true);
}
catch (WebException ex)
{
response = (FtpWebResponse)ex.Response;
if (response.StatusCode == FtpStatusCode.ActionNotTakenFileUnavailable)
{
return(false);
}
}
return(false);
}
public async Task DownLoadFileAsync(FtpTransferResult ftpResult,
CancellationTokenSource cancelltionTokenSource)
{
byte[] buffer = new byte[BUFFER_LENGTH];
FtpWebRequest request = FtpWebRequest.Create("ftp://" +
this.Ftp.Host + ":" + this.Ftp.Port + ftpResult.Info) as FtpWebRequest;
request.Credentials = new NetworkCredential(this.Ftp.UserName, this.Ftp.Password);
request.Method = WebRequestMethods.Ftp.DownloadFile;
request.Timeout = 10000;
request.ReadWriteTimeout = 10000;
using (var response = await request.GetResponseAsync() as FtpWebResponse)
using (var stream = response.GetResponseStream())
using (var filestream = new FileStream(ftpResult.Target, FileMode.CreateNew, FileAccess.Write, FileShare.None))
{
int readed = 0;
while ((readed = await stream.ReadAsync(buffer, 0, BUFFER_LENGTH)) > 0)
{
if (cancelltionTokenSource.IsCancellationRequested)
{
break;
}
await filestream.WriteAsync(buffer, 0, readed);
ftpResult.Position += readed;
ftpResult.Process = (double)ftpResult.Position / ftpResult.TotalLength * 100;
}
await filestream.FlushAsync();
}
}
public async Task <string[]> GetDirectoryContentsAsync(string relativePath)
{
string[] result = new string[] { "" };
try
{
FtpWebRequest request = GetFTPRequest(relativePath, WebRequestMethods.Ftp.ListDirectoryDetails);
using (var response = await request.GetResponseAsync())
{
TextReader reader = new StreamReader(response.GetResponseStream());
List <string> lines = new List <string>();
bool escape = false;
string line;
while (!escape)
{
line = reader.ReadLine();
escape = line == null;
if (!escape)
{
lines.Add(line);
}
}
result = lines.ToArray();
reader.Close();
}
}
catch (Exception ex)
{
OnFailedLogon(ex.Message);
}
return(result);
}
/// <summary>
/// Verify whether the directory exists.
/// </summary>
private async Task <bool> VerifyDirectoryExistAsync(Uri url)
{
FtpWebRequest request = this.CreateFtpWebRequest(url, WebRequestMethods.Ftp.ListDirectory);
try
{
using (FtpWebResponse response = await request.GetResponseAsync() as FtpWebResponse)
{
// Messages
this.OnNewMessageArrived(new NewMessageEventArgs(response.BannerMessage));
this.OnNewMessageArrived(new NewMessageEventArgs(response.WelcomeMessage));
this.OnNewMessageArrived(new NewMessageEventArgs(response.StatusDescription));
//return response.StatusCode == FtpStatusCode.DataAlreadyOpen;
return(true);
}
}
catch (System.Net.WebException webEx)
{
FtpWebResponse ftpResponse = webEx.Response as FtpWebResponse;
if (ftpResponse.StatusCode == FtpStatusCode.ActionNotTakenFileUnavailable)
{
return(false);
}
throw;
}
}
private static async Task <Stream> GetFtpFile(FtpWebRequest ftpRequest)
{
using (WebResponse ftpResponse = await ftpRequest.GetResponseAsync().ConfigureAwait(false))
{
return(ftpResponse.GetResponseStream());
}
}
public async Task <string> GetDirectory(string HostName, string UserName, string Password, int Port)
{
StringBuilder strBuilder = new StringBuilder();
if (Port > 0)
{
HostName += HostName + ":" + Port + "/";
}
FtpWebRequest req = (FtpWebRequest)WebRequest.Create(HostName);
req.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
req.Credentials = new NetworkCredential(UserName, Password);
req.EnableSsl = false;
FtpWebResponse resp = (FtpWebResponse)await req.GetResponseAsync();
using (var respStream = resp.GetResponseStream()) {
using (var reader = new StreamReader(respStream)) {
strBuilder.Append(reader.ReadToEnd());
strBuilder.Append(resp.WelcomeMessage);
strBuilder.Append($"Request returned status: {resp.StatusDescription}");
}
}
return(strBuilder.ToString());
}
/// <summary>
/// Request a RemoveDirectory action on the targeted Directory. The target must exists.
/// </summary>
/// <param name="cancelToken">The token to cancel the query</param>
/// <param name="options">The query-specific options</param>
/// <returns>A Task</returns>
public async Task RemoveDirectory(CancellationToken cancelToken, FtpOptions options = null)
{
cancelToken.ThrowIfCancellationRequested();
FtpWebRequest request = Handler.MakeRequest(cancelToken, options, Target, WebRequestMethods.Ftp.RemoveDirectory);
using (var response = (FtpWebResponse)await request.GetResponseAsync())
cancelToken.ThrowIfCancellationRequested();
}
/// <summary>
/// Request a Download action on the targeted file.
/// </summary>
/// <param name="stream">The stream that will be written to</param>
/// <param name="cancelToken">The token to cancel the query</param>
/// <param name="progress">The progress monitor</param>
/// <param name="options">The query-specific options</param>
/// <returns>A Task</returns>
public async Task Download(Stream stream, CancellationToken cancelToken, ProgressMonitorBase progress = null, FtpOptions options = null)
{
cancelToken.ThrowIfCancellationRequested();
options = options ?? Handler.Options;
FtpWebResponse response = null;
FtpWebRequest request = null;
if (progress != null)
{
long size = -1;
if (progress.AskForSize)
{
try {
size = await GetFileSize(cancelToken);
} catch { }
}
progress.Progress = new FtpProgress(size);
progress.OnInit();
}
if (cancelToken.IsCancellationRequested)
{
cancelToken.ThrowIfCancellationRequested();
}
request = Handler.MakeRequest(cancelToken, options, Target, WebRequestMethods.Ftp.DownloadFile);
response = (FtpWebResponse)await request.GetResponseAsync();
cancelToken.ThrowIfCancellationRequested();
byte[] buffer = new byte[options.BufferSize];
int readCount = 0;
try {
using (var responseStream = response.GetResponseStream()) {
if (progress != null)
{
progress.Progress.StartRateTimer();
}
do
{
readCount = await responseStream.ReadAsync(buffer, 0, options.BufferSize, cancelToken);
await stream.WriteAsync(buffer, 0, readCount, cancelToken);
cancelToken.ThrowIfCancellationRequested();
if (progress != null)
{
progress.Progress.CurrentCount += readCount;
progress.Progress.AddToRate(readCount);
progress.Progressed();
}
} while (readCount > 0);
}
} finally {
if (progress != null)
{
progress.Progress.StopRateTimer();
}
}
}
public override async Task Upload(string path, string name, byte[] buffer, bool allowCreateDirectory = true)
{
Exception exception = null;
bool directoryNotExist = false;
try
{
if (base.Config.Folder != "/")
{
path = base.Config.Folder + path.TrimStart('/');
}
string url = string.Format("{0}://{1}:{2}/{3}/{4}"
, base.Config.Protocol
, base.Config.Server
, base.Config.Port
, path.Trim('/')
, name
);
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(url);
request.UseBinary = true;
request.Method = WebRequestMethods.Ftp.UploadFile;
request.ContentLength = buffer.Length;
request.Credentials = new NetworkCredential(base.Config.Username, base.Config.Password);
Stream requestStream = await request.GetRequestStreamAsync();
await requestStream.WriteAsync(buffer, 0, buffer.Length);
requestStream.Close();
await request.GetResponseAsync();
return;
}
catch (WebException ex)
{
exception = ex;
FtpWebResponse response = ex.Response as FtpWebResponse;
if (response != null)
{
if (response.StatusCode == FtpStatusCode.ActionNotTakenFilenameNotAllowed)
{
// directory not exist
directoryNotExist = true;
}
}
}
if (directoryNotExist && allowCreateDirectory)
{
await CreateDir(path);
await Upload(path, name, buffer);
}
else
{
throw exception;
}
}
//都调用这个
private async System.Threading.Tasks.Task <string[]> GetFileListAsync(string path, string WRMethods)//上面的代码示例了如何从ftp服务器上获得文件列表
{
string[] downloadFiles;
StringBuilder result = new StringBuilder();
try
{
Connect(path);
reqFTP.Method = WRMethods;
WebResponse response = await reqFTP.GetResponseAsync();
StreamReader reader = new StreamReader(response.GetResponseStream(), System.Text.Encoding.Default);//中文文件名
string line = reader.ReadLine();
while (line != null)
{
result.Append(line);
result.Append("\n");
line = reader.ReadLine();
}
// to remove the trailing '\n'
result.Remove(result.ToString().LastIndexOf('\n'), 1);
reader.Close();
response.Close();
return(result.ToString().Split('\n'));
}
catch (Exception ex)
{
downloadFiles = null;
return(downloadFiles);
}
}
public async Task <FtpWebResponse> GetRawResponseStream(FTPfileInfo file)
{
FtpWebRequest ftp = await GetRequest(_hostname + file.FullName);
//Set request to download a file in binary mode
ftp.Method = WebRequestMethods.Ftp.DownloadFile;
ftp.UseBinary = true;
return((FtpWebResponse)await ftp.GetResponseAsync());
}
/// <summary>
/// Query the last modified time of the target.
/// </summary>
/// <param name="cancelToken">The token to cancel the query</param>
/// <param name="options">The query-specific options</param>
/// <returns>The last modified time of the targeted file</returns>
public async Task <DateTime> GetDatestamp(CancellationToken cancelToken, FtpOptions options = null)
{
cancelToken.ThrowIfCancellationRequested();
FtpWebRequest request = Handler.MakeRequest(cancelToken, options, Target, WebRequestMethods.Ftp.GetDateTimestamp);
using (var response = (FtpWebResponse)await request.GetResponseAsync()) {
cancelToken.ThrowIfCancellationRequested();
return(response.LastModified);
}
}
/// <summary>
/// Query the Current directory.
/// </summary>
/// <param name="cancelToken">The token to cancel the query</param>
/// <param name="options">The query-specific options</param>
/// <returns>The working directory</returns>
public async Task <string> PrintWorkingDirectory(CancellationToken cancelToken, FtpOptions options = null)
{
cancelToken.ThrowIfCancellationRequested();
FtpWebRequest request = Handler.MakeRequest(cancelToken, options, Target, WebRequestMethods.Ftp.PrintWorkingDirectory);
using (var response = (FtpWebResponse)await request.GetResponseAsync()) {
cancelToken.ThrowIfCancellationRequested();
return(response.StatusDescription);
}
}
/* List Directory Contents in Detail (Name, Size, Created, etc.) */
public async Task <List <FileProperty> > DirectoryListDetails(string directory)
{
var filePropertyList = new List <FileProperty>();
try
{
_ftpRequest = (FtpWebRequest)WebRequest.Create(_host + directory);
_ftpRequest.Credentials = new NetworkCredential(_user, _pass);
_ftpRequest.UseBinary = true;
_ftpRequest.UsePassive = true;
_ftpRequest.KeepAlive = true;
_ftpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
using (_ftpResponse = (FtpWebResponse)await _ftpRequest.GetResponseAsync())
{
using (_ftpStream = _ftpResponse.GetResponseStream())
{
if (_ftpStream != null)
{
_streamReader = new StreamReader(_ftpStream);
}
string line;
while ((line = _streamReader.ReadLine()) != null)
{
var fileListArr = line.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (fileListArr.Count() >= 4)
{
FileProperty fileProperty = new FileProperty()
{
ModifiedDate = fileListArr[0] != null?DateTime.ParseExact(Convert.ToString(fileListArr[0]), "MM-dd-yy", null) : DateTime.MinValue,
FileName = fileListArr[3] != null?Convert.ToString(fileListArr[3]) : string.Empty,
FileSize = fileListArr[2] != null && fileListArr[2] != "<DIR>" ? long.Parse(fileListArr[2]) : 0
};
filePropertyList.Add(fileProperty);
}
}
}
}
}
finally
{
_streamReader?.Close();
_ftpStream?.Close();
_ftpResponse?.Close();
_ftpRequest = null;
}
if (filePropertyList.Any())
{
filePropertyList = filePropertyList.OrderByDescending(x => x.ModifiedDate).ToList();
}
return(filePropertyList);
}
/// <summary>
/// Query the file size of the target.
/// </summary>
/// <param name="cancelToken">The token to cancel the query</param>
/// <param name="options">The query-specific options</param>
/// <returns>The size of the targeted file</returns>
public async Task <long> GetFileSize(CancellationToken cancelToken, FtpOptions options = null)
{
cancelToken.ThrowIfCancellationRequested();
FtpWebRequest request = Handler.MakeRequest(cancelToken, options, Target, WebRequestMethods.Ftp.GetFileSize);
using (var response = (FtpWebResponse)await request.GetResponseAsync()) {
cancelToken.ThrowIfCancellationRequested();
using (var sizeStream = response.GetResponseStream())
return(response.ContentLength);
}
}
private static async Task <FtpWebResponse> GetResponseAsync([NotNull] FtpWebRequest request)
{
try {
return((FtpWebResponse)await request.GetResponseAsync());
} catch (WebException exc) {
Console.WriteLine(exc);
Debug.Assert(exc.Response != null, "exc.Response != null");
exc.Response.Dispose();
return(null);
}
}
/// <summary>
/// Get all file names in a directory
/// </summary>
/// <returns>
/// Array of file names as strings
/// </returns>
public async Task <string[]> DirectoryListAsync()
{
try
{
Log.Verbose("Request to get file list from directory {0}", RemoteDirectory);
StringBuilder result = new StringBuilder();
FtpWebRequest ftpRequest = ConstructFtpRequest(null);
ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
using (WebResponse response = await ftpRequest.GetResponseAsync())
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
string line = reader.ReadLine();
while (line != null)
{
// We only care about log files in .txt extensions
if (line.EndsWith(".txt", true, CultureInfo.InvariantCulture))
{
result.Append(line);
result.Append(";");
}
line = reader.ReadLine();
}
if (!string.IsNullOrEmpty(result.ToString()))
{
result.Remove(result.ToString().LastIndexOf(';'), 1);
string[] fileList = result.ToString().Split(';');
Log.Information("Following files are available in {0} directory", RemoteDirectory);
foreach (string fileName in fileList)
{
Log.Information("File Name : {0}", fileName);
}
return(result.ToString().Split(';'));
}
Log.Information("No files are available in {0} directory", RemoteDirectory);
return(null);
}
}
}
catch (Exception exception)
{
Log.Error(
"Error during directory list operation. " +
"Directory : {0} , Uri : {1}",
exception,
RemoteDirectory,
FtpUri);
throw;
}
}
/// <summary>
/// Upload file to ftp server
/// </summary>
/// <param name="ftpSite"></param>
/// <param name="uploadFile"></param>
/// <param name="username"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task UploadFileAsync(Uri ftpSite, string uploadFile, string username, string password)
{
int totalBytes = 0;
Console.WriteLine("Uploading {uploadFile} to {ftpSite.AbsoluteUri}...");
try
{
FileInfo fileInfo = new FileInfo(uploadFile);
FtpWebRequest request = (FtpWebRequest)WebRequest.Create(ftpSite);
request.Method = WebRequestMethods.Ftp.UploadFile;
request.UseBinary = true;
request.ContentLength = fileInfo.Length;
request.Credentials = new NetworkCredential(username, password);
byte[] byteBuffer = new byte[4096];
using (Stream requestStream = await request.GetRequestStreamAsync())
{
using (FileStream fileStream = new FileStream(uploadFile, FileMode.Open, FileAccess.Read,
FileShare.Read, 4096, useAsync: true))
{
int bytesRead = 0;
do
{
bytesRead = await fileStream.ReadAsync(byteBuffer, 0, byteBuffer.Length);
if (bytesRead > 0)
{
totalBytes += bytesRead;
Console.WriteLine("Uploaded {totalBytes} Bytes");
await requestStream.WriteAsync(byteBuffer, 0, bytesRead);
}
} while (bytesRead > 0);
}
}
using (FtpWebResponse response = (FtpWebResponse)await request.GetResponseAsync())
{
Console.WriteLine(response.StatusDescription);
}
Console.WriteLine("Uploaded {uploadFile} to {ftpSite.AbsoluteUri}...");
}
catch (WebException e)
{
Console.WriteLine("Failed to upload {uploadFile} to {ftpSite.AbsoluteUri}.");
Console.WriteLine(((FtpWebResponse)e.Response).StatusDescription);
Console.WriteLine(e);
}
}
private static async Task<MemoryStream> DoAsync(FtpWebRequest request, MemoryStream requestBody)
{
if (requestBody != null)
{
Stream requestStream = await request.GetRequestStreamAsync();
await requestBody.CopyToAsync(requestStream);
requestStream.Close();
}
MemoryStream responseBody = new MemoryStream();
FtpWebResponse response = (FtpWebResponse)await request.GetResponseAsync();
await response.GetResponseStream().CopyToAsync(responseBody);
response.Close();
return responseBody;
}
