[ephs] split server into servicer and low-level client

Make the ephs servicer act as a front-end to the ephs low-level client library, which handles all direct interaction with etcd.

- Move all ephs etcd interaction from `ephs/servicer` to `ephs/ephsll`
- Add ephs.Path type to make ephs path transformations simpler
- Refactor grpc's `WithStaticAddress` option to support DNS names

[utils/log] fix prepending prefix to FATAL messages

[ephs] `edit` command, client library and server improvements

- fixed server failing to build since 020d9e6d because s3.go referenced the removed `genericOption` type
- add custom error type for not-found errors so they are easier to distinguish
- validate S3 credentials on server startup
- add `edit` command to ephs commandline client to allow editing text files directly in ephs

[mint] add new service: mint

Add a mint service which can issue certificates for other service identities based on configured rules. This allows, for example, a service to use its own identity to request a temporary `etcd-client` certificate.

The mint service applies the following restrictions:

1. Only service account identities may be requested.
2. Clients are not allowed to request a certificate for their own identity.
3. Issued certificates will always use the same SPIFFE domain as the original requester's certificate.
4. Certificates issued by the mint service expire at the same time as the client certificate used to make the connection to the mint service.
5. The rules for which services are allowed to request which identities are defined in a YAML file stored in ephs at (by default) `/ephs/local/services/mint/rules.yaml`.

[grpc/client] make serverId a string

Prevent gRPC clients from trying to load the server's identity by calling `mtls.NewRemoteServiceIdentity` (which only returns a stub identity) and changing the `NewGrpcClient` function signature to accept a string instead of an Identity.

Genericize "option" interface

"Option" variadic pattern has been used in lots of things lately - grpc client and server, ephs, etc. Although the implementation is trivial, the repetition was becoming obnoxious.

Other trivial fixes:
- Fixed sd watcher wait group never calling Done if etcd client context is canceled
- Fixed etcd_factory type declaration

[mtls] add lazy identities, loader improvements

- indicate principal class and name separately to loader drivers
- add LazyIdentity to delay calling drivers until credentials are needed

[mtls] make some types and functions public

Make public the necessary functions and types to allow other packages to register identity and roots providers.

- Types `CertificatePrimitive` and `RootsPrimitive`
- Driver registration functions: `RegisterIdentityDriver`, `RegisterRootDriver`
- `newDialContextFunc` -> `MakeDialContextFunc`
- `newTlsCertificate` -> `MakeTlsCertificate`

[grpc] adopt Option pattern, add DNS SRV support

- Allow gRPC server and client factories to accept variadic Options
- Add `ClientOption`: `WithDNSSRV`, which uses DNS SRV queries instead of SD
- Add `ServerOption`: `WithTransport` (overrides `-grpc.transport` flag)
- Force ephs server to use QUIC transport as QUIC is hardcoded into the client library

[grpc/healthcheck] add missing List RPC (unimplemented)

[grpc] make PeerIdentity take a context instead of peer.Peer; break out cert retrieval into new PeerCertificate helper

[proto/service/ephs] rename files with unique names

[mtls] add common identity parser

Add a new function in `mtls`, `ParseIdentity`, which standardizes the following prefixes for identities:
- "user." for human users
- "ssl://" for publicly trusted certs
- the exact string "anonymous" for anonymous access
- all other strings are parsed as service identities

The etcd client is configured to follow this convention.

[http/route_action_s3] use etag over ChecksumSHA1; fix URL decoding; limit to GET and HEAD

only enable cgo on amd64 for now

fix building pkcs11 features on linux

[mtls] merge the init functions in provider_macos_keychain

[sd/etcd_factory] try default identity if etcd identity fails

And fail without trying to connect if neither the etcd identity nor default identity are valid.

cleanup bazel files for uncommitted packages

metricbus: abstract transport

- rename metricbus/internal -> metricbus/mbserver due to import from //cmd/metricbus_server
- add httpserver transport
- add utils/rollout library for... controlling rollouts

bulk replace all signal.NotifyContext with utils/context.Interruptible()

constants: rename constants.go.in -> constants_in.go so IDEs pick it up

[grpc] support loading ACLs from ephs

Supporting changes:

- Rearranged grpc into internal/{client,server,common} packages to deal with circular dep between ephs and grpc
- Rename `mtls.parseName` -> `mtls.ParseRemoteIdentity` and make the returned struct and its properties public
- In ephs server ACLs, try to parse principal; if successful, set `name`, `class` and `domain` substitutions in the key
- Fixed severely incorrect invocation of acl.Check in ephs server (not a security issue, legitimate requests were blocked but no illegitimate requests were allowed)
- Add `utils/context` package - wrapper for `context` with shared `Interruptible` context that cancels on SIGTERM and SIGINT

Merge branch 'migrate-to-bazel'

initial effort to migrate to bazel

utils/hostname: add Containerization for macos

fsnotify: use os.Getwd instead of syscall.Getcwd

update go.mod and go.sum

[mtls] add provider_anonymous

utils/stringmatch: add Sub method; utils/hashset: add Equal method

more ephs

[machines_agent] parse mac address before posting to /api/host/seen

[http/proxy] enable config_watcher + live reload support

Add ephs ("ephemeral filesystem")

[http] live reload, SNI proxying, bugfixes

- Initial backend live reload support, to be enabled in binary with merge of ephs/config_watcher
- Fix SNI listener closure upon single connection TLS handshake error

[http/s3] support `if-modified-since` and `if-none-match`

[http] SNI proxying, healthcheck action, populate authorization, better handle nested authorization, docs

- added readme, because this is seriously getting too complicated for me to configure from memory
- refactored connection acceptance with a new `net.Listener` implementation that supports SNI, with virtual listeners that can be used with `http.Server`
- foundations laid for bare-TCP SNI proxying too, but implementation not started yet
- added `healthcheck` action
- added a mutable request context at the logging middleware level, to bubble up request data to the logger
- propagate SAML authorization state to global request context
- SAML action now skips if request was previously authorized
- got multiple listeners + multiple vhosts per listener working

No breaking config changes.

[http] add request IDs w/tracing support

[http] support ranges for route_action_s3

thirdparty/registry: add s3-aws driver

[http] fix s3 chunk size workaround, enable H2 ALPN

- Set `NextProtos` to `[]string{"h2"}` when setting up tls config for http server
- Use `io.CopyN` to stream response in route_action_s3

add mtls/supervisor command

utils: add SetVerbosity/SetLevel to log; implement Containerization() for OpenBSD

utils/debounce: fix debouncer not always triggering

machines/coredns_plugin: use RWMutex to guard registryStore reads

go mod tidy

Makefile: include all .go files from maindirs, exclude vendor/ from target detection

fsnotify: robust support for detecting changes to k8s config objects

Kubernetes uses a fairly crazy scheme for files mounted from config maps and in-memory CSI drivers:

  /mnt/file     -> ..data/file
  /mnt/..data   -> ..TIME
  /mnt/..TIME/file (real file)

New versions of the config state are published atomically by doing

  symlink(/mnt/..NEWTIME, /mnt/..data_new)
  rename(/mnt/..data_new, /mnt/..data)

To detect changes to the contents of /mnt/file using inotify instead of polling file contents, we need to detect when /mnt/..data is overwritten.

This requires complex symlink detection and resolution for not only the file but any of the directories in its path, and tracking of final absolute path and inode number to detect when the file was swapped with a different one.

This commit adds that support to fsnotify, along with lots of documentation and tests.

refactor MetricBusService to an interface

D-Bus metricbus server is being deprecated and being replaced with an https server that registers itself in sd and publishes its own stats.

This is the first step in the refactor, converting `MetricBusService` to an interface and updating all references accordingly. Full implementation will come later.

[sd] workaround for no FQDN in k8s when populating ShardRegion

[mtls] use fullchain for leaf and chain when individual files unavailable

Fixes cert loading failures in k8s with certificates from cert-manager

[http/saml] cookie bugfixes

- strip auth cookies before forwarding to origin
- when no session, send 401 instead of redirect for CORS and websocket requests
- delete unused relaystate cookies

[http] add PROXY protocol v1 and v2 support

[metricbus/mbserver] default to port 0 (randomly assigned by OS)

[metricbus] publish server in SD

[sd] write logs once at notice level when health status changes

[sd] several bugfixes incl. http healthchecker memory leak

health-exporter: include node name in labels, publish under correct otel-tls service

fix proxy systemd unit

coredns_plugin: wildcard support for DNS records

stringmatch: add "any" and "never" matchers

Fine let's just make it a full HTTP proxy

Refactor samlproxy into a general purpose proxy with pluggable actions. Add S3 bucket serving backend. Route actions can fulfill the request or modify it and call next(), basically the same idea as coredns but for http.

Backwards incompatible with existing configs.

[http/samlproxy] support route actions - just redirects for now

[http/samlproxy] listener address in yaml; add unsecure listener for http->https redirections

[http/samlproxy] add systemd service, allow username header to be customized

[http/samlproxy] multiple vhosts, loadable yaml config, SAML config per vhost

add prometheus_http_discovery program

[sd] differentiate node name and shard name

Shard is not always applicable to sd entries, but sd entries do need
some kind of discriminator for etcd path collision avoidance.

Use the first element of the hostname for collision avoidance, and make
shard an optional element that nests items one level deeper.

samlproxy: update for latest log changes

Merge branch 'main' of gitlab.web.xx0r.info:dan/go-runtime

add gRPC client and server for Bryston autio device remote control

mtls: add more logging to pkcs11 and tpm2 code

add log writer interface

machines bugfixes

- handle interface:deleted and host:deleted events
- coredns plugin: only call tryInit if we fail to load the saved state from disk
- coredns plugin: make all hostname lookups case insensitive
- coredns plugin: fix <interface>.<host>.<domain> lookups
- coredns plugin: bump init ticker interval to 10 seconds
- coredns plugin: tighten lock window when updating registry from API
- coredns plugin: increase verbosity level of some really noisy log messages
- tweak mqtt startup
- fix `allow/deny unknown-clients` being added to dhcp subnets with only one range
- add captive portal service in openbsd, fix maclist template

[http] add samlproxy

Add a basic SAML-enforcing sidecar proxy for future use with various internal services.

go mod tidy

stringmatch: support serialization, add tests, etc.

metrics/metricbus: add healthcheck endpoint

utils/log: record body size, request duration, initialize status to 200

fix panic

move HTTP logging middleware to log package

HTTP access logs are needed in more places, so it makes sense to make this code reusable.

log: make Logger an interface

Logger needs to be mockable, and for that we need it to be an interface.

go mod tidy; update to go1.23

[mtls] Support service identity from cert-manager-csi-driver-spiffe

K8s support, commit 3 of 3.

Check the default mount location of `cert-manager-csi-driver-spiffe` for service certificate discovery. Support default and certbot file naming schemes.

[sd] add SRVHost option

Kubernetes support, commit 2 of 3: publish `pod-name.service.<SDDomain>` as the name in the SRV record when Kubernetes is detected. Preserve legacy behavior by defaulting to `AdvertiseHost` if configured, or our FQDN if not.

hostname: support /etc/hosts, /etc/resolv.conf; add container detection

Needed for Kubernetes compatibility.

Kubernetes doesn't publish DNS records for pods. So the runtime can no longer assume that A/AAAA records exist for the host.

As a first step we need to be able to detect the hostname and kubernetes domain name. K8s is pretty good about populating `/etc/hosts` and `/etc/resolv.conf`, so we parse those when k8s is detected.

go mod tidy

sd/systemd: use generic network-online.target instead of systemd-networkd-wait-online.service

mtls/provider_file: better logging for load failures

machines: mqtt client: use credentials provider, not updateCreds

Fixes mqtt not successfully connecting on the first try (only on retries).

machines/coredns_plugin: map interface name + hostname to host ID

Will be used soon to support querying by interface name (not complete
yet)

machines/agent: support dns_server_v[46] fields with interface name stand ins

Add support for the `dns_server_v4` and `dns_server_v6` domain fields.

If either is a unix network interface name, use the primary IP address of that interface as the address.

machines: start captive portal config (not done yet)

machines_agent: daemonize with utils/daemon

utils/daemon: add new package

Add new "daemon" package to handle detaching on Linux and Unix systems.
Supports writing pid files, socket pair based startup messaging, and
systemd notification on Linux.

utils/hostname: handle special case of domain name = "(none)" on linux

Linux systems can return interesting values when the domain name is
unset, like "(none)" or an empty string. To handle these, hostname.go is
forked with special Hostname(), DomainName() and RegionName()
implementations for Linux and the original implementations for other
OSes.

utils/log: only init default logger once

Fixes configuration of the default logger via flags

dns: exclude 169.254.0.0/16 from lookup results, too

dns_cache: bypass systemd-resolved

On Linux systems, the stub resolv.conf points at systemd-resolved which uses the hostsfile. We don't want this - we need the system's addresses as described by the network's DNS server.

machines_agent: allow starting/stopping/restarting services from machines_agent cmd