Composed component from `wac plug` throws `NotImplementedError`

[peter-facko]

Hello,

I am experimenting with WASM components. I have two packages, A and B.

package example:a;

interface %type {
    record blob {
        x: f64,
    }
}

interface %interface {
    use %type.{blob};

    f-a: func(x: f64) -> blob;
}

world %world {
    export %type;
    export %interface;
}

from a.interface.wit_world.exports import Interface as Base
from a.interface.wit_world.exports.type import Blob

class Interface(Base):
    def f_a(self, x: float):
        return Blob(x=x * 5)

package example:b;

interface %interface {
    use example:a/%type.{blob};

    f-b: func(x: f64) -> blob;
}

world %world {
    import example:a/%interface;

    export %interface;
}

from b.interface.wit_world.exports import Interface as Base
from b.interface.wit_world.imports.interface import f_a

class Interface(Base):
    def f_b(self, x: float):
        return f_a(f_a(x).x)

If I do componentize-py componentize on A, I can run this on the output successfully

wasmtime run --invoke 'f-a(3)' a.wasm

However, when i do

wac plug --plug a.wasm b.wasm --output composed.wasm

wasmtime run --invoke 'f-b(3)' composed.wasm

gives me

Traceback (most recent call last):
  File "/1/b/implementation/__init__.py", line 11, in f_b1
  File "/1/b/interface/wit_world/imports/interface.py", line 15, in f_a
NotImplementedError

thread '<unnamed>' (1) panicked at runtime/src/lib.rs:1290:25:
Python function threw an unexpected exception
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Error: failed to run main module `composed.wasm`

Caused by:
    0: error while executing at wasm backtrace:
           0: 0x4b05657 - libc.so!abort
           1: 0x2695395 - <unknown>!<wasm function 307>
           2: 0x31fbc00 - libcomponentize_py_runtime_sync.so!std::sys::pal::wasip1::helpers::abort_internal
           3: 0x31fdce0 - libcomponentize_py_runtime_sync.so!std::process::abort
           4: 0x31eeaf7 - libcomponentize_py_runtime_sync.so!__rustc::__rust_abort
           5: 0x318476f - libcomponentize_py_runtime_sync.so!__rustc::__rust_start_panic
           6: 0x31ff807 - libcomponentize_py_runtime_sync.so!__rustc::rust_panic
           7: 0x3200983 - libcomponentize_py_runtime_sync.so!std::panicking::panic_with_hook
           8: 0x32038fc - libcomponentize_py_runtime_sync.so!std::panicking::panic_handler::{closure#0}
           9: 0x320388f - libcomponentize_py_runtime_sync.so!std::sys::backtrace::__rust_end_short_backtrace::<std::panicking::panic_handler::{closure#0}, !>
          10: 0x31ff8de - libcomponentize_py_runtime_sync.so!__rustc::rust_begin_unwind
          11: 0x32453ff - libcomponentize_py_runtime_sync.so!core::panicking::panic_fmt
          12: 0x31748f7 - libcomponentize_py_runtime_sync.so!wit_dylib_export_call
          13: 0x4cd1934 - <unknown>!example:b/%interface#f-b
       note: using the `WASMTIME_BACKTRACE_DETAILS=1` environment variable may show more debugging information
    1: wasm trap: wasm `unreachable` instruction executed

Why doesn't the implementation of f-a end up in the composed component?

[dicej]

Thanks for reporting this.

I wasn't sure what specific commands you were using to build the components, so I guessed and made some tweaks to the Python code you provided since it wouldn't run otherwise:

mkdir foo
cd foo
python3 -m venv .venv
source .venv/bin/activate
pip install componentize-py==0.19.3
mkdir -p wit/deps/a
cat >wit/deps/a/a.wit <<EOF
package example:a;

interface %type {
    record blob {
        x: f64,
    }
}

interface %interface {
    use %type.{blob};

    f-a: func(x: f64) -> blob;
}

world %world {
    export %type;
    export %interface;
}
EOF
cat >wit/b.wit <<EOF
package example:b;

interface %interface {
    use example:a/%type.{blob};

    f-b: func(x: f64) -> blob;
}

world %world {
    import example:a/%interface;

    export %interface;
}
EOF
cat >a.py <<EOF
from wit_world.exports import Interface as Base
from wit_world.exports.type import Blob

class Interface(Base):
    def f_a(self, x: float):
        return Blob(x=x * 5)
EOF
cat >b.py <<EOF
from wit_world.exports import Interface as Base
from wit_world.imports.interface import f_a

class Interface(Base):
    def f_b(self, x: float):
        return f_a(f_a(x).x)
EOF
componentize-py -d wit -w 'example:a/%world' componentize a -o a.wasm
componentize-py -d wit -w 'example:b/%world' componentize b -o b.wasm
wac plug --plug a.wasm b.wasm -o composed.wasm
wasmtime run --invoke 'f-b(3)' composed.wasm

When I run that, I get {x: 75}, which appears correct. Can you compare that with the commands you used?