Installing INDI Webmanager

[Olli781]

Hello everyone,

I've installed the latest version of astroarch on a Raspberry Pi 5. So far, everything is working well. I'd now like to install the INDI Web Manager. Unfortunately, I can't find any instructions for installing it on Arch Linux. Can anyone help me with this?

Thank you very much.

[rankinstudio]

Here is a python solution to starting / stopping drivers over SSH:

Start:

import paramiko
import time

# INDI DRIVER CHECK / START
PI_IP   = "YOUR IP"
PI_USER = "astronaut" #defaults from astroarch
PI_PASS = "astro"

#your required drivers
REQUIRED_DRIVERS = [
    "indi_qhy_ccd",
    "indi_eqmod_telescope",
    "indi_asi_focuser",
    "indi_rolloffino",
]

def pi_run(command):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(PI_IP, username=PI_USER, password=PI_PASS)
    _, stdout, stderr = ssh.exec_command(command)
    out = stdout.read().decode().strip()
    err = stderr.read().decode().strip()
    ssh.close()
    return out, err

def pi_run_bg(command):
    """Fire-and-forget: launches a background process without blocking."""
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(PI_IP, username=PI_USER, password=PI_PASS)
    channel = ssh.get_transport().open_session()
    # Fully detach stdin/stdout so the process survives SSH session close
    channel.exec_command(f"bash -c '{command} </dev/null >/dev/null 2>&1 &'")
    channel.close()
    ssh.close()

def get_running_drivers():
    out, _ = pi_run("ps aux | grep -i indi | grep -v grep")
    return out

def drivers_running(ps_output):
    return [d for d in REQUIRED_DRIVERS if d in ps_output]

def drivers_missing(ps_output):
    return [d for d in REQUIRED_DRIVERS if d not in ps_output]

print("\nChecking INDI drivers...")
ps = get_running_drivers()
missing = drivers_missing(ps)
running = drivers_running(ps)

if running:
    print(f"  Already running: {', '.join(running)}")

if missing:
    print(f"  Missing drivers:  {', '.join(missing)}")
    print("  Starting indiserver with all required drivers...")
    pi_run("pkill -f indiserver")
    time.sleep(2)
    driver_args = " ".join(f"/usr/bin/{d}" for d in REQUIRED_DRIVERS)
    pi_run_bg(f"/usr/bin/indiserver -v {driver_args} >/tmp/indiserver.log 2>&1")
    time.sleep(10)

    ps2 = get_running_drivers()
    confirmed = drivers_running(ps2)
    still_missing = drivers_missing(ps2)

    if confirmed:
        print(f"  Confirmed started: {', '.join(confirmed)}")
    if still_missing:
        print(f"  WARNING - failed to start: {', '.join(still_missing)}")
    else:
        print("  All INDI drivers running.")
else:
    print("  All INDI drivers already running.")

Stop:

import paramiko
import time

PI_IP   = "YOUR PI IP"
PI_USER = "astronaut"
PI_PASS = "astro"

REQUIRED_DRIVERS = [
    "indi_qhy_ccd",
    "indi_eqmod_telescope",
    "indi_asi_focuser",
    "indi_rolloffino",
]

def pi_run(command):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(PI_IP, username=PI_USER, password=PI_PASS)
    _, stdout, stderr = ssh.exec_command(command)
    out = stdout.read().decode().strip()
    err = stderr.read().decode().strip()
    ssh.close()
    return out, err

# STOP INDI
print("Checking for running INDI drivers...")
ps_out, _ = pi_run("ps aux | grep -i indi | grep -v grep")
running = [d for d in REQUIRED_DRIVERS if d in ps_out]

if running:
    print(f"  Stopping: {', '.join(running)}")
    pi_run("pkill -f indiserver")
    for driver in REQUIRED_DRIVERS:
        pi_run(f"pkill -f {driver}")
    time.sleep(3)
    ps_check, _ = pi_run("ps aux | grep -i indi | grep -v grep")
    still_running = [d for d in REQUIRED_DRIVERS if d in ps_check]
    if still_running:
        print(f"  WARNING - still running: {', '.join(still_running)}")
    else:
        print("  All INDI drivers stopped.")
else:
    print("  No INDI drivers running.")

# SHUTDOWN PI
print("Shutting down Pi...")
pi_run("sudo shutdown -h now")
print("Shutdown command sent. Waiting 30s for Pi to power down...")
time.sleep(30)

[rankinstudio]

After some testing, this is a better way to shut things down over ssh. It properly kills the INDI drivers and releases the USB ports so everything connects right on next boot:

import paramiko
import time

#default astroarch login
PI_IP   = "10.0.0.181"
PI_USER = "astronaut" 
PI_PASS = "astro"

REQUIRED_DRIVERS = [
    "indi_qhy_ccd",
    "indi_eqmod_telescope",
    "indi_asi_focuser",
    "indi_rolloffino",
]

def pi_run(command):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(PI_IP, username=PI_USER, password=PI_PASS)
    _, stdout, stderr = ssh.exec_command(command)
    out = stdout.read().decode().strip()
    err = stderr.read().decode().strip()
    ssh.close()
    return out, err

# STOP INDI
def indi_procs_running():
    ps_out, _ = pi_run("ps aux | grep -i indi | grep -v grep")
    drivers = [d for d in REQUIRED_DRIVERS if d in ps_out]
    server = "indiserver" in ps_out
    return server, drivers, ps_out

print("Checking for running INDI processes...")
server, running, _ = indi_procs_running()

if server or running:
    print(f"  Found indiserver={server}, drivers={running}")

    # Step 1: SIGTERM indiserver and let it gracefully tear down its driver children.
    # indiserver propagates the signal to drivers so USB devices release cleanly.
    print("  SIGTERM indiserver, waiting for graceful driver shutdown...")
    pi_run("pkill -TERM -f indiserver")
    time.sleep(8)

    # Step 2: SIGTERM any straggler drivers directly.
    server, running, _ = indi_procs_running()
    if server or running:
        print(f"  Stragglers after indiserver SIGTERM: server={server}, drivers={running}")
        for driver in running:
            pi_run(f"pkill -TERM -f {driver}")
        if server:
            pi_run("pkill -TERM -f indiserver")
        time.sleep(5)

    # Step 3: SIGKILL anything still alive (last resort - USB may not release cleanly).
    server, running, _ = indi_procs_running()
    if server or running:
        print(f"  SIGKILL force: server={server}, drivers={running}")
        for driver in running:
            pi_run(f"pkill -KILL -f {driver}")
        if server:
            pi_run("pkill -KILL -f indiserver")
        time.sleep(3)

    # Final verification
    server, running, _ = indi_procs_running()
    if server or running:
        print(f"  WARNING - still running after SIGKILL: server={server}, drivers={running}")
    else:
        print("  All INDI processes stopped cleanly.")
else:
    print("  No INDI processes running.")

# Let USB devices fully release before powering down the Pi
print("Waiting 10s for USB devices to release...")
time.sleep(10)

# SHUTDOWN PI
print("Shutting down Pi...")
try:
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(PI_IP, username=PI_USER, password=PI_PASS)
    ssh.exec_command("sudo shutdown -h now")
    time.sleep(2)
    ssh.close()
except Exception:
    pass  # connection drop on shutdown is expected

print("Shutdown command sent. Waiting 30s for Pi to power down...")
time.sleep(30)