mirror of
https://github.com/fusion44/blitz_api.git
synced 2026-08-13 11:52:45 +02:00
343 lines
13 KiB
Python
343 lines
13 KiB
Python
import logging
|
|
from pickle import FALSE
|
|
from xmlrpc.client import boolean
|
|
|
|
from aioredis import Redis
|
|
from fastapi import APIRouter, HTTPException, status
|
|
from fastapi.params import Depends
|
|
from fastapi_plugins import depends_redis
|
|
from pydantic import BaseModel
|
|
from setuptools import setup
|
|
|
|
from app.auth.auth_bearer import JWTBearer
|
|
from app.auth.auth_handler import sign_jwt
|
|
from app.repositories.system import name_valid, password_valid, shutdown
|
|
from app.utils import call_script, parse_key_value_lines, redis_get
|
|
|
|
router = APIRouter(prefix="/setup", tags=["Setup"])
|
|
|
|
setupFilePath = "/var/cache/raspiblitz/temp/raspiblitz.setup"
|
|
configFilePath = "/mnt/hdd/raspiblitz.conf"
|
|
|
|
# can always be called without credentials to check if
|
|
# the system needs or is in setup (setupPhase!="done")
|
|
# for example in the beginning setupPhase can be (see controlSetupDialog.sh)
|
|
# 1) recovery = same version on fresh sd card
|
|
# 2) update = updated version on fresh sd card
|
|
# 3) migration = hdd got data from another node project
|
|
# 4) setup = a fresh blitz to setup
|
|
@router.get("/status")
|
|
async def get_status():
|
|
setupPhase = await redis_get("setupPhase")
|
|
state = await redis_get("state")
|
|
message = await redis_get("message")
|
|
if setupPhase == "done":
|
|
try:
|
|
btc_default_sync_initial_done = await redis_get(
|
|
"btc_default_sync_initial_done"
|
|
)
|
|
if btc_default_sync_initial_done == "1":
|
|
initialsync = "done"
|
|
else:
|
|
initialsync = "running"
|
|
except:
|
|
initialsync = ""
|
|
else:
|
|
initialsync = ""
|
|
return {
|
|
"setupPhase": setupPhase,
|
|
"state": state,
|
|
"message": message,
|
|
"initialsync": initialsync,
|
|
}
|
|
|
|
|
|
# if setupPhase!="done" && state="waitsetup" then
|
|
# 'setup/setup_start_info' should be called
|
|
# We can do the "MIGRATION" option later - because it would need an additional step after formatting hdd
|
|
# People that need to migrate can do for now by SSH option
|
|
|
|
|
|
@router.get("/setup-start-info")
|
|
async def setup_start_info():
|
|
|
|
# first check that node is really in setup state
|
|
setupPhase = await redis_get("setupPhase")
|
|
state = await redis_get("state")
|
|
if state != "waitsetup":
|
|
logging.warning(f"/setup-start-info can only be called when nodes awaits setup")
|
|
return HTTPException(status.status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
# get all the additional info needed to do setup dialog
|
|
hddGotMigrationData = await redis_get("hddGotMigrationData")
|
|
hddGotBlockchain = await redis_get("hddBlocksBitcoin")
|
|
migrationMode = await redis_get("migrationMode")
|
|
lan = await redis_get("internet_localip")
|
|
tor = await redis_get("tor_web_addr")
|
|
# return info as JSON
|
|
return {
|
|
"setupPhase": setupPhase,
|
|
"migrationMode": migrationMode, # 'normal', 'outdatedLightning'
|
|
"hddGotMigrationData": hddGotMigrationData, # 'umbrel', 'mynode', 'citadel'
|
|
"hddGotBlockchain": hddGotBlockchain,
|
|
"ssh_login": f"ssh admin@{lan}",
|
|
"tor_web_ui": tor,
|
|
}
|
|
|
|
|
|
def write_text_file(filename: str, arrayOfLines):
|
|
with open(filename, "w", encoding="utf-8") as f:
|
|
f.write("\n".join(arrayOfLines))
|
|
|
|
|
|
class StartDoneData(BaseModel):
|
|
hostname: str = ""
|
|
forceFreshSetup: bool = False
|
|
keepBlockchain: bool = True
|
|
lightning: str = ""
|
|
passwordA: str = ""
|
|
passwordB: str = ""
|
|
passwordC: str = ""
|
|
|
|
|
|
# With all this info the WebUi can run its own runs its dialogs and in the end makes a call to
|
|
@router.post("/setup-start-done")
|
|
async def setup_start_done(data: StartDoneData):
|
|
|
|
# first check that node is really in setup state
|
|
setupPhase = await redis_get("setupPhase")
|
|
state = await redis_get("state")
|
|
hddGotBlockchain = await redis_get("hddBlocksBitcoin")
|
|
|
|
if state != "waitsetup":
|
|
logging.warning(f"/setup-start-done can only be called when nodes awaits setup")
|
|
return HTTPException(status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
# check if a fresh setup is forced
|
|
if data.forceFreshSetup:
|
|
logging.warning(f"forcing node to fresh setup")
|
|
setupPhase = "setup"
|
|
|
|
#### SETUP ####
|
|
if setupPhase == "setup":
|
|
if name_valid(data.hostname) == False:
|
|
logging.warning(f"hostname is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if (
|
|
data.lightning != "lnd"
|
|
and data.lightning != "cl"
|
|
and data.lightning != "none"
|
|
):
|
|
logging.warning(f"lightning is not valid")
|
|
if password_valid(data.passwordA) == False:
|
|
logging.warning(f"passwordA is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if password_valid(data.passwordB) == False:
|
|
logging.warning(f"passwordB is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if data.lightning != "none" and password_valid(data.passwordC) == False:
|
|
logging.warning(f"passwordC is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if hddGotBlockchain != "1" and data.keepBlockchain:
|
|
logging.warning(f"cannot keep blockchain that does not exists")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if data.keepBlockchain:
|
|
formatHDD = 0
|
|
cleanHDD = 1
|
|
else:
|
|
formatHDD = 1
|
|
cleanHDD = 0
|
|
write_text_file(
|
|
setupFilePath,
|
|
[
|
|
f"formatHDD={formatHDD}",
|
|
f"cleanHDD={cleanHDD}",
|
|
"network=bitcoin",
|
|
"chain=main",
|
|
f"lightning={data.lightning}",
|
|
f"hostname={data.hostname}",
|
|
"setPasswordA=1",
|
|
"setPasswordB=1",
|
|
"setPasswordC=1",
|
|
f"passwordA='{data.passwordA}'",
|
|
f"passwordB='{data.passwordB}'",
|
|
f"passwordC='{data.passwordC}'",
|
|
"",
|
|
],
|
|
)
|
|
|
|
#### RECOVERY ####
|
|
elif setupPhase == "recovery" or setupPhase == "update":
|
|
logging.warning(f"check recovery data")
|
|
if password_valid(data.passwordA) == False:
|
|
logging.warning(f"passwordA is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
write_text_file(
|
|
setupFilePath, ["setPasswordA=1", f"passwordA='{data.passwordA}'"]
|
|
)
|
|
|
|
#### MIGRATION ####
|
|
elif setupPhase == "migration":
|
|
logging.warning(f"check migration data")
|
|
hddGotMigrationData = await redis_get("hddGotMigrationData")
|
|
if hddGotMigrationData == "":
|
|
logging.warning(f"hddGotMigrationData is not available")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if password_valid(data.passwordA) == False:
|
|
logging.warning(f"passwordA is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if password_valid(data.passwordB) == False:
|
|
logging.warning(f"passwordB is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
if password_valid(data.passwordC) == False:
|
|
logging.warning(f"passwordC is not valid")
|
|
return HTTPException(status.HTTP_400_BAD_REQUEST)
|
|
write_text_file(
|
|
setupFilePath,
|
|
[
|
|
f"migrationOS={hddGotMigrationData}",
|
|
"setPasswordA=1",
|
|
"setPasswordB=1",
|
|
"setPasswordC=1",
|
|
f"passwordA='{data.passwordA}'",
|
|
f"passwordB='{data.passwordB}'",
|
|
f"passwordC='{data.passwordC}'",
|
|
],
|
|
)
|
|
|
|
else:
|
|
logging.warning(f"not handled setupPhase state ({setupPhase})")
|
|
return HTTPException(status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
await call_script("/home/admin/_cache.sh set state waitprovision")
|
|
|
|
# TODO: Following input parameters:
|
|
# lightning='lnd', 'cl' or 'none'
|
|
# network=bitcoin
|
|
# chain=main
|
|
# hostname=[string]
|
|
# passwordA=[string]
|
|
# passwordB=[string]
|
|
# passwordC=[string] (might be empty of no lightning was chosen)
|
|
# lndrescue=[path] (might be used later if lnd rescue file upload is offered)
|
|
# clrescue=[path] (might be used later if c-lightning rescue file upload is offered)
|
|
# seedWords= (might be used later if we offer recover from seed words)
|
|
# seedPassword= (might be used later if we offer recover from seed words)
|
|
# migrationFile=[path] (might be used later if we offer raspiblitz migration)
|
|
# those values get stored in: /var/cache/raspiblitz/temp/raspiblitz.setup
|
|
# also a skeleton raspiblitz.conf gets created (see controlSetupDialog.sh Line 318)
|
|
# and then API sets state to `waitprovision` to kick-off provision
|
|
|
|
return sign_jwt()
|
|
|
|
|
|
# WebUI now loops getting status until state=`waitfinal` then calls:
|
|
@router.get("/setup-final-info", dependencies=[Depends(JWTBearer())])
|
|
async def setup_final_info():
|
|
# TODO: return info on setup final
|
|
# during the process some data might be written to /var/cache/raspiblitz/temp/raspiblitz.setup
|
|
# seedwordsNEW='${seedwords}
|
|
# seedwords6x4NEW='${seedwords6x4}
|
|
# syncProgressFull=[percent] = (later WebUi can offer sync from another RaspiBlitz)
|
|
|
|
# first check that node is really in setup state
|
|
setupPhase = await redis_get("setupPhase")
|
|
state = await redis_get("state")
|
|
if state != "waitfinal":
|
|
logging.warning(
|
|
f"/setup-final-info can only be called when nodes awaits final ({state})"
|
|
)
|
|
return HTTPException(status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
result_lines = []
|
|
with open(setupFilePath, "r") as setup_file:
|
|
result_lines = setup_file.readlines()
|
|
data = parse_key_value_lines(result_lines)
|
|
try:
|
|
seedwordsNEW = data["seedwordsNEW"]
|
|
except:
|
|
seedwordsNEW = ""
|
|
|
|
return {"seedwordsNEW": seedwordsNEW}
|
|
|
|
|
|
# When WebUI displayed seed words & user confirmed write the calls:
|
|
@router.post("/setup-final-done", dependencies=[Depends(JWTBearer())])
|
|
async def setup_final_done():
|
|
|
|
# first check that node is really in setup state
|
|
setupPhase = await redis_get("setupPhase")
|
|
state = await redis_get("state")
|
|
if state != "waitfinal":
|
|
logging.warning(f"/setup-final-done can only be called when nodes awaits final")
|
|
return HTTPException(status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
await call_script("/home/admin/_cache.sh set state donefinal")
|
|
return {"state": "donefinal"}
|
|
|
|
|
|
@router.get("/shutdown")
|
|
async def get_shutdown():
|
|
|
|
# only allow unauthorized shutdowns during setup
|
|
setupPhase = await redis_get("setupPhase")
|
|
state = await redis_get("state")
|
|
if setupPhase == "done":
|
|
logging.warning(f"can only be called when the nodes is not finalized yet")
|
|
return HTTPException(status.status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
if state != "waitsetup":
|
|
logging.warning(f"can only be called when nodes awaits setup")
|
|
return HTTPException(status.status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
# do the shutdown
|
|
return await shutdown(False)
|
|
|
|
|
|
# When WebUI displayed seed words & user confirmed write the calls:
|
|
@router.post("/setup-sync-info", dependencies=[Depends(JWTBearer())])
|
|
async def setup_sync_info():
|
|
|
|
# first check that node is really in setup state
|
|
setupPhase = await redis_get("setupPhase")
|
|
if setupPhase != "done":
|
|
logging.warning(f"sync info not available yet")
|
|
return HTTPException(status.HTTP_405_METHOD_NOT_ALLOWED)
|
|
|
|
try:
|
|
blitz_sync_initial_done = await redis_get("blitz_sync_initial_done")
|
|
if blitz_sync_initial_done == "1":
|
|
initialsync = "done"
|
|
else:
|
|
initialsync = "running"
|
|
btc_default_ready = await redis_get("btc_default_ready")
|
|
btc_default_sync_percentage = await redis_get("btc_default_sync_percentage")
|
|
btc_default_peers = await redis_get("btc_default_peers")
|
|
system_count_start_blockchain = await redis_get("system_count_start_blockchain")
|
|
except:
|
|
initialsync = ""
|
|
btc_default_ready = ""
|
|
btc_default_sync_percentage = ""
|
|
btc_default_peers = ""
|
|
system_count_start_blockchain = "0"
|
|
try:
|
|
ln_default = await redis_get("lightning")
|
|
ln_default_ready = await redis_get("ln_default_ready")
|
|
ln_default_locked = await redis_get("ln_default_locked")
|
|
system_count_start_lightning = await redis_get("system_count_start_lightning")
|
|
except:
|
|
ln_default = ""
|
|
ln_default_ready = ""
|
|
ln_default_locked = ""
|
|
system_count_start_lightning = "0"
|
|
return {
|
|
"initialsync": initialsync,
|
|
"btc_default": "bitcoin",
|
|
"btc_default_ready": btc_default_ready,
|
|
"btc_default_sync_percentage": btc_default_sync_percentage,
|
|
"btc_default_peers": btc_default_peers,
|
|
"system_count_start_blockchain": system_count_start_blockchain,
|
|
"ln_default": ln_default,
|
|
"ln_default_ready": ln_default_ready,
|
|
"ln_default_locked": ln_default_locked,
|
|
"system_count_start_lightning": system_count_start_lightning,
|
|
}
|