How to use StartPlugins method of plugin Package

Best Gauge code snippet using plugin.StartPlugins

plugins.go

Source:plugins.go

1/*2 *  Copyright 2020 F5 Networks3 *4 *  Licensed under the Apache License, Version 2.0 (the "License");5 *  you may not use this file except in compliance with the License.6 *  You may obtain a copy of the License at7 *8 *      http://www.apache.org/licenses/LICENSE-2.09 *10 *  Unless required by applicable law or agreed to in writing, software11 *  distributed under the License is distributed on an "AS IS" BASIS,12 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13 *  See the License for the specific language governing permissions and14 *  limitations under the License.15 */16package initapp17import (18	"github.com/davecgh/go-spew/spew"19	slog "github.com/go-eden/slf4go"20	"github.com/nginxinc/nginx-wrapper/app/config"21	"github.com/nginxinc/nginx-wrapper/app/embeddedplugins"22	"github.com/nginxinc/nginx-wrapper/lib/api"23	"github.com/nginxinc/nginx-wrapper/lib/osenv"24	"github.com/pkg/errors"25	"github.com/spf13/viper"26	"os"27	"path/filepath"28	"plugin"29	"reflect"30	"strings"31)32func initPlugins(startPlugins bool, vconfig *viper.Viper) {33	initEmbeddedPlugins(startPlugins, vconfig)34	initExternalPlugins(startPlugins, vconfig)35}36func initEmbeddedPlugins(startPlugins bool, vconfig *viper.Viper) {37	embeddedplugins.LoadAll(startPlugins, vconfig)38}39func initExternalPlugins(startPlugins bool, vconfig *viper.Viper) {40	log := slog.NewLogger("init-plugins")41	pluginPath := vconfig.GetString("plugin_path")42	if pluginPath == "" {43		log.Errorf("plugin_path is blank - can't load plugins")44		return45	}46	pathInfo, statErr := os.Stat(pluginPath)47	if statErr != nil {48		log.Errorf("error reading plugin_path (%s) - can't load plugins: %v",49			pluginPath, statErr)50		return51	}52	if !pathInfo.IsDir() {53		log.Error("plugin_path is not a directory - can't load plugins")54		return55	}56	var plugins []string57	walkErr := filepath.Walk(pluginPath, func(path string, info os.FileInfo, err error) error {58		// skip directories59		// skip files without the shared object suffix60		if !info.IsDir() && strings.HasSuffix(path, osenv.SharedObjectSuffix) {61			plugins = append(plugins, path)62		}63		return nil64	})65	if walkErr != nil {66		log.Errorf("unable to traverse plugin_path - can't load plugins: %v",67			walkErr)68		return69	}70	for _, file := range plugins {71		loadPluginErr := loadPlugin(file, startPlugins, vconfig)72		if loadPluginErr != nil {73			if strings.Contains(errors.Cause(loadPluginErr).Error(),74				"plugin was built with a different version of package") {75				log.Warn(loadPluginErr)76			} else {77				log.Errorf("unable to load plugin (%s): %+v", file, loadPluginErr)78			}79		}80	}81}82func loadPlugin(file string, startPlugins bool, vconfig *viper.Viper) error {83	log := slog.NewLogger("load-plugin")84	pluginRef, pluginOpenErr := plugin.Open(file)85	if pluginOpenErr != nil {86		return errors.Wrap(pluginOpenErr, "unable to open plugin file")87	}88	metadata, loadMetadataErr := loadPluginMetadata(pluginRef, vconfig)89	if loadMetadataErr != nil {90		return errors.Wrap(loadMetadataErr, "unable to load plugin metadata")91	}92	start, loadStartFuncErr := loadPluginStartFunc(pluginRef)93	if loadStartFuncErr != nil {94		return errors.Wrap(loadStartFuncErr, "unable to load plugin Start func")95	}96	pluginName := metadata["name"].(string)97	if !isPluginEnabled(pluginName, vconfig) {98		log.Debugf("plugin [%s] was detected but not enabled - not loading", pluginName)99		return nil100	}101	configDefaults := metadata["config_defaults"].(map[string]interface{})102	// Add the defaults read from plugin so that we know what are the keys103	// used in a plugin104	config.PluginDefaults[pluginName] = configDefaults105	// Set the defaults as read from the plugin106	for k, v := range configDefaults {107		configKey := pluginName + "." + k108		vconfig.SetDefault(configKey, v)109	}110	if startPlugins {111		startErr := startPlugin(start, pluginName, vconfig)112		if startErr != nil {113			return startErr114		}115		log.Infof("started plugin: [%s]", pluginName)116	} else {117		log.Infof("loaded plugin: [%s]", pluginName)118	}119	return nil120}121func isPluginEnabled(pluginName string, vconfig *viper.Viper) bool {122	enabledPlugins := vconfig.GetStringSlice("enabled_plugins")123	found := false124	for _, p := range enabledPlugins {125		if p == pluginName {126			found = true127			break128		}129	}130	return found131}132func startPlugin(startFunc func(api.PluginStartupContext) error, pluginName string,133	vconfig api.Settings) error {134	context := api.PluginStartupContext{135		Settings: vconfig,136	}137	// It is the plugin's decision if they want to kick off138	// another go worker. However, the plugin must return139	// from the Start() function.140	startErr := startFunc(context)141	if startErr != nil {142		return errors.Wrapf(startErr, "error starting plugin (%s)", pluginName)143	}144	return nil145}146func loadPluginMetadata(pluginRef *plugin.Plugin, settings api.Settings) (map[string]interface{}, error) {147	pluginSymbol, lookupErr := pluginRef.Lookup("Metadata")148	if lookupErr != nil {149		return nil, errors.Wrapf(lookupErr, "unable to load plugin metadata (%v)", pluginRef)150	}151	metadata, ok := pluginSymbol.(func(settings api.Settings) map[string]interface{})152	if !ok {153		return nil, errors.Errorf("unable to load plugin metadata from symbol (%v).Metadata()", pluginRef)154	}155	m := metadata(settings)156	if m["name"] == nil {157		return nil, errors.WithStack(&PluginMetadataKeyMissing{KeyMissing: "name"})158	}159	if reflect.ValueOf(m["name"]).Kind() != reflect.String {160		return nil, errors.WithStack(&PluginMetadataMalformedType{161			KeyName:      "name",162			ExpectedType: reflect.String,163		})164	}165	if m["config_defaults"] == nil {166		m["config_defaults"] = map[string]interface{}{}167	}168	if reflect.ValueOf(m["config_defaults"]).Kind() != reflect.Map {169		return nil, errors.WithStack(&PluginMetadataMalformedType{170			KeyName:      "config_defaults",171			ExpectedType: reflect.Map,172		})173	}174	return m, nil175}176func loadPluginStartFunc(pluginRef *plugin.Plugin) (func(api.PluginStartupContext) error, error) {177	pluginSymbol, lookupErr := pluginRef.Lookup("Start")178	if lookupErr != nil {179		return nil, errors.Wrapf(lookupErr, "unable to load plugin start function (%v)",180			pluginRef)181	}182	start, ok := pluginSymbol.(func(api.PluginStartupContext) error)183	if !ok {184		return nil, errors.Errorf("unexpected type (%v) from start module symbol",185			spew.Sdump(start))186	}187	return start, nil188}...

server.go

Source:server.go

...59	s.mux.Handle(path, s.handlers[path])60}61// ListenAndServe starts all plugins before starting the block Server62func (s *Server) ListenAndServe() error {63	if err := s.StartPlugins(); err != nil {64		return err65	}66	lis, err := net.Listen(s.network, fmt.Sprintf("%s:%d", s.Addr, s.Port))67	if err != nil {68		return err69	}70	defer func(lis net.Listener) {71		if err = lis.Close(); err != nil {72			log.Fatalln(err)73		}74	}(lis)75	return s.Serve(lis)76}77func (s *Server) Serve(lis net.Listener) error {78	s.s.Handler = s.mux79	return s.s.Serve(lis)80}81// Shutdown gracefully shutsdown the http server before killing all child processes82func (s *Server) Shutdown() error {83	s.cancel() // kill the server context to allow everything to stop84	ctx, cancel := context.WithTimeout(context.Background(), s.shutdownDuration)85	defer cancel()86	// stop new requests from coming in and shut down the external server87	if err := s.s.Shutdown(ctx); err != nil {88		return err89	}90	// kill each sub process91	for path := range s.handlers {92		if err := s.handlers[path].Kill(); err != nil {93			log.Println(err)94		}95	}96	return nil97}98// StartPlugins launches all plugins as child processes99func (s *Server) StartPlugins() error {100	for path := range s.handlers {101		if err := s.handlers[path].Start(s.config.ConfigPath); err != nil {102			log.WithError(err).Error("s.Handlers[path].Start")103			return err104		}105	}106	return nil107}...

actions.go

Source:actions.go

...37}38func getInstalledPlugins(config *config.Config) (installedPlugins []installedPlugin, err error) {39	var startPlugins []installedPlugin40	var optPlugins []installedPlugin41	startPlugins, err = getInstalledStartPlugins(config)42	optPlugins, err = getInstalledOptPlugins(config)43	installedPlugins = append(startPlugins, optPlugins...)44	return45}46func getInstalledOptPlugins(config *config.Config) ([]installedPlugin, error) {47	installedOptPlugins := make([]installedPlugin, 0)48	var plugins []os.DirEntry49	var err error50	if plugins, err = os.ReadDir(config.PluginOptDir); err != nil {51		return nil, err52	}53	for _, p := range plugins {54		installedOptPlugins = append(installedOptPlugins, installedPlugin{55			Basename: p.Name(),56			FullPath: filepath.Join(config.PluginOptDir, p.Name()),57			Opt:      true,58		})59	}60	return installedOptPlugins, nil61}62func getInstalledStartPlugins(config *config.Config) ([]installedPlugin, error) {63	installedStartPlugins := make([]installedPlugin, 0)64	var plugins []os.DirEntry65	var err error66	if plugins, err = os.ReadDir(config.PluginStartDir); err != nil {67		return nil, err68	}69	for _, p := range plugins {70		installedStartPlugins = append(installedStartPlugins, installedPlugin{71			Basename: p.Name(),72			FullPath: filepath.Join(config.PluginStartDir, p.Name()),73			Opt:      false,74		})75	}76	return installedStartPlugins, nil77}...

StartPlugins

Using AI Code Generation

1import (2func main() {3	p, err := plugin.Open("plugin.so")4	if err != nil {5		panic(err)6	}7	symPlugin, err := p.Lookup("Plugin")8	if err != nil {9		panic(err)10	}11	plugin, ok := symPlugin.(*Plugin)12	if !ok {13		panic("unexpected type from module symbol")14	}15	plugin.StartPlugins()16}17import (18type Plugin struct {19}20func (p *Plugin) StartPlugins() {21	fmt.Println("Plugin started")22}

StartPlugins

Using AI Code Generation

1import (2func main() {3p, _ := plugin.Open("plugin.so")4start, _ := p.Lookup("StartPlugins")5start.(func())()6}7import (8func main() {9p, _ := plugin.Open("plugin.so")10stop, _ := p.Lookup("StopPlugins")11stop.(func())()12}13import (14func main() {15p, _ := plugin.Open("plugin.so")16do, _ := p.Lookup("DoPlugins")17do.(func())()18}19import (20func StartPlugins() {21fmt.Println("StartPlugins")22}23func StopPlugins() {24fmt.Println("StopPlugins")25}26func DoPlugins() {27fmt.Println("DoPlugins")28}29func main() {30}

StartPlugins

Using AI Code Generation

1import (2func main() {3	p, err := plugin.Open("plugin.so")4	if err != nil {5		panic(err)6	}7	symGreeter, err := p.Lookup("Greeter")8	if err != nil {9		panic(err)10	}11	greeter, ok := symGreeter.(GreeterType)12	if !ok {13		panic("unexpected type from module symbol")14	}15	greeter.Greet()16}17import (18func main() {19	p, err := plugin.Open("plugin.so")20	if err != nil {21		panic(err)22	}23	symGreeter, err := p.Lookup("Greeter")24	if err != nil {25		panic(err)26	}27	greeter, ok := symGreeter.(GreeterType)28	if !ok {29		panic("unexpected type from module symbol")30	}31	greeter.Greet()32}33import (34func main() {35	p, err := plugin.Open("plugin.so")36	if err != nil {37		panic(err)38	}39	symGreeter, err := p.Lookup("Greeter")40	if err != nil {41		panic(err)42	}

StartPlugins

Using AI Code Generation

1func main() {2    plugin.StartPlugins()3}4func main() {5    plugin.StartPlugins()6}7func main() {8    plugin.StartPlugins()9}10func main() {11    plugin.StartPlugins()12}13func main() {14    plugin.StartPlugins()15}16func main() {17    plugin.StartPlugins()18}19func main() {20    plugin.StartPlugins()21}22func main() {23    plugin.StartPlugins()24}25func main() {26    plugin.StartPlugins()27}28func main() {29    plugin.StartPlugins()30}31func main() {32    plugin.StartPlugins()33}34func main() {35    plugin.StartPlugins()36}37func main() {38    plugin.StartPlugins()39}40func main() {41    plugin.StartPlugins()42}43func main() {44    plugin.StartPlugins()45}46func main()

StartPlugins

Using AI Code Generation

1import (2func main() {3    p, err := plugin.Open("1.so")4    if err != nil {5        fmt.Println(err)6    }7    start, err := p.Lookup("StartPlugins")8    if err != nil {9        fmt.Println(err)10    }11    start.(func())()12}

StartPlugins

Using AI Code Generation

1import (2func main() {3	var pluginMap = map[string]plugin.Plugin{4		"plugin": &Plugin{},5	}6	client := plugin.NewClient(&plugin.ClientConfig{7		Cmd:              exec.Command("sh", "-c", "go run 2.go"),8		AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},9	})10	rpcClient, err := client.Client()11	if err != nil {12		logrus.Fatal(err)13	}14	raw, err := rpcClient.Dispense("plugin")15	if err != nil {16		logrus.Fatal(err)17	}18	plugin := raw.(PluginInterface)19	fmt.Println(plugin.SayHello())20}21import (22type Plugin struct{}23func (p *Plugin) SayHello() string {24}25func main() {26	var pluginMap = map[string]plugin.Plugin{27		"plugin": &Plugin{},28	}29	plugin.Serve(&plugin.ServeConfig{30	})31}

StartPlugins

Using AI Code Generation

1import (2var logger = logrus.New()3func main() {4	logger.SetFormatter(&logrus.JSONFormatter{})5	logger.SetLevel(logrus.DebugLevel)6	logger.SetOutput(os.Stdout)7	client := plugin.NewClient(&plugin.ClientConfig{8		HandshakeConfig: plugin.HandshakeConfig{9		},10		Plugins: map[string]plugin.Plugin{11			"plugin": &plugin.PluginImpl{},12		},13		AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},14	})15	rpcClient, err := client.Client()16	if err != nil {17		logger.Fatal(err)18	}19	raw, err := rpcClient.Dispense("plugin")20	if err != nil {21		logger.Fatal(err)22	}23	plugin := raw.(plugin.Plugin)24	logger.Info("Plugin started")25	plugin.StartPlugins()26	sigChan := make(chan os.Signal, 1)27	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)28	plugin.StopPlugins()29}30import (

StartPlugins

Using AI Code Generation

1import (2func main() {3	plugins := golplugin.NewPlugins()4	plugins.Add("plugin1", "plugin1.so")5	plugins.Add("plugin2", "plugin2.so")6	plugins.StartPlugins()7	fmt.Println("plugins started")8}9import (10type plugin1 struct{}11func (p *plugin1) Init() {12	fmt.Println("plugin1 initialized")13}14func (p *plugin1) Start() {15	fmt.Println("plugin1 started")16}17func (p *plugin1) Stop() {18	fmt.Println("plugin1 stopped")19}20func init() {21	golplugin.Register("plugin1", &plugin1{})22}23import (24type plugin2 struct{}25func (p *plugin2) Init() {26	fmt.Println("plugin2 initialized")27}28func (p *plugin2) Start() {29	fmt.Println("plugin2 started")30}31func (p *plugin2) Stop() {32	fmt.Println("plugin2 stopped")33}34func init() {35	golplugin.Register("plugin2", &plugin2{})36}

StartPlugins

Using AI Code Generation

1import (2func main() {3	fmt.Println("main")4}5import (6func main() {7	fmt.Println("main")8}9import (10func main() {11	fmt.Println("main")12}13import (14func main() {15	fmt.Println("main")16}17import (18func main() {19	fmt.Println("main")20}21import (22func main() {23	fmt.Println("main")24}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.