Merge ~cgrabowski/maas:rpc_client_server into maas:rack_region_exploration

[Christian Grabowski]

add rpc handshake

add machine helper functions

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: b8a28beb8353fa66ac5a4d5130940e457ccd5ed9

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: 55db9bddb0a716d1a24be429bdd4750027740736

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/10399/console
COMMIT: 6b7bb3239a1fa1687c37b5a93587fddb06a009a9

review: Needs Fixing

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: efa4abdd774328b4e09c27e4404f5981eeff08cf

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: bd874202dee2eeed333cc3c647b3b8c4873608c2

review: Approve

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/10417/console
COMMIT: a350ebb73dc98f908746aa767362b4525ad8b712

review: Needs Fixing

[MAAS Lander (maas-lander)]

UNIT TESTS
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: SUCCESS
COMMIT: e4105e0c6bf7c8b11fa71629d67385c20b5a2cad

review: Approve

[Alexsander de Souza (alexsander-souza)]

LGTM

review: Approve

[MAAS Lander (maas-lander)]

LANDING
-b rpc_client_server lp:~cgrabowski/maas/+git/maas into -b rack_region_exploration lp:~maas-committers/maas

STATUS: FAILED BUILD
LOG: http://maas-ci.internal:8080/job/maas/job/branch-tester/10425/consoleText

diff --git a/src/rackd_spike/Makefile b/src/rackd_spike/Makefile
index 81278c8..df50bdd 100644
--- a/src/rackd_spike/Makefile
+++ b/src/rackd_spike/Makefile
@@ -1,3 +1,6 @@
+PWD:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
+ROOT_DIR:=$(shell dirname $(PWD))
+RPC_DIR:=$(PWD)/pkg/rpc
 VERSION:=develop-$(shell git rev-list -1 HEAD)
 
 PATH:=$(shell go env GOPATH)/bin:${PATH}
@@ -5,24 +8,41 @@ export PATH
 
 LDFLAGS="-X main.Version=$(VERSION) -s -w"
 
+.PHONY: all
 all: version test build
 
 version:
 	@go version
 
+.PHONY: build
 build: rackd
 
+.PHONY: build-dir
 build-dir:
 	mkdir -p ./build
 
-rackd: build-dir
+.PHONY: rackd
+rackd: build-dir gen-capnp
 	go build -ldflags $(LDFLAGS) -o ./build/rackd ./cmd/rackd.go
 
+.PHONY: test
 test:
 	go test ./...
 
+.PHONY: lint
 lint:
 	go vet ./...
 
+.PHONY: format
 format:
 	gofmt -s -d ./cmd ./internal ./pkg
+
+.PHONY: capnp-dir
+capnp-dir:
+	mkdir -p ./pkg/rpc
+
+%.capnp: capnp-dir
+	capnp compile -ogo:$(PWD)/pkg/rpc $(ROOT_DIR)/rpc/$@ --src-prefix $(ROOT_DIR)/rpc
+
+.PHONY: gen-capnp
+gen-capnp: handshake.capnp network.capnp
diff --git a/src/rackd_spike/cmd/rackd.go b/src/rackd_spike/cmd/rackd.go
index fd7dac5..8ca5188 100644
--- a/src/rackd_spike/cmd/rackd.go
+++ b/src/rackd_spike/cmd/rackd.go
@@ -14,6 +14,10 @@ import (
 	"rackd/cmd/subcommands"
 	"rackd/internal/config"
 	"rackd/internal/metrics"
+	"rackd/internal/transport"
+	"rackd/pkg/authenticate"
+	"rackd/pkg/region"
+	"rackd/pkg/register"
 )
 
 type opts struct {
@@ -76,6 +80,23 @@ var (
 			}
 			defer metricsSrvr.Close()
 
+			initRegion := os.Getenv("REGION_URL")
+			rpcMgr := transport.NewRPCManager(initRegion, true) // TODO use the register command to provide info to connect instead and make TLS skip verify configurable
+			err = rpcMgr.Init(ctx)
+			if err != nil {
+				return err
+			}
+			rpcMgr.AddClient(ctx, authenticate.NewCapnpAuthenticator())
+			rpcMgr.AddClient(ctx, register.NewCapnpRegisterer())
+			err = rpcMgr.Init(ctx)
+			if err != nil {
+				return err
+			}
+			err = region.Handshake(ctx, initRegion, Version, rpcMgr)
+			if err != nil {
+				return err
+			}
+
 			log.Info().Msgf("rackd %v started successfully", Version)
 
 			sigChan := make(chan os.Signal, 4)
diff --git a/src/rackd_spike/go.mod b/src/rackd_spike/go.mod
index 3339fb7..73edbc6 100644
--- a/src/rackd_spike/go.mod
+++ b/src/rackd_spike/go.mod
@@ -3,11 +3,15 @@ module rackd
 go 1.16
 
 require (
+	capnproto.org/go/capnp/v3 v3.0.0-alpha.1
 	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
 	github.com/coreos/go-systemd/v22 v22.3.2
 	github.com/kolo/xmlrpc v0.0.0-20201022064351-38db28db192b
+	github.com/lxc/lxd v0.0.0-20210705204343-3596a3bcba59
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/prometheus/client_golang v0.9.3
 	github.com/rs/zerolog v1.23.0
 	github.com/spf13/cobra v1.1.3
+	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 )
diff --git a/src/rackd_spike/go.sum b/src/rackd_spike/go.sum
index 4c08b8b..b61ac4f 100644
--- a/src/rackd_spike/go.sum
+++ b/src/rackd_spike/go.sum
@@ -1,3 +1,5 @@
+capnproto.org/go/capnp/v3 v3.0.0-alpha.1 h1:lA/zWC1XgaFez/UdqcWi5Bz1grsqPQDY5Ki4lgYrQ1o=
+capnproto.org/go/capnp/v3 v3.0.0-alpha.1/go.mod h1:izbWjXlvObqHwvhxwDBFLpY9lXSXIxDKRtnuktKHVsU=
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
@@ -110,11 +112,13 @@ github.com/kolo/xmlrpc v0.0.0-20201022064351-38db28db192b h1:iNjcivnc6lhbvJA3LD6
 github.com/kolo/xmlrpc v0.0.0-20201022064351-38db28db192b/go.mod h1:pcaDhQK0/NJZEvtCO0qQPPropqV0sJOJ6YW7X+9kRwM=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/lxc/lxd v0.0.0-20210705204343-3596a3bcba59 h1:FvuAx1MSuzz2gC5fqGG1tL99SNm1JacG3kDWqL3vILo=
+github.com/lxc/lxd v0.0.0-20210705204343-3596a3bcba59/go.mod h1:2BaZflfwsv8a3uy3/Vw+de4Avn4DSrAiqaHJjCIXMV4=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
@@ -132,9 +136,13 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/philhofer/fwd v1.1.1 h1:GdGcTjf5RNAxwS4QLsiMzJYj5KEvPJD3Abr261yRQXQ=
+github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -181,7 +189,10 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
+github.com/tinylib/msgp v1.1.5 h1:2gXmtWueD2HefZHQe1QOy9HVzmFrLOVvsXwXBQ0ayy0=
+github.com/tinylib/msgp v1.1.5/go.mod h1:eQsjooMTnV42mHu917E26IogZ2930nFyBQdofk10Udg=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/ttacon/chalk v0.0.0-20160626202418-22c06c80ed31/go.mod h1:onvgF043R+lC5RZ8IT9rBXDaEDnpnw/Cl+HFiw+v/7Q=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
@@ -280,6 +291,7 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -307,8 +319,9 @@ google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiq
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
diff --git a/src/rackd_spike/internal/machine_helpers/env.go b/src/rackd_spike/internal/machine_helpers/env.go
 new file mode 100644
index 0000000..351d53c
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/env.go
@@ -0,0 +1,67 @@
+package machinehelpers
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+var (
+	maasId string
+)
+
+var (
+	maasIdLock = &sync.RWMutex{}
+)
+
+func GetMAASDataPath(path string) string {
+	basePath, ok := os.LookupEnv(path)
+	if !ok {
+		basePath = "/var/lib/maas"
+	}
+	return filepath.Join(basePath, path)
+}
+
+func GetMAASID() (string, error) {
+	maasIdLock.RLock()
+	defer maasIdLock.RUnlock()
+
+	if len(maasId) == 0 {
+		path := GetMAASDataPath("maas_id")
+		f, err := os.Open(path)
+		if err != nil {
+			if os.IsNotExist(err) {
+				return "", nil
+			}
+			return "", err
+		}
+		contents, err := io.ReadAll(f)
+		if err != nil {
+			return "", err
+		}
+		maasIdLock.Lock()
+		defer maasIdLock.Unlock()
+		maasId = strings.TrimSpace(string(contents))
+	}
+	return maasId, nil
+}
+
+func SetMAASId(id string) error {
+	path := GetMAASDataPath("maas_id")
+	maasIdLock.Lock()
+	defer maasIdLock.Unlock()
+	maasId = id
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	_, err = fmt.Fprint(f, id)
+	if err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/src/rackd_spike/internal/machine_helpers/info.go b/src/rackd_spike/internal/machine_helpers/info.go
 new file mode 100644
index 0000000..1517fc6
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/info.go
@@ -0,0 +1,24 @@
+package machinehelpers
+
+import (
+	lxdresources "github.com/lxc/lxd/shared/api"
+)
+
+type EnvInfo struct {
+	Kernel             string `json:"kernel"`
+	KernelArchitecture string `json:"kernel_architecture"`
+	KernelVersion      string `json:"kernel_version"`
+	OSName             string `json:"os_name"`
+	OSVersion          string `json:"os_version"`
+	Server             string `json:"server"`
+	ServerName         string `json:"server_name"`
+	ServerVersion      string `json:"server_version"`
+}
+
+type MachineInfo struct {
+	APIExtensions []string                             `json:"api_extension"`
+	APIVersion    string                               `json:"api_version"`
+	Environment   EnvInfo                              `json:"environment"`
+	Resources     lxdresources.Resources               `json:"resources"`
+	Networks      map[string]lxdresources.NetworkState `json:"networks"`
+}
diff --git a/src/rackd_spike/internal/machine_helpers/interfaces.go b/src/rackd_spike/internal/machine_helpers/interfaces.go
 new file mode 100644
index 0000000..cbf58e6
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/interfaces.go
@@ -0,0 +1,498 @@
+package machinehelpers
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	lxdresources "github.com/lxc/lxd/shared/api"
+)
+
+var (
+	excludedInterfaceTypes = map[string]struct{}{
+		"loopback": {},
+		"ipip":     {},
+		"tunnel":   {},
+	}
+
+	leaseRx = regexp.MustCompile(`(?m)(^\s*lease\s+{([^}]+)})`)
+)
+
+func isExcludedType(ctx context.Context, t string) (bool, error) {
+	if _, ok := excludedInterfaceTypes[t]; ok {
+		return true, nil
+	}
+	runningContainer, err := RunningInContainer(ctx)
+	if err != nil {
+		return false, err
+	}
+	if runningContainer && t == "ethernet" {
+		return true, nil
+	}
+	if strings.HasPrefix("unknown-", t) {
+		return true, nil
+	}
+	return false, nil
+}
+
+func GetIPAddr(ctx context.Context) (map[string]lxdresources.NetworkState, error) {
+	cmdPath, err := GetResourcesBinPath()
+	if err != nil {
+		return nil, err
+	}
+	var args []string
+	if IsRunningInSnap() {
+		args = append(args, cmdPath)
+		cmdPath = "/usr/bin/sudo"
+	}
+	cmd := exec.CommandContext(ctx, cmdPath, args...)
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+	var info MachineInfo
+	err = json.Unmarshal(out, &info)
+	if err != nil {
+		return nil, err
+	}
+	return info.Networks, nil
+}
+
+func splitDhclientCmdlineFile(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	for i := 0; i < len(data); i++ {
+		if data[i] == '\x00' {
+			return i + 1, data[:i], nil
+		}
+		if !atEOF {
+			return 0, nil, nil
+		}
+	}
+	return 0, data, bufio.ErrFinalToken
+}
+
+func GetLatestFixedAddress(leasePath string) (string, error) {
+	f, err := os.Open(leasePath)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+	return getLatestFixedAddress(f)
+}
+
+func getLatestFixedAddress(leaseFile io.Reader) (string, error) {
+	leaseBytes, err := io.ReadAll(leaseFile)
+	if err != nil {
+		return "", err
+	}
+	submatches := leaseRx.FindAllSubmatch(leaseBytes, -1)
+	if len(submatches) > 0 {
+		matches := submatches[len(submatches)-1]
+		if len(matches) > 0 {
+			lastLease := matches[len(matches)-1]
+			for _, line := range strings.Split(string(lastLease), "\n") {
+				line = strings.TrimSpace(line)
+				if len(line) > 0 {
+					lineList := strings.SplitN(line, " ", 2)
+					if len(lineList) < 2 {
+						continue
+					}
+					statement, value := lineList[0], lineList[1]
+					if statement == "fixed-address" || statement == "fixed-address6" {
+						return strings.TrimSpace(strings.SplitN(value, ";", 2)[0]), nil
+					}
+				}
+			}
+		}
+	}
+	return "", nil
+}
+
+func GetDhclientInfo(ctx context.Context, procPath string) (map[string]string, error) {
+	if len(procPath) == 0 {
+		procPath = "/proc"
+	}
+	pids, err := GetRunningPIDsWithCMD(ctx, "dhclient", "", false)
+	if err != nil {
+		return nil, err
+	}
+	info := make(map[string]string)
+	for _, pid := range pids {
+		cmdlinePath := filepath.Join(procPath, strconv.Itoa(pid), "cmdline")
+		err = func() error {
+			f, err := os.Open(cmdlinePath)
+			if err != nil {
+				return err
+			}
+			defer f.Close()
+			scanner := bufio.NewScanner(f)
+			scanner.Split(splitDhclientCmdlineFile)
+			var (
+				cmd       []string
+				leasePath string
+			)
+			lfIdx := -1
+			for scanner.Scan() {
+				cmd = append(cmd, scanner.Text())
+				if cmd[len(cmd)-1] == "-lf" {
+					lfIdx = len(cmd) - 1
+				}
+				if lfIdx > -1 && len(cmd)-2 == lfIdx {
+					leasePath = cmd[len(cmd)-1]
+				}
+			}
+			ifaceName := cmd[len(cmd)-1]
+			ipAddr, err := GetLatestFixedAddress(leasePath)
+			if err != nil {
+				return err
+			}
+			if len(ipAddr) > 0 && ipAddr != " " {
+				info[ifaceName] = ipAddr
+			}
+			return nil
+		}()
+		if err != nil {
+			return nil, err
+		}
+	}
+	return info, nil
+}
+
+type IPLink struct {
+	Netmask int
+	Mode    string
+	Address string
+	Gateway string
+}
+
+type Vlan struct {
+	LowerDev string
+	Vid      uint64
+}
+
+type Interface struct {
+	Type      string
+	Mac       string
+	Links     []IPLink
+	Enabled   bool
+	Vlan      *Vlan
+	Source    string
+	Parents   []string
+	Monitored bool
+}
+
+type sortableSubnets []*net.IPNet
+
+func (s sortableSubnets) Len() int {
+	return len(s)
+}
+
+func (s sortableSubnets) Less(i, j int) bool {
+	iPrefixlen, _ := s[i].Mask.Size()
+	jPrefixlen, _ := s[j].Mask.Size()
+	return iPrefixlen < jPrefixlen
+}
+
+func (s sortableSubnets) Swap(i, j int) {
+	tmp := s[j]
+	s[j] = s[i]
+	s[i] = tmp
+}
+
+func fixLinkAddresses(links []IPLink) ([]IPLink, error) {
+	var (
+		subnetsV4 []*net.IPNet
+		linksV4   []struct {
+			Link IPLink
+			Idx  int
+		}
+		subnetsV6 []*net.IPNet
+		linksV6   []struct {
+			Link IPLink
+			Idx  int
+		}
+	)
+	for i, link := range links {
+		var (
+			ipAddr net.IP
+			ipNet  *net.IPNet
+			err    error
+		)
+		if link.Netmask != 0 {
+			ipAddr, ipNet, err = net.ParseCIDR(fmt.Sprintf("%s/%d", link.Address, link.Netmask))
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			ipAddr, ipNet, err = net.ParseCIDR(link.Address)
+			if err != nil {
+				return nil, err
+			}
+		}
+		prefixLen, _ := ipNet.Mask.Size()
+		if ipAddr.To4() != nil {
+			if prefixLen == 32 {
+				linksV4 = append(linksV4, struct {
+					Link IPLink
+					Idx  int
+				}{
+					Link: link,
+					Idx:  i,
+				})
+			} else {
+				subnetsV4 = append(subnetsV4, ipNet)
+			}
+		} else {
+			if prefixLen == 128 {
+				linksV6 = append(linksV6, struct {
+					Link IPLink
+					Idx  int
+				}{
+					Link: link,
+					Idx:  i,
+				})
+			} else {
+				subnetsV6 = append(subnetsV6, ipNet)
+			}
+		}
+	}
+	newLinks := [][]struct {
+		Link IPLink
+		Idx  int
+	}{linksV4, linksV6}
+	newSubnets := [][]*net.IPNet{subnetsV4, subnetsV6}
+	for i, currLinks := range newLinks {
+		currSubnets := sortableSubnets(newSubnets[i])
+		var ok bool
+		currSubnets, ok = sort.Reverse(currSubnets).(sortableSubnets)
+		if !ok {
+			return nil, fmt.Errorf("sort.Reverse() returned a type other than sortableSubnets, %T", currSubnets)
+		}
+		for _, link := range currLinks {
+			var (
+				ip  net.IP
+				err error
+			)
+			if link.Link.Netmask != 0 {
+				ip, _, err = net.ParseCIDR(
+					fmt.Sprintf("%s:%d", link.Link.Address, link.Link.Netmask),
+				)
+			} else {
+				ip, _, err = net.ParseCIDR(link.Link.Address)
+			}
+			if err != nil {
+				return nil, err
+			}
+			for _, subnet := range currSubnets {
+				if subnet.Contains(ip) {
+					prefixlen, _ := subnet.Mask.Size()
+					if link.Link.Netmask != 0 {
+						link.Link.Netmask = prefixlen
+					} else {
+						link.Link.Address = fmt.Sprintf("%s/%d", ip, prefixlen)
+					}
+				}
+			}
+			links[link.Idx] = link.Link
+		}
+	}
+	return links, nil
+}
+
+type IPRoute struct {
+	Gateway   string `json:"gateway"`
+	GatewayIP net.IP `json:"-"`
+	Dev       string `json:"dev"`
+	Protocol  string `json:"protocol"`
+	Metric    int    `json:"metric"`
+	Flags     []int  `json:"flags"`
+}
+
+func GetIPRoute(ctx context.Context) (map[string]IPRoute, error) {
+	cmd := exec.CommandContext(ctx, "ip", "-json", "route", "list", "scope", "global")
+	routes := make(map[string]IPRoute)
+	var routeList []struct {
+		Name string `json:"dst"`
+		IPRoute
+	}
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(out, &routeList)
+	if err != nil {
+		return nil, err
+	}
+	for _, route := range routeList {
+		route.IPRoute.GatewayIP = net.ParseIP(route.Gateway)
+		routes[route.Name] = route.IPRoute
+	}
+	return routes, nil
+}
+
+func fixGateways(links []IPLink, ipRouteInfo map[string]IPRoute) ([]IPLink, error) {
+	for i, link := range links {
+		_, subnet, err := net.ParseCIDR(link.Address)
+		if err != nil {
+			return nil, err
+		}
+		if routeInfo, ok := ipRouteInfo[subnet.String()]; ok {
+			link.Gateway = routeInfo.Gateway
+		} else if defaultInfo, ok := ipRouteInfo["default"]; ok && subnet.Contains(defaultInfo.GatewayIP) {
+			link.Gateway = defaultInfo.Gateway
+		}
+		links[i] = link
+	}
+	return links, nil
+}
+
+func GetInterfaceChildren(interfaces map[string]Interface) map[string][]string {
+	children := make(map[string][]string)
+	for name, iface := range interfaces {
+		for _, parent := range iface.Parents {
+			if node, ok := children[parent]; ok {
+				node = append(node, name)
+			} else {
+				children[parent] = []string{name}
+			}
+		}
+	}
+	return children
+}
+
+type InterfaceChild struct {
+	Name  string
+	Iface Interface
+}
+
+func InterfaceChildren(ifname string, interfaces map[string]Interface, children map[string][]string) (res []InterfaceChild) {
+	if node, ok := children[ifname]; ok {
+		for _, child := range node {
+			res = append(res, InterfaceChild{Name: child, Iface: interfaces[child]})
+		}
+	}
+	return res
+}
+
+func GetDefaultMonitoredInterfaces(interfaces map[string]Interface) (res map[string]struct{}) {
+	res = make(map[string]struct{})
+	childrenMap := GetInterfaceChildren(interfaces)
+	for name, iface := range interfaces {
+		if !iface.Enabled {
+			continue
+		}
+		switch iface.Type {
+		case "physical":
+			shouldMonitor := true
+			for _, child := range InterfaceChildren(name, interfaces, childrenMap) {
+				if child.Iface.Type == "bond" {
+					shouldMonitor = false
+					break
+				}
+			}
+			if shouldMonitor {
+				res[name] = struct{}{}
+			}
+		case "bond":
+			res[name] = struct{}{}
+		case "bridge":
+			if len(iface.Parents) == 0 {
+				res[name] = struct{}{}
+			}
+		}
+	}
+	return res
+}
+
+func GetAllInterfacesDefinition(ctx context.Context, annotateWithMonitored bool) (map[string]Interface, error) {
+	dhclientInfo, err := GetDhclientInfo(ctx, "")
+	if err != nil {
+		return nil, err
+	}
+	netIfaces, err := GetIPAddr(ctx)
+	if err != nil {
+		return nil, err
+	}
+	iprouteInfo, err := GetIPRoute(ctx)
+	if err != nil {
+		return nil, err
+	}
+	res := make(map[string]Interface)
+	for name, iface := range netIfaces {
+		excludeType, err := isExcludedType(ctx, iface.Type)
+		if err != nil {
+			return nil, err
+		}
+		if excludeType {
+			continue
+		}
+		i := Interface{
+			Mac:     iface.Hwaddr,
+			Enabled: iface.State == "up",
+		}
+		if !(iface.Type == "vlan" || iface.Type == "bridge" || iface.Type == "bond") {
+			i.Type = "physical"
+		} else {
+			i.Type = iface.Type
+			if iface.Bond != nil && len(iface.Bond.LowerDevices) > 0 {
+				i.Parents = append(i.Parents, iface.Bond.LowerDevices...)
+			}
+			if iface.Bridge != nil && len(iface.Bridge.UpperDevices) > 0 {
+				i.Parents = append(i.Parents, iface.Bridge.UpperDevices...)
+			}
+		}
+		if iface.VLAN != nil {
+			i.Vlan = &Vlan{
+				LowerDev: iface.VLAN.LowerDevice,
+				Vid:      iface.VLAN.VID,
+			}
+			i.Parents = append(i.Parents, iface.VLAN.LowerDevice)
+		}
+		dhcpAddr := dhclientInfo[name]
+		for _, addr := range iface.Addresses {
+			mode := "static"
+			if net.ParseIP(addr.Address).String() == dhcpAddr {
+				mode = "dhcp"
+			}
+
+			link := IPLink{Mode: mode, Address: addr.Address}
+			if len(addr.Netmask) > 0 {
+				link.Netmask, err = strconv.Atoi(addr.Netmask)
+				if err != nil {
+					return nil, err
+				}
+			}
+			i.Links = append(i.Links, link)
+		}
+		i.Links, err = fixLinkAddresses(i.Links)
+		if err != nil {
+			return nil, err
+		}
+		i.Links, err = fixGateways(i.Links, iprouteInfo)
+		if err != nil {
+			return nil, err
+		}
+		res[name] = i
+	}
+	if annotateWithMonitored {
+		monitoredIfaces := GetDefaultMonitoredInterfaces(res)
+		for name, iface := range res {
+			if _, ok := monitoredIfaces[name]; ok {
+				iface.Monitored = true
+			} else {
+				iface.Monitored = false
+			}
+			res[name] = iface
+		}
+	}
+	return res, nil
+}
diff --git a/src/rackd_spike/internal/machine_helpers/interfaces_capnp.go b/src/rackd_spike/internal/machine_helpers/interfaces_capnp.go
 new file mode 100644
index 0000000..777f0b4
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/interfaces_capnp.go
@@ -0,0 +1,65 @@
+package machinehelpers
+
+import (
+	"rackd/pkg/rpc"
+)
+
+type CapnpInterfaces map[string]Interface
+
+func (c CapnpInterfaces) SetProto(ifacePayload rpc.Interfaces) error {
+	ifaces, err := ifacePayload.NewIfaces(int32(len(c)))
+	if err != nil {
+		return err
+	}
+	var idx int
+	for name, iface := range c {
+		protoIface := ifaces.At(idx)
+		err = protoIface.SetName(name)
+		if err != nil {
+			return err
+		}
+		details, err := protoIface.NewIface()
+		if err != nil {
+			return err
+		}
+		details.SetMacAddress(iface.Mac)
+		details.SetType(iface.Type)
+		protoLinks, err := details.NewLinks(int32(len(iface.Links)))
+		if err != nil {
+			return err
+		}
+		for i, link := range iface.Links {
+			protoLink := protoLinks.At(i)
+			err = protoLink.SetMode(link.Mode)
+			if err != nil {
+				return err
+			}
+			err = protoLink.SetAddress(link.Address)
+			if err != nil {
+				return err
+			}
+			err = protoLink.SetGateway(link.Gateway)
+			if err != nil {
+				return err
+			}
+			protoLink.SetNetmask(int32(link.Netmask))
+		}
+		if iface.Vlan != nil {
+			details.SetVid(iface.Vlan.Vid)
+		}
+		if len(iface.Parents) > 0 {
+			protoParents, err := details.NewParents(int32(len(iface.Parents)))
+			if err != nil {
+				return err
+			}
+			for i, parent := range iface.Parents {
+				err = protoParents.Set(i, parent)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		idx++
+	}
+	return nil
+}
diff --git a/src/rackd_spike/internal/machine_helpers/interfaces_test.go b/src/rackd_spike/internal/machine_helpers/interfaces_test.go
 new file mode 100644
index 0000000..a7d2b3c
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/interfaces_test.go
@@ -0,0 +1,81 @@
+package machinehelpers
+
+import (
+	"errors"
+	"io"
+	"testing"
+)
+
+type mockLeaseFile struct {
+	Data []byte
+}
+
+func (m mockLeaseFile) Read(b []byte) (n int, err error) {
+	n = copy(b, m.Data)
+	if n > 0 {
+		m.Data = m.Data[n:]
+	}
+	if len(m.Data) == 0 {
+		return n, io.EOF
+	}
+	return n, nil
+}
+
+func TestGetLatestFixedAddress(t *testing.T) {
+	table := []struct {
+		Name string
+		In   mockLeaseFile
+		Out  string
+		Err  error
+	}{
+		{
+			Name: "basic-v4-lease-file",
+			In: mockLeaseFile{
+				Data: []byte(`
+	lease {
+		fixed-address 10.0.0.2;
+	}
+				`),
+			},
+			Out: "10.0.0.2",
+		}, {
+			Name: "basic-v6-lease-file",
+			In: mockLeaseFile{
+				Data: []byte(`
+	lease {
+		fixed-address6 fe80::ca56:eed8:1344:1aa2;
+	}
+				`),
+			},
+			Out: "fe80::ca56:eed8:1344:1aa2",
+		}, {
+			Name: "no-data-lease-file",
+			In:   mockLeaseFile{},
+		}, {
+			Name: "multi-lease-lease-file",
+			In: mockLeaseFile{
+				Data: []byte(`
+	lease {
+		fixed-address 10.0.0.9;
+	}
+
+	lease {
+		fixed-address 10.0.0.2;
+	}
+				`),
+			},
+			Out: "10.0.0.2",
+		},
+	}
+	for _, tcase := range table {
+		t.Run(tcase.Name, func(tt *testing.T) {
+			out, err := getLatestFixedAddress(tcase.In)
+			if !errors.Is(err, tcase.Err) {
+				tt.Fatalf("expected %v to equal %v", err, tcase.Err)
+			}
+			if out != tcase.Out {
+				tt.Fatalf("expected '%s' to equal '%s'", out, tcase.Out)
+			}
+		})
+	}
+}
diff --git a/src/rackd_spike/internal/machine_helpers/ps.go b/src/rackd_spike/internal/machine_helpers/ps.go
 new file mode 100644
index 0000000..016564b
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/ps.go
@@ -0,0 +1,81 @@
+package machinehelpers
+
+import (
+	"bufio"
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+const (
+	vertCheckExec = "systemd-detect-virt"
+)
+
+var (
+	vertCheckArgs = []string{"-c"}
+)
+
+func RunningInContainer(ctx context.Context) (bool, error) {
+	cmd := exec.CommandContext(ctx, vertCheckExec, vertCheckArgs...)
+	if err := cmd.Run(); err != nil {
+		if cmd.ProcessState.ExitCode() == 1 {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
+func PIDInContainer(pid int, procPath string) (bool, error) {
+	if len(procPath) == 0 {
+		procPath = "/proc"
+	}
+	cgroupPath := filepath.Join(procPath, strconv.Itoa(pid), "cgroup")
+	f, err := os.Open(cgroupPath)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := scanner.Text()
+		cgroup := strings.SplitN(line, ":", 2)
+		// cgroup[2] will be the cgroup heirarchy
+		if strings.HasPrefix(cgroup[2], "/lxc") || strings.Contains(cgroup[2], "docker") {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func GetRunningPIDsWithCMD(ctx context.Context, command, procPath string, excludeContainerProcesses bool) ([]int, error) {
+	if len(procPath) == 0 {
+		procPath = "/proc"
+	}
+	dirs, err := os.ReadDir(procPath)
+	if err != nil {
+		return nil, err
+	}
+	var runningPIDs []int
+	runningInContainer, err := RunningInContainer(ctx)
+	if err != nil {
+		return nil, err
+	}
+	for _, dir := range dirs {
+		pid, parseErr := strconv.Atoi(dir.Name())
+		if parseErr == nil {
+			pidInContainer, err := PIDInContainer(pid, procPath)
+			if err != nil {
+				return nil, err
+			}
+			if excludeContainerProcesses && !runningInContainer && pidInContainer {
+				continue
+			}
+			runningPIDs = append(runningPIDs, pid)
+		}
+	}
+	return runningPIDs, nil
+}
diff --git a/src/rackd_spike/internal/machine_helpers/refresh.go b/src/rackd_spike/internal/machine_helpers/refresh.go
 new file mode 100644
index 0000000..685460b
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/refresh.go
@@ -0,0 +1,29 @@
+package machinehelpers
+
+import (
+	"path/filepath"
+	"runtime"
+)
+
+func isDevEnv() bool {
+	// TODO grab this value from config
+	return true
+}
+
+func GetResourcesBinPath() (string, error) {
+	var path string
+	if isDevEnv() {
+		path = "src/machine-resources/bin"
+	} else {
+		prefix, ok := SnapPaths{}.FromEnv()["snap"]
+		path = "/usr/share/maas/machine-resources"
+		if ok {
+			path = prefix + path
+		}
+	}
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(absPath, runtime.GOARCH), nil
+}
diff --git a/src/rackd_spike/internal/machine_helpers/snap.go b/src/rackd_spike/internal/machine_helpers/snap.go
 new file mode 100644
index 0000000..0956377
--- /dev/null
+++ b/src/rackd_spike/internal/machine_helpers/snap.go
@@ -0,0 +1,30 @@
+package machinehelpers
+
+import (
+	"os"
+)
+
+var (
+	pathVars = map[string]string{
+		"snap":   "SNAP",
+		"common": "SNAP_COMMON",
+		"data":   "SNAP_DATA",
+	}
+)
+
+func IsRunningInSnap() bool {
+	_, ok := os.LookupEnv("SNAP")
+	return ok
+}
+
+type SnapPaths map[string]string
+
+func (s SnapPaths) FromEnv() SnapPaths {
+	for k, v := range pathVars {
+		path, ok := os.LookupEnv(v)
+		if ok {
+			s[k] = path
+		}
+	}
+	return s
+}
diff --git a/src/rackd_spike/internal/transport/rpc.go b/src/rackd_spike/internal/transport/rpc.go
 new file mode 100644
index 0000000..c0764d0
--- /dev/null
+++ b/src/rackd_spike/internal/transport/rpc.go
@@ -0,0 +1,127 @@
+package transport
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"net"
+	"net/url"
+
+	capnprpc "capnproto.org/go/capnp/v3/rpc"
+	"github.com/rs/zerolog"
+
+	"rackd/internal/metrics"
+)
+
+var (
+	ErrRPCClientNotFound = errors.New("error client not found")
+)
+
+type RPCHandler interface {
+	Name() string
+	RegisterMetrics(*metrics.Registry) error
+	SetupServer(context.Context, *ConnWrapper)
+}
+
+type RPCClient interface {
+	Name() string
+	RegisterMetrics(*metrics.Registry) error
+	SetupClient(context.Context, *ConnWrapper)
+}
+
+type CapnpRPCClient interface {
+	RPCClient
+	Release()
+}
+
+type ConnWrapper struct {
+	Conn      net.Conn
+	capnpConn *capnprpc.Conn
+}
+
+func NewConnWrapper(conn net.Conn) *ConnWrapper {
+	return &ConnWrapper{
+		Conn:      conn,
+		capnpConn: capnprpc.NewConn(capnprpc.NewStreamTransport(conn), nil),
+	}
+}
+
+func (c *ConnWrapper) Capnp() *capnprpc.Conn {
+	return c.capnpConn
+}
+
+type RPCManager struct {
+	conns          map[string]*ConnWrapper
+	handlers       map[string]RPCHandler
+	clients        map[string]RPCClient
+	initURL        string
+	skipHostVerify bool
+}
+
+func NewRPCManager(rpcServerURL string, skipHostVerify bool) *RPCManager {
+	return &RPCManager{
+		conns:          make(map[string]*ConnWrapper),
+		handlers:       make(map[string]RPCHandler),
+		clients:        make(map[string]RPCClient),
+		initURL:        rpcServerURL,
+		skipHostVerify: skipHostVerify,
+	}
+}
+
+// Init initiates the initial region connection
+func (r *RPCManager) Init(ctx context.Context) error {
+	parsedURL, err := url.Parse(r.initURL)
+	if err != nil {
+		return err
+	}
+	var conn net.Conn
+	if parsedURL.Scheme == "https" {
+		conn, err = tls.Dial(
+			"tcp",
+			net.JoinHostPort(parsedURL.Hostname(), parsedURL.Port()),
+			&tls.Config{InsecureSkipVerify: r.skipHostVerify},
+		)
+	} else {
+		conn, err = net.Dial("tcp", net.JoinHostPort(parsedURL.Hostname(), parsedURL.Port()))
+	}
+	if err != nil {
+		return err
+	}
+	r.AddConn(ctx, conn)
+	log := zerolog.Ctx(ctx)
+	log.Debug().Msg("connected to region server")
+	return nil
+}
+
+func (r *RPCManager) AddHandler(ctx context.Context, handler RPCHandler) {
+	r.handlers[handler.Name()] = handler
+	for _, conn := range r.conns {
+		handler.SetupServer(ctx, conn)
+	}
+}
+
+func (r *RPCManager) AddClient(ctx context.Context, client RPCClient) {
+	r.clients[client.Name()] = client
+	for _, conn := range r.conns {
+		client.SetupClient(ctx, conn)
+	}
+}
+
+func (r *RPCManager) AddConn(ctx context.Context, conn net.Conn) {
+	newConn := NewConnWrapper(conn)
+	r.conns[conn.RemoteAddr().String()] = newConn
+	for _, handler := range r.handlers {
+		handler.SetupServer(ctx, newConn)
+	}
+	for _, client := range r.clients {
+		client.SetupClient(ctx, newConn)
+	}
+}
+
+func (r *RPCManager) GetClient(clientName string) (RPCClient, error) {
+	c, ok := r.clients[clientName]
+	if !ok {
+		return nil, ErrRPCClientNotFound
+	}
+	return c, nil
+}
diff --git a/src/rackd_spike/pkg/authenticate/authenticator.go b/src/rackd_spike/pkg/authenticate/authenticator.go
 new file mode 100644
index 0000000..6a60a86
--- /dev/null
+++ b/src/rackd_spike/pkg/authenticate/authenticator.go
@@ -0,0 +1,93 @@
+package authenticate
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"rackd/internal/metrics"
+	"rackd/internal/transport"
+	"rackd/pkg/rpc"
+)
+
+type AuthCreds struct {
+	Salt   []byte
+	Digest []byte
+}
+
+func (c *AuthCreds) localDigest(secret, message []byte) []byte {
+	// TODO
+	return nil
+}
+
+func (c *AuthCreds) Verify(secret, message []byte) bool {
+	return bytes.Compare(c.Digest, c.localDigest(secret, message)) == 0
+}
+
+type Authenticator interface {
+	transport.RPCClient
+	Authenticate(context.Context, string, []byte, []byte) (*AuthCreds, error)
+}
+
+type CapnpAuthenticator struct {
+	clients map[string]*rpc.Authenticator
+}
+
+func NewCapnpAuthenticator() Authenticator {
+	// Perhaps we should initialize this with the shared secret already loaded either
+	// from the config manager or load from the FS on instantiation?
+	return &CapnpAuthenticator{
+		clients: make(map[string]*rpc.Authenticator),
+	}
+}
+
+func (c *CapnpAuthenticator) Name() string {
+	return "authenticator"
+}
+
+func (c *CapnpAuthenticator) RegisterMetrics(registry *metrics.Registry) error {
+	// TODO
+	return nil
+}
+
+func (c *CapnpAuthenticator) SetupClient(ctx context.Context, conn *transport.ConnWrapper) {
+	c.clients[conn.Conn.RemoteAddr().String()] = &rpc.Authenticator{Client: conn.Capnp().Bootstrap(ctx)}
+}
+
+func (c *CapnpAuthenticator) Authenticate(ctx context.Context, region string, secret, message []byte) (*AuthCreds, error) {
+	regionClient, ok := c.clients[region]
+	if !ok {
+		return nil, fmt.Errorf("%w: %s", transport.ErrRPCClientNotFound, region)
+	}
+	result, release := regionClient.Authenticate(ctx, func(params rpc.Authenticator_authenticate_Params) error {
+		return params.SetMsg(message)
+	})
+	defer release()
+	resp, err := result.Struct()
+	if err != nil {
+		return nil, err
+	}
+	creds, err := resp.Resp()
+	if err != nil {
+		return nil, err
+	}
+	salt, err := creds.Salt()
+	if err != nil {
+		return nil, err
+	}
+	digest, err := creds.Digest()
+	if err != nil {
+		return nil, err
+	}
+	return &AuthCreds{
+		Salt:   salt,
+		Digest: digest,
+	}, nil
+}
+
+func (c *CapnpAuthenticator) Release() {
+	for k, client := range c.clients {
+		client.Release()
+		delete(c.clients, k)
+	}
+}
diff --git a/src/rackd_spike/pkg/region/handshake.go b/src/rackd_spike/pkg/region/handshake.go
 new file mode 100644
index 0000000..4d1a090
--- /dev/null
+++ b/src/rackd_spike/pkg/region/handshake.go
@@ -0,0 +1,91 @@
+package region
+
+import (
+	"context"
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"os"
+
+	machinehelpers "rackd/internal/machine_helpers"
+	"rackd/internal/transport"
+	auth "rackd/pkg/authenticate"
+	reg "rackd/pkg/register"
+)
+
+var (
+	ErrNoAuthenticatorProvided = errors.New("error no authenticator was provided")
+	ErrNoRegistererProvided    = errors.New("error no registerer was provided")
+	ErrRegionNotAuthed         = errors.New("error unable to authenticate with region")
+)
+
+func authenticate(ctx context.Context, region string, rpcMgr *transport.RPCManager) error {
+	authenticatorIface, err := rpcMgr.GetClient("authenticator")
+	if err != nil {
+		return err
+	}
+	authenticator, ok := authenticatorIface.(auth.Authenticator)
+	if !ok {
+		return ErrNoAuthenticatorProvided
+	}
+	secret := []byte{} // TODO get this from filesystem
+	message := make([]byte, 16)
+	_, err = rand.Read(message)
+	if err != nil {
+		return err
+	}
+	creds, err := authenticator.Authenticate(ctx, region, secret, message)
+	if err != nil {
+		return err
+	}
+	if !creds.Verify(secret, message) {
+		return fmt.Errorf("%w: credential verification failed", ErrRegionNotAuthed)
+	}
+	return nil
+}
+
+func register(ctx context.Context, region, localVersion string, rpcMgr *transport.RPCManager) error {
+	registererIface, err := rpcMgr.GetClient("registerer")
+	if err != nil {
+		return err
+	}
+	registerer, ok := registererIface.(reg.Registerer)
+	if !ok {
+		return ErrNoRegistererProvided
+	}
+	// TODO get cluster UUID from config
+	clusterUUID := "123456"
+	systemId, err := machinehelpers.GetMAASID()
+	if err != nil {
+		return err
+	}
+	interfaces, err := machinehelpers.GetAllInterfacesDefinition(ctx, false)
+	if err != nil {
+		return err
+	}
+	hostname, err := os.Hostname()
+	if err != nil {
+		return err
+	}
+	err = registerer.Register(
+		ctx,
+		region,
+		clusterUUID,
+		systemId,
+		hostname,
+		localVersion,
+		interfaces,
+	)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func Handshake(ctx context.Context, region, localVersion string, rpcMgr *transport.RPCManager) error {
+	err := authenticate(ctx, region, rpcMgr)
+	if err != nil {
+		return err
+	}
+	return register(ctx, region, localVersion, rpcMgr)
+}
diff --git a/src/rackd_spike/pkg/register/registerer.go b/src/rackd_spike/pkg/register/registerer.go
 new file mode 100644
index 0000000..b6562e7
--- /dev/null
+++ b/src/rackd_spike/pkg/register/registerer.go
@@ -0,0 +1,125 @@
+package register
+
+import (
+	"context"
+
+	"github.com/rs/zerolog"
+
+	machinehelpers "rackd/internal/machine_helpers"
+	"rackd/internal/metrics"
+	"rackd/internal/transport"
+	"rackd/pkg/rpc"
+)
+
+type Registerer interface {
+	transport.RPCClient
+	Register(
+		ctx context.Context,
+		region, clusterUUID, systemId, hostname, version string,
+		interfaces map[string]machinehelpers.Interface,
+	) error
+}
+
+type CapnpRegisterer struct {
+	clients map[string]*rpc.Registerer
+}
+
+func NewCapnpRegisterer() Registerer {
+	return &CapnpRegisterer{}
+}
+
+func (c *CapnpRegisterer) Name() string {
+	return "Registerer"
+}
+
+func (c *CapnpRegisterer) RegisterMetrics(registry *metrics.Registry) error {
+	// TODO
+	return nil
+}
+
+func (c *CapnpRegisterer) SetupClient(ctx context.Context, client *transport.ConnWrapper) {
+	c.clients[client.Conn.RemoteAddr().String()] = &rpc.Registerer{Client: client.Capnp().Bootstrap(ctx)}
+}
+
+func (c *CapnpRegisterer) Register(
+	ctx context.Context,
+	region, clusterUUID, systemId, hostname, version string,
+	interfaces map[string]machinehelpers.Interface,
+) error {
+	client, ok := c.clients[region]
+	if !ok {
+		return transport.ErrRPCClientNotFound
+	}
+	result, release := client.Register(ctx, func(params rpc.Registerer_register_Params) error {
+		req, err := params.NewReq()
+		if err != nil {
+			return err
+		}
+		err = req.SetSystemId(systemId)
+		if err != nil {
+			return err
+		}
+		err = req.SetHostname(hostname)
+		if err != nil {
+			return err
+		}
+		ifaces, err := req.NewInterfaces()
+		if err != nil {
+			return err
+		}
+		capnpIfaces := machinehelpers.CapnpInterfaces(interfaces)
+		err = capnpIfaces.SetProto(ifaces)
+		if err != nil {
+			return err
+		}
+		err = req.SetUrl(region)
+		if err != nil {
+			return err
+		}
+		err = req.SetNodegroup(clusterUUID)
+		if err != nil {
+			return err
+		}
+		req.SetBeaconSupport(true)
+		err = req.SetVersion(version)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+	defer release()
+	resp, err := result.Struct()
+	if err != nil {
+		return err
+	}
+	res, err := resp.Resp()
+	if err != nil {
+		return err
+	}
+	localId, err := res.SystemId()
+	if err != nil {
+		return err
+	}
+	// TODO set global metrics labels
+	err = machinehelpers.SetMAASId(localId)
+	if err != nil {
+		return err
+	}
+	respVersion, err := res.Version()
+	if err != nil {
+		return err
+	}
+	if len(respVersion) == 0 {
+		respVersion = "unknown MAAS version"
+	}
+	log := zerolog.Ctx(ctx)
+	log.Log().Msgf("Rack controller '%s' registered (via %s) with %s.", localId, region, respVersion)
+	return nil
+}
+
+func (c *CapnpRegisterer) Release() {
+	for k, client := range c.clients {
+		client.Release()
+		delete(c.clients, k)
+	}
+}
diff --git a/src/rackd_spike/pkg/rpc/handshake.capnp.go b/src/rackd_spike/pkg/rpc/handshake.capnp.go
 new file mode 100644
index 0000000..94955c9
--- /dev/null
+++ b/src/rackd_spike/pkg/rpc/handshake.capnp.go
@@ -0,0 +1,933 @@
+// Code generated by capnpc-go. DO NOT EDIT.
+
+package rpc
+
+import (
+	capnp "capnproto.org/go/capnp/v3"
+	text "capnproto.org/go/capnp/v3/encoding/text"
+	schemas "capnproto.org/go/capnp/v3/schemas"
+	server "capnproto.org/go/capnp/v3/server"
+	context "context"
+)
+
+type AuthResponse struct{ capnp.Struct }
+
+// AuthResponse_TypeID is the unique identifier for the type AuthResponse.
+const AuthResponse_TypeID = 0x98b03f82d720e4e1
+
+func NewAuthResponse(s *capnp.Segment) (AuthResponse, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
+	return AuthResponse{st}, err
+}
+
+func NewRootAuthResponse(s *capnp.Segment) (AuthResponse, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
+	return AuthResponse{st}, err
+}
+
+func ReadRootAuthResponse(msg *capnp.Message) (AuthResponse, error) {
+	root, err := msg.Root()
+	return AuthResponse{root.Struct()}, err
+}
+
+func (s AuthResponse) String() string {
+	str, _ := text.Marshal(0x98b03f82d720e4e1, s.Struct)
+	return str
+}
+
+func (s AuthResponse) Salt() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return []byte(p.Data()), err
+}
+
+func (s AuthResponse) HasSalt() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s AuthResponse) SetSalt(v []byte) error {
+	return s.Struct.SetData(0, v)
+}
+
+func (s AuthResponse) Digest() ([]byte, error) {
+	p, err := s.Struct.Ptr(1)
+	return []byte(p.Data()), err
+}
+
+func (s AuthResponse) HasDigest() bool {
+	return s.Struct.HasPtr(1)
+}
+
+func (s AuthResponse) SetDigest(v []byte) error {
+	return s.Struct.SetData(1, v)
+}
+
+// AuthResponse_List is a list of AuthResponse.
+type AuthResponse_List struct{ capnp.List }
+
+// NewAuthResponse creates a new list of AuthResponse.
+func NewAuthResponse_List(s *capnp.Segment, sz int32) (AuthResponse_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
+	return AuthResponse_List{l}, err
+}
+
+func (s AuthResponse_List) At(i int) AuthResponse { return AuthResponse{s.List.Struct(i)} }
+
+func (s AuthResponse_List) Set(i int, v AuthResponse) error { return s.List.SetStruct(i, v.Struct) }
+
+func (s AuthResponse_List) String() string {
+	str, _ := text.MarshalList(0x98b03f82d720e4e1, s.List)
+	return str
+}
+
+// AuthResponse_Future is a wrapper for a AuthResponse promised by a client call.
+type AuthResponse_Future struct{ *capnp.Future }
+
+func (p AuthResponse_Future) Struct() (AuthResponse, error) {
+	s, err := p.Future.Struct()
+	return AuthResponse{s}, err
+}
+
+type Authenticator struct{ Client *capnp.Client }
+
+// Authenticator_TypeID is the unique identifier for the type Authenticator.
+const Authenticator_TypeID = 0x800ae3a77a7bc18e
+
+func (c Authenticator) Authenticate(ctx context.Context, params func(Authenticator_authenticate_Params) error) (Authenticator_authenticate_Results_Future, capnp.ReleaseFunc) {
+	s := capnp.Send{
+		Method: capnp.Method{
+			InterfaceID:   0x800ae3a77a7bc18e,
+			MethodID:      0,
+			InterfaceName: "handshake.capnp:Authenticator",
+			MethodName:    "authenticate",
+		},
+	}
+	if params != nil {
+		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
+		s.PlaceArgs = func(s capnp.Struct) error { return params(Authenticator_authenticate_Params{Struct: s}) }
+	}
+	ans, release := c.Client.SendCall(ctx, s)
+	return Authenticator_authenticate_Results_Future{Future: ans.Future()}, release
+}
+
+func (c Authenticator) AddRef() Authenticator {
+	return Authenticator{
+		Client: c.Client.AddRef(),
+	}
+}
+
+func (c Authenticator) Release() {
+	c.Client.Release()
+}
+
+// A Authenticator_Server is a Authenticator with a local implementation.
+type Authenticator_Server interface {
+	Authenticate(context.Context, Authenticator_authenticate) error
+}
+
+// Authenticator_NewServer creates a new Server from an implementation of Authenticator_Server.
+func Authenticator_NewServer(s Authenticator_Server, policy *server.Policy) *server.Server {
+	c, _ := s.(server.Shutdowner)
+	return server.New(Authenticator_Methods(nil, s), s, c, policy)
+}
+
+// Authenticator_ServerToClient creates a new Client from an implementation of Authenticator_Server.
+// The caller is responsible for calling Release on the returned Client.
+func Authenticator_ServerToClient(s Authenticator_Server, policy *server.Policy) Authenticator {
+	return Authenticator{Client: capnp.NewClient(Authenticator_NewServer(s, policy))}
+}
+
+// Authenticator_Methods appends Methods to a slice that invoke the methods on s.
+// This can be used to create a more complicated Server.
+func Authenticator_Methods(methods []server.Method, s Authenticator_Server) []server.Method {
+	if cap(methods) == 0 {
+		methods = make([]server.Method, 0, 1)
+	}
+
+	methods = append(methods, server.Method{
+		Method: capnp.Method{
+			InterfaceID:   0x800ae3a77a7bc18e,
+			MethodID:      0,
+			InterfaceName: "handshake.capnp:Authenticator",
+			MethodName:    "authenticate",
+		},
+		Impl: func(ctx context.Context, call *server.Call) error {
+			return s.Authenticate(ctx, Authenticator_authenticate{call})
+		},
+	})
+
+	return methods
+}
+
+// Authenticator_authenticate holds the state for a server call to Authenticator.authenticate.
+// See server.Call for documentation.
+type Authenticator_authenticate struct {
+	*server.Call
+}
+
+// Args returns the call's arguments.
+func (c Authenticator_authenticate) Args() Authenticator_authenticate_Params {
+	return Authenticator_authenticate_Params{Struct: c.Call.Args()}
+}
+
+// AllocResults allocates the results struct.
+func (c Authenticator_authenticate) AllocResults() (Authenticator_authenticate_Results, error) {
+	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Authenticator_authenticate_Results{Struct: r}, err
+}
+
+type Authenticator_authenticate_Params struct{ capnp.Struct }
+
+// Authenticator_authenticate_Params_TypeID is the unique identifier for the type Authenticator_authenticate_Params.
+const Authenticator_authenticate_Params_TypeID = 0xdbaca3bedaffa653
+
+func NewAuthenticator_authenticate_Params(s *capnp.Segment) (Authenticator_authenticate_Params, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Authenticator_authenticate_Params{st}, err
+}
+
+func NewRootAuthenticator_authenticate_Params(s *capnp.Segment) (Authenticator_authenticate_Params, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Authenticator_authenticate_Params{st}, err
+}
+
+func ReadRootAuthenticator_authenticate_Params(msg *capnp.Message) (Authenticator_authenticate_Params, error) {
+	root, err := msg.Root()
+	return Authenticator_authenticate_Params{root.Struct()}, err
+}
+
+func (s Authenticator_authenticate_Params) String() string {
+	str, _ := text.Marshal(0xdbaca3bedaffa653, s.Struct)
+	return str
+}
+
+func (s Authenticator_authenticate_Params) Msg() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return []byte(p.Data()), err
+}
+
+func (s Authenticator_authenticate_Params) HasMsg() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Authenticator_authenticate_Params) SetMsg(v []byte) error {
+	return s.Struct.SetData(0, v)
+}
+
+// Authenticator_authenticate_Params_List is a list of Authenticator_authenticate_Params.
+type Authenticator_authenticate_Params_List struct{ capnp.List }
+
+// NewAuthenticator_authenticate_Params creates a new list of Authenticator_authenticate_Params.
+func NewAuthenticator_authenticate_Params_List(s *capnp.Segment, sz int32) (Authenticator_authenticate_Params_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Authenticator_authenticate_Params_List{l}, err
+}
+
+func (s Authenticator_authenticate_Params_List) At(i int) Authenticator_authenticate_Params {
+	return Authenticator_authenticate_Params{s.List.Struct(i)}
+}
+
+func (s Authenticator_authenticate_Params_List) Set(i int, v Authenticator_authenticate_Params) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Authenticator_authenticate_Params_List) String() string {
+	str, _ := text.MarshalList(0xdbaca3bedaffa653, s.List)
+	return str
+}
+
+// Authenticator_authenticate_Params_Future is a wrapper for a Authenticator_authenticate_Params promised by a client call.
+type Authenticator_authenticate_Params_Future struct{ *capnp.Future }
+
+func (p Authenticator_authenticate_Params_Future) Struct() (Authenticator_authenticate_Params, error) {
+	s, err := p.Future.Struct()
+	return Authenticator_authenticate_Params{s}, err
+}
+
+type Authenticator_authenticate_Results struct{ capnp.Struct }
+
+// Authenticator_authenticate_Results_TypeID is the unique identifier for the type Authenticator_authenticate_Results.
+const Authenticator_authenticate_Results_TypeID = 0x96c07ce683897942
+
+func NewAuthenticator_authenticate_Results(s *capnp.Segment) (Authenticator_authenticate_Results, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Authenticator_authenticate_Results{st}, err
+}
+
+func NewRootAuthenticator_authenticate_Results(s *capnp.Segment) (Authenticator_authenticate_Results, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Authenticator_authenticate_Results{st}, err
+}
+
+func ReadRootAuthenticator_authenticate_Results(msg *capnp.Message) (Authenticator_authenticate_Results, error) {
+	root, err := msg.Root()
+	return Authenticator_authenticate_Results{root.Struct()}, err
+}
+
+func (s Authenticator_authenticate_Results) String() string {
+	str, _ := text.Marshal(0x96c07ce683897942, s.Struct)
+	return str
+}
+
+func (s Authenticator_authenticate_Results) Resp() (AuthResponse, error) {
+	p, err := s.Struct.Ptr(0)
+	return AuthResponse{Struct: p.Struct()}, err
+}
+
+func (s Authenticator_authenticate_Results) HasResp() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Authenticator_authenticate_Results) SetResp(v AuthResponse) error {
+	return s.Struct.SetPtr(0, v.Struct.ToPtr())
+}
+
+// NewResp sets the resp field to a newly
+// allocated AuthResponse struct, preferring placement in s's segment.
+func (s Authenticator_authenticate_Results) NewResp() (AuthResponse, error) {
+	ss, err := NewAuthResponse(s.Struct.Segment())
+	if err != nil {
+		return AuthResponse{}, err
+	}
+	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
+	return ss, err
+}
+
+// Authenticator_authenticate_Results_List is a list of Authenticator_authenticate_Results.
+type Authenticator_authenticate_Results_List struct{ capnp.List }
+
+// NewAuthenticator_authenticate_Results creates a new list of Authenticator_authenticate_Results.
+func NewAuthenticator_authenticate_Results_List(s *capnp.Segment, sz int32) (Authenticator_authenticate_Results_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Authenticator_authenticate_Results_List{l}, err
+}
+
+func (s Authenticator_authenticate_Results_List) At(i int) Authenticator_authenticate_Results {
+	return Authenticator_authenticate_Results{s.List.Struct(i)}
+}
+
+func (s Authenticator_authenticate_Results_List) Set(i int, v Authenticator_authenticate_Results) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Authenticator_authenticate_Results_List) String() string {
+	str, _ := text.MarshalList(0x96c07ce683897942, s.List)
+	return str
+}
+
+// Authenticator_authenticate_Results_Future is a wrapper for a Authenticator_authenticate_Results promised by a client call.
+type Authenticator_authenticate_Results_Future struct{ *capnp.Future }
+
+func (p Authenticator_authenticate_Results_Future) Struct() (Authenticator_authenticate_Results, error) {
+	s, err := p.Future.Struct()
+	return Authenticator_authenticate_Results{s}, err
+}
+
+func (p Authenticator_authenticate_Results_Future) Resp() AuthResponse_Future {
+	return AuthResponse_Future{Future: p.Future.Field(0, nil)}
+}
+
+type RegisterRequest struct{ capnp.Struct }
+
+// RegisterRequest_TypeID is the unique identifier for the type RegisterRequest.
+const RegisterRequest_TypeID = 0x8a21a43d866e69f4
+
+func NewRegisterRequest(s *capnp.Segment) (RegisterRequest, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6})
+	return RegisterRequest{st}, err
+}
+
+func NewRootRegisterRequest(s *capnp.Segment) (RegisterRequest, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6})
+	return RegisterRequest{st}, err
+}
+
+func ReadRootRegisterRequest(msg *capnp.Message) (RegisterRequest, error) {
+	root, err := msg.Root()
+	return RegisterRequest{root.Struct()}, err
+}
+
+func (s RegisterRequest) String() string {
+	str, _ := text.Marshal(0x8a21a43d866e69f4, s.Struct)
+	return str
+}
+
+func (s RegisterRequest) SystemId() (string, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.Text(), err
+}
+
+func (s RegisterRequest) HasSystemId() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s RegisterRequest) SystemIdBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.TextBytes(), err
+}
+
+func (s RegisterRequest) SetSystemId(v string) error {
+	return s.Struct.SetText(0, v)
+}
+
+func (s RegisterRequest) Hostname() (string, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.Text(), err
+}
+
+func (s RegisterRequest) HasHostname() bool {
+	return s.Struct.HasPtr(1)
+}
+
+func (s RegisterRequest) HostnameBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.TextBytes(), err
+}
+
+func (s RegisterRequest) SetHostname(v string) error {
+	return s.Struct.SetText(1, v)
+}
+
+func (s RegisterRequest) Interfaces() (Interfaces, error) {
+	p, err := s.Struct.Ptr(2)
+	return Interfaces{Struct: p.Struct()}, err
+}
+
+func (s RegisterRequest) HasInterfaces() bool {
+	return s.Struct.HasPtr(2)
+}
+
+func (s RegisterRequest) SetInterfaces(v Interfaces) error {
+	return s.Struct.SetPtr(2, v.Struct.ToPtr())
+}
+
+// NewInterfaces sets the interfaces field to a newly
+// allocated Interfaces struct, preferring placement in s's segment.
+func (s RegisterRequest) NewInterfaces() (Interfaces, error) {
+	ss, err := NewInterfaces(s.Struct.Segment())
+	if err != nil {
+		return Interfaces{}, err
+	}
+	err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
+	return ss, err
+}
+
+func (s RegisterRequest) Url() (string, error) {
+	p, err := s.Struct.Ptr(3)
+	return p.Text(), err
+}
+
+func (s RegisterRequest) HasUrl() bool {
+	return s.Struct.HasPtr(3)
+}
+
+func (s RegisterRequest) UrlBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(3)
+	return p.TextBytes(), err
+}
+
+func (s RegisterRequest) SetUrl(v string) error {
+	return s.Struct.SetText(3, v)
+}
+
+func (s RegisterRequest) Nodegroup() (string, error) {
+	p, err := s.Struct.Ptr(4)
+	return p.Text(), err
+}
+
+func (s RegisterRequest) HasNodegroup() bool {
+	return s.Struct.HasPtr(4)
+}
+
+func (s RegisterRequest) NodegroupBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(4)
+	return p.TextBytes(), err
+}
+
+func (s RegisterRequest) SetNodegroup(v string) error {
+	return s.Struct.SetText(4, v)
+}
+
+func (s RegisterRequest) BeaconSupport() bool {
+	return s.Struct.Bit(0)
+}
+
+func (s RegisterRequest) SetBeaconSupport(v bool) {
+	s.Struct.SetBit(0, v)
+}
+
+func (s RegisterRequest) Version() (string, error) {
+	p, err := s.Struct.Ptr(5)
+	return p.Text(), err
+}
+
+func (s RegisterRequest) HasVersion() bool {
+	return s.Struct.HasPtr(5)
+}
+
+func (s RegisterRequest) VersionBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(5)
+	return p.TextBytes(), err
+}
+
+func (s RegisterRequest) SetVersion(v string) error {
+	return s.Struct.SetText(5, v)
+}
+
+// RegisterRequest_List is a list of RegisterRequest.
+type RegisterRequest_List struct{ capnp.List }
+
+// NewRegisterRequest creates a new list of RegisterRequest.
+func NewRegisterRequest_List(s *capnp.Segment, sz int32) (RegisterRequest_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6}, sz)
+	return RegisterRequest_List{l}, err
+}
+
+func (s RegisterRequest_List) At(i int) RegisterRequest { return RegisterRequest{s.List.Struct(i)} }
+
+func (s RegisterRequest_List) Set(i int, v RegisterRequest) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s RegisterRequest_List) String() string {
+	str, _ := text.MarshalList(0x8a21a43d866e69f4, s.List)
+	return str
+}
+
+// RegisterRequest_Future is a wrapper for a RegisterRequest promised by a client call.
+type RegisterRequest_Future struct{ *capnp.Future }
+
+func (p RegisterRequest_Future) Struct() (RegisterRequest, error) {
+	s, err := p.Future.Struct()
+	return RegisterRequest{s}, err
+}
+
+func (p RegisterRequest_Future) Interfaces() Interfaces_Future {
+	return Interfaces_Future{Future: p.Future.Field(2, nil)}
+}
+
+type RegisterResponse struct{ capnp.Struct }
+
+// RegisterResponse_TypeID is the unique identifier for the type RegisterResponse.
+const RegisterResponse_TypeID = 0x971fe28893233a11
+
+func NewRegisterResponse(s *capnp.Segment) (RegisterResponse, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
+	return RegisterResponse{st}, err
+}
+
+func NewRootRegisterResponse(s *capnp.Segment) (RegisterResponse, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
+	return RegisterResponse{st}, err
+}
+
+func ReadRootRegisterResponse(msg *capnp.Message) (RegisterResponse, error) {
+	root, err := msg.Root()
+	return RegisterResponse{root.Struct()}, err
+}
+
+func (s RegisterResponse) String() string {
+	str, _ := text.Marshal(0x971fe28893233a11, s.Struct)
+	return str
+}
+
+func (s RegisterResponse) SystemId() (string, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.Text(), err
+}
+
+func (s RegisterResponse) HasSystemId() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s RegisterResponse) SystemIdBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.TextBytes(), err
+}
+
+func (s RegisterResponse) SetSystemId(v string) error {
+	return s.Struct.SetText(0, v)
+}
+
+func (s RegisterResponse) Uuid() (string, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.Text(), err
+}
+
+func (s RegisterResponse) HasUuid() bool {
+	return s.Struct.HasPtr(1)
+}
+
+func (s RegisterResponse) UuidBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.TextBytes(), err
+}
+
+func (s RegisterResponse) SetUuid(v string) error {
+	return s.Struct.SetText(1, v)
+}
+
+func (s RegisterResponse) Version() (string, error) {
+	p, err := s.Struct.Ptr(2)
+	return p.Text(), err
+}
+
+func (s RegisterResponse) HasVersion() bool {
+	return s.Struct.HasPtr(2)
+}
+
+func (s RegisterResponse) VersionBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(2)
+	return p.TextBytes(), err
+}
+
+func (s RegisterResponse) SetVersion(v string) error {
+	return s.Struct.SetText(2, v)
+}
+
+// RegisterResponse_List is a list of RegisterResponse.
+type RegisterResponse_List struct{ capnp.List }
+
+// NewRegisterResponse creates a new list of RegisterResponse.
+func NewRegisterResponse_List(s *capnp.Segment, sz int32) (RegisterResponse_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
+	return RegisterResponse_List{l}, err
+}
+
+func (s RegisterResponse_List) At(i int) RegisterResponse { return RegisterResponse{s.List.Struct(i)} }
+
+func (s RegisterResponse_List) Set(i int, v RegisterResponse) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s RegisterResponse_List) String() string {
+	str, _ := text.MarshalList(0x971fe28893233a11, s.List)
+	return str
+}
+
+// RegisterResponse_Future is a wrapper for a RegisterResponse promised by a client call.
+type RegisterResponse_Future struct{ *capnp.Future }
+
+func (p RegisterResponse_Future) Struct() (RegisterResponse, error) {
+	s, err := p.Future.Struct()
+	return RegisterResponse{s}, err
+}
+
+type Registerer struct{ Client *capnp.Client }
+
+// Registerer_TypeID is the unique identifier for the type Registerer.
+const Registerer_TypeID = 0xe75723043cae2d20
+
+func (c Registerer) Register(ctx context.Context, params func(Registerer_register_Params) error) (Registerer_register_Results_Future, capnp.ReleaseFunc) {
+	s := capnp.Send{
+		Method: capnp.Method{
+			InterfaceID:   0xe75723043cae2d20,
+			MethodID:      0,
+			InterfaceName: "handshake.capnp:Registerer",
+			MethodName:    "register",
+		},
+	}
+	if params != nil {
+		s.ArgsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 1}
+		s.PlaceArgs = func(s capnp.Struct) error { return params(Registerer_register_Params{Struct: s}) }
+	}
+	ans, release := c.Client.SendCall(ctx, s)
+	return Registerer_register_Results_Future{Future: ans.Future()}, release
+}
+
+func (c Registerer) AddRef() Registerer {
+	return Registerer{
+		Client: c.Client.AddRef(),
+	}
+}
+
+func (c Registerer) Release() {
+	c.Client.Release()
+}
+
+// A Registerer_Server is a Registerer with a local implementation.
+type Registerer_Server interface {
+	Register(context.Context, Registerer_register) error
+}
+
+// Registerer_NewServer creates a new Server from an implementation of Registerer_Server.
+func Registerer_NewServer(s Registerer_Server, policy *server.Policy) *server.Server {
+	c, _ := s.(server.Shutdowner)
+	return server.New(Registerer_Methods(nil, s), s, c, policy)
+}
+
+// Registerer_ServerToClient creates a new Client from an implementation of Registerer_Server.
+// The caller is responsible for calling Release on the returned Client.
+func Registerer_ServerToClient(s Registerer_Server, policy *server.Policy) Registerer {
+	return Registerer{Client: capnp.NewClient(Registerer_NewServer(s, policy))}
+}
+
+// Registerer_Methods appends Methods to a slice that invoke the methods on s.
+// This can be used to create a more complicated Server.
+func Registerer_Methods(methods []server.Method, s Registerer_Server) []server.Method {
+	if cap(methods) == 0 {
+		methods = make([]server.Method, 0, 1)
+	}
+
+	methods = append(methods, server.Method{
+		Method: capnp.Method{
+			InterfaceID:   0xe75723043cae2d20,
+			MethodID:      0,
+			InterfaceName: "handshake.capnp:Registerer",
+			MethodName:    "register",
+		},
+		Impl: func(ctx context.Context, call *server.Call) error {
+			return s.Register(ctx, Registerer_register{call})
+		},
+	})
+
+	return methods
+}
+
+// Registerer_register holds the state for a server call to Registerer.register.
+// See server.Call for documentation.
+type Registerer_register struct {
+	*server.Call
+}
+
+// Args returns the call's arguments.
+func (c Registerer_register) Args() Registerer_register_Params {
+	return Registerer_register_Params{Struct: c.Call.Args()}
+}
+
+// AllocResults allocates the results struct.
+func (c Registerer_register) AllocResults() (Registerer_register_Results, error) {
+	r, err := c.Call.AllocResults(capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Registerer_register_Results{Struct: r}, err
+}
+
+type Registerer_register_Params struct{ capnp.Struct }
+
+// Registerer_register_Params_TypeID is the unique identifier for the type Registerer_register_Params.
+const Registerer_register_Params_TypeID = 0x80a0e6cbaa396ef4
+
+func NewRegisterer_register_Params(s *capnp.Segment) (Registerer_register_Params, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Registerer_register_Params{st}, err
+}
+
+func NewRootRegisterer_register_Params(s *capnp.Segment) (Registerer_register_Params, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Registerer_register_Params{st}, err
+}
+
+func ReadRootRegisterer_register_Params(msg *capnp.Message) (Registerer_register_Params, error) {
+	root, err := msg.Root()
+	return Registerer_register_Params{root.Struct()}, err
+}
+
+func (s Registerer_register_Params) String() string {
+	str, _ := text.Marshal(0x80a0e6cbaa396ef4, s.Struct)
+	return str
+}
+
+func (s Registerer_register_Params) Req() (RegisterRequest, error) {
+	p, err := s.Struct.Ptr(0)
+	return RegisterRequest{Struct: p.Struct()}, err
+}
+
+func (s Registerer_register_Params) HasReq() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Registerer_register_Params) SetReq(v RegisterRequest) error {
+	return s.Struct.SetPtr(0, v.Struct.ToPtr())
+}
+
+// NewReq sets the req field to a newly
+// allocated RegisterRequest struct, preferring placement in s's segment.
+func (s Registerer_register_Params) NewReq() (RegisterRequest, error) {
+	ss, err := NewRegisterRequest(s.Struct.Segment())
+	if err != nil {
+		return RegisterRequest{}, err
+	}
+	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
+	return ss, err
+}
+
+// Registerer_register_Params_List is a list of Registerer_register_Params.
+type Registerer_register_Params_List struct{ capnp.List }
+
+// NewRegisterer_register_Params creates a new list of Registerer_register_Params.
+func NewRegisterer_register_Params_List(s *capnp.Segment, sz int32) (Registerer_register_Params_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Registerer_register_Params_List{l}, err
+}
+
+func (s Registerer_register_Params_List) At(i int) Registerer_register_Params {
+	return Registerer_register_Params{s.List.Struct(i)}
+}
+
+func (s Registerer_register_Params_List) Set(i int, v Registerer_register_Params) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Registerer_register_Params_List) String() string {
+	str, _ := text.MarshalList(0x80a0e6cbaa396ef4, s.List)
+	return str
+}
+
+// Registerer_register_Params_Future is a wrapper for a Registerer_register_Params promised by a client call.
+type Registerer_register_Params_Future struct{ *capnp.Future }
+
+func (p Registerer_register_Params_Future) Struct() (Registerer_register_Params, error) {
+	s, err := p.Future.Struct()
+	return Registerer_register_Params{s}, err
+}
+
+func (p Registerer_register_Params_Future) Req() RegisterRequest_Future {
+	return RegisterRequest_Future{Future: p.Future.Field(0, nil)}
+}
+
+type Registerer_register_Results struct{ capnp.Struct }
+
+// Registerer_register_Results_TypeID is the unique identifier for the type Registerer_register_Results.
+const Registerer_register_Results_TypeID = 0xb5c83b347e16691c
+
+func NewRegisterer_register_Results(s *capnp.Segment) (Registerer_register_Results, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Registerer_register_Results{st}, err
+}
+
+func NewRootRegisterer_register_Results(s *capnp.Segment) (Registerer_register_Results, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Registerer_register_Results{st}, err
+}
+
+func ReadRootRegisterer_register_Results(msg *capnp.Message) (Registerer_register_Results, error) {
+	root, err := msg.Root()
+	return Registerer_register_Results{root.Struct()}, err
+}
+
+func (s Registerer_register_Results) String() string {
+	str, _ := text.Marshal(0xb5c83b347e16691c, s.Struct)
+	return str
+}
+
+func (s Registerer_register_Results) Resp() (RegisterResponse, error) {
+	p, err := s.Struct.Ptr(0)
+	return RegisterResponse{Struct: p.Struct()}, err
+}
+
+func (s Registerer_register_Results) HasResp() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Registerer_register_Results) SetResp(v RegisterResponse) error {
+	return s.Struct.SetPtr(0, v.Struct.ToPtr())
+}
+
+// NewResp sets the resp field to a newly
+// allocated RegisterResponse struct, preferring placement in s's segment.
+func (s Registerer_register_Results) NewResp() (RegisterResponse, error) {
+	ss, err := NewRegisterResponse(s.Struct.Segment())
+	if err != nil {
+		return RegisterResponse{}, err
+	}
+	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
+	return ss, err
+}
+
+// Registerer_register_Results_List is a list of Registerer_register_Results.
+type Registerer_register_Results_List struct{ capnp.List }
+
+// NewRegisterer_register_Results creates a new list of Registerer_register_Results.
+func NewRegisterer_register_Results_List(s *capnp.Segment, sz int32) (Registerer_register_Results_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Registerer_register_Results_List{l}, err
+}
+
+func (s Registerer_register_Results_List) At(i int) Registerer_register_Results {
+	return Registerer_register_Results{s.List.Struct(i)}
+}
+
+func (s Registerer_register_Results_List) Set(i int, v Registerer_register_Results) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s Registerer_register_Results_List) String() string {
+	str, _ := text.MarshalList(0xb5c83b347e16691c, s.List)
+	return str
+}
+
+// Registerer_register_Results_Future is a wrapper for a Registerer_register_Results promised by a client call.
+type Registerer_register_Results_Future struct{ *capnp.Future }
+
+func (p Registerer_register_Results_Future) Struct() (Registerer_register_Results, error) {
+	s, err := p.Future.Struct()
+	return Registerer_register_Results{s}, err
+}
+
+func (p Registerer_register_Results_Future) Resp() RegisterResponse_Future {
+	return RegisterResponse_Future{Future: p.Future.Field(0, nil)}
+}
+
+const schema_dceab81b996ed67b = "x\xda\x8cTM\x88\x1cE\x18}\xaf\xaa\xbb'\x09\xbb" +
+	"\xcc\x14=zI\xe2F\xb3\x07W\xd8%\x92\x04qU" +
+	"6F%\xc9\xa2\xb8\xb51(\xb9uf\xca\xdd1;" +
+	"=\x93\xae\x1e%\xc6\x9f\x10QTPQ\xc1?<\x08" +
+	"\x8a\x82\x88z0\xa0\xa0\x12\xc1\xc0\x82\x04\x12\x10\x7f\xe2" +
+	"^\xa2!J\xc0\x8b\xe4\xe2AZj\xdc\xe9\xe9L\x0c" +
+	"\xd9[\xd7\xc7\xeb\xf7\xbd\xef\xbd\xaao\xd3Ub\x9b\xb8" +
+	"\xd1\xbf)\x00\xf4N?\xc8^\xfc\xe6\xd0\xa3\x1f\xfc\xb6" +
+	"\xe60TEf\x87~\x88\xdf\\\xfb\xf9\xf9%\x80!" +
+	"\xe5_\xe1\xb0,\x01\xe1j\xb9#\xdc\xea\xbe\xb2\x0b\xf1" +
+	"\xcd\x1f~w\xee\x9d\xc3Pk\x09\xf8,\x01\x9b\xd7\xcb" +
+	"\xbd\x04\xc319\x05f\x17\x1a\xf13\xb7\xbdw\xed\xf3" +
+	"\xd0\x15\xb2O\xe7\x07\x0e\xb9K\x0a\x86{\x1c\xd1f-" +
+	"_\"\x98m?\xf8\xdcS\xe7\x1e;\xf6\x1a\xd459" +
+	"\xdf\x9f\xde[\x8e\xef\x1f\xcf\xf1\xa9\xc9\x8d\xaf>\xfb\xeb" +
+	"\xc8\xebP\x95\"]\x97c\xbd\xbf\x86\xe1\xb8\xef\x14\x8e" +
+	"\xf9\x9f\x80\xd9\x99\xb3\x1b~<2\xf5\xe9\x1b\x03`\xe1" +
+	"\x10\xc7\xfd\xf3\xe1\xa9.\xf6\x84\xff\x08\x98\xadk\\\xfd" +
+	"\xc4\x96[\x16\x8f\x16'\x19\x0b\xf6\xb9\xce[\x03\xd7y" +
+	"\xf7\xfb\xd9\xe9\xaf\xdf\xfd\xe8\x97\xa2\xb4=\xc1+\x0e`" +
+	"\xba\x80\x0d\xe3\x1f\xdf\xeam\xbc\xff\xf7K\x8c{:8" +
+	"\x1d\xbe\xec\x06\x0e_\x08v\x84_\x04%\xd4\xb2\xf9(" +
+	"\xae\xdb\xf9h\xbf0\x13\xb5\xa8\x1d\xb7'o\xef\xa4\xf3" +
+	"&N\x1b#\xb5(m%3\xa4\xf6\xa4\x0f\xe4m\xd9" +
+	"\xb3F\xa9\x87 \xd4\xeaR\x16-\xff\x81r-J\xcd" +
+	"6\xce\x909\xad\xd7\xa3\x9d5s\x0d\x9b\x9a\xc4$\x13" +
+	"\xc9\xf2\xe7\xe8L\x94D\xb2i\xb5'=\xc0#\xa0\x86" +
+	"\xaf\x03\xf4*I]\x15,%\xe6\x00+\xfd\xe0@V" +
+	"\xd0g\x96\x83\xcc\xb3\xe6@\xc7\xd8\x14N\xf2\xba\x9c\xf1" +
+	"\xe84\xa0?\x93\xd4\xc7\x04\x15Y\xa5+~\xe5\x8a_" +
+	"J\xeaEA%D\x95\x02P\xc7\xf7\x02\xfa[I}" +
+	"RPIY\xa5\x04\xd4\x09'hQR\x7f/\xa8<" +
+	"\xafJ\x0fP\xa7f\x01}RR/\x09\xd2\xaf\xd2\x07" +
+	"\xd4\xcf\x09\xa0\x7f\x92\xd4g\x05U\xe0W\x19\x00\xea\xcc" +
+	"v@/I\xea?\x043{\xd0\xa6\xa6\xb9\xab\x0e\x80" +
+	"C\x10\x1cr\xc3\xb4l\x1aGMS\xac5\xe2\xd4$" +
+	"\x0fF5HcY\xc9\xee\x98~\xfc\xef{\xdf\xde\x7f" +
+	"dy\xfeR'Y\xc8\xa1q\xabn\xe6\x92V\x07l" +
+	"\xe7\xb5}&\xaa\xb5\xe2\xdd\x1d\x8c\xb4\xdb\xad$%!" +
+	"H\xf0\xc9\x87Mb\x1b\xad\xb8\xdfz\xd9G\x7f0\xf8" +
+	"n\xee\x13Q\xffdFg\x8d\xed,\xc8\xf4\xa2\xa4n" +
+	"\xe8'UN\x8cm\xb3\xd2\xbf\xe6W\x8e\xca\xb6[\xb1" +
+	"5\xe8\x865\x94\x93\xde\xe5r\xb9SR\xcf\x14\xc2\xba" +
+	"\xc7u\xda)\xa9\xef+\x84\xa5\x9d\xb3wK\xea\x07\xfe" +
+	"\xdf\xd9r\xa7\xd3\xa8\xf7\x0e\x97\x9d\xfd\xa2K\xefD\x95" +
+	"\x9d*\xa7iU\xaei\xcc\xb5\x1f\x95\xd4\x9b\x0a\x9a\xc6" +
+	"'\x01}\xbd\xa4\xde\"X\xb6\xd1B\xcaa\x08\x0e\x83" +
+	"S\xf5\xc6\x9c\xb1\xf9qe\xef\xc0\xd9[Z\xb8\xa2\xbd" +
+	"\xf9\xca\x19\xb0w%\x09\xba\xa7\xd6\xe4e\x9fZ\xd3\xce" +
+	"]\"Y\x0cJ\x96\xa6\xb0\x0ez\x0b\x97\xbd}\xa5\xd4" +
+	"\xf4\x7f\xeb\xa07\x16\x80\xee.\xf87\x00\x00\xff\xff\x86" +
+	"\xdc\x84m"
+
+func init() {
+	schemas.Register(schema_dceab81b996ed67b,
+		0x800ae3a77a7bc18e,
+		0x80a0e6cbaa396ef4,
+		0x8a21a43d866e69f4,
+		0x96c07ce683897942,
+		0x971fe28893233a11,
+		0x98b03f82d720e4e1,
+		0xb5c83b347e16691c,
+		0xdbaca3bedaffa653,
+		0xe75723043cae2d20)
+}
diff --git a/src/rackd_spike/pkg/rpc/network.capnp.go b/src/rackd_spike/pkg/rpc/network.capnp.go
 new file mode 100644
index 0000000..4101c19
--- /dev/null
+++ b/src/rackd_spike/pkg/rpc/network.capnp.go
@@ -0,0 +1,489 @@
+// Code generated by capnpc-go. DO NOT EDIT.
+
+package rpc
+
+import (
+	capnp "capnproto.org/go/capnp/v3"
+	text "capnproto.org/go/capnp/v3/encoding/text"
+	schemas "capnproto.org/go/capnp/v3/schemas"
+)
+
+type Link struct{ capnp.Struct }
+
+// Link_TypeID is the unique identifier for the type Link.
+const Link_TypeID = 0xc7251b7c2c125e6e
+
+func NewLink(s *capnp.Segment) (Link, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
+	return Link{st}, err
+}
+
+func NewRootLink(s *capnp.Segment) (Link, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3})
+	return Link{st}, err
+}
+
+func ReadRootLink(msg *capnp.Message) (Link, error) {
+	root, err := msg.Root()
+	return Link{root.Struct()}, err
+}
+
+func (s Link) String() string {
+	str, _ := text.Marshal(0xc7251b7c2c125e6e, s.Struct)
+	return str
+}
+
+func (s Link) Mode() (string, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.Text(), err
+}
+
+func (s Link) HasMode() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Link) ModeBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.TextBytes(), err
+}
+
+func (s Link) SetMode(v string) error {
+	return s.Struct.SetText(0, v)
+}
+
+func (s Link) Address() (string, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.Text(), err
+}
+
+func (s Link) HasAddress() bool {
+	return s.Struct.HasPtr(1)
+}
+
+func (s Link) AddressBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.TextBytes(), err
+}
+
+func (s Link) SetAddress(v string) error {
+	return s.Struct.SetText(1, v)
+}
+
+func (s Link) Gateway() (string, error) {
+	p, err := s.Struct.Ptr(2)
+	return p.Text(), err
+}
+
+func (s Link) HasGateway() bool {
+	return s.Struct.HasPtr(2)
+}
+
+func (s Link) GatewayBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(2)
+	return p.TextBytes(), err
+}
+
+func (s Link) SetGateway(v string) error {
+	return s.Struct.SetText(2, v)
+}
+
+func (s Link) Netmask() int32 {
+	return int32(s.Struct.Uint32(0))
+}
+
+func (s Link) SetNetmask(v int32) {
+	s.Struct.SetUint32(0, uint32(v))
+}
+
+// Link_List is a list of Link.
+type Link_List struct{ capnp.List }
+
+// NewLink creates a new list of Link.
+func NewLink_List(s *capnp.Segment, sz int32) (Link_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 3}, sz)
+	return Link_List{l}, err
+}
+
+func (s Link_List) At(i int) Link { return Link{s.List.Struct(i)} }
+
+func (s Link_List) Set(i int, v Link) error { return s.List.SetStruct(i, v.Struct) }
+
+func (s Link_List) String() string {
+	str, _ := text.MarshalList(0xc7251b7c2c125e6e, s.List)
+	return str
+}
+
+// Link_Future is a wrapper for a Link promised by a client call.
+type Link_Future struct{ *capnp.Future }
+
+func (p Link_Future) Struct() (Link, error) {
+	s, err := p.Future.Struct()
+	return Link{s}, err
+}
+
+type InterfaceDetails struct{ capnp.Struct }
+
+// InterfaceDetails_TypeID is the unique identifier for the type InterfaceDetails.
+const InterfaceDetails_TypeID = 0xca5e2a006234f169
+
+func NewInterfaceDetails(s *capnp.Segment) (InterfaceDetails, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 4})
+	return InterfaceDetails{st}, err
+}
+
+func NewRootInterfaceDetails(s *capnp.Segment) (InterfaceDetails, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 4})
+	return InterfaceDetails{st}, err
+}
+
+func ReadRootInterfaceDetails(msg *capnp.Message) (InterfaceDetails, error) {
+	root, err := msg.Root()
+	return InterfaceDetails{root.Struct()}, err
+}
+
+func (s InterfaceDetails) String() string {
+	str, _ := text.Marshal(0xca5e2a006234f169, s.Struct)
+	return str
+}
+
+func (s InterfaceDetails) MacAddress() (string, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.Text(), err
+}
+
+func (s InterfaceDetails) HasMacAddress() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s InterfaceDetails) MacAddressBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.TextBytes(), err
+}
+
+func (s InterfaceDetails) SetMacAddress(v string) error {
+	return s.Struct.SetText(0, v)
+}
+
+func (s InterfaceDetails) Type() (string, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.Text(), err
+}
+
+func (s InterfaceDetails) HasType() bool {
+	return s.Struct.HasPtr(1)
+}
+
+func (s InterfaceDetails) TypeBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(1)
+	return p.TextBytes(), err
+}
+
+func (s InterfaceDetails) SetType(v string) error {
+	return s.Struct.SetText(1, v)
+}
+
+func (s InterfaceDetails) Links() (Link_List, error) {
+	p, err := s.Struct.Ptr(2)
+	return Link_List{List: p.List()}, err
+}
+
+func (s InterfaceDetails) HasLinks() bool {
+	return s.Struct.HasPtr(2)
+}
+
+func (s InterfaceDetails) SetLinks(v Link_List) error {
+	return s.Struct.SetPtr(2, v.List.ToPtr())
+}
+
+// NewLinks sets the links field to a newly
+// allocated Link_List, preferring placement in s's segment.
+func (s InterfaceDetails) NewLinks(n int32) (Link_List, error) {
+	l, err := NewLink_List(s.Struct.Segment(), n)
+	if err != nil {
+		return Link_List{}, err
+	}
+	err = s.Struct.SetPtr(2, l.List.ToPtr())
+	return l, err
+}
+
+func (s InterfaceDetails) Vid() uint64 {
+	return s.Struct.Uint64(0)
+}
+
+func (s InterfaceDetails) SetVid(v uint64) {
+	s.Struct.SetUint64(0, v)
+}
+
+func (s InterfaceDetails) Enabled() bool {
+	return s.Struct.Bit(64)
+}
+
+func (s InterfaceDetails) SetEnabled(v bool) {
+	s.Struct.SetBit(64, v)
+}
+
+func (s InterfaceDetails) Parents() (capnp.TextList, error) {
+	p, err := s.Struct.Ptr(3)
+	return capnp.TextList{List: p.List()}, err
+}
+
+func (s InterfaceDetails) HasParents() bool {
+	return s.Struct.HasPtr(3)
+}
+
+func (s InterfaceDetails) SetParents(v capnp.TextList) error {
+	return s.Struct.SetPtr(3, v.List.ToPtr())
+}
+
+// NewParents sets the parents field to a newly
+// allocated capnp.TextList, preferring placement in s's segment.
+func (s InterfaceDetails) NewParents(n int32) (capnp.TextList, error) {
+	l, err := capnp.NewTextList(s.Struct.Segment(), n)
+	if err != nil {
+		return capnp.TextList{}, err
+	}
+	err = s.Struct.SetPtr(3, l.List.ToPtr())
+	return l, err
+}
+
+// InterfaceDetails_List is a list of InterfaceDetails.
+type InterfaceDetails_List struct{ capnp.List }
+
+// NewInterfaceDetails creates a new list of InterfaceDetails.
+func NewInterfaceDetails_List(s *capnp.Segment, sz int32) (InterfaceDetails_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 4}, sz)
+	return InterfaceDetails_List{l}, err
+}
+
+func (s InterfaceDetails_List) At(i int) InterfaceDetails { return InterfaceDetails{s.List.Struct(i)} }
+
+func (s InterfaceDetails_List) Set(i int, v InterfaceDetails) error {
+	return s.List.SetStruct(i, v.Struct)
+}
+
+func (s InterfaceDetails_List) String() string {
+	str, _ := text.MarshalList(0xca5e2a006234f169, s.List)
+	return str
+}
+
+// InterfaceDetails_Future is a wrapper for a InterfaceDetails promised by a client call.
+type InterfaceDetails_Future struct{ *capnp.Future }
+
+func (p InterfaceDetails_Future) Struct() (InterfaceDetails, error) {
+	s, err := p.Future.Struct()
+	return InterfaceDetails{s}, err
+}
+
+type Interface struct{ capnp.Struct }
+
+// Interface_TypeID is the unique identifier for the type Interface.
+const Interface_TypeID = 0x929a2663d1c662e2
+
+func NewInterface(s *capnp.Segment) (Interface, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
+	return Interface{st}, err
+}
+
+func NewRootInterface(s *capnp.Segment) (Interface, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
+	return Interface{st}, err
+}
+
+func ReadRootInterface(msg *capnp.Message) (Interface, error) {
+	root, err := msg.Root()
+	return Interface{root.Struct()}, err
+}
+
+func (s Interface) String() string {
+	str, _ := text.Marshal(0x929a2663d1c662e2, s.Struct)
+	return str
+}
+
+func (s Interface) Name() (string, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.Text(), err
+}
+
+func (s Interface) HasName() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Interface) NameBytes() ([]byte, error) {
+	p, err := s.Struct.Ptr(0)
+	return p.TextBytes(), err
+}
+
+func (s Interface) SetName(v string) error {
+	return s.Struct.SetText(0, v)
+}
+
+func (s Interface) Iface() (InterfaceDetails, error) {
+	p, err := s.Struct.Ptr(1)
+	return InterfaceDetails{Struct: p.Struct()}, err
+}
+
+func (s Interface) HasIface() bool {
+	return s.Struct.HasPtr(1)
+}
+
+func (s Interface) SetIface(v InterfaceDetails) error {
+	return s.Struct.SetPtr(1, v.Struct.ToPtr())
+}
+
+// NewIface sets the iface field to a newly
+// allocated InterfaceDetails struct, preferring placement in s's segment.
+func (s Interface) NewIface() (InterfaceDetails, error) {
+	ss, err := NewInterfaceDetails(s.Struct.Segment())
+	if err != nil {
+		return InterfaceDetails{}, err
+	}
+	err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
+	return ss, err
+}
+
+// Interface_List is a list of Interface.
+type Interface_List struct{ capnp.List }
+
+// NewInterface creates a new list of Interface.
+func NewInterface_List(s *capnp.Segment, sz int32) (Interface_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
+	return Interface_List{l}, err
+}
+
+func (s Interface_List) At(i int) Interface { return Interface{s.List.Struct(i)} }
+
+func (s Interface_List) Set(i int, v Interface) error { return s.List.SetStruct(i, v.Struct) }
+
+func (s Interface_List) String() string {
+	str, _ := text.MarshalList(0x929a2663d1c662e2, s.List)
+	return str
+}
+
+// Interface_Future is a wrapper for a Interface promised by a client call.
+type Interface_Future struct{ *capnp.Future }
+
+func (p Interface_Future) Struct() (Interface, error) {
+	s, err := p.Future.Struct()
+	return Interface{s}, err
+}
+
+func (p Interface_Future) Iface() InterfaceDetails_Future {
+	return InterfaceDetails_Future{Future: p.Future.Field(1, nil)}
+}
+
+type Interfaces struct{ capnp.Struct }
+
+// Interfaces_TypeID is the unique identifier for the type Interfaces.
+const Interfaces_TypeID = 0x826b9c4ff97d4a43
+
+func NewInterfaces(s *capnp.Segment) (Interfaces, error) {
+	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Interfaces{st}, err
+}
+
+func NewRootInterfaces(s *capnp.Segment) (Interfaces, error) {
+	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
+	return Interfaces{st}, err
+}
+
+func ReadRootInterfaces(msg *capnp.Message) (Interfaces, error) {
+	root, err := msg.Root()
+	return Interfaces{root.Struct()}, err
+}
+
+func (s Interfaces) String() string {
+	str, _ := text.Marshal(0x826b9c4ff97d4a43, s.Struct)
+	return str
+}
+
+func (s Interfaces) Ifaces() (Interface_List, error) {
+	p, err := s.Struct.Ptr(0)
+	return Interface_List{List: p.List()}, err
+}
+
+func (s Interfaces) HasIfaces() bool {
+	return s.Struct.HasPtr(0)
+}
+
+func (s Interfaces) SetIfaces(v Interface_List) error {
+	return s.Struct.SetPtr(0, v.List.ToPtr())
+}
+
+// NewIfaces sets the ifaces field to a newly
+// allocated Interface_List, preferring placement in s's segment.
+func (s Interfaces) NewIfaces(n int32) (Interface_List, error) {
+	l, err := NewInterface_List(s.Struct.Segment(), n)
+	if err != nil {
+		return Interface_List{}, err
+	}
+	err = s.Struct.SetPtr(0, l.List.ToPtr())
+	return l, err
+}
+
+// Interfaces_List is a list of Interfaces.
+type Interfaces_List struct{ capnp.List }
+
+// NewInterfaces creates a new list of Interfaces.
+func NewInterfaces_List(s *capnp.Segment, sz int32) (Interfaces_List, error) {
+	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
+	return Interfaces_List{l}, err
+}
+
+func (s Interfaces_List) At(i int) Interfaces { return Interfaces{s.List.Struct(i)} }
+
+func (s Interfaces_List) Set(i int, v Interfaces) error { return s.List.SetStruct(i, v.Struct) }
+
+func (s Interfaces_List) String() string {
+	str, _ := text.MarshalList(0x826b9c4ff97d4a43, s.List)
+	return str
+}
+
+// Interfaces_Future is a wrapper for a Interfaces promised by a client call.
+type Interfaces_Future struct{ *capnp.Future }
+
+func (p Interfaces_Future) Struct() (Interfaces, error) {
+	s, err := p.Future.Struct()
+	return Interfaces{s}, err
+}
+
+const schema_dae346a935a6f239 = "x\xda|\x921h\x14O\x18\xc5\xdf\x9b\xd9\xfb'\x81" +
+	"\xfc/\xb7\xde\x15\x82\x85\"Q4\x18\x89\x1a\x0b\xd3$" +
+	"F\x11\"\x82\xf9\x0a\x11D\x82\x93\xdb\xd1,w\xb79" +
+	"\xee\x16C@9\x14,l\xad4\xa4PP\xd1\xde\xc2" +
+	"@\x04#j \x9d\x9d\xd8\xa9\x88X\x89v\xda\xac\xcc" +
+	"\x06\xf7\x16A\xbb\x9d\xc7o\xbf\xf7\xde|32\xc9\x09" +
+	"u\xa0\xb0\xae\x00\xd9Q\xf8/9v\xf2\xea\x8f\xd3\xcb" +
+	"\xb5\xeb\xf0\x8bL\x8e|\x7fx\xf8\xf1\x89\x8f\xefP`" +
+	"\x0fP\x9e\xe2F\xf9L\xfa%\x1c\x07\x93\x0f\xb3\xaf\xdf" +
+	"Tw/\xdd\xfa\x83U\x8e\xb8\xc6\x17\xe5\x9b){\x83" +
+	"\x0b`\x12\xcdl\xd9we\xdb\xaeuH\x91yX;" +
+	"\xe4=\x97\xca_R\xf8\x13?\x83_\xc3o\xa3\xb3C" +
+	"3\x1bR\xa4\xca\xa1\x9e\x03V\xd4\xcf\xf2+\xe7ph" +
+	"M\x9d%\x86\x93\xc8\xc6\x0b\xf3\xad\xda~U5\xcd\xa8" +
+	"96\x15\xc5\xb6u\xd1Tm\x1b\x98&\xc5\xd3\x1e\xe0" +
+	"\x11\xf0\xff\x1f\x03\xa4WS\x06\x15\xc7\xc3\x14a\x11\x9c" +
+	"\xd6d\xa9[\x05t\xe2_\xa7\xa63{\xb3\x99{\x87" +
+	"\x00\x19\xd4\x94\x11E\x9f\xac\xd0\x89\xc3\x07\x01\xd9\xa3)" +
+	"\xa3\x8a\x03\x91iX\xf6C\xb1\x1f\xdc\x9e\xba\xb2\xf4\xbb" +
+	"\x1f\xc8R\xce\x8b\x9b^\xa7B\x1d\xd5\x9cM)\xb31" +
+	"\xce\xe6\xbc\xa6\xcc\xe5l\xec$ \x174\xa5\xae\xe8+" +
+	"U\xa1\x02\xfc\xd0\x89\x81\xa64\x15\xa9+\xd4\x80\xdfp" +
+	"\xda\x9c\xa6\xc4\x8a\x03\x8d\xf9 \xcb\xd31A\xd0\xb2\xed" +
+	"vv\xbedb\xbb`\x16\xb3sd\xe3\x86i\xd7\xe8" +
+	"A\xd1\xfb\xc7\xad\x1c\x1f\xb7\xb1\x09\xebm\x97zk\x96" +
+	"\xfa\xce9@nk\xca\xfd\\\xea{\xae\xca\xb2\xa6<" +
+	"\xca\xa5~\xe0n\xec\xae\xa6\xacvS\xaf\xec\x04\xe4\x89" +
+	"\xa6<W\xf4\xbd\x89\x0a=\xc0\x7f\xe6\xaa<\xd5\x94\x97" +
+	"\x8a~AWX\x00\xfc5'\xaej\xca[\xc5\xa4a" +
+	"\xaaG]+\xe8n\xaf\x81x\xb1\xd9]B=\x8cj" +
+	"\xb9\xcdg\x0fss\xf3=\x97\xc3\x80}P\xec\x03;" +
+	"62\xb3u\x1b\x90P$\xd8i\x9a\x96\x8d\xe2\xecg" +
+	"7\xb1\x08\xfe\x0a\x00\x00\xff\xff\x8c{\xba\xe7"
+
+func init() {
+	schemas.Register(schema_dae346a935a6f239,
+		0x826b9c4ff97d4a43,
+		0x929a2663d1c662e2,
+		0xc7251b7c2c125e6e,
+		0xca5e2a006234f169)
+}
diff --git a/src/rpc/go.capnp b/src/rpc/go.capnp
 new file mode 100644
index 0000000..4072b57
--- /dev/null
+++ b/src/rpc/go.capnp
@@ -0,0 +1,27 @@
+@0xd12a1c51fedd6c88;
+
+annotation package(file) :Text;
+# The Go package name for the generated file.
+
+annotation import(file) :Text;
+# The Go import path that the generated file is accessible from.
+# Used to generate import statements and check if two types are in the
+# same package.
+
+annotation doc(struct, field, enum) :Text;
+# Adds a doc comment to the generated code.
+
+annotation tag(enumerant) :Text;
+# Changes the string representation of the enum in the generated code.
+
+annotation notag(enumerant) :Void;
+# Removes the string representation of the enum in the generated code.
+
+annotation customtype(field) :Text;
+# OBSOLETE, not used by code generator.
+
+annotation name(struct, field, union, enum, enumerant, interface, method, param, annotation, const, group) :Text;
+# Used to rename the element in the generated code.
+
+$package("gocp");
+$import("capnproto.org/go/capnp/v3/std/go");
diff --git a/src/rpc/handshake.capnp b/src/rpc/handshake.capnp
 new file mode 100644
index 0000000..dc87b67
--- /dev/null
+++ b/src/rpc/handshake.capnp
@@ -0,0 +1,36 @@
+@0xdceab81b996ed67b;
+
+using Go = import "go.capnp";
+$Go.package("rpc");
+$Go.import("rpc");
+
+using Network = import "network.capnp";
+
+struct AuthResponse {
+    salt @0 :Data;
+    digest @1 :Data;
+}
+
+interface Authenticator {
+    authenticate @0 (msg :Data) -> (resp :AuthResponse);
+}
+
+struct RegisterRequest {
+    systemId @0 :Text;
+    hostname @1 :Text;
+    interfaces @2 :Network.Interfaces;
+    url @3 :Text;
+    nodegroup @4 :Text;
+    beaconSupport @5 :Bool;
+    version @6 :Text;
+}
+
+struct RegisterResponse {
+    systemId @0 :Text;
+    uuid @1 :Text;
+    version @2 :Text;
+}
+
+interface Registerer {
+    register @0 (req :RegisterRequest) -> (resp :RegisterResponse);
+}
diff --git a/src/rpc/network.capnp b/src/rpc/network.capnp
 new file mode 100644
index 0000000..5e719c9
--- /dev/null
+++ b/src/rpc/network.capnp
@@ -0,0 +1,30 @@
+@0xdae346a935a6f239;
+
+using Go = import "go.capnp";
+$Go.package("rpc");
+$Go.import("rpc");
+
+struct Link {
+    mode @0 :Text;
+    address @1 :Text;
+    gateway @2 :Text;
+    netmask @3 :Int32;
+}
+
+struct InterfaceDetails {
+    macAddress @0 :Text;
+    type @1 :Text;
+    links @2 :List(Link);
+    vid @3 :UInt64;
+    enabled @4 :Bool;
+    parents @5 :List(Text);
+}
+
+struct Interface {
+    name @0 :Text;
+    iface @1 :InterfaceDetails;
+}
+
+struct Interfaces {
+    ifaces @0 :List(Interface);
+}