devproje/headscale
1
0
Fork 0
mirror of https://github.com/juanfont/headscale.git synced 2024-11-29 18:33:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
headscale/api.go

408 lines
12 KiB
Go
Raw Normal View History

Initial commit
2020-06-21 10:32:08 +00:00
package headscale
import (
"encoding/binary"
"encoding/json"
Update Headscale to depend on gorm v2
2021-06-24 13:44:19 +00:00
"errors"
Initial commit
2020-06-21 10:32:08 +00:00
"fmt"
"io"
"net/http"
"time"
Initial port to zerologger
2021-08-05 17:11:26 +00:00
"github.com/rs/zerolog/log"
Initial commit
2020-06-21 10:32:08 +00:00
"github.com/gin-gonic/gin"
"github.com/klauspost/compress/zstd"
Update Headscale to depend on gorm v2
2021-06-24 13:44:19 +00:00
"gorm.io/gorm"
Initial commit
2020-06-21 10:32:08 +00:00
"tailscale.com/tailcfg"
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
"tailscale.com/types/wgkey"
Initial commit
2020-06-21 10:32:08 +00:00
)
Initial multi-user support using namespaces
2021-02-27 23:58:09 +00:00
// KeyHandler provides the Headscale pub key
// Listens in /key
Initial commit
2020-06-21 10:32:08 +00:00
func (h *Headscale) KeyHandler(c *gin.Context) {
c.Data(200, "text/plain; charset=utf-8", []byte(h.publicKey.HexString()))
}
Initial multi-user support using namespaces
2021-02-27 23:58:09 +00:00
// RegisterWebAPI shows a simple message in the browser to point to the CLI
// Listens in /register
func (h *Headscale) RegisterWebAPI(c *gin.Context) {
mKeyStr := c.Query("key")
if mKeyStr == "" {
c.String(http.StatusBadRequest, "Wrong params")
return
}
c.Data(http.StatusOK, "text/html; charset=utf-8", []byte(fmt.Sprintf(`
<html>
<body>
<h1>headscale</h1>
<p>
Remove dependency on postgres' jsonb
2021-05-14 22:05:41 +00:00
Run the command below in the headscale server to add this machine to your network:
Initial multi-user support using namespaces
2021-02-27 23:58:09 +00:00
</p>
<p>
<code>
Fix minor typo on the register webpage
2021-07-11 13:05:32 +00:00
<b>headscale -n NAMESPACE nodes register %s</b>
Initial multi-user support using namespaces
2021-02-27 23:58:09 +00:00
</code>
</p>
</body>
</html>
Improved tailnode start up handling
2021-05-24 19:59:03 +00:00
Initial multi-user support using namespaces
2021-02-27 23:58:09 +00:00
`, mKeyStr)))
}
// RegistrationHandler handles the actual registration process of a machine
// Endpoint /machine/:id
Initial commit
2020-06-21 10:32:08 +00:00
func (h *Headscale) RegistrationHandler(c *gin.Context) {
Fixes here and there
2021-02-21 22:54:15 +00:00
body, _ := io.ReadAll(c.Request.Body)
Initial commit
2020-06-21 10:32:08 +00:00
mKeyStr := c.Param("id")
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
mKey, err := wgkey.ParseHex(mKeyStr)
Initial commit
2020-06-21 10:32:08 +00:00
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot parse machine key")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("unkown", "web", "error", "unknown").Inc()
Initial commit
2020-06-21 10:32:08 +00:00
c.String(http.StatusInternalServerError, "Sad!")
return
}
req := tailcfg.RegisterRequest{}
err = decode(body, &req, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot decode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("unkown", "web", "error", "unknown").Inc()
Initial commit
2020-06-21 10:32:08 +00:00
c.String(http.StatusInternalServerError, "Very sad!")
return
}
Preauth keys kinda working
2021-05-05 22:59:26 +00:00
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 22:24:22 +00:00
now := time.Now().UTC()
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
var m Machine
Send the namespace name as user to the clients
2021-07-11 14:39:19 +00:00
if result := h.db.Preload("Namespace").First(&m, "machine_key = ?", mKey.HexString()); errors.Is(result.Error, gorm.ErrRecordNotFound) {
Make log keys lowercase
2021-08-05 19:57:47 +00:00
log.Info().Str("machine", req.Hostinfo.Hostname).Msg("New machine")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
m = Machine{
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 22:24:22 +00:00
Expiry: &req.Expiry,
MachineKey: mKey.HexString(),
Name: req.Hostinfo.Hostname,
NodeKey: wgkey.Key(req.NodeKey).HexString(),
LastSuccessfulUpdate: &now,
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
}
Use gorm connection pool
2021-07-04 19:40:46 +00:00
if err := h.db.Create(&m).Error; err != nil {
Convert missing from api.go
2021-08-05 17:16:21 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Convert missing from api.go
2021-08-05 17:16:21 +00:00
Err(err).
Msg("Could not create row")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("unkown", "web", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
return
}
}
if !m.Registered && req.Auth.AuthKey != "" {
Use gorm connection pool
2021-07-04 19:40:46 +00:00
h.handleAuthKey(c, h.db, mKey, req, m)
Initial commit
2020-06-21 10:32:08 +00:00
return
}
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
resp := tailcfg.RegisterResponse{}
// We have the updated key!
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
if m.NodeKey == wgkey.Key(req.NodeKey).HexString() {
Initial commit
2020-06-21 10:32:08 +00:00
if m.Registered {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Str("machine", m.Name).
Fixed log message
2021-08-05 22:21:34 +00:00
Msg("Client is registered and we have the current NodeKey. All clear to /map")
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Initial commit
2020-06-21 10:32:08 +00:00
resp.AuthURL = ""
Update README (although do not advirtise preauth keys that much yet)
2021-05-06 21:25:40 +00:00
resp.MachineAuthorized = true
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
resp.User = *m.Namespace.toUser()
Initial commit
2020-06-21 10:32:08 +00:00
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("update", "web", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
c.String(http.StatusInternalServerError, "")
Initial commit
2020-06-21 10:32:08 +00:00
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("update", "web", "success", m.Namespace.Name).Inc()
Initial commit
2020-06-21 10:32:08 +00:00
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("Not registered and not NodeKey rotation. Sending a authurl to register")
Initial commit
2020-06-21 10:32:08 +00:00
resp.AuthURL = fmt.Sprintf("%s/register?key=%s",
h.cfg.ServerURL, mKey.HexString())
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "web", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
c.String(http.StatusInternalServerError, "")
Initial commit
2020-06-21 10:32:08 +00:00
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "web", "success", m.Namespace.Name).Inc()
Initial commit
2020-06-21 10:32:08 +00:00
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
// The NodeKey we have matches OldNodeKey, which means this is a refresh after an key expiration
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
if m.NodeKey == wgkey.Key(req.OldNodeKey).HexString() {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("We have the OldNodeKey in the database. This is a key refresh")
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
m.NodeKey = wgkey.Key(req.NodeKey).HexString()
Use gorm connection pool
2021-07-04 19:40:46 +00:00
h.db.Save(&m)
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
Initial commit
2020-06-21 10:32:08 +00:00
resp.AuthURL = ""
Initial multi-user support using namespaces
2021-02-27 23:58:09 +00:00
resp.User = *m.Namespace.toUser()
Initial commit
2020-06-21 10:32:08 +00:00
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Initial commit
2020-06-21 10:32:08 +00:00
c.String(http.StatusInternalServerError, "Extremely sad!")
return
}
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
// We arrive here after a client is restarted without finalizing the authentication flow or
// when headscale is stopped in the middle of the auth process.
if m.Registered {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("The node is sending us a new NodeKey, but machine is registered. All clear for /map")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
resp.AuthURL = ""
resp.MachineAuthorized = true
resp.User = *m.Namespace.toUser()
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
c.String(http.StatusInternalServerError, "")
return
}
c.Data(200, "application/json; charset=utf-8", respBody)
return
}
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("The node is sending us a new NodeKey, sending auth url")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
resp.AuthURL = fmt.Sprintf("%s/register?key=%s",
h.cfg.ServerURL, mKey.HexString())
respBody, err := encode(resp, &mKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("handler", "Registration").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
c.String(http.StatusInternalServerError, "")
return
}
c.Data(200, "application/json; charset=utf-8", respBody)
Initial commit
2020-06-21 10:32:08 +00:00
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
func (h *Headscale) getMapResponse(mKey wgkey.Key, req tailcfg.MapRequest, m *Machine) (*[]byte, error) {
Add more trace logging
2021-08-05 20:47:06 +00:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Msg("Creating Map response")
Implement node sharing functionality
2021-09-02 14:59:03 +00:00
node, err := m.toNode(true)
Initial commit
2020-06-21 10:32:08 +00:00
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot convert to node")
Initial commit
2020-06-21 10:32:08 +00:00
return nil, err
}
Move DB call of pollmap to Machine inside a function
2021-10-02 20:58:28 +00:00
Initial commit
2020-06-21 10:32:08 +00:00
peers, err := h.getPeers(m)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "getMapResponse").
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot fetch peers")
Initial commit
2020-06-21 10:32:08 +00:00
return nil, err
}
Send the namespace name as user to the clients
2021-07-11 14:39:19 +00:00
profile := tailcfg.UserProfile{
ID: tailcfg.UserID(m.NamespaceID),
LoginName: m.Namespace.Name,
DisplayName: m.Namespace.Name,
}
Move toNode, add type helpers, split peers and shared This commit moves toNode to the bottom of the file, and adds a helper function for lists of Machines to be converted. It also adds string helpers for Machines and lists of machines. Lastly it splits getPeers into getDirectPeers, which exist in the same namespace, and getShared, which is nodes shared with the namespace. getPeers is kept as a function putting together the two lists for convenience.
2021-10-02 21:03:34 +00:00
nodePeers, err := peers.toNodes(true)
if err != nil {
log.Error().
Str("func", "getMapResponse").
Err(err).
Msg("Failed to convert peers to Tailscale nodes")
return nil, err
}
Initial commit
2020-06-21 10:32:08 +00:00
resp := tailcfg.MapResponse{
Pass DNSConfig to nodes in MapResponse
2021-08-24 06:11:45 +00:00
KeepAlive: false,
Node: node,
Move toNode, add type helpers, split peers and shared This commit moves toNode to the bottom of the file, and adds a helper function for lists of Machines to be converted. It also adds string helpers for Machines and lists of machines. Lastly it splits getPeers into getDirectPeers, which exist in the same namespace, and getShared, which is nodes shared with the namespace. getPeers is kept as a function putting together the two lists for convenience.
2021-10-02 21:03:34 +00:00
Peers: nodePeers,
// TODO(kradalby): As per tailscale docs, if DNSConfig is nil,
Pass DNSConfig to nodes in MapResponse
2021-08-24 06:11:45 +00:00
// it means its not updated, maybe we can have some logic
// to check and only pass updates when its updates.
// This is probably more relevant if we try to implement
// "MagicDNS"
DNSConfig: h.cfg.DNSConfig,
Initial commit
2020-06-21 10:32:08 +00:00
SearchPaths: []string{},
Send the namespace name as user to the clients
2021-07-11 14:39:19 +00:00
Domain: "headscale.net",
Load ACL policy on headscale startup
2021-07-04 11:24:05 +00:00
PacketFilter: *h.aclRules,
Load DERP servers from file
2021-02-20 22:57:06 +00:00
DERPMap: h.cfg.DerpMap,
Send the namespace name as user to the clients
2021-07-11 14:39:19 +00:00
UserProfiles: []tailcfg.UserProfile{profile},
Minor thing
2021-02-23 23:31:58 +00:00
}
Resolve merge conflict
2021-08-13 09:33:19 +00:00
log.Trace().
Str("func", "getMapResponse").
Str("machine", req.Hostinfo.Hostname).
Msgf("Generated map response: %s", tailMapResponseToString(resp))
Initial commit
2020-06-21 10:32:08 +00:00
var respBody []byte
if req.Compress == "zstd" {
src, _ := json.Marshal(resp)
Resolve merge conflict
2021-08-13 09:33:19 +00:00
Initial commit
2020-06-21 10:32:08 +00:00
encoder, _ := zstd.NewWriter(nil)
srcCompressed := encoder.EncodeAll(src, nil)
respBody, err = encodeMsg(srcCompressed, &mKey, h.privateKey)
if err != nil {
return nil, err
}
} else {
respBody, err = encode(resp, &mKey, h.privateKey)
if err != nil {
return nil, err
}
}
// declare the incoming size on the first 4 bytes
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
return &data, nil
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
func (h *Headscale) getMapKeepAliveResponse(mKey wgkey.Key, req tailcfg.MapRequest, m *Machine) (*[]byte, error) {
Initial commit
2020-06-21 10:32:08 +00:00
resp := tailcfg.MapResponse{
KeepAlive: true,
}
var respBody []byte
var err error
if req.Compress == "zstd" {
src, _ := json.Marshal(resp)
encoder, _ := zstd.NewWriter(nil)
srcCompressed := encoder.EncodeAll(src, nil)
respBody, err = encodeMsg(srcCompressed, &mKey, h.privateKey)
if err != nil {
return nil, err
}
} else {
respBody, err = encode(resp, &mKey, h.privateKey)
if err != nil {
return nil, err
}
}
data := make([]byte, 4)
binary.LittleEndian.PutUint32(data, uint32(len(respBody)))
data = append(data, respBody...)
return &data, nil
}
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
func (h *Headscale) handleAuthKey(c *gin.Context, db *gorm.DB, idKey wgkey.Key, req tailcfg.RegisterRequest, m Machine) {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", req.Hostinfo.Hostname).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msgf("Processing auth key for %s", req.Hostinfo.Hostname)
Preauth keys kinda working
2021-05-05 22:59:26 +00:00
resp := tailcfg.RegisterResponse{}
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
pak, err := h.checkKeyValidity(req.Auth.AuthKey)
if err != nil {
resp.MachineAuthorized = false
Preauth keys kinda working
2021-05-05 22:59:26 +00:00
respBody, err := encode(resp, &idKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
c.String(http.StatusInternalServerError, "")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Preauth keys kinda working
2021-05-05 22:59:26 +00:00
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
c.Data(401, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("Failed authentication via AuthKey")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
return
}
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Debug().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("Authentication key was valid, proceeding to acquire an IP address")
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
ip, err := h.getAvailableIP()
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("Failed to find an available IP")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Preauth keys kinda working
2021-05-05 22:59:26 +00:00
return
Initial commit
2020-06-21 10:32:08 +00:00
}
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Info().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Str("ip", ip.String()).
Move most "poll" functionality to poll.go This function migrates more poll functions (including keepalive) to poll.go to keep it somehow in the same file. In addition it makes changes to improve the stability and ensure nodes get the appropriate updates from the headscale control and are not left in an inconsistent state. Two new additions is: omitpeers=true will now trigger an update if the clients are not already up to date keepalive has been extended with a timer that will check every 120s if all nodes are up to date.
2021-08-18 22:24:22 +00:00
Msgf("Assigning %s to %s", ip, m.Name)
Initial commit
2020-06-21 10:32:08 +00:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
m.AuthKeyID = uint(pak.ID)
m.IPAddress = ip.String()
m.NamespaceID = pak.NamespaceID
Update code to Tailscale 1.10
2021-06-25 16:57:08 +00:00
m.NodeKey = wgkey.Key(req.NodeKey).HexString() // we update it just in case
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
m.Registered = true
m.RegisterMethod = "authKey"
db.Save(&m)
Preauth keys kinda working
2021-05-05 22:59:26 +00:00
Handle client sending new NodeKey (fixes #32)
2021-06-05 10:13:55 +00:00
resp.MachineAuthorized = true
resp.User = *pak.Namespace.toUser()
Initial commit
2020-06-21 10:32:08 +00:00
respBody, err := encode(resp, &idKey, h.privateKey)
if err != nil {
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Error().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Err(err).
Msg("Cannot encode message")
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "authkey", "error", m.Namespace.Name).Inc()
Initial commit
2020-06-21 10:32:08 +00:00
c.String(http.StatusInternalServerError, "Extremely sad!")
return
}
Initial work on Prometheus metrics This commit adds some Prometheus metrics to /metrics in headscale. It will add the standard go metrics, some automatic gin metrics and some initial headscale specific ones. Some of them has been added to aid debugging #97 (loop bug) In the future, we can use the metrics to get rid of the sleep in the integration tests by checking that our expected number of nodes has been registered: ``` headscale_machine_registrations_total ```
2021-10-04 16:28:07 +00:00
machineRegistrations.WithLabelValues("new", "authkey", "success", m.Namespace.Name).Inc()
Initial commit
2020-06-21 10:32:08 +00:00
c.Data(200, "application/json; charset=utf-8", respBody)
Initial port to zerologger
2021-08-05 17:11:26 +00:00
log.Info().
Make log keys lowercase
2021-08-05 19:57:47 +00:00
Str("func", "handleAuthKey").
Str("machine", m.Name).
Str("ip", ip.String()).
Initial port to zerologger
2021-08-05 17:11:26 +00:00
Msg("Successfully authenticated via AuthKey")
Initial commit
2020-06-21 10:32:08 +00:00
}
Reference in a new issue Copy permalink