2023-05-21 10:37:59 -06:00
|
|
|
package db
|
2020-06-21 04:32:08 -06:00
|
|
|
|
|
|
|
import (
|
2022-04-16 04:20:58 -06:00
|
|
|
"errors"
|
2020-06-21 04:32:08 -06:00
|
|
|
"fmt"
|
2022-09-01 16:04:31 -06:00
|
|
|
"net/netip"
|
2021-02-21 16:53:37 -07:00
|
|
|
"sort"
|
2021-10-02 15:03:34 -06:00
|
|
|
"strings"
|
2020-06-21 04:32:08 -06:00
|
|
|
"time"
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
"github.com/juanfont/headscale/hscontrol/types"
|
2023-05-11 01:09:18 -06:00
|
|
|
"github.com/juanfont/headscale/hscontrol/util"
|
|
|
|
"github.com/patrickmn/go-cache"
|
2021-08-05 11:11:26 -06:00
|
|
|
"github.com/rs/zerolog/log"
|
2022-11-24 09:00:40 -07:00
|
|
|
"gorm.io/gorm"
|
2021-11-26 16:30:42 -07:00
|
|
|
"tailscale.com/types/key"
|
2020-06-21 04:32:08 -06:00
|
|
|
)
|
|
|
|
|
2021-11-15 12:18:14 -07:00
|
|
|
const (
|
2022-09-18 03:37:38 -06:00
|
|
|
MachineGivenNameHashLength = 8
|
|
|
|
MachineGivenNameTrimSize = 2
|
2022-02-23 06:21:46 -07:00
|
|
|
)
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
var (
|
|
|
|
ErrMachineNotFound = errors.New("machine not found")
|
|
|
|
ErrMachineRouteIsNotAvailable = errors.New("route is not available on machine")
|
|
|
|
ErrMachineNotFoundRegistrationCache = errors.New(
|
|
|
|
"machine not found in registration cache",
|
|
|
|
)
|
|
|
|
ErrCouldNotConvertMachineInterface = errors.New("failed to convert machine interface")
|
|
|
|
ErrDifferentRegisteredUser = errors.New(
|
|
|
|
"machine was previously registered with a different user",
|
|
|
|
)
|
2021-11-15 12:18:14 -07:00
|
|
|
)
|
|
|
|
|
2023-05-26 04:26:34 -06:00
|
|
|
// ListPeers returns all peers of machine, regardless of any Policy.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) ListPeers(machine *types.Machine) (types.Machines, error) {
|
2021-10-02 15:03:34 -06:00
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2022-04-24 13:54:38 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2021-10-04 11:39:01 -06:00
|
|
|
Msg("Finding direct peers")
|
2021-02-23 12:10:58 -07:00
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
machines := types.Machines{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if err := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
Where("node_key <> ?",
|
|
|
|
machine.NodeKey).Find(&machines).Error; err != nil {
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
return types.Machines{}, err
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
|
|
|
|
2021-10-04 11:39:01 -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
|
|
|
|
2021-10-02 15:03:34 -06:00
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2022-04-24 13:54:38 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2022-02-25 02:26:34 -07:00
|
|
|
Msgf("Found peers: %s", machines.String())
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-10-04 11:39:01 -06:00
|
|
|
return machines, nil
|
2020-06-21 04:32:08 -06:00
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) ListMachines() ([]types.Machine, error) {
|
|
|
|
machines := []types.Machine{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if err := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
Find(&machines).Error; err != nil {
|
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return nil, err
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return machines, nil
|
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) ListMachinesByGivenName(givenName string) (types.Machines, error) {
|
|
|
|
machines := types.Machines{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if err := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
Where("given_name = ?", givenName).Find(&machines).Error; err != nil {
|
|
|
|
|
2022-10-21 06:42:37 -06:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return machines, nil
|
|
|
|
}
|
|
|
|
|
2023-01-17 09:43:44 -07:00
|
|
|
// GetMachine finds a Machine by name and user and returns the Machine struct.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) GetMachine(user string, name string) (*types.Machine, error) {
|
2023-05-11 01:09:18 -06:00
|
|
|
machines, err := hsdb.ListMachinesByUser(user)
|
2021-03-14 04:38:42 -06:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
for _, m := range machines {
|
2022-04-24 13:54:38 -06:00
|
|
|
if m.Hostname == name {
|
2021-03-14 04:38:42 -06:00
|
|
|
return &m, nil
|
|
|
|
}
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-07-29 09:35:21 -06:00
|
|
|
return nil, ErrMachineNotFound
|
2021-03-14 04:38:42 -06:00
|
|
|
}
|
|
|
|
|
2023-01-17 09:43:44 -07:00
|
|
|
// GetMachineByGivenName finds a Machine by given name and user and returns the Machine struct.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) GetMachineByGivenName(
|
|
|
|
user string,
|
|
|
|
givenName string,
|
|
|
|
) (*types.Machine, error) {
|
2023-05-11 01:09:18 -06:00
|
|
|
machines, err := hsdb.ListMachinesByUser(user)
|
2022-08-31 05:41:01 -06:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, m := range machines {
|
|
|
|
if m.GivenName == givenName {
|
|
|
|
return &m, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, ErrMachineNotFound
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// GetMachineByID finds a Machine by ID and returns the Machine struct.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) GetMachineByID(id uint64) (*types.Machine, error) {
|
|
|
|
m := types.Machine{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if result := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
Find(&types.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
|
|
|
|
}
|
|
|
|
|
2022-08-10 05:15:31 -06:00
|
|
|
// GetMachineByMachineKey finds a Machine by its MachineKey and returns the Machine struct.
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) GetMachineByMachineKey(
|
2021-11-26 16:30:42 -07:00
|
|
|
machineKey key.MachinePublic,
|
2023-05-21 10:37:59 -06:00
|
|
|
) (*types.Machine, error) {
|
|
|
|
m := types.Machine{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if result := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
First(&m, "machine_key = ?", util.MachinePublicKeyStripPrefix(machineKey)); result.Error != nil {
|
2021-10-02 14:58:28 -06:00
|
|
|
return nil, result.Error
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-10-02 14:58:28 -06:00
|
|
|
return &m, nil
|
|
|
|
}
|
|
|
|
|
2022-08-10 08:03:33 -06:00
|
|
|
// GetMachineByNodeKey finds a Machine by its current NodeKey.
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) GetMachineByNodeKey(
|
2022-08-10 05:15:31 -06:00
|
|
|
nodeKey key.NodePublic,
|
2023-05-21 10:37:59 -06:00
|
|
|
) (*types.Machine, error) {
|
|
|
|
machine := types.Machine{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if result := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
First(&machine, "node_key = ?",
|
|
|
|
util.NodePublicKeyStripPrefix(nodeKey)); result.Error != nil {
|
2022-08-10 05:15:31 -06:00
|
|
|
return nil, result.Error
|
|
|
|
}
|
|
|
|
|
|
|
|
return &machine, nil
|
|
|
|
}
|
|
|
|
|
2022-12-09 09:56:43 -07:00
|
|
|
// GetMachineByAnyNodeKey finds a Machine by its MachineKey, its current NodeKey or the old one, and returns the Machine struct.
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) GetMachineByAnyKey(
|
2022-12-09 09:56:43 -07:00
|
|
|
machineKey key.MachinePublic, nodeKey key.NodePublic, oldNodeKey key.NodePublic,
|
2023-05-21 10:37:59 -06:00
|
|
|
) (*types.Machine, error) {
|
|
|
|
machine := types.Machine{}
|
2023-05-31 01:59:15 -06:00
|
|
|
if result := hsdb.db.
|
|
|
|
Preload("AuthKey").
|
|
|
|
Preload("AuthKey.User").
|
|
|
|
Preload("User").
|
|
|
|
Preload("Routes").
|
|
|
|
First(&machine, "machine_key = ? OR node_key = ? OR node_key = ?",
|
|
|
|
util.MachinePublicKeyStripPrefix(machineKey),
|
|
|
|
util.NodePublicKeyStripPrefix(nodeKey),
|
|
|
|
util.NodePublicKeyStripPrefix(oldNodeKey)); result.Error != nil {
|
2022-08-13 13:03:02 -06:00
|
|
|
return nil, result.Error
|
|
|
|
}
|
|
|
|
|
|
|
|
return &machine, nil
|
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
// TODO(kradalby): rename this, it sounds like a mix of getting and setting to db
|
2022-05-30 04:18:23 -06:00
|
|
|
// UpdateMachineFromDatabase takes a Machine struct pointer (typically already loaded from database
|
2021-08-23 00:35:44 -06:00
|
|
|
// and updates it with the latest data from the database.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) UpdateMachineFromDatabase(machine *types.Machine) error {
|
2023-05-11 01:09:18 -06:00
|
|
|
if result := hsdb.db.Find(machine).First(&machine); result.Error != nil {
|
2021-08-18 16:17:38 -06:00
|
|
|
return result.Error
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-08-18 16:17:38 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-04-25 13:16:14 -06:00
|
|
|
// SetTags takes a Machine struct pointer and update the forced tags.
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) SetTags(
|
2023-05-21 10:37:59 -06:00
|
|
|
machine *types.Machine,
|
2023-05-11 01:09:18 -06:00
|
|
|
tags []string,
|
2023-05-21 10:37:59 -06:00
|
|
|
) error {
|
2022-07-25 02:54:51 -06:00
|
|
|
newTags := []string{}
|
|
|
|
for _, tag := range tags {
|
2023-05-11 01:09:18 -06:00
|
|
|
if !util.StringOrPrefixListContains(newTags, tag) {
|
2022-07-25 02:54:51 -06:00
|
|
|
newTags = append(newTags, tag)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
machine.ForcedTags = newTags
|
2022-05-30 07:31:06 -06:00
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
hsdb.notifyPolicyChan <- struct{}{}
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.notifyStateChange()
|
|
|
|
|
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
2022-05-30 07:31:06 -06:00
|
|
|
return fmt.Errorf("failed to update tags for machine in the database: %w", err)
|
|
|
|
}
|
2022-04-15 05:11:41 -06:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-11-21 06:40:19 -07:00
|
|
|
// ExpireMachine takes a Machine struct and sets the expire field to now.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) ExpireMachine(machine *types.Machine) error {
|
2021-11-21 06:40:19 -07:00
|
|
|
now := time.Now()
|
|
|
|
machine.Expiry = &now
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.notifyStateChange()
|
2021-11-22 12:51:16 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
2022-05-30 07:31:06 -06:00
|
|
|
return fmt.Errorf("failed to expire machine in the database: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2021-11-21 06:40:19 -07:00
|
|
|
}
|
|
|
|
|
2022-04-24 14:10:50 -06:00
|
|
|
// RenameMachine takes a Machine struct and a new GivenName for the machines
|
|
|
|
// and renames it.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) RenameMachine(machine *types.Machine, newName string) error {
|
|
|
|
err := util.CheckForFQDNRules(
|
2022-03-13 15:55:36 -06:00
|
|
|
newName,
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Str("func", "RenameMachine").
|
2022-04-24 13:54:38 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2022-03-13 15:55:36 -06:00
|
|
|
Str("newName", newName).
|
|
|
|
Err(err)
|
|
|
|
|
2022-04-24 13:54:38 -06:00
|
|
|
return err
|
2022-03-13 15:55:36 -06:00
|
|
|
}
|
2022-04-24 13:54:38 -06:00
|
|
|
machine.GivenName = newName
|
2022-03-13 15:03:20 -06:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.notifyStateChange()
|
2022-03-13 15:03:20 -06:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
2022-05-31 02:18:13 -06:00
|
|
|
return fmt.Errorf("failed to rename machine in the database: %w", err)
|
|
|
|
}
|
2022-04-24 13:54:38 -06:00
|
|
|
|
|
|
|
return nil
|
2022-03-13 15:03:20 -06:00
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
// RefreshMachine takes a Machine struct and a new expiry time.
|
|
|
|
func (hsdb *HSDatabase) RefreshMachine(machine *types.Machine, expiry time.Time) error {
|
2021-11-22 12:32:11 -07:00
|
|
|
now := time.Now()
|
|
|
|
|
|
|
|
machine.LastSuccessfulUpdate = &now
|
|
|
|
machine.Expiry = &expiry
|
2021-11-22 12:51:16 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.notifyStateChange()
|
2021-11-22 12:51:16 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
2022-05-31 03:03:08 -06:00
|
|
|
return fmt.Errorf(
|
|
|
|
"failed to refresh machine (update expiration) in the database: %w",
|
|
|
|
err,
|
|
|
|
)
|
2022-05-30 07:31:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2021-11-22 12:32:11 -07:00
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// DeleteMachine softs deletes a Machine from the database.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) DeleteMachine(machine *types.Machine) error {
|
2023-05-11 01:09:18 -06:00
|
|
|
err := hsdb.DeleteMachineRoutes(machine)
|
2023-03-06 01:05:40 -07:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Delete(&machine).Error; err != nil {
|
2021-07-16 16:14:22 -06:00
|
|
|
return err
|
|
|
|
}
|
2021-07-25 09:59:48 -06:00
|
|
|
|
2022-02-12 14:04:00 -07:00
|
|
|
return nil
|
2021-07-16 16:14:22 -06:00
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) TouchMachine(machine *types.Machine) error {
|
|
|
|
return hsdb.db.Updates(types.Machine{
|
2022-01-16 03:59:03 -07:00
|
|
|
ID: machine.ID,
|
|
|
|
LastSeen: machine.LastSeen,
|
|
|
|
LastSuccessfulUpdate: machine.LastSuccessfulUpdate,
|
|
|
|
}).Error
|
|
|
|
}
|
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// HardDeleteMachine hard deletes a Machine from the database.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) HardDeleteMachine(machine *types.Machine) error {
|
2023-05-11 01:09:18 -06:00
|
|
|
err := hsdb.DeleteMachineRoutes(machine)
|
2023-03-06 01:05:40 -07:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Unscoped().Delete(&machine).Error; err != nil {
|
2021-07-16 16:14:22 -06:00
|
|
|
return err
|
|
|
|
}
|
2021-10-10 15:55:03 -06:00
|
|
|
|
2022-02-12 14:04:00 -07:00
|
|
|
return nil
|
2021-07-16 16:14:22 -06:00
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) IsOutdated(machine *types.Machine, lastChange time.Time) bool {
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.UpdateMachineFromDatabase(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.
|
2021-08-19 11:05:33 -06:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2023-01-17 09:43:44 -07:00
|
|
|
// Get the last update from all headscale users to compare with our nodes
|
2022-05-30 04:39:41 -06:00
|
|
|
// last update.
|
2023-01-17 09:43:44 -07:00
|
|
|
// TODO(kradalby): Only request updates from users where we can talk to nodes
|
2022-05-30 04:39:41 -06:00
|
|
|
// This would mostly be for a bit of performance, and can be calculated based on
|
|
|
|
// ACLs.
|
2022-01-15 08:20:14 -07:00
|
|
|
lastUpdate := machine.CreatedAt
|
|
|
|
if machine.LastSuccessfulUpdate != nil {
|
|
|
|
lastUpdate = *machine.LastSuccessfulUpdate
|
|
|
|
}
|
2021-08-18 16:17:38 -06:00
|
|
|
log.Trace().
|
2021-11-04 16:11:38 -06:00
|
|
|
Caller().
|
2022-04-24 13:54:38 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-15 08:20:14 -07:00
|
|
|
Time("last_successful_update", lastChange).
|
|
|
|
Time("last_state_change", lastUpdate).
|
2022-04-24 13:54:38 -06:00
|
|
|
Msgf("Checking if %s is missing updates", machine.Hostname)
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-01-15 08:20:14 -07:00
|
|
|
return lastUpdate.Before(lastChange)
|
2021-08-18 16:17:38 -06:00
|
|
|
}
|
2021-10-02 15:03:34 -06:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) RegisterMachineFromAuthCallback(
|
|
|
|
cache *cache.Cache,
|
2022-08-10 05:15:31 -06:00
|
|
|
nodeKeyStr string,
|
2023-01-17 09:43:44 -07:00
|
|
|
userName string,
|
2022-12-14 17:10:26 -07:00
|
|
|
machineExpiry *time.Time,
|
2022-02-28 01:06:39 -07:00
|
|
|
registrationMethod string,
|
2023-05-21 10:37:59 -06:00
|
|
|
) (*types.Machine, error) {
|
2022-11-05 02:07:22 -06:00
|
|
|
nodeKey := key.NodePublic{}
|
|
|
|
err := nodeKey.UnmarshalText([]byte(nodeKeyStr))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2022-12-09 09:56:43 -07:00
|
|
|
log.Debug().
|
|
|
|
Str("nodeKey", nodeKey.ShortString()).
|
2023-01-17 09:43:44 -07:00
|
|
|
Str("userName", userName).
|
2022-12-09 09:56:43 -07:00
|
|
|
Str("registrationMethod", registrationMethod).
|
2023-01-11 05:21:30 -07:00
|
|
|
Str("expiresAt", fmt.Sprintf("%v", machineExpiry)).
|
2022-12-09 09:56:43 -07:00
|
|
|
Msg("Registering machine from API/CLI or auth callback")
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if machineInterface, ok := cache.Get(util.NodePublicKeyStripPrefix(nodeKey)); ok {
|
2023-05-21 10:37:59 -06:00
|
|
|
if registrationMachine, ok := machineInterface.(types.Machine); ok {
|
2023-05-11 01:09:18 -06:00
|
|
|
user, err := hsdb.GetUser(userName)
|
2022-02-28 09:34:28 -07:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf(
|
2023-01-17 09:43:44 -07:00
|
|
|
"failed to find user in register machine from auth callback, %w",
|
2022-02-28 09:34:28 -07:00
|
|
|
err,
|
|
|
|
)
|
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2023-01-17 09:43:44 -07:00
|
|
|
// Registration of expired machine with different user
|
2022-09-18 03:37:38 -06:00
|
|
|
if registrationMachine.ID != 0 &&
|
2023-01-17 09:43:44 -07:00
|
|
|
registrationMachine.UserID != user.ID {
|
|
|
|
return nil, ErrDifferentRegisteredUser
|
2022-08-19 04:38:39 -06:00
|
|
|
}
|
|
|
|
|
2023-01-17 09:43:44 -07:00
|
|
|
registrationMachine.UserID = user.ID
|
2022-02-28 09:34:28 -07:00
|
|
|
registrationMachine.RegisterMethod = registrationMethod
|
2021-11-26 16:30:42 -07:00
|
|
|
|
2022-12-14 17:10:26 -07:00
|
|
|
if machineExpiry != nil {
|
|
|
|
registrationMachine.Expiry = machineExpiry
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
machine, err := hsdb.RegisterMachine(
|
2022-02-28 09:34:28 -07:00
|
|
|
registrationMachine,
|
2022-02-28 01:06:39 -07:00
|
|
|
)
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2022-08-19 04:38:39 -06:00
|
|
|
if err == nil {
|
2023-05-11 01:09:18 -06:00
|
|
|
cache.Delete(nodeKeyStr)
|
2022-08-19 04:38:39 -06:00
|
|
|
}
|
|
|
|
|
2022-02-28 01:06:39 -07:00
|
|
|
return machine, err
|
|
|
|
} else {
|
2022-07-29 09:35:21 -06:00
|
|
|
return nil, ErrCouldNotConvertMachineInterface
|
2021-11-22 12:32:52 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-29 09:35:21 -06:00
|
|
|
return nil, ErrMachineNotFoundRegistrationCache
|
2022-02-28 01:06:39 -07:00
|
|
|
}
|
2021-11-22 12:32:52 -07:00
|
|
|
|
2021-11-13 01:39:04 -07:00
|
|
|
// RegisterMachine is executed from the CLI to register a new Machine using its MachineKey.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) RegisterMachine(machine types.Machine,
|
|
|
|
) (*types.Machine, error) {
|
2022-12-09 09:56:43 -07:00
|
|
|
log.Debug().
|
|
|
|
Str("machine", machine.Hostname).
|
2022-02-28 09:34:28 -07:00
|
|
|
Str("machine_key", machine.MachineKey).
|
2022-12-09 09:56:43 -07:00
|
|
|
Str("node_key", machine.NodeKey).
|
2023-01-17 09:43:44 -07:00
|
|
|
Str("user", machine.User.Name).
|
2021-11-26 16:30:42 -07:00
|
|
|
Msg("Registering machine")
|
2021-11-22 12:32:52 -07:00
|
|
|
|
2022-12-09 09:56:43 -07:00
|
|
|
// If the machine exists and we had already IPs for it, we just save it
|
|
|
|
// so we store the machine.Expire and machine.Nodekey that has been set when
|
|
|
|
// adding it to the registrationCache
|
|
|
|
if len(machine.IPAddresses) > 0 {
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Save(&machine).Error; err != nil {
|
2022-12-09 09:56:43 -07:00
|
|
|
return nil, fmt.Errorf("failed register existing machine in the database: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Trace().
|
|
|
|
Caller().
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("machine_key", machine.MachineKey).
|
|
|
|
Str("node_key", machine.NodeKey).
|
2023-01-17 09:43:44 -07:00
|
|
|
Str("user", machine.User.Name).
|
2022-12-09 09:56:43 -07:00
|
|
|
Msg("Machine authorized again")
|
|
|
|
|
|
|
|
return &machine, nil
|
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.ipAllocationMutex.Lock()
|
|
|
|
defer hsdb.ipAllocationMutex.Unlock()
|
2022-02-24 06:18:18 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
ips, err := hsdb.getAvailableIPs()
|
2021-11-04 16:11:38 -06:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
2022-04-24 13:54:38 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2021-11-04 16:11:38 -06:00
|
|
|
Msg("Could not find IP for the new machine")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2022-01-16 06:16:59 -07:00
|
|
|
machine.IPAddresses = ips
|
2022-02-27 10:40:10 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
if err := hsdb.db.Save(&machine).Error; err != nil {
|
2022-05-30 07:31:06 -06:00
|
|
|
return nil, fmt.Errorf("failed register(save) machine in the database: %w", err)
|
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
log.Trace().
|
|
|
|
Caller().
|
2022-04-24 13:54:38 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2023-05-31 01:59:37 -06:00
|
|
|
Str("ip", strings.Join(ips.StringSlice(), ",")).
|
2021-11-04 16:11:38 -06:00
|
|
|
Msg("Machine registered with the database")
|
|
|
|
|
2022-02-28 09:34:28 -07:00
|
|
|
return &machine, nil
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
// MachineSetNodeKey sets the node key of a machine and saves it to the database.
|
|
|
|
func (hsdb *HSDatabase) MachineSetNodeKey(machine *types.Machine, nodeKey key.NodePublic) error {
|
|
|
|
machine.NodeKey = util.NodePublicKeyStripPrefix(nodeKey)
|
|
|
|
|
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// MachineSetMachineKey sets the machine key of a machine and saves it to the database.
|
|
|
|
func (hsdb *HSDatabase) MachineSetMachineKey(
|
|
|
|
machine *types.Machine,
|
|
|
|
nodeKey key.MachinePublic,
|
|
|
|
) error {
|
|
|
|
machine.MachineKey = util.MachinePublicKeyStripPrefix(nodeKey)
|
|
|
|
|
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// MachineSave saves a machine object to the database, prefer to use a specific save method rather
|
|
|
|
// than this. It is intended to be used when we are changing or.
|
|
|
|
func (hsdb *HSDatabase) MachineSave(machine *types.Machine) error {
|
|
|
|
if err := hsdb.db.Save(machine).Error; err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
// GetAdvertisedRoutes returns the routes that are be advertised by the given machine.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) GetAdvertisedRoutes(machine *types.Machine) ([]netip.Prefix, error) {
|
|
|
|
routes := types.Routes{}
|
2022-11-24 09:00:40 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
err := hsdb.db.
|
2022-11-24 09:00:40 -07:00
|
|
|
Preload("Machine").
|
|
|
|
Where("machine_id = ? AND advertised = ?", machine.ID, true).Find(&routes).Error
|
|
|
|
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("Could not get advertised routes for machine")
|
2022-11-25 08:29:45 -07:00
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
prefixes := []netip.Prefix{}
|
|
|
|
for _, route := range routes {
|
|
|
|
prefixes = append(prefixes, netip.Prefix(route.Prefix))
|
|
|
|
}
|
|
|
|
|
|
|
|
return prefixes, nil
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
// GetEnabledRoutes returns the routes that are enabled for the machine.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) GetEnabledRoutes(machine *types.Machine) ([]netip.Prefix, error) {
|
|
|
|
routes := types.Routes{}
|
2022-11-24 09:00:40 -07:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
err := hsdb.db.
|
2022-11-24 09:00:40 -07:00
|
|
|
Preload("Machine").
|
|
|
|
Where("machine_id = ? AND advertised = ? AND enabled = ?", machine.ID, true, true).
|
|
|
|
Find(&routes).Error
|
|
|
|
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("Could not get enabled routes for machine")
|
2022-11-25 08:29:45 -07:00
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
prefixes := []netip.Prefix{}
|
|
|
|
for _, route := range routes {
|
|
|
|
prefixes = append(prefixes, netip.Prefix(route.Prefix))
|
|
|
|
}
|
|
|
|
|
|
|
|
return prefixes, nil
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) IsRoutesEnabled(machine *types.Machine, routeStr string) bool {
|
2022-09-01 16:04:31 -06:00
|
|
|
route, err := netip.ParsePrefix(routeStr)
|
2021-11-04 16:11:38 -06:00
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
enabledRoutes, err := hsdb.GetEnabledRoutes(machine)
|
2022-11-24 09:00:40 -07:00
|
|
|
if err != nil {
|
|
|
|
log.Error().Err(err).Msg("Could not get enabled routes")
|
2022-11-25 08:29:45 -07:00
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
return false
|
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
|
|
|
for _, enabledRoute := range enabledRoutes {
|
|
|
|
if route == enabledRoute {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2023-01-22 15:39:42 -07:00
|
|
|
// enableRoutes enables new routes based on a list of new routes.
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) enableRoutes(machine *types.Machine, routeStrs ...string) error {
|
2022-09-01 16:04:31 -06:00
|
|
|
newRoutes := make([]netip.Prefix, len(routeStrs))
|
2021-11-04 16:11:38 -06:00
|
|
|
for index, routeStr := range routeStrs {
|
2022-09-01 16:04:31 -06:00
|
|
|
route, err := netip.ParsePrefix(routeStr)
|
2021-11-04 16:11:38 -06:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
newRoutes[index] = route
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
advertisedRoutes, err := hsdb.GetAdvertisedRoutes(machine)
|
2022-11-24 09:00:40 -07:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
for _, newRoute := range newRoutes {
|
2023-05-11 01:09:18 -06:00
|
|
|
if !util.StringOrPrefixListContains(advertisedRoutes, 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",
|
2022-04-24 13:54:38 -06:00
|
|
|
machine.Hostname,
|
2022-07-29 09:35:21 -06:00
|
|
|
newRoute, ErrMachineRouteIsNotAvailable,
|
2021-11-13 01:36:45 -07:00
|
|
|
)
|
2021-11-04 16:11:38 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
// Separate loop so we don't leave things in a half-updated state
|
|
|
|
for _, prefix := range newRoutes {
|
2023-05-21 10:37:59 -06:00
|
|
|
route := types.Route{}
|
2023-05-11 01:09:18 -06:00
|
|
|
err := hsdb.db.Preload("Machine").
|
2023-05-21 10:37:59 -06:00
|
|
|
Where("machine_id = ? AND prefix = ?", machine.ID, types.IPPrefix(prefix)).
|
2022-11-24 09:00:40 -07:00
|
|
|
First(&route).Error
|
|
|
|
if err == nil {
|
|
|
|
route.Enabled = true
|
2022-05-30 07:31:06 -06:00
|
|
|
|
2022-11-24 09:00:40 -07:00
|
|
|
// Mark already as primary if there is only this node offering this subnet
|
|
|
|
// (and is not an exit route)
|
2023-05-21 10:37:59 -06:00
|
|
|
if !route.IsExitRoute() {
|
2023-05-11 01:09:18 -06:00
|
|
|
route.IsPrimary = hsdb.isUniquePrefix(route)
|
2022-11-24 09:00:40 -07:00
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
err = hsdb.db.Save(&route).Error
|
2022-11-24 09:00:40 -07:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to enable route: %w", err)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return fmt.Errorf("failed to find route: %w", err)
|
|
|
|
}
|
2022-05-30 07:31:06 -06:00
|
|
|
}
|
2021-11-04 16:11:38 -06:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.notifyStateChange()
|
2022-12-20 14:03:15 -07:00
|
|
|
|
2021-11-04 16:11:38 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) generateGivenName(suppliedName string, randomSuffix bool) (string, error) {
|
2023-05-21 10:37:59 -06:00
|
|
|
normalizedHostname, err := util.NormalizeToFQDNRules(
|
2022-05-16 12:30:43 -06:00
|
|
|
suppliedName,
|
2023-05-11 01:09:18 -06:00
|
|
|
hsdb.stripEmailDomain,
|
2022-05-16 12:30:43 -06:00
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2022-08-31 05:41:01 -06:00
|
|
|
if randomSuffix {
|
|
|
|
// Trim if a hostname will be longer than 63 chars after adding the hash.
|
2023-05-21 10:37:59 -06:00
|
|
|
trimmedHostnameLength := util.LabelHostnameLength - MachineGivenNameHashLength - MachineGivenNameTrimSize
|
2022-08-31 05:41:01 -06:00
|
|
|
if len(normalizedHostname) > trimmedHostnameLength {
|
|
|
|
normalizedHostname = normalizedHostname[:trimmedHostnameLength]
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
suffix, err := util.GenerateRandomStringDNSSafe(MachineGivenNameHashLength)
|
2022-08-31 05:41:01 -06:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
normalizedHostname += "-" + suffix
|
|
|
|
}
|
|
|
|
|
|
|
|
return normalizedHostname, nil
|
|
|
|
}
|
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
func (hsdb *HSDatabase) GenerateGivenName(machineKey string, suppliedName string) (string, error) {
|
|
|
|
givenName, err := hsdb.generateGivenName(suppliedName, false)
|
2022-05-16 12:30:43 -06:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2022-08-31 05:41:01 -06:00
|
|
|
// Tailscale rules (may differ) https://tailscale.com/kb/1098/machine-names/
|
2023-05-11 01:09:18 -06:00
|
|
|
machines, err := hsdb.ListMachinesByGivenName(givenName)
|
2022-10-21 06:42:37 -06:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
2022-08-31 05:41:01 -06:00
|
|
|
|
2022-10-21 06:42:37 -06:00
|
|
|
for _, machine := range machines {
|
|
|
|
if machine.MachineKey != machineKey && machine.GivenName == givenName {
|
2023-05-11 01:09:18 -06:00
|
|
|
postfixedName, err := hsdb.generateGivenName(suppliedName, true)
|
2022-10-21 06:42:37 -06:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
givenName = postfixedName
|
|
|
|
}
|
2022-05-16 12:30:43 -06:00
|
|
|
}
|
|
|
|
|
2022-08-31 05:41:01 -06:00
|
|
|
return givenName, nil
|
2022-05-16 12:30:43 -06:00
|
|
|
}
|
2023-04-16 04:26:35 -06:00
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
func (hsdb *HSDatabase) ExpireEphemeralMachines(inactivityThreshhold time.Duration) {
|
|
|
|
users, err := hsdb.ListUsers()
|
|
|
|
if err != nil {
|
|
|
|
log.Error().Err(err).Msg("Error listing users")
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
2023-04-16 04:26:35 -06:00
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
for _, user := range users {
|
|
|
|
machines, err := hsdb.ListMachinesByUser(user.Name)
|
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Err(err).
|
|
|
|
Str("user", user.Name).
|
|
|
|
Msg("Error listing machines in user")
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
expiredFound := false
|
|
|
|
for idx, machine := range machines {
|
|
|
|
if machine.IsEphemeral() && machine.LastSeen != nil &&
|
|
|
|
time.Now().
|
|
|
|
After(machine.LastSeen.Add(inactivityThreshhold)) {
|
|
|
|
expiredFound = true
|
|
|
|
log.Info().
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("Ephemeral client removed from database")
|
|
|
|
|
|
|
|
err = hsdb.HardDeleteMachine(&machines[idx])
|
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Err(err).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("🤮 Cannot delete ephemeral machine from the database")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if expiredFound {
|
|
|
|
hsdb.notifyStateChange()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (hsdb *HSDatabase) ExpireExpiredMachines(lastChange time.Time) {
|
|
|
|
users, err := hsdb.ListUsers()
|
|
|
|
if err != nil {
|
|
|
|
log.Error().Err(err).Msg("Error listing users")
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, user := range users {
|
|
|
|
machines, err := hsdb.ListMachinesByUser(user.Name)
|
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Err(err).
|
|
|
|
Str("user", user.Name).
|
|
|
|
Msg("Error listing machines in user")
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
expiredFound := false
|
|
|
|
for index, machine := range machines {
|
|
|
|
if machine.IsExpired() &&
|
|
|
|
machine.Expiry.After(lastChange) {
|
|
|
|
expiredFound = true
|
|
|
|
|
|
|
|
err := hsdb.ExpireMachine(&machines[index])
|
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Err(err).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("name", machine.GivenName).
|
|
|
|
Msg("🤮 Cannot expire machine")
|
|
|
|
} else {
|
|
|
|
log.Info().
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("name", machine.GivenName).
|
|
|
|
Msg("Machine successfully expired")
|
|
|
|
}
|
2023-04-16 04:26:35 -06:00
|
|
|
}
|
|
|
|
}
|
2023-05-21 10:37:59 -06:00
|
|
|
|
|
|
|
if expiredFound {
|
|
|
|
hsdb.notifyStateChange()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|