init

2019-01-18 02:50:10 +01:00
commit e989f0a25f
1789 changed files with 680059 additions and 0 deletions
--- a/cmd/kg/main.go
+++ b/cmd/kg/main.go
@@ -0,0 +1,232 @@
+// Copyright 2019 the Kilo authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/log/level"
+	"github.com/oklog/run"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/clientcmd"
+
+	"github.com/squat/kilo/pkg/k8s"
+	"github.com/squat/kilo/pkg/mesh"
+	"github.com/squat/kilo/pkg/version"
+)
+
+const (
+	logLevelAll   = "all"
+	logLevelDebug = "debug"
+	logLevelInfo  = "info"
+	logLevelWarn  = "warn"
+	logLevelError = "error"
+	logLevelNone  = "none"
+)
+
+var (
+	availableBackends = strings.Join([]string{
+		k8s.Backend,
+	}, ", ")
+	availableEncapsulations = strings.Join([]string{
+		string(mesh.NeverEncapsulate),
+		string(mesh.CrossSubnetEncapsulate),
+		string(mesh.AlwaysEncapsulate),
+	}, ", ")
+	availableGranularities = strings.Join([]string{
+		string(mesh.DataCenterGranularity),
+		string(mesh.NodeGranularity),
+	}, ", ")
+	availableLogLevels = strings.Join([]string{
+		logLevelAll,
+		logLevelDebug,
+		logLevelInfo,
+		logLevelWarn,
+		logLevelError,
+		logLevelNone,
+	}, ", ")
+)
+
+// 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))
+	encapsulate := flag.String("encapsulate", string(mesh.AlwaysEncapsulate), fmt.Sprintf("When should Kilo encapsulate packets within a location. Possible values: %s", availableEncapsulations))
+	granularity := flag.String("mesh-granularity", string(mesh.DataCenterGranularity), 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.")
+	listen := flag.String("listen", "localhost:1107", "The address at which to listen for health and metrics.")
+	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).")
+	port := flag.Int("port", 51820, "The port over which WireGuard peers should communicate.")
+	subnet := flag.String("subnet", "10.4.0.0/16", "CIDR from which to allocate addressees to WireGuard interfaces.")
+	printVersion := flag.Bool("version", false, "Print version and exit")
+	flag.Parse()
+
+	if *printVersion {
+		fmt.Println(version.Version)
+		return nil
+	}
+
+	_, s, err := net.ParseCIDR(*subnet)
+	if err != nil {
+		return fmt.Errorf("failed to parse %q as CIDR: %v", *subnet, err)
+	}
+
+	if *hostname == "" {
+		var err error
+		*hostname, err = os.Hostname()
+		if *hostname == "" || err != nil {
+			return errors.New("failed to determine hostname")
+		}
+	}
+
+	logger := log.NewJSONLogger(log.NewSyncWriter(os.Stdout))
+	switch *logLevel {
+	case logLevelAll:
+		logger = level.NewFilter(logger, level.AllowAll())
+	case logLevelDebug:
+		logger = level.NewFilter(logger, level.AllowDebug())
+	case logLevelInfo:
+		logger = level.NewFilter(logger, level.AllowInfo())
+	case logLevelWarn:
+		logger = level.NewFilter(logger, level.AllowWarn())
+	case logLevelError:
+		logger = level.NewFilter(logger, level.AllowError())
+	case logLevelNone:
+		logger = level.NewFilter(logger, level.AllowNone())
+	default:
+		return fmt.Errorf("log level %v unknown; posible values are: %s", *logLevel, availableLogLevels)
+	}
+	logger = log.With(logger, "ts", log.DefaultTimestampUTC)
+	logger = log.With(logger, "caller", log.DefaultCaller)
+
+	e := mesh.Encapsulate(*encapsulate)
+	switch e {
+	case mesh.NeverEncapsulate:
+	case mesh.CrossSubnetEncapsulate:
+	case mesh.AlwaysEncapsulate:
+	default:
+		return fmt.Errorf("encapsulation %v unknown; posible values are: %s", *encapsulate, availableEncapsulations)
+	}
+
+	gr := mesh.Granularity(*granularity)
+	switch gr {
+	case mesh.DataCenterGranularity:
+	case mesh.NodeGranularity:
+	default:
+		return fmt.Errorf("mesh granularity %v unknown; posible values are: %s", *granularity, availableGranularities)
+	}
+
+	var b mesh.Backend
+	switch *backend {
+	case k8s.Backend:
+		config, err := clientcmd.BuildConfigFromFlags(*master, *kubeconfig)
+		if err != nil {
+			return fmt.Errorf("failed to create Kubernetes config: %v", err)
+		}
+		client := kubernetes.NewForConfigOrDie(config)
+		b = k8s.New(client)
+	default:
+		return fmt.Errorf("backend %v unknown; posible values are: %s", *backend, availableBackends)
+	}
+
+	m, err := mesh.New(b, e, gr, *hostname, *port, s, *local, log.With(logger, "component", "kilo"))
+	if err != nil {
+		return fmt.Errorf("failed to create Kilo mesh: %v", err)
+	}
+
+	r := prometheus.NewRegistry()
+	r.MustRegister(
+		prometheus.NewGoCollector(),
+		prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{}),
+	)
+	m.RegisterMetrics(r)
+
+	var g run.Group
+	{
+		// Run the HTTP server.
+		mux := http.NewServeMux()
+		mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		})
+		mux.Handle("/metrics", promhttp.HandlerFor(r, promhttp.HandlerOpts{}))
+		l, err := net.Listen("tcp", *listen)
+		if err != nil {
+			return fmt.Errorf("failed to listen on %s: %v", *listen, err)
+		}
+
+		g.Add(func() error {
+			if err := http.Serve(l, mux); err != nil && err != http.ErrServerClosed {
+				return fmt.Errorf("error: server exited unexpectedly: %v", err)
+			}
+			return nil
+		}, func(error) {
+			l.Close()
+		})
+	}
+
+	{
+		// Start the mesh.
+		g.Add(func() error {
+			logger.Log("msg", fmt.Sprintf("Starting Kilo network mesh '%v'.", version.Version))
+			if err := m.Run(); err != nil {
+				return fmt.Errorf("error: Kilo exited unexpectedly: %v", err)
+			}
+			return nil
+		}, func(error) {
+			m.Stop()
+		})
+	}
+	{
+		// Exit gracefully on SIGINT and SIGTERM.
+		term := make(chan os.Signal, 1)
+		signal.Notify(term, syscall.SIGINT, syscall.SIGTERM)
+		cancel := make(chan struct{})
+		g.Add(func() error {
+			for {
+				select {
+				case <-term:
+					logger.Log("msg", "caught interrupt; gracefully cleaning up; see you next time!")
+					return nil
+				case <-cancel:
+					return nil
+				}
+			}
+		}, func(error) {
+			close(cancel)
+		})
+	}
+
+	return g.Run()
+}
+
+func main() {
+	if err := Main(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+}
--- a/cmd/kgctl/graph.go
+++ b/cmd/kgctl/graph.go
@@ -0,0 +1,58 @@
+// Copyright 2019 the Kilo authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/squat/kilo/pkg/mesh"
+)
+
+func newGraph() *cobra.Command {
+	return &cobra.Command{
+		Use:   "graph",
+		Short: "Generates a graph of the Kilo network",
+		Long:  "",
+		RunE:  runGraph,
+	}
+}
+
+func runGraph(_ *cobra.Command, _ []string) error {
+	ns, err := opts.backend.List()
+	if err != nil {
+		return fmt.Errorf("failed to list nodes: %v", err)
+	}
+	var hostname string
+	if len(ns) != 0 {
+		hostname = ns[0].Name
+	}
+	nodes := make(map[string]*mesh.Node)
+	for _, n := range ns {
+		if n.Ready() {
+			nodes[n.Name] = n
+		}
+	}
+	t, err := mesh.NewTopology(nodes, opts.granularity, hostname, 0, []byte{}, opts.subnet)
+	if err != nil {
+		return fmt.Errorf("failed to create topology: %v", err)
+	}
+	g, err := t.Dot()
+	if err != nil {
+		return fmt.Errorf("failed to generate graph: %v", err)
+	}
+	fmt.Println(g)
+	return nil
+}
--- a/cmd/kgctl/main.go
+++ b/cmd/kgctl/main.go
@@ -0,0 +1,124 @@
+// Copyright 2019 the Kilo authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"strings"
+
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/tools/clientcmd"
+
+	"github.com/spf13/cobra"
+	"github.com/squat/kilo/pkg/k8s"
+	"github.com/squat/kilo/pkg/mesh"
+	"github.com/squat/kilo/pkg/version"
+)
+
+const (
+	logLevelAll   = "all"
+	logLevelDebug = "debug"
+	logLevelInfo  = "info"
+	logLevelWarn  = "warn"
+	logLevelError = "error"
+	logLevelNone  = "none"
+)
+
+var (
+	availableBackends = strings.Join([]string{
+		k8s.Backend,
+	}, ", ")
+	availableGranularities = strings.Join([]string{
+		string(mesh.DataCenterGranularity),
+		string(mesh.NodeGranularity),
+	}, ", ")
+	availableLogLevels = strings.Join([]string{
+		logLevelAll,
+		logLevelDebug,
+		logLevelInfo,
+		logLevelWarn,
+		logLevelError,
+		logLevelNone,
+	}, ", ")
+	opts struct {
+		backend     mesh.Backend
+		granularity mesh.Granularity
+		subnet      *net.IPNet
+	}
+	backend     string
+	granularity string
+	kubeconfig  string
+	subnet      string
+)
+
+func runRoot(_ *cobra.Command, _ []string) error {
+	_, s, err := net.ParseCIDR(subnet)
+	if err != nil {
+		return fmt.Errorf("failed to parse %q as CIDR: %v", subnet, err)
+	}
+	opts.subnet = s
+
+	opts.granularity = mesh.Granularity(granularity)
+	switch opts.granularity {
+	case mesh.DataCenterGranularity:
+	case mesh.NodeGranularity:
+	default:
+		return fmt.Errorf("mesh granularity %v unknown; posible values are: %s", granularity, availableGranularities)
+	}
+
+	switch backend {
+	case k8s.Backend:
+		config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
+		if err != nil {
+			return fmt.Errorf("failed to create Kubernetes config: %v", err)
+		}
+		client := kubernetes.NewForConfigOrDie(config)
+		opts.backend = k8s.New(client)
+	default:
+		return fmt.Errorf("backend %v unknown; posible values are: %s", backend, availableBackends)
+	}
+
+	if err := opts.backend.Init(make(chan struct{})); err != nil {
+		return fmt.Errorf("failed to initialize backend: %v", err)
+	}
+	return nil
+}
+
+func main() {
+	cmd := &cobra.Command{
+		Use:               "kgctl",
+		Short:             "Manage a Kilo network",
+		Long:              "",
+		PersistentPreRunE: runRoot,
+		Version:           version.Version,
+	}
+	cmd.PersistentFlags().StringVar(&backend, "backend", k8s.Backend, fmt.Sprintf("The backend for the mesh. Possible values: %s", availableBackends))
+	cmd.PersistentFlags().StringVar(&granularity, "mesh-granularity", string(mesh.DataCenterGranularity), fmt.Sprintf("The granularity of the network mesh to create. Possible values: %s", availableGranularities))
+	cmd.PersistentFlags().StringVar(&kubeconfig, "kubeconfig", "", "Path to kubeconfig.")
+	cmd.PersistentFlags().StringVar(&subnet, "subnet", "10.4.0.0/16", "CIDR from which to allocate addressees to WireGuard interfaces.")
+
+	for _, subCmd := range []*cobra.Command{
+		newGraph(),
+	} {
+		cmd.AddCommand(subCmd)
+	}
+
+	if err := cmd.Execute(); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+		os.Exit(1)
+	}
+}