protected override async Task PerformIO()
{
bool hadToConnect = _client.ConnectIfNeeded();
_client.CreateDirectoriesIfNeeded(Folder);
string fullFilePath = ODFileUtils.CombinePaths(Folder, FileName, '/');
using (MemoryStream uploadStream = new MemoryStream(FileContent)) {
SftpUploadAsyncResult res = (SftpUploadAsyncResult)_client.BeginUploadFile(uploadStream, fullFilePath);
while (!res.AsyncWaitHandle.WaitOne(100))
{
if (DoCancel)
{
res.IsUploadCanceled = true;
}
OnProgress((double)res.UploadedBytes / (double)1024 / (double)1024, "?currentVal MB of ?maxVal MB uploaded", (double)FileContent.Length / (double)1024 / (double)1024, "");
}
_client.EndUploadFile(res);
if (res.IsUploadCanceled)
{
TaskStateDelete state = new Delete()
{
_client = this._client,
Path = fullFilePath
};
state.Execute(false);
}
}
_client.DisconnectIfNeeded(hadToConnect);
await Task.Run(() => { }); //Gets rid of a compiler warning and does nothing.
}
/// <summary>
/// Upload method using SSH.NET SFTP implementation for async files uploading.
/// </summary>
private void UPLOAD(SftpClient client, String localFileName)
{
string name = localFileName;
int pos = name.LastIndexOf(@"\") + 1;
String remoteFileName = name.Substring(pos, name.Length - pos);
Modify_UploadStatusTextBox(UploadStatusTextBox, System.Environment.NewLine + "Checking if local file " + localFileName + " exists..." + System.Environment.NewLine);
if (File.Exists(localFileName))
{
Console.WriteLine("Local file exists, continue...");
Modify_UploadStatusTextBox(UploadStatusTextBox, "File exists..." + System.Environment.NewLine);
localFileSize = new FileInfo(localFileName).Length;
Console.WriteLine("File size is: " + localFileSize);
Modify_UploadStatusTextBox(UploadStatusTextBox, "File size is: " + localFileSize + "." + System.Environment.NewLine);
using (Stream file = File.OpenRead(localFileName))
{
Modify_UploadStatusTextBox(UploadStatusTextBox, "Uploading file " + localFileName + " ..." + System.Environment.NewLine);
Console.WriteLine("### CLIENT: " + client);
Console.WriteLine("## FILE: " + file);
IAsyncResult asyncr = client.BeginUploadFile(file, remoteFileName);
sftpAsyncrUpload = (SftpUploadAsyncResult)asyncr;
while (!sftpAsyncrUpload.IsCompleted && !sftpAsyncrUpload.IsUploadCanceled)
{
int pct = Convert.ToInt32(((double)sftpAsyncrUpload.UploadedBytes / (double)localFileSize) * 100);
double temp = (double)sftpAsyncrUpload.UploadedBytes / (double)localFileSize;
Console.WriteLine("Uploaded Bytes: " + sftpAsyncrUpload.UploadedBytes);
Console.WriteLine("Uploaded: " + temp);
Console.WriteLine("File size is: " + localFileSize);
Console.WriteLine(pct);
Modify_progressBar2(progressBar2, pct);
Modify_UploadLabel(UploadLabel, "Status: " + pct + " %");
Modify_UploadBytesLabel(UploadBytesLabel, sftpAsyncrUpload.UploadedBytes);
}
client.EndUploadFile(asyncr);
file.Close();
}
if (sftpAsyncrUpload.IsUploadCanceled)
{
Console.WriteLine("File Upload has been canceled!");
Modify_UploadStatusTextBox(UploadStatusTextBox, "File Upload has been canceled!" + System.Environment.NewLine);
}
else
{
Console.WriteLine("The file " + localFileName + " has been successfully uploaded successfully to the server!");
Modify_UploadStatusTextBox(UploadStatusTextBox, "The file " + localFileName + " has been uploaded successfully!" + System.Environment.NewLine);
}
}
else
{
MessageBox.Show("The file " + localFileName + " does not exists on this computer", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private static void UploadFiles(string address, List <FileInfo> files)
{
var client = new SftpClient(address, 22, User, Password);
client.Connect();
client.BufferSize = 4 * 1024;
if (!client.Exists("/home/ec2-user/socialwargames/"))
{
client.CreateDirectory("/home/ec2-user/socialwargames/");
}
List <Task> tasks = new List <Task>();
var count = 0;
for (var index = 0; index < files.Count; index++)
{
var fileInfo = files[index];
tasks.Add(Task.Factory.FromAsync((callback, stateObject) =>
{
// Console.WriteLine($"{fileInfo.Name} {index}/{files.Count}");
return(client.BeginUploadFile(fileInfo.OpenRead(), "/home/ec2-user/socialwargames/" + fileInfo.Name, true, callback, stateObject));
}, (result) =>
{
count++;
Console.WriteLine($"{address} {count}/{files.Count}");
client.EndUploadFile(result);
}, null));
}
Task.WaitAll(tasks.ToArray());
client.Disconnect();
client.Dispose();
}
public void Test_Sftp_EndUploadFile_Invalid_Async_Handle()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var async1 = sftp.BeginListDirectory("/", null, null);
var filename = Path.GetTempFileName();
this.CreateTestFile(filename, 100);
var async2 = sftp.BeginUploadFile(File.OpenRead(filename), "test", null, null);
sftp.EndUploadFile(async1);
}
}
public void Test_Sftp_EndUploadFile_Invalid_Async_Handle()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var async1 = sftp.BeginListDirectory("/", null, null);
var filename = Path.GetTempFileName();
this.CreateTestFile(filename, 100);
var async2 = sftp.BeginUploadFile(File.OpenRead(filename), "test", null, null);
sftp.EndUploadFile(async1);
}
}
/// <summary>
/// Upload a file via SFTP.
/// </summary>
/// <param name="file">The file to upload.</param>
/// <returns>True on failure, false on success.</returns>
static bool UploadSftp(UploadFile file)
{
try
{
SftpClient client;
if (Settings.Default.TransferType == (int)TransferType.SftpKeys)
{
client = new SftpClient(Settings.Default.Host, Settings.Default.Port, Settings.Default.Username, new PrivateKeyFile(Misc.Decrypt(Settings.Default.Password)));
}
else
{
client = new SftpClient(Settings.Default.Host, Settings.Default.Port, Settings.Default.Username, Misc.Decrypt(Settings.Default.Password));
}
using (FileStream inputStream = new FileStream(file.Path, FileMode.Open))
using (SftpClient outputStream = client)
{
outputStream.Connect();
if (!String.IsNullOrEmpty(Settings.Default.Directory))
{
outputStream.ChangeDirectory(Settings.Default.Directory);
}
IAsyncResult async = outputStream.BeginUploadFile(inputStream, file.FileName);
SftpUploadAsyncResult sftpAsync = async as SftpUploadAsyncResult;
while (sftpAsync != null && !sftpAsync.IsCompleted)
{
if (UploadWorker.CancellationPending)
{
return(true);
}
UploadWorker.ReportProgress((int)(sftpAsync.UploadedBytes * 100 / (ulong)inputStream.Length));
}
outputStream.EndUploadFile(async);
}
return(false);
}
catch (Exception e)
{
_uploadStatus = Misc.HandleErrorStatusText(Resources.Sftp);
Misc.HandleError(e, Resources.Sftp);
return(true);
}
}
public static void UploadFile(FileInfo file, string ftpDir)
{
log.WriteLine("\nAttempting to upload " + file.FullName + " to " + ftpDir + "/" + file.Name + "... ", false);
Run("touch " + ftpDir + "/" + file.Name);
var inputStream = file.OpenRead();
var up = sftp.BeginUploadFile(inputStream, ftpDir + "/" + file.Name);
while (!up.IsCompleted)
{
;
}
sftp.EndUploadFile(up);
inputStream.Close();
log.WriteLine("Sucess!", false);
}
/// <summary>
/// Uploads the given <paramref name="inputStream"/> to the given <paramref name="path"/> asynchronously.
/// </summary>
/// <param name="client">The SFTP client to perform the upload action with.</param>
/// <param name="path">The path to where the file should be uploaded to.</param>
/// <param name="inputStream">The input stream containing the data to upload.</param>
/// <returns>The <see cref="Task"/> that represents the asynchronous operation.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="client"/> or <paramref name="inputStream"/> is null.</exception>
/// <exception cref="ArgumentException">If <paramref name="path"/> is null or white space.</exception>
public static Task UploadFileAsync(this SftpClient client, string path, Stream inputStream, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (inputStream == null)
{
throw new ArgumentNullException(nameof(inputStream));
}
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentException("Path must not be null or white space.");
}
cancellationToken.ThrowIfCancellationRequested();
return(Task.Factory.FromAsync(client.BeginUploadFile(inputStream, path),
result => client.EndUploadFile(result)));
}
/// <summary>
/// Upload the captured image, file path found in CapturedImage.LocalPath
/// </summary>
public static void UploadCapturedImage()
{
if (FTP)
{
ftpc.PutFileAsync(CapturedImage.LocalPath, CapturedImage.RemotePath, FileAction.CreateNew);
}
else
{
EventWaitHandle wait = new AutoResetEvent(false);
using (var file = File.OpenRead(CapturedImage.LocalPath))
{
var asynch = sftpc.BeginUploadFile(file, CapturedImage.RemotePath, delegate
{
Console.Write("\nCallback called.");
wait.Set();
},
null);
var sftpASynch = asynch as Renci.SshNet.Sftp.SftpUploadAsyncResult;
while (!sftpASynch.IsCompleted)
{
if (sftpASynch.UploadedBytes > 0)
{
Console.Write("\rUploaded {0} bytes ", sftpASynch.UploadedBytes);
}
Thread.Sleep(100);
}
Console.Write("\rUploaded {0} bytes!", sftpASynch.UploadedBytes);
sftpc.EndUploadFile(asynch);
wait.WaitOne();
}
CaptureControl.ImageUploaded();
}
}
public void transferFile()
{
//richTextBox1.AppendText("Creating client and connecting");
LogThis("\rCreating client and connecting...");
bool directoryAlreadyExists = false;
using (var client = new SftpClient(HostName, _port, UserName, Password))
{
try
{
// connect to SFTP host:
client.Connect();
OutputThis(string.Format("\rConnected to {0}", HostName));
// cd to the remote folder we want as the root:
client.ChangeDirectory(WorkingDirectory);
LogThis(string.Format("\rChanged directory to {0}", WorkingDirectory));
LogThis(string.Format("\rChanged directory to {0}", WorkingDirectory));
// this just lists the current [root] folder contents to make sure we're where we think we are: for testing only
//var listDirectory = client.ListDirectory(workingdirectory);
//LogThis("\rListing directory:");
//// event args for listing directory event:
//ListingDirectoryEventArgs listArgs = new ListingDirectoryEventArgs();
//foreach (var fi in listDirectory)
//{
// listArgs.FolderName = workingdirectory;
// listArgs.FileName = fi.Name;
// OnListingDirectory(listArgs);
// LogThis(string.Format("\r{0}", fi.Name));
//}
// make the new directory on the server, test if it already exists though:
// a bug in client.Exists prevents me from using it reliably, so just try to
// cd to the dir and trap for the error if it doesn't exist:
//if (client.Exists(workingdirectory + "/" + PhotoFTPFolderName) == false)
//{
// client.CreateDirectory(PhotoFTPFolderName);
// LogThis("directory created.");
//}
try
{
client.ChangeDirectory(WorkingDirectory + "/" + PhotoFTPFolderName);
directoryAlreadyExists = true;
}
catch (Exception exDirError)
{
if (exDirError != null)
{
if (exDirError.Message.Contains("not found"))
{
directoryAlreadyExists = false;
}
}
}
if (directoryAlreadyExists == false)
{
client.CreateDirectory(PhotoFTPFolderName);
LogThis("directory created.");
}
client.ChangeDirectory(WorkingDirectory + "/" + PhotoFTPFolderName);
LogThis("set working directory to photo Directory");
LogThis(string.Format("\rset working directory to {0}", WorkingDirectory + "/" + PhotoFTPFolderName));
//listDirectory = client.ListDirectory(workingdirectory);
//LogThis("\rListing directory:");
//foreach (var fi in listDirectory)
//{
// LogThis(string.Format("\r{0}", fi.Name));
//}
using (var fileStream = new FileStream(UploadFileName, FileMode.Open))
{
LogThis(string.Format("\rUploading {0} ({1:N0} bytes)", UploadFileName, fileStream.Length));
client.BufferSize = 4 * 1024; // bypass Payload error large files
//client.UploadFile(fileStream, Path.GetFileName(uploadfile));
// try async:
var asyncResult = client.BeginUploadFile(fileStream, Path.GetFileName(UploadFileName), null, null) as Renci.SshNet.Sftp.SftpUploadAsyncResult;
//var asyncResult = async1 as CommandAsyncResult;
while (!asyncResult.IsCompleted)
{
FileUploadingEventArgs args = new FileUploadingEventArgs();
args.BytesSentSoFar = asyncResult.UploadedBytes;
args.FileNameInProgress = UploadFileName;
args.FileBytesTotal = fileStream.Length;
LogThis(string.Format("\rUploaded {0:#########}", (asyncResult.UploadedBytes * 1024)));
OnFileUploading(args);
Thread.Sleep(200);
}
LogThis(string.Format("\rUploaded {0:#########}", (asyncResult.UploadedBytes * 1024)));
if (asyncResult.IsCompleted)
{
FileUploadCompletedEventArgs fileCompleteArgs = new FileUploadCompletedEventArgs();
fileCompleteArgs.UploadedFileName = UploadFileName;
fileCompleteArgs.BytesSent = asyncResult.UploadedBytes;
client.EndUploadFile(asyncResult);
OnFileUploadCompleted(fileCompleteArgs);
// raise an event to tell the client we're done!
//MessageBox.Show("File upload completed!", "File Upload", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//MessageBox.Show("File upload completed!", "File Upload", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
catch (Exception ex)
{
if (ex == null)
{
throw;
}
else
{
LogThis(ex.Message);
// throw this exception so the consumer knows
throw ex;
}
}
finally
{
client.Disconnect();
}
}
}
public void Test_Sftp_Ensure_Async_Delegates_Called_For_BeginFileUpload_BeginFileDownload_BeginListDirectory()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
string remoteFileName = Path.GetRandomFileName();
string localFileName = Path.GetRandomFileName();
bool uploadDelegateCalled = false;
bool downloadDelegateCalled = false;
bool listDirectoryDelegateCalled = false;
IAsyncResult asyncResult;
// Test for BeginUploadFile.
CreateTestFile(localFileName, 1);
using (var fileStream = File.OpenRead(localFileName))
{
asyncResult = sftp.BeginUploadFile(fileStream, remoteFileName, delegate(IAsyncResult ar)
{
sftp.EndUploadFile(ar);
uploadDelegateCalled = true;
}, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(500);
}
}
File.Delete(localFileName);
Assert.IsTrue(uploadDelegateCalled, "BeginUploadFile");
// Test for BeginDownloadFile.
asyncResult = null;
using (var fileStream = File.OpenWrite(localFileName))
{
asyncResult = sftp.BeginDownloadFile(remoteFileName, fileStream, delegate(IAsyncResult ar)
{
sftp.EndDownloadFile(ar);
downloadDelegateCalled = true;
}, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(500);
}
}
File.Delete(localFileName);
Assert.IsTrue(downloadDelegateCalled, "BeginDownloadFile");
// Test for BeginListDirectory.
asyncResult = null;
asyncResult = sftp.BeginListDirectory(sftp.WorkingDirectory, delegate(IAsyncResult ar)
{
sftp.EndListDirectory(ar);
listDirectoryDelegateCalled = true;
}, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(500);
}
Assert.IsTrue(listDirectoryDelegateCalled, "BeginListDirectory");
}
}
public void Test_Sftp_Multiple_Async_Upload_And_Download_10Files_5MB_Each()
{
var maxFiles = 10;
var maxSize = 5;
RemoveAllFiles();
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var testInfoList = new Dictionary <string, TestInfo>();
for (int i = 0; i < maxFiles; i++)
{
var testInfo = new TestInfo();
testInfo.UploadedFileName = Path.GetTempFileName();
testInfo.DownloadedFileName = Path.GetTempFileName();
testInfo.RemoteFileName = Path.GetRandomFileName();
this.CreateTestFile(testInfo.UploadedFileName, maxSize);
// Calculate hash value
testInfo.UploadedHash = CalculateMD5(testInfo.UploadedFileName);
testInfoList.Add(testInfo.RemoteFileName, testInfo);
}
var uploadWaitHandles = new List <WaitHandle>();
// Start file uploads
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
testInfo.UploadedFile = File.OpenRead(testInfo.UploadedFileName);
testInfo.UploadResult = sftp.BeginUploadFile(testInfo.UploadedFile,
remoteFile,
null,
null) as SftpUploadAsyncResult;
uploadWaitHandles.Add(testInfo.UploadResult.AsyncWaitHandle);
}
// Wait for upload to finish
bool uploadCompleted = false;
while (!uploadCompleted)
{
// Assume upload completed
uploadCompleted = true;
foreach (var testInfo in testInfoList.Values)
{
var sftpResult = testInfo.UploadResult;
if (!testInfo.UploadResult.IsCompleted)
{
uploadCompleted = false;
}
}
Thread.Sleep(500);
}
// End file uploads
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
sftp.EndUploadFile(testInfo.UploadResult);
testInfo.UploadedFile.Dispose();
}
// Start file downloads
var downloadWaitHandles = new List <WaitHandle>();
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
testInfo.DownloadedFile = File.OpenWrite(testInfo.DownloadedFileName);
testInfo.DownloadResult = sftp.BeginDownloadFile(remoteFile,
testInfo.DownloadedFile,
null,
null) as SftpDownloadAsyncResult;
downloadWaitHandles.Add(testInfo.DownloadResult.AsyncWaitHandle);
}
// Wait for download to finish
bool downloadCompleted = false;
while (!downloadCompleted)
{
// Assume download completed
downloadCompleted = true;
foreach (var testInfo in testInfoList.Values)
{
var sftpResult = testInfo.DownloadResult;
if (!testInfo.DownloadResult.IsCompleted)
{
downloadCompleted = false;
}
}
Thread.Sleep(500);
}
var hashMatches = true;
var uploadDownloadSizeOk = true;
// End file downloads
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
sftp.EndDownloadFile(testInfo.DownloadResult);
testInfo.DownloadedFile.Dispose();
testInfo.DownloadedHash = CalculateMD5(testInfo.DownloadedFileName);
if (!(testInfo.UploadResult.UploadedBytes > 0 && testInfo.DownloadResult.DownloadedBytes > 0 && testInfo.DownloadResult.DownloadedBytes == testInfo.UploadResult.UploadedBytes))
{
uploadDownloadSizeOk = false;
}
if (!testInfo.DownloadedHash.Equals(testInfo.UploadedHash))
{
hashMatches = false;
}
}
// Clean up after test
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
sftp.DeleteFile(remoteFile);
File.Delete(testInfo.UploadedFileName);
File.Delete(testInfo.DownloadedFileName);
}
sftp.Disconnect();
Assert.IsTrue(hashMatches, "Hash does not match");
Assert.IsTrue(uploadDownloadSizeOk, "Uploaded and downloaded bytes does not match");
}
}
public void Test_Sftp_Multiple_Async_Upload_And_Download_10Files_5MB_Each()
{
var maxFiles = 10;
var maxSize = 5;
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var testInfoList = new Dictionary<string, TestInfo>();
for (int i = 0; i < maxFiles; i++)
{
var testInfo = new TestInfo();
testInfo.UploadedFileName = Path.GetTempFileName();
testInfo.DownloadedFileName = Path.GetTempFileName();
testInfo.RemoteFileName = Path.GetRandomFileName();
this.CreateTestFile(testInfo.UploadedFileName, maxSize);
// Calculate hash value
testInfo.UploadedHash = CalculateMD5(testInfo.UploadedFileName);
testInfoList.Add(testInfo.RemoteFileName, testInfo);
}
var uploadWaitHandles = new List<WaitHandle>();
// Start file uploads
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
testInfo.UploadedFile = File.OpenRead(testInfo.UploadedFileName);
testInfo.UploadResult = sftp.BeginUploadFile(testInfo.UploadedFile,
remoteFile,
null,
null) as SftpUploadAsyncResult;
uploadWaitHandles.Add(testInfo.UploadResult.AsyncWaitHandle);
}
// Wait for upload to finish
bool uploadCompleted = false;
while (!uploadCompleted)
{
// Assume upload completed
uploadCompleted = true;
foreach (var testInfo in testInfoList.Values)
{
var sftpResult = testInfo.UploadResult;
if (!testInfo.UploadResult.IsCompleted)
{
uploadCompleted = false;
}
}
Thread.Sleep(500);
}
// End file uploads
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
sftp.EndUploadFile(testInfo.UploadResult);
testInfo.UploadedFile.Dispose();
}
// Start file downloads
var downloadWaitHandles = new List<WaitHandle>();
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
testInfo.DownloadedFile = File.OpenWrite(testInfo.DownloadedFileName);
testInfo.DownloadResult = sftp.BeginDownloadFile(remoteFile,
testInfo.DownloadedFile,
null,
null) as SftpDownloadAsyncResult;
downloadWaitHandles.Add(testInfo.DownloadResult.AsyncWaitHandle);
}
// Wait for download to finish
bool downloadCompleted = false;
while (!downloadCompleted)
{
// Assume download completed
downloadCompleted = true;
foreach (var testInfo in testInfoList.Values)
{
var sftpResult = testInfo.DownloadResult;
if (!testInfo.DownloadResult.IsCompleted)
{
downloadCompleted = false;
}
}
Thread.Sleep(500);
}
var hashMatches = true;
var uploadDownloadSizeOk = true;
// End file downloads
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
sftp.EndDownloadFile(testInfo.DownloadResult);
testInfo.DownloadedFile.Dispose();
testInfo.DownloadedHash = CalculateMD5(testInfo.DownloadedFileName);
if (!(testInfo.UploadResult.UploadedBytes > 0 && testInfo.DownloadResult.DownloadedBytes > 0 && testInfo.DownloadResult.DownloadedBytes == testInfo.UploadResult.UploadedBytes))
{
uploadDownloadSizeOk = false;
}
if (!testInfo.DownloadedHash.Equals(testInfo.UploadedHash))
{
hashMatches = false;
}
}
// Clean up after test
foreach (var remoteFile in testInfoList.Keys)
{
var testInfo = testInfoList[remoteFile];
sftp.DeleteFile(remoteFile);
File.Delete(testInfo.UploadedFileName);
File.Delete(testInfo.DownloadedFileName);
}
sftp.Disconnect();
Assert.IsTrue(hashMatches, "Hash does not match");
Assert.IsTrue(uploadDownloadSizeOk, "Uploaded and downloaded bytes does not match");
}
}
public void Test_Sftp_Ensure_Async_Delegates_Called_For_BeginFileUpload_BeginFileDownload_BeginListDirectory()
{
RemoveAllFiles();
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
string remoteFileName = Path.GetRandomFileName();
string localFileName = Path.GetRandomFileName();
bool uploadDelegateCalled = false;
bool downloadDelegateCalled = false;
bool listDirectoryDelegateCalled = false;
IAsyncResult asyncResult;
// Test for BeginUploadFile.
CreateTestFile(localFileName, 1);
using (var fileStream = File.OpenRead(localFileName))
{
asyncResult = sftp.BeginUploadFile(fileStream, remoteFileName, delegate(IAsyncResult ar)
{
sftp.EndUploadFile(ar);
uploadDelegateCalled = true;
}, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(500);
}
}
File.Delete(localFileName);
Assert.IsTrue(uploadDelegateCalled, "BeginUploadFile");
// Test for BeginDownloadFile.
asyncResult = null;
using (var fileStream = File.OpenWrite(localFileName))
{
asyncResult = sftp.BeginDownloadFile(remoteFileName, fileStream, delegate(IAsyncResult ar)
{
sftp.EndDownloadFile(ar);
downloadDelegateCalled = true;
}, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(500);
}
}
File.Delete(localFileName);
Assert.IsTrue(downloadDelegateCalled, "BeginDownloadFile");
// Test for BeginListDirectory.
asyncResult = null;
asyncResult = sftp.BeginListDirectory(sftp.WorkingDirectory, delegate(IAsyncResult ar)
{
sftp.EndListDirectory(ar);
listDirectoryDelegateCalled = true;
}, null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(500);
}
Assert.IsTrue(listDirectoryDelegateCalled, "BeginListDirectory");
}
}
public void EndUploadFileTest()
{
ConnectionInfo connectionInfo = null; // TODO: Initialize to an appropriate value
SftpClient target = new SftpClient(connectionInfo); // TODO: Initialize to an appropriate value
IAsyncResult asyncResult = null; // TODO: Initialize to an appropriate value
target.EndUploadFile(asyncResult);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void EndUploadFile(IAsyncResult ar)
{
ColoredConsole.WriteLine(ConsoleColor.Cyan, "SSH.NET: Ending upload of file...");
_connection.EndUploadFile(ar);
ColoredConsole.WriteLine(ConsoleColor.Green, "SSH.NET: Ended file uploaded.");
}
private static async Task UploadFiles(string timestamp, string outputPath, string rsaPrivate, string sftpHost, string sftpUsername)
{
using var client = new SftpClient(sftpHost, sftpUsername, new PrivateKeyFile(File.OpenRead(rsaPrivate)))
{
BufferSize = 4096,
OperationTimeout = TimeSpan.FromHours(1),
};
client.Connect();
client.CreateDirectory(timestamp);
foreach (var file in Directory.GetFiles(outputPath))
{
using var zipUpload = File.OpenRead(file);
await Task.Factory.FromAsync((callback, stateObject) => client.BeginUploadFile(zipUpload, $"{timestamp}\\{Path.GetFileName(file)}", callback, stateObject), result => client.EndUploadFile(result), null);
}
client.Disconnect();
}
public void End_Upload()
{
SftpClt.EndUploadFile(async_upload_result);
stream_upload.Close();
}
public void transferFiles(string[] filesToUpload)
{
//richTextBox1.AppendText("Creating client and connecting");
LogThis("\rCreating client and connecting...");
bool directoryAlreadyExists = false;
int fileCount = filesToUpload.Count();
int fileCounter = 0;
using (var client = new SftpClient(HostName, _port, UserName, Password))
{
try
{
// connect to SFTP host:
client.Connect();
OutputThis(string.Format("\rConnected to {0}", HostName));
// cd to the remote folder we want as the root:
client.ChangeDirectory(WorkingDirectory);
LogThis(string.Format("\rChanged directory to {0}", WorkingDirectory));
LogThis(string.Format("\rChanged directory to {0}", WorkingDirectory));
try
{
client.ChangeDirectory(WorkingDirectory + "/" + PhotoFTPFolderName);
directoryAlreadyExists = true;
}
catch (Exception exDirError)
{
if (exDirError != null)
{
if (exDirError.Message.Contains("not found"))
{
directoryAlreadyExists = false;
}
}
}
if (directoryAlreadyExists == false)
{
client.CreateDirectory(PhotoFTPFolderName);
LogThis("directory created.");
}
client.ChangeDirectory(WorkingDirectory + "/" + PhotoFTPFolderName);
LogThis("set working directory to photo Directory");
LogThis(string.Format("\rset working directory to {0}", WorkingDirectory + "/" + PhotoFTPFolderName));
// manage the uploading of multiple files
foreach (var file in filesToUpload)
{
fileCounter++;
using (var fileStream = new FileStream(file, FileMode.Open))
{
LogThis(string.Format("\rUploading {0} ({1:N0} bytes)", file, fileStream.Length));
client.BufferSize = 4 * 1024; // bypass Payload error large files
//client.UploadFile(fileStream, Path.GetFileName(uploadfile));
// try async:
var asyncResult = client.BeginUploadFile(fileStream, Path.GetFileName(file), null, null) as Renci.SshNet.Sftp.SftpUploadAsyncResult;
//var asyncResult = async1 as CommandAsyncResult;
while (!asyncResult.IsCompleted)
{
FileUploadingEventArgs args = new FileUploadingEventArgs();
args.BytesSentSoFar = asyncResult.UploadedBytes;
args.FileNameInProgress = file;
args.FileBytesTotal = fileStream.Length;
args.FileNumberOfTotal = fileCounter;
args.TotalNumberFilesToTransfer = fileCount;
LogThis(string.Format("\rUploaded {0:#########}", (asyncResult.UploadedBytes * 1024)));
OnFileUploading(args);
Thread.Sleep(200);
}
LogThis(string.Format("\rUploaded {0:#########}", (asyncResult.UploadedBytes * 1024)));
if (asyncResult.IsCompleted)
{
FileUploadCompletedEventArgs fileCompleteArgs = new FileUploadCompletedEventArgs();
fileCompleteArgs.UploadedFileName = file;
fileCompleteArgs.BytesSent = asyncResult.UploadedBytes;
client.EndUploadFile(asyncResult);
OnFileUploadCompleted(fileCompleteArgs);
// raise an event to tell the client we're done!
//MessageBox.Show("File upload completed!", "File Upload", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//MessageBox.Show("File upload completed!", "File Upload", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
catch (Exception ex)
{
if (ex == null)
{
throw;
}
else
{
LogThis(ex.Message);
// throw this exception so the consumer knows
throw ex;
}
}
finally
{
client.Disconnect();
}
}
}
private void UploadFilesFromFilemanager()
{
string destpathroot = txtRemoteFolderPath.Text;
if (!destpathroot.EndsWith("/"))
{
destpathroot += "/";
}
var filelist = new Dictionary<string, string>();
foreach (var item in lvLocalBrowser.SelectedItems.Cast<EXImageListViewItem>().Where(item => (string) item.Tag != "[..]"))
{
if ((string)item.Tag == "File")
{
filelist.Add(item.MyValue, destpathroot + Path.GetFileName(item.MyValue));
}
if ((string)item.Tag == "Folder")
{
string folder = Path.GetDirectoryName(item.MyValue);
folder = folder.EndsWith("\\") ? folder : folder + "\\";
string[] files = Directory.GetFiles(item.MyValue,
"*.*",
SearchOption.AllDirectories);
// Display all the files.
foreach (string file in files)
{
filelist.Add(Path.GetFullPath(file), destpathroot + Path.GetFullPath(file).Replace(folder,"").Replace("\\","/"));
}
}
}
long fulllength = filelist.Sum(file => new FileInfo(file.Key).Length);
MessageBox.Show(Tools.Misc.LengthToHumanReadable(fulllength));
var ssh = new SftpClient(txtHost.Text, int.Parse(this.txtPort.Text), txtUser.Text, txtPassword.Text);
ssh.Connect();
ThreadPool.QueueUserWorkItem(state =>
{
long totaluploaded = 0;
foreach (var file in filelist)
{
CreatSSHDir(ssh, file.Value);
var s = new FileStream(file.Key, FileMode.Open);
var i = ssh.BeginUploadFile(s, file.Value) as SftpUploadAsyncResult;
while (!i.IsCompleted)
{
SetProgressStatus(totaluploaded + (long)i.UploadedBytes, fulllength);
}
ssh.EndUploadFile(i);
totaluploaded += s.Length;
}
MessageBox.Show(Language.SSHTransfer_StartTransfer_Upload_completed_);
EnableButtons();
ssh.Disconnect();
});
}