Console App

.travis.yml

@@ -4,25 +4,20 @@ dotnet: 2.0.0
 
 install:
   - export FrameworkPathOverride=$(dirname $(which mono))/../lib/mono/4.5/
-  #- curl -L -o nuget.exe https://dist.nuget.org/win-x86-commandline/latest/nuget.exe
   - dotnet restore
 
 script:
-  - dotnet build -c Debug --no-restore -v m
+  #- dotnet build -c Debug --no-restore -v m
   #- dotnet test Jenkins.Net.Tests/Jenkins.Net.Tests.csproj -c Debug --no-build --filter Category=Unit
-  - dotnet pack Jenkins.Net/Jenkins.Net.csproj -c Debug --no-build --no-restore -o bin
+  - dotnet pack Jenkins.Net/Jenkins.Net.csproj -c Debug -o bin -v m
+  - dotnet publish Jenkins.Net.Console/Jenkins.Net.Console.csproj -c Release -f net45 -o bin -v m -p:PublishSingleFile=true
 
 deploy:
   provider: releases
   api_key: $GITHUB_APIKEY
-  file: "Jenkins.Net/bin/jenkinsnet.*.nupkg"
+  file:
+    - "Jenkins.Net/bin/jenkinsnet.*.nupkg"
+    - "Jenkins.Net.Console/bin/Jenkins.Net.Console.exe"
   skip_cleanup: true
   on:
     tags: true
-
-# deploy:
-#   skip_cleanup: true
-#   provider: script
-#   script: dotnet nuget push Jenkins.Net/bin/jenkinsnet.*.nupkg -k $NUGET_APIKEY -s $NUGET_SOURCE
-#   on:
-#     branch: master

Jenkins.Net.Console/Arguments.cs

@@ -0,0 +1,52 @@
+using System;
+using JenkinsNET.Console.Internal;
+using System.Threading;
+using System.Threading.Tasks;
+using SysConsole = System.Console;
+
+namespace JenkinsNET.Console
+{
+    internal class Arguments : ArgumentsGroup
+    {
+        public RunArguments RunGroup {get;}
+        public Actions Action {get; private set;}
+
+
+        public Arguments()
+        {
+            RunGroup = new RunArguments();
+
+            Map("run").ToGroup(RunGroup, () => Action = Actions.Run);
+            Map("-help", "-?").ToAction(v => Action = Actions.Help);
+        }
+
+        public Task RunAsync(CancellationToken token = default)
+        {
+            switch (Action) {
+                case Actions.Run:
+                    return RunGroup.RunAsync(token);
+                default:
+                    PrintHelp();
+                    break;
+            }
+
+            return Task.CompletedTask;
+        }
+
+        private static void PrintHelp()
+        {
+            SysConsole.ResetColor();
+            SysConsole.WriteLine("Arguments:");
+            SysConsole.ForegroundColor = ConsoleColor.White;
+            SysConsole.WriteLine("   run ...");
+            SysConsole.WriteLine("  -help | -?");
+        }
+
+        public enum Actions
+        {
+            Undefined,
+            Run,
+            Help,
+        }
+    }
+}

Jenkins.Net.Console/Internal/ArgumentsGroup.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SysConsole = System.Console;
+
+namespace JenkinsNET.Console.Internal
+{
+    internal class ArgumentsGroup
+    {
+        private readonly Dictionary<string, ArgumentGroupAction> groupMap;
+        private readonly Dictionary<string, Action<string>> actionMap;
+
+
+        public ArgumentsGroup()
+        {
+            groupMap = new Dictionary<string, ArgumentGroupAction>(StringComparer.OrdinalIgnoreCase);
+            actionMap = new Dictionary<string, Action<string>>(StringComparer.OrdinalIgnoreCase);
+        }
+
+        public void Parse(string[] args)
+        {
+            for (var i = 0; i < args.Length; i++) {
+                var arg = args[i];
+
+                if (i == 0 && groupMap.TryGetValue(arg, out var groupItem)) {
+                    var subArgs = args.Skip(1).ToArray();
+                    groupItem.Action?.Invoke();
+                    groupItem.Group.Parse(subArgs);
+                    return;
+                }
+
+                var x = arg.IndexOfAny(new[] {'=', ':'});
+                var key = x >= 0 ? arg.Substring(0, x) : arg;
+                var value = x >= 0 ? arg.Substring(x + 1) : null;
+
+                if (actionMap.TryGetValue(key, out var action)) {
+                    action.Invoke(value);
+                    continue;
+                }
+
+                SysConsole.ForegroundColor = ConsoleColor.DarkYellow;
+                SysConsole.WriteLine($"Unknown argument '{arg}'!");
+            }
+        }
+
+        public ArgumentActionBuilder Map(params string[] args)
+        {
+            return new ArgumentActionBuilder(args, this);
+        }
+
+        public class ArgumentActionBuilder
+        {
+            private readonly string[] arguments;
+            private readonly ArgumentsGroup parentGroup;
+
+
+            public ArgumentActionBuilder(string[] arguments, ArgumentsGroup parentGroup)
+            {
+                this.arguments = arguments;
+                this.parentGroup = parentGroup;
+            }
+
+            public ArgumentActionBuilder ToGroup(ArgumentsGroup group, Action action = null)
+            {
+                foreach (var arg in arguments)
+                    parentGroup.groupMap[arg] = new ArgumentGroupAction(group, action);
+
+                return this;
+            }
+
+            public ArgumentActionBuilder ToAction(Action<string> action)
+            {
+                foreach (var arg in arguments)
+                    parentGroup.actionMap[arg] = action;
+
+                return this;
+            }
+
+            public ArgumentActionBuilder ToAction<T>(Action<T> action, T defaultValue = default)
+            {
+                foreach (var arg in arguments) {
+                    parentGroup.actionMap[arg] = value => {
+                        var valueT = value != null
+                            ? (T)Convert.ChangeType(value, typeof(T))
+                            : defaultValue;
+
+                        action.Invoke(valueT);
+                    };
+                }
+
+                return this;
+            }
+        }
+
+        private class ArgumentGroupAction
+        {
+            public ArgumentsGroup Group {get;}
+            public Action Action {get;}
+
+            public ArgumentGroupAction(ArgumentsGroup group, Action action)
+            {
+                this.Group = group;
+                this.Action = action;
+            }
+        }
+    }
+}

Jenkins.Net.Console/Internal/ExceptionExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace JenkinsNET.Console.Internal
+{
+    internal static class ExceptionExtensions
+    {
+        public static IEnumerable<Exception> UnfoldExceptions(this Exception error)
+        {
+            var e = error;
+            while (e != null) {
+                yield return e;
+                e = e.InnerException;
+            }
+        }
+
+        public static string UnfoldMessages(this Exception error)
+        {
+            var errors = error.UnfoldExceptions().Select(x => x.Message);
+            return string.Join(" ", errors);
+        }
+    }
+}

Jenkins.Net.Console/Jenkins.Net.Console.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net472</TargetFramework>
+    <RootNamespace>JenkinsNET.Console</RootNamespace>
+    <Version>1.0.5</Version>
+    <FileVersion>1.0.5</FileVersion>
+    <AssemblyVersion>1.0.5</AssemblyVersion>
+    <LangVersion>latest</LangVersion>
+    <AssemblyName>JenkinsNet.Console</AssemblyName>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Jenkins.Net\Jenkins.Net.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="Microsoft.CSharp" />
+  </ItemGroup>
+</Project>

Jenkins.Net.Console/Program.cs

@@ -0,0 +1,37 @@
+using JenkinsNET.Console.Internal;
+using System;
+using System.Threading.Tasks;
+using SysConsole = System.Console;
+
+namespace JenkinsNET.Console
+{
+    internal static class Program
+    {
+        public static async Task<int> Main(string[] args)
+        {
+            SysConsole.ForegroundColor = ConsoleColor.White;
+            SysConsole.WriteLine("Jenkins.NET Console");
+            SysConsole.WriteLine();
+
+            try {
+                var arguments = new Arguments();
+                arguments.Parse(args);
+
+                await arguments.RunAsync();
+
+                return 0;
+            }
+            catch (Exception error) {
+                SysConsole.ForegroundColor = ConsoleColor.Red;
+                SysConsole.WriteLine("[ERROR] ");
+                SysConsole.ForegroundColor = ConsoleColor.DarkRed;
+                SysConsole.WriteLine(error.UnfoldMessages());
+
+                return 1;
+            }
+            finally {
+                SysConsole.ResetColor();
+            }
+        }
+    }
+}

Jenkins.Net.Console/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "Jenkins.Net.Console": {
+      "commandName": "Project",
+      "commandLineArgs": "run -job=\"Test Job\" -p:Arg1=Hello -p:Arg2=\"World!\""
+    }
+  }
+}

Jenkins.Net.Console/RunArguments.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JenkinsNET.Console.Internal;
+using System.Threading;
+using System.Threading.Tasks;
+using JenkinsNET.Utilities;
+using SysConsole = System.Console;
+
+namespace JenkinsNET.Console
+{
+    internal class RunArguments : ArgumentsGroup
+    {
+        public Dictionary<string, string> JobParameters {get;}
+        public string JobName {get; private set;}
+        public bool ShowHelp {get; private set;}
+
+
+        public RunArguments()
+        {
+            Map("-job").ToAction(v => JobName = v);
+            Map("-p").ToAction(AddProperty);
+            Map("-help", "-?").ToAction(v => ShowHelp = v, false);
+
+            JobParameters = new Dictionary<string, string>();
+        }
+
+        public async Task RunAsync(CancellationToken token)
+        {
+            if (ShowHelp) {
+                PrintHelp();
+                return;
+            }
+
+            SysConsole.ForegroundColor = ConsoleColor.Cyan;
+            SysConsole.WriteLine($"Starting Job \"{JobName}\"...");
+
+            var client = new JenkinsClient {
+                BaseUrl = "http://localhost:8080/",
+                // TODO: Load from local file
+            };
+
+            var runner = new JenkinsJobRunner(client) {
+                MonitorConsoleOutput = true,
+                // TODO: Setup
+            };
+
+            runner.StatusChanged += () => {
+                SysConsole.ForegroundColor = ConsoleColor.White;
+                SysConsole.WriteLine($"[STATUS] {runner.Status}");
+            };
+
+            runner.ConsoleOutputChanged += text => {
+                SysConsole.ResetColor();
+                SysConsole.Write(text);
+            };
+
+            if (JobParameters.Any()) {
+                await runner.RunWithParametersAsync(JobName, JobParameters, token);
+            }
+            else {
+                await runner.RunAsync(JobName, token);
+            }
+        }
+
+        private void AddProperty(string property)
+        {
+            var x = property.IndexOf('=');
+            if (x < 0) throw new ApplicationException($"No value specified in property string '{property}'!");
+
+            var key = property.Substring(0, x);
+            var value = property.Substring(x + 1);
+            JobParameters[key] = value;
+        }
+
+        private static void PrintHelp()
+        {
+            SysConsole.ResetColor();
+            SysConsole.Write("Arguments: ");
+            SysConsole.ForegroundColor = ConsoleColor.DarkCyan;
+            SysConsole.WriteLine("run");
+            SysConsole.ForegroundColor = ConsoleColor.White;
+            SysConsole.WriteLine("  -job <name>");
+            SysConsole.WriteLine("  -p:<key>=<value>");
+            SysConsole.WriteLine("  -help | -?");
+        }
+    }
+}

Jenkins.Net.sln

@@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Jenkins.Net", "Jenkins.Net\
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Jenkins.Net.Tests", "Jenkins.Net.Tests\Jenkins.Net.Tests.csproj", "{C39D7FDD-F85E-4FEF-8E30-A23B04DD1787}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Jenkins.Net.Console", "Jenkins.Net.Console\Jenkins.Net.Console.csproj", "{DC01C670-176F-4587-B574-7FA73795F335}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{C39D7FDD-F85E-4FEF-8E30-A23B04DD1787}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C39D7FDD-F85E-4FEF-8E30-A23B04DD1787}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C39D7FDD-F85E-4FEF-8E30-A23B04DD1787}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DC01C670-176F-4587-B574-7FA73795F335}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DC01C670-176F-4587-B574-7FA73795F335}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DC01C670-176F-4587-B574-7FA73795F335}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DC01C670-176F-4587-B574-7FA73795F335}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE