working commit

cmd/minilbctl/forwarder/createforw.go

@@ -0,0 +1,51 @@
+package forwarder
+
+import (
+	"context"
+	"time"
+
+	"helmet/pkg/client"
+	"helmet/pkg/mlbctl"
+
+	"github.com/spf13/cobra"
+)
+
+type CreateForwarderParams struct {
+	Hostname  string
+	Lport     uint32
+	Dport     uint32
+	Addresses []string
+}
+type CreateForwarderResult struct{}
+
+func (tool *Tool) CreateForwarder(cmd *cobra.Command, args []string) {
+	tool.createForwarderParams.Hostname = args[0]
+	res, err := tool.createForwarder(&tool.createForwarderParams)
+	printResponse(res, err)
+}
+
+func (tool *Tool) createForwarder(params *CreateForwarderParams) (*CreateForwarderResult, error) {
+	var err error
+	res := &CreateForwarderResult{}
+	ref, err := client.NewReferer(params.Hostname)
+	if err != nil {
+		return res, err
+	}
+	authCred := client.NewAuthCredential(ref.Userinfo())
+	conn, cli, err := client.NewClient(ref.Hostinfo(), authCred)
+	if err != nil {
+		return res, err
+	}
+	defer conn.Close()
+	ctx, _ := context.WithTimeout(context.Background(), 1*time.Second)
+	opReq := &mlbctl.CreateForwarderParams{
+		Lport:        params.Lport,
+		Dport:        params.Dport,
+		Destinations: params.Addresses,
+	}
+	_, err = cli.CreateForwarder(ctx, opReq)
+	if err != nil {
+		return res, err
+	}
+	return res, err
+}

cmd/minilbctl/forwarder/deleteforw.go

@@ -0,0 +1,47 @@
+package forwarder
+
+import (
+	"context"
+	"time"
+
+	"helmet/pkg/client"
+	"helmet/pkg/mlbctl"
+
+	"github.com/spf13/cobra"
+)
+
+type DeleteForwarderParams struct {
+	Hostname string
+	Lport    uint32
+}
+type DeleteForwarderResult struct{}
+
+func (tool *Tool) DeleteForwarder(cmd *cobra.Command, args []string) {
+	tool.deleteForwarderParams.Hostname = args[0]
+	res, err := tool.deleteForwarder(&tool.deleteForwarderParams)
+	printResponse(res, err)
+}
+
+func (tool *Tool) deleteForwarder(params *DeleteForwarderParams) (*DeleteForwarderResult, error) {
+	var err error
+	res := &DeleteForwarderResult{}
+	ref, err := client.NewReferer(params.Hostname)
+	if err != nil {
+		return res, err
+	}
+	authCred := client.NewAuthCredential(ref.Userinfo())
+	conn, cli, err := client.NewClient(ref.Hostinfo(), authCred)
+	if err != nil {
+		return res, err
+	}
+	defer conn.Close()
+	ctx, _ := context.WithTimeout(context.Background(), 1*time.Second)
+	opReq := &mlbctl.DeleteForwarderParams{
+		Lport: params.Lport,
+	}
+	_, err = cli.DeleteForwarder(ctx, opReq)
+	if err != nil {
+		return res, err
+	}
+	return res, err
+}

cmd/minilbctl/forwarder/forwcmd.go

@@ -0,0 +1,78 @@
+package forwarder
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"sigs.k8s.io/yaml"
+)
+
+type Tool struct {
+	cmd                   *cobra.Command
+	listForwardersParams  ListForwardersParams
+	createForwarderParams CreateForwarderParams
+	deleteForwarderParams DeleteForwarderParams
+}
+
+func NewTool() *Tool {
+	tool := &Tool{}
+	tool.cmd = &cobra.Command{
+		Use:     "forwarder",
+		Short:   "Forwarder operation",
+		Aliases: []string{"forw"},
+	}
+	listForwardersCmd := &cobra.Command{
+		Use:   "list",
+		Args:  cobra.ExactArgs(1),
+		Short: "List forwarders",
+		Run:   tool.ListForwarders,
+	}
+	tool.cmd.AddCommand(listForwardersCmd)
+
+	createForwarderCmd := &cobra.Command{
+		Use:   "create",
+		Args:  cobra.ExactArgs(1),
+		Short: "Create forwarder",
+		Run:   tool.CreateForwarder,
+	}
+	createForwarderCmd.Flags().Uint32VarP(&tool.createForwarderParams.Lport, "lport", "L", 0, "Listening port")
+	createForwarderCmd.Flags().Uint32VarP(&tool.createForwarderParams.Dport, "dport", "D", 0, "Destination port")
+	createForwarderCmd.Flags().StringArrayVarP(&tool.createForwarderParams.Addresses, "dests", "A", []string{}, "Destination address list")
+	createForwarderCmd.MarkFlagRequired("lport")
+	createForwarderCmd.MarkFlagRequired("dport")
+	createForwarderCmd.MarkFlagRequired("dests")
+	tool.cmd.AddCommand(createForwarderCmd)
+
+	deleteForwarderCmd := &cobra.Command{
+		Use:   "delete",
+		Args:  cobra.ExactArgs(1),
+		Short: "Delete forwarder",
+		Run:   tool.CreateForwarder,
+	}
+	deleteForwarderCmd.Flags().Uint32VarP(&tool.deleteForwarderParams.Lport, "lport", "L", 0, "Listening port")
+	deleteForwarderCmd.MarkFlagRequired("lport")
+	tool.cmd.AddCommand(deleteForwarderCmd)
+
+	return tool
+}
+
+func (tool *Tool) GetCmd() *cobra.Command {
+	return tool.cmd
+}
+
+func printResponse(res any, err error) {
+	type Response struct {
+		Error   bool   `json:"error"             json:"error"`
+		Message string `json:"message,omitempty" json:"message,omitempty"`
+		Result  any    `json:"result,omitempty"  json:"result,omitempty"`
+	}
+	resp := Response{}
+	if err != nil {
+		resp.Error = true
+		resp.Message = err.Error()
+	} else {
+		resp.Result = res
+	}
+	respBytes, _ := yaml.Marshal(resp)
+	fmt.Printf("---\n%s\n", string(respBytes))
+}

cmd/minilbctl/forwarder/listforw.go

@@ -0,0 +1,47 @@
+package forwarder
+
+import (
+	"context"
+	"time"
+
+	"helmet/pkg/client"
+	"helmet/pkg/mlbctl"
+
+	"github.com/spf13/cobra"
+)
+
+type ListForwardersParams struct {
+	Hostname string
+}
+type ListForwardersResult struct {
+	Forwarders []*mlbctl.Forwarder `json:"forwarders,omitempty"`
+}
+
+func (tool *Tool) ListForwarders(cmd *cobra.Command, args []string) {
+	tool.listForwardersParams.Hostname = args[0]
+	res, err := tool.listForwarders(&tool.listForwardersParams)
+	printResponse(res, err)
+}
+
+func (tool *Tool) listForwarders(params *ListForwardersParams) (*ListForwardersResult, error) {
+	var err error
+	res := &ListForwardersResult{}
+	ref, err := client.NewReferer(params.Hostname)
+	if err != nil {
+		return res, err
+	}
+	authCred := client.NewAuthCredential(ref.Userinfo())
+	conn, cli, err := client.NewClient(ref.Hostinfo(), authCred)
+	if err != nil {
+		return res, err
+	}
+	defer conn.Close()
+	ctx, _ := context.WithTimeout(context.Background(), 1*time.Second)
+	opReq := &mlbctl.ListForwardersParams{}
+	opRes, err := cli.ListForwarders(ctx, opReq)
+	if err != nil {
+		return res, err
+	}
+	res.Forwarders = opRes.Forwarders
+	return res, err
+}