Initial

ServiceFabricUploader.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "ServiceFabricUploader", "src\ServiceFabricUploader\ServiceFabricUploader.xproj", "{3E1D7C4D-27B3-4AB6-9EE6-B8D0386EAF1D}"
+EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SfRestApi", "src\SfRestApi\SfRestApi.xproj", "{26533E1D-9E12-4D0B-A7A0-4A864249B3BA}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3E1D7C4D-27B3-4AB6-9EE6-B8D0386EAF1D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3E1D7C4D-27B3-4AB6-9EE6-B8D0386EAF1D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3E1D7C4D-27B3-4AB6-9EE6-B8D0386EAF1D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3E1D7C4D-27B3-4AB6-9EE6-B8D0386EAF1D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{26533E1D-9E12-4D0B-A7A0-4A864249B3BA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{26533E1D-9E12-4D0B-A7A0-4A864249B3BA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{26533E1D-9E12-4D0B-A7A0-4A864249B3BA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{26533E1D-9E12-4D0B-A7A0-4A864249B3BA}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

src/ServiceFabricUploader/Commands/Application/ApplicationCommands.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using Microsoft.Extensions.CommandLineUtils;
+using ServiceFabricUploader.Models;
+
+namespace ServiceFabricUploader.Commands.Application
+{
+    public class ApplicationCommands
+    {
+        public static void Configure(CommandLineApplication app)
+        {
+            app.Command("application", application =>
+            {
+                ProvisionCommand.Configure(application);
+            });
+        }
+    }
+}

src/ServiceFabricUploader/Commands/Application/ProvisionCommand.cs

@@ -0,0 +1,42 @@
+using System.Threading.Tasks;
+using Microsoft.Extensions.CommandLineUtils;
+using ServiceFabricUploader.Models;
+using SfRestApi.Endpoints;
+
+namespace ServiceFabricUploader.Commands.Application
+{
+    public class ProvisionCommand
+    {
+        private static AppOptionsRaw _appOptions;
+        private static ProvisionCommandOptionsRaw _provisionCommandOptions;
+
+        public static void Configure(CommandLineApplication app)
+        {
+            app.Command("provision", application =>
+            {
+                _appOptions = new AppOptionsRaw(application);
+                _provisionCommandOptions = new ProvisionCommandOptionsRaw(application);
+
+                application.OnExecute(async () =>
+                {
+                    var appConfig = AppOptions.ValidateAndCreate(_appOptions);
+                    var commandConfig = ProvisionCommandOptions.VerifyAndCreateArgs(_provisionCommandOptions);
+                    var command = new ProvisionCommand();
+                    return await command.RunAsync(appConfig, commandConfig).ConfigureAwait(false);
+                });
+            });
+        }
+
+        public async Task<int> RunAsync(AppOptions appOptions, ProvisionCommandOptions commandConfig)
+        {
+            var connectionInfo = ConnectionInfoHelper.CreateConnectionInfo(appOptions);
+            var connection = connectionInfo.CreateClusterConnection();
+            var logger = new Logger(appOptions.Verbose);
+
+            var register = new Register(connection, logger);
+            var registerSuccess = await register.RegisterAsync(commandConfig.PackageName).ConfigureAwait(false);
+
+            return registerSuccess ? 0 : -1;
+        }
+    }
+}

src/ServiceFabricUploader/Commands/Application/ProvisionCommandOptions.cs

@@ -0,0 +1,33 @@
+using System;
+using Microsoft.Extensions.CommandLineUtils;
+
+namespace ServiceFabricUploader.Commands.Application
+{
+    public class ProvisionCommandOptionsRaw
+    {
+        public ProvisionCommandOptionsRaw(CommandLineApplication app)
+        {
+            PackageName = app.Option("--packageName", "Package name in ImageStore", CommandOptionType.SingleValue);
+        }
+
+        public CommandOption PackageName { get; set; }
+    }
+
+    public class ProvisionCommandOptions
+    {
+        internal ProvisionCommandOptions(ProvisionCommandOptionsRaw rawConfig)
+        {
+            if (!rawConfig.PackageName.HasValue())
+                throw new ArgumentException("No Package Name specified");
+
+            PackageName = rawConfig.PackageName.Value();
+        }
+
+        public string PackageName { get; set; }
+
+        public static ProvisionCommandOptions VerifyAndCreateArgs(ProvisionCommandOptionsRaw rawConfig)
+        {
+            return new ProvisionCommandOptions(rawConfig);
+        }
+    }
+}

src/ServiceFabricUploader/Commands/ImageStore/ImageStoreCommand.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.CommandLineUtils;
+
+namespace ServiceFabricUploader.Commands.ImageStore
+{
+    public class ImageStoreCommand
+    {
+        public static void Configure(CommandLineApplication app)
+        {
+            app.Command("imagestore", application =>
+            {
+                UploadCommand.Configure(application);
+            });
+        }
+    }
+}

src/ServiceFabricUploader/Commands/ImageStore/UploadCommand.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.CommandLineUtils;
+using ServiceFabricUploader.Models;
+
+namespace ServiceFabricUploader.Commands.ImageStore
+{
+    public class UploadCommand
+    {
+        private static AppOptionsRaw _appOptions;
+        private static UploadCommandOptionsRaw _uploadCommandOptions;
+
+        public static void Configure(CommandLineApplication app)
+        {
+            app.Command("upload", application =>
+            {
+                _appOptions = new AppOptionsRaw(application);
+                _uploadCommandOptions = new UploadCommandOptionsRaw(application);
+
+                application.OnExecute(async () =>
+                {
+                    var appConfig = AppOptions.ValidateAndCreate(_appOptions);
+                    var commandConfig = UploadCommandOptions.VerifyAndCreateArgs(_uploadCommandOptions);
+                    var command = new UploadCommand();
+                    var exitCode = await command.RunAsync(appConfig, commandConfig).ConfigureAwait(false);
+                    return exitCode;
+                });
+            });
+        }
+
+        public async Task<int> RunAsync(AppOptions appOptions, UploadCommandOptions commandConfig)
+        {
+            var connectionInfo = ConnectionInfoHelper.CreateConnectionInfo(appOptions);
+            var connection = connectionInfo.CreateClusterConnection();
+
+            var filesToUpload = DiscoverFilesToUploadRecursivly(commandConfig.PackageSourcePath,
+                commandConfig.PackageSourcePath.FullName);
+
+            var logger = new Logger(appOptions.Verbose);
+            var imageStore = new SfRestApi.Endpoints.ImageStore(connection, logger);
+            var failedUploads = new List<FileInfo>();
+
+            foreach (var fileToUpload in filesToUpload)
+            {
+                var success =
+                    await imageStore.UploadAsync(fileToUpload.Key, fileToUpload.Value, commandConfig.PackageName).ConfigureAwait(false);
+                if (!success)
+                    failedUploads.Add(fileToUpload.Key);
+            }
+
+            if (!failedUploads.Any())
+            {
+                logger.Log($"Upload completed.");
+                return 0;
+            }
+
+            logger.LogError("Failed to upload some files, aborting");
+            return -1;
+        }
+
+        private static Dictionary<FileInfo, string> DiscoverFilesToUploadRecursivly(DirectoryInfo sourceDirectory,
+            string baseDirectory)
+        {
+            var filesToUpload = sourceDirectory
+                .GetFiles()
+                .ToDictionary(fileInfo => fileInfo,
+                    fileInfo => fileInfo.FullName.Substring(baseDirectory.Length + 1).Replace("/", "\\"));
+
+            var markFileName = Path.Combine(sourceDirectory.FullName, "_.dir");
+            //File.Create(markFileName).Dispose();
+            var markFile = new FileInfo(markFileName);
+            filesToUpload.Add(markFile, markFile.FullName.Substring(baseDirectory.Length + 1));
+
+            var subFolders = sourceDirectory.GetDirectories();
+            if (!subFolders.Any())
+                return filesToUpload;
+
+            foreach (var subFolder in subFolders)
+            {
+                var fromSubFolders = DiscoverFilesToUploadRecursivly(subFolder, baseDirectory);
+                foreach (var fromSubFolder in fromSubFolders)
+                {
+                    filesToUpload.Add(fromSubFolder.Key, fromSubFolder.Value);
+                }
+            }
+
+            return filesToUpload;
+        }
+    }
+}

src/ServiceFabricUploader/Commands/ImageStore/UploadCommandOptions.cs

@@ -0,0 +1,41 @@
+using System;
+using System.IO;
+using Microsoft.Extensions.CommandLineUtils;
+
+namespace ServiceFabricUploader.Commands.ImageStore
+{
+    public class UploadCommandOptionsRaw
+    {
+        public UploadCommandOptionsRaw(CommandLineApplication app)
+        {
+            PackageSourcePath = app.Option("--packageSource", "Source path of the package",
+                CommandOptionType.SingleValue);
+            PackageName = app.Option("--packageName", "Package name in ImageStore",
+                CommandOptionType.SingleValue);
+        }
+
+        public CommandOption PackageSourcePath { get; set; }
+        public CommandOption PackageName { get; set; }
+    }
+
+    public class UploadCommandOptions
+    {
+        public DirectoryInfo PackageSourcePath { get; set; }
+        public string PackageName { get; set; }
+
+        public static UploadCommandOptions VerifyAndCreateArgs(UploadCommandOptionsRaw rawConfig)
+        {
+            if (!rawConfig.PackageSourcePath.HasValue())
+                throw new ArgumentException("No Package Source Path specified");
+
+            if (!rawConfig.PackageName.HasValue())
+                throw new ArgumentException("No Package Name specified");
+
+            return new UploadCommandOptions
+            {
+                PackageSourcePath = new DirectoryInfo(rawConfig.PackageSourcePath.Value()),
+                PackageName = rawConfig.PackageName.Value()
+            };
+        }
+    }
+}

src/ServiceFabricUploader/ConnectionInfoHelper.cs

@@ -0,0 +1,23 @@
+using ServiceFabricUploader.Models;
+using SfRestApi.Models;
+
+namespace ServiceFabricUploader
+{
+    public static class ConnectionInfoHelper
+    {
+        internal static BaseClusterConnectionInfo CreateConnectionInfo(AppOptions options)
+        {
+            if (options.SecureCluster)
+            {
+                return SecureConnectionInfo.CreateSecure(
+                    options.ClusterHostname,
+                    options.ClusterPort,
+                    options.CertificateThumbprint,
+                    options.CertificateStore,
+                    options.CertificateLocation);
+            }
+
+            return NonSecureConnectionInfo.Create(options.ClusterHostname, options.ClusterPort);
+        }
+    }
+}

src/ServiceFabricUploader/Logger.cs

@@ -0,0 +1,33 @@
+using System;
+using SfRestApi;
+
+namespace ServiceFabricUploader
+{
+    public class Logger : ILogOutput
+    {
+        private readonly bool _verbose;
+
+        public Logger(bool verbose)
+        {
+            _verbose = verbose;
+        }
+
+        public void Log(string message)
+        {
+            if (_verbose)
+                return;
+
+            Console.WriteLine(message);
+        }
+
+        public void LogException(Exception ex)
+        {
+            Console.WriteLine(ex.ToString());
+        }
+
+        public void LogError(string message)
+        {
+            Console.WriteLine(message);
+        }
+    }
+}