Esempio n. 1
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            // We need to copy any of the files referenced by [--script]
            // [--text] and/or [--data] options to the shim directory.

            var commandLine    = shim.CommandLine;
            var optionPatterns = new string[]
            {
                "--script=",
                "--text=",
                "--data="
            };

            for (int i = 0; i < commandLine.Items.Length; i++)
            {
                var item = commandLine.Items[i];

                foreach (var pattern in optionPatterns)
                {
                    if (item.StartsWith(pattern))
                    {
                        var shimPath = shim.AddFile(item.Substring(pattern.Length), dontReplace: true, noGuid: true);

                        commandLine.Items[i] = $"{pattern}{shimPath}";
                        break;
                    }
                }
            }

            return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
        }
Esempio n. 2
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            var commandLine = shim.CommandLine;

            if (commandLine.Arguments.Length >= 3)
            {
                // We need to have the container command write the target file
                // to the [/shim] folder and then add a post action that copies
                // the target file to the specified location on the operator's
                // workstation.

                var externalTarget = commandLine.Arguments[2];
                var internalTarget = "__target";

                shim.ReplaceItem(externalTarget, internalTarget);

                shim.SetPostAction(
                    exitCode =>
                {
                    if (exitCode == 0)
                    {
                        File.Copy(Path.Combine(shim.ShimExternalFolder, internalTarget), externalTarget);
                    }
                });
            }

            return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
        }
Esempio n. 3
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            Program.LogPath = null;

            var commandLine = shim.CommandLine;

            // Handle the case where we need to pipe the standard input to
            // to the container.

            if (commandLine.Items.LastOrDefault() == "-")
            {
                shim.AddStdin();
            }
            else if (commandLine.StartsWithArgs("consul", "kv", "put") && commandLine.Arguments.Length == 5 && commandLine.Arguments[4].StartsWith("@"))
            {
                // We're going to special case PUT when saving a file
                // whose name is prefixed with "@".

                var fileArg  = commandLine.Arguments[4];
                var filePath = fileArg.Substring(1);
                var shimFile = shim.AddFile(filePath, dontReplace: true);

                shim.ReplaceItem(fileArg, "@" + shimFile);
            }

            return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
        }
Esempio n. 4
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            Program.LogPath = null;

            var commandLine = shim.CommandLine;

            if (commandLine.Arguments.Length > 2)
            {
                switch (commandLine[1])
                {
                case "write":

                    // We need handle any [key=@file] arguments specially by adding
                    // them to the shim.

                    foreach (var arg in commandLine.Arguments.Skip(2))
                    {
                        var pos = arg.IndexOf("=@");

                        if (pos != -1)
                        {
                            var shimFile = shim.AddFile(arg.Substring(pos + 2), dontReplace: true);

                            shim.ReplaceItem(arg, arg.Substring(0, pos + 2) + shimFile);
                        }
                    }
                    break;

                case "policy-write":

                    // The last command line item is either:
                    //
                    //      * A "-", indicating that the content should come from standard input.
                    //      * A file name prefixed by "@"
                    //      * A string holding JSON or HCL

                    if (commandLine.Arguments.LastOrDefault() == "-")
                    {
                        shim.AddStdin();
                    }
                    else
                    {
                        var lastArg = commandLine.Arguments.LastOrDefault();

                        if (lastArg.StartsWith("@"))
                        {
                            var shimFile = shim.AddFile(lastArg.Substring(1), dontReplace: true);

                            shim.ReplaceItem(lastArg, "@" + shimFile);
                        }
                    }
                    break;
                }
            }

            return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
        }
Esempio n. 5
0
        /// <summary>
        /// Handles the shim for the <b>docker deploy</b> and <b>docker stack deploy</b> commands.
        /// </summary>
        /// <param name="shim">The shim.</param>
        /// <param name="rightCommandLine">The right split of the command line.</param>
        private void ShimDeploy(DockerShim shim, CommandLine rightCommandLine)
        {
            string path;

            // We're going to shim the file specified by the first
            // [--bundle-file], [--compose-file], or [-c] option.

            for (int i = 0; i < rightCommandLine.Items.Length; i++)
            {
                switch (rightCommandLine.Items[i])
                {
                case "--bundle-file":
                case "--compose-file":
                case "-c":

                    path = rightCommandLine.Items.Skip(i + 1).FirstOrDefault();

                    if (path != null)
                    {
                        shim.AddFile(path);
                        return;
                    }
                    break;
                }
            }

            // If that didn't work, try looking for arguments like:
            //
            //      --bundle-file=PATH

            var patterns =
                new string[]
            {
                "--bundle-file=",
                "--compose-file=",
                "-c="
            };

            foreach (var item in rightCommandLine.Items)
            {
                foreach (var pattern in patterns)
                {
                    if (item.StartsWith(pattern))
                    {
                        path = item.Substring(pattern.Length);

                        var shimFile = shim.AddFile(path, dontReplace: true);

                        shim.ReplaceItem(pattern + path, pattern + shimFile);
                        return;
                    }
                }
            }
        }
Esempio n. 6
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            var commandLine = shim.CommandLine;
            var command     = commandLine.Arguments.ElementAtOrDefault(1);

            switch (command)
            {
            // These commands should be run on the operator workstation.

            case "join":
            case "split":

                return(new DockerShimInfo(shimability: DockerShimability.None));

            // These commands can be run in Docker without modification.

            case "set":

                if (commandLine.Arguments.Length >= 4)
                {
                    shim.AddFile(commandLine.Arguments[3]);
                }

                return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));

            case "verify":

                foreach (var path in commandLine.Arguments.Skip(2))
                {
                    shim.AddFile(path);
                }

                return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));

            case "remove":
            case "rm":
            case "get":
            case "ls":
            case "list":
            default:

                return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
            }
        }
Esempio n. 7
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            var commandLine = shim.CommandLine;

            if (commandLine.Arguments.LastOrDefault() == "-")
            {
                shim.AddStdin(text: true);
            }
            else if (commandLine.Arguments.Length == 4)
            {
                switch (commandLine.Arguments[2])
                {
                case "add":
                case "settings":

                    shim.AddFile(commandLine.Arguments[3]);
                    break;
                }
            }

            return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
        }
Esempio n. 8
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            var ensureConnection = shim.CommandLine.Arguments.ElementAtOrDefault(1) != "help";

            return(new DockerShimInfo(shimability: DockerShimability.None, ensureConnection: ensureConnection));
        }
Esempio n. 9
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            Program.LogPath = null;

            // We're going to upload files for a handful of Docker commands unless this is disabled.

            var split            = shim.CommandLine.Split(SplitItem);
            var leftCommandLine  = split.Left;
            var rightCommandLine = split.Right;

            if (rightCommandLine == null)
            {
                rightCommandLine = new CommandLine();
            }

            if (leftCommandLine.HasOption("--no-upload"))
            {
                return(new DockerShimInfo(shimability: DockerShimability.Optional));
            }

            var arg1 = rightCommandLine.Arguments.ElementAtOrDefault(0);
            var arg2 = rightCommandLine.Arguments.ElementAtOrDefault(1);

            switch (arg1)
            {
            case "deploy":

                ShimDeploy(shim, rightCommandLine);
                break;

            case "stack":

                if (arg2 == "deploy")
                {
                    ShimDeploy(shim, rightCommandLine);
                }
                break;

            case "config":

                if (arg2 == "create")
                {
                    var path = rightCommandLine.Arguments.Skip(3).FirstOrDefault();

                    if (path == null)
                    {
                        return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));      // This is an error but we'll let Docker report it.
                    }

                    if (path == "-")
                    {
                        shim.AddStdin();
                    }
                    else
                    {
                        shim.AddFile(path);
                    }
                }
                break;

            case "secret":

                if (arg2 == "create")
                {
                    var path = rightCommandLine.Arguments.Skip(3).FirstOrDefault();

                    if (path == null)
                    {
                        return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));      // This is an error but we'll let Docker report it.
                    }

                    if (path == "-")
                    {
                        shim.AddStdin();
                    }
                    else
                    {
                        shim.AddFile(path);
                    }
                }
                break;
            }

            return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
        }
Esempio n. 10
0
 /// <inheritdoc/>
 public override DockerShimInfo Shim(DockerShim shim)
 {
     return(new DockerShimInfo(shimability: DockerShimability.None, ensureConnection: false));
 }
Esempio n. 11
0
 /// <inheritdoc/>
 public override DockerShimInfo Shim(DockerShim shim)
 {
     return(new DockerShimInfo(shimability: DockerShimability.Optional, ensureConnection: true));
 }
Esempio n. 12
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            // This command cannot be executed within the [neon-cli] container.

            return(new DockerShimInfo(shimability: DockerShimability.None, ensureConnection: true));
        }
Esempio n. 13
0
 public DockerShimInfo Shim(DockerShim shim)
 {
     Covenant.Requires <ArgumentNullException>(shim != null);
     return(null);
 }
Esempio n. 14
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            shim.AddFile(shim.CommandLine.Arguments.LastOrDefault());

            return(new DockerShimInfo(shimability: DockerShimability.Optional));
        }
Esempio n. 15
0
 /// <inheritdoc/>
 public abstract DockerShimInfo Shim(DockerShim shim);
Esempio n. 16
0
 /// <inheritdoc/>
 public override DockerShimInfo Shim(DockerShim shim)
 {
     return(new DockerShimInfo(shimability: DockerShimability.None));
 }
Esempio n. 17
0
        /// <inheritdoc/>
        public override DockerShimInfo Shim(DockerShim shim)
        {
            var commandLine = shim.CommandLine;

            // Shim command: neon vpn ca HIVE-DEF CA-FOLDER
            //
            // We need to copy the [HIVE-DEF] and the contents of the
            // [CA-FOLDER] into a shim subfolder, update the command line
            // and execute it, and then copy the file contents back out
            // to the original folder when the command completes.

            if (commandLine.Arguments.Length == 4 &&
                commandLine.Arguments[0] == "vpn" &&
                commandLine.Arguments[1] == "ca")
            {
                var hiveDefPath     = commandLine.Arguments[2];
                var caFolderPath    = commandLine.Arguments[3];
                var shimmedCaFolder = Path.Combine(shim.ShimExternalFolder, "ca");

                shim.AddFile(hiveDefPath);

                foreach (var file in Directory.GetFiles(caFolderPath, "*.*", SearchOption.TopDirectoryOnly))
                {
                    File.Copy(file, Path.Combine(shimmedCaFolder, Path.GetFileName(file)));
                }

                shim.ReplaceItem(caFolderPath, $"{DockerShim.ShimInternalFolder}/ca");

                shim.SetPostAction(
                    exitCode =>
                {
                    if (exitCode == 0)
                    {
                        foreach (var file in Directory.GetFiles(shimmedCaFolder, "*.*", SearchOption.TopDirectoryOnly))
                        {
                            File.Copy(file, Path.Combine(caFolderPath, Path.GetFileName(file)));
                        }
                    }
                });

                return(new DockerShimInfo(shimability: DockerShimability.Required));
            }

            // Shim command: neon vpn cert user create USER
            //
            // We need to copy the new hive login file to the current directory
            // after the command runs in Docker.  Note that the shimmed command
            // writes the file name for the new login to [new-login.txt].

            if (commandLine.Arguments.Length == 4 &&
                commandLine.Arguments[0] == "vpn" &&
                commandLine.Arguments[1] == "user" &&
                commandLine.Arguments[2] == "create")
            {
                var username = commandLine.Arguments[3];

                shim.SetPostAction(
                    exitCode =>
                {
                    if (exitCode == 0)
                    {
                        var loginName          = File.ReadAllText(Path.Combine(shim.ShimExternalFolder, "new-login.txt"));
                        var generatedLoginPath = Path.Combine(shim.ShimExternalFolder, loginName);
                        var outputLoginPath    = Path.GetFullPath(loginName);
                        var generatedLoginText = File.ReadAllText(generatedLoginPath);

                        File.WriteAllText(outputLoginPath, generatedLoginText);
                        Console.WriteLine($"*** Created login: {outputLoginPath}");
                    }
                });

                return(new DockerShimInfo(shimability: DockerShimability.Required));
            }

            // Shim command: neon vpn user revoke [--restart-vpn] THUMBPRINT
            //
            // No special actions required.

            return(new DockerShimInfo(shimability: DockerShimability.Required));
        }