feat: add model groups, verified registration and CNY credit grants
This commit is contained in:
1 parent
f5ba6cb255
commit
7a18db2123
40 files changed
+1980
-263
No files matched your search
@@ -0,0 +1,278 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Reset the existing owner of a single-instance MOYI cloud deployment."""
|
||||
import argparse
|
||||
import base64
|
||||
import copy
|
||||
import getpass
|
||||
import hashlib
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import secrets
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import urllib.parse
|
||||
|
||||
|
||||
class MaintenanceError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def require(condition, message):
|
||||
if not condition:
|
||||
raise MaintenanceError(message)
|
||||
|
||||
|
||||
def run(command, *, cwd=None, env=None, sql=None, timeout=240):
|
||||
options = {"input": sql} if sql is not None else {"stdin": subprocess.DEVNULL}
|
||||
result = subprocess.run(command, cwd=cwd, env=env, capture_output=True,
|
||||
text=True, encoding="utf-8", timeout=timeout, **options)
|
||||
# Database/Compose error messages can contain secrets or SQL; never echo them.
|
||||
require(result.returncode == 0, Path(command[0]).name + " failed; output withheld to protect credentials.")
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def password_hash(password, pepper):
|
||||
salt = secrets.token_bytes(16)
|
||||
key = hashlib.pbkdf2_hmac("sha256", (password + pepper).encode("utf-8"), salt, 210000, 32)
|
||||
encode = lambda value: base64.urlsafe_b64encode(value).decode("ascii").rstrip("=")
|
||||
return "pbkdf2$210000$" + encode(salt) + "$" + encode(key)
|
||||
|
||||
|
||||
def sql_literal(value):
|
||||
# Hex also prevents dollar-quote delimiters from appearing inside a DO body.
|
||||
return "convert_from(decode('" + str(value).encode("utf-8").hex() + "', 'hex'), 'UTF8')"
|
||||
|
||||
|
||||
def updated_environment(original, account, password):
|
||||
require(password.strip() and not any(ord(char) < 32 or ord(char) == 127 for char in password),
|
||||
"Password must be nonblank and cannot contain control characters.")
|
||||
require(password != "admin123", "The development default password is not allowed.")
|
||||
# Append effective overrides, then ask Compose to validate them. Do not parse
|
||||
# or rewrite arbitrary existing dotenv values, which may be multiline/quoted.
|
||||
values = {"ADMIN_ACCOUNT": account, "ADMIN_PASSWORD": password}
|
||||
return original.rstrip("\r\n") + "\n\n# Owner credentials set by admin_credentials.py\n" + "".join(
|
||||
key + "=" + json.dumps(value, ensure_ascii=False).replace("$", "$$") + "\n"
|
||||
for key, value in values.items())
|
||||
|
||||
|
||||
def validate_staged_config(before, after, account, password):
|
||||
expected = copy.deepcopy(before)
|
||||
expected["services"]["moyi-api"]["environment"].update(
|
||||
ADMIN_ACCOUNT=account, ADMIN_PASSWORD=password)
|
||||
require(after == expected, "Staged configuration differs unexpectedly. Check shell environment overrides; nothing was changed.")
|
||||
|
||||
|
||||
def postgres_environment(api, expected_database):
|
||||
url = str(api["SPRING_DATASOURCE_URL"])
|
||||
require(url.startswith("jdbc:postgresql://"), "PostgreSQL JDBC URL required.")
|
||||
target = urllib.parse.urlsplit(url[5:])
|
||||
require(urllib.parse.unquote(target.path) == "/" + expected_database and target.hostname
|
||||
and not target.username and not target.password, "Database target does not match --database.")
|
||||
query = urllib.parse.parse_qs(target.query, keep_blank_values=True)
|
||||
supported = {"sslmode": "PGSSLMODE", "sslrootcert": "PGSSLROOTCERT", "sslcert": "PGSSLCERT", "sslkey": "PGSSLKEY"}
|
||||
require(all(key in supported and len(value) == 1 for key, value in query.items()),
|
||||
"Unsupported JDBC parameters; review TLS settings before maintenance.")
|
||||
env = {key: value for key, value in os.environ.items() if not key.startswith("PG")}
|
||||
env.update(PGHOST=target.hostname, PGPORT=str(target.port or 5432), PGDATABASE=expected_database,
|
||||
PGUSER=str(api["SPRING_DATASOURCE_USERNAME"]), PGPASSWORD=str(api["SPRING_DATASOURCE_PASSWORD"]),
|
||||
PGCONNECT_TIMEOUT="10", PGAPPNAME="moyi-admin-maintenance", PGCLIENTENCODING="UTF8")
|
||||
for key, value in query.items():
|
||||
env[supported[key]] = value[0]
|
||||
return env
|
||||
|
||||
|
||||
def query_database(psql, env, sql):
|
||||
return run([psql, "-X", "--no-password", "-qAt", "-v", "ON_ERROR_STOP=1", "-f", "-"], env=env, sql=sql)
|
||||
|
||||
|
||||
def read_owner(psql, env, configured_account, new_account):
|
||||
rows = json.loads(query_database(psql, env, """
|
||||
SELECT COALESCE(json_agg(json_build_object('id', id, 'account', account, 'status', status)), '[]'::json)
|
||||
FROM public.users WHERE role = 'super_admin';
|
||||
"""))
|
||||
require(len(rows) == 1 and rows[0]["status"] == "active", "Expected exactly one active super administrator.")
|
||||
normalized = re.sub(r"[\s-]", "", configured_account.strip().lower())
|
||||
# The second case permits retry after DB commit but before env installation.
|
||||
require(rows[0]["account"] in (normalized, new_account.lower()),
|
||||
"Existing owner differs from both configured and requested accounts; refusing to change it.")
|
||||
occupied = query_database(psql, env, "SELECT count(*) FROM public.users WHERE account = "
|
||||
+ sql_literal(new_account.lower()) + " AND id <> " + sql_literal(rows[0]["id"]) + "::uuid;")
|
||||
require(occupied == "0", "Requested account is already used by another user; nothing changed.")
|
||||
return rows[0]
|
||||
|
||||
|
||||
def reset_sql(database, owner, account, encoded):
|
||||
database, user_id, previous, account, encoded = map(sql_literal, (
|
||||
database, owner["id"], owner["account"], account.lower(), encoded))
|
||||
return f"""
|
||||
BEGIN;
|
||||
SET LOCAL standard_conforming_strings = on;
|
||||
SET LOCAL lock_timeout = '10s';
|
||||
SET LOCAL statement_timeout = '30s';
|
||||
LOCK TABLE public.users IN SHARE ROW EXCLUSIVE MODE;
|
||||
DO $moyi_reset$
|
||||
BEGIN
|
||||
IF current_database() <> {database} THEN
|
||||
RAISE EXCEPTION 'Wrong database';
|
||||
END IF;
|
||||
IF (SELECT count(*) FROM public.users WHERE role = 'super_admin') <> 1
|
||||
OR NOT EXISTS (SELECT 1 FROM public.users WHERE id = {user_id}::uuid
|
||||
AND account = {previous} AND role = 'super_admin' AND status = 'active') THEN
|
||||
RAISE EXCEPTION 'Owner changed; refusing reset';
|
||||
END IF;
|
||||
IF EXISTS (SELECT 1 FROM public.users WHERE account = {account} AND id <> {user_id}::uuid) THEN
|
||||
RAISE EXCEPTION 'Account already exists';
|
||||
END IF;
|
||||
UPDATE public.users SET account = {account}, account_kind = 'username',
|
||||
password_hash = {encoded}, updated_at = now() WHERE id = {user_id}::uuid;
|
||||
UPDATE public.auth_sessions SET revoked_at = now()
|
||||
WHERE user_id = {user_id}::uuid AND revoked_at IS NULL;
|
||||
INSERT INTO public.auth_audit_log (actor_user_id, event_type, target_type, target_id, details)
|
||||
VALUES ({user_id}::uuid, 'user.credentials_reset', 'user', {user_id},
|
||||
json_build_object('fromAccount', {previous}, 'account', {account}, 'method', 'server_cli')::jsonb);
|
||||
END;
|
||||
$moyi_reset$;
|
||||
COMMIT;
|
||||
SELECT 'OWNER_RESET_COMMITTED';
|
||||
"""
|
||||
|
||||
|
||||
def write_private(path, data):
|
||||
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
with os.fdopen(descriptor, "wb") as stream:
|
||||
stream.write(data)
|
||||
stream.flush()
|
||||
os.fsync(stream.fileno())
|
||||
|
||||
|
||||
def install_environment(env_file, content):
|
||||
temporary = env_file.with_name(".env.owner-" + secrets.token_hex(8))
|
||||
write_private(temporary, content)
|
||||
os.replace(temporary, env_file)
|
||||
if os.name != "nt":
|
||||
descriptor = os.open(env_file.parent, os.O_RDONLY | os.O_DIRECTORY)
|
||||
try:
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
|
||||
|
||||
def check_container(deploy, config, env_file, mode):
|
||||
compose = deploy.compose_command(env_file, mode)
|
||||
ids = run(compose + ["ps", "-a", "-q", "moyi-api"], cwd=deploy.HERE).splitlines()
|
||||
require(len(ids) == 1, "Expected one existing API container in this Compose project.")
|
||||
item = json.loads(run(["docker", "inspect", ids[0]]))[0]
|
||||
labels = item["Config"]["Labels"]
|
||||
require(Path(labels["com.docker.compose.project.working_dir"]).resolve() == deploy.HERE.resolve(),
|
||||
"Container belongs to another release directory.")
|
||||
require(item["Config"]["Image"] == config["services"]["moyi-api"]["image"],
|
||||
"Running image differs from deployment configuration.")
|
||||
actual = dict(value.split("=", 1) for value in item["Config"]["Env"] if "=" in value)
|
||||
expected = config["services"]["moyi-api"]["environment"]
|
||||
for key in ("SPRING_DATASOURCE_URL", "SPRING_DATASOURCE_USERNAME", "SPRING_DATASOURCE_PASSWORD",
|
||||
"AUTH_PASSWORD_PEPPER", "CREDENTIAL_ENCRYPTION_KEY"):
|
||||
require(actual.get(key) == expected.get(key), "Container/database or encryption settings differ; refusing reset.")
|
||||
return ids[0], compose
|
||||
|
||||
|
||||
def apply_change(deploy, config, env_file, mode, account, password, database, psql, pg_dump, backup_root):
|
||||
api = config["services"]["moyi-api"]["environment"]
|
||||
pg_env = postgres_environment(api, database)
|
||||
owner = read_owner(psql, pg_env, api["ADMIN_ACCOUNT"], account)
|
||||
container, compose = check_container(deploy, config, env_file, mode)
|
||||
original = env_file.read_bytes()
|
||||
content = updated_environment(original.decode("utf-8-sig"), account, password).encode("utf-8")
|
||||
backup_root.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||
backup = Path(tempfile.mkdtemp(prefix="owner-reset-", dir=backup_root))
|
||||
write_private(backup / "env.cloud.before", original)
|
||||
write_private(backup / "env.cloud.after", content)
|
||||
staged = deploy.load_config(backup / "env.cloud.after", mode)
|
||||
deploy.validate_config(staged, mode)
|
||||
validate_staged_config(config, staged, account, password)
|
||||
print("Private recovery directory: " + str(backup), flush=True)
|
||||
print("Stopping API for backup and session revocation...", flush=True)
|
||||
mutation_started = False
|
||||
try:
|
||||
run(["docker", "stop", "--time", "40", container])
|
||||
require(env_file.read_bytes() == original, "Environment file changed concurrently; refusing reset.")
|
||||
dump = backup / "moyi_control.dump"
|
||||
run([pg_dump, "--no-password", "--format=custom", "--quote-all-identifiers", "--lock-wait-timeout=10000",
|
||||
"--file=" + str(dump)], env=pg_env)
|
||||
require(dump.stat().st_size > 0, "Database backup is empty.")
|
||||
with dump.open("rb") as stream:
|
||||
digest = hashlib.file_digest(stream, "sha256").hexdigest()
|
||||
write_private(backup / "moyi_control.dump.sha256", (digest + " moyi_control.dump\n").encode("ascii"))
|
||||
encoded = password_hash(password, api["AUTH_PASSWORD_PEPPER"])
|
||||
mutation_started = True
|
||||
result = query_database(psql, pg_env, reset_sql(database, owner, account, encoded))
|
||||
require(result == "OWNER_RESET_COMMITTED", "Database outcome uncertain; keep API stopped and rerun this tool.")
|
||||
install_environment(env_file, content)
|
||||
run(compose + ["up", "-d", "--no-deps", "--no-build", "--pull", "never", "--force-recreate",
|
||||
"--wait", "--wait-timeout", "180", "moyi-api"], cwd=deploy.HERE)
|
||||
run(compose + ["exec", "-T", "frontend", "nginx", "-t"], cwd=deploy.HERE)
|
||||
run(compose + ["exec", "-T", "frontend", "nginx", "-s", "reload"], cwd=deploy.HERE)
|
||||
deploy.smoke(staged, mode, login=True)
|
||||
except BaseException:
|
||||
if not mutation_started:
|
||||
run(["docker", "start", container])
|
||||
print("Reset was not attempted; original API container restarted.", flush=True)
|
||||
else:
|
||||
print("Maintenance did not finish. Do not restore the old env or database blindly. "
|
||||
"Rerun this tool with the same account/password to reconcile and verify. Recovery: " + str(backup), flush=True)
|
||||
raise
|
||||
print("SUPER_ADMIN_RESET_OK: " + account + "; existing user ID preserved; previous sessions revoked.")
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--deployment-dir", type=Path, required=True)
|
||||
parser.add_argument("--account", required=True)
|
||||
parser.add_argument("--database", default="moyi_control")
|
||||
parser.add_argument("--mode", choices=("https", "tunnel"), default="https")
|
||||
parser.add_argument("--backup-root", type=Path, default=Path("/opt/moyi/backups"))
|
||||
parser.add_argument("--apply", action="store_true", help="Stop API, back up, reset owner and restart; password is prompted twice")
|
||||
args = parser.parse_args()
|
||||
require(re.fullmatch(r"[A-Za-z][A-Za-z0-9_]{0,79}", args.account), "Use an ASCII username starting with a letter.")
|
||||
require(re.fullmatch(r"[a-z][a-z0-9_]+", args.database) and args.database not in ("postgres", "template0", "template1"),
|
||||
"Use a dedicated application database.")
|
||||
require(not args.apply or (os.name == "posix" and os.geteuid() == 0), "Apply must run as root on the Linux server.")
|
||||
directory = args.deployment_dir.resolve()
|
||||
spec = importlib.util.spec_from_file_location("moyi_deploy", directory / "deploy.py")
|
||||
deploy = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(deploy)
|
||||
env_file = directory / ".env.cloud"
|
||||
psql, pg_dump = shutil.which("psql"), shutil.which("pg_dump")
|
||||
require(psql and pg_dump, "Install postgresql-client first.")
|
||||
if args.apply:
|
||||
import fcntl
|
||||
os.umask(0o077)
|
||||
lock = open(directory / ".owner-maintenance.lock", "a")
|
||||
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
config = deploy.preflight(env_file, args.mode)
|
||||
api = config["services"]["moyi-api"]["environment"]
|
||||
env = postgres_environment(api, args.database)
|
||||
owner = read_owner(psql, env, api["ADMIN_ACCOUNT"], args.account)
|
||||
check_container(deploy, config, env_file, args.mode)
|
||||
print("Database: " + args.database + "; existing super administrator: " + owner["account"])
|
||||
if not args.apply:
|
||||
print("Read-only check passed. Add --apply to change credentials.")
|
||||
return
|
||||
require(sys.stdin.isatty(), "Run interactively in SSH, not through a heredoc or pipe.")
|
||||
password = getpass.getpass("New super administrator password (hidden): ")
|
||||
require(password == getpass.getpass("Repeat new password (hidden): "), "Passwords do not match; nothing changed.")
|
||||
apply_change(deploy, config, env_file, args.mode, args.account, password, args.database,
|
||||
psql, pg_dump, args.backup_root.resolve())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
main()
|
||||
except (MaintenanceError, ValueError, OSError, subprocess.SubprocessError, KeyboardInterrupt) as error:
|
||||
message = str(error) if isinstance(error, MaintenanceError) else type(error).__name__ + ": maintenance stopped; no secret output shown."
|
||||
print("ERROR: " + message, file=sys.stderr)
|
||||
sys.exit(1)
|
||||
Reference in new issue
Block a user