2023-05-10 09:24:05 +02:00
|
|
|
package hscontrol
|
2021-08-13 10:33:50 +01:00
|
|
|
|
|
|
|
import (
|
2021-12-31 20:51:20 +01:00
|
|
|
"context"
|
|
|
|
"fmt"
|
2021-08-18 23:24:22 +01:00
|
|
|
"net/http"
|
2021-08-13 10:33:50 +01:00
|
|
|
"time"
|
|
|
|
|
2023-05-26 11:26:34 +01:00
|
|
|
"github.com/juanfont/headscale/hscontrol/mapper"
|
2023-05-21 19:37:59 +03:00
|
|
|
"github.com/juanfont/headscale/hscontrol/types"
|
2023-05-11 09:09:18 +02:00
|
|
|
"github.com/juanfont/headscale/hscontrol/util"
|
2021-08-13 10:33:50 +01:00
|
|
|
"github.com/rs/zerolog/log"
|
|
|
|
"tailscale.com/tailcfg"
|
|
|
|
)
|
|
|
|
|
2021-11-14 18:31:51 +01:00
|
|
|
const (
|
2022-07-12 12:27:28 +02:00
|
|
|
keepAliveInterval = 60 * time.Second
|
2021-11-14 18:31:51 +01:00
|
|
|
)
|
|
|
|
|
2022-05-16 14:59:46 +02:00
|
|
|
type contextKey string
|
|
|
|
|
|
|
|
const machineNameContextKey = contextKey("machineName")
|
|
|
|
|
2023-06-06 17:14:56 +02:00
|
|
|
// handlePoll is the common code for the legacy and Noise protocols to
|
2022-08-15 10:43:39 +02:00
|
|
|
// managed the poll loop.
|
2023-06-06 17:14:56 +02:00
|
|
|
func (h *Headscale) handlePoll(
|
2022-06-26 12:06:25 +02:00
|
|
|
writer http.ResponseWriter,
|
2022-09-04 15:14:12 +02:00
|
|
|
ctx context.Context,
|
2023-05-21 19:37:59 +03:00
|
|
|
machine *types.Machine,
|
2022-08-14 22:57:03 +02:00
|
|
|
mapRequest tailcfg.MapRequest,
|
|
|
|
isNoise bool,
|
2022-06-20 12:30:51 +02:00
|
|
|
) {
|
2023-06-22 10:01:17 +02:00
|
|
|
mapp := mapper.NewMapper(
|
|
|
|
h.db,
|
2023-05-26 11:26:34 +01:00
|
|
|
h.privateKey2019,
|
|
|
|
isNoise,
|
|
|
|
h.DERPMap,
|
|
|
|
h.cfg.BaseDomain,
|
|
|
|
h.cfg.DNSConfig,
|
|
|
|
h.cfg.LogTail.Enabled,
|
|
|
|
h.cfg.RandomizeClientPort,
|
|
|
|
)
|
|
|
|
|
2022-06-26 12:06:25 +02:00
|
|
|
machine.Hostname = mapRequest.Hostinfo.Hostname
|
2023-05-21 19:37:59 +03:00
|
|
|
machine.HostInfo = types.HostInfo(*mapRequest.Hostinfo)
|
2023-05-11 09:09:18 +02:00
|
|
|
machine.DiscoKey = util.DiscoPublicKeyStripPrefix(mapRequest.DiscoKey)
|
2021-08-18 23:24:22 +01:00
|
|
|
now := time.Now().UTC()
|
|
|
|
|
2023-05-21 19:37:59 +03:00
|
|
|
err := h.db.ProcessMachineRoutes(machine)
|
2022-11-24 15:59:37 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("Error processing machine routes")
|
|
|
|
}
|
|
|
|
|
2022-02-06 17:55:12 +01:00
|
|
|
// update ACLRules with peer informations (to update server tags if necessary)
|
2023-05-21 19:37:59 +03:00
|
|
|
if h.ACLPolicy != nil {
|
2022-08-24 20:53:55 +10:00
|
|
|
// update routes with peer information
|
2023-05-21 19:37:59 +03:00
|
|
|
err = h.db.EnableAutoApprovedRoutes(h.ACLPolicy, machine)
|
2022-11-25 15:29:45 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Bool("noise", isNoise).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Err(err).
|
|
|
|
Msg("Error running auto approved routes")
|
|
|
|
}
|
2022-02-06 17:55:12 +01:00
|
|
|
}
|
2022-08-24 20:53:55 +10:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
// From Tailscale client:
|
|
|
|
//
|
|
|
|
// ReadOnly is whether the client just wants to fetch the MapResponse,
|
|
|
|
// without updating their Endpoints. The Endpoints field will be ignored and
|
|
|
|
// LastSeen will not be updated and peers will not be notified of changes.
|
|
|
|
//
|
|
|
|
// The intended use is for clients to discover the DERP map at start-up
|
|
|
|
// before their first real endpoint update.
|
2022-06-26 12:06:25 +02:00
|
|
|
if !mapRequest.ReadOnly {
|
|
|
|
machine.Endpoints = mapRequest.Endpoints
|
2021-11-15 16:15:50 +00:00
|
|
|
machine.LastSeen = &now
|
2021-08-18 23:24:22 +01:00
|
|
|
}
|
2022-05-30 15:39:24 +02:00
|
|
|
|
2023-05-21 19:37:59 +03:00
|
|
|
if err := h.db.MachineSave(machine); err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMap").
|
|
|
|
Bool("noise", isNoise).
|
|
|
|
Str("node_key", machine.NodeKey).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Err(err).
|
|
|
|
Msg("Failed to persist/update machine in the database")
|
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
2022-05-30 15:39:24 +02:00
|
|
|
|
2023-05-21 19:37:59 +03:00
|
|
|
return
|
2022-05-30 15:39:24 +02:00
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2023-05-26 11:26:34 +01:00
|
|
|
mapResp, err := mapp.CreateMapResponse(mapRequest, machine, h.ACLPolicy)
|
2021-08-18 23:24:22 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-08-14 22:57:03 +02:00
|
|
|
Str("node_key", machine.NodeKey).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Err(err).
|
|
|
|
Msg("Failed to get Map response")
|
2022-06-26 12:06:25 +02:00
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// We update our peers if the client is not sending ReadOnly in the MapRequest
|
|
|
|
// so we don't distribute its initial request (it comes with
|
|
|
|
// empty endpoints to peers)
|
|
|
|
|
|
|
|
// Details on the protocol can be found in https://github.com/tailscale/tailscale/blob/main/tailcfg/tailcfg.go#L696
|
|
|
|
log.Debug().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-06-26 12:06:25 +02:00
|
|
|
Bool("readOnly", mapRequest.ReadOnly).
|
|
|
|
Bool("omitPeers", mapRequest.OmitPeers).
|
|
|
|
Bool("stream", mapRequest.Stream).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Client map request processed")
|
|
|
|
|
2022-06-26 12:06:25 +02:00
|
|
|
if mapRequest.ReadOnly {
|
2021-08-18 23:24:22 +01:00
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Client is starting up. Probably interested in a DERP map")
|
2022-06-20 12:30:51 +02:00
|
|
|
|
2022-06-26 12:06:25 +02:00
|
|
|
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
|
|
writer.WriteHeader(http.StatusOK)
|
2022-08-14 22:57:03 +02:00
|
|
|
_, err := writer.Write(mapResp)
|
2022-06-26 12:21:35 +02:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
|
|
|
Msg("Failed to write response")
|
|
|
|
}
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-08-14 22:57:03 +02:00
|
|
|
if f, ok := writer.(http.Flusher); ok {
|
|
|
|
f.Flush()
|
|
|
|
}
|
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// There has been an update to _any_ of the nodes that the other nodes would
|
|
|
|
// need to know about
|
2022-08-16 13:39:15 +02:00
|
|
|
h.setLastStateChangeToNow()
|
2021-08-18 23:24:22 +01:00
|
|
|
|
|
|
|
// The request is not ReadOnly, so we need to set up channels for updating
|
|
|
|
// peers via longpoll
|
|
|
|
|
|
|
|
// Only create update channel if it has not been created
|
|
|
|
log.Trace().
|
2022-08-14 22:57:03 +02:00
|
|
|
Caller().
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Loading or creating update channel")
|
|
|
|
|
2021-12-31 20:51:20 +01:00
|
|
|
const chanSize = 8
|
|
|
|
updateChan := make(chan struct{}, chanSize)
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2021-12-31 20:51:20 +01:00
|
|
|
pollDataChan := make(chan []byte, chanSize)
|
2022-04-24 20:55:54 +01:00
|
|
|
defer closeChanWithLog(pollDataChan, machine.Hostname, "pollDataChan")
|
2021-12-31 20:51:20 +01:00
|
|
|
|
|
|
|
keepAliveChan := make(chan []byte)
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2022-06-26 12:06:25 +02:00
|
|
|
if mapRequest.OmitPeers && !mapRequest.Stream {
|
2021-08-18 23:24:22 +01:00
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Client sent endpoint update and is ok with a response without peer list")
|
2022-06-26 12:06:25 +02:00
|
|
|
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
|
|
writer.WriteHeader(http.StatusOK)
|
2022-08-14 22:57:03 +02:00
|
|
|
_, err := writer.Write(mapResp)
|
2022-06-26 12:21:35 +02:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Err(err).
|
|
|
|
Msg("Failed to write response")
|
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
// It sounds like we should update the nodes when we have received a endpoint update
|
|
|
|
// even tho the comments in the tailscale code dont explicitly say so.
|
2023-01-17 17:43:44 +01:00
|
|
|
updateRequestsFromNode.WithLabelValues(machine.User.Name, machine.Hostname, "endpoint-update").
|
2021-11-13 08:36:45 +00:00
|
|
|
Inc()
|
2021-12-31 20:51:20 +01:00
|
|
|
updateChan <- struct{}{}
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
return
|
2022-06-26 12:06:25 +02:00
|
|
|
} else if mapRequest.OmitPeers && mapRequest.Stream {
|
2021-08-18 23:24:22 +01:00
|
|
|
log.Warn().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Ignoring request, don't know how to handle it")
|
2022-06-26 12:06:25 +02:00
|
|
|
http.Error(writer, "", http.StatusBadRequest)
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Client is ready to access the tailnet")
|
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Sending initial map")
|
2022-08-14 22:57:03 +02:00
|
|
|
pollDataChan <- mapResp
|
2021-08-18 23:24:22 +01:00
|
|
|
|
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Notifying peers")
|
2023-01-17 17:43:44 +01:00
|
|
|
updateRequestsFromNode.WithLabelValues(machine.User.Name, machine.Hostname, "full-update").
|
2021-11-13 08:36:45 +00:00
|
|
|
Inc()
|
2021-12-31 20:51:20 +01:00
|
|
|
updateChan <- struct{}{}
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2022-08-14 22:57:03 +02:00
|
|
|
h.pollNetMapStream(
|
2022-06-26 12:06:25 +02:00
|
|
|
writer,
|
2022-09-04 15:14:12 +02:00
|
|
|
ctx,
|
2022-06-26 12:06:25 +02:00
|
|
|
machine,
|
|
|
|
mapRequest,
|
2021-11-13 08:36:45 +00:00
|
|
|
pollDataChan,
|
|
|
|
keepAliveChan,
|
|
|
|
updateChan,
|
2022-08-14 22:57:03 +02:00
|
|
|
isNoise,
|
2021-11-13 08:36:45 +00:00
|
|
|
)
|
2022-08-14 22:57:03 +02:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Finished stream, closing PollNetMap session")
|
|
|
|
}
|
|
|
|
|
2022-08-14 22:57:03 +02:00
|
|
|
// pollNetMapStream stream logic for /machine/map,
|
|
|
|
// ensuring we communicate updates and data to the connected clients.
|
|
|
|
func (h *Headscale) pollNetMapStream(
|
2022-06-26 12:06:25 +02:00
|
|
|
writer http.ResponseWriter,
|
2022-09-04 15:14:12 +02:00
|
|
|
ctxReq context.Context,
|
2023-05-21 19:37:59 +03:00
|
|
|
machine *types.Machine,
|
2021-11-15 16:15:50 +00:00
|
|
|
mapRequest tailcfg.MapRequest,
|
2021-08-18 23:24:22 +01:00
|
|
|
pollDataChan chan []byte,
|
|
|
|
keepAliveChan chan []byte,
|
2021-10-05 16:17:18 +00:00
|
|
|
updateChan chan struct{},
|
2022-08-14 22:57:03 +02:00
|
|
|
isNoise bool,
|
2021-08-13 10:33:50 +01:00
|
|
|
) {
|
2023-05-26 11:26:34 +01:00
|
|
|
// TODO(kradalby): This is a stepping stone, mapper should be initiated once
|
|
|
|
// per client or something similar
|
|
|
|
mapp := mapper.NewMapper(h.db,
|
|
|
|
h.privateKey2019,
|
|
|
|
isNoise,
|
|
|
|
h.DERPMap,
|
|
|
|
h.cfg.BaseDomain,
|
|
|
|
h.cfg.DNSConfig,
|
|
|
|
h.cfg.LogTail.Enabled,
|
|
|
|
h.cfg.RandomizeClientPort,
|
|
|
|
)
|
|
|
|
|
2022-07-11 20:33:24 +02:00
|
|
|
h.pollNetMapStreamWG.Add(1)
|
|
|
|
defer h.pollNetMapStreamWG.Done()
|
2022-06-30 23:35:22 +02:00
|
|
|
|
2022-09-04 15:14:12 +02:00
|
|
|
ctx := context.WithValue(ctxReq, machineNameContextKey, machine.Hostname)
|
2022-04-10 00:37:13 +02:00
|
|
|
|
2022-06-20 12:30:51 +02:00
|
|
|
ctx, cancel := context.WithCancel(ctx)
|
|
|
|
defer cancel()
|
2022-04-10 00:37:13 +02:00
|
|
|
|
2022-06-20 12:30:51 +02:00
|
|
|
go h.scheduledPollWorker(
|
|
|
|
ctx,
|
|
|
|
updateChan,
|
|
|
|
keepAliveChan,
|
|
|
|
mapRequest,
|
|
|
|
machine,
|
2022-08-14 22:57:03 +02:00
|
|
|
isNoise,
|
2022-06-20 12:30:51 +02:00
|
|
|
)
|
2021-08-13 10:33:50 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
log.Trace().
|
2022-08-15 10:43:39 +02:00
|
|
|
Str("handler", "pollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-20 21:40:28 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("Waiting for data to stream...")
|
2021-08-13 10:33:50 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
log.Trace().
|
2022-08-15 10:43:39 +02:00
|
|
|
Str("handler", "pollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-20 21:40:28 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msgf("pollData is %#v, keepAliveChan is %#v, updateChan is %#v", pollDataChan, keepAliveChan, updateChan)
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
for {
|
2021-08-18 23:24:22 +01:00
|
|
|
select {
|
|
|
|
case data := <-pollDataChan:
|
2021-08-13 10:33:50 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "pollData").
|
2021-08-13 10:33:50 +01:00
|
|
|
Int("bytes", len(data)).
|
|
|
|
Msg("Sending data received via pollData channel")
|
2022-06-26 12:06:25 +02:00
|
|
|
_, err := writer.Write(data)
|
2021-08-13 10:33:50 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "pollData").
|
2021-08-13 10:33:50 +01:00
|
|
|
Err(err).
|
|
|
|
Msg("Cannot write data")
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
return
|
2021-08-13 10:33:50 +01:00
|
|
|
}
|
2022-06-26 12:25:26 +02:00
|
|
|
|
|
|
|
flusher, ok := writer.(http.Flusher)
|
|
|
|
if !ok {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-26 12:25:26 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("channel", "pollData").
|
|
|
|
Msg("Cannot cast writer to http.Flusher")
|
|
|
|
} else {
|
|
|
|
flusher.Flush()
|
|
|
|
}
|
2022-06-20 21:40:28 +02:00
|
|
|
|
2021-08-13 10:33:50 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "pollData").
|
2021-08-13 10:33:50 +01:00
|
|
|
Int("bytes", len(data)).
|
|
|
|
Msg("Data from pollData channel written successfully")
|
2022-07-21 23:47:59 +02:00
|
|
|
// TODO(kradalby): Abstract away all the database calls, this can cause race conditions
|
|
|
|
// when an outdated machine object is kept alive, e.g. db is update from
|
|
|
|
// command line, but then overwritten.
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.UpdateMachineFromDatabase(machine)
|
2021-08-21 16:52:19 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-21 16:52:19 +01:00
|
|
|
Str("channel", "pollData").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine from database")
|
2022-01-16 11:59:03 +01:00
|
|
|
|
|
|
|
// client has been removed from database
|
|
|
|
// since the stream opened, terminate connection.
|
2022-06-20 21:40:28 +02:00
|
|
|
return
|
2021-08-21 16:52:19 +01:00
|
|
|
}
|
2021-08-13 10:33:50 +01:00
|
|
|
now := time.Now().UTC()
|
2021-11-15 16:15:50 +00:00
|
|
|
machine.LastSeen = &now
|
2021-10-04 16:28:07 +00:00
|
|
|
|
2023-01-17 17:43:44 +01:00
|
|
|
lastStateUpdate.WithLabelValues(machine.User.Name, machine.Hostname).
|
2021-11-13 08:36:45 +00:00
|
|
|
Set(float64(now.Unix()))
|
2021-11-15 16:15:50 +00:00
|
|
|
machine.LastSuccessfulUpdate = &now
|
2021-10-04 16:28:07 +00:00
|
|
|
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.TouchMachine(machine)
|
2022-01-16 11:59:03 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-16 11:59:03 +01:00
|
|
|
Str("channel", "pollData").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine LastSuccessfulUpdate")
|
2022-06-20 21:40:28 +02:00
|
|
|
|
|
|
|
return
|
2022-01-16 11:59:03 +01:00
|
|
|
}
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-20 21:40:28 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("channel", "pollData").
|
|
|
|
Int("bytes", len(data)).
|
|
|
|
Msg("Machine entry in database updated successfully after sending data")
|
2021-08-13 10:33:50 +01:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
case data := <-keepAliveChan:
|
|
|
|
log.Trace().
|
2021-08-13 10:33:50 +01:00
|
|
|
Str("handler", "PollNetMapStream").
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "keepAlive").
|
|
|
|
Int("bytes", len(data)).
|
|
|
|
Msg("Sending keep alive message")
|
2022-06-26 12:06:25 +02:00
|
|
|
_, err := writer.Write(data)
|
2021-08-13 10:33:50 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "keepAlive").
|
2021-08-13 10:33:50 +01:00
|
|
|
Err(err).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Cannot write keep alive message")
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
return
|
2021-08-13 10:33:50 +01:00
|
|
|
}
|
2022-06-26 12:25:26 +02:00
|
|
|
flusher, ok := writer.(http.Flusher)
|
|
|
|
if !ok {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-26 12:25:26 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("channel", "keepAlive").
|
|
|
|
Msg("Cannot cast writer to http.Flusher")
|
|
|
|
} else {
|
|
|
|
flusher.Flush()
|
|
|
|
}
|
2022-06-20 21:40:28 +02:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "keepAlive").
|
|
|
|
Int("bytes", len(data)).
|
|
|
|
Msg("Keep alive sent successfully")
|
2022-07-21 23:47:59 +02:00
|
|
|
// TODO(kradalby): Abstract away all the database calls, this can cause race conditions
|
|
|
|
// when an outdated machine object is kept alive, e.g. db is update from
|
|
|
|
// command line, but then overwritten.
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.UpdateMachineFromDatabase(machine)
|
2021-08-21 16:52:19 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-21 16:52:19 +01:00
|
|
|
Str("channel", "keepAlive").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine from database")
|
2022-01-16 11:59:03 +01:00
|
|
|
|
|
|
|
// client has been removed from database
|
|
|
|
// since the stream opened, terminate connection.
|
2022-06-20 21:40:28 +02:00
|
|
|
return
|
2021-08-21 16:52:19 +01:00
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
now := time.Now().UTC()
|
2021-11-15 16:15:50 +00:00
|
|
|
machine.LastSeen = &now
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.TouchMachine(machine)
|
2022-01-16 11:59:03 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-16 11:59:03 +01:00
|
|
|
Str("channel", "keepAlive").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine LastSeen")
|
2022-06-20 21:40:28 +02:00
|
|
|
|
|
|
|
return
|
2022-01-16 11:59:03 +01:00
|
|
|
}
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-20 21:40:28 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("channel", "keepAlive").
|
|
|
|
Int("bytes", len(data)).
|
|
|
|
Msg("Machine updated successfully after sending keep alive")
|
2021-08-18 23:24:22 +01:00
|
|
|
|
|
|
|
case <-updateChan:
|
2021-08-19 18:05:33 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-19 18:05:33 +01:00
|
|
|
Str("channel", "update").
|
|
|
|
Msg("Received a request for update")
|
2023-01-17 17:43:44 +01:00
|
|
|
updateRequestsReceivedOnChannel.WithLabelValues(machine.User.Name, machine.Hostname).
|
2021-11-13 08:36:45 +00:00
|
|
|
Inc()
|
2022-06-20 21:40:28 +02:00
|
|
|
|
2023-05-21 19:37:59 +03:00
|
|
|
if h.db.IsOutdated(machine, h.getLastStateChange()) {
|
2022-01-15 16:20:14 +01:00
|
|
|
var lastUpdate time.Time
|
|
|
|
if machine.LastSuccessfulUpdate != nil {
|
|
|
|
lastUpdate = *machine.LastSuccessfulUpdate
|
|
|
|
}
|
2021-08-19 18:05:33 +01:00
|
|
|
log.Debug().
|
2021-08-13 10:33:50 +01:00
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-15 16:20:14 +01:00
|
|
|
Time("last_successful_update", lastUpdate).
|
2023-01-17 17:43:44 +01:00
|
|
|
Time("last_state_change", h.getLastStateChange(machine.User)).
|
2022-04-24 20:55:54 +01:00
|
|
|
Msgf("There has been updates since the last successful update to %s", machine.Hostname)
|
2023-05-26 11:26:34 +01:00
|
|
|
data, err := mapp.CreateMapResponse(mapRequest, machine, h.ACLPolicy)
|
2021-08-18 23:24:22 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "update").
|
|
|
|
Err(err).
|
|
|
|
Msg("Could not get the map update")
|
2022-06-20 21:40:28 +02:00
|
|
|
|
|
|
|
return
|
2021-08-18 23:24:22 +01:00
|
|
|
}
|
2022-06-26 12:06:25 +02:00
|
|
|
_, err = writer.Write(data)
|
2021-08-18 23:24:22 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "update").
|
|
|
|
Err(err).
|
|
|
|
Msg("Could not write the map response")
|
2023-01-17 17:43:44 +01:00
|
|
|
updateRequestsSentToNode.WithLabelValues(machine.User.Name, machine.Hostname, "failed").
|
2021-11-13 08:36:45 +00:00
|
|
|
Inc()
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-06-20 12:30:51 +02:00
|
|
|
return
|
2021-08-18 23:24:22 +01:00
|
|
|
}
|
2022-06-26 12:25:26 +02:00
|
|
|
|
|
|
|
flusher, ok := writer.(http.Flusher)
|
|
|
|
if !ok {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-26 12:25:26 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Str("channel", "update").
|
|
|
|
Msg("Cannot cast writer to http.Flusher")
|
|
|
|
} else {
|
|
|
|
flusher.Flush()
|
|
|
|
}
|
2022-06-25 20:47:42 +02:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 23:24:22 +01:00
|
|
|
Str("channel", "update").
|
|
|
|
Msg("Updated Map has been sent")
|
2023-01-17 17:43:44 +01:00
|
|
|
updateRequestsSentToNode.WithLabelValues(machine.User.Name, machine.Hostname, "success").
|
2021-11-13 08:36:45 +00:00
|
|
|
Inc()
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2021-10-05 21:59:15 +00:00
|
|
|
// Keep track of the last successful update,
|
|
|
|
// we sometimes end in a state were the update
|
|
|
|
// is not picked up by a client and we use this
|
|
|
|
// to determine if we should "force" an update.
|
|
|
|
// TODO(kradalby): Abstract away all the database calls, this can cause race conditions
|
|
|
|
// when an outdated machine object is kept alive, e.g. db is update from
|
|
|
|
// command line, but then overwritten.
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.UpdateMachineFromDatabase(machine)
|
2021-08-21 16:52:19 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-21 16:52:19 +01:00
|
|
|
Str("channel", "update").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine from database")
|
2022-01-16 11:59:03 +01:00
|
|
|
|
|
|
|
// client has been removed from database
|
|
|
|
// since the stream opened, terminate connection.
|
2022-06-20 12:30:51 +02:00
|
|
|
return
|
2021-08-21 16:52:19 +01:00
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
now := time.Now().UTC()
|
2021-10-04 16:28:07 +00:00
|
|
|
|
2023-01-17 17:43:44 +01:00
|
|
|
lastStateUpdate.WithLabelValues(machine.User.Name, machine.Hostname).
|
2021-11-13 08:36:45 +00:00
|
|
|
Set(float64(now.Unix()))
|
2021-11-15 16:15:50 +00:00
|
|
|
machine.LastSuccessfulUpdate = &now
|
2021-10-04 16:28:07 +00:00
|
|
|
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.TouchMachine(machine)
|
2022-01-16 11:59:03 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-16 11:59:03 +01:00
|
|
|
Str("channel", "update").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine LastSuccessfulUpdate")
|
2022-06-20 21:40:28 +02:00
|
|
|
|
|
|
|
return
|
2022-01-16 11:59:03 +01:00
|
|
|
}
|
2021-08-19 18:05:33 +01:00
|
|
|
} else {
|
2022-01-15 16:20:14 +01:00
|
|
|
var lastUpdate time.Time
|
|
|
|
if machine.LastSuccessfulUpdate != nil {
|
|
|
|
lastUpdate = *machine.LastSuccessfulUpdate
|
|
|
|
}
|
2021-08-19 18:05:33 +01:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-15 16:20:14 +01:00
|
|
|
Time("last_successful_update", lastUpdate).
|
2023-01-17 17:43:44 +01:00
|
|
|
Time("last_state_change", h.getLastStateChange(machine.User)).
|
2022-04-24 20:55:54 +01:00
|
|
|
Msgf("%s is up to date", machine.Hostname)
|
2021-08-13 10:33:50 +01:00
|
|
|
}
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2022-06-20 12:30:51 +02:00
|
|
|
case <-ctx.Done():
|
2021-08-13 10:33:50 +01:00
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-13 10:33:50 +01:00
|
|
|
Msg("The client has closed the connection")
|
2022-07-21 23:47:59 +02:00
|
|
|
// TODO: Abstract away all the database calls, this can cause race conditions
|
|
|
|
// when an outdated machine object is kept alive, e.g. db is update from
|
|
|
|
// command line, but then overwritten.
|
2023-05-11 09:09:18 +02:00
|
|
|
err := h.db.UpdateMachineFromDatabase(machine)
|
2021-08-21 16:52:19 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-21 16:52:19 +01:00
|
|
|
Str("channel", "Done").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine from database")
|
2022-01-16 11:59:03 +01:00
|
|
|
|
|
|
|
// client has been removed from database
|
|
|
|
// since the stream opened, terminate connection.
|
2022-06-20 21:40:28 +02:00
|
|
|
return
|
2021-08-21 16:52:19 +01:00
|
|
|
}
|
2021-08-13 10:33:50 +01:00
|
|
|
now := time.Now().UTC()
|
2021-11-15 16:15:50 +00:00
|
|
|
machine.LastSeen = &now
|
2023-05-11 09:09:18 +02:00
|
|
|
err = h.db.TouchMachine(machine)
|
2022-01-16 11:59:03 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-01-16 11:59:03 +01:00
|
|
|
Str("channel", "Done").
|
|
|
|
Err(err).
|
|
|
|
Msg("Cannot update machine LastSeen")
|
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2022-06-20 21:40:28 +02:00
|
|
|
// The connection has been closed, so we can stop polling.
|
|
|
|
return
|
2022-06-23 19:40:07 +02:00
|
|
|
|
|
|
|
case <-h.shutdownChan:
|
|
|
|
log.Info().
|
|
|
|
Str("handler", "PollNetMapStream").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2022-06-23 19:40:07 +02:00
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg("The long-poll handler is shutting down")
|
2022-06-26 12:06:25 +02:00
|
|
|
|
2022-06-23 19:40:07 +02:00
|
|
|
return
|
2021-08-13 10:33:50 +01:00
|
|
|
}
|
2022-06-20 12:30:51 +02:00
|
|
|
}
|
2021-08-13 10:33:50 +01:00
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2021-08-19 18:06:57 +01:00
|
|
|
func (h *Headscale) scheduledPollWorker(
|
2021-12-31 20:51:20 +01:00
|
|
|
ctx context.Context,
|
2022-04-10 00:37:13 +02:00
|
|
|
updateChan chan struct{},
|
|
|
|
keepAliveChan chan []byte,
|
2021-11-15 16:15:50 +00:00
|
|
|
mapRequest tailcfg.MapRequest,
|
2023-05-21 19:37:59 +03:00
|
|
|
machine *types.Machine,
|
2022-08-14 22:57:03 +02:00
|
|
|
isNoise bool,
|
2021-08-18 23:24:22 +01:00
|
|
|
) {
|
2023-05-26 11:26:34 +01:00
|
|
|
// TODO(kradalby): This is a stepping stone, mapper should be initiated once
|
|
|
|
// per client or something similar
|
|
|
|
mapp := mapper.NewMapper(h.db,
|
|
|
|
h.privateKey2019,
|
|
|
|
isNoise,
|
|
|
|
h.DERPMap,
|
|
|
|
h.cfg.BaseDomain,
|
|
|
|
h.cfg.DNSConfig,
|
|
|
|
h.cfg.LogTail.Enabled,
|
|
|
|
h.cfg.RandomizeClientPort,
|
|
|
|
)
|
|
|
|
|
2021-11-15 17:24:24 +00:00
|
|
|
keepAliveTicker := time.NewTicker(keepAliveInterval)
|
2022-07-12 12:52:03 +02:00
|
|
|
updateCheckerTicker := time.NewTicker(h.cfg.NodeUpdateCheckInterval)
|
2021-08-18 23:24:22 +01:00
|
|
|
|
2022-04-10 00:37:13 +02:00
|
|
|
defer closeChanWithLog(
|
|
|
|
updateChan,
|
2022-05-16 14:59:46 +02:00
|
|
|
fmt.Sprint(ctx.Value(machineNameContextKey)),
|
2022-04-10 00:37:13 +02:00
|
|
|
"updateChan",
|
|
|
|
)
|
|
|
|
defer closeChanWithLog(
|
|
|
|
keepAliveChan,
|
2022-05-16 14:59:46 +02:00
|
|
|
fmt.Sprint(ctx.Value(machineNameContextKey)),
|
2022-11-10 13:03:26 +01:00
|
|
|
"keepAliveChan",
|
2022-04-10 00:37:13 +02:00
|
|
|
)
|
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
for {
|
|
|
|
select {
|
2021-12-31 20:51:20 +01:00
|
|
|
case <-ctx.Done():
|
2021-08-18 23:24:22 +01:00
|
|
|
return
|
|
|
|
|
|
|
|
case <-keepAliveTicker.C:
|
2023-05-26 11:26:34 +01:00
|
|
|
data, err := mapp.CreateKeepAliveResponse(mapRequest, machine)
|
2021-08-18 23:24:22 +01:00
|
|
|
if err != nil {
|
|
|
|
log.Error().
|
|
|
|
Str("func", "keepAlive").
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2021-08-18 23:24:22 +01:00
|
|
|
Err(err).
|
|
|
|
Msg("Error generating the keep alive msg")
|
2021-11-14 16:46:09 +01:00
|
|
|
|
2021-08-18 23:24:22 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Debug().
|
|
|
|
Str("func", "keepAlive").
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2021-08-18 23:24:22 +01:00
|
|
|
Msg("Sending keepalive")
|
2022-12-25 19:30:52 +08:00
|
|
|
select {
|
|
|
|
case keepAliveChan <- data:
|
|
|
|
case <-ctx.Done():
|
|
|
|
return
|
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
|
|
|
|
case <-updateCheckerTicker.C:
|
2021-10-05 16:17:18 +00:00
|
|
|
log.Debug().
|
|
|
|
Str("func", "scheduledPollWorker").
|
2022-04-24 20:55:54 +01:00
|
|
|
Str("machine", machine.Hostname).
|
2022-08-14 23:11:33 +02:00
|
|
|
Bool("noise", isNoise).
|
2021-10-05 16:17:18 +00:00
|
|
|
Msg("Sending update request")
|
2023-01-17 17:43:44 +01:00
|
|
|
updateRequestsFromNode.WithLabelValues(machine.User.Name, machine.Hostname, "scheduled-update").
|
2021-11-13 08:36:45 +00:00
|
|
|
Inc()
|
2022-12-25 19:30:52 +08:00
|
|
|
select {
|
|
|
|
case updateChan <- struct{}{}:
|
|
|
|
case <-ctx.Done():
|
|
|
|
return
|
|
|
|
}
|
2021-08-18 23:24:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-04-10 00:37:13 +02:00
|
|
|
|
2022-04-25 22:33:53 +02:00
|
|
|
func closeChanWithLog[C chan []byte | chan struct{}](channel C, machine, name string) {
|
2022-04-10 00:37:13 +02:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMap").
|
|
|
|
Str("machine", machine).
|
|
|
|
Str("channel", "Done").
|
|
|
|
Msg(fmt.Sprintf("Closing %s channel", name))
|
|
|
|
|
|
|
|
close(channel)
|
|
|
|
}
|