Skip to content

armgit / ODS

Public Imported from GitHub
0

ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.

12.8 KB
Raw Blame
"""Actual temporary files, simulated root/admission; not installed acceptance."""
import sys
if sys.platform == "win32":
    from unittest import SkipTest
    raise SkipTest("Requires POSIX host ownership, file locks, or Unix sockets; run under Linux/WSL")

import copy
import hashlib
import json
import os
import plistlib
import sys
from pathlib import Path
from types import SimpleNamespace

import pytest

sys.path.insert(0, str(Path(__file__).resolve().parents[2] / 'bin'))
from pixel_access_bridge import AccessError, atomic_json
from pixel_gateway_service import LaunchdGatewayService, SystemdGatewayService
from pixel_provider import service_environment as env
from pixel_provider.managed_deployment import deployment, required_policy

BINDING = {'schemaVersion': 1, 'activationId': '123e4567-e89b-12d3-a456-426614174000',
           'revision': 1, 'allowCloud': False}


class Bridge:
    def __init__(self, root):
        self.gateway_service = SystemdGatewayService(
            lambda *args, **kwargs: self.command(*args, **kwargs), AccessError, 'openclaw-gateway.service')
        self.gateway_service.boot_identity = lambda: '11111111-2222-3333-4444-555555555555'
        self.state, self.home = root / 'state', root / 'home'
        self.state.mkdir(mode=0o700)
        (self.home / '.openclaw').mkdir(parents=True, mode=0o700)
        self.owner = SimpleNamespace(pw_uid=os.getuid())
        self.phase, self.active, self.streams = 'held', 0, 0
        self.token = 'b' * 64
        self.record = {'kind': 'provider', 'phase': 'invoking', 'token': self.token,
                       'transactionId': 'a' * 64, 'edge_revision': 'c' * 64}
        atomic_json(self.state / 'transition.json', self.record)
        self.config = self.home / '.openclaw/openclaw.json'
        self.before = b'{"route":"before"}\n'
        self.after = b'{"route":"after"}\n'
        self.config.write_bytes(self.before)
        self.config.chmod(0o600)

    def pending(self):
        return json.loads((self.state / 'transition.json').read_text())

    def native(self, operation=None, token=None, **kwargs):
        if operation and token != self.token:
            raise AccessError('native-lease-unconfirmed')
        return {'phase': self.phase, 'active': self.active}

    def edge(self, operation=None, token=None, revision=None):
        if operation and token != self.token:
            raise AccessError('edge-lease-unconfirmed')
        return {'phase': self.phase, 'streams': self.streams}


@pytest.fixture
def participant(tmp_path, monkeypatch):
    # Explicit custody simulation: tests run as a non-root CI owner in /tmp.
    # All file type, mode, nlink, inode and durability code remains real.
    monkeypatch.setattr(env, 'ROOT_UID', os.getuid())
    original = env._parents
    def parents(path):
        if path.resolve() != path:
            raise AccessError('unsafe-provider-service-path')
        for entry in path.parents:
            if entry == tmp_path.parent:
                break
            info = entry.lstat()
            if not entry.is_dir() or info.st_uid != os.getuid() or info.st_mode & 0o022:
                raise AccessError('unsafe-provider-service-directory')
    monkeypatch.setattr(env, '_parents', parents)
    bridge = Bridge(tmp_path)
    directory = tmp_path / 'service'
    directory.mkdir(mode=0o700)
    value = env.ServiceEnvironment(bridge, environment=directory / 'provider.env', dropin=directory / '95-provider.conf')
    value.original_parents = original
    return value


def arm(value, **overrides):
    b = value.bridge
    options = {'before_sha': hashlib.sha256(b.before).hexdigest(), 'after_sha': hashlib.sha256(b.after).hexdigest(),
               'before_binding': None, 'after_binding': copy.deepcopy(BINDING),
               'deployment_document': deployment(BINDING, '/opt/ods/source', '/usr/bin/python3',
                                                  str(b.home / 'providers'), True),
               'policy': required_policy()}
    options.update(overrides)
    return value.prepare(b.record, **options)


def test_forward_then_same_callback_rollback_restores_absence(participant):
    p, b = participant, participant.bridge
    record = arm(p)
    assert bytes.fromhex(record['after']['dropin']['hex']) == ('[Service]\nEnvironmentFile=' + str(p.environment)
        + '\nBindPaths=' + str(b.home / 'providers') + '\n').encode()
    assert p.snapshot() == {'environment': None, 'dropin': None}
    b.config.write_bytes(b.after)
    selected = p.apply(b.record)
    assert selected['binding'] == BINDING and selected['side'] == 'after'
    assert p.snapshot() == record['after']
    assert p.verify(b.record, selected) == record['after']
    b.config.write_bytes(b.before)
    restored = p.apply(b.record)
    assert restored['binding'] is None and restored['side'] == 'before'
    assert p.verify(b.record, restored) == record['before']
    assert not p.environment.exists() and not p.dropin.exists()
    assert b.pending() == b.record and b.phase == 'held'


def test_launchd_environment_rewrites_only_managed_env_i_arguments(participant):
    _systemd, b = participant, participant.bridge
    plist = b.home / 'service' / 'gateway.plist'
    plist.parent.mkdir()
    original = {
        'Label': 'com.ods.fixture',
        'ProgramArguments': ['/usr/bin/env', '-i', 'HOME=/private/fixture',
                             'PATH=/usr/bin:/bin', '/usr/bin/node', '/opt/openclaw.mjs',
                             'gateway', 'run', '--port', '18789'],
        'WorkingDirectory': '/private/fixture', 'RunAtLoad': True,
    }
    plist.write_bytes(plistlib.dumps(original, sort_keys=True))
    plist.chmod(0o644)
    b.gateway_service = LaunchdGatewayService(lambda *args, **kwargs: '', AccessError,
        'system/com.ods.fixture', lambda: None, plist=plist)
    value = env.LaunchdServiceEnvironment(b, snapshotter=env._snapshot)
    options = {'before_sha': hashlib.sha256(b.before).hexdigest(),
               'after_sha': hashlib.sha256(b.after).hexdigest(),
               'before_binding': None, 'after_binding': copy.deepcopy(BINDING),
               'deployment_document': deployment(BINDING, '/opt/ods/source', '/usr/bin/python3',
                                                  str(b.home / 'providers'), True),
               'policy': required_policy(), 'expected': value.baseline()}
    record = value.prepare(b.record, **options)
    b.config.write_bytes(b.after)
    selected = value.apply(b.record)
    assert selected['side'] == 'after'
    changed = plistlib.loads(plist.read_bytes())
    arguments = changed['ProgramArguments']
    assert arguments[:4] == ['/usr/bin/env', '-i', 'HOME=/private/fixture', 'PATH=/usr/bin:/bin']
    assert sum(item.startswith('OPENCLAW_REQUIRED_PLUGINS=') for item in arguments) == 1
    assert sum(item.startswith('PIXEL_ODS_PROVIDER_DEPLOYMENT=') for item in arguments) == 1
    command_index = arguments.index('/usr/bin/node')
    assert arguments[command_index:] == original['ProgramArguments'][4:]
    b.config.write_bytes(b.before)
    assert value.apply(b.record)['side'] == 'before'
    assert plist.read_bytes() == bytes.fromhex(record['before']['environment']['hex'])


@pytest.mark.parametrize('directory,error', [
    ('/home/ods/with space', AccessError),
    ('/home/ods/%h', AccessError),
    ('/home/ods/a:b', AccessError),
    ('/home/ods/../elsewhere', ValueError),
])
def test_provider_mount_cannot_expand_unit_syntax_or_escape_selected_path(participant, directory, error):
    doc = deployment(BINDING, '/opt/ods/source', '/usr/bin/python3', '/home/ods/providers', True)
    doc['providerDirectory'] = directory
    with pytest.raises(error): arm(participant, deployment_document=doc)
    assert participant.snapshot() == {'environment': None, 'dropin': None}


def test_second_prepare_cannot_overwrite_recovery_images(participant):
    arm(participant)
    original = (participant.bridge.state / env.RECORD).read_bytes()
    with pytest.raises(AccessError, match='already-prepared'):
        arm(participant)
    assert (participant.bridge.state / env.RECORD).read_bytes() == original


@pytest.mark.parametrize('failure', ['config', 'busy', 'streams', 'idle', 'journal'])
def test_refuse_before_any_service_write(participant, failure):
    p, b = participant, participant.bridge
    arm(p)
    b.config.write_bytes(b.after)
    if failure == 'config': b.config.write_bytes(b'{"other":1}\n')
    if failure == 'busy': b.active = 1
    if failure == 'streams': b.streams = 1
    if failure == 'idle': b.phase = 'idle'
    if failure == 'journal': atomic_json(b.state / 'transition.json', dict(b.record, transactionId='d' * 64))
    with pytest.raises(AccessError): p.apply(b.record)
    assert not p.environment.exists() and not p.dropin.exists()


def test_partial_write_crash_is_recoverable_without_adopting_state(participant, monkeypatch):
    p, b = participant, participant.bridge
    record = arm(p)
    b.config.write_bytes(b.after)
    replace = env._replace
    def fail_dropin(path, expected, image):
        if path == p.dropin: raise OSError('injected disk failure')
        replace(path, expected, image)
    monkeypatch.setattr(env, '_replace', fail_dropin)
    with pytest.raises(OSError): p.apply(b.record)
    assert p.snapshot() == {'environment': record['after']['environment'], 'dropin': None}
    monkeypatch.setattr(env, '_replace', replace)
    b.config.write_bytes(b.before)
    assert p.apply(b.record)['side'] == 'before'
    assert p.snapshot() == record['before']


def test_foreign_file_is_not_overwritten_during_recovery(participant):
    p, b = participant, participant.bridge
    arm(p)
    b.config.write_bytes(b.after)
    p.apply(b.record)
    p.environment.write_bytes(b'FOREIGN=not-ours\n')
    b.config.write_bytes(b.before)
    with pytest.raises(AccessError, match='recovery-conflict'): p.apply(b.record)
    assert p.environment.read_bytes() == b'FOREIGN=not-ours\n' and p.dropin.exists()


@pytest.mark.parametrize('kind', ['symlink', 'hardlink', 'writable', 'directory', 'parent'])
def test_unsafe_service_files_refused(participant, tmp_path, kind):
    p, b = participant, participant.bridge
    arm(p)
    b.config.write_bytes(b.after)
    target = tmp_path / 'unrelated'
    target.write_bytes(b'preserve')
    target.chmod(0o600)
    if kind == 'symlink': p.environment.symlink_to(target)
    if kind == 'hardlink': os.link(target, p.environment)
    if kind == 'writable':
        p.environment.write_bytes(b'x')
        p.environment.chmod(0o666)
    if kind == 'directory': p.environment.mkdir()
    if kind == 'parent': p.environment.parent.chmod(0o777)
    with pytest.raises(AccessError): p.apply(b.record)
    assert target.read_bytes() == b'preserve' and not p.dropin.exists()


def test_config_change_during_admission_prevents_file_write(participant, monkeypatch):
    p, b = participant, participant.bridge
    arm(p)
    b.config.write_bytes(b.after)
    edge = b.edge
    def raced(*args):
        b.config.write_bytes(b.before)
        return edge(*args)
    monkeypatch.setattr(b, 'edge', raced)
    with pytest.raises(AccessError, match='config-changed'): p.apply(b.record)
    assert not p.environment.exists() and not p.dropin.exists()


def test_update_requires_exact_root_previous_image_and_deactivation_restores_it(participant):
    p, b = participant, participant.bridge
    original = arm(p)
    b.config.write_bytes(b.after)
    p.apply(b.record)
    baseline = original['before']
    b.record = dict(b.record, transactionId='d' * 64)
    b.record.pop('serviceEnvironment')
    atomic_json(b.state / 'transition.json', b.record)
    b.before, b.after = b.after, b.before
    arm(p, before_binding=BINDING, after_binding=None, deployment_document=None, policy=None,
        restore=baseline, expected=original['after'])
    b.config.write_bytes(b.after)
    assert p.apply(b.record)['binding'] is None
    assert p.snapshot() == baseline


def test_changed_root_record_fails_digest_binding(participant):
    p, b = participant, participant.bridge
    record = arm(p)
    record['afterSha'] = 'e' * 64
    atomic_json(b.state / env.RECORD, record)
    with pytest.raises(AccessError, match='invalid-provider-service-record'): p.load(b.record)


def test_verify_refuses_post_apply_file_drift(participant):
    p, b = participant, participant.bridge
    arm(p)
    b.config.write_bytes(b.after)
    selection = p.apply(b.record)
    p.dropin.unlink()
    with pytest.raises(AccessError, match='verification-changed'): p.verify(b.record, selection)


def test_initial_adoption_refuses_existing_environment(participant):
    participant.environment.write_bytes(b'EXISTING=yes\n')
    participant.environment.chmod(0o600)
    with pytest.raises(AccessError, match='baseline-conflict'): arm(participant)
    assert participant.environment.read_bytes() == b'EXISTING=yes\n'


def test_equal_config_hashes_are_ambiguous(participant):
    with pytest.raises(AccessError, match='ambiguous-provider-config-hash'):
        arm(participant, after_sha=hashlib.sha256(participant.bridge.before).hexdigest())