PluginContext

Structure link

Every time a plugin is called by the IDE (or a by another plugin), a PluginContext is generated and passed throughout, providing access to the core functionality and data of Omniview. The context provides access to various aspects of the request, including the request options, authentication context, resource context, and plugin configuration.

The PluginContext struct is defined as follows:

type PluginContext struct {
	Context         context.Context
	RequestID       string
	RequesterID     string
	RequestOptions  *RequestOptions
	AuthContext     *AuthContext
	ResourceContext *ResourceContext
	PluginConfig    *PluginConfig
	GlobalConfig    *GlobalConfig
}

🌐 RequestOptions link

Request options are used to control the behavior of the request. This includes the timeout, the number of retries, and the backoff interval.

type RequestOptions struct {
	Timeout         time.Duration
	MaxRetries      int
	BackoffInterval time.Duration
}

🔑 AuthContext link

Stores information about the authorization context for the request to the backend, as well settings the user has configured for the specific authorization context instance. This also includes a data store that the client factories can inject into for passing arbitrary scoped data down the call stack.

Examples of auth contexts defined in the IDE include things such as:

• An AWS profile
• A Kubernetes context
• A GCP service account

type AuthContext struct {
	ID              string
	UID             string
	Name            string
	Description     string
	Labels          map[string]string
	ExpiryTime      time.Duration
	LastRefresh     time.Time
	Data            map[string]interface{}
	sensitiveData   map[string]interface{}
}

IsAuthed link

Check if the request is authenticated.

func (c *AuthContext) IsAuthed() bool 

GetData link

Get non-sensitive data attached to the auth context by the client factory

func (c *AuthContext) GetData() map[string]interface{}

SetData link

Set non-sensitive data on the context. This will overwrite any existing data.

func (c *AuthContext) SetData(data map[string]interface{})

GetDataKey link

Get an item from the data store by key

func (c *AuthContext) GetDataKey(key string) (interface{}, bool)

SetDataKey link

Set an item in the data store by key.

func (c *AuthContext) SetDataKey(key string, value interface{})

GetSensitiveData link

Get sensitive data attached to the auth context by the client factory

func (c *AuthContext) GetSensitiveData() map[string]interface{}

SetSensitiveData link

Set sensitive data on the context. This will overwrite any existing data.

func (c *AuthContext) SetSensitiveData(data map[string]interface{})

SetSensitiveDataKey link

Set an item in the sensitive data store by key.

func (c *AuthContext) SetSensitiveDataKey(key string, value interface{})

GetSensitiveDataKey link

Get an item from the sensitive data store by key

func (c *AuthContext) GetSensitiveDataKey(key string) (interface{}, bool)

📦 ResourceContext link

The context of the resource being operated on. This is only available when the plugin is called from a resource context.

type ResourceContext struct {
  ID          string
  Metadata    ResourceMetadata
  Data        map[string]string
}

🛠 PluginConfig link

Configuration of the plugin itself by the user, as defined in the settings options in the plugin setup function.

The available keys here are defined when you setup the plugin. For example, if we were to initialize a plugin with the following PluginOpts:

package main

import (
	"github.com/omniview/kubernetes/pkg/plugin/resource"
	"github.com/omniviewdev/plugin/pkg/resource/types"
	"github.com/omniviewdev/plugin/pkg/sdk"
	sdksettings "github.com/omniviewdev/plugin/pkg/settings"
)

func main() {
	plugin := sdk.NewPlugin(sdk.PluginOpts{
		Settings: []interface{}{
			sdksettings.Multitext{
				ID:          "kubeconfigs",
				Name:        "Kubeconfigs",
				Description: "A list of available Kubeconfigs to use",
				Default:     []string{"~/.kube/config"},
			},
			sdksettings.Text{
				ID:          "shell",
				Name:        "Shell",
				Description: "The default shell to use for running commands and authenticating with Kubernetes clusters.",
				Default:     "/bin/zsh",
			},
		},
	})
  // ...
  // ...

We can access the PluginConfig in the plugin context with the following keys:

func SomeFunction(c *sdk.PluginContext) {
  kubeconfigs, _ := c.PluginConfig.Get[[]string]("kubeconfigs")
  shell, _ := c.PluginConfig.Get[string]("shell")
}

Get link

Get a global configuration value by key

func (c *PluginContext) Get[K comparable](key string) (K, bool)

Set link

Set a global configuration value by key

func (c *PluginContext) Set(key string, value interface{})

🌍 GlobalConfig link

Configuration of the IDE itself by the user, as defined in the settings options in the IDE setup function. The most common settings found here can be accessed via the exported symbols:

• globals.SHELL
• globals.EDITOR
• globals.THEME
• globals.LANGUAGE

Detailed documentation on the global configuration settings can be found here.

Get link

Get a global configuration value by key

func (c *GlobalConfig) Get[K comparable](key string) (K, bool)

Set link

Set a global configuration value by key

func (c *GlobalConfig) Set(key string, value interface{})