Merge pull request #15 from andreaskueffel/development

add DateTime format option for DestinationPath on AbstractProvider

Author: andreaskueffel

FileSyncApp/Program.cs

@@ -62,9 +62,9 @@ static void RunProgram()
                 jobOptions.Add("CleanJob", cleanJob);
 
                 var syncFromEdgeToLocal = FileSyncJobOptionsBuilder.CreateBuilder()
-                    .WithSourcePath("\\\\edgeip\\share\\service\\production")
+                    .WithSourcePath("scp://edgeip/service/production")
                     .WithDestinationPath("temp")
-                    .WithFileSyncProvider(SyncProvider.SMBLib)
+                    .WithFileSyncProvider(SyncProvider.Abstract)
                     .WithSubfolder("left")
                     .WithSubfolder("right")
                     .WithCredentials(new System.Net.NetworkCredential("USER", "Password", ""))

FileSyncLibNet/AccessProviders/FileIoAccessProvider.cs

@@ -8,8 +8,11 @@ namespace FileSyncLibNet.AccessProviders
 {
     internal class FileIoAccessProvider : IAccessProvider
     {
-        public string AccessPath { get; }
-        public FileIoAccessProvider(string accessPath)
+        public string AccessPath { get; private set; }
+        public FileIoAccessProvider()
+        {
+        }
+        public void UpdateAccessPath(string accessPath)
         {
             AccessPath = accessPath;
         }

FileSyncLibNet/AccessProviders/IAccessProvider.cs

@@ -8,6 +8,7 @@ namespace FileSyncLibNet.AccessProviders
     internal interface IAccessProvider
     {
         void CreateDirectory(string path);
+        void UpdateAccessPath(string path);
         List<FileInfo2> GetFiles(DateTime minimumLastWriteTime, string pattern, string path = null, bool recursive = false, List<string> subfolders = null);
         FileInfo2 GetFileInfo(string path);
         void Delete(FileInfo2 fileInfo);

FileSyncLibNet/AccessProviders/ScpAccessProvider.cs

@@ -11,17 +11,35 @@ namespace FileSyncLibNet.AccessProviders
 {
     internal class ScpAccessProvider : IAccessProvider
     {
-        string AccessPathUri { get; }
+        public string AccessPathUri { get; private set; }
         NetworkCredential Credentials { get; }
         SftpClient ftpClient;
         public string AccessPath { get; private set; }
 
-        public ScpAccessProvider(string accessPath, NetworkCredential credentials)
+        public ScpAccessProvider(NetworkCredential credentials)
         {
-            AccessPathUri = accessPath;
             Credentials = credentials;
-            //CreateClient();
         }
+        public void UpdateAccessPath(string accessPath) 
+        { 
+            AccessPathUri = accessPath;
+            var pattern = @"scp://(?:(?<user>[^@]+)@)?(?<host>[^:/]+)(?::(?<port>\d+))?(?<path>/.*)?";
+            var match = Regex.Match(AccessPathUri, pattern);
+
+
+            if (!match.Success)
+            {
+                throw new UriFormatException($"Unable to match scp pattern with given URL {AccessPathUri}, use format scp://host:port/path");
+            }
+            else
+            {
+                AccessPath = match.Groups["path"].Value;
+                if (AccessPath.StartsWith("/~"))
+                    AccessPath = AccessPath.Substring(1);
+            }
+        }
+
+
         void CreateClient()
         {
             var pattern = @"scp://(?:(?<user>[^@]+)@)?(?<host>[^:/]+)(?::(?<port>\d+))?(?<path>/.*)?";
@@ -44,6 +62,7 @@ void CreateClient()
                 ftpClient = new SftpClient(host, port, Credentials.UserName, Credentials.Password);
             }
         }
+        
         void EnsureConnected()
         {
             if (ftpClient == null)

FileSyncLibNet/SyncProviders/AbstractProvider.cs

@@ -18,20 +18,23 @@ public AbstractProvider(IFileJobOptions jobOptions) : base(jobOptions)
                 throw new ArgumentException("this instance has no information about syncing files, it has type " + JobOptions.GetType().ToString());
             if (syncJobOptions.SourcePath.StartsWith("scp:"))
             {
-                SourceAccess = new ScpAccessProvider(syncJobOptions.SourcePath, syncJobOptions.Credentials);
+                SourceAccess = new ScpAccessProvider(syncJobOptions.Credentials);
+
             }
             else
             {
-                SourceAccess = new FileIoAccessProvider(syncJobOptions.SourcePath);
+                SourceAccess = new FileIoAccessProvider();
             }
+            SourceAccess.UpdateAccessPath(syncJobOptions.SourcePath);
             if (syncJobOptions.DestinationPath.StartsWith("scp:"))
             {
-                DestinationAccess = new ScpAccessProvider(syncJobOptions.DestinationPath, syncJobOptions.Credentials);
+                DestinationAccess = new ScpAccessProvider(syncJobOptions.Credentials);
             }
             else
             {
-                DestinationAccess = new FileIoAccessProvider(syncJobOptions.DestinationPath);
+                DestinationAccess = new FileIoAccessProvider();
             }
+
         }
 
         public override void DeleteFiles()
@@ -44,29 +47,40 @@ public override void SyncSourceToDest()
             if (!(JobOptions is IFileSyncJobOptions jobOptions))
                 throw new ArgumentException("this instance has no information about syncing files, it has type " + JobOptions.GetType().ToString());
             var sw = Stopwatch.StartNew();
+
             try
             {
-                DestinationAccess.CreateDirectory("");
+                string formattedDestinationPath = string.Format(jobOptions.DestinationPath, DateTime.Now);
+                DestinationAccess.UpdateAccessPath(formattedDestinationPath);
             }
-            catch (Exception ex) { logger?.LogError(ex, "exception creating destination directory {A}", jobOptions.DestinationPath); }
-            if (JobOptions.Credentials != null)
-            {
+            catch (Exception ex) { logger?.LogError(ex, "exception formatting destination accesspath with DateTime.Now as 0 arg {A}", jobOptions.DestinationPath); }
 
-            }
+            bool createDestinationDir = true;
             int copied = 0;
             int skipped = 0;
             var minimumLastWriteTime = jobOptions.RememberLastSync ? (LastRun - jobOptions.Interval - jobOptions.Interval) : DateTime.MinValue;
             bool error_occured = false;
             try
             {
-                var sourceFiles = SourceAccess.GetFiles(minimumLastWriteTime.DateTime, JobOptions.SearchPattern, recursive: JobOptions.Recursive, subfolders: JobOptions.Subfolders);
-
+                var sourceFiles = SourceAccess.GetFiles(minimumLastWriteTime: minimumLastWriteTime.DateTime,
+                                                        pattern: JobOptions.SearchPattern,
+                                                        recursive: JobOptions.Recursive,
+                                                        subfolders: JobOptions.Subfolders);
                 foreach (var sourceFile in sourceFiles)
                 {
                     var remoteFile = DestinationAccess.GetFileInfo(sourceFile.Name);
                     bool copy = !remoteFile.Exists || remoteFile.Length != sourceFile.Length || remoteFile.LastWriteTime != sourceFile.LastWriteTime;
                     if (copy)
                     {
+                        if (createDestinationDir)
+                        {
+                            try
+                            {
+                                DestinationAccess.CreateDirectory("");
+                            }
+                            catch (Exception ex) { logger?.LogError(ex, "exception creating destination directory {A}", jobOptions.DestinationPath); }
+                            createDestinationDir = false;
+                        }
                         try
                         {
                             logger.LogDebug("Copy {A}", sourceFile.Name);
@@ -100,7 +114,7 @@ public override void SyncSourceToDest()
                     LastRun = DateTimeOffset.Now;
                 }
             }
-            catch(Exception exc)
+            catch (Exception exc)
             {
                 logger.LogError(exc, "Exception in main logic of abstract provider");
             }