remoteRF-server-testing 0.0.0__py3-none-any.whl

remoteRF_server/drivers/adalm_pluto/pluto_remote_server.py

@@ -0,0 +1,105 @@
+from ...server.device_manager import set_pluto, get_device as device_pluto
+from ...common.utils.process_arg import unmap_arg, map_arg
+        
+class PlutoServer: 
+    
+    @staticmethod
+    def handle_call(*, function_name, args):
+        try:
+            # print(f'fn {function_name}')
+            
+            function_name_args = function_name.split(':')
+            function_name = function_name_args[1]
+            function_type = function_name_args[2]
+            if function_name == "ip":
+                set_pluto(ip=args[function_name].string_value.split(":")[1])
+            elif function_type == "GET":
+                return PlutoServer.get(function_name=function_name, token=unmap_arg(args['a']))
+            elif function_type == "SET":
+                PlutoServer.set(function_name=function_name, value=args[function_name], token=unmap_arg(args['a']))
+                
+            elif function_type in ("CALL0", "CALL1"):
+                return PlutoServer.call_func(
+                    function_name=function_name,
+                    function_type=function_type,
+                    args=args,
+                    token=unmap_arg(args['a'])
+                )
+            else:
+                raise ValueError(f"Unknown function_type: {function_type}. Is that a function you can call?")
+        except Exception as e:
+            return {function_name:map_arg('None'), "Error":map_arg(f'{e}')}
+        
+    @staticmethod
+    def call_func(*, function_name, function_type, args, token):
+        device = device_pluto(api_token=token)
+        if device is None:
+            return {function_name: map_arg('None'), "UE": map_arg("API Token Invalid")}
+
+        method = getattr(device, function_name)
+        if not callable(method):
+            raise ValueError(f"Device attribute '{function_name}' is not callable.")
+
+        # if PlutoServer.DEBUG:
+        
+        # print(f"[DEBUG] call_func: calling {function_name} on {device} with type={function_type}")
+        
+        # print(f"raw values: {args['arg1']}")
+        
+        if function_type == "CALL0":
+            # Zero-argument function call
+            result = method()
+        elif function_type == "CALL1":
+            # Single-argument function call
+            if 'arg1' not in args:
+                raise ValueError("Client Package: CALL1 type requires 'arg1' in args.")
+            python_arg = unmap_arg(args['arg1'])
+            # if PlutoServer.DEBUG:
+            #     print(f"[DEBUG] call_func: unmap_arg(args['arg1']) => {python_arg}")
+            # print(f"Pluto.{method} \n unmapped arg: {python_arg}")
+            # print(f"unmapped values: {python_arg}")
+            # print(f"{function_name} is called on {device}")
+            result = method(python_arg)
+        else:
+            raise ValueError(f"Unsupported call type: {function_type} (arg length not supported)")
+
+        # If the function returns something, map it back
+        if result is not None:
+            return {function_name: map_arg(result)}
+        else:
+            # If there's no return value, return some placeholder
+            return {function_name: map_arg('None')}
+            
+    @staticmethod
+    def get(*, function_name, token):
+        try:
+            device = device_pluto(api_token=token)
+            if device == None:
+                return {function_name:map_arg('None'), "UE":map_arg("API Token Invalid")}
+            if not hasattr(device, function_name):
+                return {function_name:map_arg('None'), "UE":map_arg(f'{function_name} is not a gettable value.')}
+            
+            attr = getattr(device, function_name)
+            if callable(attr):
+                return {function_name:map_arg(attr())}
+            else:
+                return {function_name:map_arg(attr)}
+        except Exception as e:
+            
+            # print(f"UE: Pluto_server ln:35: {e}")
+            return {function_name:map_arg('None'), "UE":map_arg(f'{e}')}
+    
+    @staticmethod
+    def set(*, function_name, value, token):
+        try:
+            device = device_pluto(api_token=token)
+            if device == None:
+                return {function_name:map_arg('None'), "UE":map_arg("API Token Invalid")}
+            if not hasattr(device, function_name):
+                return {function_name:map_arg('None'), "UE":map_arg(f'{function_name} is not a settable value.')}
+            
+            setattr(device, function_name, unmap_arg(value))
+            return {}
+        except Exception as e:
+            # print(f"UE: Pluto_server ln:44: {e}")
+            return {function_name:map_arg('None'), "UE":map_arg(f'{e}')}

remoteRF_server/host/host_auth_token.py

@@ -0,0 +1,292 @@
+# remoteRF_server/host/host_auth_token.py
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+import time
+import threading
+from pathlib import Path
+from typing import Dict, Tuple, List
+from datetime import datetime, timezone
+import hashlib
+
+from ..common.utils import *  
+
+_HOST_ID_RE = re.compile(r"^[A-Za-z0-9_.-]{1,64}$")
+
+def _validate_host_id(raw: str) -> str:
+    hid = (raw or "").strip()
+    if not hid:
+        raise ValueError("Missing host_id")
+    if hid == "unknown-host":
+        raise ValueError("host_id cannot be 'unknown-host'")
+    if not _HOST_ID_RE.fullmatch(hid):
+        raise ValueError("Invalid host_id (allowed: 1..64 chars of [A-Za-z0-9_.-])")
+    return hid
+
+def _hosts_auth_path() -> Path:
+    return get_db_dir() / "hosts_auth.env"
+
+def _utc_now_s() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+def _host_key(host_id: str) -> str:
+    return hashlib.sha256(host_id.encode("utf-8")).hexdigest()[:16]
+
+# Minimal env read/write
+
+def _read_env_kv(path: Path) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    if not path.exists():
+        return out
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, v = line.split("=", 1)
+        out[k.strip()] = v.strip().strip('"').strip("'")
+    return out
+
+def _write_env_kv(path: Path, kv: Dict[str, str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # deterministic output makes diffs/debugging easier
+    lines: List[str] = []
+    for k in sorted(kv.keys()):
+        v = str(kv[k])
+        if any(c.isspace() for c in v) or any(c in v for c in ['"', "'"]):
+            v = v.replace('"', '\\"')
+            lines.append(f'{k}="{v}"')
+        else:
+            lines.append(f"{k}={v}")
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+# Cached DB load (thread-safe)
+
+_DB_LOCK = threading.RLock()
+_DB_CACHE_MTIME: float = 0.0
+_DB_CACHE: Dict[str, str] = {}
+
+def _load_db_kv() -> Dict[str, str]:
+    global _DB_CACHE_MTIME, _DB_CACHE
+    p = _hosts_auth_path()
+
+    try:
+        st = p.stat()
+        mtime = float(st.st_mtime)
+    except FileNotFoundError:
+        with _DB_LOCK:
+            _DB_CACHE_MTIME = 0.0
+            _DB_CACHE = {}
+            return {}
+    except Exception:
+        # if stat fails oddly, fall back to best-effort read
+        mtime = -1.0
+
+    with _DB_LOCK:
+        if mtime > 0 and _DB_CACHE and _DB_CACHE_MTIME == mtime:
+            return dict(_DB_CACHE)
+
+        kv = _read_env_kv(p)
+        _DB_CACHE = dict(kv)
+        _DB_CACHE_MTIME = mtime if mtime > 0 else time.time()
+        return dict(kv)
+
+def _save_db_kv(kv: Dict[str, str]) -> None:
+    global _DB_CACHE_MTIME, _DB_CACHE
+    p = _hosts_auth_path()
+    _write_env_kv(p, kv)
+    # refresh cache immediately
+    try:
+        mtime = float(p.stat().st_mtime)
+    except Exception:
+        mtime = time.time()
+    with _DB_LOCK:
+        _DB_CACHE = dict(kv)
+        _DB_CACHE_MTIME = mtime
+
+# Public API
+
+def create_host_token(
+    host_id: str,
+    *,
+    length: int = 8,
+    status: str = "approved",
+    overwrite: bool = True,
+) -> str:
+    hid = _validate_host_id(host_id)
+    hk = _host_key(hid)
+
+    salt, hashed, token = generate_token(length=length)
+    now = _utc_now_s()
+
+    kv = _load_db_kv()
+
+    # If not overwriting and host exists, refuse
+    if not overwrite and kv.get(f"HOST_{hk}_ID", "").strip():
+        raise ValueError(f"Host token already exists for host_id={hid!r} (use --force to overwrite)")
+
+    kv[f"HOST_{hk}_ID"] = hid
+    kv[f"HOST_{hk}_SALT"] = salt
+    kv[f"HOST_{hk}_HASH"] = hashed
+    kv[f"HOST_{hk}_STATUS"] = (status or "approved").strip().lower()
+    kv[f"HOST_{hk}_UPDATED_UTC"] = now
+    if f"HOST_{hk}_CREATED_UTC" not in kv:
+        kv[f"HOST_{hk}_CREATED_UTC"] = now
+
+    _save_db_kv(kv)
+    return token
+
+def set_host_status(host_id: str, status: str) -> None:
+    hid = _validate_host_id(host_id)
+    hk = _host_key(hid)
+
+    kv = _load_db_kv()
+    if kv.get(f"HOST_{hk}_ID", "").strip() != hid:
+        raise ValueError(f"Unknown host_id={hid!r} (no record)")
+
+    kv[f"HOST_{hk}_STATUS"] = (status or "").strip().lower()
+    kv[f"HOST_{hk}_UPDATED_UTC"] = _utc_now_s()
+    _save_db_kv(kv)
+
+def is_host_token_valid(host_id: str, token: str, *, require_status: str = "approved") -> bool:
+    try:
+        hid = _validate_host_id(host_id)
+    except Exception:
+        return False
+
+    tok = (token or "").strip()
+    if not tok:
+        return False
+
+    hk = _host_key(hid)
+    kv = _load_db_kv()
+
+    rid = (kv.get(f"HOST_{hk}_ID", "") or "").strip()
+    if rid != hid:
+        return False
+
+    status = (kv.get(f"HOST_{hk}_STATUS", "") or "").strip().lower()
+    if require_status and status != require_status.strip().lower():
+        return False
+
+    salt = (kv.get(f"HOST_{hk}_SALT", "") or "").strip()
+    hashed = (kv.get(f"HOST_{hk}_HASH", "") or "").strip()
+    if not salt or not hashed:
+        return False
+
+    try:
+        return bool(validate_token(salt, hashed, tok))
+    except Exception:
+        return False
+
+def list_hosts() -> List[Tuple[str, str]]:
+    kv = _load_db_kv()
+    out: List[Tuple[str, str]] = []
+    # Scan by HOST_<hk>_ID keys
+    for k, v in kv.items():
+        if not k.startswith("HOST_") or not k.endswith("_ID"):
+            continue
+        hk = k[len("HOST_") : -len("_ID")]
+        hid = (v or "").strip()
+        st = (kv.get(f"HOST_{hk}_STATUS", "") or "").strip().lower()
+        if hid:
+            out.append((hid, st or ""))
+    out.sort(key=lambda t: t[0])
+    return out
+
+def _host_record_keys(hk: str) -> list[str]:
+    # all keys stored for this host_key
+    return [
+        f"HOST_{hk}_ID",
+        f"HOST_{hk}_SALT",
+        f"HOST_{hk}_HASH",
+        f"HOST_{hk}_STATUS",
+        f"HOST_{hk}_CREATED_UTC",
+        f"HOST_{hk}_UPDATED_UTC",
+    ]
+
+def list_host_token_records(*, include_secrets: bool = False) -> list[dict[str, str]]:
+    kv = _load_db_kv()
+    out: list[dict[str, str]] = []
+
+    # Find all host keys by scanning HOST_<hk>_ID
+    for k, v in kv.items():
+        if not k.startswith("HOST_") or not k.endswith("_ID"):
+            continue
+
+        hk = k[len("HOST_") : -len("_ID")]
+        host_id = (v or "").strip()
+        if not host_id:
+            continue
+
+        rec: dict[str, str] = {
+            "host_id": host_id,
+            "status": (kv.get(f"HOST_{hk}_STATUS", "") or "").strip().lower(),
+            "created_utc": (kv.get(f"HOST_{hk}_CREATED_UTC", "") or "").strip(),
+            "updated_utc": (kv.get(f"HOST_{hk}_UPDATED_UTC", "") or "").strip(),
+        }
+
+        if include_secrets:
+            rec["salt"] = (kv.get(f"HOST_{hk}_SALT", "") or "").strip()
+            rec["hash"] = (kv.get(f"HOST_{hk}_HASH", "") or "").strip()
+
+        out.append(rec)
+
+    out.sort(key=lambda r: r.get("host_id", ""))
+    return out
+
+def delete_host_token(host_id: str) -> bool:
+    hid = _validate_host_id(host_id)
+    hk = _host_key(hid)
+
+    kv = _load_db_kv()
+    rid = (kv.get(f"HOST_{hk}_ID", "") or "").strip()
+    if rid != hid:
+        return False
+
+    removed = False
+    for k in _host_record_keys(hk):
+        if k in kv:
+            kv.pop(k, None)
+            removed = True
+
+    if removed:
+        _save_db_kv(kv)
+    return removed
+
+def wipe_all_host_tokens() -> int:
+    kv = _load_db_kv()
+
+    # Count how many hosts are present
+    host_keys: list[str] = []
+    for k in kv.keys():
+        if k.startswith("HOST_") and k.endswith("_ID"):
+            hk = k[len("HOST_") : -len("_ID")]
+            host_keys.append(hk)
+
+    # Remove all per-host keys
+    for hk in host_keys:
+        for kk in _host_record_keys(hk):
+            kv.pop(kk, None)
+
+    _save_db_kv(kv)
+    return len(host_keys)
+
+def show_host_tokens(*, include_secrets: bool = False, file=sys.stdout) -> None:
+    recs = list_host_token_records(include_secrets=include_secrets)
+    if not recs:
+        print(f"No host tokens found ({_hosts_auth_path()}).", file=file)
+        return
+
+    print(f"Host tokens ({_hosts_auth_path()}):", file=file)
+    for r in recs:
+        host_id = r.get("host_id", "")
+        status = r.get("status", "")
+        created = r.get("created_utc", "")
+        updated = r.get("updated_utc", "")
+        print(f"  - {host_id}  status={status}  created={created}  updated={updated}", file=file)
+        if include_secrets:
+            print(f"      salt={r.get('salt','')}", file=file)
+            print(f"      hash={r.get('hash','')}", file=file)

remoteRF_server/host/host_directory_store.py

@@ -0,0 +1,142 @@
+# src/remoteRF_host/host/host_directory_store.py
+
+from __future__ import annotations
+
+import os
+import re
+import threading
+from pathlib import Path
+from typing import Dict, List, Optional
+
+_ENV_LINE = re.compile(r"^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$")
+
+def now_ms() -> int:
+    import time
+    return int(time.time() * 1000)
+
+def repo_root_from_file(file: str) -> Path:
+    p = Path(file).resolve()
+    for parent in p.parents:
+        if parent.name == "src":
+            return parent.parent
+    return p.parents[3]
+
+def cfg_dir_from_file(file: str) -> Path:
+    return repo_root_from_file(file) / ".config"
+
+def sanitize_env_key(s: str) -> str:
+    s = (s or "").strip().upper()
+    s = re.sub(r"[^A-Z0-9_]", "_", s)
+    s = re.sub(r"_+", "_", s)
+    return s[:120]
+
+def strip_quotes(v: str) -> str:
+    v = (v or "").strip()
+    if len(v) >= 2 and ((v[0] == v[-1] == '"') or (v[0] == v[-1] == "'")):
+        return v[1:-1]
+    return v
+
+def csv_split(v: str) -> List[str]:
+    return [x.strip() for x in (v or "").split(",") if x.strip()]
+
+class DeviceIdConflictError(RuntimeError):
+    def __init__(self, *, device_id: str, existing_host: str, new_host: str) -> None:
+        super().__init__(
+            f"device_id '{device_id}' already owned by host '{existing_host}', rejecting host '{new_host}'"
+        )
+        self.device_id = device_id
+        self.existing_host = existing_host
+        self.new_host = new_host
+
+class EnvStore:
+    def __init__(self, path: Path) -> None:
+        self.path = Path(path)
+        self._lock = threading.Lock()
+
+    def _read_lines(self) -> List[str]:
+        if not self.path.exists():
+            return []
+        return self.path.read_text(encoding="utf-8").splitlines()
+
+    def _write_lines(self, lines: List[str]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")
+
+    def read_kv(self) -> Dict[str, str]:
+        out: Dict[str, str] = {}
+        for raw in self._read_lines():
+            line = raw.strip()
+            if not line or line.startswith("#"):
+                continue
+            m = _ENV_LINE.match(line)
+            if not m:
+                continue
+            k = m.group(1).strip()
+            v = strip_quotes(m.group(2))
+            out[k] = v
+        return out
+
+    def append_to_csv_list(self, key: str, value: str) -> None:
+        key = sanitize_env_key(key)
+        value = (value or "").strip()
+        if not value:
+            return
+
+        with self._lock:
+            lines = self._read_lines()
+            idx: Optional[int] = None
+            cur = ""
+
+            for i, ln in enumerate(lines):
+                if ln.startswith(key + "="):
+                    idx = i
+                    cur = ln[len(key) + 1:].strip()
+                    break
+
+            existing = csv_split(cur)
+            if value in existing:
+                return
+
+            existing.append(value)
+            new_line = f"{key}=" + ",".join(existing)
+
+            if idx is None:
+                lines.append(new_line)
+            else:
+                lines[idx] = new_line
+
+            self._write_lines(lines)
+
+    def upsert_kv(self, key: str, value: str) -> None:
+        key = sanitize_env_key(key)
+        value = (value or "").strip()
+
+        with self._lock:
+            lines = self._read_lines()
+            idx: Optional[int] = None
+            for i, ln in enumerate(lines):
+                if ln.startswith(key + "="):
+                    idx = i
+                    break
+
+            new_line = f"{key}={value}"
+            if idx is None:
+                lines.append(new_line)
+            else:
+                lines[idx] = new_line
+
+            self._write_lines(lines)
+
+    def set_kv_if_absent(self, key: str, value: str) -> None:
+        key = sanitize_env_key(key)
+        value = (value or "").strip()
+        if not value:
+            return
+
+        with self._lock:
+            lines = self._read_lines()
+            for ln in lines:
+                if ln.startswith(key + "="):
+                    return
+            lines.append(f"{key}={value}")
+            self._write_lines(lines)