/// <summary> /// Sync call to list directory contents /// </summary> /// <param name="session"></param> /// <param name="path"></param> /// <returns></returns> public ListDirectoryResult ListDirectory(SessionData session, BrowserFileInfo path) { ListDirectoryResult result; if (session == null || session.Username == null) { result = new ListDirectoryResult(path); result.ErrorMsg = "Session invalid"; result.StatusCode = ResultStatusCode.Error; } else { string targetPath = path.Path; if (targetPath == null || targetPath == ".") { targetPath = ScpUtils.GetHomeDirectory(session); Log.InfoFormat("Defaulting path: {0}->{1}", path.Path, targetPath); path.Path = targetPath; } PscpClient client = new PscpClient(this.Options, session); result = client.ListDirectory(path); } return result; }
void LoadDirectory(BrowserFileInfo path, ListDirectoryResult result) { if (path.Path == null) { // special case for drives/mounts foreach (DriveInfo drive in DriveInfo.GetDrives()) { BrowserFileInfo bfiDrive = new BrowserFileInfo(drive); result.Add(bfiDrive); result.MountCount++; } } else if (Directory.Exists(path.Path)) { // get new files DirectoryInfo newDir = new DirectoryInfo(path.Path); // add back (..) entry, if relevant if (newDir.Parent != null) { // has valid parent dir BrowserFileInfo bfiParent = new BrowserFileInfo(newDir.Parent); bfiParent.Name = ".."; bfiParent.Type = FileType.ParentDirectory; result.Add(bfiParent); } else { // hit top of root so list drives, special case of null path BrowserFileInfo bfiListDrives = new BrowserFileInfo { Path = null, Name = "..", Type = FileType.ParentDirectory, }; result.Add(bfiListDrives); } // dirs foreach (DirectoryInfo di in newDir.GetDirectories()) { BrowserFileInfo bfi = new BrowserFileInfo(di); result.Add(bfi); } // files foreach (FileInfo fi in newDir.GetFiles()) { BrowserFileInfo bfi = new BrowserFileInfo(fi); result.Add(bfi); } } else { result.SetError(string.Format("Directory doesn't exist: {0}", path.Path), null); } }
public static BrowserFileInfo NewDirectory(string dir) { BrowserFileInfo file = new BrowserFileInfo { Name = Path.GetFileName(dir), Path = dir, Type = FileType.Directory, Source = SourceType.Remote }; return file; }
public void Initialize(IBrowserPresenter presenter, BrowserFileInfo startingDir) { if (this.initialized) return; this.Presenter = presenter; this.Presenter.AuthRequest += (Presenter_AuthRequest); this.Bind(this.Presenter.ViewModel); this.Presenter.LoadDirectory(startingDir); this.ConfirmTransfer = true; this.initialized = true; }
public ListDirectoryResult ListDirectory(SessionData session, BrowserFileInfo path) { Log.InfoFormat("GetFilesForPath, path={0}", path.Path); ListDirectoryResult result = new ListDirectoryResult(path); try { LoadDirectory(path, result); } catch (Exception ex) { result.SetError(null, ex); Log.ErrorFormat("Error loading directory: {0}", ex.Message); } return result; }
public bool TryParseFileLine(string line, out BrowserFileInfo fileInfo) { bool success = false; if (line.StartsWith("Listing directory")) { // ignore header line and current dir fileInfo = null; } else { Match match = regExFileLine.Match(line); if (match.Success) { string name = match.Groups["FileName"].Value; fileInfo = new BrowserFileInfo { Name = name, Path = name, Owner = match.Groups["OwnerName"].Value, Group = match.Groups["GroupName"].Value, Permissions = match.Groups["Permissions"].Value, Source = SourceType.Remote }; fileInfo.Type = fileInfo.Name == ".." ? FileType.ParentDirectory : fileInfo.Permissions != null && fileInfo.Permissions.StartsWith("d") ? FileType.Directory : FileType.File; DateTime lastMod; if (TryParseTimestamp(match.Groups["Timestamp"].Value, out lastMod)) { fileInfo.LastModTime = lastMod; } int blocks; if (int.TryParse(match.Groups["BlockCount"].Value, out blocks)) { fileInfo.Size = blocks; } success = true; } else { Log.WarnFormat("Could not parse directory listing entry: '{0}'", line); fileInfo = null; } } return success; }
static string ToArgs(SessionData session, string password, List<BrowserFileInfo> source, BrowserFileInfo target) { StringBuilder sb = new StringBuilder(); sb.Append("-r -agent "); // default arguments if (!String.IsNullOrEmpty(session.PuttySession)) { sb.Append("-load \"").Append(session.PuttySession).Append("\" "); } if (!String.IsNullOrEmpty(password)) { sb.Append("-pw ").Append(password).Append(" "); } sb.AppendFormat("-P {0} ", session.Port); if (target.Source == SourceType.Remote) { // possible to send multiple files remotely at a time foreach(BrowserFileInfo file in source) { sb.AppendFormat("\"{0}\" ", file.Path); } sb.AppendFormat(" {0}@{1}:\"{2}\"", session.Username, session.Host, EscapeForUnix(target.Path)); } else { if (source.Count > 1) { Log.WarnFormat("Not possible to transfer multiple remote files locally at one time. Tranfering first only!"); } sb.AppendFormat(" {0}@{1}:\"{2}\" ", session.Username, session.Host, EscapeForUnix(source[0].Path)); sb.AppendFormat("\"{0}\"", target.Path); } return sb.ToString(); }
public ListDirectoryResult ListDirectory(BrowserFileInfo path) { lock (this) { //return this.DoListDirectory(path); ListDirectoryResult result = new ListDirectoryResult(path); RunPscp( result, ToArgs(this.Session, this.Session.Password, path.Path), ToArgs(this.Session, "XXXXX", path.Path), null, null, (lines) => { // successful list ScpLineParser parser = new ScpLineParser(); foreach (string rawLine in lines) { string line = rawLine.TrimEnd(); BrowserFileInfo fileInfo; if (parser.TryParseFileLine(line, out fileInfo)) { if (fileInfo.Name != ".") { fileInfo.Path = MakePath(path.Path, fileInfo.Name); result.Add(fileInfo); } } } }); return result; } }
/// <summary> /// Copy files /// </summary> /// <param name="sourceFiles"></param> /// <param name="target"></param> /// <param name="callback"></param> /// <returns></returns> public FileTransferResult CopyFiles(List<BrowserFileInfo> sourceFiles, BrowserFileInfo target, TransferUpdateCallback callback) { lock(this) { /// Known Issues: /// - If a large exe (or other file that the OS will virus scan) is tranfered, the operation will timeout. /// After completion, the OS seems to block on the final write (while scanning). During this time the process looks like it's /// hanging and the timeout logic kicks in. Hacked in "completed" logic into inlineOut/Err handlers but this is awkward FileTransferResult result = new FileTransferResult(); string args = ToArgs(this.Session, this.Session.Password, sourceFiles, target); string argsToLog = ToArgs(this.Session, "XXXXX", sourceFiles, target); ScpLineParser parser = new ScpLineParser(); RunPscp( result, args, argsToLog, (line) => { bool completed = false; if (callback != null) { FileTransferStatus status; if (parser.TryParseTransferStatus(line, out status)) { completed = status.PercentComplete == 100; callback(completed, false, status); } } return completed; }, null, null); return result; } }
public void Add(BrowserFileInfo fileInfo) { this.Files.Add(fileInfo); if (fileInfo.Type == FileType.File) { this.FileCount++; } else if (fileInfo.Type == FileType.Directory) { this.DirCount++; } }
public void LocalToRemote() { SessionData session = new SessionData { Username = ScpConfig.UserName, Password = ScpConfig.Password, Host = ScpConfig.KnownHost, Port = 22 }; List<BrowserFileInfo> sourceFiles = new List<BrowserFileInfo> { //new BrowserFileInfo(new FileInfo(Path.GetTempFileName())) new BrowserFileInfo(new FileInfo( @"D:\Downloads\vs2012_winexp_enu.iso" )) }; BrowserFileInfo target = new BrowserFileInfo { Path = string.Format("/home/{0}/", session.Username), Source = SourceType.Remote }; PscpOptions options = new PscpOptions { PscpLocation = ScpConfig.PscpLocation, TimeoutMs = 5000 }; PscpClient client = new PscpClient(options, session); PscpResult res = client.CopyFiles( sourceFiles, target, (complete, cancelAll, status) => { Log.InfoFormat( "complete={0}, cancelAll={1}, fileName={2}, pctComplete={3}", complete, cancelAll, status.Filename, status.PercentComplete); }); Log.InfoFormat("Result: {0}", res); /* ListDirectoryResult res = client.ListDirectory(new BrowserFileInfo { Path = "." }); Assert.AreEqual(ResultStatusCode.Success, res.StatusCode); Assert.Greater(res.Files.Count, 0); foreach (BrowserFileInfo file in res.Files) { Log.Info(file); } Log.InfoFormat("Result: {0}", res);*/ }
public void LoadDirectory(BrowserFileInfo dir) { if (this.BackgroundWorker.IsBusy) { this.ViewModel.Status = "Busying loading directory"; } else { this.ViewModel.BrowserState = BrowserState.Working; Log.InfoFormat("LoadDirectory, path={0}", dir); this.BackgroundWorker.RunWorkerAsync(dir); } }
public bool CanTransferFile(BrowserFileInfo source, BrowserFileInfo target) { return this.FileTransferPresenter.CanTransferFile(source, target); }
public bool CanTransferFile(BrowserFileInfo source, BrowserFileInfo target) { return true; }
public ListDirectoryResult(BrowserFileInfo path) { this.Path = path; this.Files = new List<BrowserFileInfo>(); }
public bool CanTransferFile(BrowserFileInfo source, BrowserFileInfo target) { // Source Target Result // 1) WindowsFile Local if not the same, File.Copy // 2) Local Local File.Copy // 3) Remote Local RemoteCopy bool canTransfer = true; if (target.Type == FileType.File || target.Type == FileType.ParentDirectory) { // can't drop on file or parent dir (..) canTransfer = false; } else if (target.Source == source.Source) { // can't drop local-on-local or remote-on-remote canTransfer = false; } else if (target.Path == source.Path) { // can't drop on self canTransfer = false; } /* Future...if/when local-on-local allowed else if (source.Source == SourceType.Local) { // can't drop into own folder...no op string sourceDir = Path.GetFullPath(Path.GetDirectoryName(source.Path)); string targetDir = Path.GetFullPath(target.Path); canTransfer = sourceDir != targetDir; }*/ return canTransfer; }
public BrowserView(IBrowserPresenter presenter, BrowserFileInfo startingDir) : this() { Initialize(presenter, startingDir); }