ohmyserver

module
v0.0.0-...-b380bb8 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 18, 2026 License: MIT

README

OhMyServer

A server panel assembled from modules. Mature modules are projects of their own that also run on their own:

Module Project Standalone
Docker (containers, compose, app store) docker-go docker-go
Certificates (ACME) acme-go acme serve
Gateway (reverse proxy, TLS) yabber yabber run -admin …
DNS (resolver, filtering, zones) dns-go dns-go -config …
Port forwarding (TCP/UDP) forward-go forward-go
DHCP server (leases, reservations) dhcp-go dhcp-go -config …

Modules that are still small and change with the panel live in modules/ until they are mature enough to stand on their own:

Module Directory Standalone
SSH hosts and web terminal modules/ssh ssh-go
Scheduled jobs (cron) modules/cron cron-go
Xray proxy and routing modules/xray xray-go
Host monitoring modules/monitor monitor-go
CI (builds and tests in Docker) modules/ci ci-go
Packages (dnf, apt, installing Docker) modules/pkgmgr pkgmgr
Services (systemd) and logs (journal) modules/svcmgr svcmgr
Network (interfaces and settings, routes, ports, diagnostics) modules/netmgr netmgr
Firewall (nftables for the WAN, NAT) modules/fwmgr fwmgr
Disks (capacity, RAID, SMART health) modules/diskmgr diskmgr
Samba shares, settings and users (smb.conf) modules/smbmgr smbmgr
ZFS pools, datasets, snapshots and schedules modules/zfsmgr zfsmgr
Notifications: what modules report and what is still wrong modules/notify notify-go
Files (browse, edit, upload, download, move, copy) modules/filemgr filemgr
Domains at DNS providers (Cloudflare), and DNS-01 for certificates modules/domains domains

Every module follows the module contract: an API handler, assets with a manifest.json, and a mount(el, ctx) entry point. Modules never import each other or the panel; the ones in modules/ import nothing else from this repository either, so each directory can move out into a project of its own as it is.

This repository holds the assembly:

  • internal/shell mounts contract modules under one sign-in: it reads each manifest, serves the API at /m/<id>/api/ and the assets at /m/<id>/ui/, and renders each module into its own shadow root, passing the theme through the @lsongdev/stylesheets CSS variables.
  • internal/stores keeps the state of modules that use files on their own (docker-go's install records, yabber's configuration, forward-go's rules, dhcp-go's settings, reservations and leases) in the shared database, by implementing their store interfaces.
  • gateway connects modules through interfaces they define: the gateway serves acme-go's certificates and answers its HTTP-01 challenges, and docker-go apps with a domain become gateway sites with a certificate.
  • dns connects dns-go the same way: DNS-01 challenges for zones dns-go serves authoritatively are published there automatically, and for zones a domains account (Cloudflare) holds, there (other names stay manual), DoT/DoH listeners with tls: true serve acme-go's certificates, and an app domain inside a zone dns-go manages gets an address record pointing at host (config.yaml).
  • cron lets scheduled jobs run on the SSH module's saved hosts as well as on this machine, with the hosts' stored credentials and pinned host keys.
  • monitor lets the monitor module read the SSH module's saved Linux hosts over SSH, with nothing installed on them (one kept connection per host); the overview shows this machine's CPU, memory and disk.
  • CI builds on the Docker daemon the Docker module manages, so built images appear under Images; its webhook path is public in its manifest, so git hosts reach it without the panel's sign-in.
  • home is the panel's own overview module.
  • modules/pkgmgr drives the system's package manager (dnf or apt) and installs Docker for the modules that need it; the overview and the Docker module link there when Docker is missing.
  • modules/svcmgr manages systemd services and reads the journal; it never stops or disables the service running the panel.
  • modules/netmgr shows interfaces, routes, DNS servers and listening ports, runs diagnostics, and changes interface settings through NetworkManager or systemd-networkd. A change is on trial: it reverts by itself unless it is kept within two minutes, even if the panel crashes meanwhile. It is left out outside Linux.
  • modules/diskmgr shows file system capacity, software RAID arrays and each disk's SMART health (through smartctl-go), without waking sleeping disks.
  • modules/smbmgr edits Samba's smb.conf (shares, server settings, or the file as text) and its users; testparm checks every change before it replaces the file, and smbd reloads it. It is left out without Samba.
  • modules/zfsmgr takes, compares, deletes and rolls back to ZFS snapshots, and applies schedules with retention stored on the datasets, from a job in the job scheduler; retention only removes the snapshots schedules took. It is left out without ZFS.
  • modules/notify records what modules report and tracks the problems still open, shown on the overview, and sends them to chat services by each channel's rule, with an outbox, retries and rate limits.
  • modules/filemgr manages the server's files from /; system top-level directories cannot be deleted or moved.

The SSH and cron modules run commands on this machine and every saved host, so set a password whenever the panel listens beyond loopback.

  • cmd/ohmyserver opens the shared SQLite database (<data>/ohmyserver.db), builds every module and mounts them.

Settings come from <dir>/config.yaml, where <dir> is -d (default ~/.ohmyserver); without the file every setting takes its default. config.yaml.example documents each one: the panel's listen address, data directory (<dir> itself by default), sign-in password (OHMYSERVER_PASSWORD overrides it), apps host, the first-run gateway and DNS listeners, and the ACME timeouts and retries. For development, copy it to config.yaml in the checkout (git-ignored):

make deps     # npm ci in each UI: its browser dependencies
cp config.yaml.example config.yaml   # then set data: ./data
go run ./cmd/ohmyserver -d .

Each UI, the shell's (internal/shell/ui/static) and every module's (modules/*/web/ui or web/ui in a sibling checkout), declares its browser dependencies in its own package.json: @lsongdev/stylesheets, @lsongdev/scripts (with Preact and htm) and, for SSH, xterm.js. Go embeds them from that UI's node_modules, which is not committed, so run make deps (or make build, make test) before any go build, go run or go test; without it the shell refuses to start and says so.

On Linux with systemd, install or upgrade from the latest GitHub release:

curl -fsSLo install.sh https://raw.githubusercontent.com/lsongdev/ohmyserver/master/install.sh &&
  sudo sh install.sh

The installer verifies the binary and systemd unit against the release's SHA-256 checksums, then enables and restarts the service. It supports AMD64, ARM64, ARMv7 and RISC-V 64 and preserves existing configuration and data. The panel defaults to http://127.0.0.1:8080. From another machine, forward the port with ssh -L 8080:127.0.0.1:8080 user@server and open that address in your browser. To configure the service, use config.yaml.example as a reference for /var/lib/ohmyserver/config.yaml. Set a password before exposing the panel.

ImmortalWrt and OpenWrt

The procd service runs /usr/bin/ohmyserver with configuration and persistent data under /etc/ohmyserver. For a fresh install on an ARM64 Photonicat, build with make linux/arm64 and copy the binary and service script to the router:

scp -O dist/ohmyserver_linux_arm64 root@172.16.0.1:/usr/bin/ohmyserver
scp -O contrib/openwrt/ohmyserver root@172.16.0.1:/etc/init.d/ohmyserver
ssh root@172.16.0.1 'chmod 755 /usr/bin/ohmyserver /etc/init.d/ohmyserver && mkdir -p -m 700 /etc/ohmyserver'

Before starting the service, configure /etc/ohmyserver/config.yaml. Set a password when exposing the panel on the LAN. For a fresh installation, choose an alternate gateway HTTP address if LuCI already uses port 80. Start the service with /etc/init.d/ohmyserver start and enable it at boot with /etc/init.d/ohmyserver enable.

The gateway listens on :80 and :443 by default; gateway.http and gateway.https choose other addresses for a new installation, after which the configuration is edited in the panel. The DNS server is off until enabled under DNS → Settings. Its initial configuration is a forwarding resolver on :53 (UDP and TCP, dns.listen for a new installation). Changes to its listeners, upstreams and mode take effect at once. A listener that cannot bind (a port taken, or :53 without the privilege) shows in the overview instead of stopping the panel.

ACME network and recovery settings (the acme section) are passed to acme-go. Defaults are a 60-second request timeout, 30-second TLS handshake timeout, four safe-read attempts and four issuance attempts with backoff starting at one minute; validation_timeout (5m) bounds each authorization wait and order_timeout (10m) finalization and certificate download. An attempt limit of 1 disables retries at that layer. Unfinished issuances resume from their saved order and key after restart; the certificate panel shows attempt counts and the next retry time.

Development uses go.work with sibling checkouts of the projects (../docker-go, ../acme-go, ../yabber, ../dns-go, ../forward-go) and of the smartctl-go library (../smartctl-go).

Directories

Path Synopsis
cmd
ohmyserver command
Command ohmyserver runs the server panel: every module in one process, under one sign-in, sharing one database, wired together where they cooperate.
Command ohmyserver runs the server panel: every module in one process, under one sign-in, sharing one database, wired together where they cooperate.
Package cron connects the cron-go scheduler to the other modules.
Package cron connects the cron-go scheduler to the other modules.
Package dns connects the dns-go server to the other modules.
Package dns connects the dns-go server to the other modules.
Package gateway connects the yabber gateway to the other modules.
Package gateway connects the yabber gateway to the other modules.
Package home is OhMyServer's own module: an overview across every other module.
Package home is OhMyServer's own module: an overview across every other module.
internal
shell
Package shell is OhMyServer's panel host.
Package shell is OhMyServer's panel host.
shell/ui
Package ui embeds the shell's browser code: Preact and htm (vendor/, from npm), the layout and module host, and the components and design system the shell and its built-in modules use.
Package ui embeds the shell's browser code: Preact and htm (vendor/, from npm), the layout and module host, and the components and design system the shell and its built-in modules use.
stores
Package stores keeps module state in OhMyServer's shared database for modules that keep it in files when they run on their own.
Package stores keeps module state in OhMyServer's shared database for modules that keep it in files when they run on their own.
modules
cellular/internal/at
Package at manages a serial command session.
Package at manages a serial command session.
cellular/internal/modem
Package modem discovers Quectel modules and collects their cellular status.
Package modem discovers Quectel modules and collects their cellular status.
cellular/web
Package web exposes the cellular monitor through the panel module contract.
Package web exposes the cellular monitor through the panel module contract.
ci/api
Package api queues and runs builds, keeps their history and logs, takes webhooks from git hosts, and serves it all as a JSON API with relative routes.
Package api queues and runs builds, keeps their history and logs, takes webhooks from git hosts, and serves it all as a JSON API with relative routes.
ci/cmd/ci-go command
Command ci-go serves the CI on its own: builds run in Docker containers on the daemon the docker CLI would use, and the UI and API manage them.
Command ci-go serves the CI on its own: builds run in Docker containers on the daemon the docker CLI would use, and the UI and API manage them.
ci/docker
Package docker is the small part of the Docker Engine API that ci-go needs: pulling images, running containers and following their output, and removing what a build created.
Package docker is the small part of the Docker Engine API that ci-go needs: pulling images, running containers and following their output, and removing what a build created.
ci/pipeline
Package pipeline reads a repository's .ci.yml and runs it: each step in a container of its own, sharing the checked-out workspace.
Package pipeline reads a repository's .ci.yml and runs it: each step in a container of its own, sharing the checked-out workspace.
ci/store
Package store keeps repositories, builds and their step logs in SQLite.
Package store keeps repositories, builds and their step logs in SQLite.
ci/web
Package web assembles the CI as a panel module: repositories and builds in SQLite, the build queue running steps in Docker containers, the JSON API with its webhook endpoint, and the browser UI (native ES modules in ui/, no build step).
Package web assembles the CI as a panel module: repositories and builds in SQLite, the build queue running steps in Docker containers, the JSON API with its webhook endpoint, and the browser UI (native ES modules in ui/, no build step).
cron/api
Package api schedules jobs, runs them on their targets and keeps their history, and serves all of it as a JSON API with relative routes.
Package api schedules jobs, runs them on their targets and keeps their history, and serves all of it as a JSON API with relative routes.
cron/cmd/cron-go command
Command cron-go serves the job scheduler on its own: jobs run in this process, as its user, and the UI and API manage them.
Command cron-go serves the job scheduler on its own: jobs run in this process, as its user, and the UI and API manage them.
cron/runner
Package runner defines where job commands run.
Package runner defines where job commands run.
cron/schedule
Package schedule parses cron expressions and computes when they fire.
Package schedule parses cron expressions and computes when they fire.
cron/store
Package store keeps jobs and their run history in SQLite.
Package store keeps jobs and their run history in SQLite.
cron/web
Package web assembles the job scheduler as a panel module: jobs and their history in SQLite, the scheduler, the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the job scheduler as a panel module: jobs and their history in SQLite, the scheduler, the JSON API and the browser UI (native ES modules in ui/, no build step).
diskmgr/api
Package api is the disk module's JSON API: capacity of the mounted file systems, software RAID arrays, and the disks with their SMART health and self-tests.
Package api is the disk module's JSON API: capacity of the mounted file systems, software RAID arrays, and the disks with their SMART health and self-tests.
diskmgr/cmd/diskmgr command
Command diskmgr serves the disk module on its own: the UI and API show capacity, RAID arrays and SMART health, and start self-tests; smartctl needs root.
Command diskmgr serves the disk module on its own: the UI and API show capacity, RAID arrays and SMART health, and start self-tests; smartctl needs root.
diskmgr/system
Package system reads a host's storage: block devices (lsblk on Linux, diskutil on macOS), mounted file systems and their capacity (df), software RAID arrays (/proc/mdstat, Linux) and disk health (smartctl, through smartctl-go).
Package system reads a host's storage: block devices (lsblk on Linux, diskutil on macOS), mounted file systems and their capacity (df), software RAID arrays (/proc/mdstat, Linux) and disk health (smartctl, through smartctl-go).
diskmgr/web
Package web assembles the disk module for a panel: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the disk module for a panel: the JSON API and the browser UI (native ES modules in ui/, no build step).
domains/api
Package api manages DNS provider accounts and the zones and records they hold, as a JSON API with relative routes, and publishes ACME DNS-01 records in them (see Challenges).
Package api manages DNS provider accounts and the zones and records they hold, as a JSON API with relative routes, and publishes ACME DNS-01 records in them (see Challenges).
domains/cmd/domains command
Command domains serves the domains module on its own: DNS provider accounts (Cloudflare, …) and the zones and records they hold.
Command domains serves the domains module on its own: DNS provider accounts (Cloudflare, …) and the zones and records they hold.
domains/provider
Package provider describes DNS hosting services (Cloudflare, …) through one interface: the zones an account holds and their records.
Package provider describes DNS hosting services (Cloudflare, …) through one interface: the zones an account holds and their records.
domains/provider/cloudflare
Package cloudflare is the Cloudflare DNS provider, on the v4 REST API with an API token.
Package cloudflare is the Cloudflare DNS provider, on the v4 REST API with an API token.
domains/provider/dnspod
Package dnspod implements DNSPod's traditional mainland API (DNSPod Token).
Package dnspod implements DNSPod's traditional mainland API (DNSPod Token).
domains/provider/namecom
Package namecom manages Name.com DNS through its v4 REST API.
Package namecom manages Name.com DNS through its v4 REST API.
domains/store
Package store keeps DNS provider accounts in SQLite.
Package store keeps DNS provider accounts in SQLite.
domains/web
Package web assembles the domains module: DNS provider accounts in SQLite, the JSON API, and the browser UI (native ES modules in ui/, no build step).
Package web assembles the domains module: DNS provider accounts in SQLite, the JSON API, and the browser UI (native ES modules in ui/, no build step).
filemgr/api
Package api is the file manager's JSON API.
Package api is the file manager's JSON API.
filemgr/cmd/filemgr command
Command filemgr serves the file manager on its own: the UI and API browse, view, edit, upload, download, move, copy and delete files under a root directory, as the user running it.
Command filemgr serves the file manager on its own: the UI and API browse, view, edit, upload, download, move, copy and delete files under a root directory, as the user running it.
filemgr/files
Package files carries out file operations under a root directory: listing, reading and writing text, uploads, downloads (directories as tar.gz), creating folders, renaming, moving, copying and deleting.
Package files carries out file operations under a root directory: listing, reading and writing text, uploads, downloads (directories as tar.gz), creating folders, renaming, moving, copying and deleting.
filemgr/web
Package web assembles the file manager for a panel: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the file manager for a panel: the JSON API and the browser UI (native ES modules in ui/, no build step).
fwmgr/api
Package api is the firewall manager's JSON API.
Package api is the firewall manager's JSON API.
fwmgr/cmd/fwmgr command
Command fwmgr serves the firewall manager on its own: the UI and API change interface settings, so it usually runs as root.
Command fwmgr serves the firewall manager on its own: the UI and API change interface settings, so it usually runs as root.
fwmgr/system
Package system renders and applies one nftables table: protection for the interfaces that face the internet, and NAT for what leaves through them.
Package system renders and applies one nftables table: protection for the interfaces that face the internet, and NAT for what leaves through them.
fwmgr/web
Package web assembles the firewall manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the firewall manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
monitor/api
Package api samples every monitored host on an interval, keeps their history, and serves both as a JSON API with relative routes.
Package api samples every monitored host on an interval, keeps their history, and serves both as a JSON API with relative routes.
monitor/cmd/monitor-go command
Command monitor-go monitors this machine on its own: it samples CPU, memory, disks and network, keeps their history and serves the UI and API.
Command monitor-go monitors this machine on its own: it samples CPU, memory, disks and network, keeps their history and serves the UI and API.
monitor/collector
Package collector defines where readings come from.
Package collector defines where readings come from.
monitor/metrics
Package metrics defines what monitor-go measures: a Reading is what a collector reads from a host at one moment (with cumulative counters), and a Sample is what two consecutive readings say about the time between them (usage percentages and rates).
Package metrics defines what monitor-go measures: a Reading is what a collector reads from a host at one moment (with cumulative counters), and a Sample is what two consecutive readings say about the time between them (usage percentages and rates).
monitor/procfs
Package procfs reads a Linux host through a shell: Script prints what /proc and a few commands say, in one round trip, and Parse turns that output into a reading and host info.
Package procfs reads a Linux host through a shell: Script prints what /proc and a few commands say, in one round trip, and Parse turns that output into a reading and host info.
monitor/store
Package store keeps hosts and their samples in SQLite, at three resolutions: raw samples for a day, one-minute averages for a week and one-hour averages for three months, so the database stays small however long it runs.
Package store keeps hosts and their samples in SQLite, at three resolutions: raw samples for a day, one-minute averages for a week and one-hour averages for three months, so the database stays small however long it runs.
monitor/web
Package web assembles the host monitor as a panel module: the sampler, its SQLite history, the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the host monitor as a panel module: the sampler, its SQLite history, the JSON API and the browser UI (native ES modules in ui/, no build step).
netmgr/api
Package api is the network manager's JSON API: interfaces, routes, DNS servers, listening ports and diagnostics to read, and interface settings to change.
Package api is the network manager's JSON API: interfaces, routes, DNS servers, listening ports and diagnostics to read, and interface settings to change.
netmgr/cmd/netmgr command
Command netmgr serves the network manager on its own: the UI and API change interface settings, so it usually runs as root.
Command netmgr serves the network manager on its own: the UI and API change interface settings, so it usually runs as root.
netmgr/system
Bridges join interfaces into one network, as a switch does.
Bridges join interfaces into one network, as a switch does.
netmgr/web
Package web assembles the network manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the network manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
notify/api
Package api is the notification center: it records what modules and scripts report, keeps track of the problems still open, and serves both as a JSON API with relative routes.
Package api is the notification center: it records what modules and scripts report, keeps track of the problems still open, and serves both as a JSON API with relative routes.
notify/channels
Package channels sends messages out: to any web hook, with presets for the common services, and to Telegram.
Package channels sends messages out: to any web hook, with presets for the common services, and to Telegram.
notify/cmd/notify-go command
Command notify-go serves the notification center on its own; a panel shell can mount the same module (web.New) beside others instead.
Command notify-go serves the notification center on its own; a panel shell can mount the same module (web.New) beside others instead.
notify/store
Package store keeps events and issues in SQLite, in tables prefixed "notify_", so the database can be shared with other modules.
Package store keeps events and issues in SQLite, in tables prefixed "notify_", so the database can be shared with other modules.
notify/web
Package web assembles the notification center as a panel module: events and issues in SQLite, the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the notification center as a panel module: events and issues in SQLite, the JSON API and the browser UI (native ES modules in ui/, no build step).
pkgmgr/api
Package api is the package manager's service and JSON API.
Package api is the package manager's service and JSON API.
pkgmgr/cmd/pkgmgr command
Command pkgmgr serves the package manager on its own: the UI and API install, remove and upgrade the system's packages with dnf or apt, so it usually runs as root.
Command pkgmgr serves the package manager on its own: the UI and API install, remove and upgrade the system's packages with dnf or apt, so it usually runs as root.
pkgmgr/system
Package system drives the host's package manager through its command-line tools: dnf on Fedora and Enterprise Linux (RHEL, Rocky, AlmaLinux, Alibaba Cloud Linux, …), apt on Debian and Ubuntu, pacman on Arch Linux, and Homebrew on macOS.
Package system drives the host's package manager through its command-line tools: dnf on Fedora and Enterprise Linux (RHEL, Rocky, AlmaLinux, Alibaba Cloud Linux, …), apt on Debian and Ubuntu, pacman on Arch Linux, and Homebrew on macOS.
pkgmgr/web
Package web assembles the package manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the package manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
smbmgr/api
Package api is the Samba manager's JSON API: shares and server settings edited as parameters, smb.conf edited as text, Samba users, and who is connected.
Package api is the Samba manager's JSON API: shares and server settings edited as parameters, smb.conf edited as text, Samba users, and who is connected.
smbmgr/cmd/smbmgr command
Command smbmgr serves the Samba manager on its own: the UI and API edit smb.conf and Samba users, so it usually runs as root.
Command smbmgr serves the Samba manager on its own: the UI and API edit smb.conf and Samba users, so it usually runs as root.
smbmgr/system
Package system reads and changes a Samba server: its smb.conf, checked with testparm before it replaces the file, its users (smbpasswd and pdbedit) and who is connected (smbstatus).
Package system reads and changes a Samba server: its smb.conf, checked with testparm before it replaces the file, its users (smbpasswd and pdbedit) and who is connected (smbstatus).
smbmgr/web
Package web assembles the Samba manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the Samba manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
ssh/api
Package api manages saved SSH hosts and opens terminals on them, as a JSON API with relative routes plus a WebSocket terminal.
Package api manages saved SSH hosts and opens terminals on them, as a JSON API with relative routes plus a WebSocket terminal.
ssh/cmd/ssh-go command
Command ssh-go serves the SSH terminal on its own: saved hosts and a web terminal on each.
Command ssh-go serves the SSH terminal on its own: saved hosts and a web terminal on each.
ssh/hosts
Package hosts describes saved SSH hosts and connects to them: password, private key or the panel's own key authentication, and host keys pinned on first use.
Package hosts describes saved SSH hosts and connects to them: password, private key or the panel's own key authentication, and host keys pinned on first use.
ssh/store
Package store keeps SSH hosts and the panel key in SQLite.
Package store keeps SSH hosts and the panel key in SQLite.
ssh/web
Package web assembles the SSH terminal as a panel module: saved hosts in SQLite, the JSON API with its WebSocket terminal, and the browser UI (native ES modules in ui/, no build step).
Package web assembles the SSH terminal as a panel module: saved hosts in SQLite, the JSON API with its WebSocket terminal, and the browser UI (native ES modules in ui/, no build step).
svcmgr/api
Package api is the service manager's JSON API: systemd services, their state, actions and unit files, and the journal, which it can also stream as server-sent events.
Package api is the service manager's JSON API: systemd services, their state, actions and unit files, and the journal, which it can also stream as server-sent events.
svcmgr/cmd/svcmgr command
Command svcmgr serves the service manager on its own: the UI and API start, stop and enable systemd services and read the journal, so it usually runs as root.
Command svcmgr serves the service manager on its own: the UI and API start, stop and enable systemd services and read the journal, so it usually runs as root.
svcmgr/system
Package system drives systemd through systemctl and journalctl: listing services, showing their state and unit files, starting and stopping them, and reading the journal.
Package system drives systemd through systemctl and journalctl: listing services, showing their state and unit files, starting and stopping them, and reading the journal.
svcmgr/web
Package web assembles the service manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
Package web assembles the service manager as a panel module: the JSON API and the browser UI (native ES modules in ui/, no build step).
xray/cmd/xray-go command
Command xray-go serves the Xray module on its own.
Command xray-go serves the Xray module on its own.
xray/engine
Package engine manages one embedded Xray instance and its saved configuration.
Package engine manages one embedded Xray instance and its saved configuration.
xray/web
Package web exposes the embedded Xray engine as a panel module.
Package web exposes the embedded Xray engine as a panel module.
zfsmgr/api
Package api is the ZFS snapshot manager's JSON API: snapshots to list, take, rename, compare, delete and roll back to, and the retention policies a scheduler applies to datasets.
Package api is the ZFS snapshot manager's JSON API: snapshots to list, take, rename, compare, delete and roll back to, and the retention policies a scheduler applies to datasets.
zfsmgr/cmd/zfsmgr command
Command zfsmgr serves the ZFS snapshot manager on its own: it runs zfs, so it usually runs as root, and applies retention policies for as long as it runs.
Command zfsmgr serves the ZFS snapshot manager on its own: it runs zfs, so it usually runs as root, and applies retention policies for as long as it runs.
zfsmgr/system
Package system drives the zfs and zpool commands.
Package system drives the zfs and zpool commands.
zfsmgr/web
Package web assembles the ZFS snapshot manager as a panel module: the JSON API, what applies retention policies, and the browser UI (native ES modules in ui/, no build step).
Package web assembles the ZFS snapshot manager as a panel module: the JSON API, what applies retention policies, and the browser UI (native ES modules in ui/, no build step).
Package monitor connects the monitor-go host monitor to the other modules.
Package monitor connects the monitor-go host monitor to the other modules.
Package notify connects the notification center to the modules that report to it: each defines the small interface it needs, and implements it here, with the source fixed so that it cannot be forged.
Package notify connects the notification center to the modules that report to it: each defines the small interface it needs, and implements it here, with the source fixed so that it cannot be forged.
Package panel holds the browser runtime of the panel module contract (docs/module-contract.md) in one place: mount, the page context, form helpers, the API client, formatting, the standalone host and module.css, the styles every module shares.
Package panel holds the browser runtime of the panel module contract (docs/module-contract.md) in one place: mount, the page context, form helpers, the API client, formatting, the standalone host and module.css, the styles every module shares.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL