How to use startLegacyPlugin method of plugin Package

...202	}203	if pd.hasCapability(gRPCSupportCapability) {204		return startGRPCPlugin(pd, command)205	}206	return startLegacyPlugin(pd, command)207}208func startGRPCPlugin(pd *PluginDescriptor, command []string) (*plugin, error) {209	portChan := make(chan string)210	writer := &logger.LogWriter{211		Stderr: logger.NewCustomWriter(portChan, os.Stderr, pd.ID, true),212		Stdout: logger.NewCustomWriter(portChan, os.Stdout, pd.ID, false),213	}214	cmd, err := common.ExecuteCommand(command, pd.pluginPath, writer.Stdout, writer.Stderr)215	go func() {216		err = cmd.Wait()217		if err != nil {218			logger.Errorf(true, "Error occurred while waiting for plugin process to finish.\nError : %s", err.Error())219		}220	}()221	if err != nil {222		return nil, err223	}224	var port string225	select {226	case port = <-portChan:227		close(portChan)228	case <-time.After(config.PluginConnectionTimeout()):229		return nil, fmt.Errorf("timed out connecting to %s", pd.ID)230	}231	logger.Debugf(true, "Attempting to connect to grpc server at port: %s", port)232	gRPCConn, err := grpc.Dial(fmt.Sprintf("%s:%s", "127.0.0.1", port),233		grpc.WithTransportCredentials(insecure.NewCredentials()),234		grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(1024*1024*1024), grpc.MaxCallRecvMsgSize(1024*1024*1024)),235		grpc.WithBlock())236	if err != nil {237		return nil, err238	}239	plugin := &plugin{240		pluginCmd:  cmd,241		descriptor: pd,242		gRPCConn:   gRPCConn,243		mutex:      &sync.Mutex{},244	}245	if pd.hasScope(docScope) {246		plugin.DocumenterClient = gauge_messages.NewDocumenterClient(gRPCConn)247	} else {248		plugin.ReporterClient = gauge_messages.NewReporterClient(gRPCConn)249	}250	logger.Debugf(true, "Successfully made the connection with plugin with port: %s", port)251	return plugin, nil252}253func startLegacyPlugin(pd *PluginDescriptor, command []string) (*plugin, error) {254	writer := logger.NewLogWriter(pd.ID, true, 0)255	cmd, err := common.ExecuteCommand(command, pd.pluginPath, writer.Stdout, writer.Stderr)256	if err != nil {257		return nil, err258	}259	var mutex = &sync.Mutex{}260	go func() {261		pState, _ := cmd.Process.Wait()262		mutex.Lock()263		cmd.ProcessState = pState264		mutex.Unlock()265	}()266	plugin := &plugin{pluginCmd: cmd, descriptor: pd, mutex: mutex}267	return plugin, nil...

1import (2func main() {3    pluginClient := plugin.NewClient(&plugin.ClientConfig{4        AllowedProtocols: []plugin.Protocol{5        },6        Logger: log.New(log.Writer(), "[plugin]", log.LstdFlags),7    })8    rcpClient, err := pluginClient.Client()9    if err != nil {10        panic(err)11    }12    defer rcpClient.Close()13    raw, err := rcpClient.Dispense("greeter")14    if err != nil {15        panic(err)16    }17    greeter := raw.(shared.Greeter)18    fmt.Println(greeter.Greet("Plugin"))19    pluginClient.Kill()20}21import (22func main() {23    pluginClient := plugin.NewClient(&plugin.ClientConfig{24        AllowedProtocols: []plugin.Protocol{25        },26        Logger: log.New(log.Writer(), "[plugin]", log.LstdFlags),27    })28    rcpClient, err := pluginClient.Client()29    if err != nil {30        panic(err)31    }32    defer rcpClient.Close()

1import (2func main() {3    pluginMap := map[string]plugin.Plugin{4        "greeter": &GreeterPlugin{},5    }6    client := plugin.NewClient(&plugin.ClientConfig{7        Cmd:             exec.Command("sh", "-c", "./plugin"),8        AllowedProtocols: []plugin.Protocol{9        },10    })11    r, err := client.Client()12    if err != nil {13        panic(err)14    }15    raw, err := r.Dispense("greeter")16    if err != nil {17        panic(err)18    }19    greeter := raw.(Greeter)20    fmt.Println(greeter.Greet())21}22import (23func main() {24    pluginMap := map[string]plugin.Plugin{25        "greeter": &GreeterPlugin{},26    }27    client := plugin.NewClient(&plugin.ClientConfig{28        Cmd:             exec.Command("sh", "-c", "./plugin"),29        AllowedProtocols: []plugin.Protocol{30        },31    })32    r, err := client.Client()33    if err != nil {34        panic(err)35    }36    raw, err := r.Dispense("greeter")37    if err != nil {38        panic(err)39    }40    greeter := raw.(Greeter)41    fmt.Println(greeter.Greet())42}43import (44func main() {45    pluginMap := map[string]plugin.Plugin{

1import (2func main() {3	plugin := &plugin{}4	fmt.Println(plugin.startLegacyPlugin("test"))5}6import (7func main() {8	plugin := &plugin{}9	fmt.Println(plugin.startLegacyPlugin("test"))10}11import (12func main() {13	plugin := &plugin{}14	fmt.Println(plugin.startLegacyPlugin("test"))15}16import (17func main() {18	plugin := &plugin{}19	fmt.Println(plugin.startLegacyPlugin("test"))20}21import (22func main() {23	plugin := &plugin{}24	fmt.Println(plugin.startLegacyPlugin("test"))25}26import (27func main() {28	plugin := &plugin{}29	fmt.Println(plugin.startLegacyPlugin("test"))30}31import (32func main() {33	plugin := &plugin{}34	fmt.Println(plugin.startLegacyPlugin("test"))35}36import (37func main() {38	plugin := &plugin{}39	fmt.Println(plugin.startLegacyPlugin("test"))40}41import (42func main() {43	plugin := &plugin{}44	fmt.Println(plugin.startLegacyPlugin("test"))45}46import (47func main() {48	plugin := &plugin{}49	fmt.Println(plugin.startLegacyPlugin("test"))50}51import (52func main() {

1import (2type Plugin interface {3	startLegacyPlugin()4	start()5}6type plugin struct {7}8func (p *plugin) startLegacyPlugin() {9	fmt.Println("code to use startLegacyPlugin method of plugin class")10}11func (p *plugin) start() {12	fmt.Println("code to use start method of plugin class")13}14func main() {15	p := &plugin{name: "test"}16	p.startLegacyPlugin()17	p.start()18}19func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) }20func (v *Vertex) Scale(f float64) { v.X = v.X * f v.Y = v.Y * f }21import (22type Vertex struct {23}24func (v Vertex) Abs() float64 {25	return math.Sqrt(v.X*v.X + v.Y*v.Y)26}27func (v *Vertex) Scale(f float64) {28}29func main() {30	v := Vertex{3, 4}31	v.Scale(10)32	fmt.Println(v.Abs())33}34func (v Vertex) Abs() float64 { return math.Sqrt(v.X*v.X + v.Y*v.Y) }35func (v *Vertex) Scale(f float64) { v.X

1import (2func main() {3	client := plugin.NewClient(&plugin.ClientConfig{4		Plugins:          plugin.PluginSet{},5		AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},6	})7	defer client.Kill()8	rpcClient, err := client.Client()9	if err != nil {10		panic(err)11	}12	raw, err := rpcClient.Dispense("legacy-plugin")13	if err != nil {14		panic(err)15	}16	plugin := raw.(plugin_legacy.LegacyPlugin)17	fmt.Println(plugin.StartLegacyPlugin())18}19import (20func main() {21	client := plugin.NewClient(&plugin.ClientConfig{22		Plugins:          plugin.PluginSet{},23		AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC},24	})25	defer client.Kill()26	rpcClient, err := client.Client()27	if err != nil {28		panic(err)29	}30	raw, err := rpcClient.Dispense("legacy-plugin")31	if err != nil {32		panic(err)33	}34	plugin := raw.(plugin_legacy.LegacyPlugin)

1import (2func main() {3	plugin.Serve(&plugin.ServeConfig{4		Plugins: map[string]plugin.Plugin{5			"legacyplugin": &legacyplugin.LegacyPlugin{},6		},7	})8	fmt.Println("Hello")9}10import (11func main() {12	plugin.Serve(&plugin.ServeConfig{13		Plugins: map[string]plugin.Plugin{14			"legacyplugin": &legacyplugin.LegacyPlugin{},15		},16	})17	fmt.Println("Hello")18}19import (20func main() {21	plugin.Serve(&plugin.ServeConfig{22		Plugins: map[string]plugin.Plugin{23			"legacyplugin": &legacyplugin.LegacyPlugin{},24		},25	})26	fmt.Println("Hello")27}28import (29func main() {30	plugin.Serve(&plugin.ServeConfig{31		Plugins: map[string]plugin.Plugin{32			"legacyplugin": &legacyplugin.LegacyPlugin{},33		},34	})35	fmt.Println("Hello")36}37import (

1import (2func main() {3	plugin := new(Plugin)4	plugin.startLegacyPlugin()5	fmt.Println("Hello World")6}7import (8func main() {9	plugin := new(Plugin)10	plugin.startPlugin()11	fmt.Println("Hello World")12}13import (14func main() {15	plugin := new(Plugin)16	plugin.startPlugin()17	fmt.Println("Hello World")18}19import (20func main() {21	plugin := new(Plugin)22	plugin.startPlugin()23	fmt.Println("Hello World")24}25import (26func main() {27	plugin := new(Plugin)28	plugin.startPlugin()29	fmt.Println("Hello World")30}31The output is as expected. The startPlugin() method is called and the plugin is started. The next step is to use the plugin as a library in a more sophisticated