public Task <bool> IsDirectoryExists(string directoryPath)
{
return(HandleCommonExceptions(() => {
if (_client.Exists(directoryPath))
{
var file = _client.Get(directoryPath);
return file.IsDirectory;
}
return false;
}));
}
public Task <bool> IsDirectory(string fileName, DirectoryEnum directoryEnum = DirectoryEnum.Published)
{
try
{
Connect();
SftpFile sftpFile = _sftpClient.Get(GetFilePath(fileName, directoryEnum));
return(Task.FromResult(sftpFile?.IsDirectory ?? false));
}
catch
{
return(Task.FromResult(false));
}
}
public void Test_Sftp_SftpFile_MoveTo()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
string uploadedFileName = Path.GetTempFileName();
string remoteFileName = Path.GetRandomFileName();
string newFileName = Path.GetRandomFileName();
this.CreateTestFile(uploadedFileName, 1);
using (var file = File.OpenRead(uploadedFileName))
{
sftp.UploadFile(file, remoteFileName);
}
var sftpFile = sftp.Get(remoteFileName);
sftpFile.MoveTo(newFileName);
Assert.AreEqual(newFileName, sftpFile.Name);
sftp.Disconnect();
}
}
public void Test_Sftp_SftpFile_MoveTo()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
string uploadedFileName = Path.GetTempFileName();
string remoteFileName = Path.GetRandomFileName();
string newFileName = Path.GetRandomFileName();
this.CreateTestFile(uploadedFileName, 1);
using (var file = File.OpenRead(uploadedFileName))
{
sftp.UploadFile(file, remoteFileName);
}
var sftpFile = sftp.Get(remoteFileName);
sftpFile.MoveTo(newFileName);
Assert.AreEqual(newFileName, sftpFile.Name);
sftp.Disconnect();
}
}
public Task <FileSpec> GetFileInfoAsync(string path)
{
if (String.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
EnsureClientConnected();
try {
var file = _client.Get(NormalizePath(path));
return(Task.FromResult(new FileSpec {
Path = file.FullName.TrimStart('/'),
Created = file.LastWriteTimeUtc,
Modified = file.LastWriteTimeUtc,
Size = file.Length
}));
} catch (SftpPathNotFoundException ex) {
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace(ex, "Error trying to getting file info: {Path}", path);
}
return(Task.FromResult <FileSpec>(null));
}
}
private void UploadFile(SftpClient sftpClient, FileEntry file, string localPath)
{
if (verboseMode)
{
lock (this)
{
ConsoleOutput($"- {Thread.CurrentThread.ManagedThreadId,2}> Uploading file {file.Name} ({file.Length:N0} bytes)");
}
}
long lastProgress = 0;
using (var stream = File.OpenRead(Path.Combine(localPath, file.Name)))
{
sftpClient.UploadFile(stream, tempUploadDirectory + "/" + file.Name, offset =>
{
lock (this)
{
uploadedBytes -= lastProgress;
uploadedBytes += lastProgress = (long)offset;
}
});
}
var sftpFile = sftpClient.Get(tempUploadDirectory + "/" + file.Name);
sftpFile.LastWriteTimeUtc = file.UtcTime;
sftpFile.UpdateStatus();
lock (this)
{
uploadedBytes -= lastProgress;
uploadedBytes += file.Length;
}
}
private void Download()
{
try
{
this.Invoke(new MethodInvoker(delegate()
{
using (var stream = new FileStream(LocalDirectory + "/" + listView1.SelectedItems[0].Text, FileMode.Create))
using (var oSftp = new SftpClient(ftpPath, ftpUser, ftpPass))
{
oSftp.Connect();
//SftpFileAttributes attributes = Client.GetAttributes(subURL + "/" + listView1.SelectedItems[0].Text);
SftpFile file = oSftp.Get(subURL + "/" + listView1.SelectedItems[0].Text);
progressBar1.Invoke((MethodInvoker)
delegate
{
progressBar1.Maximum = (int)file.Attributes.Size;
});
oSftp.DownloadFile(subURL + "/" + listView1.SelectedItems[0].Text, stream, DownloadProgresBar);
oSftp.Disconnect();
}
}));
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// Descarga archivo de servidor a un directorio local.
/// </summary>
/// <param name="filePath">Ruta de Archivo en servidor remoto.</param>
/// <param name="destinationPath">Ruta de descarga local.</param>
/// <returns>Logrado o no logrado.</returns>
/// <remmarks>No validado.</remmarks>
public bool Download(string filePath, string destinationPath)
{
bool result = false;
using (SftpClient client = new SftpClient(Host, User, Pass))
{
client.Connect();
if (client.IsConnected)
{
SftpFile file = client.Get(filePath);
if (!file.IsDirectory)
{
string path = $"{destinationPath}/{file.Name}";
using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.ReadWrite))
{
client.DownloadFile(file.FullName, fs);
}
result = true;
}
client.Disconnect();
}
}
return(result);
}
/// <summary>
/// Elimina un archivo del servidor SFTP.
/// </summary>
/// <param name="filePath">Ruta de Archivo/Directorio dentro del servidor.</param>
/// <returns>Logrado o no logrado.</returns>
/// <remarks>No validado.</remarks>
public bool Delete(string filePath)
{
bool result = false;
using (SftpClient client = new SftpClient(Host, User, Pass))
{
client.Connect();
if (client.IsConnected)
{
SftpFile file = client.Get(filePath);
if (file.IsDirectory)
{
client.DeleteDirectory(file.FullName);
}
else
{
client.DeleteFile(file.FullName);
}
result = true;
client.Disconnect();
}
}
return(result);
}
public static void SftpFileUpload(FTPConfig config)
{
ConnectionInfo connectionInfo = new ConnectionInfo(config.IP, config.Port, config.User, new PasswordAuthenticationMethod(config.User, config.Password));
using (SftpClient sftp = new SftpClient(connectionInfo))
{
sftp.Connect();
sftp.ChangeDirectory(config.Directory);
FileInfo fi = new FileInfo(config.FilePath);
using (var uplfileStream = File.OpenRead(config.FilePath))
{
if (config.DeleteIfExists)
{
try
{
Renci.SshNet.Sftp.SftpFile file = sftp.Get(fi.Name);
if (file.HasValue())
{
sftp.DeleteFile(file.FullName);
}
}
catch
{
}
}
sftp.UploadFile(uplfileStream, fi.Name, true);
}
sftp.Disconnect();
}
}
public NtStatus GetFileInformation(string fileName, out FileInformation fileInfo, DokanFileInfo info)
{
SftpFile file = sftpClient.Get(ToUnixStylePath(fileName));
fileInfo = new FileInformation()
{
FileName = file.Name,
Attributes = FileAttributes.NotContentIndexed,
CreationTime = file.LastWriteTime,
LastAccessTime = file.LastAccessTime,
LastWriteTime = file.LastWriteTime,
Length = file.Length
};
if (file.IsDirectory)
{
fileInfo.Attributes |= FileAttributes.Directory;
fileInfo.Length = 0;
}
else
{
fileInfo.Attributes |= FileAttributes.Normal;
}
if (fileInfo.FileName.StartsWith("."))
{
fileInfo.Attributes |= FileAttributes.Hidden;
}
// todo :
// readonly check
return(DokanResult.Success);
}
public async Task <ActionResult> LoadFTPFiles(FTPCredentials credentials, Guid requestId, IEnumerable <string> paths)
{
List <Document> uploadedDocuments = new List <Document>();
using (var sftp = new SftpClient(credentials.Address, credentials.Port, credentials.Login, credentials.Password))
{
try
{
sftp.Connect();
foreach (var path in paths)
{
var fileInfo = sftp.Get(path);
using (var sSource = sftp.OpenRead(path))
{
using (var db = new DataContext())
{
var document = new Document
{
CreatedOn = DateTime.UtcNow,
FileName = fileInfo.Name,
ItemID = requestId,
Length = fileInfo.Length,
MimeType = FileEx.GetMimeTypeByExtension(fileInfo.Name),
Name = fileInfo.Name,
Viewable = false,
Kind = DocumentKind.User
};
db.Documents.Add(document);
uploadedDocuments.Add(document);
await db.SaveChangesAsync();
var docStream = new DocumentStream(db, document.ID);
await sSource.CopyToAsync(docStream);
}
}
}
}
catch (Exception ex)
{
return(new HttpStatusCodeResult((int)HttpStatusCode.BadRequest, ex.Message));
}
finally
{
if (sftp.IsConnected)
{
sftp.Disconnect();
}
}
}
Response.StatusCode = (int)HttpStatusCode.OK;
Response.ContentType = "application/json";
return(Json(uploadedDocuments.Select(d => new { d.ID, d.FileName, d.MimeType, Size = d.Length }), JsonRequestBehavior.AllowGet));
}
public void Test_Get_Invalid_Directory()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
sftp.Get("/xyz");
}
}
public void Test_Get_Invalid_Directory()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
sftp.Get("/xyz");
}
}
private string UploadFileProd(string path, string filename)
{
try
{
User user = GetUser();
MemoryStream stream = new MemoryStream();
using (var sftp = new SftpClient(SchemaFtpSiteTest, SchemaUsernameTest, SchemaPasswordTest))
{
sftp.Connect();
sftp.DownloadFile(SchemaFtpWorkingDirectoryTest + "/" + path + "/" + filename, stream);
sftp.Disconnect();
}
using (var sftp = new SftpClient(SchemaFtpSite, user.Username, user.Password))
{
sftp.Connect();
string[] subDirs = path.Split('/');
string currentDir = SchemaFtpWorkingDirectory;
foreach (string subDir in subDirs)
{
currentDir = currentDir + "/" + subDir;
try
{
SftpFile folder = sftp.Get(currentDir);
}
catch (SftpPathNotFoundException ex)
{
sftp.CreateDirectory(currentDir);
}
}
stream.Position = 0;
var filePath = currentDir + "/" + filename;
sftp.UploadFile(stream, filePath, true);
sftp.Disconnect();
}
}
catch (Exception ex)
{
Log.Error(ex);
throw new Exception("Sftp skjema feilet");
}
Task.Run(() => LogEntryService.AddLogEntry(new LogEntry {
ElementId = path + "/" + filename, Operation = Operation.Added, User = ClaimsPrincipal.Current.GetUsername(), Description = "Ftp gml-skjema til prod"
}));
return(SchemaRemoteUrl + path + "/" + filename);
}
public void MoveFile(string sourcePath, string destinationPath)
{
using SftpClient sftpClient = CreateSftpClient();
sftpClient.Connect();
sftpClient.Get(sourcePath).MoveTo(destinationPath);
sftpClient.Disconnect();
}
public HResult GetFileDataCallback(int commandId, string relativePath, ulong byteOffset, uint length, Guid dataStreamId, byte[] contentId, byte[] providerId, uint triggeringProcessId, string triggeringProcessImageFileName)
{
if (string.IsNullOrWhiteSpace(relativePath))
{
return(HResult.Ok);
}
else
{
var fullPath = GetFullPath(relativePath);
if (sftpClient.Exists(fullPath))
{
var file = sftpClient.Get(fullPath);
uint desiredBufferSize = (uint)Math.Min(64 * 1024, file.Length);
using (var reader = sftpClient.OpenRead(fullPath)) {
using (var writeBuffer = virtualization.CreateWriteBuffer(byteOffset, desiredBufferSize, out var alignedWriteOffset, out var alignedBufferSize)) {
while (alignedWriteOffset < (ulong)file.Length)
{
writeBuffer.Stream.Seek(0, SeekOrigin.Begin);
var currentBufferSize = Math.Min(desiredBufferSize, (ulong)file.Length - alignedWriteOffset);
var buffer = new byte[currentBufferSize];
reader.Read(buffer, 0, (int)currentBufferSize);
writeBuffer.Stream.Write(buffer, 0, (int)currentBufferSize);
var hr = virtualization.WriteFileData(dataStreamId, writeBuffer, alignedWriteOffset, (uint)currentBufferSize);
if (hr != HResult.Ok)
{
return(HResult.InternalError);
}
alignedWriteOffset += (ulong)currentBufferSize;
}
}
}
return(HResult.Ok);
}
else
{
return(HResult.FileNotFound);
}
}
}
private static long BackupFile(string root, string remotePath, SftpClient client)
{
string name = Path.GetFileName(remotePath);
// trim rooted paths, including drive letters
string localPath = Regex.Replace(remotePath, @"^\/[A-Za-z]\:[/\\]", string.Empty).Trim('/', '\\');
string fileName = Path.Combine(root, localPath);
try
{
SftpFile file = client.Get(remotePath);
if (file.IsRegularFile &&
(!File.Exists(fileName) || file.LastWriteTimeUtc > File.GetLastWriteTimeUtc(fileName)))
{
string tempFile = fileName + ".__TEMP__";
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
using (FileStream stream = File.Create(tempFile))
{
long prevProgress = 0;
client.DownloadFile(remotePath, stream, (progress) =>
{
Interlocked.Add(ref bytesDownloaded, ((long)progress - prevProgress));
prevProgress = (long)progress;
});
}
if (File.Exists(tempFile) && new FileInfo(tempFile).Length == file.Length)
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.Move(tempFile, fileName);
File.SetLastWriteTimeUtc(fileName, file.LastWriteTimeUtc);
}
}
else
{
Interlocked.Add(ref bytesSkipped, file.Length);
}
return(file.Length);
}
catch (SftpPathNotFoundException)
{
// OK
}
catch (SftpPermissionDeniedException)
{
// OK
}
catch (Exception ex)
{
Console.WriteLine("Error: {0} ", ex.Message);
}
return(0);
}
public void Test_Get_File_Null()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var file = sftp.Get(null);
sftp.Disconnect();
}
}
public void Test_Get_File_Null()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var file = sftp.Get(null);
sftp.Disconnect();
}
}
public void Test_Get_Root_Directory()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var directory = sftp.Get("/");
Assert.AreEqual("/", directory.FullName);
Assert.IsTrue(directory.IsDirectory);
Assert.IsFalse(directory.IsRegularFile);
}
}
public void Test_Get_Root_Directory()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
var directory = sftp.Get("/");
Assert.AreEqual("/", directory.FullName);
Assert.IsTrue(directory.IsDirectory);
Assert.IsFalse(directory.IsRegularFile);
}
}
public ItemInfo GetItemInfo(string path)
{
if (!string.IsNullOrWhiteSpace(_rootPath))
{
path = LexicalPath.Combine(_rootPath, path);
}
var info = _client.Get(path);
return(new ItemInfo {
Name = info.Name, Size = info.Length, IsDir = info.IsDirectory, Id = info.FullName, LastWriteTime = info.LastWriteTime
});
}
/// <summary>
/// Lists the files.
/// </summary>
/// <param name="remotePath">The remote path.</param>
/// <param name="failRemoteNotExists">if set to <c>true</c> [fail remote not exists].</param>
/// <returns></returns>
/// <exception cref="System.Exception"></exception>
public List <IRemoteFileInfo> ListFiles(string remotePath)
{
List <IRemoteFileInfo> fileList = new List <IRemoteFileInfo>();
try
{
this.Log(String.Format("Connecting to Host: [{0}].", this.hostName), LogLevel.Minimal);
using (SftpClient sftp = new SftpClient(this.hostName, this.portNumber, this.userName, this.passWord))
{
sftp.Connect();
this.Log(String.Format("Connected to Host: [{0}].", this.hostName), LogLevel.Verbose);
if (!sftp.Exists(remotePath))
{
this.Log(String.Format("Remote Path Does Not Exist: [{0}].", this.hostName), LogLevel.Verbose);
if (this.stopOnFailure)
{
throw new Exception(String.Format("Invalid Path: [{0}]", remotePath));
}
}
else
{
this.Log(String.Format("Listing Files: [{0}].", remotePath), LogLevel.Minimal);
this.Log(String.Format("Getting Attributes: [{0}].", remotePath), LogLevel.Verbose);
SftpFile sftpFileInfo = sftp.Get(remotePath);
if (sftpFileInfo.IsDirectory)
{
this.Log(String.Format("Path is a Directory: [{0}].", remotePath), LogLevel.Verbose);
IEnumerable <SftpFile> dirList = sftp.ListDirectory(remotePath);
foreach (SftpFile sftpFile in dirList)
{
fileList.Add(this.CreateFileInfo(sftpFile));
}
}
else
{
this.Log(String.Format("Path is a File: [{0}].", remotePath), LogLevel.Verbose);
fileList.Add(this.CreateFileInfo(sftpFileInfo));
}
}
}
this.Log(String.Format("Disconnected from Host: [{0}].", this.hostName), LogLevel.Minimal);
}
catch (Exception ex)
{
this.Log(String.Format("Disconnected from Host: [{0}].", this.hostName), LogLevel.Minimal);
this.ThrowException("Unable to List: ", ex);
}
return(fileList);
}
///<summary>Synchronous. Returns true if a file exists in the passed in filePath</summary>
private static bool FileExists(SftpClient client, string filePath)
{
bool retVal = false;
try {
bool hadToConnect = client.ConnectIfNeeded();
client.Get(filePath);
client.DisconnectIfNeeded(hadToConnect);
retVal = true;
}
catch (Exception) {
}
return(retVal);
}
private static long BackupFolder(HostEntry host, string root, string path, SftpClient client, StreamWriter log)
{
long size = 0;
foreach (string fileOrFolder in path.Split('|').Select(s => s.Trim()).Where(s => s.Length != 0))
{
if (!client.Exists(fileOrFolder))
{
continue;
}
SftpFile file;
try
{
file = client.Get(fileOrFolder);
}
catch (SftpPathNotFoundException)
{
continue;
}
catch (Exception ex)
{
log.WriteLine("Error backing up folder {0}: {1}", fileOrFolder, ex);
continue;
}
if (file.IsRegularFile)
{
Interlocked.Add(ref size, BackupFile(root, file.FullName, client));
}
else
{
try
{
SftpFile[] files = client.ListDirectory(fileOrFolder).Where(f => f.IsRegularFile || (f.IsDirectory && !f.Name.StartsWith("."))).ToArray();
Parallel.ForEach(files.Where(f => f.IsRegularFile && (host.IgnoreRegex == null || !host.IgnoreRegex.IsMatch(f.FullName))), parallelOptions, (_file) =>
{
Interlocked.Add(ref size, BackupFile(root, _file.FullName, client));
});
Parallel.ForEach(files.Where(f => f.IsDirectory && (host.IgnoreRegex == null || !host.IgnoreRegex.IsMatch(f.FullName))), parallelOptions2, (folder) =>
{
Interlocked.Add(ref size, BackupFolder(host, root, folder.FullName, client, log));
});
}
catch (Exception ex)
{
log.WriteLine("Failed to backup file or folder {0}, error: {1}", fileOrFolder, ex.Message);
}
}
}
return(size);
}
private IEnumerable <Tuple <string, string> > GetRemoteListing(string remotePath, string localPath, bool recursive)
{
if (string.IsNullOrWhiteSpace(remotePath))
{
throw new ArgumentNullException(nameof(remotePath));
}
if (string.IsNullOrWhiteSpace(localPath))
{
throw new ArgumentNullException(nameof(localPath));
}
string initialWorkingDirectory = _sftpClient.WorkingDirectory;
_sftpClient.ChangeDirectory(remotePath);
List <Tuple <string, string> > listing = new List <Tuple <string, string> >();
SftpFile currentDirectory = _sftpClient.Get(_sftpClient.WorkingDirectory);
IEnumerable <SftpFile> items = _sftpClient.ListDirectory(currentDirectory.FullName);
string nextLocalPath = Path.Combine(localPath, currentDirectory.Name);
foreach (SftpFile file in items.Where(i => i.IsRegularFile))
{
listing.Add(new Tuple <string, string>(Path.Combine(nextLocalPath, file.Name), file.FullName));
}
if (recursive)
{
foreach (SftpFile directory in items.Where(i => i.IsDirectory && i.Name != "." && i.Name != ".."))
{
listing.AddRange(GetRemoteListing(directory.FullName, nextLocalPath, recursive));
}
}
_sftpClient.ChangeDirectory(initialWorkingDirectory);
return(listing);
}
public Boolean MyFTPFileHasData(string remoteFile)
{
using (var sftp = new SftpClient(host, Port, user, pass))
{
Boolean isData = false;
String[] dList = new string[] { };
sftp.Connect();
if (sftp.Get(remoteFile).Length > 500)
{
isData = true;
}
sftp.Disconnect();
return(isData);
}
}
//ファイルサイズを取得
public long GetFileSize(string From_File, bool IsErrorLogMode = false)
{
if (!IsConnected)
{
return(0);
}
else if (!SFTP_Server.IsConnected)
{
SFTP_Server.Connect();
}
try
{
SftpFile GetFileInfo = SFTP_Server.Get(From_File);
return(GetFileInfo.Attributes.Size);
}
catch (Exception e)
{
if (IsErrorLogMode)
{
Sub_Code.Error_Log_Write(e.Message);
}
return(0);
}
}
public void Test_Get_File()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
sftp.UploadFile(new MemoryStream(), "abc.txt");
var file = sftp.Get("abc.txt");
Assert.AreEqual("/home/tester/abc.txt", file.FullName);
Assert.IsTrue(file.IsRegularFile);
Assert.IsFalse(file.IsDirectory);
}
}
public override async Task <IFile> GetFileAsync(string path, CancellationToken cancellationToken = default)
{
path = PrependRootPath(path);
try
{
var file = await Task.Run(() => client.Get(path), cancellationToken);
if (file.IsDirectory)
{
throw new FileNotFoundException(path, Prefix);
}
return(ModelFactory.CreateFile(file));
}
catch (SftpPathNotFoundException)
{
throw new FileNotFoundException(path, Prefix);
}
catch (Exception exception)
{
throw Exception(exception);
}
}
public void Test_Get_International_File()
{
using (var sftp = new SftpClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
sftp.Connect();
sftp.UploadFile(new MemoryStream(), "test-üöä-");
var file = sftp.Get("test-üöä-");
Assert.AreEqual("/home/tester/test-üöä-", file.FullName);
Assert.IsTrue(file.IsRegularFile);
Assert.IsFalse(file.IsDirectory);
}
}
public FDCDirectoryInfo GetDirectoryInfo(string server, int port, string directory)
{
directory = AdjustPath(server, directory);
SftpClient client = null;
try
{
client = OpenSftpClient(server, port);
try
{
SftpFile a = client.Get(directory);
if (a.IsDirectory)
{
return new FDCDirectoryInfo {
CreationTimeUtc = a.LastWriteTimeUtc, LastAccessTimeUtc = a.LastAccessTimeUtc, LastWriteTimeUtc = a.LastWriteTimeUtc
}
}
;
}
catch
{
}
finally
{
RecycleClient(client);
client = null;
}
}
catch (Exception ex)
{
try
{
client.Disconnect();
}
catch { }
try
{
client.Dispose();
}
catch { }
STEM.Sys.EventLog.WriteEntry("Authentication.GetDirectoryInfo", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error);
}
return(null);
}
public FDCFileInfo GetFileInfo(string server, int port, string file)
{
file = AdjustPath(server, file);
SftpClient client = null;
try
{
client = OpenSftpClient(server, port);
try
{
SftpFile a = client.Get(file);
if (a.IsRegularFile)
{
return new FDCFileInfo {
CreationTimeUtc = a.LastWriteTimeUtc, LastAccessTimeUtc = a.LastAccessTimeUtc, LastWriteTimeUtc = a.LastWriteTimeUtc, Size = a.Attributes.Size
}
}
;
}
catch
{
}
finally
{
RecycleClient(client);
client = null;
}
}
catch (Exception ex)
{
try
{
client.Disconnect();
}
catch { }
try
{
client.Dispose();
}
catch { }
STEM.Sys.EventLog.WriteEntry("Authentication.GetFileInfo", ex.ToString(), STEM.Sys.EventLog.EventLogEntryType.Error);
}
return(null);
}
/// <summary>
/// 保存到联贷平台SFTP
/// </summary>
public bool SaveToGFSftp(string remotePath, Stream fileStream, string fileName)
{
var isSuccess = false;
try
{
using (var client = new SftpClient(gfFtpIp, int.Parse(gfFtpPort), gfFtpAccount, gfFtpPassword)) //创建连接对象
{
client.Connect(); //连接
if (!client.Exists(remotePath))
{
var paths = remotePath.Split('/');
if (paths.Length > 1)
{
var path = "";
foreach (var p in paths)
{
path += "/" + p;
if (!client.Exists(path))
{
client.CreateDirectory(path);
}
}
}
}
client.ChangeDirectory(remotePath); //切换目录
client.UploadFile(fileStream, fileName); //上传文件
var stpFile = client.Get(fileName);
if (stpFile.IsRegularFile)
{
isSuccess = true;
}
client.Disconnect();
}
}
catch (Exception ex)
{
AppUtility.Engine.LogWriter.Write($"联贷平台SFTP上传{remotePath}/{fileName}文件错误{ex.ToString()}");
}
return(isSuccess);
}
public void GetTest()
{
ConnectionInfo connectionInfo = null; // TODO: Initialize to an appropriate value
SftpClient target = new SftpClient(connectionInfo); // TODO: Initialize to an appropriate value
string path = string.Empty; // TODO: Initialize to an appropriate value
SftpFile expected = null; // TODO: Initialize to an appropriate value
SftpFile actual;
actual = target.Get(path);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
