Ejemplo n.º 1
0
        private static void About(ArgList args)
        {
            Console.WriteLine("Components:");
            var assemblyNames = new[] { "Inedo.SDK", "Inedo.ExecutionEngine", "Inedo.Agents.Client", "Inedo.UPack" };

            foreach (var asmName in assemblyNames)
            {
                var asm  = Assembly.Load(asmName);
                var name = asm.GetName();
                var info = FileVersionInfo.GetVersionInfo(asm.Location);
                Console.WriteLine("  " + name.Name + " " + info.FileVersion);
            }

            Console.WriteLine();
            Console.WriteLine("Extensions:");
            ExtensionsManager.WaitForInitialization();
            bool anyExtensions = false;

            foreach (var ext in ExtensionsManager.GetExtensions(false))
            {
                if (ext.LoadResult.Loaded)
                {
                    Console.WriteLine("  " + ext.Name + " " + ext.LoadResult.Version);
                    anyExtensions = true;
                }
            }

            if (!anyExtensions)
            {
                Console.WriteLine("  (no extensions loaded)");
            }
        }
Ejemplo n.º 2
0
        private static void Credentials(ArgList args)
        {
            var command = args.PopCommand()?.ToLowerInvariant();

            switch (command)
            {
            case "list":
                list();
                break;

            case "display":
                display();
                break;

            case "store":
                store();
                break;

            case "delete":
                delete();
                break;

            default:
                Console.WriteLine("Usage:");
                Console.WriteLine("romp credentials list");
                Console.WriteLine("romp credentials display <name> [--show-hidden]");
                Console.WriteLine("romp credentials store <name>");
                Console.WriteLine("romp credentials delete <name>");
                break;
            }

            void list()
            {
                foreach (var c in RompDb.GetCredentials())
                {
                    Console.WriteLine(c.CredentialType_Name + "::" + c.Credential_Name);
                }
            }

            void display()
            {
                var(type, name) = parseQualifiedName();
                var creds = RompDb.GetCredentialsByName(type, name);

                if (creds == null)
                {
                    throw new RompException($"Credentials {type}::{name} not found.");
                }

                bool showHidden = false;

                args.ProcessOptions(
                    o =>
                {
                    if (string.Equals(o.Key, "show-hidden", StringComparison.OrdinalIgnoreCase))
                    {
                        showHidden = true;
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
                    );

                args.ThrowIfAnyRemaining();

                var instance = (ResourceCredentials)Persistence.DeserializeFromPersistedObjectXml(creds.Configuration_Xml);

                Console.WriteLine($"Name: {creds.CredentialType_Name}::{creds.Credential_Name}");

                foreach (var prop in Persistence.GetPersistentProperties(instance.GetType(), false))
                {
                    var alias = prop.GetCustomAttribute <ScriptAliasAttribute>()?.Alias;
                    if (alias != null) // only show items with ScriptAlias
                    {
                        var  propName = prop.GetCustomAttribute <DisplayNameAttribute>()?.DisplayName ?? alias;
                        bool hidden   = prop.GetCustomAttribute <PersistentAttribute>().Encrypted;

                        var value = prop.GetValue(instance);
                        if (value is SecureString secure)
                        {
                            value = AH.Unprotect(secure);
                        }

                        if (hidden && !showHidden)
                        {
                            value = "(hidden)";
                        }
                        if (value == null)
                        {
                            value = "(not specified)";
                        }

                        Console.WriteLine(propName + ": " + value);
                    }
                }
            }

            void store()
            {
                var n    = parseQualifiedName();
                var type = (from c in ExtensionsManager.GetComponentsByBaseClass <ResourceCredentials>()
                            let a = c.ComponentType.GetCustomAttribute <ScriptAliasAttribute>()
                                    where string.Equals(a?.Alias, n.type, StringComparison.OrdinalIgnoreCase) || string.Equals(c.ComponentType.Name, n.type, StringComparison.OrdinalIgnoreCase)
                                    orderby string.Equals(a?.Alias, n.type, StringComparison.OrdinalIgnoreCase) descending
                                    select c.ComponentType).FirstOrDefault();

                if (type == null)
                {
                    throw new RompException($"Unknown credentials type \"{n.type}\". Are you missing an extension?");
                }

                var credentials = (ResourceCredentials)Activator.CreateInstance(type);

                if (!Console.IsInputRedirected)
                {
                    foreach (var property in Persistence.GetPersistentProperties(type, true))
                    {
Again:
                        Console.Write((property.GetCustomAttribute <DisplayNameAttribute>()?.DisplayName ?? property.Name) + ": ");
                        string value;
                        if (property.GetCustomAttribute <PersistentAttribute>()?.Encrypted == true || property.PropertyType == typeof(SecureString))
                        {
                            value = ReadSensitive();
                        }
                        else
                        {
                            value = Console.ReadLine();
                        }

                        if (!string.IsNullOrEmpty(value))
                        {
                            if (property.PropertyType == typeof(string))
                            {
                                property.SetValue(credentials, value);
                            }
                            else if (property.PropertyType == typeof(SecureString))
                            {
                                property.SetValue(credentials, AH.CreateSecureString(value));
                            }
                            else
                            {
                                try
                                {
                                    var convertedValue = Convert.ChangeType(value, Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType);
                                    property.SetValue(credentials, convertedValue);
                                }
                                catch (Exception ex)
                                {
                                    Console.Error.WriteLine("Invalid value: " + ex.Message);
                                    goto Again;
                                }
                            }
                        }
                    }
                }
                else
                {
                    throw new RompException("Credentials must be stored interactively.");
                }

                RompDb.CreateOrUpdateCredentials(n.name, credentials, true);
                Console.WriteLine("Credentials stored.");
            }

            void delete()
            {
                var(type, name) = parseQualifiedName();
                RompDb.DeleteCredentials(type, name);
                Console.WriteLine("Credentials deleted.");
            }

            (string type, string name) parseQualifiedName()
            {
                var qualifiedName = args.PopCommand();

                if (string.IsNullOrEmpty(qualifiedName))
                {
                    throw new RompException("Expected credentials name.");
                }

                var parts = qualifiedName.Split(new[] { "::" }, StringSplitOptions.None);

                if (parts.Length != 2 || string.IsNullOrWhiteSpace(parts[0]) || string.IsNullOrWhiteSpace(parts[1]))
                {
                    throw new RompException("Invalid credentials name specification.");
                }

                return(parts[0], parts[1]);
            }
        }
Ejemplo n.º 3
0
        private static async Task Uninstall(ArgList args)
        {
            var spec = PackageSpecifier.FromArgs(args);

            if (spec == null)
            {
                throw new RompException("Usage: romp uninstall <package> [-Vvar=value...]");
            }

            Console.WriteLine("Package: " + spec);
            Console.WriteLine();

            var registeredPackage = await GetRegisteredPackageAsync(spec.PackageId);

            if (registeredPackage == null)
            {
                throw new RompException("Package is not installed.");
            }

            spec.PackageVersion = UniversalPackageVersion.Parse(registeredPackage.Version);

            await ExtensionsManager.WaitForInitializationAsync();

            var vars = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);

            using (var package = await spec.FetchPackageAsync(args, default))
            {
                args.ProcessOptions(parseOption);

                foreach (var var in vars)
                {
                    RompSessionVariable.SetSessionVariable(var.Key, var.Value);
                }

                var packageInfo = RompPackInfo.Load(package);
                if (packageInfo.WriteScriptErrors())
                {
                    throw new RompException("Error compiling uninstall script.");
                }

                PackageInstaller.TargetDirectory = registeredPackage.InstallPath;
                RompSessionVariable.SetSessionVariable("TargetDirectory", registeredPackage.InstallPath);

                await PackageInstaller.RunAsync(package, "uninstall.otter", false);

                using (var registry = PackageRegistry.GetRegistry(RompConfig.UserMode))
                {
                    await registry.LockAsync();

                    await registry.UnregisterPackageAsync(registeredPackage);

                    await registry.DeleteFromCacheAsync(spec.PackageId, package.Version);

                    await registry.UnlockAsync();
                }
            }

            bool parseOption(ArgOption o)
            {
                if (o.Key.StartsWith("V") && o.Key.Length > 1)
                {
                    vars[o.Key.Substring(1)] = o.Value ?? string.Empty;
                    return(true);
                }

                return(false);
            }
        }
Ejemplo n.º 4
0
        public static async Task <int> Main(string[] args)
        {
            try
            {
                RompConsoleMessenger.WriteDirect("romp " + typeof(Program).Assembly.GetName().Version.ToString(3), ConsoleColor.White);

                var argList = new ArgList(args);

                RompConfig.Initialize(argList);

                RompSdkConfig.Initialize();

                // this is a hack due to the weird way the extensions manager works
                Directory.CreateDirectory(RompConfig.ExtensionsPath);

                ExtensionsManager.SetEnvironmentConfiguration(RompConfig.ExtensionsPath, RompConfig.ExtensionsTempPath, AppDomain.CurrentDomain.BaseDirectory);
                RompDb.Initialize();
                GlobalRompPlanValidator.Initialize();
                Logger.AddMessenger(new RompConsoleMessenger());

                RompConsoleMessenger.MinimumLevel = RompConfig.LogLevel;

                var command = argList.PopCommand()?.ToLowerInvariant();
                switch (command)
                {
                case "install":
                    await Install(argList);

                    break;

                case "uninstall":
                    await Uninstall(argList);

                    break;

                case "validate":
                    Validate(argList);
                    break;

                case "inspect":
                    await Inspect(argList);

                    break;

                case "pack":
                    Pack(argList);
                    break;

                case "sources":
                    Sources(argList);
                    break;

                case "jobs":
                    Jobs(argList);
                    break;

                case "credentials":
                    Credentials(argList);
                    break;

                case "config":
                    Config(argList);
                    break;

                case "packages":
                    await Packages(argList);

                    break;

                case "about":
                    About(argList);
                    break;

                default:
                    WriteUsage();
                    break;
                }

                WaitForEnter();
                return(0);
            }
            catch (RompException ex)
            {
                Console.Error.WriteLine(ex.Message);
                WaitForEnter();
                return(-1);
            }
            finally
            {
                RompDb.Cleanup();
            }
        }
Ejemplo n.º 5
0
        private static async Task Install(ArgList args)
        {
            var spec = PackageSpecifier.FromArgs(args);

            if (spec == null)
            {
                throw new RompException("Usage: romp install <package-file-or-name> [--version=<version-number>] [--source=<name-or-feed-url>] [--force] [-Vvar=value...]");
            }

            Console.WriteLine("Package: " + spec);
            Console.WriteLine();

            await ExtensionsManager.WaitForInitializationAsync();

            bool simulate = false;
            bool force    = false;
            var  vars     = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);

            using (var package = await spec.FetchPackageAsync(args, default))
            {
                args.ProcessOptions(parseOption);

                if (!force)
                {
                    var registeredPackage = await GetRegisteredPackageAsync(spec.PackageId);

                    if (registeredPackage != null)
                    {
                        Console.WriteLine("Package is already installed. Use --force to install anyway.");
                        return;
                    }
                }

                foreach (var var in vars)
                {
                    RompSessionVariable.SetSessionVariable(var.Key, var.Value);
                }

                var packageInfo = RompPackInfo.Load(package);
                if (packageInfo.WriteScriptErrors())
                {
                    throw new RompException("Error compiling install script.");
                }

                foreach (var var in packageInfo.Variables)
                {
                    if (var.Value.Value != null && !vars.ContainsKey(var.Key))
                    {
                        RompSessionVariable.SetSessionVariable(var.Key, var.Value.Value.Value);
                    }
                }

                foreach (var var in packageInfo.Variables)
                {
                    // should also validate/coerce type here
                    if (var.Value.Required && var.Value.Value == null && !vars.ContainsKey(var.Key))
                    {
                        if (Console.IsOutputRedirected)
                        {
                            throw new RompException("Missing required variable: " + var.Key);
                        }

                        Console.WriteLine($"Variable \"{var.Key}\" is required.");
                        if (!string.IsNullOrWhiteSpace(var.Value.Description))
                        {
                            Console.WriteLine("Description: " + var.Value.Description);
                        }

                        string value;
                        do
                        {
                            // should not assume type to be scalar
                            Console.Write(new RuntimeVariableName(var.Key, RuntimeValueType.Scalar) + ": ");
                            if (var.Value.Sensitive)
                            {
                                value = ReadSensitive();
                            }
                            else
                            {
                                value = Console.ReadLine();
                            }
                        }while (string.IsNullOrEmpty(value));

                        RompSessionVariable.SetSessionVariable(var.Key, value);
                    }
                }

                bool credentialsMissing = false;
                foreach (var creds in packageInfo.Credentials.Values)
                {
                    if (RompDb.GetCredentialsByName(creds.Type, creds.Name) == null)
                    {
                        credentialsMissing = true;
                        var text = "Credentials required: " + creds.FullName;
                        if (!string.IsNullOrWhiteSpace(creds.Description))
                        {
                            text += " (" + creds.Description + ")";
                        }
                        RompConsoleMessenger.WriteDirect(text, ConsoleColor.Red);
                    }
                }

                if (credentialsMissing)
                {
                    throw new RompException("Use \"romp credentials store\" to create missing credentials.");
                }

                await PackageInstaller.RunAsync(package, "install.otter", simulate);

                using (var registry = PackageRegistry.GetRegistry(RompConfig.UserMode))
                {
                    await registry.LockAsync();

                    await registry.RegisterPackageAsync(
                        new RegisteredPackage
                    {
                        Group            = package.Group,
                        Name             = package.Name,
                        Version          = package.Version.ToString(),
                        InstallationDate = DateTimeOffset.Now.ToString("o"),
                        InstalledBy      = Environment.UserName,
                        InstalledUsing   = "Romp",
                        InstallPath      = PackageInstaller.TargetDirectory
                    }
                        );

                    await registry.UnlockAsync();
                }
            }

            bool parseOption(ArgOption o)
            {
                switch (o.Key.ToLowerInvariant())
                {
                case "force":
                    force = true;
                    return(true);
                }

                if (o.Key.StartsWith("V") && o.Key.Length > 1)
                {
                    vars[o.Key.Substring(1)] = o.Value ?? string.Empty;
                    return(true);
                }

                return(false);
            }
        }