diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dcb06b2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +gen/* +build/* + diff --git a/README.md b/README.md index f651bb9..7860f36 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,38 @@ -# go-nats-client +# HTTP Hello World +This is a simple TinyGo Wasm example that responds with a "Hello World" message for each request. + +## Prerequisites + +- `go` 1.23 +- `tinygo` 0.33 +- [`wash`](https://wasmcloud.com/docs/installation) 0.35.0 +- `wasmtime` 25.0.0 (if running with wasmtime) + +## Building + +```bash +wash build +``` + +## Running with wasmtime + +You must have wasmtime 25.0.0 for this to work. Make sure to follow the build step above first. + +```bash +wasmtime serve -Scommon ./build/http_hello_world_s.wasm +``` + +## Running with wasmCloud + +Make sure to follow the build steps above, and replace the file path in [the wadm manifest](./wadm.yaml) with the absolute path to your local built component. + +```shell +wash up -d +wash app deploy ./wadm.yaml +curl http://localhost:8000 +``` + +## Adding Capabilities + +To learn how to extend this example with additional capabilities, see the [Adding Capabilities](https://wasmcloud.com/docs/tour/adding-capabilities?lang=tinygo) section of the wasmCloud documentation. diff --git a/bindings.wadge.go b/bindings.wadge.go new file mode 100644 index 0000000..09cb826 --- /dev/null +++ b/bindings.wadge.go @@ -0,0 +1,1985 @@ +//go:build !wasm && !wasi && !wasip1 && !wasip2 && !wasm_unknown && !tinygo.wasm + +// Code generated by wadge-bindgen-go DO NOT EDIT + +package main + +import ( + github_com__bytecodealliance__wasm___tools___go__cm "github.com/bytecodealliance/wasm-tools-go/cm" + go_wasmcloud_dev__component__gen__wasi__clocks__monotonic___clock "go.wasmcloud.dev/component/gen/wasi/clocks/monotonic-clock" + go_wasmcloud_dev__component__gen__wasi__http__outgoing___handler "go.wasmcloud.dev/component/gen/wasi/http/outgoing-handler" + go_wasmcloud_dev__component__gen__wasi__http__types "go.wasmcloud.dev/component/gen/wasi/http/types" + go_wasmcloud_dev__component__gen__wasi__io__poll "go.wasmcloud.dev/component/gen/wasi/io/poll" + go_wasmcloud_dev__component__gen__wasi__io__streams "go.wasmcloud.dev/component/gen/wasi/io/streams" + wadge "go.wasmcloud.dev/wadge" + "runtime" + "unsafe" +) + +const _ string = runtime.Compiler + +var _ unsafe.Pointer + +//go:linkname wasmimport_Now go.wasmcloud.dev/component/gen/wasi/clocks/monotonic-clock.wasmimport_Now +func wasmimport_Now() (result0 uint64) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:clocks/monotonic-clock@0.2.0", "now", func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_Resolution go.wasmcloud.dev/component/gen/wasi/clocks/monotonic-clock.wasmimport_Resolution +func wasmimport_Resolution() (result0 uint64) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:clocks/monotonic-clock@0.2.0", "resolution", func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_SubscribeDuration go.wasmcloud.dev/component/gen/wasi/clocks/monotonic-clock.wasmimport_SubscribeDuration +func wasmimport_SubscribeDuration(when0 uint64) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:clocks/monotonic-clock@0.2.0", "subscribe-duration", func() unsafe.Pointer { + ptr := unsafe.Pointer(&when0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_SubscribeInstant go.wasmcloud.dev/component/gen/wasi/clocks/monotonic-clock.wasmimport_SubscribeInstant +func wasmimport_SubscribeInstant(when0 uint64) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:clocks/monotonic-clock@0.2.0", "subscribe-instant", func() unsafe.Pointer { + ptr := unsafe.Pointer(&when0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_Handle go.wasmcloud.dev/component/gen/wasi/http/outgoing-handler.wasmimport_Handle +func wasmimport_Handle(request0 uint32, options0 uint32, options1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__outgoing___handler.ErrorCodeShape, go_wasmcloud_dev__component__gen__wasi__http__types.FutureIncomingResponse, go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/outgoing-handler@0.2.0", "handle", func() unsafe.Pointer { + ptr := unsafe.Pointer(&request0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&options0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&options1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_NewFields go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_NewFields +func wasmimport_NewFields() (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[constructor]fields", func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_NewOutgoingRequest go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_NewOutgoingRequest +func wasmimport_NewOutgoingRequest(headers0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[constructor]outgoing-request", func() unsafe.Pointer { + ptr := unsafe.Pointer(&headers0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_NewOutgoingResponse go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_NewOutgoingResponse +func wasmimport_NewOutgoingResponse(headers0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[constructor]outgoing-response", func() unsafe.Pointer { + ptr := unsafe.Pointer(&headers0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_NewRequestOptions go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_NewRequestOptions +func wasmimport_NewRequestOptions() (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[constructor]request-options", func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsAppend go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsAppend +func wasmimport_FieldsAppend(self0 uint32, name0 *uint8, name1 uint32, value0 *uint8, value1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError, struct{}, go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.append", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(name0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&name1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(value0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&value1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsClone go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsClone +func wasmimport_FieldsClone(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.clone", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsDelete go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsDelete +func wasmimport_FieldsDelete(self0 uint32, name0 *uint8, name1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError, struct{}, go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.delete", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(name0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&name1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsEntries go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsEntries +func wasmimport_FieldsEntries(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.List[github_com__bytecodealliance__wasm___tools___go__cm.Tuple[go_wasmcloud_dev__component__gen__wasi__http__types.FieldKey, go_wasmcloud_dev__component__gen__wasi__http__types.FieldValue]]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.entries", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsGet go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsGet +func wasmimport_FieldsGet(self0 uint32, name0 *uint8, name1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.List[go_wasmcloud_dev__component__gen__wasi__http__types.FieldValue]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.get", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(name0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&name1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsHas go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsHas +func wasmimport_FieldsHas(self0 uint32, name0 *uint8, name1 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.has", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(name0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&name1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsSet go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsSet +func wasmimport_FieldsSet(self0 uint32, name0 *uint8, name1 uint32, value0 *go_wasmcloud_dev__component__gen__wasi__http__types.FieldValue, value1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError, struct{}, go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]fields.set", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(name0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&name1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(value0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&value1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FutureIncomingResponseGet go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FutureIncomingResponseGet +func wasmimport_FutureIncomingResponseGet(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[github_com__bytecodealliance__wasm___tools___go__cm.Result[github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCodeShape, go_wasmcloud_dev__component__gen__wasi__http__types.IncomingResponse, go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode], github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCodeShape, go_wasmcloud_dev__component__gen__wasi__http__types.IncomingResponse, go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode], struct{}]]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]future-incoming-response.get", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FutureIncomingResponseSubscribe go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FutureIncomingResponseSubscribe +func wasmimport_FutureIncomingResponseSubscribe(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]future-incoming-response.subscribe", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FutureTrailersGet go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FutureTrailersGet +func wasmimport_FutureTrailersGet(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[github_com__bytecodealliance__wasm___tools___go__cm.Result[github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCodeShape, github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__http__types.Trailers], go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode], github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCodeShape, github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__http__types.Trailers], go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode], struct{}]]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]future-trailers.get", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FutureTrailersSubscribe go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FutureTrailersSubscribe +func wasmimport_FutureTrailersSubscribe(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]future-trailers.subscribe", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingBodyStream go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingBodyStream +func wasmimport_IncomingBodyStream(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.InputStream, go_wasmcloud_dev__component__gen__wasi__io__streams.InputStream, struct{}]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-body.stream", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestAuthority go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestAuthority +func wasmimport_IncomingRequestAuthority(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[string]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-request.authority", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestConsume go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestConsume +func wasmimport_IncomingRequestConsume(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.IncomingBody, go_wasmcloud_dev__component__gen__wasi__http__types.IncomingBody, struct{}]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-request.consume", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestHeaders go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestHeaders +func wasmimport_IncomingRequestHeaders(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-request.headers", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestMethod go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestMethod +func wasmimport_IncomingRequestMethod(self0 uint32, result *go_wasmcloud_dev__component__gen__wasi__http__types.Method) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-request.method", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestPathWithQuery go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestPathWithQuery +func wasmimport_IncomingRequestPathWithQuery(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[string]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-request.path-with-query", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestScheme go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestScheme +func wasmimport_IncomingRequestScheme(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__http__types.Scheme]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-request.scheme", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingResponseConsume go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingResponseConsume +func wasmimport_IncomingResponseConsume(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.IncomingBody, go_wasmcloud_dev__component__gen__wasi__http__types.IncomingBody, struct{}]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-response.consume", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingResponseHeaders go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingResponseHeaders +func wasmimport_IncomingResponseHeaders(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-response.headers", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingResponseStatus go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingResponseStatus +func wasmimport_IncomingResponseStatus(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]incoming-response.status", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingBodyWrite go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingBodyWrite +func wasmimport_OutgoingBodyWrite(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.OutputStream, go_wasmcloud_dev__component__gen__wasi__io__streams.OutputStream, struct{}]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-body.write", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestAuthority go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestAuthority +func wasmimport_OutgoingRequestAuthority(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[string]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.authority", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestBody go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestBody +func wasmimport_OutgoingRequestBody(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.OutgoingBody, go_wasmcloud_dev__component__gen__wasi__http__types.OutgoingBody, struct{}]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.body", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestHeaders go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestHeaders +func wasmimport_OutgoingRequestHeaders(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.headers", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestMethod go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestMethod +func wasmimport_OutgoingRequestMethod(self0 uint32, result *go_wasmcloud_dev__component__gen__wasi__http__types.Method) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.method", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestPathWithQuery go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestPathWithQuery +func wasmimport_OutgoingRequestPathWithQuery(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[string]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.path-with-query", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestScheme go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestScheme +func wasmimport_OutgoingRequestScheme(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__http__types.Scheme]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.scheme", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestSetAuthority go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestSetAuthority +func wasmimport_OutgoingRequestSetAuthority(self0 uint32, authority0 uint32, authority1 *uint8, authority2 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.set-authority", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&authority0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(authority1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&authority2) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestSetMethod go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestSetMethod +func wasmimport_OutgoingRequestSetMethod(self0 uint32, method0 uint32, method1 *uint8, method2 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.set-method", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&method0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(method1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&method2) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestSetPathWithQuery go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestSetPathWithQuery +func wasmimport_OutgoingRequestSetPathWithQuery(self0 uint32, pathWithQuery0 uint32, pathWithQuery1 *uint8, pathWithQuery2 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.set-path-with-query", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&pathWithQuery0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(pathWithQuery1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&pathWithQuery2) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestSetScheme go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestSetScheme +func wasmimport_OutgoingRequestSetScheme(self0 uint32, scheme0 uint32, scheme1 uint32, scheme2 *uint8, scheme3 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-request.set-scheme", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&scheme0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&scheme1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(scheme2) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&scheme3) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingResponseBody go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingResponseBody +func wasmimport_OutgoingResponseBody(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.OutgoingBody, go_wasmcloud_dev__component__gen__wasi__http__types.OutgoingBody, struct{}]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-response.body", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingResponseHeaders go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingResponseHeaders +func wasmimport_OutgoingResponseHeaders(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-response.headers", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingResponseSetStatusCode go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingResponseSetStatusCode +func wasmimport_OutgoingResponseSetStatusCode(self0 uint32, statusCode0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-response.set-status-code", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&statusCode0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingResponseStatusCode go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingResponseStatusCode +func wasmimport_OutgoingResponseStatusCode(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]outgoing-response.status-code", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsBetweenBytesTimeout go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsBetweenBytesTimeout +func wasmimport_RequestOptionsBetweenBytesTimeout(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__clocks__monotonic___clock.Duration]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]request-options.between-bytes-timeout", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsConnectTimeout go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsConnectTimeout +func wasmimport_RequestOptionsConnectTimeout(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__clocks__monotonic___clock.Duration]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]request-options.connect-timeout", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsFirstByteTimeout go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsFirstByteTimeout +func wasmimport_RequestOptionsFirstByteTimeout(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__clocks__monotonic___clock.Duration]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]request-options.first-byte-timeout", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsSetBetweenBytesTimeout go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsSetBetweenBytesTimeout +func wasmimport_RequestOptionsSetBetweenBytesTimeout(self0 uint32, duration0 uint32, duration1 uint64) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]request-options.set-between-bytes-timeout", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&duration0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&duration1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsSetConnectTimeout go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsSetConnectTimeout +func wasmimport_RequestOptionsSetConnectTimeout(self0 uint32, duration0 uint32, duration1 uint64) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]request-options.set-connect-timeout", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&duration0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&duration1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsSetFirstByteTimeout go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsSetFirstByteTimeout +func wasmimport_RequestOptionsSetFirstByteTimeout(self0 uint32, duration0 uint32, duration1 uint64) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[method]request-options.set-first-byte-timeout", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&duration0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&duration1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsResourceDrop +func wasmimport_FieldsResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]fields", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FutureIncomingResponseResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FutureIncomingResponseResourceDrop +func wasmimport_FutureIncomingResponseResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]future-incoming-response", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FutureTrailersResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FutureTrailersResourceDrop +func wasmimport_FutureTrailersResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]future-trailers", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingBodyResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingBodyResourceDrop +func wasmimport_IncomingBodyResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]incoming-body", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingRequestResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingRequestResourceDrop +func wasmimport_IncomingRequestResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]incoming-request", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingResponseResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingResponseResourceDrop +func wasmimport_IncomingResponseResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]incoming-response", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingBodyResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingBodyResourceDrop +func wasmimport_OutgoingBodyResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]outgoing-body", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingRequestResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingRequestResourceDrop +func wasmimport_OutgoingRequestResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]outgoing-request", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingResponseResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingResponseResourceDrop +func wasmimport_OutgoingResponseResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]outgoing-response", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_RequestOptionsResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_RequestOptionsResourceDrop +func wasmimport_RequestOptionsResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]request-options", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_ResponseOutparamResourceDrop go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_ResponseOutparamResourceDrop +func wasmimport_ResponseOutparamResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[resource-drop]response-outparam", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_FieldsFromList go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_FieldsFromList +func wasmimport_FieldsFromList(entries0 *github_com__bytecodealliance__wasm___tools___go__cm.Tuple[go_wasmcloud_dev__component__gen__wasi__http__types.FieldKey, go_wasmcloud_dev__component__gen__wasi__http__types.FieldValue], entries1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.Fields, go_wasmcloud_dev__component__gen__wasi__http__types.Fields, go_wasmcloud_dev__component__gen__wasi__http__types.HeaderError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[static]fields.from-list", func() unsafe.Pointer { + ptr := unsafe.Pointer(entries0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&entries1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_IncomingBodyFinish go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_IncomingBodyFinish +func wasmimport_IncomingBodyFinish(this0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[static]incoming-body.finish", func() unsafe.Pointer { + ptr := unsafe.Pointer(&this0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutgoingBodyFinish go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_OutgoingBodyFinish +func wasmimport_OutgoingBodyFinish(this0 uint32, trailers0 uint32, trailers1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode, struct{}, go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[static]outgoing-body.finish", func() unsafe.Pointer { + ptr := unsafe.Pointer(&this0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&trailers0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&trailers1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_ResponseOutparamSet go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_ResponseOutparamSet +func wasmimport_ResponseOutparamSet(param0 uint32, response0 uint32, response1 uint32, response2 uint32, response3 uint64, response4 uint32, response5 uint32, response6 uint32, response7 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "[static]response-outparam.set", func() unsafe.Pointer { + ptr := unsafe.Pointer(¶m0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response2) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response3) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response4) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response5) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response6) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&response7) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_HTTPErrorCode go.wasmcloud.dev/component/gen/wasi/http/types.wasmimport_HTTPErrorCode +func wasmimport_HTTPErrorCode(err0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Option[go_wasmcloud_dev__component__gen__wasi__http__types.ErrorCode]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:http/types@0.2.0", "http-error-code", func() unsafe.Pointer { + ptr := unsafe.Pointer(&err0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_ErrorToDebugString go.wasmcloud.dev/component/gen/wasi/io/error.wasmimport_ErrorToDebugString +func wasmimport_ErrorToDebugString(self0 uint32, result *string) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/error@0.2.0", "[method]error.to-debug-string", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_ErrorResourceDrop go.wasmcloud.dev/component/gen/wasi/io/error.wasmimport_ErrorResourceDrop +func wasmimport_ErrorResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/error@0.2.0", "[resource-drop]error", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_PollableBlock go.wasmcloud.dev/component/gen/wasi/io/poll.wasmimport_PollableBlock +func wasmimport_PollableBlock(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/poll@0.2.0", "[method]pollable.block", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_PollableReady go.wasmcloud.dev/component/gen/wasi/io/poll.wasmimport_PollableReady +func wasmimport_PollableReady(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/poll@0.2.0", "[method]pollable.ready", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_PollableResourceDrop go.wasmcloud.dev/component/gen/wasi/io/poll.wasmimport_PollableResourceDrop +func wasmimport_PollableResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/poll@0.2.0", "[resource-drop]pollable", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_Poll go.wasmcloud.dev/component/gen/wasi/io/poll.wasmimport_Poll +func wasmimport_Poll(in0 *go_wasmcloud_dev__component__gen__wasi__io__poll.Pollable, in1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.List[uint32]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/poll@0.2.0", "poll", func() unsafe.Pointer { + ptr := unsafe.Pointer(in0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&in1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_InputStreamBlockingRead go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_InputStreamBlockingRead +func wasmimport_InputStreamBlockingRead(self0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[github_com__bytecodealliance__wasm___tools___go__cm.List[uint8], github_com__bytecodealliance__wasm___tools___go__cm.List[uint8], go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]input-stream.blocking-read", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_InputStreamBlockingSkip go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_InputStreamBlockingSkip +func wasmimport_InputStreamBlockingSkip(self0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[uint64, uint64, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]input-stream.blocking-skip", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_InputStreamRead go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_InputStreamRead +func wasmimport_InputStreamRead(self0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[github_com__bytecodealliance__wasm___tools___go__cm.List[uint8], github_com__bytecodealliance__wasm___tools___go__cm.List[uint8], go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]input-stream.read", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_InputStreamSkip go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_InputStreamSkip +func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[uint64, uint64, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]input-stream.skip", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_InputStreamSubscribe go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_InputStreamSubscribe +func wasmimport_InputStreamSubscribe(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]input-stream.subscribe", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamBlockingFlush go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamBlockingFlush +func wasmimport_OutputStreamBlockingFlush(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError, struct{}, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.blocking-flush", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamBlockingSplice go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamBlockingSplice +func wasmimport_OutputStreamBlockingSplice(self0 uint32, src0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[uint64, uint64, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.blocking-splice", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&src0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamBlockingWriteAndFlush go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamBlockingWriteAndFlush +func wasmimport_OutputStreamBlockingWriteAndFlush(self0 uint32, contents0 *uint8, contents1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError, struct{}, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.blocking-write-and-flush", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(contents0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&contents1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamBlockingWriteZeroesAndFlush go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamBlockingWriteZeroesAndFlush +func wasmimport_OutputStreamBlockingWriteZeroesAndFlush(self0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError, struct{}, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.blocking-write-zeroes-and-flush", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamCheckWrite go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamCheckWrite +func wasmimport_OutputStreamCheckWrite(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[uint64, uint64, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.check-write", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamFlush go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamFlush +func wasmimport_OutputStreamFlush(self0 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError, struct{}, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.flush", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamSplice go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamSplice +func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[uint64, uint64, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.splice", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&src0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamSubscribe go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamSubscribe +func wasmimport_OutputStreamSubscribe(self0 uint32) (result0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.subscribe", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&result0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamWrite go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamWrite +func wasmimport_OutputStreamWrite(self0 uint32, contents0 *uint8, contents1 uint32, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError, struct{}, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.write", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(contents0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&contents1) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamWriteZeroes go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamWriteZeroes +func wasmimport_OutputStreamWriteZeroes(self0 uint32, len0 uint64, result *github_com__bytecodealliance__wasm___tools___go__cm.Result[go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError, struct{}, go_wasmcloud_dev__component__gen__wasi__io__streams.StreamError]) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[method]output-stream.write-zeroes", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(&len0) + __p.Pin(ptr) + return ptr + }(), func() unsafe.Pointer { + ptr := unsafe.Pointer(result) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_InputStreamResourceDrop go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_InputStreamResourceDrop +func wasmimport_InputStreamResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[resource-drop]input-stream", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} + +//go:linkname wasmimport_OutputStreamResourceDrop go.wasmcloud.dev/component/gen/wasi/io/streams.wasmimport_OutputStreamResourceDrop +func wasmimport_OutputStreamResourceDrop(self0 uint32) { + var __p runtime.Pinner + defer __p.Unpin() + if __err := wadge.WithCurrentInstance(func(__instance *wadge.Instance) error { + return __instance.Call("wasi:io/streams@0.2.0", "[resource-drop]output-stream", func() unsafe.Pointer { + ptr := unsafe.Pointer(&self0) + __p.Pin(ptr) + return ptr + }()) + }); __err != nil { + wadge.CurrentErrorHandler()(__err) + } + return +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..bba8d1d --- /dev/null +++ b/go.mod @@ -0,0 +1,24 @@ +module gitea.rebus.ninja/lore/go-nats-client + +go 1.23.0 + +require ( + github.com/bytecodealliance/wasm-tools-go v0.3.1 + go.wasmcloud.dev/component v0.0.4 + go.wasmcloud.dev/wadge v0.7.0 +) + +require ( + github.com/coreos/go-semver v0.3.1 // indirect + github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect + github.com/klauspost/compress v1.17.9 // indirect + github.com/opencontainers/go-digest v1.0.0 // indirect + github.com/regclient/regclient v0.7.1 // indirect + github.com/sirupsen/logrus v1.9.3 // indirect + github.com/ulikunitz/xz v0.5.12 // indirect + github.com/urfave/cli/v3 v3.0.0-alpha9.2 // indirect + golang.org/x/mod v0.21.0 // indirect + golang.org/x/sync v0.8.0 // indirect + golang.org/x/sys v0.26.0 // indirect + golang.org/x/tools v0.26.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..1760473 --- /dev/null +++ b/go.sum @@ -0,0 +1,48 @@ +github.com/bytecodealliance/wasm-tools-go v0.3.1 h1:9Q9PjSzkbiVmkUvZ7nYCfJ02mcQDBalxycA3s8g7kR4= +github.com/bytecodealliance/wasm-tools-go v0.3.1/go.mod h1:vNAQ8DAEp6xvvk+TUHah5DslLEa76f4H6e737OeaxuY= +github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4= +github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4= +github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/olareg/olareg v0.1.0 h1:1dXBOgPrig5N7zoXyIZVQqU0QBo6sD9pbL6UYjY75CA= +github.com/olareg/olareg v0.1.0/go.mod h1:RBuU7JW7SoIIxZKzLRhq8sVtQeAHzCAtRrXEBx2KlM4= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/regclient/regclient v0.7.1 h1:qEsJrTmZd98fZKjueAbrZCSNGU+ifnr6xjlSAs3WOPs= +github.com/regclient/regclient v0.7.1/go.mod h1:+w/BFtJuw0h0nzIw/z2+1FuA2/dVXBzDq4rYmziJpMc= +github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8= +github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc= +github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= +github.com/urfave/cli/v3 v3.0.0-alpha9.2 h1:CL8llQj3dGRLVQQzHxS+ZYRLanOuhyK1fXgLKD+qV+Y= +github.com/urfave/cli/v3 v3.0.0-alpha9.2/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y= +go.wasmcloud.dev/component v0.0.4 h1:CyqSV38sAOjYcXS6kkOIhQaDgXATHmd2gZlU7ghfUj4= +go.wasmcloud.dev/component v0.0.4/go.mod h1:EaPCl4TKNruOQ/hk/3lBTLGzpdE6R1Ju9g52ZzJQgh0= +go.wasmcloud.dev/wadge v0.7.0 h1:eUt0jODh6xQ5HEof1PFSgDp+evrNs+lD1LYCYeRR2Cg= +go.wasmcloud.dev/wadge v0.7.0/go.mod h1:SMnPSWZFTkXyUX0GJ11mcdc7ZoMITtbAlPLlpvGJd4M= +golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0= +golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= +golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ= +golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo= +golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/tools v0.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ= +golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/main.go b/main.go new file mode 100644 index 0000000..d6b1ee2 --- /dev/null +++ b/main.go @@ -0,0 +1,22 @@ +//go:generate go run github.com/bytecodealliance/wasm-tools-go/cmd/wit-bindgen-go generate --world hello --out gen ./wit +package main + +import ( + "fmt" + "net/http" + + "go.wasmcloud.dev/component/net/wasihttp" +) + +func init() { + + wasihttp.HandleFunc(handleRequest) +} + +func handleRequest(w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Hello from Go!\n") +} + +// Since we don't run this program like a CLI, the `main` function is empty. Instead, +// we call the `handleRequest` function when an HTTP request is received. +func main() {} diff --git a/main_test.go b/main_test.go new file mode 100644 index 0000000..319214e --- /dev/null +++ b/main_test.go @@ -0,0 +1,54 @@ +//go:generate go run go.wasmcloud.dev/wadge/cmd/wadge-bindgen-go + +package main + +import ( + "bytes" + "io" + "log" + "log/slog" + "net/http" + "os" + "testing" + + incominghandler "go.wasmcloud.dev/component/gen/wasi/http/incoming-handler" + "go.wasmcloud.dev/wadge" + "go.wasmcloud.dev/wadge/wadgehttp" +) + +func init() { + log.SetFlags(0) + slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{ + Level: slog.LevelDebug, ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr { + if a.Key == slog.TimeKey { + return slog.Attr{} + } + return a + }, + }))) +} + +func TestIncomingHandler(t *testing.T) { + wadge.RunTest(t, func() { + req, err := http.NewRequest("", "/", nil) + if err != nil { + t.Fatalf("failed to create new HTTP request: %s", err) + } + resp, err := wadgehttp.HandleIncomingRequest(incominghandler.Exports.Handle, req) + if err != nil { + t.Fatalf("failed to handle incoming HTTP request: %s", err) + } + if want, got := http.StatusOK, resp.StatusCode; want != got { + t.Fatalf("unexpected status code: want %d, got %d", want, got) + } + buf, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatalf("failed to read HTTP response body: %s", err) + } + defer resp.Body.Close() + + if want, got := []byte("Hello from Go!\n"), buf; !bytes.Equal(want, got) { + t.Fatalf("unexpected response body: want %q, got %q", want, got) + } + }) +} diff --git a/tools.go b/tools.go new file mode 100644 index 0000000..2b8df33 --- /dev/null +++ b/tools.go @@ -0,0 +1,8 @@ +//go:build tools + +package main + +import ( + _ "github.com/bytecodealliance/wasm-tools-go/cmd/wit-bindgen-go" + _ "go.wasmcloud.dev/wadge/cmd/wadge-bindgen-go" +) diff --git a/wadm.yaml b/wadm.yaml new file mode 100644 index 0000000..053034f --- /dev/null +++ b/wadm.yaml @@ -0,0 +1,47 @@ +apiVersion: core.oam.dev/v1beta1 +kind: Application +metadata: + name: tinygo-hello-world + annotations: + description: 'HTTP hello world demo in Golang (TinyGo), using the WebAssembly Component Model and WebAssembly Interfaces Types (WIT)' + wasmcloud.dev/authors: wasmCloud team + wasmcloud.dev/source-url: https://github.com/wasmCloud/wasmCloud/blob/main/examples/golang/components/http-hello-world/wadm.yaml + wasmcloud.dev/readme-md-url: https://github.com/wasmCloud/wasmCloud/blob/main/examples/golang/components/http-hello-world/README.md + wasmcloud.dev/homepage: https://github.com/wasmCloud/wasmCloud/tree/main/examples/golang/components/http-hello-world + wasmcloud.dev/categories: | + http,outgoing-http,http-server,tinygo,golang,example +spec: + components: + - name: http-component + type: component + properties: + image: file://./build/http_hello_world_s.wasm + traits: + # Govern the spread/scheduling of the component + - type: spreadscaler + properties: + instances: 1 + + # Add a capability provider that enables HTTP access + - name: httpserver + type: capability + properties: + image: ghcr.io/wasmcloud/http-server:0.23.2 + traits: + # Link the httpserver to the component, and configure the HTTP server + # to listen on port 8000 for incoming requests + # + # Since the HTTP server calls the `http-component` component, we establish + # a unidirectional link from this `httpserver` provider (the "source") + # to the `http-component` component (the "target"), so the server can invoke + # the component to handle a request. + - type: link + properties: + target: http-component + namespace: wasi + package: http + interfaces: [incoming-handler] + source_config: + - name: default-http + properties: + address: 127.0.0.1:8000 diff --git a/wasmcloud.lock b/wasmcloud.lock new file mode 100644 index 0000000..e830db8 --- /dev/null +++ b/wasmcloud.lock @@ -0,0 +1,21 @@ +# This file is automatically generated. +# It is not intended for manual editing. +version = 1 + +[[packages]] +name = "wasi:http" +registry = "wasi.dev" + +[[packages.versions]] +requirement = "=0.2.0" +version = "0.2.0" +digest = "sha256:5a568e6e2d60c1ce51220e1833cdd5b88db9f615720edc762a9b4a6f36b383bd" + +[[packages]] +name = "wasmcloud:component-go" +registry = "wasmcloud.com" + +[[packages.versions]] +requirement = "=0.1.0" +version = "0.1.0" +digest = "sha256:de3e9af7dedd0d9e882f68f1bee533c7af9c6a1947eb40cbf1ef6163b7d41784" diff --git a/wasmcloud.toml b/wasmcloud.toml new file mode 100644 index 0000000..54f39bb --- /dev/null +++ b/wasmcloud.toml @@ -0,0 +1,9 @@ +name = "http-hello-world" +language = "tinygo" +type = "component" +version = "0.1.0" + +[component] +wit_world = "hello" +wasm_target = "wasm32-wasip2" +destination = "build/http_hello_world_s.wasm" diff --git a/wit/deps/wasi-cli-0.2.0/package.wit b/wit/deps/wasi-cli-0.2.0/package.wit new file mode 100644 index 0000000..f8f1976 --- /dev/null +++ b/wit/deps/wasi-cli-0.2.0/package.wit @@ -0,0 +1,58 @@ +package wasi:cli@0.2.0; + +interface stdout { + use wasi:io/streams@0.2.0.{output-stream}; + + get-stdout: func() -> output-stream; +} + +interface stderr { + use wasi:io/streams@0.2.0.{output-stream}; + + get-stderr: func() -> output-stream; +} + +interface stdin { + use wasi:io/streams@0.2.0.{input-stream}; + + get-stdin: func() -> input-stream; +} + +interface environment { + get-environment: func() -> list>; + + get-arguments: func() -> list; + + initial-cwd: func() -> option; +} + +interface exit { + exit: func(status: result); +} + +interface terminal-input { + resource terminal-input; +} + +interface terminal-output { + resource terminal-output; +} + +interface terminal-stdin { + use terminal-input.{terminal-input}; + + get-terminal-stdin: func() -> option; +} + +interface terminal-stdout { + use terminal-output.{terminal-output}; + + get-terminal-stdout: func() -> option; +} + +interface terminal-stderr { + use terminal-output.{terminal-output}; + + get-terminal-stderr: func() -> option; +} + diff --git a/wit/deps/wasi-clocks-0.2.0/package.wit b/wit/deps/wasi-clocks-0.2.0/package.wit new file mode 100644 index 0000000..9e0ba3d --- /dev/null +++ b/wit/deps/wasi-clocks-0.2.0/package.wit @@ -0,0 +1,29 @@ +package wasi:clocks@0.2.0; + +interface monotonic-clock { + use wasi:io/poll@0.2.0.{pollable}; + + type instant = u64; + + type duration = u64; + + now: func() -> instant; + + resolution: func() -> duration; + + subscribe-instant: func(when: instant) -> pollable; + + subscribe-duration: func(when: duration) -> pollable; +} + +interface wall-clock { + record datetime { + seconds: u64, + nanoseconds: u32, + } + + now: func() -> datetime; + + resolution: func() -> datetime; +} + diff --git a/wit/deps/wasi-config-0.2.0-draft/package.wit b/wit/deps/wasi-config-0.2.0-draft/package.wit new file mode 100644 index 0000000..d514554 --- /dev/null +++ b/wit/deps/wasi-config-0.2.0-draft/package.wit @@ -0,0 +1,13 @@ +package wasi:config@0.2.0-draft; + +interface runtime { + variant config-error { + upstream(string), + io(string), + } + + get: func(key: string) -> result, config-error>; + + get-all: func() -> result>, config-error>; +} + diff --git a/wit/deps/wasi-filesystem-0.2.0/package.wit b/wit/deps/wasi-filesystem-0.2.0/package.wit new file mode 100644 index 0000000..cb6a2be --- /dev/null +++ b/wit/deps/wasi-filesystem-0.2.0/package.wit @@ -0,0 +1,158 @@ +package wasi:filesystem@0.2.0; + +interface types { + use wasi:io/streams@0.2.0.{input-stream, output-stream, error}; + use wasi:clocks/wall-clock@0.2.0.{datetime}; + + type filesize = u64; + + enum descriptor-type { + unknown, + block-device, + character-device, + directory, + fifo, + symbolic-link, + regular-file, + socket, + } + + flags descriptor-flags { + read, + write, + file-integrity-sync, + data-integrity-sync, + requested-write-sync, + mutate-directory, + } + + flags path-flags { + symlink-follow, + } + + flags open-flags { + create, + directory, + exclusive, + truncate, + } + + type link-count = u64; + + record descriptor-stat { + %type: descriptor-type, + link-count: link-count, + size: filesize, + data-access-timestamp: option, + data-modification-timestamp: option, + status-change-timestamp: option, + } + + variant new-timestamp { + no-change, + now, + timestamp(datetime), + } + + record directory-entry { + %type: descriptor-type, + name: string, + } + + enum error-code { + access, + would-block, + already, + bad-descriptor, + busy, + deadlock, + quota, + exist, + file-too-large, + illegal-byte-sequence, + in-progress, + interrupted, + invalid, + io, + is-directory, + loop, + too-many-links, + message-size, + name-too-long, + no-device, + no-entry, + no-lock, + insufficient-memory, + insufficient-space, + not-directory, + not-empty, + not-recoverable, + unsupported, + no-tty, + no-such-device, + overflow, + not-permitted, + pipe, + read-only, + invalid-seek, + text-file-busy, + cross-device, + } + + enum advice { + normal, + sequential, + random, + will-need, + dont-need, + no-reuse, + } + + record metadata-hash-value { + lower: u64, + upper: u64, + } + + resource descriptor { + read-via-stream: func(offset: filesize) -> result; + write-via-stream: func(offset: filesize) -> result; + append-via-stream: func() -> result; + advise: func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>; + sync-data: func() -> result<_, error-code>; + get-flags: func() -> result; + get-type: func() -> result; + set-size: func(size: filesize) -> result<_, error-code>; + set-times: func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>; + read: func(length: filesize, offset: filesize) -> result, bool>, error-code>; + write: func(buffer: list, offset: filesize) -> result; + read-directory: func() -> result; + sync: func() -> result<_, error-code>; + create-directory-at: func(path: string) -> result<_, error-code>; + stat: func() -> result; + stat-at: func(path-flags: path-flags, path: string) -> result; + set-times-at: func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>; + link-at: func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow, new-path: string) -> result<_, error-code>; + open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result; + readlink-at: func(path: string) -> result; + remove-directory-at: func(path: string) -> result<_, error-code>; + rename-at: func(old-path: string, new-descriptor: borrow, new-path: string) -> result<_, error-code>; + symlink-at: func(old-path: string, new-path: string) -> result<_, error-code>; + unlink-file-at: func(path: string) -> result<_, error-code>; + is-same-object: func(other: borrow) -> bool; + metadata-hash: func() -> result; + metadata-hash-at: func(path-flags: path-flags, path: string) -> result; + } + + resource directory-entry-stream { + read-directory-entry: func() -> result, error-code>; + } + + filesystem-error-code: func(err: borrow) -> option; +} + +interface preopens { + use types.{descriptor}; + + get-directories: func() -> list>; +} + diff --git a/wit/deps/wasi-http-0.2.0/package.wit b/wit/deps/wasi-http-0.2.0/package.wit new file mode 100644 index 0000000..11f7ff4 --- /dev/null +++ b/wit/deps/wasi-http-0.2.0/package.wit @@ -0,0 +1,571 @@ +package wasi:http@0.2.0; + +/// This interface defines all of the types and methods for implementing +/// HTTP Requests and Responses, both incoming and outgoing, as well as +/// their headers, trailers, and bodies. +interface types { + use wasi:clocks/monotonic-clock@0.2.0.{duration}; + use wasi:io/streams@0.2.0.{input-stream, output-stream}; + use wasi:io/error@0.2.0.{error as io-error}; + use wasi:io/poll@0.2.0.{pollable}; + + /// This type corresponds to HTTP standard Methods. + variant method { + get, + head, + post, + put, + delete, + connect, + options, + trace, + patch, + other(string), + } + + /// This type corresponds to HTTP standard Related Schemes. + variant scheme { + HTTP, + HTTPS, + other(string), + } + + /// Defines the case payload type for `DNS-error` above: + record DNS-error-payload { + rcode: option, + info-code: option, + } + + /// Defines the case payload type for `TLS-alert-received` above: + record TLS-alert-received-payload { + alert-id: option, + alert-message: option, + } + + /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above: + record field-size-payload { + field-name: option, + field-size: option, + } + + /// These cases are inspired by the IANA HTTP Proxy Error Types: + /// https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types + variant error-code { + DNS-timeout, + DNS-error(DNS-error-payload), + destination-not-found, + destination-unavailable, + destination-IP-prohibited, + destination-IP-unroutable, + connection-refused, + connection-terminated, + connection-timeout, + connection-read-timeout, + connection-write-timeout, + connection-limit-reached, + TLS-protocol-error, + TLS-certificate-error, + TLS-alert-received(TLS-alert-received-payload), + HTTP-request-denied, + HTTP-request-length-required, + HTTP-request-body-size(option), + HTTP-request-method-invalid, + HTTP-request-URI-invalid, + HTTP-request-URI-too-long, + HTTP-request-header-section-size(option), + HTTP-request-header-size(option), + HTTP-request-trailer-section-size(option), + HTTP-request-trailer-size(field-size-payload), + HTTP-response-incomplete, + HTTP-response-header-section-size(option), + HTTP-response-header-size(field-size-payload), + HTTP-response-body-size(option), + HTTP-response-trailer-section-size(option), + HTTP-response-trailer-size(field-size-payload), + HTTP-response-transfer-coding(option), + HTTP-response-content-coding(option), + HTTP-response-timeout, + HTTP-upgrade-failed, + HTTP-protocol-error, + loop-detected, + configuration-error, + /// This is a catch-all error for anything that doesn't fit cleanly into a + /// more specific case. It also includes an optional string for an + /// unstructured description of the error. Users should not depend on the + /// string for diagnosing errors, as it's not required to be consistent + /// between implementations. + internal-error(option), + } + + /// This type enumerates the different kinds of errors that may occur when + /// setting or appending to a `fields` resource. + variant header-error { + /// This error indicates that a `field-key` or `field-value` was + /// syntactically invalid when used with an operation that sets headers in a + /// `fields`. + invalid-syntax, + /// This error indicates that a forbidden `field-key` was used when trying + /// to set a header in a `fields`. + forbidden, + /// This error indicates that the operation on the `fields` was not + /// permitted because the fields are immutable. + immutable, + } + + /// Field keys are always strings. + type field-key = string; + + /// Field values should always be ASCII strings. However, in + /// reality, HTTP implementations often have to interpret malformed values, + /// so they are provided as a list of bytes. + type field-value = list; + + /// This following block defines the `fields` resource which corresponds to + /// HTTP standard Fields. Fields are a common representation used for both + /// Headers and Trailers. + /// + /// A `fields` may be mutable or immutable. A `fields` created using the + /// constructor, `from-list`, or `clone` will be mutable, but a `fields` + /// resource given by other means (including, but not limited to, + /// `incoming-request.headers`, `outgoing-request.headers`) might be be + /// immutable. In an immutable fields, the `set`, `append`, and `delete` + /// operations will fail with `header-error.immutable`. + resource fields { + /// Construct an empty HTTP Fields. + /// + /// The resulting `fields` is mutable. + constructor(); + /// Construct an HTTP Fields. + /// + /// The resulting `fields` is mutable. + /// + /// The list represents each key-value pair in the Fields. Keys + /// which have multiple values are represented by multiple entries in this + /// list with the same key. + /// + /// The tuple is a pair of the field key, represented as a string, and + /// Value, represented as a list of bytes. In a valid Fields, all keys + /// and values are valid UTF-8 strings. However, values are not always + /// well-formed, so they are represented as a raw list of bytes. + /// + /// An error result will be returned if any header or value was + /// syntactically invalid, or if a header was forbidden. + from-list: static func(entries: list>) -> result; + /// Get all of the values corresponding to a key. If the key is not present + /// in this `fields`, an empty list is returned. However, if the key is + /// present but empty, this is represented by a list with one or more + /// empty field-values present. + get: func(name: field-key) -> list; + /// Returns `true` when the key is present in this `fields`. If the key is + /// syntactically invalid, `false` is returned. + has: func(name: field-key) -> bool; + /// Set all of the values for a key. Clears any existing values for that + /// key, if they have been set. + /// + /// Fails with `header-error.immutable` if the `fields` are immutable. + set: func(name: field-key, value: list) -> result<_, header-error>; + /// Delete all values for a key. Does nothing if no values for the key + /// exist. + /// + /// Fails with `header-error.immutable` if the `fields` are immutable. + delete: func(name: field-key) -> result<_, header-error>; + /// Append a value for a key. Does not change or delete any existing + /// values for that key. + /// + /// Fails with `header-error.immutable` if the `fields` are immutable. + append: func(name: field-key, value: field-value) -> result<_, header-error>; + /// Retrieve the full set of keys and values in the Fields. Like the + /// constructor, the list represents each key-value pair. + /// + /// The outer list represents each key-value pair in the Fields. Keys + /// which have multiple values are represented by multiple entries in this + /// list with the same key. + entries: func() -> list>; + /// Make a deep copy of the Fields. Equivelant in behavior to calling the + /// `fields` constructor on the return value of `entries`. The resulting + /// `fields` is mutable. + clone: func() -> fields; + } + + /// Headers is an alias for Fields. + type headers = fields; + + /// Trailers is an alias for Fields. + type trailers = fields; + + /// Represents an incoming HTTP Request. + resource incoming-request { + /// Returns the method of the incoming request. + method: func() -> method; + /// Returns the path with query parameters from the request, as a string. + path-with-query: func() -> option; + /// Returns the protocol scheme from the request. + scheme: func() -> option; + /// Returns the authority from the request, if it was present. + authority: func() -> option; + /// Get the `headers` associated with the request. + /// + /// The returned `headers` resource is immutable: `set`, `append`, and + /// `delete` operations will fail with `header-error.immutable`. + /// + /// The `headers` returned are a child resource: it must be dropped before + /// the parent `incoming-request` is dropped. Dropping this + /// `incoming-request` before all children are dropped will trap. + headers: func() -> headers; + /// Gives the `incoming-body` associated with this request. Will only + /// return success at most once, and subsequent calls will return error. + consume: func() -> result; + } + + /// Represents an outgoing HTTP Request. + resource outgoing-request { + /// Construct a new `outgoing-request` with a default `method` of `GET`, and + /// `none` values for `path-with-query`, `scheme`, and `authority`. + /// + /// * `headers` is the HTTP Headers for the Request. + /// + /// It is possible to construct, or manipulate with the accessor functions + /// below, an `outgoing-request` with an invalid combination of `scheme` + /// and `authority`, or `headers` which are not permitted to be sent. + /// It is the obligation of the `outgoing-handler.handle` implementation + /// to reject invalid constructions of `outgoing-request`. + constructor(headers: headers); + /// Returns the resource corresponding to the outgoing Body for this + /// Request. + /// + /// Returns success on the first call: the `outgoing-body` resource for + /// this `outgoing-request` can be retrieved at most once. Subsequent + /// calls will return error. + body: func() -> result; + /// Get the Method for the Request. + method: func() -> method; + /// Set the Method for the Request. Fails if the string present in a + /// `method.other` argument is not a syntactically valid method. + set-method: func(method: method) -> result; + /// Get the combination of the HTTP Path and Query for the Request. + /// When `none`, this represents an empty Path and empty Query. + path-with-query: func() -> option; + /// Set the combination of the HTTP Path and Query for the Request. + /// When `none`, this represents an empty Path and empty Query. Fails is the + /// string given is not a syntactically valid path and query uri component. + set-path-with-query: func(path-with-query: option) -> result; + /// Get the HTTP Related Scheme for the Request. When `none`, the + /// implementation may choose an appropriate default scheme. + scheme: func() -> option; + /// Set the HTTP Related Scheme for the Request. When `none`, the + /// implementation may choose an appropriate default scheme. Fails if the + /// string given is not a syntactically valid uri scheme. + set-scheme: func(scheme: option) -> result; + /// Get the HTTP Authority for the Request. A value of `none` may be used + /// with Related Schemes which do not require an Authority. The HTTP and + /// HTTPS schemes always require an authority. + authority: func() -> option; + /// Set the HTTP Authority for the Request. A value of `none` may be used + /// with Related Schemes which do not require an Authority. The HTTP and + /// HTTPS schemes always require an authority. Fails if the string given is + /// not a syntactically valid uri authority. + set-authority: func(authority: option) -> result; + /// Get the headers associated with the Request. + /// + /// The returned `headers` resource is immutable: `set`, `append`, and + /// `delete` operations will fail with `header-error.immutable`. + /// + /// This headers resource is a child: it must be dropped before the parent + /// `outgoing-request` is dropped, or its ownership is transfered to + /// another component by e.g. `outgoing-handler.handle`. + headers: func() -> headers; + } + + /// Parameters for making an HTTP Request. Each of these parameters is + /// currently an optional timeout applicable to the transport layer of the + /// HTTP protocol. + /// + /// These timeouts are separate from any the user may use to bound a + /// blocking call to `wasi:io/poll.poll`. + resource request-options { + /// Construct a default `request-options` value. + constructor(); + /// The timeout for the initial connect to the HTTP Server. + connect-timeout: func() -> option; + /// Set the timeout for the initial connect to the HTTP Server. An error + /// return value indicates that this timeout is not supported. + set-connect-timeout: func(duration: option) -> result; + /// The timeout for receiving the first byte of the Response body. + first-byte-timeout: func() -> option; + /// Set the timeout for receiving the first byte of the Response body. An + /// error return value indicates that this timeout is not supported. + set-first-byte-timeout: func(duration: option) -> result; + /// The timeout for receiving subsequent chunks of bytes in the Response + /// body stream. + between-bytes-timeout: func() -> option; + /// Set the timeout for receiving subsequent chunks of bytes in the Response + /// body stream. An error return value indicates that this timeout is not + /// supported. + set-between-bytes-timeout: func(duration: option) -> result; + } + + /// Represents the ability to send an HTTP Response. + /// + /// This resource is used by the `wasi:http/incoming-handler` interface to + /// allow a Response to be sent corresponding to the Request provided as the + /// other argument to `incoming-handler.handle`. + resource response-outparam { + /// Set the value of the `response-outparam` to either send a response, + /// or indicate an error. + /// + /// This method consumes the `response-outparam` to ensure that it is + /// called at most once. If it is never called, the implementation + /// will respond with an error. + /// + /// The user may provide an `error` to `response` to allow the + /// implementation determine how to respond with an HTTP error response. + set: static func(param: response-outparam, response: result); + } + + /// This type corresponds to the HTTP standard Status Code. + type status-code = u16; + + /// Represents an incoming HTTP Response. + resource incoming-response { + /// Returns the status code from the incoming response. + status: func() -> status-code; + /// Returns the headers from the incoming response. + /// + /// The returned `headers` resource is immutable: `set`, `append`, and + /// `delete` operations will fail with `header-error.immutable`. + /// + /// This headers resource is a child: it must be dropped before the parent + /// `incoming-response` is dropped. + headers: func() -> headers; + /// Returns the incoming body. May be called at most once. Returns error + /// if called additional times. + consume: func() -> result; + } + + /// Represents an incoming HTTP Request or Response's Body. + /// + /// A body has both its contents - a stream of bytes - and a (possibly + /// empty) set of trailers, indicating that the full contents of the + /// body have been received. This resource represents the contents as + /// an `input-stream` and the delivery of trailers as a `future-trailers`, + /// and ensures that the user of this interface may only be consuming either + /// the body contents or waiting on trailers at any given time. + resource incoming-body { + /// Returns the contents of the body, as a stream of bytes. + /// + /// Returns success on first call: the stream representing the contents + /// can be retrieved at most once. Subsequent calls will return error. + /// + /// The returned `input-stream` resource is a child: it must be dropped + /// before the parent `incoming-body` is dropped, or consumed by + /// `incoming-body.finish`. + /// + /// This invariant ensures that the implementation can determine whether + /// the user is consuming the contents of the body, waiting on the + /// `future-trailers` to be ready, or neither. This allows for network + /// backpressure is to be applied when the user is consuming the body, + /// and for that backpressure to not inhibit delivery of the trailers if + /// the user does not read the entire body. + %stream: func() -> result; + /// Takes ownership of `incoming-body`, and returns a `future-trailers`. + /// This function will trap if the `input-stream` child is still alive. + finish: static func(this: incoming-body) -> future-trailers; + } + + /// Represents a future which may eventaully return trailers, or an error. + /// + /// In the case that the incoming HTTP Request or Response did not have any + /// trailers, this future will resolve to the empty set of trailers once the + /// complete Request or Response body has been received. + resource future-trailers { + /// Returns a pollable which becomes ready when either the trailers have + /// been received, or an error has occured. When this pollable is ready, + /// the `get` method will return `some`. + subscribe: func() -> pollable; + /// Returns the contents of the trailers, or an error which occured, + /// once the future is ready. + /// + /// The outer `option` represents future readiness. Users can wait on this + /// `option` to become `some` using the `subscribe` method. + /// + /// The outer `result` is used to retrieve the trailers or error at most + /// once. It will be success on the first call in which the outer option + /// is `some`, and error on subsequent calls. + /// + /// The inner `result` represents that either the HTTP Request or Response + /// body, as well as any trailers, were received successfully, or that an + /// error occured receiving them. The optional `trailers` indicates whether + /// or not trailers were present in the body. + /// + /// When some `trailers` are returned by this method, the `trailers` + /// resource is immutable, and a child. Use of the `set`, `append`, or + /// `delete` methods will return an error, and the resource must be + /// dropped before the parent `future-trailers` is dropped. + get: func() -> option, error-code>>>; + } + + /// Represents an outgoing HTTP Response. + resource outgoing-response { + /// Construct an `outgoing-response`, with a default `status-code` of `200`. + /// If a different `status-code` is needed, it must be set via the + /// `set-status-code` method. + /// + /// * `headers` is the HTTP Headers for the Response. + constructor(headers: headers); + /// Get the HTTP Status Code for the Response. + status-code: func() -> status-code; + /// Set the HTTP Status Code for the Response. Fails if the status-code + /// given is not a valid http status code. + set-status-code: func(status-code: status-code) -> result; + /// Get the headers associated with the Request. + /// + /// The returned `headers` resource is immutable: `set`, `append`, and + /// `delete` operations will fail with `header-error.immutable`. + /// + /// This headers resource is a child: it must be dropped before the parent + /// `outgoing-request` is dropped, or its ownership is transfered to + /// another component by e.g. `outgoing-handler.handle`. + headers: func() -> headers; + /// Returns the resource corresponding to the outgoing Body for this Response. + /// + /// Returns success on the first call: the `outgoing-body` resource for + /// this `outgoing-response` can be retrieved at most once. Subsequent + /// calls will return error. + body: func() -> result; + } + + /// Represents an outgoing HTTP Request or Response's Body. + /// + /// A body has both its contents - a stream of bytes - and a (possibly + /// empty) set of trailers, inducating the full contents of the body + /// have been sent. This resource represents the contents as an + /// `output-stream` child resource, and the completion of the body (with + /// optional trailers) with a static function that consumes the + /// `outgoing-body` resource, and ensures that the user of this interface + /// may not write to the body contents after the body has been finished. + /// + /// If the user code drops this resource, as opposed to calling the static + /// method `finish`, the implementation should treat the body as incomplete, + /// and that an error has occured. The implementation should propogate this + /// error to the HTTP protocol by whatever means it has available, + /// including: corrupting the body on the wire, aborting the associated + /// Request, or sending a late status code for the Response. + resource outgoing-body { + /// Returns a stream for writing the body contents. + /// + /// The returned `output-stream` is a child resource: it must be dropped + /// before the parent `outgoing-body` resource is dropped (or finished), + /// otherwise the `outgoing-body` drop or `finish` will trap. + /// + /// Returns success on the first call: the `output-stream` resource for + /// this `outgoing-body` may be retrieved at most once. Subsequent calls + /// will return error. + write: func() -> result; + /// Finalize an outgoing body, optionally providing trailers. This must be + /// called to signal that the response is complete. If the `outgoing-body` + /// is dropped without calling `outgoing-body.finalize`, the implementation + /// should treat the body as corrupted. + /// + /// Fails if the body's `outgoing-request` or `outgoing-response` was + /// constructed with a Content-Length header, and the contents written + /// to the body (via `write`) does not match the value given in the + /// Content-Length. + finish: static func(this: outgoing-body, trailers: option) -> result<_, error-code>; + } + + /// Represents a future which may eventaully return an incoming HTTP + /// Response, or an error. + /// + /// This resource is returned by the `wasi:http/outgoing-handler` interface to + /// provide the HTTP Response corresponding to the sent Request. + resource future-incoming-response { + /// Returns a pollable which becomes ready when either the Response has + /// been received, or an error has occured. When this pollable is ready, + /// the `get` method will return `some`. + subscribe: func() -> pollable; + /// Returns the incoming HTTP Response, or an error, once one is ready. + /// + /// The outer `option` represents future readiness. Users can wait on this + /// `option` to become `some` using the `subscribe` method. + /// + /// The outer `result` is used to retrieve the response or error at most + /// once. It will be success on the first call in which the outer option + /// is `some`, and error on subsequent calls. + /// + /// The inner `result` represents that either the incoming HTTP Response + /// status and headers have recieved successfully, or that an error + /// occured. Errors may also occur while consuming the response body, + /// but those will be reported by the `incoming-body` and its + /// `output-stream` child. + get: func() -> option>>; + } + + /// Attempts to extract a http-related `error` from the wasi:io `error` + /// provided. + /// + /// Stream operations which return + /// `wasi:io/stream/stream-error::last-operation-failed` have a payload of + /// type `wasi:io/error/error` with more information about the operation + /// that failed. This payload can be passed through to this function to see + /// if there's http-related information about the error to return. + /// + /// Note that this function is fallible because not all io-errors are + /// http-related errors. + http-error-code: func(err: borrow) -> option; +} + +/// This interface defines a handler of incoming HTTP Requests. It should +/// be exported by components which can respond to HTTP Requests. +interface incoming-handler { + use types.{incoming-request, response-outparam}; + + /// This function is invoked with an incoming HTTP Request, and a resource + /// `response-outparam` which provides the capability to reply with an HTTP + /// Response. The response is sent by calling the `response-outparam.set` + /// method, which allows execution to continue after the response has been + /// sent. This enables both streaming to the response body, and performing other + /// work. + /// + /// The implementor of this function must write a response to the + /// `response-outparam` before returning, or else the caller will respond + /// with an error on its behalf. + handle: func(request: incoming-request, response-out: response-outparam); +} + +/// This interface defines a handler of outgoing HTTP Requests. It should be +/// imported by components which wish to make HTTP Requests. +interface outgoing-handler { + use types.{outgoing-request, request-options, future-incoming-response, error-code}; + + /// This function is invoked with an outgoing HTTP Request, and it returns + /// a resource `future-incoming-response` which represents an HTTP Response + /// which may arrive in the future. + /// + /// The `options` argument accepts optional parameters for the HTTP + /// protocol's transport layer. + /// + /// This function may return an error if the `outgoing-request` is invalid + /// or not allowed to be made. Otherwise, protocol errors are reported + /// through the `future-incoming-response`. + handle: func(request: outgoing-request, options: option) -> result; +} + +/// The `wasi:http/proxy` world captures a widely-implementable intersection of +/// hosts that includes HTTP forward and reverse proxies. Components targeting +/// this world may concurrently stream in and out any number of incoming and +/// outgoing HTTP requests. +world proxy { + import wasi:random/random@0.2.0; + import wasi:io/error@0.2.0; + import wasi:io/poll@0.2.0; + import wasi:io/streams@0.2.0; + import wasi:cli/stdout@0.2.0; + import wasi:cli/stderr@0.2.0; + import wasi:cli/stdin@0.2.0; + import wasi:clocks/monotonic-clock@0.2.0; + import types; + import outgoing-handler; + import wasi:clocks/wall-clock@0.2.0; + + export incoming-handler; +} diff --git a/wit/deps/wasi-io-0.2.0/package.wit b/wit/deps/wasi-io-0.2.0/package.wit new file mode 100644 index 0000000..962734d --- /dev/null +++ b/wit/deps/wasi-io-0.2.0/package.wit @@ -0,0 +1,48 @@ +package wasi:io@0.2.0; + +interface poll { + resource pollable { + ready: func() -> bool; + block: func(); + } + + poll: func(in: list>) -> list; +} + +interface error { + resource error { + to-debug-string: func() -> string; + } +} + +interface streams { + use error.{error}; + use poll.{pollable}; + + variant stream-error { + last-operation-failed(error), + closed, + } + + resource input-stream { + read: func(len: u64) -> result, stream-error>; + blocking-read: func(len: u64) -> result, stream-error>; + skip: func(len: u64) -> result; + blocking-skip: func(len: u64) -> result; + subscribe: func() -> pollable; + } + + resource output-stream { + check-write: func() -> result; + write: func(contents: list) -> result<_, stream-error>; + blocking-write-and-flush: func(contents: list) -> result<_, stream-error>; + flush: func() -> result<_, stream-error>; + blocking-flush: func() -> result<_, stream-error>; + subscribe: func() -> pollable; + write-zeroes: func(len: u64) -> result<_, stream-error>; + blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>; + splice: func(src: borrow, len: u64) -> result; + blocking-splice: func(src: borrow, len: u64) -> result; + } +} + diff --git a/wit/deps/wasi-logging-0.1.0-draft/package.wit b/wit/deps/wasi-logging-0.1.0-draft/package.wit new file mode 100644 index 0000000..70349a7 --- /dev/null +++ b/wit/deps/wasi-logging-0.1.0-draft/package.wit @@ -0,0 +1,15 @@ +package wasi:logging@0.1.0-draft; + +interface logging { + enum level { + trace, + debug, + info, + warn, + error, + critical, + } + + log: func(level: level, context: string, message: string); +} + diff --git a/wit/deps/wasi-random-0.2.0/package.wit b/wit/deps/wasi-random-0.2.0/package.wit new file mode 100644 index 0000000..58c179e --- /dev/null +++ b/wit/deps/wasi-random-0.2.0/package.wit @@ -0,0 +1,18 @@ +package wasi:random@0.2.0; + +interface random { + get-random-bytes: func(len: u64) -> list; + + get-random-u64: func() -> u64; +} + +interface insecure { + get-insecure-random-bytes: func(len: u64) -> list; + + get-insecure-random-u64: func() -> u64; +} + +interface insecure-seed { + insecure-seed: func() -> tuple; +} + diff --git a/wit/deps/wasi-sockets-0.2.0/package.wit b/wit/deps/wasi-sockets-0.2.0/package.wit new file mode 100644 index 0000000..0602b85 --- /dev/null +++ b/wit/deps/wasi-sockets-0.2.0/package.wit @@ -0,0 +1,179 @@ +package wasi:sockets@0.2.0; + +interface network { + resource network; + + enum error-code { + unknown, + access-denied, + not-supported, + invalid-argument, + out-of-memory, + timeout, + concurrency-conflict, + not-in-progress, + would-block, + invalid-state, + new-socket-limit, + address-not-bindable, + address-in-use, + remote-unreachable, + connection-refused, + connection-reset, + connection-aborted, + datagram-too-large, + name-unresolvable, + temporary-resolver-failure, + permanent-resolver-failure, + } + + enum ip-address-family { + ipv4, + ipv6, + } + + type ipv4-address = tuple; + + type ipv6-address = tuple; + + variant ip-address { + ipv4(ipv4-address), + ipv6(ipv6-address), + } + + record ipv4-socket-address { + port: u16, + address: ipv4-address, + } + + record ipv6-socket-address { + port: u16, + flow-info: u32, + address: ipv6-address, + scope-id: u32, + } + + variant ip-socket-address { + ipv4(ipv4-socket-address), + ipv6(ipv6-socket-address), + } +} + +interface instance-network { + use network.{network}; + + instance-network: func() -> network; +} + +interface udp { + use wasi:io/poll@0.2.0.{pollable}; + use network.{network, error-code, ip-socket-address, ip-address-family}; + + record incoming-datagram { + data: list, + remote-address: ip-socket-address, + } + + record outgoing-datagram { + data: list, + remote-address: option, + } + + resource udp-socket { + start-bind: func(network: borrow, local-address: ip-socket-address) -> result<_, error-code>; + finish-bind: func() -> result<_, error-code>; + %stream: func(remote-address: option) -> result, error-code>; + local-address: func() -> result; + remote-address: func() -> result; + address-family: func() -> ip-address-family; + unicast-hop-limit: func() -> result; + set-unicast-hop-limit: func(value: u8) -> result<_, error-code>; + receive-buffer-size: func() -> result; + set-receive-buffer-size: func(value: u64) -> result<_, error-code>; + send-buffer-size: func() -> result; + set-send-buffer-size: func(value: u64) -> result<_, error-code>; + subscribe: func() -> pollable; + } + + resource incoming-datagram-stream { + receive: func(max-results: u64) -> result, error-code>; + subscribe: func() -> pollable; + } + + resource outgoing-datagram-stream { + check-send: func() -> result; + send: func(datagrams: list) -> result; + subscribe: func() -> pollable; + } +} + +interface udp-create-socket { + use network.{network, error-code, ip-address-family}; + use udp.{udp-socket}; + + create-udp-socket: func(address-family: ip-address-family) -> result; +} + +interface tcp { + use wasi:io/streams@0.2.0.{input-stream, output-stream}; + use wasi:io/poll@0.2.0.{pollable}; + use wasi:clocks/monotonic-clock@0.2.0.{duration}; + use network.{network, error-code, ip-socket-address, ip-address-family}; + + enum shutdown-type { + receive, + send, + both, + } + + resource tcp-socket { + start-bind: func(network: borrow, local-address: ip-socket-address) -> result<_, error-code>; + finish-bind: func() -> result<_, error-code>; + start-connect: func(network: borrow, remote-address: ip-socket-address) -> result<_, error-code>; + finish-connect: func() -> result, error-code>; + start-listen: func() -> result<_, error-code>; + finish-listen: func() -> result<_, error-code>; + accept: func() -> result, error-code>; + local-address: func() -> result; + remote-address: func() -> result; + is-listening: func() -> bool; + address-family: func() -> ip-address-family; + set-listen-backlog-size: func(value: u64) -> result<_, error-code>; + keep-alive-enabled: func() -> result; + set-keep-alive-enabled: func(value: bool) -> result<_, error-code>; + keep-alive-idle-time: func() -> result; + set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>; + keep-alive-interval: func() -> result; + set-keep-alive-interval: func(value: duration) -> result<_, error-code>; + keep-alive-count: func() -> result; + set-keep-alive-count: func(value: u32) -> result<_, error-code>; + hop-limit: func() -> result; + set-hop-limit: func(value: u8) -> result<_, error-code>; + receive-buffer-size: func() -> result; + set-receive-buffer-size: func(value: u64) -> result<_, error-code>; + send-buffer-size: func() -> result; + set-send-buffer-size: func(value: u64) -> result<_, error-code>; + subscribe: func() -> pollable; + shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>; + } +} + +interface tcp-create-socket { + use network.{network, error-code, ip-address-family}; + use tcp.{tcp-socket}; + + create-tcp-socket: func(address-family: ip-address-family) -> result; +} + +interface ip-name-lookup { + use wasi:io/poll@0.2.0.{pollable}; + use network.{network, error-code, ip-address}; + + resource resolve-address-stream { + resolve-next-address: func() -> result, error-code>; + subscribe: func() -> pollable; + } + + resolve-addresses: func(network: borrow, name: string) -> result; +} + diff --git a/wit/deps/wasmcloud-bus-1.0.0/package.wit b/wit/deps/wasmcloud-bus-1.0.0/package.wit new file mode 100644 index 0000000..2a7cd93 --- /dev/null +++ b/wit/deps/wasmcloud-bus-1.0.0/package.wit @@ -0,0 +1,10 @@ +package wasmcloud:bus@1.0.0; + +interface lattice { + resource call-target-interface { + constructor(namespace: string, %package: string, %interface: string); + } + + set-link-name: func(name: string, interfaces: list); +} + diff --git a/wit/deps/wasmcloud-component-go-0.1.0/package.wit b/wit/deps/wasmcloud-component-go-0.1.0/package.wit new file mode 100644 index 0000000..75caf04 --- /dev/null +++ b/wit/deps/wasmcloud-component-go-0.1.0/package.wit @@ -0,0 +1,85 @@ +package wasmcloud:component-go@0.1.0; + +world exports { + import wasi:io/poll@0.2.0; + import wasi:clocks/monotonic-clock@0.2.0; + import wasi:io/error@0.2.0; + import wasi:io/streams@0.2.0; + import wasi:http/types@0.2.0; + + export wasi:http/incoming-handler@0.2.0; +} +world imports { + import wasi:logging/logging@0.1.0-draft; + import wasi:config/runtime@0.2.0-draft; + import wasi:io/poll@0.2.0; + import wasi:clocks/monotonic-clock@0.2.0; + import wasi:io/error@0.2.0; + import wasi:io/streams@0.2.0; + import wasi:http/types@0.2.0; + import wasi:http/outgoing-handler@0.2.0; + import wasmcloud:bus/lattice@1.0.0; + import wasmcloud:secrets/store@0.1.0-draft; + import wasmcloud:secrets/reveal@0.1.0-draft; + import wasi:cli/environment@0.2.0; + import wasi:cli/exit@0.2.0; + import wasi:cli/stdin@0.2.0; + import wasi:cli/stdout@0.2.0; + import wasi:cli/stderr@0.2.0; + import wasi:cli/terminal-input@0.2.0; + import wasi:cli/terminal-output@0.2.0; + import wasi:cli/terminal-stdin@0.2.0; + import wasi:cli/terminal-stdout@0.2.0; + import wasi:cli/terminal-stderr@0.2.0; + import wasi:clocks/wall-clock@0.2.0; + import wasi:filesystem/types@0.2.0; + import wasi:filesystem/preopens@0.2.0; + import wasi:sockets/network@0.2.0; + import wasi:sockets/instance-network@0.2.0; + import wasi:sockets/udp@0.2.0; + import wasi:sockets/udp-create-socket@0.2.0; + import wasi:sockets/tcp@0.2.0; + import wasi:sockets/tcp-create-socket@0.2.0; + import wasi:sockets/ip-name-lookup@0.2.0; + import wasi:random/random@0.2.0; + import wasi:random/insecure@0.2.0; + import wasi:random/insecure-seed@0.2.0; +} +world sdk { + import wasi:io/poll@0.2.0; + import wasi:clocks/monotonic-clock@0.2.0; + import wasi:io/error@0.2.0; + import wasi:io/streams@0.2.0; + import wasi:http/types@0.2.0; + import wasi:logging/logging@0.1.0-draft; + import wasi:config/runtime@0.2.0-draft; + import wasi:http/outgoing-handler@0.2.0; + import wasmcloud:bus/lattice@1.0.0; + import wasmcloud:secrets/store@0.1.0-draft; + import wasmcloud:secrets/reveal@0.1.0-draft; + import wasi:cli/environment@0.2.0; + import wasi:cli/exit@0.2.0; + import wasi:cli/stdin@0.2.0; + import wasi:cli/stdout@0.2.0; + import wasi:cli/stderr@0.2.0; + import wasi:cli/terminal-input@0.2.0; + import wasi:cli/terminal-output@0.2.0; + import wasi:cli/terminal-stdin@0.2.0; + import wasi:cli/terminal-stdout@0.2.0; + import wasi:cli/terminal-stderr@0.2.0; + import wasi:clocks/wall-clock@0.2.0; + import wasi:filesystem/types@0.2.0; + import wasi:filesystem/preopens@0.2.0; + import wasi:sockets/network@0.2.0; + import wasi:sockets/instance-network@0.2.0; + import wasi:sockets/udp@0.2.0; + import wasi:sockets/udp-create-socket@0.2.0; + import wasi:sockets/tcp@0.2.0; + import wasi:sockets/tcp-create-socket@0.2.0; + import wasi:sockets/ip-name-lookup@0.2.0; + import wasi:random/random@0.2.0; + import wasi:random/insecure@0.2.0; + import wasi:random/insecure-seed@0.2.0; + + export wasi:http/incoming-handler@0.2.0; +} diff --git a/wit/deps/wasmcloud-secrets-0.1.0-draft/package.wit b/wit/deps/wasmcloud-secrets-0.1.0-draft/package.wit new file mode 100644 index 0000000..3a93ea4 --- /dev/null +++ b/wit/deps/wasmcloud-secrets-0.1.0-draft/package.wit @@ -0,0 +1,25 @@ +package wasmcloud:secrets@0.1.0-draft; + +interface store { + variant secrets-error { + upstream(string), + io(string), + not-found, + } + + variant secret-value { + %string(string), + bytes(list), + } + + resource secret; + + get: func(key: string) -> result; +} + +interface reveal { + use store.{secret, secret-value}; + + reveal: func(s: borrow) -> secret-value; +} + diff --git a/wit/world.wit b/wit/world.wit new file mode 100644 index 0000000..f1bcb6a --- /dev/null +++ b/wit/world.wit @@ -0,0 +1,8 @@ +package wasmcloud:hello; + +world hello { + include wasmcloud:component-go/imports@0.1.0; + + export wasmcloud:messaging/handler@0.2.0; + import wasmcloud:messaging/consumer@0.2.0; +}