cmd/kg: only delete iface if requested

This commit modifies the default behavior of Kilo so that the WireGuard
interface is only deleted on shutdown if explicitly requested.

Fixes: https://github.com/squat/kilo/issues/17#issuecomment-534658157

cmd/kg/main.go

@@ -79,16 +79,17 @@ var (
 // Main is the principal function for the binary, wrapped only by `main` for convenience.
 func Main() error {
 	backend := flag.String("backend", k8s.Backend, fmt.Sprintf("The backend for the mesh. Possible values: %s", availableBackends))
-	cni := flag.Bool("cni", true, "Should Kilo manage the node's CNI configuration.")
+	cleanUpIface := flag.Bool("clean-up-interface", false, "Should Kilo delete its interface when it shuts down?")
+	cni := flag.Bool("cni", true, "Should Kilo manage the node's CNI configuration?")
 	cniPath := flag.String("cni-path", mesh.DefaultCNIPath, "Path to CNI config.")
 	compatibility := flag.String("compatibility", "", fmt.Sprintf("Should Kilo run in compatibility mode? Possible values: %s", availableCompatibilities))
-	encapsulate := flag.String("encapsulate", string(encapsulation.Always), fmt.Sprintf("When should Kilo encapsulate packets within a location. Possible values: %s", availableEncapsulations))
+	encapsulate := flag.String("encapsulate", string(encapsulation.Always), fmt.Sprintf("When should Kilo encapsulate packets within a location? Possible values: %s", availableEncapsulations))
 	granularity := flag.String("mesh-granularity", string(mesh.LogicalGranularity), fmt.Sprintf("The granularity of the network mesh to create. Possible values: %s", availableGranularities))
 	kubeconfig := flag.String("kubeconfig", "", "Path to kubeconfig.")
 	hostname := flag.String("hostname", "", "Hostname of the node on which this process is running.")
 	iface := flag.String("interface", mesh.DefaultKiloInterface, "Name of the Kilo interface to use; if it does not exist, it will be created.")
 	listen := flag.String("listen", ":1107", "The address at which to listen for health and metrics.")
-	local := flag.Bool("local", true, "Should Kilo manage routes within a location.")
+	local := flag.Bool("local", true, "Should Kilo manage routes within a location?")
 	logLevel := flag.String("log-level", logLevelInfo, fmt.Sprintf("Log level to use. Possible values: %s", availableLogLevels))
 	master := flag.String("master", "", "The address of the Kubernetes API server (overrides any value in kubeconfig).")
 	var port uint
@@ -175,7 +176,7 @@ func Main() error {
 		return fmt.Errorf("backend %v unknown; possible values are: %s", *backend, availableBackends)
 	}
 
-	m, err := mesh.New(b, enc, gr, *hostname, uint32(port), s, *local, *cni, *cniPath, *iface, log.With(logger, "component", "kilo"))
+	m, err := mesh.New(b, enc, gr, *hostname, uint32(port), s, *local, *cni, *cniPath, *iface, *cleanUpIface, log.With(logger, "component", "kilo"))
 	if err != nil {
 		return fmt.Errorf("failed to create Kilo mesh: %v", err)
 	}

pkg/mesh/mesh.go

@@ -169,27 +169,27 @@ type PeerBackend interface {
 // Mesh is able to create Kilo network meshes.
 type Mesh struct {
 	Backend
-	cni         bool
-	cniPath     string
-	deleteIface bool
-	enc         encapsulation.Encapsulator
-	externalIP  *net.IPNet
-	granularity Granularity
-	hostname    string
-	internalIP  *net.IPNet
-	ipTables    *iptables.Controller
-	kiloIface   int
-	key         []byte
-	local       bool
-	port        uint32
-	priv        []byte
-	privIface   int
-	pub         []byte
-	pubIface    int
-	stop        chan struct{}
-	subnet      *net.IPNet
-	table       *route.Table
-	wireGuardIP *net.IPNet
+	cleanUpIface bool
+	cni          bool
+	cniPath      string
+	enc          encapsulation.Encapsulator
+	externalIP   *net.IPNet
+	granularity  Granularity
+	hostname     string
+	internalIP   *net.IPNet
+	ipTables     *iptables.Controller
+	kiloIface    int
+	key          []byte
+	local        bool
+	port         uint32
+	priv         []byte
+	privIface    int
+	pub          []byte
+	pubIface     int
+	stop         chan struct{}
+	subnet       *net.IPNet
+	table        *route.Table
+	wireGuardIP  *net.IPNet
 
 	// nodes and peers are mutable fields in the struct
 	// and needs to be guarded.
@@ -205,7 +205,7 @@ type Mesh struct {
 }
 
 // New returns a new Mesh instance.
-func New(backend Backend, enc encapsulation.Encapsulator, granularity Granularity, hostname string, port uint32, subnet *net.IPNet, local, cni bool, cniPath, iface string, logger log.Logger) (*Mesh, error) {
+func New(backend Backend, enc encapsulation.Encapsulator, granularity Granularity, hostname string, port uint32, subnet *net.IPNet, local, cni bool, cniPath, iface string, cleanUpIface bool, logger log.Logger) (*Mesh, error) {
 	if err := os.MkdirAll(KiloPath, 0700); err != nil {
 		return nil, fmt.Errorf("failed to create directory to store configuration: %v", err)
 	}
@@ -242,7 +242,7 @@ func New(backend Backend, enc encapsulation.Encapsulator, granularity Granularit
 		return nil, fmt.Errorf("failed to find interface for public IP: %v", err)
 	}
 	pubIface := ifaces[0].Index
-	kiloIface, created, err := wireguard.New(iface)
+	kiloIface, _, err := wireguard.New(iface)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create WireGuard interface: %v", err)
 	}
@@ -258,28 +258,28 @@ func New(backend Backend, enc encapsulation.Encapsulator, granularity Granularit
 		return nil, fmt.Errorf("failed to IP tables controller: %v", err)
 	}
 	return &Mesh{
-		Backend:     backend,
-		cni:         cni,
-		cniPath:     cniPath,
-		deleteIface: created,
-		enc:         enc,
-		externalIP:  publicIP,
-		granularity: granularity,
-		hostname:    hostname,
-		internalIP:  privateIP,
-		ipTables:    ipTables,
-		kiloIface:   kiloIface,
-		nodes:       make(map[string]*Node),
-		peers:       make(map[string]*Peer),
-		port:        port,
-		priv:        private,
-		privIface:   privIface,
-		pub:         public,
-		pubIface:    pubIface,
-		local:       local,
-		stop:        make(chan struct{}),
-		subnet:      subnet,
-		table:       route.NewTable(),
+		Backend:      backend,
+		cleanUpIface: cleanUpIface,
+		cni:          cni,
+		cniPath:      cniPath,
+		enc:          enc,
+		externalIP:   publicIP,
+		granularity:  granularity,
+		hostname:     hostname,
+		internalIP:   privateIP,
+		ipTables:     ipTables,
+		kiloIface:    kiloIface,
+		nodes:        make(map[string]*Node),
+		peers:        make(map[string]*Peer),
+		port:         port,
+		priv:         private,
+		privIface:    privIface,
+		pub:          public,
+		pubIface:     pubIface,
+		local:        local,
+		stop:         make(chan struct{}),
+		subnet:       subnet,
+		table:        route.NewTable(),
 		errorCounter: prometheus.NewCounterVec(prometheus.CounterOpts{
 			Name: "kilo_errors_total",
 			Help: "Number of errors that occurred while administering the mesh.",
@@ -717,7 +717,7 @@ func (m *Mesh) cleanUp() {
 		level.Error(m.logger).Log("error", fmt.Sprintf("failed to delete configuration file: %v", err))
 		m.errorCounter.WithLabelValues("cleanUp").Inc()
 	}
-	if m.deleteIface {
+	if m.cleanUpIface {
 		if err := iproute.RemoveInterface(m.kiloIface); err != nil {
 			level.Error(m.logger).Log("error", fmt.Sprintf("failed to remove WireGuard interface: %v", err))
 			m.errorCounter.WithLabelValues("cleanUp").Inc()