Wit in Go Practice

package main

import (
	"github.com/taction/wit-dapr/dapr/http"
)

func init() {
	a := &HostImpl{}
	http.SetExportsDaprHttpHttpHandler(a)
}

type HostImpl struct {
}

func (h *HostImpl) HandleHttpRequest(req http.DaprHttpHttpTypesRequest) http.DaprHttpHttpTypesResponse {
	headers := []http.DaprHttpHttpTypesTuple2StringStringT{{"Content-Type", "text/plain"}}
	return http.DaprHttpHttpTypesResponse{
		Status:  200,
		Body:    http.Some([]byte("Hello from WASM!")),
		Headers: http.Some(headers),
	}
}

func main() {}

// 返回值大小，根据所有返回值计算出来的，铺平后所占用的空间
static uint8_t RET_AREA[28];
__attribute__((__export_name__("dapr:http/http-handler#handle-http-request")))
int32_t __wasm_export_exports_dapr_http_http_handler_handle_http_request(int32_t arg, int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, int32_t arg6, int32_t arg7, int32_t arg8) {
	// 将arg ~ arg8组装成arg9调用go中定义的函数。
  dapr_http_http_handler_response_t ret;
  exports_dapr_http_http_handler_handle_http_request(&arg9, &ret);
  int32_t ptr = (int32_t) &RET_AREA;
  // 将返回值封装到28字节数组中，返回其指针。
  return ptr;
}

func main() {
  http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
		err := handler(writer, request, wasmFile)
		if err != nil {
			writer.WriteHeader(500)
			writer.Write([]byte(err.Error()))
		}
	})
}

func (w WasmServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
	fn := w.Module.ExportedFunction("dapr:http/http-handler#handle-http-request")
	if fn == nil {
		res.WriteHeader(500)
		res.Write([]byte("Handler not found"))
		return
	}
  // 参数准备
	methond := getMethod(req.Method)
	urlPtr, urlLen, headerPtr, headerLen, paramPtr, paramLen, hasBody, bodyPtr, bodyLen, err := formatRequestAsArgs(w.Module, req)
  // 函数调用，根据guest sdk中
	resp, err := fn.Call(context.TODO(), uint64(methond), urlPtr, urlLen, headerPtr, headerLen, paramPtr, paramLen, hasBody, bodyPtr, bodyLen)
  // 释放参数准备时申请的wasm中的内存，这些数据在wasm中不会再被用到了
	freeHeader(w.Module, headerPtr, headerLen)
	common.Free(context.TODO(), w.Module, urlPtr, headerPtr, paramPtr, bodyPtr) // free after used
	if err != nil {
		res.WriteHeader(500)
		res.Write([]byte(err.Error()))
		return
	}
  // 读取并解析返回值
	data, ok := w.Module.Memory().Read(uint32(resp[0]), returnedResponseLen)
	if !ok {
		fmt.Println("Error reading headers.")
		res.WriteHeader(500)
		res.Write([]byte("Error reading response"))
		return
	}
	response := decodeResponse(w.Module, data)
	if response == nil {
		res.WriteHeader(500)
		res.Write([]byte("Error decoding response"))
		return
	}
	if response.Headers != nil {
		// todo handle headers properly
		for k, v := range *response.Headers {
			res.Header().Set(k, v[0])
		}
	}
	res.WriteHeader(int(response.StatusCode))
	if response.Body != nil {
		res.Write(response.Body)
	}
}

static uint8_t RET_AREA[28];

__attribute__((__export_name__("dapr:http/http-handler#handle-http-request")))
int32_t __wasm_export_exports_dapr_http_http_handler_handle_http_request(int32_t arg, int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, int32_t arg6, int32_t arg7, int32_t arg8) {
  // ....
  int32_t ptr = (int32_t) &RET_AREA;
  *((int16_t*)(ptr + 0)) = (int32_t) ((ret).status);
  if (((ret).headers).is_some) {
    const dapr_http_http_types_headers_t *payload10 = &((ret).headers).val;
    *((int8_t*)(ptr + 4)) = 1;
    *((int32_t*)(ptr + 12)) = (int32_t) (*payload10).len;
    *((int32_t*)(ptr + 8)) = (int32_t) (*payload10).ptr;
  } else {
    *((int8_t*)(ptr + 4)) = 0;
  }
  if (((ret).body).is_some) {
    const dapr_http_http_types_body_t *payload12 = &((ret).body).val;
    *((int8_t*)(ptr + 16)) = 1;
    *((int32_t*)(ptr + 24)) = (int32_t) (*payload12).len;
    *((int32_t*)(ptr + 20)) = (int32_t) (*payload12).ptr;
  } else {
    *((int8_t*)(ptr + 16)) = 0;
  }
  return ptr;

func (w WasmServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
  // ...
  // 读取序列化后的response内容并解析
  data, ok := w.Module.Memory().Read(uint32(resp[0]), returnedResponseLen)// returnedResponseLen=28
	response := decodeResponse(w.Module, data)
  // ...
}
// 解析Response
func decodeResponse(m api.Module, res []byte) *Response {
	if len(res) != returnedResponseLen {
		fmt.Printf("Error response length %d, expected %v\n", len(res), returnedResponseLen)
		return nil
	}
	return &Response{
    // [0-4) 字节是StatusCode
		StatusCode: uint16(binary.LittleEndian.Uint32(res[0:4])),
    // [4-16) 字节是header
		Headers:    decodeHeaders(m, res[4:16]),
    // [16-28) 字节是body
		Body:       decodeBody(m, res[16:]),
	}
}
// 解析body：0-4是是否存在，4-8是指针，8-14是数据长度
func decodeBody(mod api.Module, h []byte) []byte {
  // 由于wasm采用小端存储，body是否有值只可能是0或者1，虽然使用前4个字节存储，因此只需要读第一字节就可以。
  // uint8(h[0]) == uint8(binary.LittleEndian.Uint32(h[:4]))
	if h[0] == 0 {
		// nil
		return nil
	}
	ptr := binary.LittleEndian.Uint32(h[4:8])
	len := binary.LittleEndian.Uint32(h[8:12])
	data, ok := mod.Memory().Read(ptr, len)
	if !ok {
		fmt.Println("Error reading header data")
		return nil
	}
	return data
}

func main() {
	state.DaprStateStateInterfaceSet("state", state.DaprStateStateTypesSetRequest{Key: "z", Value: []byte("value")})
	res := state.DaprStateStateInterfaceGet("state", state.DaprStateStateTypesGetRequest{Key: "z"})
	if res.IsOk() {
		fmt.Println(string(res.Val.Data))
	} else {
		fmt.Println(res.Err)
	}
}

__attribute__((__import_module__("dapr:state/state-interface"), __import_name__("get")))
void __wasm_import_dapr_state_state_interface_get(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);

__attribute__((__import_module__("dapr:state/state-interface"), __import_name__("set")))
void __wasm_import_dapr_state_state_interface_set(int32_t, int32_t);

const ModuleName = "dapr:state/state-interface"

func Instantiate(ctx context.Context, rt wazero.Runtime) error {
	s := State
	_, err := rt.NewHostModuleBuilder(ModuleName).
		NewFunctionBuilder().WithFunc(s.Get).Export("get").
		NewFunctionBuilder().WithFunc(s.Set).Export("set").
		NewFunctionBuilder().WithFunc(s.Delete).Export("delete").
		Instantiate(ctx)
	return err
}

func (h *HostImpl) Set(ctx context.Context, m api.Module, inPtr, outPtr uint32) {
	// read request
	name, req, err := readSetRequest(ctx, m, inPtr)

	// call state store
	c, ok := h.getComponent(ctx, string(name))
	if !ok {
		handleGetError(ctx, m, outPtr, errors.New("get component failed"))
		return
	}
	err = c.Set(ctx, req)
	if err != nil {
		handleSetError(ctx, m, outPtr, err)
		return
	}
	// handle response
	handleSetResponseOk(ctx, m, outPtr)
}

func readSetRequest(ctx context.Context, m api.Module, ptr uint32) (string, *comstate.SetRequest, error) {
	data, ok := common.ReadBytes(m, ptr, SetLen)
	if !ok {
		return "", nil, errors.New("read request failed")
	}
	// read name
	namePtr, nameLen := binary.LittleEndian.Uint32(data[0:4]), binary.LittleEndian.Uint32(data[4:8])
	name, ok := common.ReadString(m, namePtr, nameLen)
	if !ok {
		return "", nil, errors.New("read name failed")
	}
	keyPtr, keyLen := binary.LittleEndian.Uint32(data[8:12]), binary.LittleEndian.Uint32(data[12:16])
	key, ok := common.ReadString(m, keyPtr, keyLen)
	if !ok {
		return "", nil, errors.New("read key failed")
	}
	valuePtr, valueLen := binary.LittleEndian.Uint32(data[16:20]), binary.LittleEndian.Uint32(data[20:24])
	value, ok := common.ReadBytes(m, valuePtr, valueLen)
	// todo handle etag and metadata
	return name, &comstate.SetRequest{
		Key:   string(key),
		Value: value,
	}, nil
}

func handleSetResponseOk(ctx context.Context, m api.Module, ptr uint32) {
	resbytes := make([]byte, SetLen)
	//binary.LittleEndian.PutUint32(resbytes[0:4], 0) // result<ok> is 0, so do not need to write
	binary.LittleEndian.PutUint32(resbytes[4:8], 1) // write 1 to indicate ok
	m.Memory().Write(ptr, resbytes)
}

func run(wasmFile string) error {
	wasmName := filepath.Base(wasmFile)
	wasmCode, err := os.ReadFile(wasmFile)
	if err != nil {
		return fmt.Errorf("could not read WASM file '%s': %w", wasmFile, err)
	}
	ctx := context.Background()
	runtime := wazero.NewRuntime(ctx)
	defer runtime.Close(ctx)

	// todo detect wasm module valid
	wasmModule, err := runtime.CompileModule(ctx, wasmCode)
	if err != nil {
		return err
	}
	defer wasmModule.Close(ctx)
	wasi_snapshot_preview1.Instantiate(ctx, runtime)
	host_state.Instantiate(ctx, runtime)

	ins, err := runtime.InstantiateModule(ctx, wasmModule,
		wazero.NewModuleConfig().WithName(wasmName).
			WithRandSource(rand.Reader).
			WithStdout(os.Stdout).
			WithSysNanotime().
			WithSysWalltime().
			WithSysNanosleep())
	if err != nil {
		return err
	}

	ins.Close(ctx)
	return nil
}

// import 和 export 函数，都会先计算函数签名
fn import(&mut self, interface_name: Option<&WorldKey>, func: &Function) {
        self.docs(&func.docs, SourceType::HFns);
        let sig = self.resolve.wasm_signature(AbiVariant::GuestImport, func);
				// ...
}

fn export(&mut self, func: &Function, interface_name: Option<&WorldKey>) {
        let sig = self.resolve.wasm_signature(AbiVariant::GuestExport, func);
  			// ...
}

pub fn wasm_signature(&self, variant: AbiVariant, func: &Function) -> WasmSignature {
        const MAX_FLAT_PARAMS: usize = 16;
        const MAX_FLAT_RESULTS: usize = 1;
  
				// 会将参数展开，将一个参数展开成为多个wasm支持的参数（i32，i64，f32，f46）
        let mut params = Vec::new();
        let mut indirect_params = false;
        for (_, param) in func.params.iter() {
            self.push_flat(param, &mut params);
        }

        // 如果参数展开后超过了MAX_FLAT_PARAMS（16），就会将其压缩为一个参数
        if params.len() > MAX_FLAT_PARAMS {
            params.truncate(0);
            params.push(WasmType::I32);
            indirect_params = true;
        }
  			// ...
}