Not able to install storage.porter.mongodb-docker plugin through a wrapper of porter commands

[ujala-singh]

What is your question?
I am building my own CLI by wrapping up the porters's capabilities as below:

package main

import (
	"fmt"
	"os"

	"get.porter.sh/porter/pkg/porter"
	"get.porter.sh/porter/pkg/portercontext"
	"github.com/spf13/cobra"
)

func main() {
	rootCmd := &cobra.Command{Use: "porter-cli"}

	// Add commands
	rootCmd.AddCommand(buildCmd)
	rootCmd.AddCommand(installCmd)
	rootCmd.AddCommand(uninstallCmd)
	rootCmd.AddCommand(listCmd)
	rootCmd.AddCommand(runCmd)
	rootCmd.AddCommand(publishCmd)

	// Execute root command
	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

var publishCmd = &cobra.Command{
	Use:   "publish",
	Short: "Publish the porter bundle",
	Run: func(cmd *cobra.Command, args []string) {
		p := porter.New()

		// Assuming porter.yaml is in the current directory
		publishOptions := porter.PublishOptions{}
		err := publishOptions.Validate(p.Config)
		if err != nil {
			fmt.Println("Error during validation:", err)
			return
		}

		// Execute publish
		err = p.Publish(cmd.Context(), publishOptions)
		if err != nil {
			fmt.Println("Error during publish:", err)
			return
		}

		fmt.Println("Bundle published successfully.")
	},
}

var buildCmd = &cobra.Command{
	Use:   "build",
	Short: "Build the porter bundle",
	Run: func(cmd *cobra.Command, args []string) {
		p := porter.New()

		// Assuming porter.yaml is in the current directory
		buildOptions := porter.BuildOptions{}
		err := buildOptions.Validate(p) // Validate the options
		if err != nil {
			fmt.Println("Error during validation:", err)
			return
		}

		// Execute build
		err = p.Build(cmd.Context(), buildOptions)
		if err != nil {
			fmt.Println("Error during build:", err)
			return
		}

		fmt.Println("Bundle built successfully.")
	},
}

var installCmd = &cobra.Command{
	Use:   "install",
	Short: "Install the porter bundle",
	Run: func(cmd *cobra.Command, args []string) {
		p := porter.New()

		// Assuming porter.yaml is in the current directory
		installOptions := porter.NewInstallOptions()
		installOptions.File = "porter.yaml"

		// Execute install
		err := p.InstallBundle(cmd.Context(), installOptions)
		if err != nil {
			fmt.Println("Error during install:", err)
			return
		}

		fmt.Println("Bundle installed successfully.")
	},
}

var listCmd = &cobra.Command{
	Use:   "list",
	Short: "List installed bundles",
	Run: func(cmd *cobra.Command, args []string) {
		p := porter.New()

		// Create ListOptions
		runListOptions := porter.RunListOptions{}
		pCtx := portercontext.New()
		err := runListOptions.Validate(args, pCtx)
		if err != nil {
			fmt.Println("Error during validation:", err)
			return
		}

		// Execute list
		printErr := p.PrintInstallationRuns(cmd.Context(), runListOptions)
		if printErr != nil {
			fmt.Println("Error during listing bundles:", printErr)
			return
		}
	},
}

var runCmd = &cobra.Command{
	Use:   "run",
	Short: "Run the porter bundle",
	Run: func(cmd *cobra.Command, args []string) {
		p := porter.New()

		// Define run options
		runOptions := porter.NewRunOptions(p.Config)
		runOptions.File = "porter.yaml"

		// Validate the run options
		err := runOptions.Validate()
		if err != nil {
			fmt.Println("Error during validation:", err)
			return
		}

		// Execute the run command
		err = p.Run(cmd.Context(), runOptions)
		if err != nil {
			fmt.Println("Error during run:", err)
			return
		}

		fmt.Println("Bundle ran successfully.")
	},
}

var uninstallCmd = &cobra.Command{
	Use:   "uninstall",
	Short: "Uninstall the porter bundle",
	Run: func(cmd *cobra.Command, args []string) {
		p := porter.New()

		// Assuming porter.yaml is in the current directory
		uninstallOptions := porter.NewUninstallOptions()
		uninstallOptions.File = "porter.yaml"

		// Execute uninstall
		err := p.UninstallBundle(cmd.Context(), uninstallOptions)
		if err != nil {
			fmt.Println("Error during uninstall:", err)
			return
		}

		fmt.Println("Bundle uninstalled successfully.")
	},
}

My build is working fine as below:

$ go build -o porter-cli

It created binary for me. and whenever I run install command, it fails with the below error:

Error during install: could not retrieve the installation record: could not read storage schema document: could not load storage plugin: could not connect to the storage.porter.mongodb-docker plugin: plugin stderr was Error: unknown command "plugin" for "porter-cli"
: Unrecognized remote plugin message: unknown command "plugin" for "porter-cli"

This usually means that the plugin is either invalid or simply
needs to be recompiled to support the latest protocol.

How can I resolve it? Please I would really appreciate it.

I have followed the guide mentioned here: https://porter.sh/docs/references/library/

[ujala-singh]

Also this doc https://porter.sh/plugins/mongodb-docker/ says, The MongoDB Docker Storage plugin is suitable for development and test but should not be used in production. What are the recommendations for production?

[kichristensen]

Also this doc https://porter.sh/plugins/mongodb-docker/ says, The MongoDB Docker Storage plugin is suitable for development and test but should not be used in production. What are the recommendations for production?

Hi @ujala-singh, thanks for reaching out, the recommend storage plugin is MongoDB Storage Plugin, where you deploy and manage your own MongoDB or MongoDB compatible server.

[ujala-singh]

@kichristensen one more thing, my wrapper still uses the default config instead the one that I have defined in ~/.porter/config.yaml. How can I set that for my wrapper CLI?

[kichristensen]

The loading of the config file happens here, https://github.com/getporter/porter/blob/main/cmd/porter/main.go#L61. Because you are developing your own CLI, you have to handle that yourself.

[kichristensen]

The problem is that some of the plugins are maintained together with the Porter. This is the case for storage.porter.mongodb-docker, storage.porter.mongodb and others. Communication with those plugins happens through a hidden plugin CLI command.
As your CLI implementation doesn't include the plugin command the initialization of the plugins fail.

[ujala-singh]

Yes, this worked. I have added the hidden CLI command to my root command and it started working. @kichristensen Thanks a ton.

func buildPluginsCommands(p *porter.Porter) *cobra.Command {
	cmd := &cobra.Command{
		Use:     "plugins",
		Aliases: []string{"plugin"},
		Short:   "Plugin commands. Plugins enable Porter to spin up mongodb_docker container. The MongoDB Docker Storage plugin is built-in to Porter and is the default storage plugin.",
		Annotations: map[string]string{
			"group": "resource",
		},
	}

	cmd.AddCommand(buildPluginRunCommand(p))

	return cmd
}

func buildPluginRunCommand(p *porter.Porter) *cobra.Command {
	var opts porter.RunInternalPluginOpts
	cmd := &cobra.Command{
		Use:   "run PLUGIN_KEY",
		Short: "Serve internal plugins",
		RunE: func(cmd *cobra.Command, args []string) error {
			err := opts.ApplyArgs(args)
			if err != nil {
				return err
			}
			return p.RunInternalPlugins(cmd.Context(), opts)
		},
		Hidden: true, // This should ALWAYS be hidden, it is not a user-facing command
	}

	return cmd
}

[kichristensen]

You are more than welcome