headscale/machine.go

771 lines
18 KiB
Go
Raw Normal View History

2020-06-21 04:32:08 -06:00
package headscale
import (
"encoding/json"
"errors"
2020-06-21 04:32:08 -06:00
"fmt"
"sort"
2021-02-22 15:27:33 -07:00
"strconv"
"strings"
2020-06-21 04:32:08 -06:00
"time"
"github.com/fatih/set"
2021-11-13 01:39:04 -07:00
v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
2021-08-05 11:11:26 -06:00
"github.com/rs/zerolog/log"
"google.golang.org/protobuf/types/known/timestamppb"
2021-05-14 16:05:41 -06:00
"gorm.io/datatypes"
"gorm.io/gorm"
2021-02-20 14:43:07 -07:00
"inet.af/netaddr"
2020-06-21 04:32:08 -06:00
"tailscale.com/tailcfg"
2021-06-25 10:57:08 -06:00
"tailscale.com/types/wgkey"
2020-06-21 04:32:08 -06:00
)
2021-11-15 12:18:14 -07:00
const (
errMachineNotFound = Error("machine not found")
errMachineAlreadyRegistered = Error("machine already registered")
errMachineRouteIsNotAvailable = Error("route is not available on machine")
)
2021-11-13 01:39:04 -07:00
// Machine is a Headscale client.
2020-06-21 04:32:08 -06:00
type Machine struct {
ID uint64 `gorm:"primary_key"`
MachineKey string `gorm:"type:varchar(64);unique_index"`
NodeKey string
DiscoKey string
IPAddress string
Name string
NamespaceID uint
2021-06-25 10:57:08 -06:00
Namespace Namespace `gorm:"foreignKey:NamespaceID"`
2020-06-21 04:32:08 -06:00
Registered bool // temp
RegisterMethod string
AuthKeyID uint
AuthKey *PreAuthKey
LastSeen *time.Time
LastSuccessfulUpdate *time.Time
Expiry *time.Time
2020-06-21 04:32:08 -06:00
2021-05-14 16:05:41 -06:00
HostInfo datatypes.JSON
Endpoints datatypes.JSON
EnabledRoutes datatypes.JSON
2020-06-21 04:32:08 -06:00
CreatedAt time.Time
UpdatedAt time.Time
DeletedAt *time.Time
}
type (
Machines []Machine
MachinesP []*Machine
)
2021-11-13 01:39:04 -07:00
// For the time being this method is rather naive.
2021-11-22 10:21:56 -07:00
func (machine Machine) isRegistered() bool {
return machine.Registered
2020-06-21 04:32:08 -06:00
}
2021-11-13 01:39:04 -07:00
// isExpired returns whether the machine registration has expired.
func (machine Machine) isExpired() bool {
// If Expiry is not set, the client has not indicated that
// it wants an expiry time, it is therefor considered
// to mean "not expired"
if machine.Expiry.IsZero() {
return false
2021-10-10 03:22:42 -06:00
}
return time.Now().UTC().After(*machine.Expiry)
2021-10-10 03:22:42 -06:00
}
func (h *Headscale) getDirectPeers(machine *Machine) (Machines, error) {
log.Trace().
Caller().
Str("machine", machine.Name).
Msg("Finding direct peers")
machines := Machines{}
2021-10-05 09:47:21 -06:00
if err := h.db.Preload("Namespace").Where("namespace_id = ? AND machine_key <> ? AND registered",
machine.NamespaceID, machine.MachineKey).Find(&machines).Error; err != nil {
log.Error().Err(err).Msg("Error accessing db")
2021-11-14 08:46:09 -07:00
return Machines{}, err
2020-06-21 04:32:08 -06:00
}
sort.Slice(machines, func(i, j int) bool { return machines[i].ID < machines[j].ID })
2020-06-21 04:32:08 -06:00
log.Trace().
Caller().
Str("machine", machine.Name).
Msgf("Found direct machines: %s", machines.String())
2021-11-14 08:46:09 -07:00
return machines, nil
2020-06-21 04:32:08 -06:00
}
2021-11-13 01:39:04 -07:00
// getShared fetches machines that are shared to the `Namespace` of the machine we are getting peers for.
func (h *Headscale) getShared(machine *Machine) (Machines, error) {
2021-08-13 03:33:19 -06:00
log.Trace().
Caller().
Str("machine", machine.Name).
Msg("Finding shared peers")
2020-06-21 04:32:08 -06:00
sharedMachines := []SharedMachine{}
if err := h.db.Preload("Namespace").Preload("Machine").Preload("Machine.Namespace").Where("namespace_id = ?",
machine.NamespaceID).Find(&sharedMachines).Error; err != nil {
return Machines{}, err
2021-09-02 08:59:03 -06:00
}
peers := make(Machines, 0)
for _, sharedMachine := range sharedMachines {
peers = append(peers, sharedMachine.Machine)
2020-06-21 04:32:08 -06:00
}
sort.Slice(peers, func(i, j int) bool { return peers[i].ID < peers[j].ID })
2021-08-13 03:33:19 -06:00
log.Trace().
Caller().
Str("machine", machine.Name).
Msgf("Found shared peers: %s", peers.String())
2021-11-14 08:46:09 -07:00
return peers, nil
}
2021-11-13 01:39:04 -07:00
// getSharedTo fetches the machines of the namespaces this machine is shared in.
func (h *Headscale) getSharedTo(machine *Machine) (Machines, error) {
log.Trace().
Caller().
Str("machine", machine.Name).
Msg("Finding peers in namespaces this machine is shared with")
sharedMachines := []SharedMachine{}
if err := h.db.Preload("Namespace").Preload("Machine").Preload("Machine.Namespace").Where("machine_id = ?",
machine.ID).Find(&sharedMachines).Error; err != nil {
return Machines{}, err
}
peers := make(Machines, 0)
for _, sharedMachine := range sharedMachines {
2021-11-13 01:36:45 -07:00
namespaceMachines, err := h.ListMachinesInNamespace(
sharedMachine.Namespace.Name,
)
if err != nil {
return Machines{}, err
}
peers = append(peers, namespaceMachines...)
}
sort.Slice(peers, func(i, j int) bool { return peers[i].ID < peers[j].ID })
log.Trace().
Caller().
Str("machine", machine.Name).
Msgf("Found peers we are shared with: %s", peers.String())
2021-11-14 08:46:09 -07:00
return peers, nil
}
func (h *Headscale) getPeers(machine *Machine) (Machines, error) {
direct, err := h.getDirectPeers(machine)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Cannot fetch peers")
2021-11-14 08:46:09 -07:00
return Machines{}, err
}
shared, err := h.getShared(machine)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Cannot fetch peers")
2021-11-14 08:46:09 -07:00
return Machines{}, err
}
sharedTo, err := h.getSharedTo(machine)
if err != nil {
log.Error().
Caller().
Err(err).
Msg("Cannot fetch peers")
2021-11-14 08:46:09 -07:00
return Machines{}, err
}
peers := append(direct, shared...)
peers = append(peers, sharedTo...)
sort.Slice(peers, func(i, j int) bool { return peers[i].ID < peers[j].ID })
log.Trace().
Caller().
Str("machine", machine.Name).
Msgf("Found total peers: %s", peers.String())
return peers, nil
2020-06-21 04:32:08 -06:00
}
2021-03-14 04:38:42 -06:00
func (h *Headscale) ListMachines() ([]Machine, error) {
machines := []Machine{}
if err := h.db.Preload("AuthKey").Preload("AuthKey.Namespace").Preload("Namespace").Find(&machines).Error; err != nil {
return nil, err
}
2021-11-14 08:46:09 -07:00
return machines, nil
}
2021-11-13 01:39:04 -07:00
// GetMachine finds a Machine by name and namespace and returns the Machine struct.
2021-03-14 04:38:42 -06:00
func (h *Headscale) GetMachine(namespace string, name string) (*Machine, error) {
machines, err := h.ListMachinesInNamespace(namespace)
if err != nil {
return nil, err
}
for _, m := range machines {
2021-03-14 04:38:42 -06:00
if m.Name == name {
return &m, nil
}
}
2021-11-14 08:46:09 -07:00
2021-11-15 12:18:14 -07:00
return nil, errMachineNotFound
2021-03-14 04:38:42 -06:00
}
2021-11-13 01:39:04 -07:00
// GetMachineByID finds a Machine by ID and returns the Machine struct.
2021-07-16 16:14:22 -06:00
func (h *Headscale) GetMachineByID(id uint64) (*Machine, error) {
m := Machine{}
if result := h.db.Preload("Namespace").Find(&Machine{ID: id}).First(&m); result.Error != nil {
2021-07-16 16:14:22 -06:00
return nil, result.Error
}
2021-11-14 08:46:09 -07:00
2021-07-16 16:14:22 -06:00
return &m, nil
}
2021-11-13 01:39:04 -07:00
// GetMachineByMachineKey finds a Machine by ID and returns the Machine struct.
func (h *Headscale) GetMachineByMachineKey(machineKey string) (*Machine, error) {
m := Machine{}
if result := h.db.Preload("Namespace").First(&m, "machine_key = ?", machineKey); result.Error != nil {
return nil, result.Error
}
2021-11-14 08:46:09 -07:00
return &m, nil
}
2021-08-23 00:35:44 -06:00
// UpdateMachine takes a Machine struct pointer (typically already loaded from database
// and updates it with the latest data from the database.
func (h *Headscale) UpdateMachine(machine *Machine) error {
if result := h.db.Find(machine).First(&machine); result.Error != nil {
return result.Error
}
2021-11-14 08:46:09 -07:00
return nil
}
2021-11-21 06:40:19 -07:00
// ExpireMachine takes a Machine struct and sets the expire field to now.
func (h *Headscale) ExpireMachine(machine *Machine) {
now := time.Now()
machine.Expiry = &now
h.db.Save(machine)
}
2021-11-13 01:39:04 -07:00
// DeleteMachine softs deletes a Machine from the database.
func (h *Headscale) DeleteMachine(machine *Machine) error {
err := h.RemoveSharedMachineFromAllNamespaces(machine)
2021-11-15 09:33:16 -07:00
if err != nil && errors.Is(err, errMachineNotShared) {
return err
}
machine.Registered = false
namespaceID := machine.NamespaceID
h.db.Save(&machine) // we mark it as unregistered, just in case
if err := h.db.Delete(&machine).Error; err != nil {
2021-07-16 16:14:22 -06:00
return err
}
return h.RequestMapUpdates(namespaceID)
2021-07-16 16:14:22 -06:00
}
2021-11-13 01:39:04 -07:00
// HardDeleteMachine hard deletes a Machine from the database.
func (h *Headscale) HardDeleteMachine(machine *Machine) error {
err := h.RemoveSharedMachineFromAllNamespaces(machine)
2021-11-15 09:33:16 -07:00
if err != nil && errors.Is(err, errMachineNotShared) {
return err
}
namespaceID := machine.NamespaceID
if err := h.db.Unscoped().Delete(&machine).Error; err != nil {
2021-07-16 16:14:22 -06:00
return err
}
return h.RequestMapUpdates(namespaceID)
2021-07-16 16:14:22 -06:00
}
2021-11-13 01:39:04 -07:00
// GetHostInfo returns a Hostinfo struct for the machine.
func (machine *Machine) GetHostInfo() (*tailcfg.Hostinfo, error) {
2021-03-14 04:38:42 -06:00
hostinfo := tailcfg.Hostinfo{}
if len(machine.HostInfo) != 0 {
hi, err := machine.HostInfo.MarshalJSON()
2021-03-14 04:38:42 -06:00
if err != nil {
return nil, err
}
err = json.Unmarshal(hi, &hostinfo)
if err != nil {
return nil, err
}
}
2021-11-14 08:46:09 -07:00
2021-03-14 04:38:42 -06:00
return &hostinfo, nil
}
func (h *Headscale) isOutdated(machine *Machine) bool {
if err := h.UpdateMachine(machine); err != nil {
2021-10-07 08:45:45 -06:00
// It does not seem meaningful to propagate this error as the end result
// will have to be that the machine has to be considered outdated.
return true
}
sharedMachines, _ := h.getShared(machine)
namespaceSet := set.New(set.ThreadSafe)
namespaceSet.Add(machine.Namespace.Name)
// Check if any of our shared namespaces has updates that we have
// not propagated.
for _, sharedMachine := range sharedMachines {
namespaceSet.Add(sharedMachine.Namespace.Name)
}
namespaces := make([]string, namespaceSet.Size())
for index, namespace := range namespaceSet.List() {
2021-11-15 11:42:44 -07:00
if name, ok := namespace.(string); ok {
namespaces[index] = name
}
}
lastChange := h.getLastStateChange(namespaces...)
log.Trace().
Caller().
Str("machine", machine.Name).
Time("last_successful_update", *machine.LastSuccessfulUpdate).
Time("last_state_change", lastChange).
Msgf("Checking if %s is missing updates", machine.Name)
2021-11-14 08:46:09 -07:00
return machine.LastSuccessfulUpdate.Before(lastChange)
}
func (machine Machine) String() string {
return machine.Name
}
func (machines Machines) String() string {
temp := make([]string, len(machines))
for index, machine := range machines {
temp[index] = machine.Name
}
return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
}
// TODO(kradalby): Remove when we have generics...
func (machines MachinesP) String() string {
temp := make([]string, len(machines))
for index, machine := range machines {
temp[index] = machine.Name
}
return fmt.Sprintf("[ %s ](%d)", strings.Join(temp, ", "), len(temp))
}
func (machines Machines) toNodes(
2021-10-30 09:33:01 -06:00
baseDomain string,
dnsConfig *tailcfg.DNSConfig,
includeRoutes bool,
) ([]*tailcfg.Node, error) {
nodes := make([]*tailcfg.Node, len(machines))
for index, machine := range machines {
2021-10-04 15:49:16 -06:00
node, err := machine.toNode(baseDomain, dnsConfig, includeRoutes)
if err != nil {
return nil, err
}
nodes[index] = node
}
return nodes, nil
}
// toNode converts a Machine into a Tailscale Node. includeRoutes is false for shared nodes
2021-11-13 01:39:04 -07:00
// as per the expected behaviour in the official SaaS.
func (machine Machine) toNode(
2021-11-13 01:36:45 -07:00
baseDomain string,
dnsConfig *tailcfg.DNSConfig,
includeRoutes bool,
) (*tailcfg.Node, error) {
nodeKey, err := wgkey.ParseHex(machine.NodeKey)
2020-06-21 04:32:08 -06:00
if err != nil {
return nil, err
}
machineKey, err := wgkey.ParseHex(machine.MachineKey)
2020-06-21 04:32:08 -06:00
if err != nil {
return nil, err
}
var discoKey tailcfg.DiscoKey
if machine.DiscoKey != "" {
dKey, err := wgkey.ParseHex(machine.DiscoKey)
if err != nil {
return nil, err
}
discoKey = tailcfg.DiscoKey(dKey)
} else {
discoKey = tailcfg.DiscoKey{}
}
2021-02-20 14:43:07 -07:00
addrs := []netaddr.IPPrefix{}
ip, err := netaddr.ParseIPPrefix(fmt.Sprintf("%s/32", machine.IPAddress))
2020-06-21 04:32:08 -06:00
if err != nil {
log.Trace().
Caller().
Str("ip", machine.IPAddress).
Msgf("Failed to parse IP Prefix from IP: %s", machine.IPAddress)
2021-11-14 08:46:09 -07:00
2020-06-21 04:32:08 -06:00
return nil, err
}
2021-03-14 04:38:42 -06:00
addrs = append(addrs, ip) // missing the ipv6 ?
allowedIPs := []netaddr.IPPrefix{}
2021-11-13 01:36:45 -07:00
allowedIPs = append(
allowedIPs,
ip,
) // we append the node own IP, as it is required by the clients
2021-03-14 04:38:42 -06:00
2021-09-02 08:59:03 -06:00
if includeRoutes {
routesStr := []string{}
if len(machine.EnabledRoutes) != 0 {
allwIps, err := machine.EnabledRoutes.MarshalJSON()
2021-09-02 08:59:03 -06:00
if err != nil {
return nil, err
}
err = json.Unmarshal(allwIps, &routesStr)
if err != nil {
return nil, err
}
2021-03-14 04:38:42 -06:00
}
for _, routeStr := range routesStr {
ip, err := netaddr.ParseIPPrefix(routeStr)
2021-09-02 08:59:03 -06:00
if err != nil {
return nil, err
}
allowedIPs = append(allowedIPs, ip)
2021-03-14 04:38:42 -06:00
}
}
2020-06-21 04:32:08 -06:00
endpoints := []string{}
if len(machine.Endpoints) != 0 {
be, err := machine.Endpoints.MarshalJSON()
if err != nil {
return nil, err
}
err = json.Unmarshal(be, &endpoints)
if err != nil {
return nil, err
}
2020-06-21 04:32:08 -06:00
}
hostinfo := tailcfg.Hostinfo{}
if len(machine.HostInfo) != 0 {
hi, err := machine.HostInfo.MarshalJSON()
if err != nil {
return nil, err
}
err = json.Unmarshal(hi, &hostinfo)
if err != nil {
return nil, err
}
2020-06-21 04:32:08 -06:00
}
2021-02-24 15:45:27 -07:00
var derp string
if hostinfo.NetInfo != nil {
derp = fmt.Sprintf("127.3.3.40:%d", hostinfo.NetInfo.PreferredDERP)
} else {
derp = "127.3.3.40:0" // Zero means disconnected or unknown.
}
2021-09-02 08:59:03 -06:00
var keyExpiry time.Time
if machine.Expiry != nil {
keyExpiry = *machine.Expiry
2021-09-02 08:59:03 -06:00
} else {
keyExpiry = time.Time{}
}
2021-10-04 15:49:16 -06:00
var hostname string
if dnsConfig != nil && dnsConfig.Proxied { // MagicDNS
hostname = fmt.Sprintf(
"%s.%s.%s",
machine.Name,
machine.Namespace.Name,
baseDomain,
)
2021-10-04 15:49:16 -06:00
} else {
hostname = machine.Name
2021-10-04 15:49:16 -06:00
}
2021-11-15 09:15:50 -07:00
node := tailcfg.Node{
ID: tailcfg.NodeID(machine.ID), // this is the actual ID
2021-10-30 09:33:01 -06:00
StableID: tailcfg.StableNodeID(
strconv.FormatUint(machine.ID, Base10),
2021-10-30 09:33:01 -06:00
), // in headscale, unlike tailcontrol server, IDs are permanent
2021-10-04 15:49:16 -06:00
Name: hostname,
User: tailcfg.UserID(machine.NamespaceID),
Key: tailcfg.NodeKey(nodeKey),
2021-09-02 08:59:03 -06:00
KeyExpiry: keyExpiry,
Machine: tailcfg.MachineKey(machineKey),
DiscoKey: discoKey,
2020-06-21 04:32:08 -06:00
Addresses: addrs,
AllowedIPs: allowedIPs,
Endpoints: endpoints,
2021-02-24 15:45:27 -07:00
DERP: derp,
2020-06-21 04:32:08 -06:00
Hostinfo: hostinfo,
Created: machine.CreatedAt,
LastSeen: machine.LastSeen,
2020-06-21 04:32:08 -06:00
KeepAlive: true,
MachineAuthorized: machine.Registered,
2021-09-24 01:49:29 -06:00
Capabilities: []string{tailcfg.CapabilityFileSharing},
2020-06-21 04:32:08 -06:00
}
2021-11-14 08:46:09 -07:00
2021-11-15 09:15:50 -07:00
return &node, nil
2020-06-21 04:32:08 -06:00
}
func (machine *Machine) toProto() *v1.Machine {
machineProto := &v1.Machine{
Id: machine.ID,
MachineKey: machine.MachineKey,
NodeKey: machine.NodeKey,
DiscoKey: machine.DiscoKey,
IpAddress: machine.IPAddress,
Name: machine.Name,
Namespace: machine.Namespace.toProto(),
Registered: machine.Registered,
// TODO(kradalby): Implement register method enum converter
// RegisterMethod: ,
CreatedAt: timestamppb.New(machine.CreatedAt),
}
if machine.AuthKey != nil {
machineProto.PreAuthKey = machine.AuthKey.toProto()
}
if machine.LastSeen != nil {
machineProto.LastSeen = timestamppb.New(*machine.LastSeen)
}
if machine.LastSuccessfulUpdate != nil {
machineProto.LastSuccessfulUpdate = timestamppb.New(
*machine.LastSuccessfulUpdate,
)
}
if machine.Expiry != nil {
machineProto.Expiry = timestamppb.New(*machine.Expiry)
}
return machineProto
}
2021-11-13 01:39:04 -07:00
// RegisterMachine is executed from the CLI to register a new Machine using its MachineKey.
func (h *Headscale) RegisterMachine(
key string,
namespaceName string,
) (*Machine, error) {
namespace, err := h.GetNamespace(namespaceName)
if err != nil {
return nil, err
}
machineKey, err := wgkey.ParseHex(key)
if err != nil {
return nil, err
}
machine := Machine{}
if result := h.db.First(&machine, "machine_key = ?", machineKey.HexString()); errors.Is(
2021-11-13 01:36:45 -07:00
result.Error,
gorm.ErrRecordNotFound,
) {
2021-11-15 12:18:14 -07:00
return nil, errMachineNotFound
}
log.Trace().
Caller().
Str("machine", machine.Name).
Msg("Attempting to register machine")
2021-11-22 10:21:56 -07:00
if machine.isRegistered() {
2021-11-15 12:18:14 -07:00
err := errMachineAlreadyRegistered
log.Error().
Caller().
Err(err).
Str("machine", machine.Name).
Msg("Attempting to register machine")
return nil, err
}
ip, err := h.getAvailableIP()
if err != nil {
log.Error().
Caller().
Err(err).
Str("machine", machine.Name).
Msg("Could not find IP for the new machine")
2021-11-14 08:46:09 -07:00
return nil, err
}
log.Trace().
Caller().
Str("machine", machine.Name).
Str("ip", ip.String()).
Msg("Found IP for host")
machine.IPAddress = ip.String()
machine.NamespaceID = namespace.ID
machine.Registered = true
2021-11-18 10:51:54 -07:00
machine.RegisterMethod = RegisterMethodCLI
h.db.Save(&machine)
log.Trace().
Caller().
Str("machine", machine.Name).
Str("ip", ip.String()).
Msg("Machine registered with the database")
return &machine, nil
}
func (machine *Machine) GetAdvertisedRoutes() ([]netaddr.IPPrefix, error) {
hostInfo, err := machine.GetHostInfo()
if err != nil {
return nil, err
}
2021-11-14 08:46:09 -07:00
return hostInfo.RoutableIPs, nil
}
func (machine *Machine) GetEnabledRoutes() ([]netaddr.IPPrefix, error) {
data, err := machine.EnabledRoutes.MarshalJSON()
if err != nil {
return nil, err
}
routesStr := []string{}
err = json.Unmarshal(data, &routesStr)
if err != nil {
return nil, err
}
routes := make([]netaddr.IPPrefix, len(routesStr))
for index, routeStr := range routesStr {
route, err := netaddr.ParseIPPrefix(routeStr)
if err != nil {
return nil, err
}
routes[index] = route
}
return routes, nil
}
func (machine *Machine) IsRoutesEnabled(routeStr string) bool {
route, err := netaddr.ParseIPPrefix(routeStr)
if err != nil {
return false
}
enabledRoutes, err := machine.GetEnabledRoutes()
if err != nil {
return false
}
for _, enabledRoute := range enabledRoutes {
if route == enabledRoute {
return true
}
}
2021-11-14 08:46:09 -07:00
return false
}
// EnableNodeRoute enables new routes based on a list of new routes. It will _replace_ the
// previous list of routes.
func (h *Headscale) EnableRoutes(machine *Machine, routeStrs ...string) error {
newRoutes := make([]netaddr.IPPrefix, len(routeStrs))
for index, routeStr := range routeStrs {
route, err := netaddr.ParseIPPrefix(routeStr)
if err != nil {
return err
}
newRoutes[index] = route
}
availableRoutes, err := machine.GetAdvertisedRoutes()
if err != nil {
return err
}
for _, newRoute := range newRoutes {
if !containsIPPrefix(availableRoutes, newRoute) {
2021-11-13 01:36:45 -07:00
return fmt.Errorf(
2021-11-15 12:18:14 -07:00
"route (%s) is not available on node %s: %w",
machine.Name,
2021-11-15 12:18:14 -07:00
newRoute, errMachineRouteIsNotAvailable,
2021-11-13 01:36:45 -07:00
)
}
}
routes, err := json.Marshal(newRoutes)
if err != nil {
return err
}
machine.EnabledRoutes = datatypes.JSON(routes)
h.db.Save(&machine)
err = h.RequestMapUpdates(machine.NamespaceID)
if err != nil {
return err
}
return nil
}
func (machine *Machine) RoutesToProto() (*v1.Routes, error) {
availableRoutes, err := machine.GetAdvertisedRoutes()
if err != nil {
return nil, err
}
enabledRoutes, err := machine.GetEnabledRoutes()
if err != nil {
return nil, err
}
return &v1.Routes{
AdvertisedRoutes: ipPrefixToString(availableRoutes),
EnabledRoutes: ipPrefixToString(enabledRoutes),
}, nil
}