qemu-compose 0.1.0__tar.gz

qemu_compose-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+**/__pycache__
+**/*.pyc

qemu_compose-0.1.0/LICENSE.txt

@@ -0,0 +1,37 @@
+The Star And Thank Author License (SATA)
+
+Copyright (c) 2025 zTrix(i@ztrix.me)
+
+Project Url: https://github.com/zTrix/qemu-compose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software. 
+
+And wait, the most important, you shall star/+1/like the project(s) in project url 
+section above first, and then thank the author(s) in Copyright section. 
+
+Here are some suggested ways:
+
+ - Email the authors a thank-you letter, and make friends with him/her/them.
+ - Report bugs or issues.
+ - Tell friends what a wonderful project this is.
+ - And, sure, you can just express thanks in your mind without telling the world.
+
+Contributors of this project by forking have the option to add his/her name and 
+forked project url at copyright and project url sections, but shall not delete 
+or modify anything else in these two sections.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

qemu_compose-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: qemu-compose
+Version: 0.1.0
+Summary: docker-compose style composer for qemu
+License-File: LICENSE.txt
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0.2
+Description-Content-Type: text/markdown
+
+
+# qemu-compose
+
+qemu-compose aims to provide a docker-compose style composer for qemu command, with advanced scripting feature as well as http support for cloud init or general purpose provisioning.
+
+bring up a qemu VM by providing a qemu-compose.yml and run `qemu-compose up`
+
+## Advantages
+
+ - Simple and robust
+ - No libvirt stuff, no complex
+ - support `before_script` and `after_script` for setup and cleanup
+ - support `boot_commands` for vm provisioning (implemented using jsonlisp for expressive power which apparently is turing-complete)
+ - support `http_serve` for cloudinit
+ - env interpolation for advanced configuration
+
+## Examples and Screenshot
+
+bring up ubuntu cloudimg qemu vm and run a interactive shell
+
+
+```
+$ cd ./script/ubuntu-cloudimg__amd64/
+$ qemu-compose up
+```
+
+![svg](https://raw.githubusercontent.com/zTrix/qemu-compose/refs/heads/main/assets/ubuntu-cloudimg.svg)

qemu_compose-0.1.0/README.md

@@ -0,0 +1,27 @@
+
+# qemu-compose
+
+qemu-compose aims to provide a docker-compose style composer for qemu command, with advanced scripting feature as well as http support for cloud init or general purpose provisioning.
+
+bring up a qemu VM by providing a qemu-compose.yml and run `qemu-compose up`
+
+## Advantages
+
+ - Simple and robust
+ - No libvirt stuff, no complex
+ - support `before_script` and `after_script` for setup and cleanup
+ - support `boot_commands` for vm provisioning (implemented using jsonlisp for expressive power which apparently is turing-complete)
+ - support `http_serve` for cloudinit
+ - env interpolation for advanced configuration
+
+## Examples and Screenshot
+
+bring up ubuntu cloudimg qemu vm and run a interactive shell
+
+
+```
+$ cd ./script/ubuntu-cloudimg__amd64/
+$ qemu-compose up
+```
+
+![svg](https://raw.githubusercontent.com/zTrix/qemu-compose/refs/heads/main/assets/ubuntu-cloudimg.svg)

qemu_compose-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "qemu-compose"
+version = "0.1.0"
+readme = "README.md"
+description = "docker-compose style composer for qemu"
+requires-python = ">=3.11"
+dependencies = [
+    "pyyaml>=6.0.2",
+]
+
+[project.scripts]
+qemu-compose = "qemu_compose.main:cli"
+
+[tool.uv]
+environments = [
+    "sys_platform == 'darwin'",
+    "sys_platform == 'linux'",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["qemu_compose/"]
+exclude = [
+  "*.rst",
+]
+
+[tool.hatch.build.targets.sdist]
+packages = ["qemu_compose/"]
+exclude = [
+  "*.rst",
+]

qemu_compose-0.1.0/qemu_compose/jsonlisp.py

@@ -0,0 +1,254 @@
+
+# NOTE: the following code comes from https://github.com/Leden/jsonlisp with small modification for this project
+# but I have no idea why the original repo is 404 now, so I just leave a comment here to express thanks to Leden
+
+import json
+import logging
+import operator
+from collections import ChainMap
+import ast
+
+logger = logging.getLogger(__name__)
+
+Symbol = str
+List = list
+Number = (int, float)
+Dict = dict
+
+
+class Env(ChainMap):
+    def __json__(self):
+        return self.maps
+
+
+class Proc:
+    def __init__(self, params, body, env):
+        self.params = params
+        self.body = body
+        self.env = env
+
+    def __call__(self, *args):
+        env = Env(dict(zip(self.params, args)), self.env)
+        return interp(self.body, env)
+
+    def __json__(self):
+        return ["lambda", self.params, self.body]
+
+
+class Macro:
+    def __init__(self, params, body, env):
+        self.params = params
+        self.body = body
+        self.env = env
+
+    def expand(self, *args, env):
+        static_env = Env(dict(zip(self.params, args)), self.env)
+        exp = interp(self.body, static_env)
+        return interp(exp, env)
+
+    def __json__(self):
+        return ["macro", self.params, self.body]
+
+
+builtins = {
+    # Operators
+    "*": operator.mul,
+    "+": operator.add,
+    "-": operator.sub,
+    "/": operator.truediv,
+    "<": operator.lt,
+    "<=": operator.le,
+    "=": operator.eq,
+    ">": operator.gt,
+    ">=": operator.ge,
+    "^": operator.xor,
+    "and": operator.and_,
+    "contains": operator.contains,
+    "in": lambda x, y: x in y,
+    "is": operator.is_,
+    "is-not": operator.is_not,
+    "not": operator.not_,
+    "or": operator.or_,
+    "xor": lambda x, y: bool(x) ^ bool(y),  # logical XOR
+    # Typechecks
+    "dict?": lambda x: isinstance(x, Dict),
+    "list?": lambda x: isinstance(x, List),
+    "macro?": lambda x: isinstance(x, Macro),
+    "null?": lambda x: x is None,
+    "number?": lambda x: isinstance(x, Number),
+    "proc?": callable,
+    "symbol?": lambda x: isinstance(x, Symbol),
+    # List functions
+    "begin": lambda *x: x[-1],
+    "cons": lambda x, y: [x, *y],
+    "head": lambda x: x[0],
+    "len": len,
+    "list": lambda *x: list(x),
+    "map": lambda *args: list(map(*args)),
+    "range": lambda *x: list(range(*x)),
+    "tail": lambda x: x[1:],
+    # Dict functions
+    "dict": lambda x: dict(x),
+    "dict-del": lambda d, k: {_k: d[_k] for _k in d if k != _k},
+    "dict-get": lambda d, k: d.get(k),
+    "dict-items": lambda x: list(x.items()),
+    "dict-set": lambda d, k, v: {**d, k: v},
+    # Misc functions
+    "apply": lambda proc, args: proc(*args),
+    "print": print,
+    "literal": ast.literal_eval,
+    "str": str,
+    "format": lambda x, *args: x % tuple(args),
+}
+
+
+std_lib = [
+    "list",
+    [
+        "def",
+        "defmacro",
+        [
+            "macro",
+            ["name", "params", "body"],
+            [
+                "list",
+                ["quote", "def"],
+                "name",
+                ["list", ["quote", "macro"], "params", "body"],
+            ],
+        ],
+    ],
+    [
+        "defmacro",
+        "defproc",
+        ["name", "params", "body"],
+        [
+            "list",
+            ["quote", "def"],
+            "name",
+            ["list", ["quote", "lambda"], "params", "body"],
+        ],
+    ],
+]
+
+
+def default_env():
+    env = Env()
+    env.update(builtins)
+    env['key_up'] = "\x1b[A"
+    env['key_down'] = "\x1b[B"
+    env['key_right'] = "\x1b[C"
+    env['key_left'] = "\x1b[D"
+    env['key_home'] = "\x1b[H"
+    env['key_end'] = "\x1b[F"
+    env['key_ctrl_space'] = '\x00'
+    env['key_escape'] = '\x1b'
+    env['key_tab'] = '\t'
+    env['key_enter'] = '\n'
+    env['key_backspace'] = '\x7f'
+    interp(std_lib, env)
+    return env
+
+
+def parse(line):
+    return json.loads(line)
+
+
+def parse_file(path):
+    return json.load(path)
+
+
+def unparse(expr):
+    return json.dumps(expr, default=to_json)
+
+
+def to_json(obj):
+    if hasattr(obj, "__json__"):
+        return obj.__json__()
+    return repr(obj)
+
+
+def interp(x, env):
+    # a shortcut syntax for human readability
+    if isinstance(x, Dict) and len(x) == 1:
+        for k in x:
+            v = x[k]
+            if isinstance(v, List) or isinstance(v, Dict):
+                v = interp(v, env)
+
+            if not isinstance(v, List):
+                v = [v]
+
+            f = env[k]
+            logger.info('CALL_STEP: %s %s' % (f.__name__, v))
+            return f(*v)
+
+    if isinstance(x, Symbol):
+        if x.startswith('key_') and len(x) == 5:
+            return x[4]
+        return env[x]
+
+    if not isinstance(x, List):
+        return x
+
+    if x == []:
+        return x
+
+    if x[0] == "quote" or x[0] == "'":
+        _, exp = x
+        return exp
+
+    if x[0] == "flat_quote" or x[0] == "_'":
+        _, *exp = x
+        return exp
+
+    if x[0] == "if":
+        _, test, conseq, alt = x
+        exp = conseq if interp(test, env) else alt
+        return interp(exp, env)
+
+    if x[0] == "def":
+        _, var, exp = x
+        val = env[var] = interp(exp, env)
+        return val
+
+    if x[0] == "lambda":
+        _, params, body = x
+        return Proc(params, body, env)
+
+    if x[0] == "macro":
+        _, params, body = x
+        return Macro(params, body, env)
+
+    proc_or_macro_exp, *args = x
+    proc = interp(proc_or_macro_exp, env)
+    if isinstance(proc, Macro):
+        return proc.expand(*args, env=env)
+    else:
+        args = [interp(exp, env) for exp in args]
+        if callable(proc):
+            if proc_or_macro_exp != "begin":
+                logger.info('CALL_STEP: %s(%s) %s' % (proc.__name__, proc_or_macro_exp, args))
+        else:
+            logger.error('CALL_STEP:ERROR: function not callable: %s(%s) %s' % (proc, proc_or_macro_exp, args))
+        return proc(*args)
+
+def repl(prompt=r"{λ}> "):
+    env = default_env()
+
+    while True:
+        try:
+            line = input(prompt)
+            print(unparse(interp(parse(line), env)))
+        except EOFError:
+            print("Bye")
+            break
+        except Exception as err:
+            print(repr(err))
+
+
+def run_file(path):
+    env = default_env()
+
+    with open(path) as f:
+        print(unparse(interp(parse_file(f), env)))

qemu_compose-0.1.0/qemu_compose/log_tool.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+
+import ast
+import sys
+import socket
+from zio import zio
+
+def parse(log_path:str):
+    buf = [bytearray(), bytearray()]
+    ret = []
+
+    for line in open(log_path):
+        if 'IO.recv(' in line:
+            if buf[1]:
+                ret.append((1, bytes(buf[1])))
+                buf[1] = bytearray()
+            i = line.index(' -> ')
+            content = line[i+4:-1].strip()
+            assert (content.startswith('b"') and content.endswith('"')) or (content.startswith("b'") and content.endswith("'"))
+            buf[0].extend(ast.literal_eval(content))
+        elif 'IO.send(' in line:
+            if buf[0]:
+                ret.append((0, bytes(buf[0])))
+                buf[0] = bytearray()
+            i = line.index(' -> ')
+            content = line[i+4:-1].strip()
+            assert (content.startswith('b"') and content.endswith('"')) or (content.startswith("b'") and content.endswith("'"))
+            buf[1].extend(ast.literal_eval(content))
+        else:
+            continue
+
+    if buf[0]:
+        ret.append((0, bytes(buf[0])))
+    if buf[1]:
+        ret.append((1, bytes(buf[1])))
+    return ret
+
+def serve(logs, addr=None):
+    server = socket.socket()
+    if addr is None:
+        addr = ('0.0.0.0', 1111)
+    server.bind(addr)
+    server.listen(1)
+    s, _ = server.accept()
+    io = zio(s, print_read=False, print_write=False, timeout=3600)
+    for d, c in logs:
+        if d == 1:
+            print('EXPECT', c)
+            io.read_until(c)
+        else:
+            print('SEND', c)
+            io.write(c)
+    io.close()
+
+def main(name, log_path):
+    logs = parse(log_path)
+    if name == 'parse':
+        for direction, content in logs:
+            print('<<<<----' if direction else '---->>>>', content)
+    elif name == 'serve':
+        serve(logs)
+
+if __name__ == '__main__':
+    main(sys.argv[1], sys.argv[2])