Merge pull request #193 from openziti/allow-specifying-edge-config-for-loop2

Allow specifying edge config for loop2 dial/listen
2026-10-13 15:51:21 +00:00 · 2020-09-09 12:53:02 -04:00
parent 9842cec3d1 6aa5a6ea81
commit b5138fe81c
3 changed files with 104 additions and 48 deletions
@@ -2,7 +2,8 @@

 * What's New
  * [ziti#192 CAs default to 10yr expiration](https://github.com/openziti/ziti/issues/192)
-
+  * Allow specifying edge config file when using ziti-fabric-test loop2 
+  
 # Release 0.16.2

 * What's New
@@ -19,12 +19,13 @@ package loop2
 import (
 	"fmt"
 	"github.com/michaelquigley/pfxlog"
-	"github.com/openziti/ziti/ziti-fabric-test/subcmd/loop2/pb"
 	"github.com/openziti/fabric/router/xgress_transport"
 	"github.com/openziti/foundation/identity/dotziti"
 	"github.com/openziti/foundation/identity/identity"
 	"github.com/openziti/foundation/transport"
 	"github.com/openziti/sdk-golang/ziti"
+	"github.com/openziti/sdk-golang/ziti/config"
+	"github.com/openziti/ziti/ziti-fabric-test/subcmd/loop2/pb"
 	"github.com/spf13/cobra"
 	"net"
 	"strings"
@@ -32,25 +33,41 @@ import (
 )

 func init() {
-	dialerCmd.Flags().StringVarP(&dialerCmdIdentity, "identity", "i", "default", ".ziti/identities.yml name")
-	dialerCmd.Flags().StringVarP(&dialerCmdEndpoint, "endpoint", "e", "tls:127.0.0.1:7001", "Endpoint address")
-	dialerCmd.Flags().BoolVarP(&dialerCmdDirect, "direct", "d", false, "Transmit direct (no ingress)")
-	dialerCmd.Flags().StringVarP(&dialerCmdService, "service", "s", "loop", "Service name for ingress")
-	loop2Cmd.AddCommand(dialerCmd)
+	dialerCmd := newDialerCmd()
+	loop2Cmd.AddCommand(dialerCmd.cmd)
 }

-var dialerCmd = &cobra.Command{
-	Use:   "dialer <scenarioFile>",
-	Short: "Start loop2 dialer",
-	Args:  cobra.ExactArgs(1),
-	Run:   dialer,
+type dialerCmd struct {
+	cmd            *cobra.Command
+	identity       string
+	endpoint       string
+	direct         bool
+	service        string
+	edgeConfigFile string
 }
-var dialerCmdIdentity string
-var dialerCmdEndpoint string
-var dialerCmdDirect bool
-var dialerCmdService string

-func dialer(_ *cobra.Command, args []string) {
+func newDialerCmd() *dialerCmd {
+	result := &dialerCmd{
+		cmd: &cobra.Command{
+			Use:   "dialer <scenarioFile>",
+			Short: "Start loop2 dialer",
+			Args:  cobra.ExactArgs(1),
+		},
+	}
+
+	result.cmd.Run = result.run
+
+	flags := result.cmd.Flags()
+	flags.StringVarP(&result.identity, "identity", "i", "default", ".ziti/identities.yml name")
+	flags.StringVarP(&result.endpoint, "endpoint", "e", "tls:127.0.0.1:7001", "Endpoint address")
+	flags.BoolVarP(&result.direct, "direct", "d", false, "Transmit direct (no ingress)")
+	flags.StringVarP(&result.service, "service", "s", "loop", "Service name for ingress")
+	flags.StringVarP(&result.edgeConfigFile, "config-file", "c", "", "Edge SDK config file")
+
+	return result
+}
+
+func (cmd *dialerCmd) run(_ *cobra.Command, args []string) {
 	log := pfxlog.Logger()

 	scenario, err := LoadScenario(args[0])
@@ -70,30 +87,41 @@ func dialer(_ *cobra.Command, args []string) {

 			go func() {
 				var conn net.Conn
-				if strings.HasPrefix(dialerCmdEndpoint, "edge:") {
-					context := ziti.NewContext()
-					service := strings.TrimPrefix(dialerCmdEndpoint, "edge:")
+				if strings.HasPrefix(cmd.endpoint, "edge:") {
+
+					var context ziti.Context
+					if cmd.edgeConfigFile != "" {
+						zitiCfg, err := config.NewFromFile(cmd.edgeConfigFile)
+						if err != nil {
+							log.Fatalf("failed to load ziti configuration from %s: %v", cmd.edgeConfigFile, err)
+						}
+						context = ziti.NewContextWithConfig(zitiCfg)
+					} else {
+						context = ziti.NewContext()
+					}
+
+					service := strings.TrimPrefix(cmd.endpoint, "edge:")
 					conn, err = context.Dial(service)
 					if err != nil {
 						panic(err)
 					}
 				} else {
-					endpoint, err := transport.ParseAddress(dialerCmdEndpoint)
+					endpoint, err := transport.ParseAddress(cmd.endpoint)
 					if err != nil {
 						panic(err)
 					}

-					_, id, err := dotziti.LoadIdentity(dialerCmdIdentity)
+					_, id, err := dotziti.LoadIdentity(cmd.identity)
 					if err != nil {
 						panic(err)
 					}

-					if dialerCmdDirect {
+					if cmd.direct {
 						if conn, err = dialDirect(endpoint, id); err != nil {
 							panic(err)
 						}
 					} else {
-						serviceId := &identity.TokenId{Token: dialerCmdService}
+						serviceId := &identity.TokenId{Token: cmd.service}
 						if conn, err = dialIngress(endpoint, id, serviceId); err != nil {
 							panic(err)
 						}
@@ -22,6 +22,7 @@ import (
 	"github.com/openziti/foundation/identity/identity"
 	"github.com/openziti/foundation/transport"
 	"github.com/openziti/sdk-golang/ziti"
+	"github.com/openziti/sdk-golang/ziti/config"
 	"github.com/openziti/ziti/ziti-fabric-test/subcmd/loop2/pb"
 	"github.com/spf13/cobra"
 	"net"
@@ -29,45 +30,71 @@ import (
 )

 func init() {
-	listenerCmd.Flags().StringVarP(&listenerCmdIdentity, "identity", "i", "default", ".ziti/identities.yml name")
-	listenerCmd.Flags().StringVarP(&listenerCmdBindAddress, "bind", "b", "tcp:127.0.0.1:8171", "Listener bind address")
-	loop2Cmd.AddCommand(listenerCmd)
+	listenerCmd := newListenerCmd()
+	loop2Cmd.AddCommand(listenerCmd.cmd)
 }

-var listenerCmd = &cobra.Command{
-	Use:   "listener",
-	Short: "Start loop2 listener",
-	Args:  cobra.ExactArgs(0),
-	Run:   listener,
+type listenerCmd struct {
+	cmd            *cobra.Command
+	identity       string
+	bindAddress    string
+	edgeConfigFile string
 }
-var listenerCmdIdentity string
-var listenerCmdBindAddress string

-func listener(_ *cobra.Command, _ []string) {
-	if strings.HasPrefix(listenerCmdBindAddress, "edge") {
-		listenEdge()
+func newListenerCmd() *listenerCmd {
+	result := &listenerCmd{
+		cmd: &cobra.Command{
+			Use:   "listener",
+			Short: "Start loop2 listener",
+			Args:  cobra.ExactArgs(0),
+		},
+	}
+
+	result.cmd.Run = result.run
+
+	flags := result.cmd.Flags()
+	flags.StringVarP(&result.identity, "identity", "i", "default", ".ziti/identities.yml name")
+	flags.StringVarP(&result.bindAddress, "bind", "b", "tcp:127.0.0.1:8171", "Listener bind address")
+	flags.StringVarP(&result.edgeConfigFile, "config-file", "c", "", "Edge SDK config file")
+
+	return result
+}
+
+func (cmd *listenerCmd) run(_ *cobra.Command, _ []string) {
+	if strings.HasPrefix(cmd.bindAddress, "edge") {
+		cmd.listenEdge()
 	} else {
-		_, id, err := dotziti.LoadIdentity(listenerCmdIdentity)
+		_, id, err := dotziti.LoadIdentity(cmd.identity)
 		if err != nil {
 			panic(err)
 		}

-		bindAddress, err := transport.ParseAddress(listenerCmdBindAddress)
+		bindAddress, err := transport.ParseAddress(cmd.bindAddress)
 		if err != nil {
 			panic(err)
 		}

-		listen(bindAddress, id)
+		cmd.listen(bindAddress, id)
 	}
 }

-func listenEdge() {
-	log := pfxlog.ContextLogger(dialerCmdEndpoint)
+func (cmd *listenerCmd) listenEdge() {
+	log := pfxlog.ContextLogger(cmd.bindAddress)
 	defer log.Error("exited")
 	log.Info("started")

-	context := ziti.NewContext()
-	service := strings.TrimPrefix(dialerCmdEndpoint, "edge:")
+	var context ziti.Context
+	if cmd.edgeConfigFile != "" {
+		zitiCfg, err := config.NewFromFile(cmd.edgeConfigFile)
+		if err != nil {
+			log.Fatalf("failed to load ziti configuration from %s: %v", cmd.edgeConfigFile, err)
+		}
+		context = ziti.NewContextWithConfig(zitiCfg)
+	} else {
+		context = ziti.NewContext()
+	}
+
+	service := strings.TrimPrefix(cmd.bindAddress, "edge:")
 	listener, err := context.Listen(service)
 	if err != nil {
 		panic(err)
@@ -77,12 +104,12 @@ func listenEdge() {
 		if conn, err := listener.Accept(); err != nil {
 			panic(err)
 		} else {
-			go handle(conn, dialerCmdEndpoint)
+			go cmd.handle(conn, cmd.bindAddress)
 		}
 	}
 }

-func listen(bind transport.Address, i *identity.TokenId) {
+func (cmd *listenerCmd) listen(bind transport.Address, i *identity.TokenId) {
 	log := pfxlog.ContextLogger(bind.String())
 	defer log.Error("exited")
 	log.Info("started")
@@ -97,7 +124,7 @@ func listen(bind transport.Address, i *identity.TokenId) {
 		select {
 		case peer := <-incoming:
 			if peer != nil {
-				go handle(peer.Conn(), peer.Detail().String())
+				go cmd.handle(peer.Conn(), peer.Detail().String())
 			} else {
 				return
 			}
@@ -105,7 +132,7 @@ func listen(bind transport.Address, i *identity.TokenId) {
 	}
 }

-func handle(conn net.Conn, context string) {
+func (cmd *listenerCmd) handle(conn net.Conn, context string) {
 	log := pfxlog.ContextLogger(context)
 	if proto, err := newProtocol(conn); err == nil {
 		if test, err := proto.rxTest(); err == nil {