Beispiel #1
0
        private static void Validate(ArgList args)
        {
            var packageName = args.PopCommand();

            if (string.IsNullOrEmpty(packageName))
            {
                throw new RompException("Usage: romp validate <package-file>");
            }

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

                Console.WriteLine($"Package {new UniversalPackageId(package.Group, package.Name)} validated.");
            }
        }
Beispiel #2
0
        private static async Task Inspect(ArgList args)
        {
            var spec = PackageSpecifier.FromArgs(args);

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

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

            using (var package = await spec.FetchPackageAsync(args, default))
            {
                var packageInfo = RompPackInfo.Load(package);
                Console.WriteLine("Name: " + new UniversalPackageId(package.Group, package.Name));
                Console.WriteLine("Version: " + package.Version);

                Console.WriteLine();
                if (packageInfo.Variables.Count > 0)
                {
                    Console.WriteLine("Variables:");
                    foreach (var var in packageInfo.Variables)
                    {
                        Console.WriteLine($" {var.Key}={var.Value.Value?.ToString() ?? "(required)"}");
                    }
                }
                else
                {
                    Console.WriteLine("Variables: (none)");
                }

                Console.WriteLine();
                if (packageInfo.Credentials.Count > 0)
                {
                    Console.WriteLine("Credentials:");
                    foreach (var creds in packageInfo.Credentials)
                    {
                        Console.WriteLine($" {creds.Key}: {AH.CoalesceString(creds.Value.Description, "(required)")}");
                    }
                }
                else
                {
                    Console.WriteLine("Credentials: (none)");
                }

                Console.WriteLine();
                if (!string.IsNullOrWhiteSpace(packageInfo.RawInstallScript))
                {
                    if (packageInfo.InstallScript.Errors.Count > 0)
                    {
                        Console.WriteLine("install.otter:");
                        packageInfo.WriteScriptErrors();
                    }
                    else
                    {
                        Console.WriteLine("install.otter: no errors");
                    }
                }
                else
                {
                    Console.WriteLine("install.otter: not present");
                }
            }
        }
Beispiel #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);
            }
        }
Beispiel #4
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);
            }
        }