2023-05-10 01:24:05 -06:00
|
|
|
package hscontrol
|
2021-08-13 03:33:50 -06:00
|
|
|
|
|
|
|
import (
|
2021-12-31 12:51:20 -07:00
|
|
|
"context"
|
|
|
|
"fmt"
|
2021-08-18 16:24:22 -06:00
|
|
|
"net/http"
|
2021-08-13 03:33:50 -06:00
|
|
|
"time"
|
|
|
|
|
2023-05-26 04:26:34 -06:00
|
|
|
"github.com/juanfont/headscale/hscontrol/mapper"
|
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"
|
2021-08-13 03:33:50 -06:00
|
|
|
"github.com/rs/zerolog/log"
|
|
|
|
"tailscale.com/tailcfg"
|
|
|
|
)
|
|
|
|
|
2021-11-14 10:31:51 -07:00
|
|
|
const (
|
2022-07-12 04:27:28 -06:00
|
|
|
keepAliveInterval = 60 * time.Second
|
2021-11-14 10:31:51 -07:00
|
|
|
)
|
|
|
|
|
2022-05-16 06:59:46 -06:00
|
|
|
type contextKey string
|
|
|
|
|
|
|
|
const machineNameContextKey = contextKey("machineName")
|
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
type UpdateNode func()
|
|
|
|
|
|
|
|
func logPollFunc(
|
|
|
|
mapRequest tailcfg.MapRequest,
|
|
|
|
machine *types.Machine,
|
|
|
|
isNoise bool,
|
|
|
|
) (func(string), func(error, string)) {
|
|
|
|
return func(msg string) {
|
|
|
|
log.Info().
|
|
|
|
Caller().
|
|
|
|
Bool("noise", isNoise).
|
|
|
|
Bool("readOnly", mapRequest.ReadOnly).
|
|
|
|
Bool("omitPeers", mapRequest.OmitPeers).
|
|
|
|
Bool("stream", mapRequest.Stream).
|
|
|
|
Str("node_key", machine.NodeKey).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Msg(msg)
|
|
|
|
},
|
|
|
|
func(err error, msg string) {
|
|
|
|
log.Error().
|
|
|
|
Caller().
|
|
|
|
Bool("noise", isNoise).
|
|
|
|
Bool("readOnly", mapRequest.ReadOnly).
|
|
|
|
Bool("omitPeers", mapRequest.OmitPeers).
|
|
|
|
Bool("stream", mapRequest.Stream).
|
|
|
|
Str("node_key", machine.NodeKey).
|
|
|
|
Str("machine", machine.Hostname).
|
|
|
|
Err(err).
|
|
|
|
Msg(msg)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-06 09:14:56 -06:00
|
|
|
// handlePoll is the common code for the legacy and Noise protocols to
|
2022-08-15 02:43:39 -06:00
|
|
|
// managed the poll loop.
|
2023-08-09 14:56:21 -06:00
|
|
|
//
|
|
|
|
//nolint:gocyclo
|
2023-06-06 09:14:56 -06:00
|
|
|
func (h *Headscale) handlePoll(
|
2022-06-26 04:06:25 -06:00
|
|
|
writer http.ResponseWriter,
|
2022-09-04 07:14:12 -06:00
|
|
|
ctx context.Context,
|
2023-05-21 10:37:59 -06:00
|
|
|
machine *types.Machine,
|
2022-08-14 14:57:03 -06:00
|
|
|
mapRequest tailcfg.MapRequest,
|
|
|
|
isNoise bool,
|
2022-06-20 04:30:51 -06:00
|
|
|
) {
|
2023-07-26 09:54:19 -06:00
|
|
|
// Immediate open the channel and register it if the client wants
|
|
|
|
// a stream of MapResponses to prevent initial map response and
|
|
|
|
// following updates missing
|
|
|
|
var updateChan chan types.StateUpdate
|
|
|
|
if mapRequest.Stream {
|
2023-08-09 14:56:21 -06:00
|
|
|
h.pollStreamOpenMu.Lock()
|
2023-07-26 09:54:19 -06:00
|
|
|
h.pollNetMapStreamWG.Add(1)
|
|
|
|
defer h.pollNetMapStreamWG.Done()
|
|
|
|
|
|
|
|
updateChan = make(chan types.StateUpdate)
|
|
|
|
defer closeChanWithLog(updateChan, machine.Hostname, "updateChan")
|
|
|
|
|
|
|
|
// Register the node's update channel
|
|
|
|
h.nodeNotifier.AddNode(machine.MachineKey, updateChan)
|
|
|
|
defer h.nodeNotifier.RemoveNode(machine.MachineKey)
|
|
|
|
}
|
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
logInfo, logErr := logPollFunc(mapRequest, machine, isNoise)
|
|
|
|
|
2023-08-09 14:20:05 -06:00
|
|
|
// When a node connects to control, list the peers it has at
|
|
|
|
// that given point, further updates are kept in memory in
|
|
|
|
// the Mapper, which lives for the duration of the polling
|
|
|
|
// session.
|
|
|
|
peers, err := h.db.ListPeers(machine)
|
|
|
|
if err != nil {
|
|
|
|
logErr(err, "Failed to list peers when opening poller")
|
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-06-22 02:01:17 -06:00
|
|
|
mapp := mapper.NewMapper(
|
2023-07-24 00:58:51 -06:00
|
|
|
machine,
|
2023-08-09 14:20:05 -06:00
|
|
|
peers,
|
2023-05-26 04:26:34 -06:00
|
|
|
h.privateKey2019,
|
|
|
|
isNoise,
|
|
|
|
h.DERPMap,
|
|
|
|
h.cfg.BaseDomain,
|
|
|
|
h.cfg.DNSConfig,
|
|
|
|
h.cfg.LogTail.Enabled,
|
|
|
|
h.cfg.RandomizeClientPort,
|
|
|
|
)
|
|
|
|
|
2022-06-26 04:06:25 -06:00
|
|
|
machine.Hostname = mapRequest.Hostinfo.Hostname
|
2023-05-21 10:37:59 -06:00
|
|
|
machine.HostInfo = types.HostInfo(*mapRequest.Hostinfo)
|
2023-05-11 01:09:18 -06:00
|
|
|
machine.DiscoKey = util.DiscoPublicKeyStripPrefix(mapRequest.DiscoKey)
|
2021-08-18 16:24:22 -06:00
|
|
|
now := time.Now().UTC()
|
|
|
|
|
2023-08-09 14:20:05 -06:00
|
|
|
err = h.db.SaveMachineRoutes(machine)
|
2022-11-24 08:59:37 -07:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Error processing machine routes")
|
2022-11-24 08:59:37 -07:00
|
|
|
}
|
|
|
|
|
2022-02-06 09:55:12 -07:00
|
|
|
// update ACLRules with peer informations (to update server tags if necessary)
|
2023-05-21 10:37:59 -06:00
|
|
|
if h.ACLPolicy != nil {
|
2022-08-24 04:53:55 -06:00
|
|
|
// update routes with peer information
|
2023-05-21 10:37:59 -06:00
|
|
|
err = h.db.EnableAutoApprovedRoutes(h.ACLPolicy, machine)
|
2022-11-25 08:29:45 -07:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Error running auto approved routes")
|
2022-11-25 08:29:45 -07:00
|
|
|
}
|
2022-02-06 09:55:12 -07:00
|
|
|
}
|
2022-08-24 04:53:55 -06:00
|
|
|
|
2021-08-18 16:24:22 -06: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 04:06:25 -06:00
|
|
|
if !mapRequest.ReadOnly {
|
|
|
|
machine.Endpoints = mapRequest.Endpoints
|
2021-11-15 09:15:50 -07:00
|
|
|
machine.LastSeen = &now
|
2021-08-18 16:24:22 -06:00
|
|
|
}
|
2022-05-30 07:39:24 -06:00
|
|
|
|
2023-07-17 05:35:05 -06:00
|
|
|
// TODO(kradalby): Save specific stuff, not whole object.
|
2023-05-21 10:37:59 -06:00
|
|
|
if err := h.db.MachineSave(machine); err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Failed to persist/update machine in the database")
|
2023-05-21 10:37:59 -06:00
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
2022-05-30 07:39:24 -06:00
|
|
|
|
2023-05-21 10:37:59 -06:00
|
|
|
return
|
2022-05-30 07:39:24 -06:00
|
|
|
}
|
2021-08-18 16:24:22 -06:00
|
|
|
|
2023-07-26 09:54:19 -06:00
|
|
|
if !mapRequest.ReadOnly {
|
|
|
|
// 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.
|
|
|
|
updateRequestsFromNode.WithLabelValues(machine.User.Name, machine.Hostname, "endpoint-update").
|
|
|
|
Inc()
|
|
|
|
|
|
|
|
// Tell all the other nodes about the new endpoint, but dont update ourselves.
|
|
|
|
h.nodeNotifier.NotifyWithIgnore(
|
|
|
|
types.StateUpdate{
|
|
|
|
Type: types.StatePeerChanged,
|
2023-08-09 14:20:05 -06:00
|
|
|
Changed: types.Machines{machine},
|
2023-07-26 09:54:19 -06:00
|
|
|
},
|
|
|
|
machine.MachineKey)
|
|
|
|
}
|
|
|
|
|
2021-08-18 16:24:22 -06:00
|
|
|
// 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
|
2023-06-21 03:29:52 -06:00
|
|
|
logInfo("Client map request processed")
|
2021-08-18 16:24:22 -06:00
|
|
|
|
2022-06-26 04:06:25 -06:00
|
|
|
if mapRequest.ReadOnly {
|
2023-06-21 03:29:52 -06:00
|
|
|
logInfo("Client is starting up. Probably interested in a DERP map")
|
2022-06-20 04:30:51 -06:00
|
|
|
|
2023-07-26 05:55:03 -06:00
|
|
|
mapResp, err := mapp.FullMapResponse(mapRequest, machine, h.ACLPolicy)
|
|
|
|
if err != nil {
|
|
|
|
logErr(err, "Failed to create MapResponse")
|
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-06-26 04:06:25 -06:00
|
|
|
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
|
|
writer.WriteHeader(http.StatusOK)
|
2023-07-26 05:55:03 -06:00
|
|
|
_, err = writer.Write(mapResp)
|
2022-06-26 04:21:35 -06:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Failed to write response")
|
2022-06-26 04:21:35 -06:00
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-08-14 14:57:03 -06:00
|
|
|
if f, ok := writer.(http.Flusher); ok {
|
|
|
|
f.Flush()
|
|
|
|
}
|
|
|
|
|
2021-08-18 16:24:22 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-06-26 04:06:25 -06:00
|
|
|
if mapRequest.OmitPeers && !mapRequest.Stream {
|
2023-06-21 03:29:52 -06:00
|
|
|
logInfo("Client sent endpoint update and is ok with a response without peer list")
|
|
|
|
|
2023-07-26 05:55:03 -06:00
|
|
|
mapResp, err := mapp.LiteMapResponse(mapRequest, machine, h.ACLPolicy)
|
|
|
|
if err != nil {
|
|
|
|
logErr(err, "Failed to create MapResponse")
|
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-06-26 04:06:25 -06:00
|
|
|
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
|
|
writer.WriteHeader(http.StatusOK)
|
2023-07-26 05:55:03 -06:00
|
|
|
_, err = writer.Write(mapResp)
|
2022-06-26 04:21:35 -06:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Failed to write response")
|
2022-06-26 04:21:35 -06:00
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-08-18 16:24:22 -06:00
|
|
|
return
|
2022-06-26 04:06:25 -06:00
|
|
|
} else if mapRequest.OmitPeers && mapRequest.Stream {
|
2021-08-18 16:24:22 -06:00
|
|
|
log.Warn().
|
|
|
|
Str("handler", "PollNetMap").
|
2022-08-14 15:11:33 -06:00
|
|
|
Bool("noise", isNoise).
|
2022-04-24 13:55:54 -06:00
|
|
|
Str("machine", machine.Hostname).
|
2021-08-18 16:24:22 -06:00
|
|
|
Msg("Ignoring request, don't know how to handle it")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2021-08-18 16:24:22 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
logInfo("Sending initial map")
|
2021-08-18 16:24:22 -06:00
|
|
|
|
2023-07-26 05:55:03 -06:00
|
|
|
mapResp, err := mapp.FullMapResponse(mapRequest, machine, h.ACLPolicy)
|
|
|
|
if err != nil {
|
|
|
|
logErr(err, "Failed to create MapResponse")
|
|
|
|
http.Error(writer, "", http.StatusInternalServerError)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
// Send the client an update to make sure we send an initial mapresponse
|
|
|
|
_, err = writer.Write(mapResp)
|
|
|
|
if err != nil {
|
|
|
|
logErr(err, "Could not write the map response")
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if flusher, ok := writer.(http.Flusher); ok {
|
|
|
|
flusher.Flush()
|
|
|
|
} else {
|
|
|
|
return
|
|
|
|
}
|
2021-08-18 16:24:22 -06:00
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
keepAliveTicker := time.NewTicker(keepAliveInterval)
|
|
|
|
|
2023-07-26 09:54:19 -06:00
|
|
|
ctx = context.WithValue(ctx, machineNameContextKey, machine.Hostname)
|
2022-04-09 16:37:13 -06:00
|
|
|
|
2022-06-20 04:30:51 -06:00
|
|
|
ctx, cancel := context.WithCancel(ctx)
|
|
|
|
defer cancel()
|
2022-04-09 16:37:13 -06:00
|
|
|
|
2023-08-09 14:56:21 -06:00
|
|
|
h.pollStreamOpenMu.Unlock()
|
|
|
|
|
2022-06-20 13:40:28 -06:00
|
|
|
for {
|
2023-07-24 00:58:51 -06:00
|
|
|
logInfo("Waiting for update on stream channel")
|
2021-08-18 16:24:22 -06:00
|
|
|
select {
|
2023-06-21 03:29:52 -06:00
|
|
|
case <-keepAliveTicker.C:
|
2023-06-29 04:20:22 -06:00
|
|
|
data, err := mapp.KeepAliveResponse(mapRequest, machine)
|
2021-08-13 03:33:50 -06:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Error generating the keep alive msg")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-06-20 13:40:28 -06:00
|
|
|
return
|
2021-08-13 03:33:50 -06:00
|
|
|
}
|
2023-06-21 03:29:52 -06:00
|
|
|
_, err = writer.Write(data)
|
|
|
|
if err != nil {
|
|
|
|
logErr(err, "Cannot write keep alive message")
|
2022-06-26 04:25:26 -06:00
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
return
|
2022-06-26 04:25:26 -06:00
|
|
|
}
|
2023-06-21 03:29:52 -06:00
|
|
|
if flusher, ok := writer.(http.Flusher); ok {
|
|
|
|
flusher.Flush()
|
|
|
|
} else {
|
2023-07-24 00:58:51 -06:00
|
|
|
log.Error().Msg("Failed to create http flusher")
|
|
|
|
|
2022-06-20 13:40:28 -06:00
|
|
|
return
|
2021-08-21 09:52:19 -06:00
|
|
|
}
|
2021-10-04 10:28:07 -06:00
|
|
|
|
2023-05-11 01:09:18 -06:00
|
|
|
err = h.db.TouchMachine(machine)
|
2022-01-16 03:59:03 -07:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Cannot update machine LastSeen")
|
2022-06-20 13:40:28 -06:00
|
|
|
|
|
|
|
return
|
2022-01-16 03:59:03 -07:00
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2023-06-29 04:20:22 -06:00
|
|
|
case update := <-updateChan:
|
2023-07-24 00:58:51 -06:00
|
|
|
logInfo("Received update")
|
|
|
|
|
2023-06-29 04:20:22 -06:00
|
|
|
var data []byte
|
|
|
|
var err error
|
|
|
|
|
|
|
|
switch update.Type {
|
|
|
|
case types.StatePeerChanged:
|
2023-07-17 03:13:48 -06:00
|
|
|
logInfo("Sending PeerChanged MapResponse")
|
2023-06-29 04:20:22 -06:00
|
|
|
data, err = mapp.PeerChangedResponse(mapRequest, machine, update.Changed, h.ACLPolicy)
|
|
|
|
case types.StatePeerRemoved:
|
2023-07-17 03:13:48 -06:00
|
|
|
logInfo("Sending PeerRemoved MapResponse")
|
2023-06-29 04:20:22 -06:00
|
|
|
data, err = mapp.PeerRemovedResponse(mapRequest, machine, update.Removed)
|
|
|
|
case types.StateDERPUpdated:
|
2023-07-17 03:13:48 -06:00
|
|
|
logInfo("Sending DERPUpdate MapResponse")
|
2023-06-29 04:20:22 -06:00
|
|
|
data, err = mapp.DERPMapResponse(mapRequest, machine, update.DERPMap)
|
2023-07-17 03:13:48 -06:00
|
|
|
case types.StateFullUpdate:
|
|
|
|
logInfo("Sending Full MapResponse")
|
|
|
|
data, err = mapp.FullMapResponse(mapRequest, machine, h.ACLPolicy)
|
2023-06-29 04:20:22 -06:00
|
|
|
}
|
|
|
|
|
2021-08-13 03:33:50 -06:00
|
|
|
if err != nil {
|
2023-06-29 04:20:22 -06:00
|
|
|
logErr(err, "Could not get the create map update")
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2022-06-20 13:40:28 -06:00
|
|
|
return
|
2021-08-13 03:33:50 -06:00
|
|
|
}
|
2022-06-20 13:40:28 -06:00
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
_, err = writer.Write(data)
|
2022-01-16 03:59:03 -07:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Could not write the map response")
|
|
|
|
|
|
|
|
updateRequestsSentToNode.WithLabelValues(machine.User.Name, machine.Hostname, "failed").
|
|
|
|
Inc()
|
2022-06-20 13:40:28 -06:00
|
|
|
|
|
|
|
return
|
2022-01-16 03:59:03 -07:00
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
if flusher, ok := writer.(http.Flusher); ok {
|
|
|
|
flusher.Flush()
|
2021-08-19 11:05:33 -06:00
|
|
|
} else {
|
2023-07-24 00:58:51 -06:00
|
|
|
log.Error().Msg("Failed to create http flusher")
|
|
|
|
|
2023-06-21 03:29:52 -06:00
|
|
|
return
|
2021-08-13 03:33:50 -06:00
|
|
|
}
|
2021-11-14 08:46:09 -07:00
|
|
|
|
2023-06-21 03:29:52 -06: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.
|
|
|
|
err = h.db.TouchMachine(machine)
|
2021-08-21 09:52:19 -06:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Cannot update machine LastSuccessfulUpdate")
|
|
|
|
|
2022-06-20 13:40:28 -06:00
|
|
|
return
|
2021-08-21 09:52:19 -06:00
|
|
|
}
|
2023-06-21 03:29:52 -06:00
|
|
|
|
2023-07-24 00:58:51 -06:00
|
|
|
logInfo("Update sent")
|
2023-06-21 03:29:52 -06:00
|
|
|
case <-ctx.Done():
|
|
|
|
logInfo("The client has closed the connection")
|
|
|
|
|
|
|
|
err := h.db.TouchMachine(machine)
|
2022-01-16 03:59:03 -07:00
|
|
|
if err != nil {
|
2023-06-21 03:29:52 -06:00
|
|
|
logErr(err, "Cannot update machine LastSeen")
|
2022-01-16 03:59:03 -07:00
|
|
|
}
|
2021-08-18 16:24:22 -06:00
|
|
|
|
2022-06-20 13:40:28 -06:00
|
|
|
// The connection has been closed, so we can stop polling.
|
|
|
|
return
|
2022-06-23 11:40:07 -06:00
|
|
|
|
|
|
|
case <-h.shutdownChan:
|
2023-06-21 03:29:52 -06:00
|
|
|
logInfo("The long-poll handler is shutting down")
|
2022-06-26 04:06:25 -06:00
|
|
|
|
2022-06-23 11:40:07 -06:00
|
|
|
return
|
2021-08-13 03:33:50 -06:00
|
|
|
}
|
2022-06-20 04:30:51 -06:00
|
|
|
}
|
2021-08-13 03:33:50 -06:00
|
|
|
}
|
2021-08-18 16:24:22 -06:00
|
|
|
|
2023-06-29 04:20:22 -06:00
|
|
|
func closeChanWithLog[C chan []byte | chan struct{} | chan types.StateUpdate](channel C, machine, name string) {
|
2022-04-09 16:37:13 -06:00
|
|
|
log.Trace().
|
|
|
|
Str("handler", "PollNetMap").
|
|
|
|
Str("machine", machine).
|
|
|
|
Str("channel", "Done").
|
|
|
|
Msg(fmt.Sprintf("Closing %s channel", name))
|
|
|
|
|
|
|
|
close(channel)
|
|
|
|
}
|