This is an automated email from the ASF dual-hosted git repository. songxiaosheng pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/dubbo-spi-extensions.git
The following commit(s) were added to refs/heads/master by this push: new b1360ac [ISSUE dubbo#11900] part6 init dubbo-wasm-remoting-api module (#295) b1360ac is described below commit b1360ac89c8f5b6c66b2c49f4d69c56138b585c8 Author: loongs-zhang <zhangzich...@apache.org> AuthorDate: Mon Mar 25 20:31:59 2024 +0800 [ISSUE dubbo#11900] part6 init dubbo-wasm-remoting-api module (#295) * [ISSUE dubbo#11900] part6 init dubbo-wasm-remoting-api module * fix test * fix import --------- Co-authored-by: xiaosheng <songxiaosh...@apache.org> --- dubbo-wasm/dubbo-wasm-remoting-api/pom.xml | 62 +++++ .../remoting/transport/AbstractWasmChannel.java | 275 +++++++++++++++++++++ .../transport/AbstractWasmChannelTest.java | 106 ++++++++ .../org/apache/dubbo/wasm/test/TestHelper.java | 4 + .../src/main/resources/rust_extensions.wasm | Bin 1685184 -> 1687720 bytes .../src/main/rust-extensions/src/lib.rs | 87 +++++++ dubbo-wasm/pom.xml | 1 + 7 files changed, 535 insertions(+) diff --git a/dubbo-wasm/dubbo-wasm-remoting-api/pom.xml b/dubbo-wasm/dubbo-wasm-remoting-api/pom.xml new file mode 100644 index 0000000..4335dde --- /dev/null +++ b/dubbo-wasm/dubbo-wasm-remoting-api/pom.xml @@ -0,0 +1,62 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + ~ Licensed to the Apache Software Foundation (ASF) under one or more + ~ contributor license agreements. See the NOTICE file distributed with + ~ this work for additional information regarding copyright ownership. + ~ The ASF licenses this file to You under the Apache License, Version 2.0 + ~ (the "License"); you may not use this file except in compliance with + ~ the License. You may obtain a copy of the License at + ~ + ~ http://www.apache.org/licenses/LICENSE-2.0 + ~ + ~ Unless required by applicable law or agreed to in writing, software + ~ distributed under the License is distributed on an "AS IS" BASIS, + ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ~ See the License for the specific language governing permissions and + ~ limitations under the License. + --> + +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <parent> + <artifactId>dubbo-wasm</artifactId> + <groupId>org.apache.dubbo.extensions</groupId> + <version>${revision}</version> + <relativePath>../pom.xml</relativePath> + </parent> + <modelVersion>4.0.0</modelVersion> + + <artifactId>dubbo-wasm-remoting-api</artifactId> + + <dependencies> + <dependency> + <groupId>org.apache.dubbo</groupId> + <artifactId>dubbo-remoting-api</artifactId> + <optional>true</optional> + </dependency> + <dependency> + <groupId>org.apache.dubbo.extensions</groupId> + <artifactId>dubbo-wasm-api</artifactId> + </dependency> + <dependency> + <groupId>org.apache.dubbo.extensions</groupId> + <artifactId>dubbo-wasm-test</artifactId> + <scope>test</scope> + </dependency> + <dependency> + <groupId>ch.qos.logback</groupId> + <artifactId>logback-classic</artifactId> + <scope>test</scope> + </dependency> + </dependencies> + + <build> + <resources> + <resource> + <directory>../dubbo-wasm-test/src/main/resources</directory> + <includes> + <include>rust_extensions.wasm</include> + </includes> + </resource> + </resources> + </build> +</project> diff --git a/dubbo-wasm/dubbo-wasm-remoting-api/src/main/java/org/apache/dubbo/wasm/remoting/transport/AbstractWasmChannel.java b/dubbo-wasm/dubbo-wasm-remoting-api/src/main/java/org/apache/dubbo/wasm/remoting/transport/AbstractWasmChannel.java new file mode 100644 index 0000000..3d21818 --- /dev/null +++ b/dubbo-wasm/dubbo-wasm-remoting-api/src/main/java/org/apache/dubbo/wasm/remoting/transport/AbstractWasmChannel.java @@ -0,0 +1,275 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.dubbo.wasm.remoting.transport; + +import io.github.kawamuray.wasmtime.Extern; +import io.github.kawamuray.wasmtime.Func; +import io.github.kawamuray.wasmtime.Store; +import io.github.kawamuray.wasmtime.WasmFunctions; +import io.github.kawamuray.wasmtime.WasmValType; + +import org.apache.dubbo.common.URL; +import org.apache.dubbo.common.logger.Logger; +import org.apache.dubbo.common.logger.LoggerFactory; +import org.apache.dubbo.remoting.ChannelHandler; +import org.apache.dubbo.remoting.RemotingException; +import org.apache.dubbo.remoting.transport.AbstractChannel; +import org.apache.dubbo.wasm.WasmLoader; +import org.apache.dubbo.wasm.exception.DubboWasmException; + +import java.net.InetSocketAddress; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +/** + * Channels implemented in other languages should extend this class, we still need to write Java subclasses, + * so we can reuse the convenient/powerful control of dubbo, such as {@link org.apache.dubbo.common.extension.Activate}. + * + * @see WasmLoader + */ +public abstract class AbstractWasmChannel extends AbstractChannel { + + private static final Logger logger = LoggerFactory.getLogger(AbstractWasmChannel.class); + + private static final String SEND_METHOD_NAME = "send"; + + private static final String CLOSE_METHOD_NAME = "closeChannel"; + + private static final String GET_REMOTE_ADDRESS_HOST_METHOD_NAME = "getRemoteAddressHost"; + + private static final String GET_REMOTE_ADDRESS_PORT_METHOD_NAME = "getRemoteAddressPort"; + + private static final String IS_CONNECTED_METHOD_NAME = "isConnected"; + + private static final String HAS_ATTRIBUTE_METHOD_NAME = "hasAttribute"; + + private static final String GET_ATTRIBUTE_METHOD_NAME = "getAttribute"; + + private static final String SET_ATTRIBUTE_METHOD_NAME = "setAttribute"; + + private static final String REMOVE_ATTRIBUTE_METHOD_NAME = "removeAttribute"; + + private static final String GET_LOCAL_ADDRESS_HOST_METHOD_NAME = "getLocalAddressHost"; + + private static final String GET_LOCAL_ADDRESS_PORT_METHOD_NAME = "getLocalAddressPort"; + + protected static final Map<Long, SendArgument> SEND_ARGUMENT_MAP = new ConcurrentHashMap<>(); + + protected static final Map<Long, String> GET_REMOTE_ADDRESS_RESULTS = new ConcurrentHashMap<>(); + + protected static final Map<Long, String> HAS_ATTRIBUTE_ARGUMENTS = new ConcurrentHashMap<>(); + + protected static final Map<Long, String> GET_ATTRIBUTE_ARGUMENTS = new ConcurrentHashMap<>(); + + protected static final Map<Long, SetAttributeArgument> SET_ATTRIBUTE_ARGUMENT_MAP = new ConcurrentHashMap<>(); + + protected static final Map<Long, String> REMOVE_ATTRIBUTE_ARGUMENTS = new ConcurrentHashMap<>(); + + protected static final Map<Long, String> GET_LOCAL_ADDRESS_RESULTS = new ConcurrentHashMap<>(); + + private final WasmLoader wasmLoader; + + public AbstractWasmChannel(URL url, ChannelHandler handler) { + super(url, handler); + this.wasmLoader = new WasmLoader(this.getClass(), this::buildWasmName, this::initWasmCallJavaFunc); + } + + protected String buildWasmName(final Class<?> clazz) { + return clazz.getName() + ".wasm"; + } + + protected Map<String, Func> initWasmCallJavaFunc(final Store<Void> store, Supplier<ByteBuffer> buf) { + Map<String, Func> funcMap = new HashMap<>(); + funcMap.put("setRemoteAddressHost", WasmFunctions.wrap(store, WasmValType.I64, WasmValType.I64, WasmValType.I32, WasmValType.I32, + (respId, addr, len) -> { + ByteBuffer buffer = buf.get(); + byte[] bytes = new byte[len]; + for (int i = 0; i < len; i++) { + bytes[i] = buffer.get(addr.intValue() + i); + } + GET_REMOTE_ADDRESS_RESULTS.put(respId, new String(bytes, StandardCharsets.UTF_8)); + return 0; + })); + funcMap.put("setLocalAddressHost", WasmFunctions.wrap(store, WasmValType.I64, WasmValType.I64, WasmValType.I32, WasmValType.I32, + (respId, addr, len) -> { + ByteBuffer buffer = buf.get(); + byte[] bytes = new byte[len]; + for (int i = 0; i < len; i++) { + bytes[i] = buffer.get(addr.intValue() + i); + } + GET_LOCAL_ADDRESS_RESULTS.put(respId, new String(bytes, StandardCharsets.UTF_8)); + return 0; + })); + return funcMap; + } + + @Override + public void send(Object message, boolean sent) throws RemotingException { + super.send(message, sent); + Optional<Extern> func = wasmLoader.getWasmExtern(SEND_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(SEND_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long argumentId = sendArgumentId(message, sent); + SEND_ARGUMENT_MAP.put(argumentId, new SendArgument(message, sent)); + WasmFunctions.consumer(wasmLoader.getStore(), func.get().func(), WasmValType.I64).accept(argumentId); + SEND_ARGUMENT_MAP.remove(argumentId); + } + + protected abstract Long sendArgumentId(Object message, boolean sent); + + @Override + public void close() { + try { + super.close(); + } catch (Exception e) { + logger.warn(e.getMessage(), e); + } + Optional<Extern> func = wasmLoader.getWasmExtern(CLOSE_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(CLOSE_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + WasmFunctions.consumer(wasmLoader.getStore(), func.get().func()).accept(); + } + + @Override + public InetSocketAddress getRemoteAddress() { + Optional<Extern> hostFunc = wasmLoader.getWasmExtern(GET_REMOTE_ADDRESS_HOST_METHOD_NAME); + if (!hostFunc.isPresent()) { + throw new DubboWasmException(GET_REMOTE_ADDRESS_HOST_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + Optional<Extern> portFunc = wasmLoader.getWasmExtern(GET_REMOTE_ADDRESS_PORT_METHOD_NAME); + if (!portFunc.isPresent()) { + throw new DubboWasmException(GET_REMOTE_ADDRESS_PORT_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long respId = WasmFunctions.func(wasmLoader.getStore(), hostFunc.get().func(), WasmValType.I64).call(); + final Integer port = WasmFunctions.func(wasmLoader.getStore(), portFunc.get().func(), WasmValType.I32).call(); + return InetSocketAddress.createUnresolved(GET_REMOTE_ADDRESS_RESULTS.get(respId), port); + } + + @Override + public boolean isConnected() { + Optional<Extern> func = wasmLoader.getWasmExtern(IS_CONNECTED_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(IS_CONNECTED_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + Integer result = WasmFunctions.func(wasmLoader.getStore(), func.get().func(), WasmValType.I32).call(); + return result != 0; + } + + @Override + public boolean hasAttribute(String key) { + Optional<Extern> func = wasmLoader.getWasmExtern(HAS_ATTRIBUTE_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(HAS_ATTRIBUTE_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long argumentId = hasAttributeArgumentId(key); + HAS_ATTRIBUTE_ARGUMENTS.put(argumentId, key); + Integer result = WasmFunctions.func(wasmLoader.getStore(), func.get().func(), WasmValType.I64, WasmValType.I32) + .call(argumentId); + HAS_ATTRIBUTE_ARGUMENTS.remove(argumentId); + return result != 0; + } + + protected abstract Long hasAttributeArgumentId(String key); + + @Override + public Object getAttribute(String key) { + Optional<Extern> func = wasmLoader.getWasmExtern(GET_ATTRIBUTE_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(GET_ATTRIBUTE_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long argumentId = getAttributeArgumentId(key); + GET_ATTRIBUTE_ARGUMENTS.put(argumentId, key); + WasmFunctions.consumer(wasmLoader.getStore(), func.get().func(), WasmValType.I64).accept(argumentId); + GET_ATTRIBUTE_ARGUMENTS.remove(argumentId); + return getAttribute(key, argumentId); + } + + protected abstract Long getAttributeArgumentId(String key); + + protected abstract Object getAttribute(String key, Long argumentId); + + @Override + public void setAttribute(String key, Object value) { + Optional<Extern> func = wasmLoader.getWasmExtern(SET_ATTRIBUTE_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(SET_ATTRIBUTE_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long argumentId = setAttributeArgumentId(key, value); + SET_ATTRIBUTE_ARGUMENT_MAP.put(argumentId, new SetAttributeArgument(key, value)); + WasmFunctions.consumer(wasmLoader.getStore(), func.get().func(), WasmValType.I64).accept(argumentId); + SET_ATTRIBUTE_ARGUMENT_MAP.remove(argumentId); + } + + protected abstract Long setAttributeArgumentId(String key, Object value); + + @Override + public void removeAttribute(String key) { + Optional<Extern> func = wasmLoader.getWasmExtern(REMOVE_ATTRIBUTE_METHOD_NAME); + if (!func.isPresent()) { + throw new DubboWasmException(REMOVE_ATTRIBUTE_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long argumentId = removeAttributeArgumentId(key); + REMOVE_ATTRIBUTE_ARGUMENTS.put(argumentId, key); + WasmFunctions.consumer(wasmLoader.getStore(), func.get().func(), WasmValType.I64).accept(argumentId); + REMOVE_ATTRIBUTE_ARGUMENTS.remove(argumentId); + } + + protected abstract Long removeAttributeArgumentId(String key); + + @Override + public InetSocketAddress getLocalAddress() { + Optional<Extern> hostFunc = wasmLoader.getWasmExtern(GET_LOCAL_ADDRESS_HOST_METHOD_NAME); + if (!hostFunc.isPresent()) { + throw new DubboWasmException(GET_LOCAL_ADDRESS_HOST_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + Optional<Extern> portFunc = wasmLoader.getWasmExtern(GET_LOCAL_ADDRESS_PORT_METHOD_NAME); + if (!portFunc.isPresent()) { + throw new DubboWasmException(GET_LOCAL_ADDRESS_PORT_METHOD_NAME + " function not found in " + wasmLoader.getWasmName()); + } + final Long respId = WasmFunctions.func(wasmLoader.getStore(), hostFunc.get().func(), WasmValType.I64).call(); + final Integer port = WasmFunctions.func(wasmLoader.getStore(), portFunc.get().func(), WasmValType.I32).call(); + return InetSocketAddress.createUnresolved(GET_LOCAL_ADDRESS_RESULTS.get(respId), port); + } + + protected static class SendArgument { + protected Object message; + protected boolean sent; + + private SendArgument(Object message, boolean sent) { + this.message = message; + this.sent = sent; + } + } + + protected static class SetAttributeArgument { + protected String key; + protected Object value; + + private SetAttributeArgument(String key, Object value) { + this.key = key; + this.value = value; + } + } +} diff --git a/dubbo-wasm/dubbo-wasm-remoting-api/src/test/java/org/apache/dubbo/wasm/remoting/transport/AbstractWasmChannelTest.java b/dubbo-wasm/dubbo-wasm-remoting-api/src/test/java/org/apache/dubbo/wasm/remoting/transport/AbstractWasmChannelTest.java new file mode 100644 index 0000000..72852d6 --- /dev/null +++ b/dubbo-wasm/dubbo-wasm-remoting-api/src/test/java/org/apache/dubbo/wasm/remoting/transport/AbstractWasmChannelTest.java @@ -0,0 +1,106 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.dubbo.wasm.remoting.transport; + +import org.apache.dubbo.common.URL; +import org.apache.dubbo.remoting.transport.ChannelHandlerAdapter; +import org.apache.dubbo.wasm.test.TestHelper; + +import io.github.kawamuray.wasmtime.Func; +import io.github.kawamuray.wasmtime.Store; +import org.junit.jupiter.api.Test; + +import java.nio.ByteBuffer; +import java.util.Map; +import java.util.function.Supplier; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +/** + * see dubbo-wasm/dubbo-wasm-test/src/main/rust-extensions/README.md + */ +public class AbstractWasmChannelTest { + + @Test + void test() { + RustChannel channel = new RustChannel(); + try { + channel.send("key"); + channel.getRemoteAddress(); + channel.isConnected(); + channel.hasAttribute("key"); + channel.getAttribute("key"); + channel.setAttribute("key", "value"); + channel.removeAttribute("key"); + channel.getLocalAddress(); + } catch (Exception ignored) { + } finally { + channel.close(); + } + } + + static class RustChannel extends AbstractWasmChannel { + public RustChannel() { + super(URL.valueOf("dubbo://127.0.0.1:12345?timeout=1234&default.timeout=5678"), new ChannelHandlerAdapter()); + } + + @Override + protected String buildWasmName(Class<?> clazz) { + return TestHelper.WASM_NAME; + } + + @Override + protected Map<String, Func> initWasmCallJavaFunc(Store<Void> store, Supplier<ByteBuffer> supplier) { + Map<String, Func> funcs = TestHelper.initWasmCallJavaFunc(store, supplier); + funcs.putAll(super.initWasmCallJavaFunc(store, supplier)); + return funcs; + } + + @Override + protected Long sendArgumentId(Object message, boolean sent) { + return 9L; + } + + @Override + protected Long hasAttributeArgumentId(String key) { + return 9L; + } + + @Override + protected Long getAttributeArgumentId(String key) { + return 9L; + } + + @Override + protected Object getAttribute(String key, Long argumentId) { + String result = TestHelper.getResult(argumentId); + assertEquals("rust result", result); + return result; + } + + @Override + protected Long setAttributeArgumentId(String key, Object value) { + return 9L; + } + + @Override + protected Long removeAttributeArgumentId(String key) { + return 9L; + } + } +} diff --git a/dubbo-wasm/dubbo-wasm-test/src/main/java/org/apache/dubbo/wasm/test/TestHelper.java b/dubbo-wasm/dubbo-wasm-test/src/main/java/org/apache/dubbo/wasm/test/TestHelper.java index ee72d24..a019831 100644 --- a/dubbo-wasm/dubbo-wasm-test/src/main/java/org/apache/dubbo/wasm/test/TestHelper.java +++ b/dubbo-wasm/dubbo-wasm-test/src/main/java/org/apache/dubbo/wasm/test/TestHelper.java @@ -59,6 +59,10 @@ public class TestHelper { System.out.println("java side->" + result); return 0; })); + funcMap.put("setRemoteAddressHost", WasmFunctions.wrap(store, WasmValType.I64, WasmValType.I64, WasmValType.I32, WasmValType.I32, + (respId, addr, len) -> 0)); + funcMap.put("setLocalAddressHost", WasmFunctions.wrap(store, WasmValType.I64, WasmValType.I64, WasmValType.I32, WasmValType.I32, + (respId, addr, len) -> 0)); return funcMap; } diff --git a/dubbo-wasm/dubbo-wasm-test/src/main/resources/rust_extensions.wasm b/dubbo-wasm/dubbo-wasm-test/src/main/resources/rust_extensions.wasm index 41e3c41..156cb4a 100755 Binary files a/dubbo-wasm/dubbo-wasm-test/src/main/resources/rust_extensions.wasm and b/dubbo-wasm/dubbo-wasm-test/src/main/resources/rust_extensions.wasm differ diff --git a/dubbo-wasm/dubbo-wasm-test/src/main/rust-extensions/src/lib.rs b/dubbo-wasm/dubbo-wasm-test/src/main/rust-extensions/src/lib.rs index 10c4bdf..90d23e3 100644 --- a/dubbo-wasm/dubbo-wasm-test/src/main/rust-extensions/src/lib.rs +++ b/dubbo-wasm/dubbo-wasm-test/src/main/rust-extensions/src/lib.rs @@ -20,6 +20,10 @@ extern "C" { fn get_args(arg_id: i64, addr: i64, len: i32) -> i32; fn put_result(arg_id: i64, addr: i64, len: i32) -> i32; + + fn setRemoteAddressHost(arg_id: i64, addr: i64, len: i32) -> i32; + + fn setLocalAddressHost(arg_id: i64, addr: i64, len: i32) -> i32; } pub unsafe extern "C" fn impls(arg_id: i64) { @@ -230,3 +234,86 @@ pub unsafe extern "C" fn publishConfigCas(arg_id: i64) -> i32 { impls(arg_id); 1 } + +/// 9 + +#[no_mangle] +pub unsafe extern "C" fn send(arg_id: i64) { + eprintln!("rust side-> send"); + impls(arg_id); +} + +#[no_mangle] +pub unsafe extern "C" fn getRemoteAddressHost()->i64 { + eprintln!("rust side-> getRemoteAddressHost"); + impls(9); + let rust_result = "localhost".as_bytes(); + let result_ptr = rust_result.as_ptr() as i64; + _ = setRemoteAddressHost(9, result_ptr, rust_result.len() as i32); + 9 +} + +#[no_mangle] +pub unsafe extern "C" fn getRemoteAddressPort()->i32 { + eprintln!("rust side-> getRemoteAddressPort"); + impls(9); + 9999 +} + +#[no_mangle] +pub unsafe extern "C" fn isConnected()->i32 { + eprintln!("rust side-> isConnected"); + impls(9); + 1 +} + +#[no_mangle] +pub unsafe extern "C" fn hasAttribute(arg_id: i64) -> i32 { + eprintln!("rust side-> hasAttribute"); + impls(arg_id); + 1 +} + +#[no_mangle] +pub unsafe extern "C" fn getAttribute(arg_id: i64) -> i32 { + eprintln!("rust side-> getAttribute"); + impls(arg_id); + 1 +} + +#[no_mangle] +pub unsafe extern "C" fn setAttribute(arg_id: i64) -> i32 { + eprintln!("rust side-> setAttribute"); + impls(arg_id); + 1 +} + +#[no_mangle] +pub unsafe extern "C" fn removeAttribute(arg_id: i64) -> i32 { + eprintln!("rust side-> removeAttribute"); + impls(arg_id); + 1 +} + +#[no_mangle] +pub unsafe extern "C" fn getLocalAddressHost()->i64 { + eprintln!("rust side-> getLocalAddressHost"); + impls(9); + let rust_result = "localhost".as_bytes(); + let result_ptr = rust_result.as_ptr() as i64; + _ = setLocalAddressHost(9, result_ptr, rust_result.len() as i32); + 9 +} + +#[no_mangle] +pub unsafe extern "C" fn getLocalAddressPort()->i32 { + eprintln!("rust side-> getLocalAddressPort"); + impls(9); + 9999 +} + +#[no_mangle] +pub unsafe extern "C" fn closeChannel() { + eprintln!("rust side-> closeChannel"); + impls(9); +} diff --git a/dubbo-wasm/pom.xml b/dubbo-wasm/pom.xml index 75301c4..785daa0 100644 --- a/dubbo-wasm/pom.xml +++ b/dubbo-wasm/pom.xml @@ -36,6 +36,7 @@ <module>dubbo-wasm-rpc-api</module> <module>dubbo-wasm-cluster-api</module> <module>dubbo-wasm-registry-api</module> + <module>dubbo-wasm-remoting-api</module> <module>dubbo-wasm-test</module> </modules>