Milestone 2 - Server and Client

.gitignore

@@ -4,6 +4,7 @@
 *.dll
 *.so
 *.dylib
+bin/*
 
 # Test binary, built with `go test -c`
 *.test

README.md

@@ -7,3 +7,27 @@
 
 # BitBox
 Rudementary implementation of containerization in linux.
+
+
+## Server
+For available endpoints view the [gRPC deffinition](grpc/bitbox.proto).
+```bash
+# Build the Server.
+go build -o bin/bitbox cmd/server/main.go
+# Run it.
+./bin/bitbox
+```
+
+
+## CLI Client
+```bash
+# Build the CLI
+go build -o bin/bitboxcli cmd/client/*.go
+# Run it.
+./bin/bitboxcli start <process>
+```
+
+## Development Tools
+[gRPC & protoc](https://grpc.io/docs/languages/go/quickstart/) are used by `go generate` to update [bitbox/grpc](grpc/).
+
+[gRPCox](https://github.com/gusaul/grpcox) is a lightweight docker container for easy manual testing.

cmd/client/main.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net"
+	"os"
+
+	bbgrpc "github.com/jmbarzee/bitbox/grpc"
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc"
+)
+
+var defaultPort = optionalEnvString("BIT_BOX_PORT", "8443")
+
+var defaultAddress = optionalEnvString("BIT_BOX_ADDR", func() string {
+	ip, err := getOutboundIP()
+	if err != nil {
+		panic(err)
+	}
+	return ip.String()
+}())
+
+var root = &cobra.Command{
+	Use:   "bitboxcli",
+	Short: "A CLI tool for remote BitBox operations",
+	Long:  "Execute remote linux processes on a BitBox server",
+}
+
+func main() {
+	root.AddCommand(cmdStart)
+	root.AddCommand(cmdStop)
+	root.AddCommand(cmdStatus)
+	root.AddCommand(cmdQuery)
+	if err := root.Execute(); err != nil {
+		panic(err)
+	}
+}
+
+func optionalEnvString(key, defaultValue string) string {
+	if value, ok := os.LookupEnv(key); ok {
+		return value
+	}
+	log.Printf("Missing optional environment variable %s, using default %s", key, defaultValue)
+	return defaultValue
+}
+
+func getOutboundIP() (net.IP, error) {
+	conn, err := net.Dial("udp", "8.8.8.8:80")
+	if err != nil {
+		return net.IP{}, err
+	}
+	defer conn.Close()
+
+	localAddr := conn.LocalAddr().(*net.UDPAddr)
+
+	return localAddr.IP, nil
+}
+
+func getClient(ctx context.Context) bbgrpc.BitBoxClient {
+	address := fmt.Sprintf("%s:%s", defaultAddress, defaultPort)
+
+	conn, err := grpc.DialContext(
+		context.TODO(),
+		address,
+		//TODO: replace with mTLS
+		grpc.WithInsecure(),
+		grpc.WithBlock())
+	if err != nil {
+		panic(fmt.Errorf("Failed to dial connection during reconnect: %w", err))
+	}
+
+	return bbgrpc.NewBitBoxClient(conn)
+}

cmd/client/query.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+
+	bbgrpc "github.com/jmbarzee/bitbox/grpc"
+)
+
+var cmdQuery = &cobra.Command{
+	Use:   "query",
+	Short: "query",
+	Long:  "Query a process on the bitbox server",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) != 1 {
+			return errors.New("Require a single id as an argument")
+		}
+
+		uuid, err := uuid.Parse(args[0])
+		if err != nil {
+			return fmt.Errorf("failed to parse uuid: %s", args[0])
+		}
+
+		job := jobQuery{
+			id: uuid,
+		}
+		ctx := context.Background()
+		bbClient := getClient(ctx)
+		return job.execute(ctx, bbClient)
+	},
+}
+
+type jobQuery struct {
+	id uuid.UUID
+}
+
+// Execute querys a job on the remote bitBox
+func (j jobQuery) execute(ctx context.Context, c bbgrpc.BitBoxClient) error {
+	request := &bbgrpc.QueryRequest{
+		ID: j.id[:],
+	}
+
+	queryClient, err := c.Query(ctx, request)
+	if err != nil {
+		return fmt.Errorf("failed to stop process %s: %w", j.id, err)
+	}
+
+	for {
+		reply, err := queryClient.Recv()
+		if err == io.EOF {
+			log.Println("<End of Stream>")
+		}
+		if err != nil {
+			return fmt.Errorf("failed to fetch reply: %w", err)
+		}
+		switch output := reply.GetOutput().(type) {
+		case *bbgrpc.QueryReply_Stdouterr:
+			log.Println(output.Stdouterr)
+		case *bbgrpc.QueryReply_ExitCode:
+			log.Printf("Process %v exited with code %v", j.id, output.ExitCode)
+			return nil
+		}
+	}
+}

cmd/client/start.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+
+	bbgrpc "github.com/jmbarzee/bitbox/grpc"
+)
+
+var cmdStart = &cobra.Command{
+	Use:   "start",
+	Short: "start",
+	Long:  "Start a process on the bitbox server",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) < 1 {
+			return errors.New("Require atleast a single command as an argument")
+		}
+
+		job := jobStart{
+			command:   args[0],
+			arguments: args[1:],
+		}
+		ctx := context.Background()
+		bbClient := getClient(ctx)
+		return job.execute(ctx, bbClient)
+	},
+}
+
+type jobStart struct {
+	command   string
+	arguments []string
+}
+
+// Execute starts a job on the remote bitBox
+func (j jobStart) execute(ctx context.Context, c bbgrpc.BitBoxClient) error {
+	request := &bbgrpc.StartRequest{
+		Command:   j.command,
+		Arguments: j.arguments,
+	}
+
+	reply, err := c.Start(ctx, request)
+	if err != nil {
+		return fmt.Errorf("failed to run %s: %w", j.command, err)
+	}
+	uuid, err := uuid.FromBytes(reply.GetID())
+	if err != nil {
+		return fmt.Errorf("failed to parse uuid: %s", reply.GetID())
+	}
+	log.Println("Successfully started process: ", uuid.String())
+	return nil
+}

cmd/client/status.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+
+	bbgrpc "github.com/jmbarzee/bitbox/grpc"
+)
+
+var cmdStatus = &cobra.Command{
+	Use:   "status",
+	Short: "status",
+	Long:  "Stop a process on the bitbox server",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) != 1 {
+			return errors.New("Require a single id as an argument")
+		}
+
+		uuid, err := uuid.Parse(args[0])
+		if err != nil {
+			return fmt.Errorf("failed to parse uuid: %s", args[0])
+		}
+
+		job := jobStatus{
+			id: uuid,
+		}
+		ctx := context.Background()
+		bbClient := getClient(ctx)
+		return job.execute(ctx, bbClient)
+	},
+}
+
+type jobStatus struct {
+	id uuid.UUID
+}
+
+// Execute returns the status of a job on the remote bitBox
+func (j jobStatus) execute(ctx context.Context, c bbgrpc.BitBoxClient) error {
+	request := &bbgrpc.StatusRequest{
+		ID: j.id[:],
+	}
+
+	reply, err := c.Status(ctx, request)
+	if err != nil {
+		return fmt.Errorf("failed to query process %s: %w", j.id, err)
+	}
+	log.Println("Successfully queried status of process: ", j.id, ", ", reply.Status.String())
+
+	return nil
+}

cmd/client/stop.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+
+	"github.com/google/uuid"
+	"github.com/spf13/cobra"
+
+	bbgrpc "github.com/jmbarzee/bitbox/grpc"
+)
+
+var cmdStop = &cobra.Command{
+	Use:   "stop",
+	Short: "stop",
+	Long:  "Stop a process on the bitbox server",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) != 1 {
+			return errors.New("Require a single id as an argument")
+		}
+
+		uuid, err := uuid.Parse(args[0])
+		if err != nil {
+			return fmt.Errorf("failed to parse uuid: %s", args[0])
+		}
+
+		job := jobStop{
+			id: uuid,
+		}
+		ctx := context.Background()
+		bbClient := getClient(ctx)
+		return job.execute(ctx, bbClient)
+	},
+}
+
+type jobStop struct {
+	id uuid.UUID
+}
+
+// Execute stops a job on the remote bitBox
+func (j jobStop) execute(ctx context.Context, c bbgrpc.BitBoxClient) error {
+	request := &bbgrpc.StopRequest{
+		ID: j.id[:],
+	}
+
+	_, err := c.Stop(ctx, request)
+	if err != nil {
+		return fmt.Errorf("failed to stop process %s: %w", j.id, err)
+	}
+	log.Println("Successfully stopped process: ", j.id)
+	return nil
+}

cmd/server/main.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	// temp import for build
+	"fmt"
+	"log"
+	"net"
+	"os"
+
+	"github.com/jmbarzee/bitbox"
+	bbgrpc "github.com/jmbarzee/bitbox/grpc"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+var defaultPort = optionalEnvString("BIT_BOX_PORT", "8443")
+var defaultAddress = optionalEnvString("BIT_BOX_ADDR", "")
+
+func main() {
+
+	address := fmt.Sprintf("%s:%s", defaultAddress, defaultPort)
+
+	lis, err := net.Listen("tcp", address)
+	if err != nil {
+		panic(fmt.Errorf("failed to listen on %s: %w", address, err))
+	}
+
+	bitBoxServer := bitbox.NewServer()
+
+	server := grpc.NewServer()
+
+	bbgrpc.RegisterBitBoxServer(server, bitBoxServer)
+	// Register reflection service on gRPC server.
+	reflection.Register(server)
+
+	err = server.Serve(lis)
+}
+
+func optionalEnvString(key, defaultValue string) string {
+	if value, ok := os.LookupEnv(key); ok {
+		return value
+	}
+	log.Printf("Missing optional environment variable %s, using default %s", key, defaultValue)
+	return defaultValue
+}