[cmd/prometheus_http_discovery] change listener arg to address-and-port; update labels

enable linux armv7 in cross targets

update bazel module deps

go mod tidy

[ldap] port ldap_health_exporter to builtin log and urfave/cli

[utils/log] implement slog.Handler interface

add some sqfs_package targets

[bazel] add sqfs_package rule

[pkg] multiarch support!

[sqpkg] add sqpkg-upload tool

- relocate direct interactions with object storage into k8s/sqpkg package
- add //cmd/sqpkg_upload

[http] use httputil.ReverseProxy in proxyAction (rename from staticUpstreamAction)

[bazel] optionally support separating Tag from Version

[mint] support `CertificateNotifyOnReload`

and clean up deprecated identity driver interface

[mtls/fsnotify] fix some crashes, improve clarity around locks

Concurrency safety was never fsnotify's strong point.

Use RWMutex to guard watchHandlers.

[sd] always publish on non-loopback addresses

When adding support for service discovery publishing as a sidecar, I realized that health probes are often performed against the loopback address, but the sd libraries don't support separate addresses for probing and publication.

This commit adds that by detecting the local primary IPv4 and IPv6 addresses when the probe address is a loopback IP.

Supporting changes:

- Add `net2` library with `MyIP4()` and `MyIP6()`

**🚫🤖 No AI**

[http] mtls, authzn overhaul

- authorizer route actions are replaced with a separate interface
- add support for mTLS server identities and client cert validation
- add client cert authorizer with fine grained control over SPIFFE domains, users & services
- fully support hot reload for TLS using hotSwappableTLSConfig
- add HTTPError struct type (implements error) to wrap http errors
- support tls config at both listener- and vhost-level

supporting changes:

- mtls: open up interface to allow checking subjects separately from cert validity
- mtls: add `VerifyYamlConfig` type for reusable partials
- mtls: add certObject primitive (public interface: `SwappableCert`) for concurrency-safe, guaranteed consistent access to cert object types that can briefly be inconsistent in underlying storage (e.g. filesystem)
- mtls/certutil: add SplitChain, SplitChainRoot, and IsSelfSigned functions
- mtls: cleanup deprecated IdentityDriver types
- mtls: add `CertificateNotifyOnReload` interface for cert types that can perform watch-/monitor-based reloads

known limitations:

- MTLSPeerVerifier really does not

incompatible config change: `auth` route property changes from string to []string

**🚫🤖 No AI**

[k8s] sqpkg CSI driver

No, this was not vibe coded. Actually there is nothing at all in this change that came from an LLM.

I don't want to build container images. I want to ship a generic, frequently-updated base archlinux container, and push binaries, configs, etc. separately. The plan is to build squashfs packages composed of a series of bazel targets and upload those to MinIO, then pull them down when a container wants to mount them.

Getting mksquashfs to work in Bazel without it complaining about including system headers because it can't decide if it's hermetic or not is proving to be the greatest challenge in this endeavor.

[mtls][mint] tag mint-issued certs with requester identity

- Add a way to tack arbitrary structured protobuf on to certificates using a `repeated google.protobuf.Any`
- Add `fuhry.runtime.service.mint.CertificateRequester` message to represent requester identity
- Block RequestCertificate calls if caller is using a cert that came from mint

generate all .pb.go with bazel, with packages driver for completion

tidy/deps update

add coredns nfpm package

template-ize dbus policy in runtime-utils, fix systemd unit path

[constants] add BuildTimestampTime

[pkg] support rename rules and multiple bazel-bin directories

I am not proud of this code, but at least it works.

```
bazel build //pkg:runtime_utils_deb_nfpm_pkg //pkg:runtime_utils_archlinux_nfpm_pkg
```

[sase] use public NewWebSocketBinaryReadWriter method

[cmd/machines_agent] enable building for linux-arm64

[stringmatch] add "not" matcher

[grpc] add nodep version of client, use in ephs

go is now enforcing that internal packages must stay internal, so we need a nodep version of //grpc's client functionality for ephs libs

add //thirdparty/coredns and fix cross compilation

go mod tidy, upgrade coredns to 1.14.3 + grpc-quic to 0.1.3

Cross-compilation support, phase 1

Get everything building without hooking up mtls_cgo.

Co-Authored-By: Qwen3.6-35B-A3B <noreply@qwen.ai>

add go_cross_binaries macro and start enabling some cmds on other platforms

[pkg] add nfpm package generation

- add nfpm_package bazel helper
- add nfpm config generator for discovering executables and systemd units added as bazel deps
- add packages for:
  - apcupsd-exporter
  - http-proxy
  - ldap-health-exporter
  - prometheus-helpers
  - runtime-utils

[utils/rollout] get rollout configs from ephs

[mint] support Deny directives in ACLs

[mint] support new mtls config provider API

[mtls] support configs for different environments, embed default configs

- Only try the identity drivers and paths listed in the config
- Use different default config based on environment heuristics
- Remove all hardcoded file paths, make file provider paths fully configurable

Supporting changes:
- Make IdentityLoaderFunc public
- Rename type: `IdentityClass` -> `VerifyMatchBy`

[mint] Send hostname and domain name, add templates

- Add templates for custom SANs derived from host info sent in gRPC req
- Supporting changes to proto, client, etc.

[mtls/fsnotify] hush fsnotify debug log messages

[grpc/server] instrument grpc servers

[grpc/server] support loading ACLs from ephs

[sd] add AddressUpdate type for easier stringification

[cmd/*] use generated systemd services

Part 1/?? of packaging/distribution overhaul: generate systemd services with bazel rules adjacent to cmd `go_binary` targets.

sync deps

[constants] use utils/subst library to generate constants

[ephs] split out low level client, add r/w permissions

ephsll contains the etcd interaction parts of ephs, and includes an `ephs.Client` implementation which can replace the default client for a process that has unrestricted access to the etcd prefix.

ACLs for ephs now also gain mode bits for read and write access separately, allowing subtrees or individual paths to be world-readable but writable only by the owner.

[utils/hostname] add CgroupInfoSelf and IsLikelyUserMachine, w/ tests

[metrics/metricbus] implement Add and Set on bare http counters and gauges

[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