add more flags for create/update operations

cli/cmd/ext_client/update.go

@@ -10,24 +10,62 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var (
+	extClientUpdateFile    string
+	description            string
+	privateKey             string
+	publicKey              string
+	address                string
+	address6               string
+	ingressGatewayID       string
+	ingressGatewayEndpoint string
+	ownerID                string
+)
+
 var extClientUpdateCmd = &cobra.Command{
-	Use:   "update [NETWORK NAME] [NODE ID] [/path/to/ext_client_definition.json]",
-	Args:  cobra.ExactArgs(3),
+	Use:   "update [NETWORK NAME] [EXTERNAL CLIENT ID]",
+	Args:  cobra.ExactArgs(2),
 	Short: "Update an External Client",
 	Long:  `Update an External Client`,
 	Run: func(cmd *cobra.Command, args []string) {
-		extClient := &models.ExtClient{}
-		content, err := os.ReadFile(args[2])
-		if err != nil {
-			log.Fatal("Error when opening file: ", err)
-		}
-		if err := json.Unmarshal(content, extClient); err != nil {
-			log.Fatal(err)
+		var (
+			network   = args[0]
+			clientID  = args[1]
+			extClient = &models.ExtClient{}
+		)
+		if extClientUpdateFile != "" {
+			content, err := os.ReadFile(extClientUpdateFile)
+			if err != nil {
+				log.Fatal("Error when opening file: ", err)
+			}
+			if err := json.Unmarshal(content, extClient); err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			extClient.ClientID = clientID
+			extClient.Description = description
+			extClient.PrivateKey = privateKey
+			extClient.PublicKey = publicKey
+			extClient.Network = network
+			extClient.Address = address
+			extClient.Address6 = address6
+			extClient.IngressGatewayID = ingressGatewayID
+			extClient.IngressGatewayEndpoint = ingressGatewayEndpoint
+			extClient.OwnerID = ownerID
 		}
-		functions.PrettyPrint(functions.UpdateExtClient(args[0], args[1], extClient))
+		functions.PrettyPrint(functions.UpdateExtClient(network, clientID, extClient))
 	},
 }
 
 func init() {
+	extClientUpdateCmd.Flags().StringVar(&extClientUpdateFile, "file", "", "Filepath of updated external client definition in JSON")
+	extClientUpdateCmd.Flags().StringVar(&description, "desc", "", "Description of the external client")
+	extClientUpdateCmd.Flags().StringVar(&privateKey, "private_key", "", "Filepath of updated external client definition in JSON")
+	extClientUpdateCmd.Flags().StringVar(&publicKey, "public_key", "", "Filepath of updated external client definition in JSON")
+	extClientUpdateCmd.Flags().StringVar(&address, "ipv4_addr", "", "IPv4 address of the external client")
+	extClientUpdateCmd.Flags().StringVar(&address6, "ipv6_addr", "", "IPv6 address of the external client")
+	extClientUpdateCmd.Flags().StringVar(&ingressGatewayID, "ingress_gateway_id", "", "ID of the ingress gateway")
+	extClientUpdateCmd.Flags().StringVar(&ingressGatewayEndpoint, "ingress_gateway_endpoint", "", "Endpoint of the ingress gateway")
+	extClientUpdateCmd.Flags().StringVar(&ownerID, "owner_id", "", "External Client owner's ID")
 	rootCmd.AddCommand(extClientUpdateCmd)
 }

cli/cmd/keys/create.go

@@ -12,7 +12,7 @@ import (
 var keyName string
 
 var keysCreateCmd = &cobra.Command{
-	Use:   "create [NETWORK NAME] [NUM USES] [--name=test_key]",
+	Use:   "create [NETWORK NAME] [NUM USES]",
 	Args:  cobra.ExactArgs(2),
 	Short: "Create an access key",
 	Long:  `Create an access key`,

cli/cmd/network/create.go

@@ -10,18 +10,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var (
-	networkDefinitionFilePath string
-	netID                     string
-	ipv4Address               string
-	ipv6Address               string
-	udpHolePunch              bool
-	localNetwork              bool
-	defaultACL                bool
-	pointToSite               bool
-)
-
-// networkCreateCmd represents the networkCreate command
 var networkCreateCmd = &cobra.Command{
 	Use:   "create",
 	Short: "Create a Network",
@@ -39,9 +27,9 @@ var networkCreateCmd = &cobra.Command{
 			}
 		} else {
 			network.NetID = netID
-			network.AddressRange = ipv4Address
-			if ipv6Address != "" {
-				network.AddressRange6 = ipv6Address
+			network.AddressRange = address
+			if address6 != "" {
+				network.AddressRange6 = address6
 				network.IsIPv6 = "yes"
 			}
 			if udpHolePunch {
@@ -56,6 +44,18 @@ var networkCreateCmd = &cobra.Command{
 			if pointToSite {
 				network.IsPointToSite = "yes"
 			}
+			network.DefaultInterface = defaultInterface
+			network.DefaultListenPort = int32(defaultListenPort)
+			network.NodeLimit = int32(nodeLimit)
+			network.DefaultPostUp = defaultPostUp
+			network.DefaultPostDown = defaultPostDown
+			network.DefaultKeepalive = int32(defaultKeepalive)
+			if allowManualSignUp {
+				network.AllowManualSignUp = "yes"
+			}
+			network.LocalRange = localRange
+			network.DefaultExtClientDNS = defaultExtClientDNS
+			network.DefaultMTU = int32(defaultMTU)
 		}
 		functions.PrettyPrint(functions.CreateNetwork(network))
 	},
@@ -65,12 +65,21 @@ func init() {
 	networkCreateCmd.Flags().StringVar(&networkDefinitionFilePath, "file", "", "Path to network_definition.json")
 	networkCreateCmd.Flags().StringVar(&netID, "name", "", "Name of the network")
 	networkCreateCmd.MarkFlagsMutuallyExclusive("file", "name")
-
-	networkCreateCmd.Flags().StringVar(&ipv4Address, "ipv4_addr", "", "IPv4 address of the network")
-	networkCreateCmd.Flags().StringVar(&ipv6Address, "ipv6_addr", "", "IPv6 address of the network")
+	networkCreateCmd.Flags().StringVar(&address, "ipv4_addr", "", "IPv4 address of the network")
+	networkCreateCmd.Flags().StringVar(&address6, "ipv6_addr", "", "IPv6 address of the network")
 	networkCreateCmd.Flags().BoolVar(&udpHolePunch, "udp_hole_punch", false, "Enable UDP Hole Punching ?")
 	networkCreateCmd.Flags().BoolVar(&localNetwork, "local", false, "Is the network local (LAN) ?")
-	networkCreateCmd.Flags().BoolVar(&defaultACL, "default_acl", true, "Enable default Access Control List ?")
+	networkCreateCmd.Flags().BoolVar(&defaultACL, "default_acl", false, "Enable default Access Control List ?")
 	networkCreateCmd.Flags().BoolVar(&pointToSite, "point_to_site", false, "Enforce all clients to have only 1 central peer ?")
+	networkCreateCmd.Flags().StringVar(&defaultInterface, "interface", "", "Name of the network interface")
+	networkCreateCmd.Flags().StringVar(&defaultPostUp, "post_up", "", "Commands to run after server is up `;` separated")
+	networkCreateCmd.Flags().StringVar(&defaultPostDown, "post_down", "", "Commands to run after server is down `;` separated")
+	networkCreateCmd.Flags().StringVar(&localRange, "local_range", "", "Local CIDR range")
+	networkCreateCmd.Flags().StringVar(&defaultExtClientDNS, "ext_client_dns", "", "IPv4 address of DNS server to be used by external clients")
+	networkCreateCmd.Flags().IntVar(&defaultListenPort, "listen_port", 51821, "Default wireguard port each node will attempt to use")
+	networkCreateCmd.Flags().IntVar(&nodeLimit, "node_limit", 999999999, "Maximum number of nodes that can be associated with this network")
+	networkCreateCmd.Flags().IntVar(&defaultKeepalive, "keep_alive", 20, "Keep Alive in seconds")
+	networkCreateCmd.Flags().IntVar(&defaultMTU, "mtu", 1280, "MTU size")
+	networkCreateCmd.Flags().BoolVar(&allowManualSignUp, "manual_signup", false, "Allow manual signup ?")
 	rootCmd.AddCommand(networkCreateCmd)
 }

cli/cmd/network/flags.go

@@ -0,0 +1,22 @@
+package network
+
+var (
+	networkDefinitionFilePath string
+	netID                     string
+	address                   string
+	address6                  string
+	udpHolePunch              bool
+	localNetwork              bool
+	defaultACL                bool
+	pointToSite               bool
+	defaultInterface          string
+	defaultListenPort         int
+	nodeLimit                 int
+	defaultPostUp             string
+	defaultPostDown           string
+	defaultKeepalive          int
+	allowManualSignUp         bool
+	localRange                string
+	defaultExtClientDNS       string
+	defaultMTU                int
+)

cli/cmd/network/get.go

@@ -6,7 +6,7 @@ import (
 )
 
 var networkGetCmd = &cobra.Command{
-	Use:   "get [NAME]",
+	Use:   "get [NETWORK NAME]",
 	Short: "Get a Network",
 	Long:  `Get a Network`,
 	Args:  cobra.ExactArgs(1),

cli/cmd/network/node_limit.go

@@ -9,7 +9,7 @@ import (
 )
 
 var networkNodeLimitCmd = &cobra.Command{
-	Use:   "node_limit [NAME] [NEW LIMIT]",
+	Use:   "node_limit [NETWORK NAME] [NEW LIMIT]",
 	Short: "Update network nodel limit",
 	Long:  `Update network nodel limit`,
 	Args:  cobra.ExactArgs(2),

cli/cmd/network/refresh_keys.go

@@ -6,7 +6,7 @@ import (
 )
 
 var networkRefreshKeysCmd = &cobra.Command{
-	Use:   "refresh_keys [NAME]",
+	Use:   "refresh_keys [NETWORK NAME]",
 	Short: "Refresh public and private key pairs of a network",
 	Long:  `Refresh public and private key pairs of a network`,
 	Args:  cobra.ExactArgs(1),

cli/cmd/network/update.go

@@ -11,23 +11,76 @@ import (
 )
 
 var networkUpdateCmd = &cobra.Command{
-	Use:   "update [NAME] [/path/to/network_definition.json]",
+	Use:   "update [NETWORK NAME]",
 	Short: "Update a Network",
 	Long:  `Update a Network`,
-	Args:  cobra.ExactArgs(2),
+	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
-		content, err := os.ReadFile(args[1])
-		if err != nil {
-			log.Fatal("Error when opening file: ", err)
+		var (
+			networkName = args[0]
+			network     = &models.Network{}
+		)
+		if networkDefinitionFilePath != "" {
+			content, err := os.ReadFile(networkDefinitionFilePath)
+			if err != nil {
+				log.Fatal("Error when opening file: ", err)
+			}
+			if err := json.Unmarshal(content, network); err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			network.NetID = networkName
+			network.AddressRange = address
+			if address6 != "" {
+				network.AddressRange6 = address6
+				network.IsIPv6 = "yes"
+			}
+			if udpHolePunch {
+				network.DefaultUDPHolePunch = "yes"
+			}
+			if localNetwork {
+				network.IsLocal = "yes"
+			}
+			if defaultACL {
+				network.DefaultACL = "yes"
+			}
+			if pointToSite {
+				network.IsPointToSite = "yes"
+			}
+			network.DefaultInterface = defaultInterface
+			network.DefaultListenPort = int32(defaultListenPort)
+			network.NodeLimit = int32(nodeLimit)
+			network.DefaultPostUp = defaultPostUp
+			network.DefaultPostDown = defaultPostDown
+			network.DefaultKeepalive = int32(defaultKeepalive)
+			if allowManualSignUp {
+				network.AllowManualSignUp = "yes"
+			}
+			network.LocalRange = localRange
+			network.DefaultExtClientDNS = defaultExtClientDNS
+			network.DefaultMTU = int32(defaultMTU)
 		}
-		network := &models.Network{}
-		if err := json.Unmarshal(content, network); err != nil {
-			log.Fatal(err)
-		}
-		functions.PrettyPrint(functions.UpdateNetwork(args[0], network))
+		functions.PrettyPrint(functions.UpdateNetwork(networkName, network))
 	},
 }
 
 func init() {
+	networkUpdateCmd.Flags().StringVar(&networkDefinitionFilePath, "file", "", "Path to network_definition.json")
+	networkUpdateCmd.Flags().StringVar(&address, "ipv4_addr", "", "IPv4 address of the network")
+	networkUpdateCmd.Flags().StringVar(&address6, "ipv6_addr", "", "IPv6 address of the network")
+	networkUpdateCmd.Flags().BoolVar(&udpHolePunch, "udp_hole_punch", false, "Enable UDP Hole Punching ?")
+	networkUpdateCmd.Flags().BoolVar(&localNetwork, "local", false, "Is the network local (LAN) ?")
+	networkUpdateCmd.Flags().BoolVar(&defaultACL, "default_acl", false, "Enable default Access Control List ?")
+	networkUpdateCmd.Flags().BoolVar(&pointToSite, "point_to_site", false, "Enforce all clients to have only 1 central peer ?")
+	networkUpdateCmd.Flags().StringVar(&defaultInterface, "interface", "", "Name of the network interface")
+	networkUpdateCmd.Flags().StringVar(&defaultPostUp, "post_up", "", "Commands to run after server is up `;` separated")
+	networkUpdateCmd.Flags().StringVar(&defaultPostDown, "post_down", "", "Commands to run after server is down `;` separated")
+	networkUpdateCmd.Flags().StringVar(&localRange, "local_range", "", "Local CIDR range")
+	networkUpdateCmd.Flags().StringVar(&defaultExtClientDNS, "ext_client_dns", "", "IPv4 address of DNS server to be used by external clients")
+	networkUpdateCmd.Flags().IntVar(&defaultListenPort, "listen_port", 0, "Default wireguard port each node will attempt to use")
+	networkUpdateCmd.Flags().IntVar(&nodeLimit, "node_limit", 0, "Maximum number of nodes that can be associated with this network")
+	networkUpdateCmd.Flags().IntVar(&defaultKeepalive, "keep_alive", 0, "Keep Alive in seconds")
+	networkUpdateCmd.Flags().IntVar(&defaultMTU, "mtu", 0, "MTU size")
+	networkUpdateCmd.Flags().BoolVar(&allowManualSignUp, "manual_signup", false, "Allow manual signup ?")
 	rootCmd.AddCommand(networkUpdateCmd)
 }

cli/cmd/node/flags.go

@@ -1,8 +1,28 @@
 package node
 
 var (
-	networkInterface string
-	natEnabled       bool
-	failover         bool
-	networkName      string
+	networkInterface       string
+	natEnabled             bool
+	failover               bool
+	networkName            string
+	nodeDefinitionFilePath string
+	endpoint               string
+	listenPort             int
+	address                string
+	address6               string
+	localAddress           string
+	name                   string
+	postUp                 string
+	postDown               string
+	allowedIPs             string
+	keepAlive              int
+	relayAddrs             string
+	egressGatewayRanges    string
+	localRange             string
+	mtu                    int
+	expirationDateTime     int
+	defaultACL             bool
+	dnsOn                  bool
+	disconnect             bool
+	networkHub             bool
 )

cli/cmd/node/update.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"log"
 	"os"
+	"strings"
 
 	"github.com/gravitl/netmaker/cli/functions"
 	"github.com/gravitl/netmaker/models"
@@ -11,23 +12,89 @@ import (
 )
 
 var nodeUpdateCmd = &cobra.Command{
-	Use:   "update [NETWORK NAME] [NODE ID] [/path/to/node_definition.json]",
-	Args:  cobra.ExactArgs(3),
+	Use:   "update [NETWORK NAME] [NODE ID]",
+	Args:  cobra.ExactArgs(2),
 	Short: "Update a Node",
 	Long:  `Update a Node`,
 	Run: func(cmd *cobra.Command, args []string) {
-		content, err := os.ReadFile(args[2])
-		if err != nil {
-			log.Fatal("Error when opening file: ", err)
+		var (
+			node        = &models.Node{}
+			networkName = args[0]
+			nodeID      = args[1]
+		)
+		if nodeDefinitionFilePath != "" {
+			content, err := os.ReadFile(nodeDefinitionFilePath)
+			if err != nil {
+				log.Fatal("Error when opening file: ", err)
+			}
+			if err := json.Unmarshal(content, node); err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			if endpoint != "" {
+				node.Endpoint = endpoint
+				node.IsStatic = "no"
+			}
+			node.ListenPort = int32(listenPort)
+			node.Address = address
+			node.Address6 = address6
+			node.LocalAddress = localAddress
+			node.Name = name
+			node.PostUp = postUp
+			node.PostDown = postDown
+			if allowedIPs != "" {
+				node.AllowedIPs = strings.Split(allowedIPs, ",")
+			}
+			node.PersistentKeepalive = int32(keepAlive)
+			if relayAddrs != "" {
+				node.RelayAddrs = strings.Split(relayAddrs, ",")
+			}
+			if egressGatewayRanges != "" {
+				node.EgressGatewayRanges = strings.Split(egressGatewayRanges, ",")
+			}
+			if localRange != "" {
+				node.LocalRange = localRange
+				node.IsLocal = "yes"
+			}
+			node.MTU = int32(mtu)
+			node.ExpirationDateTime = int64(expirationDateTime)
+			if defaultACL {
+				node.DefaultACL = "yes"
+			}
+			if dnsOn {
+				node.DNSOn = "yes"
+			}
+			if disconnect {
+				node.Connected = "no"
+			}
+			if networkHub {
+				node.IsHub = "yes"
+			}
 		}
-		node := &models.Node{}
-		if err := json.Unmarshal(content, node); err != nil {
-			log.Fatal(err)
-		}
-		functions.PrettyPrint(functions.UpdateNode(args[0], args[1], node))
+		functions.PrettyPrint(functions.UpdateNode(networkName, nodeID, node))
 	},
 }
 
 func init() {
+	nodeUpdateCmd.Flags().StringVar(&nodeDefinitionFilePath, "file", "", "Filepath of updated node definition in JSON")
+	nodeUpdateCmd.Flags().StringVar(&endpoint, "endpoint", "", "Public endpoint of the node")
+	nodeUpdateCmd.Flags().IntVar(&listenPort, "listen_port", 0, "Default wireguard port for the node")
+	nodeUpdateCmd.Flags().StringVar(&address, "ipv4_addr", "", "IPv4 address of the node")
+	nodeUpdateCmd.Flags().StringVar(&address6, "ipv6_addr", "", "IPv6 address of the node")
+	nodeUpdateCmd.Flags().StringVar(&localAddress, "local_addr", "", "Locally reachable address of the node")
+	nodeUpdateCmd.Flags().StringVar(&name, "name", "", "Node name")
+	nodeUpdateCmd.Flags().StringVar(&postUp, "post_up", "", "Commands to run after node is up `;` separated")
+	nodeUpdateCmd.Flags().StringVar(&postDown, "post_down", "", "Commands to run after node is down `;` separated")
+	nodeUpdateCmd.Flags().StringVar(&allowedIPs, "allowed_addrs", "", "Additional private addresses given to the node (comma separated)")
+	nodeUpdateCmd.Flags().IntVar(&keepAlive, "keep_alive", 0, "Interval in which packets are sent to keep connections open with peers")
+	nodeUpdateCmd.Flags().StringVar(&relayAddrs, "relay_addrs", "", "Addresses for relaying connections if node acts as a relay")
+	nodeUpdateCmd.Flags().StringVar(&egressGatewayRanges, "egress_addrs", "", "Addresses for egressing traffic if node acts as an egress")
+	nodeUpdateCmd.Flags().StringVar(&localRange, "local_range", "", "Local range in which the node will look for private addresses to use as an endpoint if `LocalNetwork` is enabled")
+	nodeUpdateCmd.Flags().IntVar(&mtu, "mtu", 0, "MTU size")
+	nodeUpdateCmd.Flags().IntVar(&expirationDateTime, "expiry", 0, "UNIX timestamp after which node will lose access to the network")
+	nodeUpdateCmd.Flags().BoolVar(&defaultACL, "acl", false, "Enable default ACL ?")
+	nodeUpdateCmd.Flags().BoolVar(&dnsOn, "dns", false, "Setup DNS entries for peers locally ?")
+	nodeUpdateCmd.Flags().BoolVar(&disconnect, "disconnect", false, "Disconnect from the network ?")
+	nodeUpdateCmd.Flags().BoolVar(&networkHub, "hub", false, "On a point to site network, this node is the only one which all peers connect to ?")
 	rootCmd.AddCommand(nodeUpdateCmd)
 }