settings.py 91 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027
  1. import io
  2. import json
  3. import logging
  4. import os
  5. import zipfile
  6. from datetime import datetime
  7. from pathlib import Path
  8. from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
  9. from fastapi.responses import FileResponse, JSONResponse
  10. from pydantic import BaseModel, Field
  11. from sqlalchemy import func, select
  12. from sqlalchemy.ext.asyncio import AsyncSession
  13. from backend.app.core.auth import (
  14. RequestPrinterScope,
  15. RequireAdminIfAuthEnabled,
  16. RequirePermissionIfAuthEnabled,
  17. ScopedCaller,
  18. caller_is_api_key,
  19. is_auth_enabled,
  20. require_auth_if_enabled,
  21. require_energy_cost_update,
  22. )
  23. from backend.app.core.config import APP_VERSION, settings as app_settings
  24. from backend.app.core.database import get_db
  25. from backend.app.core.permissions import Permission
  26. from backend.app.core.printer_scope import PrinterScope
  27. from backend.app.models.settings import Settings
  28. from backend.app.models.user import User
  29. from backend.app.schemas.settings import ADMIN_ONLY_SETTING_KEYS, AppSettings, AppSettingsUpdate
  30. from backend.app.services import camera_light
  31. from backend.app.services.secret_fields import SETTINGS_SECRETS, SecretConfigError, mask_fields, merge_partial
  32. logger = logging.getLogger(__name__)
  33. router = APIRouter(prefix="/settings", tags=["settings"])
  34. DEFAULT_SETTINGS = AppSettings()
  35. # Sensitive credential fields blanked for API-key callers. Everyone else sees
  36. # them as the placeholder (write-only secrets, see services/secret_fields).
  37. _SENSITIVE_FIELDS_FOR_API_KEY = (*SETTINGS_SECRETS, "octoeverywhere_api_key")
  38. async def get_setting(db: AsyncSession, key: str) -> str | None:
  39. """Get a single setting value by key."""
  40. result = await db.execute(select(Settings).where(Settings.key == key))
  41. setting = result.scalar_one_or_none()
  42. return setting.value if setting else None
  43. # Accepted spellings for a boolean settings value. Settings live in a VARCHAR
  44. # column and every reader compares them as strings, so these are normalised to
  45. # "true"/"false" on the way in. The sets are deliberately generous: these
  46. # endpoints are part of the documented REST surface, reached by scripts and by
  47. # Home Assistant rest_command, where "True", "1" and "on" are all natural.
  48. _TRUTHY_SETTING_VALUES = frozenset({"true", "1", "yes", "on"})
  49. _FALSY_SETTING_VALUES = frozenset({"false", "0", "no", "off"})
  50. def setting_is_true(value: object) -> bool:
  51. """Return True if a *stored* settings value means "on".
  52. Deliberately narrower than the spellings ``normalize_bool_setting`` accepts:
  53. it matches only what every other reader in the codebase treats as on
  54. (``value.lower() == "true"``). Submitted values are canonicalised on write,
  55. so a stored value is always "true"/"false"/""; accepting "1" or "on" here
  56. would make this function disagree with the rest of the app about any legacy
  57. row containing them.
  58. A bool is tolerated for the case of a row written before values were
  59. normalised, where SQLite coerced a raw bool into the VARCHAR column.
  60. """
  61. if isinstance(value, bool):
  62. return value
  63. if value is None:
  64. return False
  65. return str(value).strip().lower() == "true"
  66. def normalize_bool_setting(key: str, value: object) -> str:
  67. """Coerce a boolean-ish settings value to the canonical "true"/"false".
  68. Raises HTTPException(400) for values with no sensible interpretation, so an
  69. API client gets a message naming the field instead of a 500.
  70. A JSON boolean is the natural thing for an API client to send, and before
  71. this normalisation it caused two distinct failures on
  72. ``PUT /settings/spoolman``: ``bool.lower()`` raised AttributeError, and the
  73. raw bool was written into a VARCHAR column, which SQLite silently coerces
  74. to 1/0 while asyncpg rejects outright. Both surfaced as an opaque 500.
  75. """
  76. if isinstance(value, bool): # must precede the int branch — bool is an int
  77. return "true" if value else "false"
  78. if isinstance(value, int):
  79. if value in (0, 1):
  80. return "true" if value else "false"
  81. raise HTTPException(400, f"{key} must be a boolean; got the number {value}")
  82. if isinstance(value, str):
  83. candidate = value.strip().lower()
  84. if not candidate:
  85. # Empty is stored verbatim rather than normalised to "false".
  86. # get_spoolman_settings reads these with ``or "<default>"``, so an
  87. # empty stored value means "use the default" — and two of them
  88. # (spoolman_report_partial_usage, auto_add_unknown_rfid) default to
  89. # ON. Rewriting "" to "false" would silently switch them off for any
  90. # client that submits a blank value.
  91. return ""
  92. if candidate in _TRUTHY_SETTING_VALUES:
  93. return "true"
  94. if candidate in _FALSY_SETTING_VALUES:
  95. return "false"
  96. raise HTTPException(400, f"{key} must be a boolean; got {value!r}")
  97. raise HTTPException(400, f"{key} must be a boolean; got {type(value).__name__}")
  98. def normalize_str_setting(key: str, value: object) -> str:
  99. """Return a string settings value, rejecting types that would store garbage.
  100. ``str()`` on a dict or list would persist its repr, so those are refused
  101. rather than silently written. Numbers are accepted and stringified: a port
  102. or a bare host submitted unquoted is a plausible client mistake, not a
  103. reason to fail the request.
  104. """
  105. if isinstance(value, str):
  106. return value
  107. if value is None:
  108. return ""
  109. if isinstance(value, bool | int | float):
  110. return str(value)
  111. raise HTTPException(400, f"{key} must be a string; got {type(value).__name__}")
  112. async def get_external_base_url(db: AsyncSession) -> str:
  113. """Base URL for links Bambuddy hands to the outside world (no trailing slash).
  114. ``external_url`` is optional and has no default, so anything that must be
  115. absolute — a login link in an e-mail, the one-tap outcome verdict links
  116. (#1898), whose Telegram/ntfy buttons are dropped for a relative URL — falls
  117. back to APP_URL and finally to the dev origin.
  118. """
  119. import os
  120. external_url = await get_setting(db, "external_url")
  121. if external_url:
  122. return external_url.rstrip("/")
  123. return os.environ.get("APP_URL", "http://localhost:5173").rstrip("/")
  124. async def get_external_login_url(db: AsyncSession) -> str:
  125. """Get the external URL for the login page.
  126. Uses external_url from settings if available, otherwise falls back to APP_URL env var.
  127. Args:
  128. db: Database session
  129. Returns:
  130. Full URL to the login page
  131. """
  132. return await get_external_base_url(db) + "/login"
  133. async def set_setting(db: AsyncSession, key: str, value: str) -> None:
  134. """Set a single setting value."""
  135. from backend.app.core.db_dialect import upsert_setting
  136. await upsert_setting(db, Settings, key, value)
  137. # Settings stored as booleans / numbers. Storage is a VARCHAR column, so
  138. # _build_settings_response() parses these back, and update_settings() refuses
  139. # an explicit null for them: a null is stored as the literal "None", which
  140. # reads back as False for a boolean and is not a number at all.
  141. _BOOL_SETTING_KEYS = frozenset(
  142. {
  143. "auto_archive",
  144. "save_thumbnails",
  145. "capture_finish_photo",
  146. "finish_photo_restore_plate",
  147. "spoolman_enabled",
  148. "spoolman_disable_weight_sync",
  149. "spoolman_report_partial_usage",
  150. "auto_add_unknown_rfid",
  151. "disable_filament_warnings",
  152. "prefer_lowest_filament",
  153. "check_updates",
  154. "check_printer_firmware",
  155. "include_beta_updates",
  156. "announcements_enabled",
  157. "announcements_all_users",
  158. "ftp_retry_enabled",
  159. "mqtt_enabled",
  160. "mqtt_use_tls",
  161. "panda_breath_enabled",
  162. "ha_enabled",
  163. "per_printer_mapping_expanded",
  164. "prometheus_enabled",
  165. "user_notifications_enabled",
  166. "queue_drying_enabled",
  167. "queue_drying_block",
  168. "ambient_drying_enabled",
  169. "print_drying_enabled",
  170. "require_plate_clear",
  171. "queue_shortest_first",
  172. # default_bed_levelling / default_flow_cali / default_nozzle_offset_cali
  173. # are tri-state strings (off/on/auto) — parsed via the raw-string else
  174. # branch; the TriState validator coerces legacy "true"/"false" rows.
  175. "default_vibration_cali",
  176. "default_layer_inspect",
  177. "default_timelapse",
  178. "default_confirm_outcome",
  179. "confirm_outcome_external_prints",
  180. "confirm_default_good_on_plate_clear",
  181. "billing_enabled",
  182. "printer_kill_switch_enabled",
  183. "ldap_enabled",
  184. "ldap_auto_provision",
  185. "local_login_enabled",
  186. "preheat_enabled",
  187. "queue_keep_bed_warm",
  188. "obico_enabled",
  189. "octoeverywhere_enabled",
  190. }
  191. )
  192. _FLOAT_SETTING_KEYS = frozenset(
  193. {
  194. "default_filament_cost",
  195. "energy_cost_per_kwh",
  196. "camera_light_delay",
  197. "ams_temp_good",
  198. "ams_temp_fair",
  199. "library_disk_warning_gb",
  200. "low_stock_threshold",
  201. }
  202. )
  203. # String settings limited to a fixed set of values, which a stored "None"
  204. # would break when the settings response is built.
  205. _ENUM_SETTING_KEYS = frozenset(
  206. {"energy_price_source", "obico_sensitivity", "obico_action", "octoeverywhere_confidence", "octoeverywhere_action"}
  207. )
  208. _INT_SETTING_KEYS = frozenset(
  209. {
  210. "ams_humidity_good",
  211. "ams_humidity_fair",
  212. "ams_history_retention_days",
  213. "printer_sensor_history_retention_days",
  214. "ftp_retry_count",
  215. "ftp_retry_delay",
  216. "ftp_timeout",
  217. "mqtt_port",
  218. "stagger_group_size",
  219. "stagger_interval_minutes",
  220. "forecast_global_lead_time_days",
  221. "location_sensor_poll_interval",
  222. "finance_budget_reset_day",
  223. "session_max_hours",
  224. "pipeline_max_copies",
  225. "preheat_max_wait_seconds",
  226. "preheat_soak_seconds",
  227. "queue_keep_warm_bed_temp",
  228. "queue_keep_warm_max_minutes",
  229. "queue_max_concurrent_uploads",
  230. "ambient_drying_sustained_minutes",
  231. "pause_warning_minutes",
  232. "obico_poll_interval",
  233. "octoeverywhere_poll_interval",
  234. }
  235. )
  236. async def _build_settings_response(db: AsyncSession, is_api_key: bool = False, mask: bool = True) -> AppSettings:
  237. """Build the full settings response.
  238. Secrets are blank for API-key callers and the placeholder for everyone else;
  239. ``mask=False`` is for server-side use only (comparing with an update).
  240. """
  241. settings_dict = DEFAULT_SETTINGS.model_dump()
  242. result = await db.execute(select(Settings))
  243. for setting in result.scalars().all():
  244. if setting.key not in settings_dict:
  245. continue
  246. if setting.key in _BOOL_SETTING_KEYS:
  247. settings_dict[setting.key] = setting.value.lower() == "true"
  248. elif setting.key in _FLOAT_SETTING_KEYS or setting.key in _INT_SETTING_KEYS:
  249. # A value that does not parse (the literal "None" from an old
  250. # null save, or a hand-edited row) keeps the default instead of
  251. # taking the whole settings response down with it.
  252. parse = int if setting.key in _INT_SETTING_KEYS else float
  253. try:
  254. settings_dict[setting.key] = parse(setting.value)
  255. except (TypeError, ValueError):
  256. logger.warning("Setting %s has an unparseable value; using the default", setting.key)
  257. elif setting.key in [
  258. # Nullable floats. Settings storage stringifies None to the literal
  259. # "None", which must read back as null here -- not as the default
  260. # the _FLOAT_SETTING_KEYS branch above falls back to (#2905).
  261. "ams_temp_alarm",
  262. ]:
  263. try:
  264. settings_dict[setting.key] = float(setting.value)
  265. except (TypeError, ValueError):
  266. settings_dict[setting.key] = None
  267. elif setting.key == "default_printer_id":
  268. settings_dict[setting.key] = int(setting.value) if setting.value and setting.value != "None" else None
  269. elif setting.key == "open_in_slicer":
  270. # None means "inherit from preferred_slicer" (#1329). The PUT path
  271. # serializes None as the literal string "None"; strip it back so
  272. # the frontend sees a true null and falls back as intended.
  273. settings_dict[setting.key] = setting.value if setting.value and setting.value != "None" else None
  274. else:
  275. settings_dict[setting.key] = setting.value
  276. ha_settings = await get_homeassistant_settings(db)
  277. settings_dict.update(ha_settings)
  278. # ldap_bind_password is never returned to any caller (mask=False is
  279. # server-side only)
  280. if mask or is_api_key:
  281. settings_dict["ldap_bind_password"] = ""
  282. # The saved key is write-only, including for authenticated administrators.
  283. settings_dict["octoeverywhere_api_key_configured"] = bool(settings_dict["octoeverywhere_api_key"].strip())
  284. settings_dict["octoeverywhere_api_key"] = ""
  285. if is_api_key:
  286. for field in _SENSITIVE_FIELDS_FOR_API_KEY:
  287. if field in settings_dict:
  288. settings_dict[field] = ""
  289. elif mask:
  290. settings_dict = mask_fields(settings_dict, SETTINGS_SECRETS)
  291. return AppSettings(**settings_dict)
  292. @router.get("", response_model=AppSettings)
  293. @router.get("/", response_model=AppSettings)
  294. async def get_settings(
  295. db: AsyncSession = Depends(get_db, scope="function"),
  296. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  297. _is_api_key: bool = Depends(caller_is_api_key),
  298. ):
  299. """Get all application settings."""
  300. return await _build_settings_response(db, is_api_key=_is_api_key)
  301. def _as_stored_setting(value: object) -> str:
  302. """The text the settings writer below stores for ``value``."""
  303. if isinstance(value, bool):
  304. return "true" if value else "false"
  305. if value is None:
  306. return "None"
  307. return str(value)
  308. def _same_setting_value(new: object, old: object) -> bool:
  309. """Whether saving ``new`` stores exactly what ``old`` is stored as."""
  310. return _as_stored_setting(new) == _as_stored_setting(old)
  311. @router.put("/", response_model=AppSettings)
  312. async def update_settings(
  313. settings_update: AppSettingsUpdate,
  314. db: AsyncSession = Depends(get_db, scope="function"),
  315. current_user: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_UPDATE),
  316. ):
  317. """Update application settings."""
  318. update_data = settings_update.model_dump(exclude_unset=True)
  319. # Write-only secrets: the placeholder keeps the stored value, and a kept
  320. # secret does not follow a changed destination.
  321. stored = (await _build_settings_response(db, mask=False)).model_dump()
  322. secrets = dict(SETTINGS_SECRETS)
  323. if stored.get("ha_token_from_env"):
  324. # The deployment's own token, not a stored secret to enter again: the
  325. # URL may change (the placeholder sent back still writes nothing).
  326. secrets["ha_token"] = ()
  327. try:
  328. update_data = merge_partial(stored, update_data, secrets)
  329. except SecretConfigError as exc:
  330. raise HTTPException(status_code=400, detail=str(exc)) from None
  331. # Omitted/null preserves the saved key; an explicit empty string removes it.
  332. if update_data.get("octoeverywhere_api_key") is None:
  333. update_data.pop("octoeverywhere_api_key", None)
  334. # These typed settings are not clearable: null would be stored as "None".
  335. # Check before normalizing provider flags so enabling one cannot hide a
  336. # null submitted for the other.
  337. null_keys = sorted(
  338. key
  339. for key, value in update_data.items()
  340. if value is None and key in (_BOOL_SETTING_KEYS | _FLOAT_SETTING_KEYS | _INT_SETTING_KEYS | _ENUM_SETTING_KEYS)
  341. )
  342. if null_keys:
  343. raise HTTPException(status_code=422, detail=f"These settings cannot be null: {', '.join(null_keys)}")
  344. # Only one failure detection provider may control a print at a time.
  345. if update_data.get("obico_enabled") and update_data.get("octoeverywhere_enabled"):
  346. raise HTTPException(status_code=400, detail="Enable only one AI failure detection provider at a time.")
  347. if update_data.get("octoeverywhere_enabled"):
  348. update_data["obico_enabled"] = False
  349. elif update_data.get("obico_enabled"):
  350. update_data["octoeverywhere_enabled"] = False
  351. # Settings that decide who can sign in are admin-only, like the user routes.
  352. # Only a real change counts: the settings page sends every field on each
  353. # save, so an unchanged value from a non-admin must pass.
  354. if current_user is not None and not current_user.is_admin:
  355. changed = sorted(
  356. key
  357. for key in update_data
  358. if key in ADMIN_ONLY_SETTING_KEYS and not _same_setting_value(update_data[key], stored.get(key))
  359. )
  360. if changed:
  361. raise HTTPException(
  362. status_code=403,
  363. detail=f"Only an administrator can change these settings: {', '.join(changed)}",
  364. )
  365. # Like an API key's or a provider's printers: a page still open from before
  366. # a printer delete would save the deleted id, which SQLite gives to the next
  367. # printer created (the validator has already checked it is a list of ints).
  368. # Only ids not stored yet are checked: the page sends the whole list, and an
  369. # id already there must not block every save.
  370. for key in ("obico_enabled_printers", "octoeverywhere_enabled_printers"):
  371. if not update_data.get(key):
  372. continue
  373. from backend.app.core.printer_scope import ensure_printers_exist
  374. try:
  375. stored_printers = json.loads(await get_setting(db, key) or "[]")
  376. except ValueError:
  377. stored_printers = []
  378. stored_printers = set(stored_printers) if isinstance(stored_printers, list) else set()
  379. added = [i for i in json.loads(update_data[key]) if i not in stored_printers]
  380. await ensure_printers_exist(db, added)
  381. # Safety refusals on disabling local login (#1589). Two failure modes
  382. # would otherwise lock everyone out of the install:
  383. # 1. No enabled OIDC provider exists — nobody could authenticate.
  384. # 2. The caller has no UserOIDCLink — they would lock themselves out
  385. # even if other admins are linked.
  386. # Either case returns HTTP 400 instead of silently saving. The
  387. # ``BAMBUDDY_LOCAL_LOGIN=true`` env-var bypass on /auth/login is a
  388. # separate recovery path; the refusals here protect the *default*
  389. # configuration where the env var is absent.
  390. if update_data.get("local_login_enabled") is False:
  391. from backend.app.models.oidc_provider import OIDCProvider, UserOIDCLink
  392. enabled_count = await db.scalar(select(func.count(OIDCProvider.id)).where(OIDCProvider.is_enabled.is_(True)))
  393. if not enabled_count:
  394. raise HTTPException(
  395. status_code=400,
  396. detail="Cannot disable local login: no OIDC provider is enabled.",
  397. )
  398. if current_user is not None:
  399. caller_links = await db.scalar(
  400. select(func.count(UserOIDCLink.id)).where(UserOIDCLink.user_id == current_user.id)
  401. )
  402. if not caller_links:
  403. raise HTTPException(
  404. status_code=400,
  405. detail="Cannot disable local login: your account has no OIDC link, so you would lock yourself out.",
  406. )
  407. # Check if any MQTT settings are being updated
  408. mqtt_keys = {
  409. "mqtt_enabled",
  410. "mqtt_broker",
  411. "mqtt_port",
  412. "mqtt_username",
  413. "mqtt_password",
  414. "mqtt_topic_prefix",
  415. "mqtt_use_tls",
  416. "panda_breath_enabled",
  417. }
  418. mqtt_updated = bool(mqtt_keys & set(update_data.keys()))
  419. # The page saves every field it shows on each change, so compare against
  420. # what is stored: only a real change of price source is worth a read.
  421. price_source_changed = False
  422. for key in ("energy_price_source", "energy_price_ha_entity"):
  423. if key in update_data and str(update_data[key]) != (await get_setting(db, key) or ""):
  424. price_source_changed = True
  425. for key, value in update_data.items():
  426. # Convert value to string for storage
  427. await set_setting(db, key, _as_stored_setting(value))
  428. await db.commit()
  429. # Expire all objects to ensure fresh reads after commit
  430. db.expire_all()
  431. if update_data.get("obico_enabled") is False:
  432. from backend.app.services.obico_detection import obico_detection_service
  433. await obico_detection_service.refresh_settings()
  434. if any(key.startswith("octoeverywhere_") for key in update_data):
  435. from backend.app.services.octoeverywhere_detection import octoeverywhere_detection_service
  436. await octoeverywhere_detection_service.refresh_settings()
  437. if {"camera_light_mode", "camera_light_delay"} & set(update_data.keys()):
  438. camera_light.invalidate_settings()
  439. if "require_plate_clear" in update_data:
  440. from backend.app.services.wled import wled_manager
  441. wled_manager.require_plate_clear = update_data["require_plate_clear"]
  442. if price_source_changed:
  443. # Read a newly chosen price sensor now, so the saved settings show its
  444. # price instead of the old one until the next hourly read (#1251).
  445. from backend.app.services.energy_price import current_price
  446. try:
  447. await current_price(db, remember=True)
  448. await db.commit()
  449. except Exception as e:
  450. logger.warning("Could not read the electricity price after saving its source: %s", e)
  451. # Reconfigure MQTT relay if any MQTT settings changed
  452. if mqtt_updated:
  453. try:
  454. from backend.app.services.mqtt_relay import mqtt_relay
  455. mqtt_settings = {
  456. "mqtt_enabled": (await get_setting(db, "mqtt_enabled") or "false") == "true",
  457. "mqtt_broker": await get_setting(db, "mqtt_broker") or "",
  458. "mqtt_port": int(await get_setting(db, "mqtt_port") or "1883"),
  459. "mqtt_username": await get_setting(db, "mqtt_username") or "",
  460. "mqtt_password": await get_setting(db, "mqtt_password") or "",
  461. "mqtt_topic_prefix": await get_setting(db, "mqtt_topic_prefix") or "bambuddy",
  462. "mqtt_use_tls": (await get_setting(db, "mqtt_use_tls") or "false") == "true",
  463. "panda_breath_enabled": (await get_setting(db, "panda_breath_enabled") or "false") == "true",
  464. }
  465. await mqtt_relay.configure(mqtt_settings)
  466. except Exception:
  467. pass # Don't fail the settings update if MQTT reconfiguration fails
  468. # Return updated settings, secrets as the placeholder
  469. return await _build_settings_response(db, is_api_key=False)
  470. @router.patch("/", response_model=AppSettings)
  471. @router.patch("", response_model=AppSettings)
  472. async def patch_settings(
  473. settings_update: AppSettingsUpdate,
  474. db: AsyncSession = Depends(get_db, scope="function"),
  475. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_UPDATE),
  476. ):
  477. """Partially update application settings (same as PUT, for REST compatibility)."""
  478. return await update_settings(settings_update, db, _)
  479. class ElectricityPriceUpdate(BaseModel):
  480. """Payload for ``POST /settings/electricity-price`` (#1356).
  481. Mirrors the field name documented in ``wiki/features/energy.md`` so the
  482. Home Assistant ``rest_command`` example needs only a URL change, not a
  483. payload change. Plain non-negative float; tariffs can go as low as 0.0 in
  484. some markets (e.g. free hours).
  485. """
  486. energy_cost_per_kwh: float = Field(ge=0)
  487. @router.post("/electricity-price", response_model=AppSettings)
  488. async def update_electricity_price(
  489. payload: ElectricityPriceUpdate,
  490. db: AsyncSession = Depends(get_db, scope="function"),
  491. _: ScopedCaller = Depends(require_energy_cost_update()),
  492. _is_api_key: bool = Depends(caller_is_api_key),
  493. ):
  494. """Update the per-kWh electricity cost used by the energy-tracking pipeline.
  495. This is the only settings field writable via API key, gated by the
  496. ``can_update_energy_cost`` toggle on the key. JWT users still need the
  497. standard ``SETTINGS_UPDATE`` permission. See #1356 for the rationale —
  498. the general ``PATCH /settings`` route remains denied for API keys because
  499. it can rewrite SMTP/LDAP/MQTT credentials, which is a much wider surface
  500. than the documented dynamic-tariff use case requires.
  501. """
  502. await set_setting(db, "energy_cost_per_kwh", str(payload.energy_cost_per_kwh))
  503. await db.commit()
  504. db.expire_all()
  505. return await _build_settings_response(db, is_api_key=_is_api_key)
  506. @router.post("/reset", response_model=AppSettings)
  507. async def reset_settings(
  508. db: AsyncSession = Depends(get_db, scope="function"),
  509. _admin: User | None = RequireAdminIfAuthEnabled(),
  510. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_UPDATE),
  511. ):
  512. """Reset all settings to defaults."""
  513. # Delete all settings
  514. result = await db.execute(select(Settings))
  515. for setting in result.scalars().all():
  516. await db.delete(setting)
  517. await db.commit()
  518. camera_light.invalidate_settings()
  519. from backend.app.services.wled import wled_manager
  520. wled_manager.require_plate_clear = False
  521. return DEFAULT_SETTINGS
  522. @router.get("/default-sidebar-order")
  523. async def get_default_sidebar_order(
  524. db: AsyncSession = Depends(get_db, scope="function"),
  525. ):
  526. """Get the admin-set default sidebar order.
  527. Intentionally unauthenticated: non-admin users need to read this value to apply
  528. the default sidebar order, but may lack SETTINGS_READ permission.
  529. The value is non-sensitive (sidebar item IDs only).
  530. """
  531. value = await get_setting(db, "default_sidebar_order")
  532. return {"default_sidebar_order": value or ""}
  533. # Fields exposed via /ui-preferences without SETTINGS_READ. Each entry MUST be
  534. # non-sensitive (no credentials, no PII, no secret tokens) — granting SETTINGS_READ
  535. # also grants visibility of SMTP/LDAP/MQTT passwords and similar, so the goal of
  536. # this endpoint is exactly to NOT require that permission for UI rendering hints.
  537. # When adding a field here, confirm it doesn't carry anything sensitive.
  538. _UI_PREFERENCE_FIELDS: tuple[str, ...] = (
  539. "require_plate_clear",
  540. "check_printer_firmware",
  541. "camera_view_mode",
  542. "time_format",
  543. "date_format",
  544. "drying_presets",
  545. "ams_humidity_thresholds",
  546. "ams_humidity_good",
  547. "ams_humidity_fair",
  548. "ams_temp_good",
  549. "ams_temp_fair",
  550. # ams_temp_alarm is deliberately NOT here. This endpoint is unauthenticated
  551. # and exists so the UI can colour readings without SETTINGS_READ; the good /
  552. # fair bands are what the printer card colours by. The alarm threshold
  553. # changes no rendering anywhere -- only SettingsPage reads it, and that is
  554. # behind the settings permissions already (#2905).
  555. "bed_cooled_threshold",
  556. # Temperature / fan-speed presets for the printer-card popovers. Numbers
  557. # only; no PII / credentials.
  558. "nozzle_temp_presets",
  559. "bed_temp_presets",
  560. "chamber_temp_presets",
  561. "fan_speed_presets",
  562. )
  563. @router.get("/ui-preferences")
  564. async def get_ui_preferences(db: AsyncSession = Depends(get_db, scope="function")):
  565. """Get the curated subset of settings that any page needs to render correctly.
  566. Intentionally not gated on SETTINGS_READ — every authenticated user (and
  567. every page that loads for them) needs these fields, but granting SETTINGS_READ
  568. would also grant visibility of secrets (SMTP/LDAP/MQTT credentials, etc.).
  569. Same pattern as /default-sidebar-order (#1293).
  570. Reuses _build_settings_response so the typed values match what /settings
  571. returns for fields with the same name — bool/int/float/str types stay in
  572. sync without a separate type-coercion path.
  573. """
  574. full = await _build_settings_response(db, is_api_key=False)
  575. dumped = full.model_dump()
  576. return {key: dumped[key] for key in _UI_PREFERENCE_FIELDS if key in dumped}
  577. # Install configuration the app shell reads before it can render correctly.
  578. #
  579. # Deliberately a second list rather than more entries in _UI_PREFERENCE_FIELDS.
  580. # That one is served to anyone at all, on the recorded grounds that its contents
  581. # are "public defaults that ship with the app" (test_route_auth_coverage.py), and
  582. # its field set is pinned by a test written to make anyone adding to it stop and
  583. # think. These fields are not defaults -- they are facts about how this
  584. # particular deployment is configured -- so they get their own endpoint at their
  585. # own trust level instead of stretching that charter to fit them.
  586. _UI_FLAG_FIELDS: tuple[str, ...] = (
  587. # The sidebar hides Finance unless billing is on. Layout read this from
  588. # GET /settings, which requires SETTINGS_READ, so for a non-admin the query
  589. # 403'd, the value arrived undefined, `undefined !== true` held, and the
  590. # entry was hidden from exactly the users cost_centers:read_own exists to
  591. # serve. The page itself was reachable by URL the whole time (#3023).
  592. "billing_enabled",
  593. # Same 403, opposite outcome. That gate tests `=== false`, which undefined
  594. # never satisfies, so an administrator who turned user notifications off
  595. # still left the entry showing -- to precisely the non-admins it governs.
  596. "user_notifications_enabled",
  597. # Not gates, but read by the shell and equally undefined for a non-admin:
  598. # the sponsor prompt fell back to EUR whatever the install uses, and the
  599. # update check ran even where it had been switched off.
  600. "currency",
  601. "check_updates",
  602. # Read by the print dialog, queue, file manager, inventory and SpoolBuddy
  603. # pages, which users without SETTINGS_READ open too: the 403 dropped them
  604. # all to their defaults (with billing on, the print dialog hid the cost
  605. # centre picker and the print was then refused for lacking one).
  606. "queue_shortest_first",
  607. "use_slicer_api",
  608. "open_in_slicer",
  609. "preferred_slicer",
  610. "disable_filament_warnings",
  611. "prefer_lowest_filament",
  612. "per_printer_mapping_expanded",
  613. "default_filament_cost",
  614. "default_bed_levelling",
  615. "default_flow_cali",
  616. "default_vibration_cali",
  617. "default_layer_inspect",
  618. "default_timelapse",
  619. "default_nozzle_offset_cali",
  620. "default_confirm_outcome",
  621. "stagger_group_size",
  622. "stagger_interval_minutes",
  623. "library_disk_warning_gb",
  624. "low_stock_threshold",
  625. "location_sensor_poll_interval",
  626. "location_sensor_alert_defaults",
  627. "pipeline_max_copies",
  628. "language",
  629. "dark_style",
  630. "dark_background",
  631. "dark_accent",
  632. "light_style",
  633. "light_background",
  634. "light_accent",
  635. # Which inventory a new spool goes to (unknown-tag prompt), and the
  636. # forecast's default lead time.
  637. "spoolman_enabled",
  638. "forecast_global_lead_time_days",
  639. # Preselected in the print dialog; withheld below from a caller who may
  640. # not use that printer.
  641. "default_printer_id",
  642. )
  643. @router.get("/ui-flags")
  644. async def get_ui_flags(
  645. db: AsyncSession = Depends(get_db, scope="function"),
  646. _: User | None = Depends(require_auth_if_enabled),
  647. printer_scope: PrinterScope = RequestPrinterScope,
  648. ):
  649. """Install configuration the app shell needs, for any signed-in user.
  650. Gated on being authenticated rather than on ``SETTINGS_READ``. The sidebar
  651. has to know whether billing is enabled before it can decide whether to offer
  652. Finance, and ``SETTINGS_READ`` cannot be the price of knowing that -- it also
  653. grants sight of the SMTP, LDAP and MQTT credentials.
  654. ``require_auth_if_enabled`` returns ``None`` when auth is switched off
  655. entirely, which is the case /ui-preferences was left ungated for. That is the
  656. distinction the two endpoints draw: "works when there is no auth" is not the
  657. same statement as "readable by anyone", and conflating them is what put a
  658. settings read in front of a permission that was never meant to require one.
  659. """
  660. full = await _build_settings_response(db, is_api_key=False)
  661. dumped = full.model_dump()
  662. flags = {key: dumped[key] for key in _UI_FLAG_FIELDS if key in dumped}
  663. if flags.get("default_printer_id") is not None and not printer_scope.allows(flags["default_printer_id"]):
  664. flags["default_printer_id"] = None
  665. # Whether G-code snippets are set up, not the snippets themselves.
  666. flags["has_gcode_snippets"] = bool(dumped.get("gcode_snippets"))
  667. return flags
  668. @router.get("/check-ffmpeg")
  669. async def check_ffmpeg(
  670. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  671. ):
  672. """Check if ffmpeg is installed and available.
  673. Gated on ``SETTINGS_READ`` (audit finding I4 — the binary path was
  674. leaking the host filesystem layout to unauthenticated callers).
  675. ``require_permission_if_auth_enabled`` returns ``None`` only when
  676. auth is disabled (in which case there's no privacy boundary to
  677. enforce); otherwise it raises 401/403 before we get here.
  678. """
  679. from backend.app.services.camera import get_ffmpeg_path
  680. ffmpeg_path = get_ffmpeg_path()
  681. return {
  682. "installed": ffmpeg_path is not None,
  683. "path": ffmpeg_path,
  684. }
  685. @router.get("/spoolman")
  686. async def get_spoolman_settings(
  687. db: AsyncSession = Depends(get_db, scope="function"),
  688. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  689. ):
  690. """Get Spoolman integration settings."""
  691. spoolman_enabled = await get_setting(db, "spoolman_enabled") or "false"
  692. spoolman_url = await get_setting(db, "spoolman_url") or ""
  693. spoolman_sync_mode = await get_setting(db, "spoolman_sync_mode") or "auto"
  694. spoolman_disable_weight_sync = await get_setting(db, "spoolman_disable_weight_sync") or "false"
  695. spoolman_report_partial_usage = await get_setting(db, "spoolman_report_partial_usage") or "true"
  696. auto_add_unknown_rfid = await get_setting(db, "auto_add_unknown_rfid") or "true"
  697. return {
  698. "spoolman_enabled": spoolman_enabled,
  699. "spoolman_url": spoolman_url,
  700. "spoolman_sync_mode": spoolman_sync_mode,
  701. "spoolman_disable_weight_sync": spoolman_disable_weight_sync,
  702. "spoolman_report_partial_usage": spoolman_report_partial_usage,
  703. "auto_add_unknown_rfid": auto_add_unknown_rfid,
  704. }
  705. @router.put("/spoolman")
  706. async def update_spoolman_settings(
  707. settings: dict,
  708. db: AsyncSession = Depends(get_db, scope="function"),
  709. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_UPDATE),
  710. ):
  711. """Update Spoolman integration settings.
  712. The body is a free-form dict rather than a schema, so each value is
  713. normalised before it is persisted — see ``normalize_bool_setting`` for why
  714. a JSON boolean used to produce a 500 here.
  715. """
  716. if "spoolman_enabled" in settings:
  717. was_enabled = setting_is_true(await get_setting(db, "spoolman_enabled"))
  718. new_val = normalize_bool_setting("spoolman_enabled", settings["spoolman_enabled"])
  719. now_enabled = new_val == "true"
  720. await set_setting(db, "spoolman_enabled", new_val)
  721. # Nothing is deleted on a mode change (#2812). Each mode keeps its slot
  722. # assignments in its own table, so both can hold rows at once and the
  723. # toggle is reversible: switching to Spoolman to see what it does, then
  724. # switching back, returns you to the assignments you had.
  725. #
  726. # This used to empty the other mode's table on every toggle. The reason
  727. # was real -- checks that read both tables would let a row in the mode
  728. # you are not using answer for the mode you are -- but the cost was that
  729. # inspecting a mode destroyed your configuration, with no confirmation
  730. # and no way back, and the deletion was unfiltered across every printer.
  731. # The readers that could be confused now ask which mode is active
  732. # (``spoolman_owns_assignments``), which is where that decision belongs:
  733. # the mode is a property of the install, not of the rows.
  734. if was_enabled != now_enabled:
  735. logger.info(
  736. "Inventory mode switched to %s; slot assignments in both tables kept",
  737. "Spoolman" if now_enabled else "built-in",
  738. )
  739. if "spoolman_url" in settings:
  740. await set_setting(db, "spoolman_url", normalize_str_setting("spoolman_url", settings["spoolman_url"]))
  741. if "spoolman_sync_mode" in settings:
  742. await set_setting(
  743. db, "spoolman_sync_mode", normalize_str_setting("spoolman_sync_mode", settings["spoolman_sync_mode"])
  744. )
  745. for bool_key in ("spoolman_disable_weight_sync", "spoolman_report_partial_usage", "auto_add_unknown_rfid"):
  746. if bool_key in settings:
  747. await set_setting(db, bool_key, normalize_bool_setting(bool_key, settings[bool_key]))
  748. spoolman_changed = "spoolman_enabled" in settings or "spoolman_url" in settings
  749. await db.commit()
  750. db.expire_all()
  751. if spoolman_changed:
  752. from backend.app.services.location_service import maybe_sync_spoolman_locations
  753. if await maybe_sync_spoolman_locations(db):
  754. await db.commit()
  755. # Return updated settings
  756. return await get_spoolman_settings(db)
  757. async def get_homeassistant_settings(db: AsyncSession) -> dict:
  758. """
  759. Get Home Assistant integration settings.
  760. Environment variables (HA_URL, HA_TOKEN) take precedence over database settings.
  761. """
  762. import os
  763. # Check environment variables first
  764. ha_url_env = os.environ.get("HA_URL")
  765. ha_token_env = os.environ.get("HA_TOKEN")
  766. # Fall back to database values
  767. ha_url = ha_url_env or await get_setting(db, "ha_url") or ""
  768. ha_token = ha_token_env or await get_setting(db, "ha_token") or ""
  769. ha_enabled_db = await get_setting(db, "ha_enabled") or "false"
  770. # Track which settings come from environment
  771. ha_url_from_env = bool(ha_url_env)
  772. ha_token_from_env = bool(ha_token_env)
  773. ha_env_managed = ha_url_from_env and ha_token_from_env
  774. # Auto-enable when both env vars are set, otherwise use database value
  775. if ha_url_env and ha_token_env:
  776. ha_enabled = True
  777. else:
  778. ha_enabled = ha_enabled_db.lower() == "true"
  779. return {
  780. "ha_enabled": ha_enabled,
  781. "ha_url": ha_url,
  782. "ha_token": ha_token,
  783. "ha_url_from_env": ha_url_from_env,
  784. "ha_token_from_env": ha_token_from_env,
  785. "ha_env_managed": ha_env_managed,
  786. }
  787. async def create_backup_zip(output_path: Path | None = None) -> tuple[Path, str]:
  788. """Create a complete backup ZIP (database + all data directories).
  789. If output_path is given, the ZIP is written there.
  790. Otherwise a temporary file is created (caller must clean up).
  791. Returns (zip_path, filename).
  792. """
  793. import shutil
  794. import tempfile
  795. from backend.app.core.db_dialect import is_sqlite
  796. base_dir = app_settings.base_dir
  797. filename = f"bambuddy-backup-{datetime.now().strftime('%Y%m%d-%H%M%S')}.zip"
  798. with tempfile.TemporaryDirectory() as temp_dir:
  799. temp_path = Path(temp_dir)
  800. if is_sqlite():
  801. from sqlalchemy import text
  802. from backend.app.core.database import engine
  803. db_path = Path(app_settings.database_url.replace("sqlite+aiosqlite:///", ""))
  804. # Checkpoint WAL to ensure all data is in main db file
  805. async with engine.begin() as conn:
  806. await conn.execute(text("PRAGMA wal_checkpoint(TRUNCATE)"))
  807. # Copy database file
  808. shutil.copy2(db_path, temp_path / "bambuddy.db")
  809. else:
  810. # PostgreSQL: export to a portable SQLite file via SQLAlchemy.
  811. # This makes backups restorable on both SQLite and Postgres installs.
  812. import json
  813. import sqlite3
  814. from sqlalchemy import create_engine as create_sync_engine
  815. from backend.app.core.database import Base, engine
  816. backup_db_path = temp_path / "bambuddy.db"
  817. metadata = Base.metadata
  818. # Build the portable SQLite schema with SQLAlchemy's own DDL rather
  819. # than a hand-rolled CREATE TABLE. metadata.create_all() emits the
  820. # exact schema a native SQLite install gets — NOT NULL, DEFAULT
  821. # (server_default=func.now() → CURRENT_TIMESTAMP), foreign keys,
  822. # unique constraints and indexes. The previous name+type-only
  823. # rebuild dropped all of these, so a Postgres→SQLite restore left
  824. # server_default columns (e.g. spoolbuddy_devices.created_at) with
  825. # no DEFAULT — SQLAlchemy omits such columns on INSERT and the DB
  826. # then wrote NULL, which 500'd on the next read (#2526). Using the
  827. # real DDL also keeps the #1333 BLOB guard: LargeBinary still
  828. # renders as BLOB, so OIDC icon bytes survive the round trip.
  829. schema_engine = create_sync_engine(f"sqlite:///{backup_db_path}")
  830. try:
  831. metadata.create_all(schema_engine)
  832. finally:
  833. schema_engine.dispose()
  834. dst = sqlite3.connect(str(backup_db_path))
  835. # Export data from Postgres to SQLite
  836. async with engine.connect() as conn:
  837. for table in metadata.sorted_tables:
  838. result = await conn.execute(table.select())
  839. rows = result.fetchall()
  840. if not rows:
  841. continue
  842. columns = list(result.keys())
  843. placeholders = ", ".join(["?"] * len(columns))
  844. col_list = ", ".join(columns)
  845. insert_sql = f"INSERT INTO {table.name} ({col_list}) VALUES ({placeholders})" # noqa: S608 # nosec B608 — table/column names from ORM metadata, not user input
  846. def _serialize_row(row):
  847. return tuple(json.dumps(v) if isinstance(v, (list, dict)) else v for v in row)
  848. dst.executemany(insert_sql, [_serialize_row(row) for row in rows])
  849. dst.commit()
  850. dst.close()
  851. logger.info("PostgreSQL backup exported to portable SQLite format")
  852. # Copy data directories (if they exist)
  853. dirs_to_backup = [
  854. ("archive", base_dir / "archive"),
  855. ("virtual_printer", base_dir / "virtual_printer"),
  856. ("plate_calibration", app_settings.plate_calibration_dir),
  857. ("icons", base_dir / "icons"),
  858. ("projects", base_dir / "projects"),
  859. ("overlay-branding", base_dir / "overlay-branding"),
  860. ]
  861. for name, src_dir in dirs_to_backup:
  862. if src_dir.exists() and any(src_dir.iterdir()):
  863. try:
  864. shutil.copytree(
  865. src_dir, temp_path / name
  866. ) # SEC-PATH-OK: name iterates the dirs_to_backup tuple of constant strings ("archive", "virtual_printer", ...)
  867. except shutil.Error as e:
  868. logger.warning("Some files in %s could not be copied: %s", name, e)
  869. except PermissionError as e:
  870. logger.warning("Permission denied copying %s: %s", name, e)
  871. # Say which version made this, so a restore that cannot import it can
  872. # name the versions rather than a list of columns. Backups from before
  873. # this existed simply have no manifest, and restore treats the version
  874. # as unknown.
  875. import json as _json
  876. manifest = {
  877. "format": 1,
  878. "app_version": APP_VERSION,
  879. "created_at": datetime.now().isoformat(timespec="seconds"),
  880. "database": "sqlite" if is_sqlite() else "postgresql",
  881. }
  882. (temp_path / "manifest.json").write_text(_json.dumps(manifest, indent=2) + "\n")
  883. # Include the MFA encryption key as a ZIP top-level entry alongside
  884. # bambuddy.db. Without it, encrypted client_secret / TOTP secret rows
  885. # would be unrecoverable after restore on a host without MFA_ENCRYPTION_KEY set.
  886. from backend.app.core.paths import resolve_data_dir
  887. mfa_key_src = resolve_data_dir() / ".mfa_encryption_key"
  888. if mfa_key_src.exists() and mfa_key_src.is_file():
  889. try:
  890. shutil.copy2(mfa_key_src, temp_path / ".mfa_encryption_key")
  891. except OSError as exc:
  892. logger.error(
  893. "Could not include MFA encryption key in backup (%s). "
  894. "The backup ZIP will not contain the key — restore on a "
  895. "keyless host will fail for encrypted secrets.",
  896. exc,
  897. )
  898. raise
  899. # Create ZIP
  900. if output_path is not None:
  901. zip_file = (
  902. output_path / filename
  903. ) # SEC-PATH-OK: filename = f"bambuddy-backup-{datetime.now()...}.zip" generated in create_backup_zip itself
  904. else:
  905. fd, tmp = tempfile.mkstemp(suffix=".zip")
  906. os.close(fd)
  907. zip_file = Path(tmp)
  908. with zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED) as zf:
  909. for file_path in temp_path.rglob("*"):
  910. if file_path.is_file():
  911. arcname = file_path.relative_to(temp_path)
  912. zf.write(file_path, arcname)
  913. return zip_file, filename
  914. @router.get("/backup")
  915. async def create_backup(
  916. db: AsyncSession = Depends(get_db, scope="function"),
  917. _admin: User | None = RequireAdminIfAuthEnabled(),
  918. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_BACKUP),
  919. ):
  920. """Create a complete backup (database + all files) as a ZIP download."""
  921. from starlette.background import BackgroundTask
  922. try:
  923. zip_file, filename = await create_backup_zip()
  924. return FileResponse(
  925. path=zip_file,
  926. filename=filename,
  927. media_type="application/zip",
  928. background=BackgroundTask(lambda: zip_file.unlink(missing_ok=True)),
  929. )
  930. except Exception as e:
  931. logger.error("Backup failed: %s", e, exc_info=True)
  932. return JSONResponse(
  933. status_code=500,
  934. content={"success": False, "message": "Backup failed. Check server logs for details."},
  935. )
  936. class BackupSchemaIncompatible(Exception):
  937. """The backup has no value for a column this version requires.
  938. A backup carries the schema of the install that made it. Restoring it into
  939. a different version means the destination can have NOT NULL columns the
  940. backup never heard of -- either because that version is older and still has
  941. a column since removed (``user_wallets.currency``, dropped in #3123), or
  942. because it is newer and has added one. Most such columns have a default and
  943. can simply be filled. The ones that cannot are what this reports, and it has
  944. to be reported BEFORE the restore drops anything: the Postgres import wipes
  945. every table in the first transaction, so a failure halfway leaves the
  946. install with an empty schema and the previous data gone.
  947. """
  948. def _missing_required_columns(pg_table, src_columns: set[str]):
  949. """Split the destination's NOT NULL columns that the backup lacks.
  950. Returns ``(injectable, db_filled, unfillable)``:
  951. * ``injectable`` -- ``{name: value}`` from the model's Python-side default.
  952. These are invisible to the import's raw SQL: SQLAlchemy applies a
  953. ``default=`` on ORM and Core inserts, never on ``text()``, and
  954. ``create_all`` emits no DDL default for one. So a column like
  955. ``currency VARCHAR(3) NOT NULL`` with ``default="EUR"`` arrives with
  956. nothing to put in it unless we put it there.
  957. * ``db_filled`` -- has a server default or is the autoincrement key; the
  958. database fills it when the column is left out of the INSERT.
  959. * ``unfillable`` -- nothing can supply a value. The backup is incompatible.
  960. """
  961. injectable: dict = {}
  962. db_filled: list[str] = []
  963. unfillable: list[str] = []
  964. for col in pg_table.columns:
  965. if col.nullable or col.name in src_columns:
  966. continue
  967. if col.default is not None:
  968. arg = col.default.arg
  969. injectable[col.name] = arg(None) if callable(arg) else arg
  970. elif col.server_default is not None or col.primary_key:
  971. db_filled.append(col.name)
  972. else:
  973. unfillable.append(col.name)
  974. return injectable, db_filled, unfillable
  975. def check_backup_schema_compatible(sqlite_path: Path, backup_version: str | None = None) -> None:
  976. """Raise if this version cannot import that backup. Touches nothing.
  977. Only the cross-engine path needs this. A SQLite install restores by copying
  978. the backup's pages, schema included, and `init_db()` migrates it forward
  979. afterwards; the Postgres import instead recreates the schema from THIS
  980. process's ORM and then inserts the backup's columns into it.
  981. """
  982. import sqlite3
  983. from backend.app.core.database import Base
  984. src = sqlite3.connect(f"file:{sqlite_path}?mode=ro", uri=True)
  985. try:
  986. src_tables = {
  987. row[0]
  988. for row in src.execute(
  989. "SELECT name FROM sqlite_master WHERE type='table' "
  990. "AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'archive_fts%'"
  991. )
  992. }
  993. problems: list[str] = []
  994. # metadata.tables, not sorted_tables: the latter warns about the
  995. # library_files/library_folders/print_archives cycle, and nothing here
  996. # depends on the order.
  997. for name, pg_table in Base.metadata.tables.items():
  998. if name not in src_tables:
  999. continue
  1000. # An empty table inserts nothing, so a column it cannot supply
  1001. # cannot fail. Refusing a restore over one would be a false alarm.
  1002. if src.execute(f'SELECT 1 FROM "{name}" LIMIT 1').fetchone() is None: # noqa: S608 # nosec B608 — name comes from ORM metadata
  1003. continue
  1004. src_columns = {row[1] for row in src.execute(f'PRAGMA table_info("{name}")')}
  1005. _, _, unfillable = _missing_required_columns(pg_table, src_columns)
  1006. problems.extend(f"{name}.{col}" for col in unfillable)
  1007. finally:
  1008. src.close()
  1009. if not problems:
  1010. return
  1011. made_by = f"The backup was made by Bambuddy {backup_version}, " if backup_version else "The backup "
  1012. raise BackupSchemaIncompatible(
  1013. "This backup cannot be restored by this version of Bambuddy. It carries no value for "
  1014. f"{len(problems)} column(s) this version requires and cannot default: {', '.join(sorted(problems))}. "
  1015. f"{made_by}and this install runs {APP_VERSION}. Restore it on the version that made it, or "
  1016. "upgrade this install to that version. Nothing has been changed."
  1017. )
  1018. def _read_backup_manifest(temp_path: Path) -> dict:
  1019. """The backup's manifest.json, or {} for a backup made before it existed."""
  1020. import json
  1021. path = temp_path / "manifest.json"
  1022. if not path.is_file():
  1023. return {}
  1024. try:
  1025. data = json.loads(path.read_text())
  1026. except (OSError, ValueError) as exc:
  1027. logger.warning("Ignoring unreadable backup manifest: %s", exc)
  1028. return {}
  1029. return data if isinstance(data, dict) else {}
  1030. def _restored_value_fixes(table_name: str) -> dict[str, tuple[tuple[str, ...], str]]:
  1031. """Columns of ``table_name`` whose backed-up value must be one of a set, with its fallback.
  1032. Older versions stored any project priority or status; one longer than the
  1033. column fails the whole import on PostgreSQL. The fallbacks are the ones
  1034. project import and the start-up repair use.
  1035. """
  1036. if table_name != "projects":
  1037. return {}
  1038. from backend.app.models.project import PROJECT_PRIORITIES, PROJECT_STATUSES
  1039. return {"priority": (PROJECT_PRIORITIES, "normal"), "status": (PROJECT_STATUSES, "active")}
  1040. async def _import_sqlite_to_postgres(sqlite_path: Path):
  1041. """Import data from a SQLite database file into the current PostgreSQL database.
  1042. Used for cross-database restore (SQLite backup → PostgreSQL).
  1043. Reads all tables from the SQLite file and bulk-inserts into Postgres.
  1044. """
  1045. import sqlite3
  1046. from sqlalchemy import text
  1047. from backend.app.core.database import AUTOINCREMENT_TABLES, Base, _create_engine, highest_referenced_id
  1048. # Before anything is dropped. The route checks this too, earlier and with
  1049. # the backup's version in the message; this call is what makes the guarantee
  1050. # a property of the import itself rather than of one caller.
  1051. check_backup_schema_compatible(sqlite_path)
  1052. # Create a temporary engine for the import (current engine was disposed)
  1053. pg_engine = _create_engine()
  1054. try:
  1055. # Open SQLite file directly (sync — it's a local file read)
  1056. src = sqlite3.connect(str(sqlite_path))
  1057. src.row_factory = sqlite3.Row
  1058. # Get list of tables from SQLite (skip internal/FTS tables)
  1059. cursor = src.execute(
  1060. "SELECT name FROM sqlite_master WHERE type='table' "
  1061. "AND name NOT LIKE 'sqlite_%' AND name NOT LIKE 'archive_fts%'"
  1062. )
  1063. src_tables = {row["name"] for row in cursor.fetchall()}
  1064. # Where SQLite's own counters stand: ids freed there are not given out
  1065. # again on PostgreSQL either (a backup from before they were kept has none).
  1066. src_counters: dict[str, int] = {}
  1067. if src.execute("SELECT 1 FROM sqlite_master WHERE name = 'sqlite_sequence'").fetchone():
  1068. src_counters = {row["name"]: row["seq"] for row in src.execute("SELECT name, seq FROM sqlite_sequence")}
  1069. # Get Postgres tables from our ORM models
  1070. metadata = Base.metadata
  1071. pg_tables = set(metadata.tables.keys())
  1072. # Only import tables that exist in both source and destination
  1073. tables_to_import = src_tables & pg_tables
  1074. sorted_tables = [t.name for t in metadata.sorted_tables if t.name in tables_to_import]
  1075. # Phase 1: Drop all tables and recreate WITHOUT foreign keys.
  1076. # This avoids all FK ordering/orphan issues during import; the
  1077. # constraints go back on at the end, once every row has landed.
  1078. async with pg_engine.begin() as conn:
  1079. # Cap how long DROP TABLE will wait for AccessExclusiveLock so
  1080. # any residual concurrent writer (per-printer MQTT clients
  1081. # writing reactively, an AMS history recorder firing on its
  1082. # hourly cadence) surfaces a fast `lock_timeout` error instead
  1083. # of blocking the restore for 30 s or producing a deadlock.
  1084. # SET LOCAL scopes to this transaction only; outside this
  1085. # restore path the global default (no timeout) applies.
  1086. await conn.execute(text("SET LOCAL lock_timeout = '10s'"))
  1087. # Drop every existing table in the public schema with CASCADE
  1088. # rather than `metadata.drop_all`. Two reasons:
  1089. # 1. The user's live DB may carry orphan tables from removed
  1090. # features (e.g. the legacy `spoolman_slot_assignments`,
  1091. # `spoolman_k_profile`) that hold FK constraints back to
  1092. # ORM tables. `drop_all` doesn't know they exist and emits
  1093. # `DROP TABLE printers` without CASCADE — Postgres refuses
  1094. # and the whole restore aborts (#XXXX).
  1095. # 2. Even within the metadata, `drop_all` is FK-ordered and
  1096. # breaks if a future schema rename leaves old constraints
  1097. # around. CASCADE is the right tool for a destructive
  1098. # restore: the user is intentionally wiping state.
  1099. await conn.execute(
  1100. text(
  1101. "DO $$ DECLARE r RECORD; BEGIN "
  1102. "FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public') LOOP "
  1103. "EXECUTE 'DROP TABLE IF EXISTS public.' || quote_ident(r.tablename) || ' CASCADE'; "
  1104. "END LOOP; END $$;"
  1105. )
  1106. )
  1107. await conn.run_sync(metadata.create_all)
  1108. # Now strip the foreign keys, at the database level.
  1109. #
  1110. # This used to be done by discarding each ForeignKeyConstraint
  1111. # from `table.constraints` before `create_all`. That only
  1112. # suppresses the inline REFERENCES clause inside CREATE TABLE:
  1113. # `Table.foreign_key_constraints` is derived from the *columns'*
  1114. # ForeignKey objects, which the discard never touched. When
  1115. # `create_all` meets a dependency cycle it can't sort -- and
  1116. # library_files / library_folders / print_archives are exactly
  1117. # such a cycle -- it falls back to emitting those tables' keys
  1118. # as separate ALTER TABLE ... ADD FOREIGN KEY statements read
  1119. # straight from that property. Twelve constraints survived,
  1120. # including library_files.folder_id, and because the same cycle
  1121. # also drops the ordering edge from `sorted_tables` the child
  1122. # table was imported before its parent and the restore died on
  1123. # a ForeignKeyViolationError.
  1124. #
  1125. # Dropping them from pg_constraint instead is indifferent to how
  1126. # create_all chose to emit them, so a future model cycle cannot
  1127. # reintroduce this. It also keeps the app's global Base.metadata
  1128. # untouched: the old code only put the constraints back *after*
  1129. # the transaction, so a failure in here left the running process
  1130. # with an FK-less metadata until restart.
  1131. await conn.execute(
  1132. text(
  1133. "DO $$ DECLARE r RECORD; BEGIN "
  1134. "FOR r IN (SELECT conrelid::regclass AS tbl, conname FROM pg_constraint "
  1135. "WHERE contype = 'f' AND connamespace = 'public'::regnamespace) LOOP "
  1136. "EXECUTE 'ALTER TABLE ' || r.tbl || ' DROP CONSTRAINT ' || quote_ident(r.conname); "
  1137. "END LOOP; END $$;"
  1138. )
  1139. )
  1140. # Phase 2: Import data (no FKs to worry about)
  1141. async with pg_engine.begin() as conn:
  1142. # Import each table in dependency order (parents before children)
  1143. for table_name in sorted_tables:
  1144. rows = src.execute(f"SELECT * FROM {table_name}").fetchall() # noqa: S608 # nosec B608
  1145. if not rows:
  1146. continue
  1147. # Filter to columns that exist in the Postgres table
  1148. src_columns = rows[0].keys()
  1149. pg_table = metadata.tables.get(table_name)
  1150. pg_columns = {c.name for c in pg_table.columns} if pg_table is not None else set()
  1151. columns = [c for c in src_columns if c in pg_columns]
  1152. if not columns:
  1153. continue
  1154. # Columns this schema requires that the backup does not have at
  1155. # all. The block below handles a column PRESENT in the backup
  1156. # with a NULL in it; one the backup never had is not in
  1157. # `columns` and so never reached it -- which is how a backup
  1158. # from an install without `user_wallets.currency` died on
  1159. # NotNullViolationError against a version that still had it.
  1160. injected, _db_filled, _unfillable = _missing_required_columns(pg_table, set(src_columns))
  1161. if injected:
  1162. logger.info(
  1163. "Filling %s column(s) absent from the backup in %s: %s",
  1164. len(injected),
  1165. table_name,
  1166. ", ".join(sorted(injected)),
  1167. )
  1168. insert_columns = columns + list(injected)
  1169. col_list = ", ".join(insert_columns)
  1170. param_list = ", ".join(f":{c}" for c in insert_columns)
  1171. # ON CONFLICT DO NOTHING handles duplicate rows from SQLite (which doesn't enforce unique constraints)
  1172. insert_sql = text(f"INSERT INTO {table_name} ({col_list}) VALUES ({param_list}) ON CONFLICT DO NOTHING") # noqa: S608 # nosec B608
  1173. # Identify columns that need type conversion (SQLite stores booleans
  1174. # as int and datetimes as str — asyncpg requires native Python types)
  1175. from datetime import datetime as dt, timezone
  1176. bool_columns = set()
  1177. datetime_columns = set()
  1178. not_null_defaults = {} # col_name -> default value for NOT NULL columns
  1179. if pg_table is not None:
  1180. for col in pg_table.columns:
  1181. if col.name not in columns:
  1182. continue
  1183. col_type = str(col.type)
  1184. if col_type == "BOOLEAN":
  1185. bool_columns.add(col.name)
  1186. elif col_type in ("DATETIME", "TIMESTAMP WITHOUT TIME ZONE", "TIMESTAMP WITH TIME ZONE"):
  1187. datetime_columns.add(col.name)
  1188. # Track NOT NULL columns with defaults — older backups may have NULL
  1189. # for columns added after the backup was created
  1190. if not col.nullable:
  1191. if col.default is not None:
  1192. default = col.default.arg
  1193. if callable(default):
  1194. default = default(None)
  1195. not_null_defaults[col.name] = default
  1196. elif col.server_default is not None:
  1197. # server_default=func.now() → use current timestamp
  1198. if col.name in datetime_columns:
  1199. not_null_defaults[col.name] = "__now__"
  1200. else:
  1201. # Try to extract literal server default
  1202. sd = str(col.server_default.arg) if hasattr(col.server_default, "arg") else None
  1203. if sd is not None:
  1204. not_null_defaults[col.name] = sd
  1205. # Naive UTC, as every stored timestamp is: the host's local
  1206. # time put backfilled rows hours off (DB-C4).
  1207. now = dt.now(timezone.utc).replace(tzinfo=None)
  1208. value_fixes = _restored_value_fixes(table_name)
  1209. def _convert_row(
  1210. row,
  1211. cols=columns,
  1212. bools=bool_columns,
  1213. dts=datetime_columns,
  1214. nn_defaults=not_null_defaults,
  1215. _now=now,
  1216. inject=injected,
  1217. fixes=value_fixes,
  1218. ):
  1219. result = dict(inject)
  1220. for c in cols:
  1221. val = row[c]
  1222. if val is None and c in nn_defaults:
  1223. val = _now if nn_defaults[c] == "__now__" else nn_defaults[c]
  1224. if val is not None:
  1225. if c in bools:
  1226. val = bool(val)
  1227. elif c in dts and isinstance(val, str):
  1228. try:
  1229. val = dt.fromisoformat(val)
  1230. except ValueError:
  1231. pass
  1232. result[c] = val
  1233. for c, (allowed, fallback) in fixes.items():
  1234. if c in result and result[c] not in allowed:
  1235. result[c] = fallback
  1236. return result
  1237. batch = [_convert_row(row) for row in rows]
  1238. await conn.execute(insert_sql, batch)
  1239. logger.info("Imported %d rows into %s", len(batch), table_name)
  1240. # Reset sequences to max(id) + 1 for each table with an id column;
  1241. # for AUTOINCREMENT_TABLES past SQLite's counter and every id still
  1242. # referred to, so a deleted row's id is not given to a new one.
  1243. for table_name in sorted_tables:
  1244. try:
  1245. async with conn.begin_nested():
  1246. result = await conn.execute(text(f"SELECT MAX(id) FROM {table_name}")) # noqa: S608 # nosec B608
  1247. max_id = result.scalar()
  1248. if table_name in AUTOINCREMENT_TABLES:
  1249. max_id = max(
  1250. max_id or 0,
  1251. src_counters.get(table_name) or 0,
  1252. await highest_referenced_id(conn, table_name),
  1253. )
  1254. if max_id:
  1255. seq_name = f"{table_name}_id_seq"
  1256. await conn.execute(text(f"SELECT setval('{seq_name}', {max_id})")) # noqa: S608
  1257. except Exception:
  1258. pass # Table may not have an id column or sequence
  1259. src.close()
  1260. logger.info("Cross-database import complete: %d tables imported", len(tables_to_import))
  1261. # Recreate FK constraints from ORM metadata, which Phase 1 left intact.
  1262. # Use individual transactions so orphaned SQLite data doesn't block valid FKs.
  1263. from sqlalchemy.schema import AddConstraint
  1264. failed_fks = []
  1265. for table in metadata.sorted_tables:
  1266. for fk in table.foreign_key_constraints:
  1267. try:
  1268. async with pg_engine.begin() as fk_conn:
  1269. await fk_conn.execute(AddConstraint(fk))
  1270. except Exception as e:
  1271. # Name the constraint by what it links, not by `fk.name`:
  1272. # these are unnamed in the ORM, so that field is None and
  1273. # the warning used to read "print_archives.None" for every
  1274. # one of the five keys on that table -- unusable for
  1275. # working out which rows to go and look at.
  1276. cols = ", ".join(c.name for c in fk.columns)
  1277. target = fk.elements[0].target_fullname if fk.elements else "unknown"
  1278. failed_fks.append(f"{table.name}({cols}) -> {target}")
  1279. # Postgres puts the offending key in a DETAIL line; it
  1280. # names the exact orphan value, which is the one thing
  1281. # that turns this into an actionable report.
  1282. detail = next(
  1283. (ln.strip() for ln in str(e).splitlines() if ln.startswith("DETAIL:")),
  1284. str(e).splitlines()[0] if str(e) else e.__class__.__name__,
  1285. )
  1286. logger.info("FK %s(%s) -> %s not restored: %s", table.name, cols, target, detail)
  1287. if failed_fks:
  1288. logger.warning(
  1289. "Could not restore %d FK constraints (orphaned data in the backup): %s. "
  1290. "The data is restored and usable; those columns are simply no longer "
  1291. "enforced. See the INFO lines above for the offending key in each case.",
  1292. len(failed_fks),
  1293. ", ".join(failed_fks),
  1294. )
  1295. finally:
  1296. await pg_engine.dispose()
  1297. @router.post("/restore")
  1298. async def restore_backup(
  1299. file: UploadFile = File(...),
  1300. db: AsyncSession = Depends(get_db, scope="function"),
  1301. _admin: User | None = RequireAdminIfAuthEnabled(),
  1302. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_RESTORE),
  1303. ):
  1304. """Restore from a complete backup ZIP.
  1305. Replaces the database and all data directories from the backup ZIP.
  1306. Requires a restart after restore.
  1307. """
  1308. import shutil
  1309. import tempfile
  1310. from fastapi import HTTPException
  1311. from backend.app.core.database import close_all_connections, init_db, reinitialize_database
  1312. from backend.app.core.db_dialect import is_sqlite
  1313. from backend.app.services.virtual_printer import virtual_printer_manager
  1314. base_dir = app_settings.base_dir
  1315. with tempfile.TemporaryDirectory() as temp_dir:
  1316. temp_path = Path(temp_dir)
  1317. # 1. Read and extract ZIP
  1318. content = await file.read()
  1319. # Check if it's a valid ZIP
  1320. if not file.filename or not file.filename.endswith(".zip"):
  1321. raise HTTPException(400, "Invalid backup file: must be a .zip file")
  1322. try:
  1323. with zipfile.ZipFile(io.BytesIO(content), "r") as zf:
  1324. for name in zf.namelist():
  1325. # Reject path-traversal payloads: any entry whose resolved
  1326. # path escapes temp_path would allow writing arbitrary files
  1327. # on the host (ZipSlip / CVE-2006-5456).
  1328. dest = (
  1329. temp_path / name
  1330. ).resolve() # SEC-PATH-OK: is_relative_to containment check below before extractall
  1331. # is_relative_to (Python 3.9+) covers both relative
  1332. # path-traversal (../etc/passwd) and absolute-path overrides
  1333. # (/etc/passwd) — str.startswith was vulnerable to
  1334. # prefix-collision attacks (e.g. /tmp/abc_evil/file passing
  1335. # a /tmp/abc prefix check).
  1336. if not dest.is_relative_to(temp_path.resolve()):
  1337. raise HTTPException(400, f"Invalid backup: unsafe path in ZIP: {name!r}")
  1338. zf.extractall(temp_path)
  1339. except zipfile.BadZipFile:
  1340. raise HTTPException(400, "Invalid backup file: not a valid ZIP")
  1341. # 2. Validate backup
  1342. backup_db = temp_path / "bambuddy.db"
  1343. if not backup_db.exists():
  1344. raise HTTPException(400, "Invalid backup: missing bambuddy.db")
  1345. # 2b. Can this version import this backup at all?
  1346. #
  1347. # Deliberately here: everything below has a side effect. The virtual
  1348. # printer stops, background services stop, the MFA key file is
  1349. # overwritten with the backup's -- and then the Postgres import drops
  1350. # every table in its first transaction. A backup rejected at the INSERT
  1351. # took the install's data with it and left the encrypted secrets under a
  1352. # key that no longer matches. Nothing above this line has touched
  1353. # anything.
  1354. import sqlite3
  1355. manifest = _read_backup_manifest(temp_path)
  1356. backup_version = manifest.get("app_version")
  1357. if backup_version:
  1358. logger.info("Backup was created by Bambuddy %s; this install runs %s", backup_version, APP_VERSION)
  1359. if not is_sqlite():
  1360. try:
  1361. check_backup_schema_compatible(backup_db, backup_version)
  1362. except BackupSchemaIncompatible as exc:
  1363. logger.error("Refusing backup: %s", exc)
  1364. raise HTTPException(400, str(exc)) from exc
  1365. except sqlite3.DatabaseError as exc:
  1366. raise HTTPException(400, f"Invalid backup: bambuddy.db is not readable ({exc})") from exc
  1367. try:
  1368. import asyncio
  1369. # 3. Stop the virtual printers if running (releases file locks).
  1370. # stop_all, not the legacy configure(): that ignores its arguments
  1371. # and re-syncs from the database not yet replaced, so their FTP,
  1372. # MQTT and SSDP services ran on through the restore (vp-2). Like
  1373. # the services below, they come back with the restart a
  1374. # successful restore asks for.
  1375. try:
  1376. if virtual_printer_manager.is_enabled:
  1377. logger.info("Stopping virtual printers for restore...")
  1378. await virtual_printer_manager.stop_all()
  1379. await asyncio.sleep(1)
  1380. except Exception as e:
  1381. logger.warning("Failed to stop virtual printer: %s", e)
  1382. # 3b. Pause timer-based background services BEFORE the DB swap.
  1383. # close_all_connections() below only disposes the engine's pool,
  1384. # not the asyncio tasks that opened sessions from it. The print
  1385. # scheduler (30 s cadence), smart-plug snapshot loop (30 s), and
  1386. # notification digest loop all
  1387. # wake up and call async_session(), which lazily re-creates a
  1388. # pool connection holding RowExclusiveLock on print_queue /
  1389. # smart_plug_energy_snapshots / etc. The DROP TABLE CASCADE
  1390. # pass in the PostgreSQL restore path needs AccessExclusiveLock
  1391. # on every public table, producing an AB/BA deadlock and a
  1392. # full restore rollback. Successful restore already requires a
  1393. # container restart, so we don't restart the services here.
  1394. try:
  1395. from backend.app.services.notification_service import notification_service
  1396. from backend.app.services.print_scheduler import scheduler as print_scheduler
  1397. from backend.app.services.smart_plug_manager import smart_plug_manager
  1398. logger.info("Pausing background services for restore...")
  1399. print_scheduler.stop()
  1400. smart_plug_manager.stop_scheduler()
  1401. notification_service.stop_digest_scheduler()
  1402. # In-flight loop iterations need a moment to commit + release
  1403. # their DB sessions before we dispose() the engine pool.
  1404. await asyncio.sleep(1.0)
  1405. except Exception as e:
  1406. logger.warning("Could not cleanly pause background services: %s", e)
  1407. # 4. Close current database connections
  1408. logger.info("Closing database connections...")
  1409. await close_all_connections()
  1410. # B1: Restore the MFA encryption key file BEFORE the database swap.
  1411. # If the key write fails (OSError, RO disk, full disk, EACCES) we
  1412. # can still abort while the live DB is intact. Doing this AFTER the
  1413. # DB swap would leave the database with rows encrypted under the
  1414. # backup's key but the running install holding only the old key —
  1415. # every encrypted secret becomes unrecoverable.
  1416. from backend.app.core.paths import resolve_data_dir
  1417. mfa_key_src = temp_path / ".mfa_encryption_key"
  1418. if mfa_key_src.exists() and mfa_key_src.is_file():
  1419. dst_key = resolve_data_dir() / ".mfa_encryption_key"
  1420. tmp_key = dst_key.parent / ".mfa_encryption_key.restore-tmp"
  1421. try:
  1422. dst_key.parent.mkdir(parents=True, exist_ok=True)
  1423. # S1: atomic write with restrictive mode from creation.
  1424. # O_TRUNC because a stale tmp may exist from a prior
  1425. # failed restore attempt — we want to overwrite it.
  1426. fd = os.open(str(tmp_key), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
  1427. try:
  1428. os.write(fd, mfa_key_src.read_bytes())
  1429. finally:
  1430. os.close(fd)
  1431. # POSIX rename(2) — atomic when source/dest are on the
  1432. # same filesystem (we're staying inside dst_key.parent).
  1433. os.replace(str(tmp_key), str(dst_key))
  1434. # S9: warn if the FS doesn't enforce 0o600
  1435. actual_mode = dst_key.stat().st_mode & 0o777
  1436. if actual_mode != 0o600:
  1437. logger.warning(
  1438. "Restored MFA key file %s: filesystem did not enforce 0o600 "
  1439. "(actual: 0o%o). Key may be world-readable on Windows / SMB / FUSE.",
  1440. dst_key,
  1441. actual_mode,
  1442. )
  1443. logger.info("Restored .mfa_encryption_key from backup")
  1444. except OSError as e:
  1445. logger.error(
  1446. "Could not write restored MFA key file to %s: %s — "
  1447. "aborting BEFORE database swap (DB unchanged).",
  1448. dst_key,
  1449. e,
  1450. exc_info=True,
  1451. )
  1452. raise HTTPException(
  1453. status_code=500,
  1454. detail=("Restore aborted: MFA key write failed. Database is unchanged. Check server logs."),
  1455. ) from e
  1456. # 5. Replace database
  1457. logger.info("Restoring database from backup...")
  1458. if is_sqlite():
  1459. db_path = Path(app_settings.database_url.replace("sqlite+aiosqlite:///", ""))
  1460. # Use SQLite's online backup API instead of shutil.copy2.
  1461. # The pragma at database.py:19 runs the live DB in WAL mode,
  1462. # which means a naive file copy is unsafe: anything written
  1463. # to the live DB before this call that hasn't been
  1464. # checkpointed yet (seed_default_groups + init_db on first
  1465. # start, plus whatever background heartbeats wrote during
  1466. # the request window) sits in bambuddy.db-wal with valid
  1467. # checksums. The route handler's own `db: Depends(get_db, scope="function")`
  1468. # session also keeps a connection checked out across
  1469. # engine.dispose(), holding fds to the WAL inode. With
  1470. # `shutil.copy2` SQLite finds the stale WAL on the next
  1471. # open and silently re-applies those page-level writes on
  1472. # top of the restored DB, partially clobbering it with
  1473. # fresh-install state — the user sees a "successful"
  1474. # restore where most rows and settings have reverted to
  1475. # defaults (#1211 / #668). The page-by-page backup API
  1476. # opens both DBs as real SQLite connections, takes the
  1477. # right locks, and routes new pages through the live DB's
  1478. # own WAL — so concurrent open sessions see their own
  1479. # snapshot until they close (transaction isolation) but
  1480. # can't corrupt the restored state.
  1481. import sqlite3
  1482. src_conn = sqlite3.connect(str(backup_db))
  1483. try:
  1484. dst_conn = sqlite3.connect(str(db_path))
  1485. try:
  1486. src_conn.backup(dst_conn)
  1487. finally:
  1488. dst_conn.close()
  1489. finally:
  1490. src_conn.close()
  1491. else:
  1492. # Import SQLite backup into PostgreSQL
  1493. logger.info("Importing SQLite backup into PostgreSQL...")
  1494. await _import_sqlite_to_postgres(backup_db)
  1495. # 6. Replace data directories
  1496. # For Docker compatibility: clear contents then copy (don't delete mount points)
  1497. dirs_to_restore = [
  1498. ("archive", base_dir / "archive"),
  1499. ("virtual_printer", base_dir / "virtual_printer"),
  1500. ("plate_calibration", app_settings.plate_calibration_dir),
  1501. ("icons", base_dir / "icons"),
  1502. ("projects", base_dir / "projects"),
  1503. ("overlay-branding", base_dir / "overlay-branding"),
  1504. ]
  1505. skipped_dirs = []
  1506. for name, dest_dir in dirs_to_restore:
  1507. src_dir = (
  1508. temp_path / name
  1509. ) # SEC-PATH-OK: name iterates the dirs_to_restore tuple of constant strings ("archive", "virtual_printer", ...)
  1510. if src_dir.exists():
  1511. logger.info("Restoring %s directory...", name)
  1512. try:
  1513. # Clear destination contents (not the dir itself - may be Docker mount)
  1514. if dest_dir.exists():
  1515. for item in dest_dir.iterdir():
  1516. try:
  1517. if item.is_dir():
  1518. shutil.rmtree(item)
  1519. else:
  1520. item.unlink()
  1521. except OSError as e:
  1522. logger.warning("Could not delete %s: %s", item, e)
  1523. else:
  1524. dest_dir.mkdir(parents=True, exist_ok=True)
  1525. # Copy contents from backup
  1526. for item in src_dir.iterdir():
  1527. dest_item = dest_dir / item.name
  1528. if item.is_dir():
  1529. shutil.copytree(item, dest_item)
  1530. else:
  1531. shutil.copy2(item, dest_item)
  1532. except OSError as e:
  1533. logger.warning("Could not restore %s directory: %s", name, e)
  1534. skipped_dirs.append(name)
  1535. # 7. Reset the encryption singleton so the migration that runs
  1536. # inside init_db() picks up the restored key file (if a new one
  1537. # was written above). Without this reset, _get_fernet would
  1538. # return the cached Fernet instance built from the previous key.
  1539. import backend.app.core.encryption as _enc_mod
  1540. _enc_mod._fernet_instance = None
  1541. _enc_mod._key_source = None
  1542. _enc_mod._warn_shown = False
  1543. # 8. Reinitialize the database engine and apply schema migrations so that
  1544. # tables added after the backup was created (e.g. ams_labels) exist
  1545. # immediately, without requiring a manual restart.
  1546. await reinitialize_database()
  1547. await init_db()
  1548. # 8b. A backup from a Windows install stores its paths with
  1549. # backslashes, which Linux and macOS read as part of a file name
  1550. # (#3501). After init_db, so the tables are current, and after the
  1551. # files are copied, so a path that exists as written is kept.
  1552. from backend.app.core import database as _db_mod
  1553. from backend.app.services.backup_paths import convert_windows_paths
  1554. try:
  1555. async with _db_mod.engine.begin() as conn:
  1556. await convert_windows_paths(conn, base_dir)
  1557. except Exception as e:
  1558. logger.warning("Could not convert Windows file paths from the backup: %s", e, exc_info=True)
  1559. # 9. Sign everyone out. The restored users and auth tokens come from
  1560. # another point in time, possibly written by older code, so no
  1561. # session issued before the restore should stay valid.
  1562. async with _db_mod.engine.begin() as conn:
  1563. await _db_mod.invalidate_all_sessions(conn)
  1564. # Open dashboards of signed-in users too: they are never signed in
  1565. # again. API-key and anonymous ones are not closed outright (nothing
  1566. # ended theirs), but the restored data decides what they may still see: the anonymous ones
  1567. # go if the backup turns authentication on, and the refresh closes
  1568. # those of a key the backup does not have (or has under another key).
  1569. from backend.app.core.auth import invalidate_auth_enabled_cache
  1570. from backend.app.core.websocket import ws_manager
  1571. # Read from the restored data: this request has just cached the
  1572. # setting it had before.
  1573. invalidate_auth_enabled_cache()
  1574. # Cloud presets were cached per user of the replaced user table.
  1575. from backend.app.api.routes.cloud import forget_all_cloud_presets
  1576. forget_all_cloud_presets()
  1577. async with _db_mod.async_session() as auth_db:
  1578. auth_on = await is_auth_enabled(auth_db)
  1579. if auth_on:
  1580. await ws_manager.close_signed_in()
  1581. await ws_manager.close_anonymous()
  1582. await ws_manager.refresh_printer_scopes()
  1583. logger.info("Restore complete - restart required")
  1584. message = "Backup restored successfully. Please restart Bambuddy for changes to take effect."
  1585. if skipped_dirs:
  1586. message += f" Note: Some directories could not be restored ({', '.join(skipped_dirs)})."
  1587. return {
  1588. "success": True,
  1589. "message": message,
  1590. }
  1591. except HTTPException:
  1592. # Preserve specific HTTP error responses raised inside the restore
  1593. # body (e.g. the key-write OSError → 500). The blanket
  1594. # except Exception below would otherwise swallow them and replace
  1595. # the operator-facing detail with a generic message.
  1596. raise
  1597. except Exception as e:
  1598. logger.error("Restore failed: %s", e, exc_info=True)
  1599. return JSONResponse(
  1600. status_code=500,
  1601. content={"success": False, "message": "Restore failed. Check server logs for details."},
  1602. )
  1603. @router.get("/network-interfaces")
  1604. async def get_network_interfaces(
  1605. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  1606. ):
  1607. """Get available network interfaces with all IPs (primary + aliases)."""
  1608. from backend.app.services.network_utils import get_all_interface_ips
  1609. interfaces = get_all_interface_ips()
  1610. return {"interfaces": interfaces}
  1611. @router.get("/virtual-printer/models")
  1612. async def get_virtual_printer_models(
  1613. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  1614. ):
  1615. """Get available virtual printer models."""
  1616. from backend.app.services.virtual_printer import (
  1617. DEFAULT_VIRTUAL_PRINTER_MODEL,
  1618. VIRTUAL_PRINTER_MODELS,
  1619. )
  1620. return {
  1621. "models": VIRTUAL_PRINTER_MODELS,
  1622. "default": DEFAULT_VIRTUAL_PRINTER_MODEL,
  1623. }
  1624. def _legacy_vp_status(status: dict, printer_scope: PrinterScope) -> dict:
  1625. """The first virtual printer's status, without what names its target for a limited caller."""
  1626. if printer_scope.is_unrestricted:
  1627. return status
  1628. return {key: value for key, value in status.items() if key not in ("name", "serial", "target_printer_ip", "proxy")}
  1629. @router.get("/virtual-printer")
  1630. async def get_virtual_printer_settings(
  1631. db: AsyncSession = Depends(get_db, scope="function"),
  1632. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  1633. printer_scope: PrinterScope = RequestPrinterScope,
  1634. ):
  1635. """Get the settings this route still sets, and the virtual printers' status.
  1636. Every other virtual printer setting lives on its own row
  1637. (``GET /virtual-printers``).
  1638. """
  1639. from backend.app.services.virtual_printer import virtual_printer_manager
  1640. tailscale_disabled_raw = await get_setting(db, "virtual_printer_tailscale_disabled")
  1641. archive_name_source = await get_setting(db, "virtual_printer_archive_name_source")
  1642. return {
  1643. "tailscale_disabled": tailscale_disabled_raw == "true" if tailscale_disabled_raw else True,
  1644. "archive_name_source": archive_name_source if archive_name_source in ("metadata", "filename") else "metadata",
  1645. "status": _legacy_vp_status(virtual_printer_manager.get_status(), printer_scope),
  1646. }
  1647. @router.put("/virtual-printer")
  1648. async def update_virtual_printer_settings(
  1649. enabled: bool = None,
  1650. access_code: str = None,
  1651. mode: str = None,
  1652. model: str = None,
  1653. target_printer_id: int = None,
  1654. remote_interface_ip: str = None,
  1655. tailscale_disabled: bool = None,
  1656. archive_name_source: str = None,
  1657. db: AsyncSession = Depends(get_db, scope="function"),
  1658. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_UPDATE),
  1659. printer_scope: PrinterScope = RequestPrinterScope,
  1660. ):
  1661. """Legacy single-printer settings: the archive name source and the first
  1662. virtual printer's Tailscale switch.
  1663. Every other virtual printer setting lives on its own row, set with
  1664. ``PUT /virtual-printers/{id}``; the rest of this route's parameters are
  1665. refused (vp-3).
  1666. """
  1667. from sqlalchemy import select
  1668. from backend.app.models.virtual_printer import VirtualPrinter as FirstVP
  1669. current_target_id_str = await get_setting(db, "virtual_printer_target_printer_id")
  1670. current_target_id = int(current_target_id_str) if current_target_id_str else None
  1671. # One bridging to a printer the caller can't use is not theirs to change,
  1672. # and they can't aim it at such a printer.
  1673. # The first virtual printer is the one these settings reach.
  1674. first_vp = (await db.execute(select(FirstVP).order_by(FirstVP.position, FirstVP.id).limit(1))).scalar_one_or_none()
  1675. if not printer_scope.allows(current_target_id) or (
  1676. first_vp is not None and not printer_scope.allows(first_vp.target_printer_id)
  1677. ):
  1678. return JSONResponse(status_code=404, content={"detail": "Virtual printer not found"})
  1679. if target_printer_id is not None and not printer_scope.allows(target_printer_id):
  1680. return JSONResponse(status_code=400, content={"detail": f"Printer with ID {target_printer_id} not found"})
  1681. # Each virtual printer keeps these itself now; this route wrote them to
  1682. # settings keys nothing reads and answered 200 as if applied (vp-3). The
  1683. # stored legacy values are not checked either: an old install's stale
  1684. # mode or deleted target printer refused the settings this still serves.
  1685. unread = [
  1686. name
  1687. for name, value in (
  1688. ("enabled", enabled),
  1689. ("access_code", access_code),
  1690. ("mode", mode),
  1691. ("model", model),
  1692. ("target_printer_id", target_printer_id),
  1693. ("remote_interface_ip", remote_interface_ip),
  1694. )
  1695. if value is not None
  1696. ]
  1697. if unread:
  1698. return JSONResponse(
  1699. status_code=400,
  1700. content={
  1701. "detail": f"{', '.join(unread)} cannot be set here any more: set them for each virtual printer "
  1702. "with PUT /api/v1/virtual-printers/{id}"
  1703. },
  1704. )
  1705. if archive_name_source is not None and archive_name_source not in ("metadata", "filename"):
  1706. return JSONResponse(
  1707. status_code=400,
  1708. content={"detail": "archive_name_source must be 'metadata' or 'filename'"},
  1709. )
  1710. if tailscale_disabled is not None:
  1711. await set_setting(db, "virtual_printer_tailscale_disabled", "true" if tailscale_disabled else "false")
  1712. # The first virtual printer's card shows its Tailscale address by it.
  1713. if first_vp is not None:
  1714. first_vp.tailscale_disabled = tailscale_disabled
  1715. if archive_name_source is not None:
  1716. await set_setting(db, "virtual_printer_archive_name_source", archive_name_source)
  1717. await db.commit()
  1718. db.expire_all()
  1719. return await get_virtual_printer_settings(db, printer_scope=printer_scope)
  1720. # =============================================================================
  1721. # MQTT Relay Settings
  1722. # =============================================================================
  1723. @router.get("/mqtt/status")
  1724. async def get_mqtt_status(
  1725. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  1726. ):
  1727. """Get MQTT relay connection status."""
  1728. from backend.app.services.mqtt_relay import mqtt_relay
  1729. return mqtt_relay.get_status()
  1730. @router.get("/panda-breath/status")
  1731. async def get_panda_breath_status(
  1732. _: User | None = RequirePermissionIfAuthEnabled(Permission.SETTINGS_READ),
  1733. printer_scope: PrinterScope = RequestPrinterScope,
  1734. db: AsyncSession = Depends(get_db, scope="function"),
  1735. ):
  1736. """Panda Breath heaters heard on the MQTT broker and their printers (#1466).
  1737. A heater bound to a printer outside the caller's scope is listed without
  1738. naming the printer.
  1739. """
  1740. from backend.app.models.printer import Printer
  1741. from backend.app.services.panda_breath import panda_breath_service
  1742. query = select(Printer.id, Printer.name, Printer.serial_number)
  1743. in_scope = printer_scope.where_strict(Printer.id)
  1744. if in_scope is not None:
  1745. query = query.where(in_scope)
  1746. rows = await db.execute(query)
  1747. printers = {(serial or "").strip().upper(): (pid, name) for pid, name, serial in rows.all() if serial}
  1748. return panda_breath_service.get_status(printers)