feat: Shared Plugin RPC Host

changelog.md

@@ -2,6 +2,7 @@
 
 ### Features
 
+- [#3238](https://github.com/ignite/cli/pull/3238) Add `Sharedhost` plugin option
 - [#3214](https://github.com/ignite/cli/pull/3214) Global plugins config.
 - [#3142](https://github.com/ignite/cli/pull/3142) Add `ignite network request param-change` command.
 - [#3181](https://github.com/ignite/cli/pull/3181) Addition of `add` `remove` commands for `plugins`

ignite/cmd/plugin.go

@@ -561,7 +561,7 @@ func NewPluginScaffold() *cobra.Command {
 				return err
 			}
 			moduleName := args[0]
-			path, err := plugin.Scaffold(wd, moduleName)
+			path, err := plugin.Scaffold(wd, moduleName, false)
 			if err != nil {
 				return err
 			}

ignite/services/plugin/cache.go

@@ -0,0 +1,143 @@
+package plugin
+
+import (
+	"encoding/gob"
+	"fmt"
+	"net"
+	"path"
+	"path/filepath"
+
+	hplugin "github.com/hashicorp/go-plugin"
+
+	chainconfig "github.com/ignite/cli/ignite/config"
+	"github.com/ignite/cli/ignite/pkg/cache"
+)
+
+const (
+	cacheFileName  = "ignite_plugin_cache.db"
+	cacheNamespace = "plugin.rpc.context"
+)
+
+var (
+	storage      *cache.Storage
+	storageCache *cache.Cache[ConfigContext]
+)
+
+func init() {
+	gob.Register(hplugin.ReattachConfig{})
+	gob.Register(net.UnixAddr{})
+}
+
+type ConfigContext struct {
+	Plugin hplugin.ReattachConfig
+	Addr   net.UnixAddr
+}
+
+func WritePluginConfigCache(pluginPath string, conf hplugin.ReattachConfig) error {
+	name := path.Base(pluginPath)
+
+	if name == "." {
+		return fmt.Errorf("provided path is invalid: %s", pluginPath)
+	}
+
+	if conf.Addr == nil {
+		return fmt.Errorf("plugin Address info cannot be empty")
+	}
+
+	confCont := ConfigContext{}
+	// TODO: figure out a better way of resolving the type of network connection is established between plugin server and host
+	// currently this will always be a unix network socket. but this might not be the case moving forward.
+	ua, err := net.ResolveUnixAddr(conf.Addr.Network(), conf.Addr.String())
+	if err != nil {
+		return err
+	}
+
+	confCont.Addr = *ua
+	conf.Addr = nil
+	confCont.Plugin = conf
+
+	cache, err := newCache()
+	if err != nil {
+		return err
+	}
+
+	cache.Put(name, confCont)
+
+	return err
+}
+
+func ReadPluginConfigCache(pluginPath string, ref *hplugin.ReattachConfig) error {
+	name := path.Base(pluginPath)
+
+	if name == "." {
+		return fmt.Errorf("provided path is invalid: %s", pluginPath)
+	}
+
+	cache, err := newCache()
+	if err != nil {
+		return err
+	}
+
+	confCont, err := cache.Get(name)
+	if err != nil {
+		return err
+	}
+
+	*ref = confCont.Plugin
+	ref.Addr = &confCont.Addr
+
+	return nil
+}
+
+func CheckPluginConfCache(pluginPath string) bool {
+	name := path.Base(pluginPath)
+
+	if name == "." {
+		return false
+	}
+
+	cache, err := newCache()
+	if err != nil {
+		return false
+	}
+	if _, err := cache.Get(name); err != nil {
+		return false
+	}
+	return true
+}
+
+func DeletePluginConfCache(pluginPath string) error {
+	name := path.Base(pluginPath)
+
+	if name == "." {
+		return fmt.Errorf("provided path is invalid: %s", pluginPath)
+	}
+	cache, err := newCache()
+	if err != nil {
+		return err
+	}
+
+	if err := cache.Delete(name); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func newCache() (*cache.Cache[ConfigContext], error) {
+	cacheRootDir, err := chainconfig.DirPath()
+	if err != nil {
+		return nil, err
+	}
+	if storage == nil {
+		storageTmp, err := cache.NewStorage(filepath.Join(cacheRootDir, cacheFileName))
+		if err != nil {
+			return nil, err
+		}
+		storage = &storageTmp
+		cacheTmp := cache.New[ConfigContext](*storage, cacheNamespace)
+		storageCache = &cacheTmp
+	}
+
+	return storageCache, nil
+}

ignite/services/plugin/cache_test.go

@@ -0,0 +1,110 @@
+package plugin
+
+import (
+	"net"
+	"testing"
+
+	hplugin "github.com/hashicorp/go-plugin"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPluginCacheAdd(t *testing.T) {
+	t.Run("Should cache plugin config and read from cache", func(t *testing.T) {
+		const path = "/path/to/awesome/plugin"
+		unixFD, _ := net.ResolveUnixAddr("unix", "/var/folders/5k/sv4bxrs102n_6rr7430jc7j80000gn/T/plugin193424090")
+
+		rc := hplugin.ReattachConfig{
+			Protocol:        hplugin.ProtocolNetRPC,
+			ProtocolVersion: hplugin.CoreProtocolVersion,
+			Addr:            unixFD,
+			Pid:             24464,
+		}
+
+		err := WritePluginConfigCache(path, rc)
+		require.NoError(t, err)
+
+		c := hplugin.ReattachConfig{}
+		err = ReadPluginConfigCache(path, &c)
+		require.NoError(t, err)
+	})
+
+	t.Run("Should error writing bad plugin config to cache", func(t *testing.T) {
+		const path = "/path/to/awesome/plugin"
+		rc := hplugin.ReattachConfig{
+			Protocol:        hplugin.ProtocolNetRPC,
+			ProtocolVersion: hplugin.CoreProtocolVersion,
+			Addr:            nil,
+			Pid:             24464,
+		}
+
+		err := WritePluginConfigCache(path, rc)
+		require.Error(t, err)
+	})
+
+	t.Run("Should error with invalid plugin path", func(t *testing.T) {
+		const path = ""
+		rc := hplugin.ReattachConfig{
+			Protocol:        hplugin.ProtocolNetRPC,
+			ProtocolVersion: hplugin.CoreProtocolVersion,
+			Addr:            nil,
+			Pid:             24464,
+		}
+
+		err := WritePluginConfigCache(path, rc)
+		require.Error(t, err)
+	})
+}
+
+func TestPluginCacheDelete(t *testing.T) {
+	t.Run("Delete plugin config after write to cache should remove from cache", func(t *testing.T) {
+		const path = "/path/to/awesome/plugin"
+		unixFD, _ := net.ResolveUnixAddr("unix", "/var/folders/5k/sv4bxrs102n_6rr7430jc7j80000gn/T/plugin193424090")
+
+		rc := hplugin.ReattachConfig{
+			Protocol:        hplugin.ProtocolNetRPC,
+			ProtocolVersion: hplugin.CoreProtocolVersion,
+			Addr:            unixFD,
+			Pid:             24464,
+		}
+
+		err := WritePluginConfigCache(path, rc)
+		require.NoError(t, err)
+
+		err = DeletePluginConfCache(path)
+		require.NoError(t, err)
+
+		c := hplugin.ReattachConfig{}
+		// there should be an error after deleting the config from the cache
+		err = ReadPluginConfigCache(path, &c)
+		require.Error(t, err)
+	})
+
+	t.Run("Delete plugin config should return error given empty path", func(t *testing.T) {
+		const path = ""
+		err := DeletePluginConfCache(path)
+		require.Error(t, err)
+	})
+}
+
+func TestPluginCacheCheck(t *testing.T) {
+	const path = "/path/to/awesome/plugin"
+	unixFD, _ := net.ResolveUnixAddr("unix", "/var/folders/5k/sv4bxrs102n_6rr7430jc7j80000gn/T/plugin193424090")
+
+	rc := hplugin.ReattachConfig{
+		Protocol:        hplugin.ProtocolNetRPC,
+		ProtocolVersion: hplugin.CoreProtocolVersion,
+		Addr:            unixFD,
+		Pid:             24464,
+	}
+
+	t.Run("Cache should be hydrated", func(t *testing.T) {
+		err := WritePluginConfigCache(path, rc)
+		require.NoError(t, err)
+		require.Equal(t, true, CheckPluginConfCache(path))
+	})
+
+	t.Run("Cache should be empty", func(t *testing.T) {
+		_ = DeletePluginConfCache(path)
+		require.Equal(t, false, CheckPluginConfCache(path))
+	})
+}

ignite/services/plugin/interface.go

@@ -59,6 +59,16 @@ type Manifest struct {
 	// Hooks contains the hooks that will be attached to the existing ignite
 	// commands.
 	Hooks []Hook
+	// SharedHost enables sharing a single plugin server across all running instances
+	// of a plugin. Useful if a plugin adds or extends long running commands
+	//
+	// example: `ignite chain serve`
+	//
+	// When enabled, all plugins of the same `Path` loaded from the same configuration will
+	// attach it's rpc client to a an existing rpc server.
+	//
+	// If a plugin instance has no other running plugin servers, it will create one and it will be the host.
+	SharedHost bool `yaml:"shared_host"`
 }
 
 // Command represents a plugin command.