Files
cairnobs/internal/server/joined.go
T
jcoffey-dev 31e10c1c09
ci / postgres (pull_request) Successful in 3m16s
ci / check (pull_request) Successful in 8m22s
join.image defaults to the public image
Clusters can be added without setting join.image: the manifest names
ghcr.io/coffey-labs/cairnobs at this obs-beacond's version. A development
build, whose version has no image there, takes :latest. Setting join.image
still points clusters at your own copy, for those that can't reach GitHub's
registry.
2026-11-15 15:10:27 -07:00

664 lines
22 KiB
Go

package server
// Adding a host from the UI: an admin makes a
// one-time join token for a name, and runs the one line the UI shows on the
// new host. install.sh installs the agent package and runs
// `obs-beacon-agent join`, which sends a key's certificate request with the
// token's secret to POST /api/v1/agent/join; obs-beacond spends the token,
// adds the agent to its database and signs its certificate. From then on the
// agent is like any other on the TLS listener.
//
// Agents can still be listed in obs-beacond.yaml (`agents`, with tokens);
// both kinds count everywhere an agent name does. A name can't be in both.
import (
_ "embed"
"encoding/json"
"errors"
"fmt"
"log"
"maps"
"net"
"net/http"
"net/url"
"os"
"path"
"path/filepath"
"regexp"
"sort"
"strings"
"time"
"github.com/cairnobs/cairnobs/internal/jointoken"
"github.com/cairnobs/cairnobs/internal/state"
"github.com/cairnobs/cairnobs/internal/version"
)
// JoinConfig is how new hosts reach obs-beacond when they join.
type JoinConfig struct {
// AgentURL is the agent listener as new hosts reach it, e.g.
// https://monitor.example.org:8461. Default: alerts.public_url's host
// with agent_listen's port.
AgentURL string `yaml:"agent_url"`
// PackagesDir is served at /agent-packages/ for install.sh: the agent's
// .deb and .rpm files and SHA256SUMS from a release. For networks that
// can't reach the public download, and before there is one.
PackagesDir string `yaml:"packages_dir"`
// PackagesURL is where install.sh fetches packages otherwise: a release
// download URL holding the same files.
PackagesURL string `yaml:"packages_url"`
// Image is where clusters pull the obs-beacond image from, which
// carries the cluster agent: e.g. registry.example.org/ops/obs-beacond,
// for clusters that can't reach the public one. Without it,
// DefaultClusterImage. Without a tag, this obs-beacond's version is used.
Image string `yaml:"image"`
}
// joinTTL is how long a join token is good for.
const joinTTL = time.Hour
// agentName is what a joined agent may be called: a short host name.
var agentName = regexp.MustCompile(`^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$`)
// loadJoined reads the joined agents into memory and the store.
func (srv *Server) loadJoined() error {
srv.joined = map[string]state.JoinedAgent{}
if srv.db == nil {
return nil
}
list, err := srv.db.JoinedAgents()
if err != nil {
return err
}
for _, a := range list {
if srv.inConfig(a.Name) {
log.Printf("agent %s is in obs-beacond.yaml and joined too; the config file's entry is used", a.Name)
continue
}
srv.joined[a.Name] = a
if !a.Cluster {
srv.store.Add(a.Name)
}
}
return nil
}
// checkAgentNames checks that everything in the config naming an agent
// names one, from the config file or joined.
func (srv *Server) checkAgentNames() error {
known := map[string]bool{}
for _, a := range srv.agentList() {
known[a.Name] = true
}
hostsOnly := maps.Clone(known)
for _, c := range srv.clusterAgents() {
known[c] = true // a maintenance window can cover a cluster
}
for _, w := range srv.cfg.Maintenance {
for _, h := range w.Hosts {
if !known[h] {
return fmt.Errorf("maintenance window %q: no agent called %q", w.Name, h)
}
}
}
if m := srv.cfg.Mail; m != nil && m.Host != "" && !hostsOnly[m.Host] {
return fmt.Errorf("mail: no agent called %q", m.Host)
}
if srv.cfg.DataLayer != nil {
return srv.cfg.DataLayer.check(hostsOnly)
}
return nil
}
func (srv *Server) inConfig(name string) bool {
for _, a := range srv.cfg.Agents {
if a.Name == name {
return true
}
}
return false
}
// agentList is every host's agent: the config file's, then the joined
// ones. Joined agents have no token. Cluster agents aren't hosts: they're
// in clusterAgents.
func (srv *Server) agentList() []AgentConfig {
out := hostAgents(srv.cfg.Agents)
srv.joinedMu.RLock()
defer srv.joinedMu.RUnlock()
names := make([]string, 0, len(srv.joined))
for n := range srv.joined {
names = append(names, n)
}
sort.Strings(names)
for _, n := range names {
if j := srv.joined[n]; !j.Cluster {
out = append(out, AgentConfig{Name: n, Workstation: j.Workstation})
}
}
return out
}
// hostAgents leaves the cluster agents out.
func hostAgents(all []AgentConfig) []AgentConfig {
out := make([]AgentConfig, 0, len(all))
for _, a := range all {
if !a.Cluster {
out = append(out, a)
}
}
return out
}
// clusterAgents is every cluster agent's name, from the config file and
// joined, sorted.
func (srv *Server) clusterAgents() []string {
var out []string
for _, a := range srv.cfg.Agents {
if a.Cluster {
out = append(out, a.Name)
}
}
srv.joinedMu.RLock()
for n, j := range srv.joined {
if j.Cluster && !srv.inConfig(n) {
out = append(out, n)
}
}
srv.joinedMu.RUnlock()
sort.Strings(out)
return out
}
// clusterAgent says whether name is a cluster agent.
func (srv *Server) clusterAgent(name string) bool {
for _, a := range srv.cfg.Agents {
if a.Name == name {
return a.Cluster
}
}
srv.joinedMu.RLock()
defer srv.joinedMu.RUnlock()
return srv.joined[name].Cluster
}
func (srv *Server) knownAgent(name string) bool {
if srv.inConfig(name) {
return true
}
srv.joinedMu.RLock()
defer srv.joinedMu.RUnlock()
_, ok := srv.joined[name]
return ok
}
// workstation reports whether the named agent is a workstation.
func (srv *Server) workstation(name string) bool {
if srv.inConfig(name) {
return srv.cfg.workstation(name)
}
srv.joinedMu.RLock()
defer srv.joinedMu.RUnlock()
return srv.joined[name].Workstation
}
// joinAgentURL is the agent listener's URL for join tokens; "" when it
// can't be worked out.
func (srv *Server) joinAgentURL(r *http.Request) string {
if u := strings.TrimRight(srv.cfg.Join.AgentURL, "/"); u != "" {
return u
}
_, port, err := net.SplitHostPort(srv.cfg.AgentListen)
if err != nil {
return ""
}
host := ""
if pu, err := url.Parse(srv.cfg.Alerts.PublicURL); err == nil && pu.Hostname() != "" {
host = pu.Hostname()
} else if h, _, err := net.SplitHostPort(r.Host); err == nil {
host = h
} else {
host = r.Host
}
if host == "" || loopbackHost(host) {
return ""
}
return "https://" + net.JoinHostPort(host, port)
}
// publicBase is the web address new hosts fetch install.sh from.
func (srv *Server) publicBase(r *http.Request) string {
if srv.cfg.Alerts.PublicURL != "" {
return srv.cfg.Alerts.PublicURL
}
scheme := "https"
if r.TLS == nil && loopbackHost(hostOnly(r.Host)) {
scheme = "http"
}
return scheme + "://" + r.Host
}
func hostOnly(hp string) string {
if h, _, err := net.SplitHostPort(hp); err == nil {
return h
}
return hp
}
type joinTokenView struct {
ID string `json:"id"`
Name string `json:"name"`
Workstation bool `json:"workstation"`
Cluster bool `json:"cluster"`
CreatedBy string `json:"created_by"`
Created time.Time `json:"created"`
Expires time.Time `json:"expires"`
}
type agentView struct {
Name string `json:"name"`
Source string `json:"source"` // config or joined
Workstation bool `json:"workstation"`
Added *time.Time `json:"added,omitempty"`
AddedBy string `json:"added_by,omitempty"`
CertUntil *time.Time `json:"cert_until,omitempty"`
// How it's doing, as on the hosts list.
Status string `json:"status"`
Word string `json:"word"`
}
// joinUnavailable says why hosts can't join here; "" when they can.
func (srv *Server) joinUnavailable(r *http.Request) string {
switch {
case srv.db == nil:
return "Joining needs the database (database and state_key_file in obs-beacond.yaml)."
case srv.atls == nil:
return "Joining needs the TLS agent listener (agent_listen, without agent_tls.off)."
case srv.joinAgentURL(r) == "":
return "obs-beacond can't tell how new hosts reach its agent listener: set join.agent_url (or alerts.public_url) in obs-beacond.yaml."
}
return ""
}
// clusterJoinUnavailable says why clusters can't join here; "" when they
// can. It's what stops hosts joining: the image has a default.
func (srv *Server) clusterJoinUnavailable(r *http.Request) string {
return srv.joinUnavailable(r)
}
// handleAgents lists the agents and the pending join tokens.
func (srv *Server) handleAgents(w http.ResponseWriter, r *http.Request) {
certs := map[string]time.Time{}
if srv.db != nil {
if live, err := srv.db.LiveAgentCerts(); err == nil {
for _, c := range live {
certs[c.Agent] = c.NotAfter
}
}
}
state := map[string]HostView{}
hosts, _ := srv.view(time.Now())
for _, h := range hosts {
state[h.Name] = h
}
// Paged like the other lists (lists.go): ?q= (part of the name),
// ?offset=, ?limit= (100, at most 500).
q := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("q")))
offset, limit := page(r, 100, 500)
agents := []agentView{}
for _, a := range srv.agentList() {
if q != "" && !strings.Contains(strings.ToLower(a.Name), q) {
continue
}
v := agentView{Name: a.Name, Source: "config", Workstation: a.Workstation, Status: state[a.Name].Status, Word: state[a.Name].Word}
srv.joinedMu.RLock()
if j, ok := srv.joined[a.Name]; ok && !srv.inConfig(a.Name) {
v.Source, v.Added, v.AddedBy = "joined", &j.Added, j.AddedBy
}
srv.joinedMu.RUnlock()
if t, ok := certs[a.Name]; ok {
v.CertUntil = &t
}
agents = append(agents, v)
}
pending := []joinTokenView{}
if srv.db != nil {
ts, err := srv.db.PendingJoinTokens(time.Now())
if err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
return
}
for _, t := range ts {
pending = append(pending, joinTokenView{ID: t.TokenSHA256[:12], Name: t.Agent, Workstation: t.Workstation, Cluster: t.Cluster, CreatedBy: t.CreatedBy, Created: t.Created, Expires: t.Expires})
}
}
writeJSON(w, http.StatusOK, map[string]any{"agents": window(agents, offset, limit), "total": len(agents), "offset": offset, "limit": limit,
"pending": pending, "join_unavailable": srv.joinUnavailable(r), "clusters": srv.clusterAgentViews(certs),
"cluster_join_unavailable": srv.clusterJoinUnavailable(r)})
}
// handleJoinCreate makes a join token and the line to run on the new host.
func (srv *Server) handleJoinCreate(w http.ResponseWriter, r *http.Request) {
if why := srv.joinUnavailable(r); why != "" {
writeJSON(w, http.StatusConflict, map[string]string{"error": why})
return
}
var req struct {
Name string `json:"name"`
Workstation bool `json:"workstation"`
Cluster bool `json:"cluster"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4096)).Decode(&req); err != nil {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "bad request"})
return
}
what := "host"
if req.Cluster {
what = "cluster"
if why := srv.clusterJoinUnavailable(r); why != "" {
writeJSON(w, http.StatusConflict, map[string]string{"error": why})
return
}
if req.Workstation {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "A cluster isn't a workstation."})
return
}
}
req.Name = strings.ToLower(strings.TrimSpace(req.Name))
if !agentName.MatchString(req.Name) {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": "A " + what + " name is lower-case letters, digits and dashes, up to 63 characters."})
return
}
if srv.knownAgent(req.Name) || req.Name == serverSource {
writeJSON(w, http.StatusConflict, map[string]string{"error": "There is already a host or cluster called " + req.Name + "."})
return
}
now := time.Now()
pending, err := srv.db.PendingJoinTokens(now)
if err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
return
}
for _, p := range pending {
if p.Agent == req.Name {
writeJSON(w, http.StatusConflict, map[string]string{"error": "A join command for " + req.Name + " is already waiting; cancel it first."})
return
}
}
secret := newToken()
t := state.JoinToken{TokenSHA256: HashToken(secret), Agent: req.Name, Workstation: req.Workstation, Cluster: req.Cluster,
Created: now, CreatedBy: srv.who(r), Expires: now.Add(joinTTL)}
if err := srv.db.AddJoinToken(t); err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
return
}
tok := jointoken.Token{Server: srv.joinAgentURL(r), CAFingerprint: srv.atls.ca.Fingerprint(), Secret: secret}.Encode()
srv.audit(srv.who(r), "made a join command", fmt.Sprintf("for %s %s, good until %s", what, req.Name, t.Expires.UTC().Format("15:04 UTC")))
command := fmt.Sprintf("curl -fsSL %s/install.sh | sudo sh -s -- --join %s", srv.publicBase(r), tok)
// Windows: PowerShell as Administrator (docs/windows.md). The script
// is fetched and run with the token as its argument, which keeps the
// token out of the address, as on Linux.
windows := fmt.Sprintf("& ([scriptblock]::Create((irm %s/install.ps1))) -Join %s", srv.publicBase(r), tok)
if req.Cluster {
// The token goes in a header, not the address: addresses end up
// in proxies' and servers' logs.
command = fmt.Sprintf("curl -fsSL -H 'Authorization: Bearer %s' %s/cluster.yaml | kubectl apply -f -", tok, srv.publicBase(r))
windows = ""
}
out := map[string]any{
"name": req.Name,
"token": tok,
"command": command,
"expires": t.Expires,
}
if windows != "" {
out["windows_command"] = windows
}
writeJSON(w, http.StatusOK, out)
}
func (srv *Server) handleJoinCancel(w http.ResponseWriter, r *http.Request) {
if srv.db == nil {
http.NotFound(w, r)
return
}
ok, err := srv.db.CancelJoinToken(r.PathValue("id"))
if err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
return
}
if !ok {
writeJSON(w, http.StatusNotFound, map[string]string{"error": "No such join command (used, cancelled or run out)."})
return
}
srv.audit(srv.who(r), "cancelled a join command", r.PathValue("id"))
w.WriteHeader(http.StatusNoContent)
}
// handleAgentRemove removes a joined agent: its certificate stops working
// at once. Agents in obs-beacond.yaml are removed there.
func (srv *Server) handleAgentRemove(w http.ResponseWriter, r *http.Request) {
name := r.PathValue("name")
if srv.inConfig(name) {
writeJSON(w, http.StatusConflict, map[string]string{"error": name + " is listed in obs-beacond.yaml; remove it there."})
return
}
if srv.db == nil {
http.NotFound(w, r)
return
}
srv.joinedMu.Lock()
cluster := srv.joined[name].Cluster
ok, err := srv.db.RemoveJoinedAgent(name, time.Now())
if ok {
delete(srv.joined, name)
}
srv.joinedMu.Unlock()
if err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
return
}
if !ok {
writeJSON(w, http.StatusNotFound, map[string]string{"error": "No joined host or cluster called " + name + "."})
return
}
what := "a host"
if cluster {
what = "a cluster"
} else {
srv.store.Remove(name)
}
// Its cluster's records, or what it read beside its host.
srv.forgetAgentSources(name)
if srv.shared() {
_ = srv.db.DeleteLive(name)
srv.publish(noticeJoined, "")
}
srv.audit(srv.who(r), "removed "+what, name+" (its certificate is revoked)")
w.WriteHeader(http.StatusNoContent)
}
// JoinAnswer is the answer to join: the certificate, and the name the
// agent was given.
type JoinAnswer struct {
Enrolled
Agent string `json:"agent"`
}
// handleJoin spends a join token and signs the new agent's first
// certificate.
func (srv *Server) handleJoin(w http.ResponseWriter, r *http.Request) {
secret, ok := strings.CutPrefix(r.Header.Get("Authorization"), "Bearer ")
if !ok || secret == "" {
http.Error(w, "no join token", http.StatusUnauthorized)
return
}
csr, err := readCSR(w, r)
if err != nil {
return
}
now := time.Now()
// Check the request before spending the token on it.
if _, err := srv.atls.ca.CheckAgentCSR(csr); err != nil {
http.Error(w, "bad certificate request: "+err.Error(), http.StatusBadRequest)
return
}
srv.joinedMu.Lock()
a, err := srv.db.UseJoinToken(HashToken(secret), now, srv.inConfig)
if err == nil {
srv.joined[a.Name] = a
}
srv.joinedMu.Unlock()
if err == nil {
srv.publish(noticeJoined, "")
}
if errors.Is(err, state.ErrJoinToken) {
http.Error(w, "unknown, used or expired join token: make a new one in the UI", http.StatusUnauthorized)
return
}
if err != nil {
http.Error(w, err.Error(), http.StatusConflict)
return
}
joined := "joined"
if a.Cluster {
joined = "joined as a cluster agent"
} else {
srv.store.Add(a.Name)
}
srv.audit("agent "+a.Name, joined, "with a join command from "+a.AddedBy+", from "+hostOnly(r.RemoteAddr))
en, err := srv.signAgent(csr, a.Name, now)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
writeJSON(w, http.StatusOK, JoinAnswer{Enrolled: en, Agent: a.Name})
}
// The install script, for `curl .../install.sh | sudo sh -s -- --join ...`.
func (srv *Server) packagesBase(r *http.Request) string {
switch {
case srv.cfg.Join.PackagesDir != "":
return srv.publicBase(r) + "/agent-packages"
case srv.cfg.Join.PackagesURL != "":
return strings.TrimRight(srv.cfg.Join.PackagesURL, "/")
}
return ""
}
func (srv *Server) handleInstallScript(w http.ResponseWriter, r *http.Request) {
s := strings.NewReplacer("@VERSION@", shellQuote(version.Version), "@PACKAGES@", shellQuote(srv.packagesBase(r))).Replace(installScript)
w.Header().Set("Content-Type", "text/x-shellscript; charset=utf-8")
w.Header().Set("Cache-Control", "no-store")
_, _ = w.Write([]byte(s))
}
// handleAgentPackage serves a file from join.packages_dir: nothing else,
// and no listing.
func (srv *Server) handleAgentPackage(w http.ResponseWriter, r *http.Request) {
name := r.PathValue("file")
if srv.cfg.Join.PackagesDir == "" || name != path.Base(name) || strings.HasPrefix(name, ".") ||
!(name == "SHA256SUMS" || name == "SHA256SUMS.minisig" || strings.HasSuffix(name, ".deb") || strings.HasSuffix(name, ".rpm") ||
strings.HasSuffix(name, "_windows_amd64.zip") || strings.HasSuffix(name, "_windows_arm64.zip")) {
http.NotFound(w, r)
return
}
p := filepath.Join(srv.cfg.Join.PackagesDir, name)
if st, err := os.Stat(p); err != nil || !st.Mode().IsRegular() {
http.NotFound(w, r)
return
}
w.Header().Set("Content-Type", "application/octet-stream")
http.ServeFile(w, r, p)
}
func shellQuote(s string) string { return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'" }
// psQuote quotes for PowerShell: single quotes, a quote doubled.
func psQuote(s string) string { return "'" + strings.ReplaceAll(s, "'", "''") + "'" }
// installPS1 is the Windows install script, for `& ([scriptblock]::Create((irm
// .../install.ps1))) -Join <token>` in PowerShell as Administrator.
//
//go:embed install.ps1
var installPS1 string
func (srv *Server) handleInstallPS1(w http.ResponseWriter, r *http.Request) {
s := strings.NewReplacer("@VERSION@", psQuote(version.Version), "@PACKAGES@", psQuote(srv.packagesBase(r))).Replace(installPS1)
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.Header().Set("Cache-Control", "no-store")
_, _ = w.Write([]byte(s))
}
const installScript = `#!/bin/sh
# Cairn OBS: install obs-beacon-agent on this host and join it to the
# obs-beacond that served this script.
#
# curl -fsSL https://<server>/install.sh | sudo sh -s -- --join <token>
#
# Options: --join <token> (from Hosts, Add host), --packages <url> (where
# the agent's .deb/.rpm and SHA256SUMS are), --force (replace an existing
# /etc/obs-beacon/agent.yaml).
set -eu
VERSION=@VERSION@
PACKAGES=@PACKAGES@
TOKEN=""
FORCE=""
say() { printf 'obs-beacon install: %s\n' "$*" >&2; }
die() { say "$*"; exit 1; }
while [ $# -gt 0 ]; do
case "$1" in
--join) [ $# -ge 2 ] || die "--join needs the token"; TOKEN=$2; shift 2 ;;
--packages) [ $# -ge 2 ] || die "--packages needs a URL"; PACKAGES=${2%/}; shift 2 ;;
--force) FORCE=-force; shift ;;
*) die "unknown option $1" ;;
esac
done
[ -n "$TOKEN" ] || die "run it with --join <token>: Hosts, Add host in the web interface makes one"
[ "$(id -u)" = 0 ] || die "run it as root (sudo sh)"
command -v systemctl >/dev/null 2>&1 || die "this host has no systemd; see docs/install.md"
if command -v obs-beacon-agent >/dev/null 2>&1; then
say "obs-beacon-agent is installed already: $(obs-beacon-agent -version)"
else
case "$(uname -m)" in
x86_64|amd64) DEB_ARCH=amd64 RPM_ARCH=x86_64 ;;
aarch64|arm64) DEB_ARCH=arm64 RPM_ARCH=aarch64 ;;
*) die "no package for $(uname -m)" ;;
esac
[ -n "$PACKAGES" ] || die "this server doesn't say where agent packages are (join.packages_dir or join.packages_url in obs-beacond.yaml). Install obs-beacon-agent by hand (docs/install.md), then: sudo obs-beacon-agent join <token>"
PKG_VERSION=$(printf '%s' "${VERSION#v}" | sed 's/-/~/')
if command -v dpkg >/dev/null 2>&1 && command -v apt-get >/dev/null 2>&1; then
FILE="obs-beacon-agent_${PKG_VERSION}_${DEB_ARCH}.deb"
elif command -v rpm >/dev/null 2>&1 && { command -v dnf >/dev/null 2>&1 || command -v yum >/dev/null 2>&1; }; then
FILE="obs-beacon-agent-${PKG_VERSION}-1.${RPM_ARCH}.rpm"
else
die "neither apt nor dnf/yum here; see docs/install.md"
fi
command -v curl >/dev/null 2>&1 || die "curl is needed"
command -v sha256sum >/dev/null 2>&1 || die "sha256sum is needed"
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT
say "fetching $FILE from $PACKAGES"
curl -fsSL -o "$TMP/SHA256SUMS" "$PACKAGES/SHA256SUMS" || die "can't fetch $PACKAGES/SHA256SUMS"
curl -fsSL -o "$TMP/$FILE" "$PACKAGES/$FILE" || die "can't fetch $PACKAGES/$FILE"
(cd "$TMP" && awk -v f="$FILE" '$2 == f' SHA256SUMS | grep -q . && awk -v f="$FILE" '$2 == f' SHA256SUMS | sha256sum -c --quiet -) || die "$FILE doesn't match SHA256SUMS"
case "$FILE" in
*.deb) DEBIAN_FRONTEND=noninteractive apt-get install -y -q "$TMP/$FILE" >/dev/null ;;
*.rpm) if command -v dnf >/dev/null 2>&1; then dnf install -y -q "$TMP/$FILE" >/dev/null; else yum install -y -q "$TMP/$FILE" >/dev/null; fi ;;
esac
say "installed $(obs-beacon-agent -version)"
fi
obs-beacon-agent join $FORCE "$TOKEN"
systemctl daemon-reload
systemctl enable --now obs-beacon-agent-helper.service >/dev/null 2>&1 || true
systemctl enable obs-beacon-agent.service >/dev/null 2>&1
systemctl restart obs-beacon-agent.service
say "done: obs-beacon-agent is running and reporting"
`