diff --git a/Cargo.lock b/Cargo.lock index 6c5ab8842f..8243a4ef26 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3516,6 +3516,7 @@ dependencies = [ "golem-wasm-ast", "golem-wasm-rpc", "golem-wasm-rpc-derive", + "heck", "http 1.3.1", "humantime-serde", "iso8601-timestamp", @@ -3554,6 +3555,8 @@ dependencies = [ "url", "uuid", "wasmtime", + "wasmtime-wasi", + "wit-parser 0.235.0", ] [[package]] @@ -3658,6 +3661,7 @@ dependencies = [ "gethostname 0.5.0", "golem-api-grpc", "golem-common", + "golem-rib", "golem-service-base", "golem-test-framework", "golem-wasm-ast", @@ -3985,7 +3989,7 @@ dependencies = [ "wasmparser 0.227.1", "wasmprinter 0.219.2", "wit-component", - "wit-parser", + "wit-parser 0.235.0", ] [[package]] @@ -9861,6 +9865,16 @@ dependencies = [ "wasmparser 0.232.0", ] +[[package]] +name = "wasm-encoder" +version = "0.235.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3bc393c395cb621367ff02d854179882b9a351b4e0c93d1397e6090b53a5c2a" +dependencies = [ + "leb128fmt", + "wasmparser 0.235.0", +] + [[package]] name = "wasm-metadata" version = "0.202.0" @@ -9898,14 +9912,14 @@ dependencies = [ [[package]] name = "wasm-metadata" -version = "0.229.0" +version = "0.235.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78fdb7d29a79191ab363dc90c1ddd3a1e880ffd5348d92d48482393a9e6c5f4d" +checksum = "b055604ba04189d54b8c0ab2c2fc98848f208e103882d5c0b984f045d5ea4d20" dependencies = [ "anyhow", "indexmap 2.10.0", - "wasm-encoder 0.229.0", - "wasmparser 0.229.0", + "wasm-encoder 0.235.0", + "wasmparser 0.235.0", ] [[package]] @@ -9923,14 +9937,14 @@ dependencies = [ [[package]] name = "wasm-wave" -version = "0.229.0" +version = "0.235.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd33c30a68c41ff354d7b3741f5d2d3dfbf8eb52033176bb01364cbdf016c17c" +checksum = "034bc908dc5c1257ffc63b42c7ac7039092bd369e858c5e78e3242b662a8b7d1" dependencies = [ "indexmap 2.10.0", "logos", "thiserror 1.0.69", - "wit-parser", + "wit-parser 0.235.0", ] [[package]] @@ -9991,6 +10005,18 @@ dependencies = [ "semver", ] +[[package]] +name = "wasmparser" +version = "0.235.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "161296c618fa2d63f6ed5fffd1112937e803cb9ec71b32b01a76321555660917" +dependencies = [ + "bitflags 2.9.1", + "hashbrown 0.15.3", + "indexmap 2.10.0", + "semver", +] + [[package]] name = "wasmprinter" version = "0.219.2" @@ -10107,7 +10133,7 @@ dependencies = [ "syn 2.0.101", "wasmtime-component-util", "wasmtime-wit-bindgen", - "wit-parser", + "wit-parser 0.229.0", ] [[package]] @@ -10313,7 +10339,7 @@ dependencies = [ "anyhow", "heck", "indexmap 2.10.0", - "wit-parser", + "wit-parser 0.229.0", ] [[package]] @@ -10967,9 +10993,9 @@ dependencies = [ [[package]] name = "wit-component" -version = "0.229.0" +version = "0.235.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f550067740e223bfe6c4878998e81cdbe2529dd9a793dc49248dd6613394e8b" +checksum = "64a57a11109cc553396f89f3a38a158a97d0b1adaec113bd73e0f64d30fb601f" dependencies = [ "anyhow", "bitflags 2.9.1", @@ -10978,10 +11004,10 @@ dependencies = [ "serde", "serde_derive", "serde_json", - "wasm-encoder 0.229.0", - "wasm-metadata 0.229.0", - "wasmparser 0.229.0", - "wit-parser", + "wasm-encoder 0.235.0", + "wasm-metadata 0.235.0", + "wasmparser 0.235.0", + "wit-parser 0.235.0", ] [[package]] @@ -11002,6 +11028,24 @@ dependencies = [ "wasmparser 0.229.0", ] +[[package]] +name = "wit-parser" +version = "0.235.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a1f95a87d03a33e259af286b857a95911eb46236a0f726cbaec1227b3dfc67a" +dependencies = [ + "anyhow", + "id-arena", + "indexmap 2.10.0", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.235.0", +] + [[package]] name = "witx" version = "0.9.1" diff --git a/Cargo.toml b/Cargo.toml index a15fef64d7..4cbdb9afe4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -138,6 +138,7 @@ futures = "0.3.31" futures-concurrency = "7.6.3" gethostname = "0.5.0" headers = "0.4.0" +heck = "0.5.0" hex = "0.4.3" http = "1.3.1" http-body = "1.0.1" @@ -285,13 +286,13 @@ url = { version = "2.5.4", features = ["serde"] } urlencoding = "2.1.3" uuid = { version = "1.15.1", features = ["serde", "v4", "v5"] } wac-graph = "=0.6.1" -wasm-wave = "0.229" +wasm-wave = "0.235" wasmtime = { version = "=33.0.0", features = ["component-model"] } wasmtime-wasi = { version = "=33.0.0" } wasmtime-wasi-http = { version = "=33.0.0" } webpki-roots = { version = "0.26.7" } -wit-component = "0.229" -wit-parser = "0.229" +wit-component = "0.235" +wit-parser = "0.235" x509-certificate = "0.23.1" [patch.crates-io] diff --git a/golem-api-grpc/proto/golem/component/agent.proto b/golem-api-grpc/proto/golem/component/agent.proto index 43ef48c69d..0567352bb2 100644 --- a/golem-api-grpc/proto/golem/component/agent.proto +++ b/golem-api-grpc/proto/golem/component/agent.proto @@ -1,6 +1,7 @@ syntax = "proto3"; import "wasm/ast/type.proto"; +import "wasm/rpc/value_and_type.proto"; package golem.component; @@ -77,3 +78,55 @@ message TextDescriptor { message TextType { string language_code = 1; } + +message DataValue { + oneof value { + TupleValue tuple = 1; + MultimodalValue multimodal = 2; + } +} + +message TupleValue { + repeated ElementValue elements = 1; +} + +message MultimodalValue { + repeated NamedElementValue elements = 1; +} + +message NamedElementValue { + string name = 1; + ElementValue value = 2; +} + +message ElementValue { + oneof value { + wasm.rpc.ValueAndType component_model = 1; + TextReference unstructured_text = 2; + BinaryReference unstructured_binary = 3; + } +} + +message TextReference { + oneof text { + string url = 1; + TextSource inline = 2; + } +} + +message TextSource { + string data = 1; + optional TextType text_type = 2; +} + +message BinaryReference { + oneof binary { + string url = 1; + BinarySource inline = 2; + } +} + +message BinarySource { + bytes data = 1; + optional BinaryType binary_type = 2; +} \ No newline at end of file diff --git a/golem-api-grpc/proto/golem/worker/public_oplog.proto b/golem-api-grpc/proto/golem/worker/public_oplog.proto index 1be4387ae3..2d88ef3c17 100644 --- a/golem-api-grpc/proto/golem/worker/public_oplog.proto +++ b/golem-api-grpc/proto/golem/worker/public_oplog.proto @@ -6,6 +6,7 @@ import "golem/common/account_id.proto"; import "golem/common/empty.proto"; import "golem/common/plugin_installation_id.proto"; import "golem/common/project_id.proto"; +import "golem/component/agent.proto"; import "golem/worker/idempotency_key.proto"; import "golem/worker/invocation_context.proto"; import "golem/worker/worker_id.proto"; @@ -48,6 +49,8 @@ message OplogEntry { FinishSpanParameters FinishSpan = 31; SetSpanAttributeParameters SetSpanAttribute = 32; ChangePersistenceLevelParameters ChangePersistenceLevel = 33; + CreateAgentInstanceParameters CreateAgentInstance = 34; + DropAgentInstanceParameters DropAgentInstance = 35; } } @@ -204,11 +207,15 @@ message GrowMemoryParameters { message CreateResourceParameters { google.protobuf.Timestamp timestamp = 1; uint64 resource_id = 2; + string name = 3; + string owner = 4; } message DropResourceParameters { google.protobuf.Timestamp timestamp = 1; uint64 resource_id = 2; + string name = 3; + string owner = 4; } message DescribeResourceParameters { @@ -216,6 +223,7 @@ message DescribeResourceParameters { uint64 resource_id = 2; string resource_name = 3; repeated wasm.rpc.ValueAndType resource_params = 4; + string resource_owner = 5; } message TimestampParameter { @@ -265,7 +273,20 @@ message SetSpanAttributeParameters { message ChangePersistenceLevelParameters { google.protobuf.Timestamp timestamp = 1; - PersistenceLevel persistence_level = 3; + PersistenceLevel persistence_level = 2; +} + +message CreateAgentInstanceParameters { + google.protobuf.Timestamp timestamp = 1; + string agent_type = 2; + string agent_id = 3; + golem.component.DataValue agent_parameters = 4; +} + +message DropAgentInstanceParameters { + google.protobuf.Timestamp timestamp = 1; + string agent_type = 2; + string agent_id = 3; } enum OplogLogLevel { @@ -292,7 +313,7 @@ message OplogEntryWithIndex { } enum PersistenceLevel { - PERSIST_NOTHING = 0; - PERSIST_REMOTE_SIDE_EFFECTS = 1; - SMART = 2; + PERSIST_NOTHING = 0; + PERSIST_REMOTE_SIDE_EFFECTS = 1; + SMART = 2; } diff --git a/golem-api-grpc/proto/golem/worker/worker_metadata.proto b/golem-api-grpc/proto/golem/worker/worker_metadata.proto index 3bf6b874a0..8d4b484c9f 100644 --- a/golem-api-grpc/proto/golem/worker/worker_metadata.proto +++ b/golem-api-grpc/proto/golem/worker/worker_metadata.proto @@ -5,10 +5,12 @@ package golem.worker; import "golem/common/account_id.proto"; import "golem/common/project_id.proto"; import "golem/common/plugin_installation_id.proto"; +import "golem/component/agent.proto"; import "golem/worker/worker_id.proto"; import "golem/worker/worker_status.proto"; import "golem/worker/wasi_config_vars.proto"; import "google/protobuf/timestamp.proto"; +import "wasm/rpc/value_and_type.proto"; message WorkerMetadata { WorkerId worker_id = 1; @@ -24,7 +26,7 @@ message WorkerMetadata { optional string last_error = 11; uint64 component_size = 12; uint64 total_linear_memory_size = 13; - map owned_resources = 14; + repeated ResourceDescription owned_resources = 14; repeated golem.common.PluginInstallationId active_plugins = 15; repeated OplogRegion skipped_regions = 16; repeated OplogRegion deleted_regions = 17; @@ -52,14 +54,33 @@ message FailedUpdate { message SuccessfulUpdate { } -message ResourceMetadata { +message ExportedResourceInstanceDescription { google.protobuf.Timestamp created_at = 1; - optional IndexedResourceMetadata indexed = 2; + uint64 resource_id = 2; + string resource_owner = 3; + string resource_name = 4; + bool is_indexed = 5; + repeated string resource_params = 6; +} + +message AgentInstanceDescription { + google.protobuf.Timestamp created_at = 1; + string agent_type = 2; + string agent_id = 3; + golem.component.DataValue agent_parameters = 4; +} + +message ResourceDescription { + oneof description { + ExportedResourceInstanceDescription exported_resource_instance = 1; + AgentInstanceDescription agent_instance = 2; + } } message IndexedResourceMetadata { string resource_name = 1; repeated string resource_params = 2; + string resource_owner = 3; } message OplogRegion { diff --git a/golem-client/build.rs b/golem-client/build.rs index cff8418c76..34fc1ad77e 100644 --- a/golem-client/build.rs +++ b/golem-client/build.rs @@ -37,6 +37,11 @@ fn generate(yaml_path: PathBuf, out_dir: OsString) { true, &[ ("AgentType", "golem_common::model::agent::AgentType"), + ("AgentInstanceKey", "golem_common::model::AgentInstanceKey"), + ( + "AgentInstanceDescription", + "golem_common::model::AgentInstanceDescription", + ), ("AnalysedExport", "golem_wasm_ast::analysis::AnalysedExport"), ("AnalysedType", "golem_wasm_ast::analysis::AnalysedType"), ("PluginScope", "golem_common::model::plugin::PluginScope"), @@ -49,6 +54,7 @@ fn generate(yaml_path: PathBuf, out_dir: OsString) { "golem_common::model::ComponentFilePathWithPermissionsList", ), ("ComponentType", "golem_common::model::ComponentType"), + ("DataValue", "golem_common::model::agent::DataValue"), ("Empty", "golem_common::model::Empty"), ( "InitialComponentFile", @@ -56,6 +62,14 @@ fn generate(yaml_path: PathBuf, out_dir: OsString) { ), ("ErrorBody", "golem_common::model::error::ErrorBody"), ("ErrorsBody", "golem_common::model::error::ErrorsBody"), + ( + "ExportedResourceInstanceKey", + "golem_common::model::ExportedResourceInstanceKey", + ), + ( + "ExportedResourceInstanceDescription", + "golem_common::model::ExportedResourceInstanceDescription", + ), ("GolemError", "golem_common::model::error::GolemError"), ( "PluginInstallationAction", @@ -103,6 +117,10 @@ fn generate(yaml_path: PathBuf, out_dir: OsString) { "WorkerBindingType", "golem_common::model::WorkerBindingType", ), + ( + "WorkerResourceDescription", + "golem_common::model::WorkerResourceDescription", + ), ("WorkerStatus", "golem_common::model::WorkerStatus"), ], &["/v1/components/{component_id}/workers/{worker_name}/connect"], diff --git a/golem-common/Cargo.toml b/golem-common/Cargo.toml index 88281b1c2c..d6e491f479 100644 --- a/golem-common/Cargo.toml +++ b/golem-common/Cargo.toml @@ -25,6 +25,7 @@ default = [ "tokio", ] +agent-extraction = ["dep:wasmtime-wasi", "dep:wit-parser"] base-model = [] config = ["model", "dep:figment"] model = [ @@ -110,6 +111,7 @@ dashmap = { workspace = true } derive_more = { workspace = true } figment = { workspace = true, optional = true } fred = { workspace = true, optional = true } +heck = { workspace = true } http = { workspace = true } humantime-serde = { workspace = true } iso8601-timestamp = { workspace = true } @@ -146,6 +148,8 @@ typed-path = { workspace = true } url = { workspace = true } uuid = { workspace = true } wasmtime = { workspace = true, optional = true } +wasmtime-wasi = { workspace = true, optional = true } +wit-parser = { workspace = true, optional = true } [dev-dependencies] anyhow = { workspace = true } diff --git a/golem-common/src/model/agent/conversions.rs b/golem-common/src/model/agent/conversions.rs index d10d3d8edb..483225ff85 100644 --- a/golem-common/src/model/agent/conversions.rs +++ b/golem-common/src/model/agent/conversions.rs @@ -15,9 +15,11 @@ use crate::model::agent::{ AgentConstructor, AgentDependency, AgentError, AgentMethod, AgentType, BinaryDescriptor, BinaryReference, BinarySource, BinaryType, DataSchema, DataValue, ElementSchema, ElementValue, - NamedElementSchema, NamedElementSchemas, NamedElementValue, TextDescriptor, TextReference, - TextSource, TextType, + ElementValues, NamedElementSchema, NamedElementSchemas, NamedElementValue, NamedElementValues, + TextDescriptor, TextReference, TextSource, TextType, Url, }; +use golem_wasm_ast::analysis::AnalysedType; +use golem_wasm_rpc::{Value, ValueAndType}; impl From for AgentConstructor { fn from(value: crate::model::agent::bindings::golem::agent::common::AgentConstructor) -> Self { @@ -79,7 +81,7 @@ impl From for AgentError { msg, ) => AgentError::InvalidAgentId(msg), crate::model::agent::bindings::golem::agent::common::AgentError::CustomError(value) => { - AgentError::CustomError(DataValue::from(value)) + AgentError::CustomError(value.into()) } } } @@ -215,20 +217,48 @@ impl From for super::bindings::golem::agent::common::DataSchema { } } -impl From for DataValue { - fn from(value: crate::model::agent::bindings::golem::agent::common::DataValue) -> Self { - match value { - crate::model::agent::bindings::golem::agent::common::DataValue::Tuple(tuple) => { - DataValue::Tuple(tuple.into_iter().map(ElementValue::from).collect()) +impl DataValue { + pub fn try_from_bindings( + value: crate::model::agent::bindings::golem::agent::common::DataValue, + schema: crate::model::agent::bindings::golem::agent::common::DataSchema, + ) -> Result { + match (value, schema) { + ( + crate::model::agent::bindings::golem::agent::common::DataValue::Tuple(tuple), + crate::model::agent::bindings::golem::agent::common::DataSchema::Tuple(schema), + ) => { + if tuple.len() != schema.len() { + return Err("Tuple length mismatch".to_string()); + } + Ok(DataValue::Tuple(ElementValues { + elements: tuple + .into_iter() + .zip(schema) + .map(|(value, schema)| ElementValue::try_from_bindings(value, schema.1)) + .collect::, _>>()?, + })) + } + ( + crate::model::agent::bindings::golem::agent::common::DataValue::Multimodal( + multimodal, + ), + crate::model::agent::bindings::golem::agent::common::DataSchema::Multimodal(schema), + ) => { + if multimodal.len() != schema.len() { + return Err("Multimodal length mismatch".to_string()); + } + Ok(DataValue::Multimodal(NamedElementValues { + elements: multimodal + .into_iter() + .zip(schema) + .map(|((name, value), schema)| { + ElementValue::try_from_bindings(value, schema.1) + .map(|v| NamedElementValue { name, value: v }) + }) + .collect::, _>>()?, + })) } - crate::model::agent::bindings::golem::agent::common::DataValue::Multimodal( - multimodal, - ) => DataValue::Multimodal( - multimodal - .into_iter() - .map(NamedElementValue::from) - .collect(), - ), + _ => Err("Data value does not match schema".to_string()), } } } @@ -237,11 +267,12 @@ impl From for super::bindings::golem::agent::common::DataValue { fn from(value: DataValue) -> Self { match value { DataValue::Tuple(tuple) => super::bindings::golem::agent::common::DataValue::Tuple( - tuple.into_iter().map(ElementValue::into).collect(), + tuple.elements.into_iter().map(ElementValue::into).collect(), ), DataValue::Multimodal(multimodal) => { super::bindings::golem::agent::common::DataValue::Multimodal( multimodal + .elements .into_iter() .map(|v| (v.name, ElementValue::into(v.value))) .collect(), @@ -287,32 +318,33 @@ impl From for super::bindings::golem::agent::common::ElementSchem } } -impl From<(String, super::bindings::golem::agent::common::ElementValue)> for NamedElementValue { - fn from( - value: ( - String, - crate::model::agent::bindings::golem::agent::common::ElementValue, - ), - ) -> Self { - Self { - name: value.0, - value: ElementValue::from(value.1), - } - } -} - -impl From for ElementValue { - fn from(value: crate::model::agent::bindings::golem::agent::common::ElementValue) -> Self { - match value { - crate::model::agent::bindings::golem::agent::common::ElementValue::ComponentModel(wit_value) => { - ElementValue::ComponentModel(wit_value.into()) +impl ElementValue { + pub fn try_from_bindings( + value: crate::model::agent::bindings::golem::agent::common::ElementValue, + schema: crate::model::agent::bindings::golem::agent::common::ElementSchema, + ) -> Result { + match (value, schema) { + ( + crate::model::agent::bindings::golem::agent::common::ElementValue::ComponentModel(wit_value), + crate::model::agent::bindings::golem::agent::common::ElementSchema::ComponentModel(wit_schema), + ) => { + let val: Value = wit_value.into(); + let typ: AnalysedType = wit_schema.into(); + Ok(ElementValue::ComponentModel(ValueAndType::new(val, typ))) } - crate::model::agent::bindings::golem::agent::common::ElementValue::UnstructuredText(text) => { - ElementValue::UnstructuredText(text.into()) + ( + crate::model::agent::bindings::golem::agent::common::ElementValue::UnstructuredText(text), + crate::model::agent::bindings::golem::agent::common::ElementSchema::UnstructuredText(_), + ) => { + Ok(ElementValue::UnstructuredText(text.into())) } - crate::model::agent::bindings::golem::agent::common::ElementValue::UnstructuredBinary(binary) => { - ElementValue::UnstructuredBinary(binary.into()) + ( + crate::model::agent::bindings::golem::agent::common::ElementValue::UnstructuredBinary(binary), + crate::model::agent::bindings::golem::agent::common::ElementSchema::UnstructuredBinary(_), + ) => { + Ok(ElementValue::UnstructuredBinary(binary.into())) } + _ => Err("Element value does not match schema".to_string()), } } } @@ -363,7 +395,7 @@ impl From for BinaryRefe fn from(value: crate::model::agent::bindings::golem::agent::common::BinaryReference) -> Self { match value { crate::model::agent::bindings::golem::agent::common::BinaryReference::Url(url) => { - BinaryReference::Url(url) + BinaryReference::Url(Url { value: url }) } crate::model::agent::bindings::golem::agent::common::BinaryReference::Inline( source, @@ -376,7 +408,7 @@ impl From for super::bindings::golem::agent::common::BinaryRefe fn from(value: BinaryReference) -> Self { match value { BinaryReference::Url(url) => { - super::bindings::golem::agent::common::BinaryReference::Url(url) + super::bindings::golem::agent::common::BinaryReference::Url(url.value) } BinaryReference::Inline(source) => { super::bindings::golem::agent::common::BinaryReference::Inline(source.into()) @@ -445,7 +477,7 @@ impl From for TextReferenc fn from(value: crate::model::agent::bindings::golem::agent::common::TextReference) -> Self { match value { crate::model::agent::bindings::golem::agent::common::TextReference::Url(url) => { - TextReference::Url(url) + TextReference::Url(Url { value: url }) } crate::model::agent::bindings::golem::agent::common::TextReference::Inline(source) => { TextReference::Inline(source.into()) @@ -458,7 +490,7 @@ impl From for super::bindings::golem::agent::common::TextReferenc fn from(value: TextReference) -> Self { match value { TextReference::Url(url) => { - super::bindings::golem::agent::common::TextReference::Url(url) + super::bindings::golem::agent::common::TextReference::Url(url.value) } TextReference::Inline(source) => { super::bindings::golem::agent::common::TextReference::Inline(source.into()) diff --git a/golem-common/src/model/agent/extraction.rs b/golem-common/src/model/agent/extraction.rs new file mode 100644 index 0000000000..fccbad9859 --- /dev/null +++ b/golem-common/src/model/agent/extraction.rs @@ -0,0 +1,283 @@ +// Copyright 2024-2025 Golem Cloud +// +// Licensed under the Golem Source License v1.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::model::agent::AgentType; +use anyhow::anyhow; +use rib::ParsedFunctionName; +use std::path::Path; +use std::sync::{Arc, Mutex}; +use tracing::{debug, error}; +use wasmtime::component::types::{ComponentInstance, ComponentItem}; +use wasmtime::component::{ + Component, Func, Instance, Linker, LinkerInstance, ResourceTable, ResourceType, Type, +}; +use wasmtime::{AsContextMut, Engine, Store}; +use wasmtime_wasi::p2::{WasiCtx, WasiView}; +use wasmtime_wasi::{IoCtx, IoView}; +use wit_parser::{PackageId, Resolve, WorldItem}; + +const INTERFACE_NAME: &str = "golem:agent/guest"; +const FUNCTION_NAME: &str = "discover-agent-types"; + +/// Extracts the implemented agent types from the given WASM component, assuming it implements the `golem:agent/guest` interface. +/// If it does not, it fails. +pub async fn extract_agent_types(wasm_path: &Path) -> anyhow::Result> { + let mut config = wasmtime::Config::default(); + config.async_support(true); + config.wasm_component_model(true); + + let engine = Engine::new(&config)?; + let mut linker: Linker = Linker::new(&engine); + linker.allow_shadowing(true); + + wasmtime_wasi::p2::add_to_linker_with_options_async( + &mut linker, + &wasmtime_wasi::p2::bindings::LinkOptions::default(), + )?; + + let (wasi, io) = WasiCtx::builder().inherit_stdout().inherit_stderr().build(); + let host = Host { + table: Arc::new(Mutex::new(ResourceTable::new())), + wasi: Arc::new(Mutex::new(wasi)), + io: Arc::new(Mutex::new(io)), + }; + + let component = Component::from_file(&engine, wasm_path)?; + let mut store = Store::new(&engine, host); + + let mut linker_instance = linker.root(); + let component_type = component.component_type(); + for (name, item) in component_type.imports(&engine) { + let name = name.to_string(); + match item { + ComponentItem::ComponentFunc(_) => {} + ComponentItem::CoreFunc(_) => {} + ComponentItem::Module(_) => {} + ComponentItem::Component(_) => {} + ComponentItem::ComponentInstance(ref inst) => { + dynamic_import(&name, &engine, &mut linker_instance, inst)?; + } + ComponentItem::Type(_) => {} + ComponentItem::Resource(_) => {} + } + } + + debug!("Instantiating component"); + let instance = linker.instantiate_async(&mut store, &component).await?; + + let func = find_discover_function(&mut store, &instance)?; + let typed_func = func + .typed::<(), (Vec,)>( + &mut store, + )?; + let results = typed_func.call_async(&mut store, ()).await?; + typed_func.post_return_async(&mut store).await?; + + let agent_types = results.0.into_iter().map(AgentType::from).collect(); + debug!("Discovered agent types: {:#?}", agent_types); + Ok(agent_types) +} + +/// Checks if the given resolved component implements the `golem:agent/guest` interface. +pub fn is_agent( + resolve: &Resolve, + root_package_id: &PackageId, + world: Option<&str>, +) -> anyhow::Result { + let golem_agent_package = wit_parser::PackageName { + namespace: "golem".to_string(), + name: "agent".to_string(), + version: None, + }; + const GOLEM_AGENT_INTERFACE_NAME: &str = "guest"; + + let world_id = resolve.select_world(*root_package_id, world)?; + let world = resolve + .worlds + .get(world_id) + .ok_or_else(|| anyhow!("Could not get {world_id:?}"))?; + let world_name = &world.name; + for (key, item) in &world.exports { + if let WorldItem::Interface { id, .. } = &item { + let interface = resolve.interfaces.get(*id).ok_or_else(|| { + anyhow!("Could not get exported interface {key:?} exported from world {world_name}") + })?; + if let Some(interface_name) = interface.name.as_ref() { + if interface_name == GOLEM_AGENT_INTERFACE_NAME { + if let Some(package_id) = &interface.package { + let package = resolve.packages.get(*package_id).ok_or_else(|| { + anyhow!( + "Could not get owner package of exported interface {interface_name}" + ) + })?; + + if package.name == golem_agent_package { + return Ok(true); + } + } + } + } + } + } + + Ok(false) +} + +fn find_discover_function( + mut store: impl AsContextMut, + instance: &Instance, +) -> anyhow::Result { + let (_, exported_instance_id) = instance + .get_export(&mut store, None, INTERFACE_NAME) + .ok_or_else(|| anyhow!("Interface {INTERFACE_NAME} not found"))?; + let (_, func_id) = instance + .get_export(&mut store, Some(&exported_instance_id), FUNCTION_NAME) + .ok_or_else(|| { + anyhow!("Function {FUNCTION_NAME} not found in interface {INTERFACE_NAME}") + })?; + let func = instance + .get_func(&mut store, func_id) + .ok_or_else(|| anyhow!("Function {FUNCTION_NAME} not found"))?; + + Ok(func) +} + +#[derive(Clone)] +struct Host { + pub table: Arc>, + pub wasi: Arc>, + pub io: Arc>, +} + +impl IoView for Host { + fn table(&mut self) -> &mut ResourceTable { + Arc::get_mut(&mut self.table) + .expect("ResourceTable is shared and cannot be borrowed mutably") + .get_mut() + .expect("ResourceTable mutex must never fail") + } + + fn io_ctx(&mut self) -> &mut IoCtx { + Arc::get_mut(&mut self.io) + .expect("IoCtx is shared and cannot be borrowed mutably") + .get_mut() + .expect("IoCtx mutex must never fail") + } +} + +impl WasiView for Host { + fn ctx(&mut self) -> &mut WasiCtx { + Arc::get_mut(&mut self.wasi) + .expect("WasiCtx is shared and cannot be borrowed mutably") + .get_mut() + .expect("WasiCtx mutex must never fail") + } +} + +fn dynamic_import( + name: &str, + engine: &Engine, + root: &mut LinkerInstance, + inst: &ComponentInstance, +) -> anyhow::Result<()> { + if name.starts_with("wasi:cli") + || name.starts_with("wasi:clocks") + || name.starts_with("wasi:filesystem") + || name.starts_with("wasi:io") + || name.starts_with("wasi:random") + || name.starts_with("wasi:sockets") + { + // These does not have to be mocked, we allow them through wasmtime-wasi + Ok(()) + } else { + let mut instance = root.instance(name)?; + let mut functions = Vec::new(); + + for (inner_name, inner_item) in inst.exports(engine) { + let name = name.to_owned(); + let inner_name = inner_name.to_owned(); + + match inner_item { + ComponentItem::ComponentFunc(fun) => { + let param_types: Vec = fun.params().map(|(_, t)| t).collect(); + let result_types: Vec = fun.results().collect(); + + let function_name = ParsedFunctionName::parse(format!( + "{name}.{{{inner_name}}}" + )) + .map_err(|err| anyhow!(format!("Unexpected linking error: {name}.{{{inner_name}}} is not a valid function name: {err}")))?; + + functions.push(FunctionInfo { + name: function_name, + params: param_types, + results: result_types, + }); + } + ComponentItem::CoreFunc(_) => {} + ComponentItem::Module(_) => {} + ComponentItem::Component(_) => {} + ComponentItem::ComponentInstance(_) => {} + ComponentItem::Type(_) => {} + ComponentItem::Resource(_resource) => { + if &inner_name != "pollable" + && &inner_name != "input-stream" + && &inner_name != "output-stream" + { + // TODO: figure out how to do this properly + instance.resource( + &inner_name, + ResourceType::host::(), + |_store, _rep| Ok(()), + )?; + } + } + } + } + + for function in functions { + instance.func_new_async( + &function.name.function.function_name(), + move |_store, _params, _results| { + let function_name = function.name.clone(); + Box::new(async move { + error!( + "External function called in get-agent-definitions: {function_name}", + ); + Err(anyhow!( + "External function called in get-agent-definitions: {function_name}" + )) + }) + }, + )?; + } + + Ok(()) + } +} + +#[allow(unused)] +struct MethodInfo { + method_name: String, + params: Vec, + results: Vec, +} + +#[allow(unused)] +struct FunctionInfo { + name: ParsedFunctionName, + params: Vec, + results: Vec, +} + +struct ResourceEntry; diff --git a/golem-common/src/model/agent/mod.rs b/golem-common/src/model/agent/mod.rs index 4cefc564f4..7968492cb1 100644 --- a/golem-common/src/model/agent/mod.rs +++ b/golem-common/src/model/agent/mod.rs @@ -14,6 +14,8 @@ mod conversions; +#[cfg(feature = "agent-extraction")] +pub mod extraction; #[cfg(feature = "protobuf")] mod protobuf; @@ -22,6 +24,7 @@ pub mod bindings { path: "wit", world: "golem-common", async: true, + trappable_imports: true, with: { "golem:rpc/types": golem_wasm_rpc::golem_rpc_0_2_x::types, }, @@ -30,11 +33,11 @@ pub mod bindings { } use bincode::{Decode, Encode}; +use golem_wasm_ast::analysis::analysed_type::{case, variant}; use golem_wasm_ast::analysis::AnalysedType; -use golem_wasm_rpc::Value; +use golem_wasm_rpc::{IntoValue, Value, ValueAndType}; use golem_wasm_rpc_derive::IntoValue; use serde::{Deserialize, Serialize}; - // NOTE: The primary reason for duplicating the model with handwritten Rust types is to avoid the need // to work with WitValue and WitType directly in the application code. Instead, we are converting them // to Value and AnalysedType which are much more ergonomic to work with. @@ -67,7 +70,7 @@ pub enum AgentError { InvalidMethod(String), InvalidType(String), InvalidAgentId(String), - CustomError(DataValue), + CustomError(ValueAndType), } #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode, IntoValue)] @@ -102,13 +105,16 @@ pub struct BinaryDescriptor { pub restrictions: Option>, } -#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Union))] +#[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] +#[serde(tag = "type")] pub enum BinaryReference { - Url(String), + Url(Url), Inline(BinarySource), } -#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] #[cfg_attr(feature = "poem", derive(poem_openapi::Object))] #[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] #[serde(rename_all = "camelCase")] @@ -151,21 +157,68 @@ pub enum DataSchema { Multimodal(NamedElementSchemas), } -#[derive(Debug, Clone, Encode, Decode, IntoValue)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Union))] +#[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] +#[serde(tag = "type")] pub enum DataValue { - Tuple(Vec), - Multimodal(Vec), + Tuple(ElementValues), + Multimodal(NamedElementValues), } -#[derive(Debug, Clone, Encode, Decode, IntoValue)] +impl IntoValue for DataValue { + fn into_value(self) -> Value { + match self { + DataValue::Tuple(elements) => Value::Variant { + case_idx: 0, + case_value: Some(Box::new(elements.elements.into_value())), + }, + DataValue::Multimodal(elements) => Value::Variant { + case_idx: 1, + case_value: Some(Box::new(elements.elements.into_value())), + }, + } + } + + fn get_type() -> AnalysedType { + variant(vec![ + case("tuple", Vec::::get_type()), + case("multimodal", Vec::::get_type()), + ]) + } +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] +pub struct ElementValues { + pub elements: Vec, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] +pub struct NamedElementValues { + pub elements: Vec, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] pub struct NamedElementValue { pub name: String, pub value: ElementValue, } -#[derive(Debug, Clone, Encode, Decode, IntoValue)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Union))] +#[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] +#[serde(tag = "type")] pub enum ElementValue { - ComponentModel(Value), + ComponentModel(ValueAndType), UnstructuredText(TextReference), UnstructuredBinary(BinaryReference), } @@ -188,13 +241,24 @@ pub struct TextDescriptor { pub restrictions: Option>, } -#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Union))] +#[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] +#[serde(tag = "type")] pub enum TextReference { - Url(String), + Url(Url), Inline(TextSource), } -#[derive(Debug, Clone, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] +pub struct Url { + pub value: String, +} + +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Encode, Decode, IntoValue)] #[cfg_attr(feature = "poem", derive(poem_openapi::Object))] #[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] #[serde(rename_all = "camelCase")] diff --git a/golem-common/src/model/agent/protobuf.rs b/golem-common/src/model/agent/protobuf.rs index 47a22bf690..7b336d1e90 100644 --- a/golem-common/src/model/agent/protobuf.rs +++ b/golem-common/src/model/agent/protobuf.rs @@ -1,9 +1,14 @@ use crate::model::agent::{ - AgentConstructor, AgentDependency, AgentMethod, AgentType, BinaryDescriptor, BinaryType, - DataSchema, ElementSchema, NamedElementSchema, NamedElementSchemas, TextDescriptor, TextType, + AgentConstructor, AgentDependency, AgentMethod, AgentType, BinaryDescriptor, BinaryReference, + BinarySource, BinaryType, DataSchema, DataValue, ElementSchema, ElementValue, ElementValues, + NamedElementSchema, NamedElementSchemas, NamedElementValue, NamedElementValues, TextDescriptor, + TextReference, TextSource, TextType, Url, }; use golem_api_grpc::proto::golem::component::data_schema; use golem_api_grpc::proto::golem::component::element_schema; +use golem_api_grpc::proto::golem::component::{ + binary_reference, data_value, element_value, text_reference, +}; impl TryFrom for AgentType { type Error = String; @@ -384,3 +389,248 @@ impl From for golem_api_grpc::proto::golem::component::BinaryType { } } } + +impl TryFrom for TextSource { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::TextSource, + ) -> Result { + Ok(TextSource { + data: value.data, + text_type: match value.text_type { + None => None, + Some(tt) => Some(tt.try_into()?), + }, + }) + } +} + +impl From for golem_api_grpc::proto::golem::component::TextSource { + fn from(value: TextSource) -> Self { + golem_api_grpc::proto::golem::component::TextSource { + data: value.data, + text_type: value.text_type.map(|tt| tt.into()), + } + } +} + +impl TryFrom for TextReference { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::TextReference, + ) -> Result { + match value.text { + None => Err("Missing field: text".to_string()), + Some(text) => match text { + text_reference::Text::Url(url) => Ok(TextReference::Url(Url { value: url })), + text_reference::Text::Inline(inline) => { + Ok(TextReference::Inline(inline.try_into()?)) + } + }, + } + } +} + +impl From for golem_api_grpc::proto::golem::component::TextReference { + fn from(value: TextReference) -> Self { + match value { + TextReference::Url(url) => golem_api_grpc::proto::golem::component::TextReference { + text: Some(text_reference::Text::Url(url.value)), + }, + TextReference::Inline(inline) => { + golem_api_grpc::proto::golem::component::TextReference { + text: Some(text_reference::Text::Inline(inline.into())), + } + } + } + } +} + +impl TryFrom for BinarySource { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::BinarySource, + ) -> Result { + Ok(BinarySource { + data: value.data, + binary_type: value + .binary_type + .ok_or_else(|| "Missing field: binary_type".to_string())? + .try_into()?, + }) + } +} + +impl From for golem_api_grpc::proto::golem::component::BinarySource { + fn from(value: BinarySource) -> Self { + golem_api_grpc::proto::golem::component::BinarySource { + data: value.data, + binary_type: Some(value.binary_type.into()), + } + } +} + +impl TryFrom for BinaryReference { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::BinaryReference, + ) -> Result { + match value.binary { + None => Err("Missing field: binary".to_string()), + Some(binary) => match binary { + binary_reference::Binary::Url(url) => Ok(BinaryReference::Url(Url { value: url })), + binary_reference::Binary::Inline(inline) => { + Ok(BinaryReference::Inline(inline.try_into()?)) + } + }, + } + } +} + +impl From for golem_api_grpc::proto::golem::component::BinaryReference { + fn from(value: BinaryReference) -> Self { + match value { + BinaryReference::Url(url) => golem_api_grpc::proto::golem::component::BinaryReference { + binary: Some(binary_reference::Binary::Url(url.value)), + }, + BinaryReference::Inline(inline) => { + golem_api_grpc::proto::golem::component::BinaryReference { + binary: Some(binary_reference::Binary::Inline(inline.into())), + } + } + } + } +} + +impl TryFrom for ElementValue { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::ElementValue, + ) -> Result { + match value.value { + None => Err("Missing field: value".to_string()), + Some(v) => match v { + element_value::Value::ComponentModel(val) => { + Ok(ElementValue::ComponentModel(val.try_into()?)) + } + element_value::Value::UnstructuredText(text_ref) => { + Ok(ElementValue::UnstructuredText(text_ref.try_into()?)) + } + element_value::Value::UnstructuredBinary(bin_ref) => { + Ok(ElementValue::UnstructuredBinary(bin_ref.try_into()?)) + } + }, + } + } +} + +impl From for golem_api_grpc::proto::golem::component::ElementValue { + fn from(value: ElementValue) -> Self { + match value { + ElementValue::ComponentModel(val) => { + golem_api_grpc::proto::golem::component::ElementValue { + value: Some(element_value::Value::ComponentModel(val.into())), + } + } + ElementValue::UnstructuredText(text_ref) => { + golem_api_grpc::proto::golem::component::ElementValue { + value: Some(element_value::Value::UnstructuredText(text_ref.into())), + } + } + ElementValue::UnstructuredBinary(bin_ref) => { + golem_api_grpc::proto::golem::component::ElementValue { + value: Some(element_value::Value::UnstructuredBinary(bin_ref.into())), + } + } + } + } +} + +impl TryFrom for NamedElementValue { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::NamedElementValue, + ) -> Result { + Ok(NamedElementValue { + name: value.name, + value: value + .value + .ok_or_else(|| "Missing field: value".to_string())? + .try_into()?, + }) + } +} + +impl From for golem_api_grpc::proto::golem::component::NamedElementValue { + fn from(value: NamedElementValue) -> Self { + golem_api_grpc::proto::golem::component::NamedElementValue { + name: value.name, + value: Some(value.value.into()), + } + } +} + +impl TryFrom for DataValue { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::component::DataValue, + ) -> Result { + match value.value { + None => Err("Missing field: value".to_string()), + Some(v) => match v { + data_value::Value::Tuple(tuple) => Ok(DataValue::Tuple(ElementValues { + elements: tuple + .elements + .into_iter() + .map(ElementValue::try_from) + .collect::, _>>()?, + })), + data_value::Value::Multimodal(mm) => { + Ok(DataValue::Multimodal(NamedElementValues { + elements: mm + .elements + .into_iter() + .map(NamedElementValue::try_from) + .collect::, _>>()?, + })) + } + }, + } + } +} + +impl From for golem_api_grpc::proto::golem::component::DataValue { + fn from(value: DataValue) -> Self { + match value { + DataValue::Tuple(elements) => golem_api_grpc::proto::golem::component::DataValue { + value: Some(data_value::Value::Tuple( + golem_api_grpc::proto::golem::component::TupleValue { + elements: elements + .elements + .into_iter() + .map(golem_api_grpc::proto::golem::component::ElementValue::from) + .collect(), + }, + )), + }, + DataValue::Multimodal(elements) => golem_api_grpc::proto::golem::component::DataValue { + value: Some(data_value::Value::Multimodal( + golem_api_grpc::proto::golem::component::MultimodalValue { + elements: elements + .elements + .into_iter() + .map(golem_api_grpc::proto::golem::component::NamedElementValue::from) + .collect(), + }, + )), + }, + } + } +} diff --git a/golem-common/src/model/component_metadata.rs b/golem-common/src/model/component_metadata.rs index 962de9356a..a079ed7866 100644 --- a/golem-common/src/model/component_metadata.rs +++ b/golem-common/src/model/component_metadata.rs @@ -12,13 +12,19 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crate::model::agent::AgentType; +use crate::model::agent::{AgentConstructor, AgentMethod, AgentType}; use crate::model::base64::Base64; use crate::model::ComponentType; use crate::{virtual_exports, SafeDisplay}; -use bincode::{Decode, Encode}; +use bincode::de::BorrowDecoder; +use bincode::enc::Encoder; +use bincode::error::{DecodeError, EncodeError}; +use bincode::{BorrowDecode, Decode, Encode}; use golem_wasm_ast::analysis::wit_parser::WitAnalysisContext; -use golem_wasm_ast::analysis::AnalysedFunctionParameter; +use golem_wasm_ast::analysis::{ + AnalysedFunctionParameter, AnalysedInstance, AnalysedResourceId, AnalysedResourceMode, + AnalysedType, TypeHandle, +}; use golem_wasm_ast::core::Mem; use golem_wasm_ast::metadata::Producers as WasmAstProducers; use golem_wasm_ast::{ @@ -26,16 +32,287 @@ use golem_wasm_ast::{ component::Component, IgnoreAllButMetadata, }; -use rib::ParsedFunctionSite; -use serde::{Deserialize, Serialize}; +use heck::ToKebabCase; +use poem_openapi::registry::{MetaSchemaRef, Registry}; +use poem_openapi::types::ParseResult; +use rib::{ParsedFunctionName, ParsedFunctionReference, ParsedFunctionSite, SemVer}; +use serde::{Deserialize, Serialize, Serializer}; +use serde_json::Value; +use std::borrow::Cow; use std::collections::HashMap; use std::fmt::{self, Debug, Display, Formatter}; +use std::sync::Arc; +use tokio::sync::Mutex; -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)] -#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] -#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] -#[serde(rename_all = "camelCase")] +#[derive(Clone, Default)] pub struct ComponentMetadata { + data: Arc, + cache: Arc>, +} + +impl ComponentMetadata { + pub fn analyse_component( + data: &[u8], + dynamic_linking: HashMap, + agent_types: Vec, + ) -> Result { + let raw = RawComponentMetadata::analyse_component(data)?; + Ok(Self { + data: Arc::new(raw.into_metadata(dynamic_linking, agent_types)), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } + + pub fn from_parts( + exports: Vec, + memories: Vec, + dynamic_linking: HashMap, + root_package_name: Option, + root_package_version: Option, + agent_types: Vec, + ) -> Self { + Self { + data: Arc::new(ComponentMetadataInnerData { + exports, + producers: vec![], + memories, + binary_wit: Base64(vec![]), + root_package_name, + root_package_version, + dynamic_linking, + agent_types, + }), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + } + } + + pub fn exports(&self) -> &[AnalysedExport] { + &self.data.exports + } + pub fn producers(&self) -> &[Producers] { + &self.data.producers + } + pub fn memories(&self) -> &[LinearMemory] { + &self.data.memories + } + pub fn binary_wit(&self) -> &Base64 { + &self.data.binary_wit + } + pub fn root_package_name(&self) -> &Option { + &self.data.root_package_name + } + pub fn root_package_version(&self) -> &Option { + &self.data.root_package_version + } + pub fn dynamic_linking(&self) -> &HashMap { + &self.data.dynamic_linking + } + pub fn agent_types(&self) -> &[AgentType] { + &self.data.agent_types + } + + pub async fn load_snapshot(&self) -> Result, String> { + self.cache.lock().await.load_snapshot(&self.data) + } + + pub async fn save_snapshot(&self) -> Result, String> { + self.cache.lock().await.save_snapshot(&self.data) + } + + pub async fn find_function(&self, name: &str) -> Result, String> { + self.cache.lock().await.find_function(&self.data, name) + } + + pub async fn find_parsed_function( + &self, + parsed: &ParsedFunctionName, + ) -> Result, String> { + self.cache + .lock() + .await + .find_parsed_function(&self.data, parsed) + } + + pub async fn find_agent_type(&self, agent_type: &str) -> Result, String> { + self.cache + .lock() + .await + .find_agent_type(&self.data, agent_type) + } +} + +impl Debug for ComponentMetadata { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.debug_struct("ComponentMetadata") + .field("exports", &self.data.exports) + .field("producers", &self.data.producers) + .field("memories", &self.data.memories) + .field("binary_wit_len", &self.data.binary_wit.len()) + .field("root_package_name", &self.data.root_package_name) + .field("root_package_version", &self.data.root_package_version) + .field("dynamic_linking", &self.data.dynamic_linking) + .field("agent_types", &self.data.agent_types) + .finish() + } +} + +impl PartialEq for ComponentMetadata { + fn eq(&self, other: &Self) -> bool { + self.data == other.data + } +} + +impl Eq for ComponentMetadata {} + +impl Serialize for ComponentMetadata { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.data.serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for ComponentMetadata { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let data = ComponentMetadataInnerData::deserialize(deserializer)?; + Ok(Self { + data: Arc::new(data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } +} + +impl Encode for ComponentMetadata { + fn encode(&self, encoder: &mut E) -> Result<(), EncodeError> { + self.data.encode(encoder) + } +} + +impl Decode for ComponentMetadata { + fn decode(decoder: &mut D) -> Result { + let data = ComponentMetadataInnerData::decode(decoder)?; + Ok(Self { + data: Arc::new(data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } +} + +impl<'de, Context> BorrowDecode<'de, Context> for ComponentMetadata { + fn borrow_decode>( + decoder: &mut D, + ) -> Result { + let data = ComponentMetadataInnerData::borrow_decode(decoder)?; + Ok(Self { + data: Arc::new(data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::Type for ComponentMetadata { + const IS_REQUIRED: bool = + ::IS_REQUIRED; + type RawValueType = ::RawValueType; + type RawElementValueType = + ::RawElementValueType; + + fn name() -> Cow<'static, str> { + ::name() + } + + fn schema_ref() -> MetaSchemaRef { + ::schema_ref() + } + + fn register(registry: &mut Registry) { + ::register(registry); + } + + fn as_raw_value(&self) -> Option<&Self::RawValueType> { + ::as_raw_value(&self.data) + } + + fn raw_element_iter<'a>( + &'a self, + ) -> Box + 'a> { + ::raw_element_iter(&self.data) + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::IsObjectType for ComponentMetadata {} + +#[cfg(feature = "poem")] +impl poem_openapi::types::ParseFromJSON for ComponentMetadata { + fn parse_from_json(value: Option) -> ParseResult { + let data = + ComponentMetadataInnerData::parse_from_json(value).map_err(|err| err.propagate())?; + Ok(Self { + data: Arc::new(data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::ToJSON for ComponentMetadata { + fn to_json(&self) -> Option { + self.data.to_json() + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::ParseFromXML for ComponentMetadata { + fn parse_from_xml(value: Option) -> ParseResult { + let data = + ComponentMetadataInnerData::parse_from_xml(value).map_err(|err| err.propagate())?; + Ok(Self { + data: Arc::new(data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::ToXML for ComponentMetadata { + fn to_xml(&self) -> Option { + self.data.to_xml() + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::ParseFromYAML for ComponentMetadata { + fn parse_from_yaml(value: Option) -> ParseResult { + let data = + ComponentMetadataInnerData::parse_from_yaml(value).map_err(|err| err.propagate())?; + Ok(Self { + data: Arc::new(data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } +} + +#[cfg(feature = "poem")] +impl poem_openapi::types::ToYAML for ComponentMetadata { + fn to_yaml(&self) -> Option { + self.data.to_yaml() + } +} + +#[derive(Clone, Default, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr( + feature = "poem", + oai(rename = "ComponentMetadata", rename_all = "camelCase") +)] +#[serde(rename = "ComponentMetadata", rename_all = "camelCase")] +pub struct ComponentMetadataInnerData { pub exports: Vec, pub producers: Vec, pub memories: Vec, @@ -51,31 +328,311 @@ pub struct ComponentMetadata { pub agent_types: Vec, } -impl ComponentMetadata { - pub fn analyse_component( - data: &[u8], - dynamic_linking: HashMap, - agent_types: Vec, - ) -> Result { - let raw = RawComponentMetadata::analyse_component(data)?; - Ok(raw.into_metadata(dynamic_linking, agent_types)) +impl ComponentMetadataInnerData { + pub fn load_snapshot(&self) -> Result, String> { + self.find_parsed_function_ignoring_version(&ParsedFunctionName::new( + ParsedFunctionSite::PackagedInterface { + namespace: "golem".to_string(), + package: "api".to_string(), + interface: "load-snapshot".to_string(), + version: None, + }, + ParsedFunctionReference::Function { + function: "load".to_string(), + }, + )) + } + + pub fn save_snapshot(&self) -> Result, String> { + self.find_parsed_function_ignoring_version(&ParsedFunctionName::new( + ParsedFunctionSite::PackagedInterface { + namespace: "golem".to_string(), + package: "api".to_string(), + interface: "save-snapshot".to_string(), + version: None, + }, + ParsedFunctionReference::Function { + function: "save".to_string(), + }, + )) + } + + pub fn find_function(&self, name: &str) -> Result, String> { + let parsed = ParsedFunctionName::parse(name)?; + self.find_parsed_function(&parsed) + } + + pub fn find_parsed_function( + &self, + parsed: &ParsedFunctionName, + ) -> Result, String> { + Ok(self + .find_analysed_function(parsed) + .map(|analysed_export| { + self.find_agent_method_or_constructor(parsed) + .map(|agent_method_or_constructor| { + (analysed_export, agent_method_or_constructor) + }) + }) + .transpose()? + .map( + |(analysed_export, agent_method_or_constructor)| InvokableFunction { + name: parsed.clone(), + analysed_export, + agent_method_or_constructor, + }, + )) + } + + pub fn find_agent_type(&self, agent_type: &str) -> Result, String> { + Ok(self + .agent_types + .iter() + .find(|t| t.type_name == agent_type) + .cloned()) + } + + /// Finds a function ignoring the function site's version. Returns None if it was not found. + fn find_parsed_function_ignoring_version( + &self, + name: &ParsedFunctionName, + ) -> Result, String> { + Ok(self + .exports + .iter() + .find_map(|export| { + if let AnalysedExport::Instance(instance) = export { + if let Ok(site) = ParsedFunctionSite::parse(&instance.name) { + if &site.unversioned() == name.site() { + Self::find_function_in_instance(name, instance) + .map(|func| (func, name.with_site(site))) + } else { + None + } + } else { + None + } + } else { + None + } + }) + .map(|(analysed_export, name)| { + self.find_agent_method_or_constructor(&name) + .map(|agent_method_or_constructor| { + (analysed_export, name, agent_method_or_constructor) + }) + }) + .transpose()? + .map( + |(analysed_export, name, agent_method_or_constructor)| InvokableFunction { + name, + analysed_export, + agent_method_or_constructor, + }, + )) + } + + fn find_analysed_function(&self, parsed: &ParsedFunctionName) -> Option { + match &parsed.site().interface_name() { + None => self.exports.iter().find_map(|f| match f { + AnalysedExport::Function(f) if f.name == parsed.function().function_name() => { + Some(f.clone()) + } + _ => None, + }), + Some(interface_name) => self + .exports + .iter() + .find_map(|instance| match instance { + AnalysedExport::Instance(inst) if inst.name == *interface_name => Some(inst), + _ => None, + }) + .and_then(|instance| Self::find_function_in_instance(parsed, instance)), + } + } + + fn find_function_in_instance( + parsed: &ParsedFunctionName, + instance: &AnalysedInstance, + ) -> Option { + match instance + .functions + .iter() + .find(|f| f.name == parsed.function().function_name()) + .cloned() + { + Some(function) => Some(function), + None => match parsed.method_as_static() { + Some(parsed_static) => instance + .functions + .iter() + .find(|f| f.name == parsed_static.function().function_name()) + .cloned(), + None => None, + }, + } + } + + fn find_agent_method_or_constructor( + &self, + parsed: &ParsedFunctionName, + ) -> Result, String> { + if let Some(root_package_name) = &self.root_package_name { + if let Some((root_namespace, root_package)) = root_package_name.split_once(':') { + let static_agent_interface = ParsedFunctionSite::PackagedInterface { + namespace: root_namespace.to_string(), + package: root_package.to_string(), + interface: "agent".to_string(), + version: self + .root_package_version + .as_ref() + .map(|v| SemVer::parse(v)) + .transpose()?, + }; + + if parsed.site() == &static_agent_interface { + if let Some(resource_name) = parsed.is_method() { + let agent = self + .agent_types + .iter() + .find(|agent| agent.type_name.to_kebab_case() == resource_name); + + let method = agent.and_then(|agent| { + agent + .methods + .iter() + .find(|method| { + method.name.to_kebab_case() == parsed.function().function_name() + }) + .cloned() + }); + + Ok(method.map(AgentMethodOrConstructor::Method)) + } else if let Some(resource_name) = parsed.is_static_method() { + if parsed.function().function_name() == "create" { + // this can be an agent constructor + let agent = self + .agent_types + .iter() + .find(|agent| agent.type_name.to_kebab_case() == resource_name); + + Ok(agent.map(|agent| { + AgentMethodOrConstructor::Constructor(agent.constructor.clone()) + })) + } else { + Ok(None) // Not the agent constructor + } + } else { + Ok(None) // Not a method or static method + } + } else { + Ok(None) // Not belonging to the static agent wrapper interface + } + } else { + Ok(None) // Not a valid root package name + } + } else { + Ok(None) // No root package name + } } } -impl Debug for ComponentMetadata { - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - f.debug_struct("ComponentMetadata") - .field("exports", &self.exports) - .field("producers", &self.producers) - .field("memories", &self.memories) - .field("binary_wit_len", &self.binary_wit.len()) - .field("root_package_name", &self.root_package_name) - .field("root_package_version", &self.root_package_version) - .field("dynamic_linking", &self.dynamic_linking) - .finish() +#[derive(Default)] +struct ComponentMetadataInnerCache { + load_snapshot: Option, String>>, + save_snapshot: Option, String>>, + functions_unparsed: HashMap, String>>, + functions_parsed: HashMap, String>>, + agent_types: HashMap, String>>, +} + +impl ComponentMetadataInnerCache { + pub fn load_snapshot( + &mut self, + data: &ComponentMetadataInnerData, + ) -> Result, String> { + if let Some(snapshot) = &self.load_snapshot { + snapshot.clone() + } else { + let result = data.load_snapshot(); + self.load_snapshot = Some(result.clone()); + result + } + } + + pub fn save_snapshot( + &mut self, + data: &ComponentMetadataInnerData, + ) -> Result, String> { + if let Some(snapshot) = &self.save_snapshot { + snapshot.clone() + } else { + let result = data.save_snapshot(); + self.save_snapshot = Some(result.clone()); + result + } + } + + pub fn find_function( + &mut self, + data: &ComponentMetadataInnerData, + name: &str, + ) -> Result, String> { + if let Some(cached) = self.functions_unparsed.get(name) { + cached.clone() + } else { + let parsed = ParsedFunctionName::parse(name)?; + let result = data.find_parsed_function(&parsed); + self.functions_unparsed + .insert(name.to_string(), result.clone()); + result + } + } + + pub fn find_parsed_function( + &mut self, + data: &ComponentMetadataInnerData, + parsed: &ParsedFunctionName, + ) -> Result, String> { + if let Some(cached) = self.functions_parsed.get(parsed) { + cached.clone() + } else { + let result = data.find_parsed_function(parsed); + self.functions_parsed.insert(parsed.clone(), result.clone()); + result + } + } + + pub fn find_agent_type( + &mut self, + data: &ComponentMetadataInnerData, + agent_type: &str, + ) -> Result, String> { + if let Some(cached) = self.agent_types.get(agent_type) { + cached.clone() + } else { + let result = data.find_agent_type(agent_type); + self.agent_types + .insert(agent_type.to_string(), result.clone()); + result + } } } +#[derive(Debug, Clone)] +pub enum AgentMethodOrConstructor { + Method(AgentMethod), + Constructor(AgentConstructor), +} + +/// Describes an exported function that can be invoked on a worker +#[derive(Debug, Clone)] +pub struct InvokableFunction { + pub name: ParsedFunctionName, + pub analysed_export: AnalysedFunction, + pub agent_method_or_constructor: Option, +} + #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)] #[cfg_attr(feature = "poem", derive(poem_openapi::Union))] #[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] @@ -187,7 +744,7 @@ impl From for LinearMemory { } } -// Metadata of Component in terms of golem_wasm_ast types +/// Metadata of Component in terms of golem_wasm_ast types #[derive(Default)] pub struct RawComponentMetadata { pub exports: Vec, @@ -255,7 +812,7 @@ impl RawComponentMetadata { self, dynamic_linking: HashMap, agent_types: Vec, - ) -> ComponentMetadata { + ) -> ComponentMetadataInnerData { let producers = self .producers .into_iter() @@ -266,7 +823,7 @@ impl RawComponentMetadata { let memories = self.memories.into_iter().map(LinearMemory::from).collect(); - ComponentMetadata { + ComponentMetadataInnerData { exports, producers, memories, @@ -362,48 +919,112 @@ impl Display for ComponentProcessingError { } } +fn collect_resource_types( + resource_types: &mut HashMap, + fun: &AnalysedFunction, +) { + if fun.is_constructor() { + if let AnalysedType::Handle(TypeHandle { + mode: AnalysedResourceMode::Owned, + resource_id, + .. + }) = &fun.result.as_ref().unwrap().typ + { + resource_types.insert(*resource_id, fun.clone()); + } + } else if fun.is_method() { + if let AnalysedType::Handle(TypeHandle { + mode: AnalysedResourceMode::Borrowed, + resource_id, + .. + }) = &fun.parameters[0].typ + { + resource_types.insert(*resource_id, fun.clone()); + } + } +} + fn add_resource_drops(exports: &mut Vec) { // Components are not exporting explicit drop functions for exported resources, but // worker executor does. So we keep golem-wasm-ast as a universal library and extend // its result with the explicit drops here, for each resource, identified by an exported // constructor. - let mut to_add = Vec::new(); + let mut top_level_resource_types = HashMap::new(); for export in exports.iter_mut() { match export { AnalysedExport::Function(fun) => { - if fun.is_constructor() { - to_add.push(AnalysedExport::Function(drop_from_constructor(fun))); - } + collect_resource_types(&mut top_level_resource_types, fun); } AnalysedExport::Instance(instance) => { - let mut to_add = Vec::new(); + let mut instance_resource_types = HashMap::new(); for fun in &instance.functions { - if fun.is_constructor() { - to_add.push(drop_from_constructor(fun)); - } + collect_resource_types(&mut instance_resource_types, fun); + } + + for fun in instance_resource_types.values() { + instance + .functions + .push(drop_from_constructor_or_method(fun)); } - instance.functions.extend(to_add.into_iter()); } } } - exports.extend(to_add); + for fun in top_level_resource_types.values() { + exports.push(AnalysedExport::Function(drop_from_constructor_or_method( + fun, + ))); + } } -fn drop_from_constructor(constructor: &AnalysedFunction) -> AnalysedFunction { - let drop_name = constructor.name.replace("[constructor]", "[drop]"); - AnalysedFunction { - name: drop_name, - parameters: constructor - .result - .iter() - .map(|result| AnalysedFunctionParameter { - name: "self".to_string(), - typ: result.typ.clone(), - }) - .collect(), - result: None, +fn drop_from_constructor_or_method(fun: &AnalysedFunction) -> AnalysedFunction { + if fun.is_constructor() { + let drop_name = fun.name.replace("[constructor]", "[drop]"); + AnalysedFunction { + name: drop_name, + parameters: fun + .result + .iter() + .map(|result| AnalysedFunctionParameter { + name: "self".to_string(), + typ: result.typ.clone(), + }) + .collect(), + result: None, + } + } else { + let name = fun.name.replace("[method]", "[drop]"); + let (drop_name, _) = name.split_once('.').unwrap(); + AnalysedFunction { + name: drop_name.to_string(), + parameters: fun + .parameters + .first() + .map(|param| AnalysedFunctionParameter { + name: "self".to_string(), + typ: { + let AnalysedType::Handle(TypeHandle { + mode: _, + resource_id, + name, + owner, + }) = ¶m.typ + else { + panic!("Expected handle type for resource drop") + }; + AnalysedType::Handle(TypeHandle { + mode: AnalysedResourceMode::Owned, + resource_id: *resource_id, + name: name.clone(), + owner: owner.clone(), + }) + }, + }) + .into_iter() + .collect(), + result: None, + } } } @@ -422,10 +1043,13 @@ fn add_virtual_exports(exports: &mut Vec) { mod protobuf { use crate::model::base64::Base64; use crate::model::component_metadata::{ - ComponentMetadata, DynamicLinkedInstance, DynamicLinkedWasmRpc, LinearMemory, - ProducerField, Producers, VersionedName, WasmRpcTarget, + ComponentMetadata, ComponentMetadataInnerCache, ComponentMetadataInnerData, + DynamicLinkedInstance, DynamicLinkedWasmRpc, LinearMemory, ProducerField, Producers, + VersionedName, WasmRpcTarget, }; use std::collections::HashMap; + use std::sync::Arc; + use tokio::sync::Mutex; impl From for VersionedName { fn from(value: golem_api_grpc::proto::golem::component::VersionedName) -> Self { @@ -500,6 +1124,22 @@ mod protobuf { impl TryFrom for ComponentMetadata { type Error = String; + fn try_from( + value: golem_api_grpc::proto::golem::component::ComponentMetadata, + ) -> Result { + let inner_data = ComponentMetadataInnerData::try_from(value)?; + Ok(Self { + data: Arc::new(inner_data), + cache: Arc::new(Mutex::new(ComponentMetadataInnerCache::default())), + }) + } + } + + impl TryFrom + for ComponentMetadataInnerData + { + type Error = String; + fn try_from( value: golem_api_grpc::proto::golem::component::ComponentMetadata, ) -> Result { @@ -538,6 +1178,14 @@ mod protobuf { impl From for golem_api_grpc::proto::golem::component::ComponentMetadata { fn from(value: ComponentMetadata) -> Self { + value.data.as_ref().clone().into() + } + } + + impl From + for golem_api_grpc::proto::golem::component::ComponentMetadata + { + fn from(value: ComponentMetadataInnerData) -> Self { Self { exports: value .exports diff --git a/golem-common/src/model/exports.rs b/golem-common/src/model/exports.rs index ee90c1ceaf..0f307f52f5 100644 --- a/golem-common/src/model/exports.rs +++ b/golem-common/src/model/exports.rs @@ -12,70 +12,10 @@ // See the License for the specific language governing permissions and // limitations under the License. -use golem_wasm_ast::analysis::{AnalysedExport, AnalysedFunction, AnalysedInstance}; +use golem_wasm_ast::analysis::{AnalysedExport, AnalysedFunction}; use rib::{ParsedFunctionName, ParsedFunctionReference, ParsedFunctionSite}; -fn instances(exports: &Vec) -> Vec { - let mut instances = vec![]; - for export in exports { - if let AnalysedExport::Instance(instance) = export { - instances.push(instance.clone()) - } - } - instances -} - -fn functions(exports: &Vec) -> Vec { - let mut functions = vec![]; - for export in exports { - if let AnalysedExport::Function(function) = export { - functions.push(function.clone()) - } - } - functions -} - -pub fn function_by_name( - exports: &Vec, - name: &str, -) -> Result, String> { - let parsed = ParsedFunctionName::parse(name)?; - - match &parsed.site().interface_name() { - None => Ok(functions(exports).iter().find(|f| f.name == *name).cloned()), - Some(interface_name) => { - let exported_function = instances(exports) - .iter() - .find(|instance| instance.name == *interface_name) - .and_then(|instance| { - instance - .functions - .iter() - .find(|f| f.name == parsed.function().function_name()) - .cloned() - }); - if exported_function.is_none() { - match parsed.method_as_static() { - Some(parsed_static) => Ok(instances(exports) - .iter() - .find(|instance| instance.name == *interface_name) - .and_then(|instance| { - instance - .functions - .iter() - .find(|f| f.name == parsed_static.function().function_name()) - .cloned() - })), - None => Ok(None), - } - } else { - Ok(exported_function) - } - } - } -} - pub fn find_resource_site( exports: &[AnalysedExport], resource_name: &str, diff --git a/golem-common/src/model/mod.rs b/golem-common/src/model/mod.rs index 787cbc0a86..78f2d3ca5d 100644 --- a/golem-common/src/model/mod.rs +++ b/golem-common/src/model/mod.rs @@ -43,8 +43,9 @@ pub mod trim_date; pub mod worker; pub use crate::base_model::*; +use crate::model::agent::DataValue; use crate::model::invocation_context::InvocationContextStack; -use crate::model::oplog::{IndexedResourceKey, TimestampedUpdateDescription, WorkerResourceId}; +use crate::model::oplog::{TimestampedUpdateDescription, WorkerResourceId}; use crate::model::regions::DeletedRegions; use bincode::de::{BorrowDecoder, Decoder}; use bincode::enc::Encoder; @@ -549,10 +550,10 @@ impl IntoValue for WorkerMetadata { self.worker_id.into_value(), self.args.into_value(), self.env.into_value(), + self.wasi_config_vars.into_value(), self.last_known_status.status.into_value(), self.last_known_status.component_version.into_value(), 0u64.into_value(), // retry count could be computed from the worker status record here but we don't support it yet - self.wasi_config_vars.into_value(), ]) } @@ -561,18 +562,124 @@ impl IntoValue for WorkerMetadata { field("worker-id", WorkerId::get_type()), field("args", list(str())), field("env", list(tuple(vec![str(), str()]))), + field("wasi-config-vars", HashMap::::get_type()), field("status", WorkerStatus::get_type()), field("component-version", u64()), field("retry-count", u64()), - field("wasi_config_vars", HashMap::::get_type()), ]) } } -#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode)] -pub struct WorkerResourceDescription { +#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Encode, Decode)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +pub struct ExportedResourceInstanceKey { + pub resource_id: WorkerResourceId, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +pub struct ExportedResourceInstanceDescription { pub created_at: Timestamp, - pub indexed_resource_key: Option, + pub resource_owner: String, + pub resource_name: String, + pub resource_params: Option>, +} + +#[derive( + Clone, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + Serialize, + Deserialize, + Encode, + Decode, + IntoValue, +)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +pub struct AgentInstanceKey { + pub agent_type: String, + pub agent_id: String, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +pub struct AgentInstanceDescription { + pub created_at: Timestamp, + pub agent_parameters: DataValue, +} + +#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Encode, Decode)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(feature = "poem", derive(poem_openapi::Union))] +#[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] +#[serde(tag = "type")] +pub enum WorkerResourceKey { + /// A living resource instance that has been returned through invocation + /// and can be referenced to from outside the worker + ExportedResourceInstanceKey(ExportedResourceInstanceKey), + /// An agent instance + AgentInstanceKey(AgentInstanceKey), +} + +impl Display for WorkerResourceKey { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + match self { + WorkerResourceKey::ExportedResourceInstanceKey(key) => { + write!(f, "resource({})", key.resource_id) + } + WorkerResourceKey::AgentInstanceKey(key) => { + write!(f, "agent({}, {})", key.agent_type, key.agent_id) + } + } + } +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)] +#[serde(rename_all = "camelCase")] +#[cfg_attr(feature = "poem", derive(poem_openapi::Union))] +#[cfg_attr(feature = "poem", oai(discriminator_name = "type", one_of = true))] +#[serde(tag = "type")] +pub enum WorkerResourceDescription { + /// A living resource instance that has been returned through invocation + /// and can be referenced to from outside the worker + ExportedResourceInstance(ExportedResourceInstanceDescription), + /// An agent instance + AgentInstance(AgentInstanceDescription), +} + +impl WorkerResourceDescription { + pub fn with_timestamp(&self, new_timestamp: Timestamp) -> Self { + match self { + WorkerResourceDescription::ExportedResourceInstance(desc) => { + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: new_timestamp, + resource_owner: desc.resource_owner.clone(), + resource_name: desc.resource_name.clone(), + resource_params: desc.resource_params.clone(), + }, + ) + } + WorkerResourceDescription::AgentInstance(desc) => { + WorkerResourceDescription::AgentInstance(AgentInstanceDescription { + created_at: new_timestamp, + agent_parameters: desc.agent_parameters.clone(), + }) + } + } + } } #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Encode, Decode)] @@ -605,7 +712,7 @@ pub struct WorkerStatusRecord { pub component_version: ComponentVersion, pub component_size: u64, pub total_linear_memory_size: u64, - pub owned_resources: HashMap, + pub owned_resources: HashMap, pub oplog_idx: OplogIndex, pub active_plugins: HashSet, pub deleted_regions: DeletedRegions, diff --git a/golem-common/src/model/oplog.rs b/golem-common/src/model/oplog.rs index 9847a2b20a..bd4526d8b7 100644 --- a/golem-common/src/model/oplog.rs +++ b/golem-common/src/model/oplog.rs @@ -13,11 +13,12 @@ // limitations under the License. pub use crate::base_model::OplogIndex; +use crate::model::agent::DataValue; use crate::model::invocation_context::{AttributeValue, InvocationContextSpan, SpanId, TraceId}; use crate::model::regions::OplogRegion; use crate::model::{ - AccountId, ComponentVersion, IdempotencyKey, PluginInstallationId, Timestamp, WorkerId, - WorkerInvocation, + AccountId, AgentInstanceKey, ComponentVersion, IdempotencyKey, PluginInstallationId, Timestamp, + WorkerId, WorkerInvocation, }; use crate::model::{ProjectId, RetryConfig}; use bincode::de::read::Reader; @@ -26,6 +27,7 @@ use bincode::enc::write::Writer; use bincode::enc::Encoder; use bincode::error::{DecodeError, EncodeError}; use bincode::{BorrowDecode, Decode, Encode}; +use golem_wasm_rpc::wasmtime::ResourceTypeId; use golem_wasm_rpc_derive::IntoValue; use nonempty_collections::NEVec; use serde::{Deserialize, Serialize}; @@ -198,6 +200,7 @@ impl Display for WorkerResourceId { #[derive(Debug, Clone, PartialEq, Eq, Hash, Encode, Decode)] pub struct IndexedResourceKey { + pub resource_owner: String, pub resource_name: String, pub resource_params: Vec, } @@ -358,17 +361,20 @@ pub enum OplogEntry { CreateResource { timestamp: Timestamp, id: WorkerResourceId, + resource_type_id: ResourceTypeId, }, /// Dropped a resource instance DropResource { timestamp: Timestamp, id: WorkerResourceId, + resource_type_id: ResourceTypeId, }, /// Adds additional information for a created resource instance DescribeResource { timestamp: Timestamp, id: WorkerResourceId, - indexed_resource: IndexedResourceKey, + resource_type_id: ResourceTypeId, + indexed_resource_parameters: Vec, }, /// The worker emitted a log message Log { @@ -464,6 +470,17 @@ pub enum OplogEntry { timestamp: Timestamp, level: PersistenceLevel, }, + /// Created an agent instance + CreateAgentInstance { + timestamp: Timestamp, + key: AgentInstanceKey, + parameters: DataValue, + }, + /// Dropped an agent instance + DropAgentInstance { + timestamp: Timestamp, + key: AgentInstanceKey, + }, } impl OplogEntry { @@ -609,28 +626,32 @@ impl OplogEntry { } } - pub fn create_resource(id: WorkerResourceId) -> OplogEntry { + pub fn create_resource(id: WorkerResourceId, resource_type_id: ResourceTypeId) -> OplogEntry { OplogEntry::CreateResource { timestamp: Timestamp::now_utc(), id, + resource_type_id, } } - pub fn drop_resource(id: WorkerResourceId) -> OplogEntry { + pub fn drop_resource(id: WorkerResourceId, resource_type_id: ResourceTypeId) -> OplogEntry { OplogEntry::DropResource { timestamp: Timestamp::now_utc(), id, + resource_type_id, } } pub fn describe_resource( id: WorkerResourceId, - indexed_resource: IndexedResourceKey, + resource_type_id: ResourceTypeId, + indexed_resource_parameters: Vec, ) -> OplogEntry { OplogEntry::DescribeResource { timestamp: Timestamp::now_utc(), id, - indexed_resource, + resource_type_id, + indexed_resource_parameters, } } @@ -716,6 +737,21 @@ impl OplogEntry { } } + pub fn create_agent_instance(key: AgentInstanceKey, parameters: DataValue) -> OplogEntry { + OplogEntry::CreateAgentInstance { + timestamp: Timestamp::now_utc(), + key, + parameters, + } + } + + pub fn drop_agent_instance(key: AgentInstanceKey) -> OplogEntry { + OplogEntry::DropAgentInstance { + timestamp: Timestamp::now_utc(), + key, + } + } + pub fn is_end_atomic_region(&self, idx: OplogIndex) -> bool { matches!(self, OplogEntry::EndAtomicRegion { begin_index, .. } if *begin_index == idx) } @@ -769,6 +805,8 @@ impl OplogEntry { | OplogEntry::DeactivatePlugin { .. } | OplogEntry::Revert { .. } | OplogEntry::CancelPendingInvocation { .. } + | OplogEntry::CreateAgentInstance { .. } + | OplogEntry::DropAgentInstance { .. } ) } @@ -806,7 +844,9 @@ impl OplogEntry { | OplogEntry::StartSpan { timestamp, .. } | OplogEntry::FinishSpan { timestamp, .. } | OplogEntry::SetSpanAttribute { timestamp, .. } - | OplogEntry::ChangePersistenceLevel { timestamp, .. } => *timestamp, + | OplogEntry::ChangePersistenceLevel { timestamp, .. } + | OplogEntry::CreateAgentInstance { timestamp, .. } + | OplogEntry::DropAgentInstance { timestamp, .. } => *timestamp, } } @@ -956,16 +996,22 @@ mod protobuf { golem_api_grpc::proto::golem::worker::IndexedResourceMetadata { resource_name: value.resource_name, resource_params: value.resource_params, + resource_owner: value.resource_owner, } } } - impl From for IndexedResourceKey { - fn from(value: golem_api_grpc::proto::golem::worker::IndexedResourceMetadata) -> Self { - IndexedResourceKey { + impl TryFrom for IndexedResourceKey { + type Error = String; + + fn try_from( + value: golem_api_grpc::proto::golem::worker::IndexedResourceMetadata, + ) -> Result { + Ok(IndexedResourceKey { + resource_owner: value.resource_owner, resource_name: value.resource_name, resource_params: value.resource_params, - } + }) } } diff --git a/golem-common/src/model/protobuf.rs b/golem-common/src/model/protobuf.rs index c6ae828b01..ba94f73b9b 100644 --- a/golem-common/src/model/protobuf.rs +++ b/golem-common/src/model/protobuf.rs @@ -12,8 +12,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -use super::WorkerWasiConfigVarsFilter; -use crate::model::oplog::OplogIndex; +use super::{ + AgentInstanceDescription, AgentInstanceKey, ExportedResourceInstanceDescription, + ExportedResourceInstanceKey, WorkerResourceDescription, WorkerResourceKey, + WorkerWasiConfigVarsFilter, +}; +use crate::model::oplog::{OplogIndex, WorkerResourceId}; use crate::model::{ AccountId, ComponentFilePath, ComponentFilePermissions, ComponentFileSystemNode, ComponentFileSystemNodeDetails, ComponentType, FilterComparator, IdempotencyKey, @@ -757,3 +761,97 @@ impl TryFrom for Component } } } + +pub fn to_protobuf_resource_description( + key: WorkerResourceKey, + description: WorkerResourceDescription, +) -> Result { + match (key, description) { + ( + WorkerResourceKey::ExportedResourceInstanceKey(key), + WorkerResourceDescription::ExportedResourceInstance(description), + ) => Ok(golem::worker::ResourceDescription { + description: Some( + golem::worker::resource_description::Description::ExportedResourceInstance( + golem::worker::ExportedResourceInstanceDescription { + created_at: Some(description.created_at.into()), + resource_id: key.resource_id.0, + resource_owner: description.resource_owner, + resource_name: description.resource_name, + is_indexed: description.resource_params.is_some(), + resource_params: description.resource_params.unwrap_or_default(), + }, + ), + ), + }), + ( + WorkerResourceKey::AgentInstanceKey(key), + WorkerResourceDescription::AgentInstance(description), + ) => Ok(golem::worker::ResourceDescription { + description: Some( + golem::worker::resource_description::Description::AgentInstance( + golem::worker::AgentInstanceDescription { + created_at: Some(description.created_at.into()), + agent_type: key.agent_type, + agent_id: key.agent_id, + agent_parameters: Some(description.agent_parameters.into()), + }, + ), + ), + }), + _ => Err("Invalid key/description combination".to_string()), + } +} + +pub fn from_protobuf_resource_description( + description: golem::worker::ResourceDescription, +) -> Result<(WorkerResourceKey, WorkerResourceDescription), String> { + match description.description { + Some(golem::worker::resource_description::Description::ExportedResourceInstance( + golem::worker::ExportedResourceInstanceDescription { + created_at, + resource_id, + resource_owner, + resource_name, + is_indexed, + resource_params, + }, + )) => Ok(( + WorkerResourceKey::ExportedResourceInstanceKey(ExportedResourceInstanceKey { + resource_id: WorkerResourceId(resource_id), + }), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: created_at.ok_or("Missing created_at")?.into(), + resource_owner, + resource_name, + resource_params: if is_indexed { + Some(resource_params) + } else { + None + }, + }, + ), + )), + Some(golem::worker::resource_description::Description::AgentInstance( + golem::worker::AgentInstanceDescription { + created_at, + agent_type, + agent_id, + agent_parameters, + }, + )) => Ok(( + WorkerResourceKey::AgentInstanceKey(AgentInstanceKey { + agent_type, + agent_id, + }), + WorkerResourceDescription::AgentInstance(AgentInstanceDescription { + created_at: created_at.ok_or("Missing created_at")?.into(), + agent_parameters: agent_parameters + .ok_or("Missing agent_parameters")? + .try_into()?, + }), + )), + None => Err("Missing description".to_string()), + } +} diff --git a/golem-common/src/model/public_oplog/mod.rs b/golem-common/src/model/public_oplog/mod.rs index 64f32e3e72..ee1cc8110a 100644 --- a/golem-common/src/model/public_oplog/mod.rs +++ b/golem-common/src/model/public_oplog/mod.rs @@ -20,6 +20,7 @@ mod tests; use super::plugin::PluginDefinition; use super::worker::WasiConfigVars; +use crate::model::agent::DataValue; use crate::model::invocation_context::{AttributeValue, SpanId, TraceId}; use crate::model::lucene::{LeafQuery, Query}; use crate::model::oplog::{ @@ -28,7 +29,8 @@ use crate::model::oplog::{ use crate::model::plugin::PluginInstallation; use crate::model::regions::OplogRegion; use crate::model::{ - AccountId, ComponentVersion, Empty, IdempotencyKey, PluginInstallationId, Timestamp, WorkerId, + AccountId, AgentInstanceKey, ComponentVersion, Empty, IdempotencyKey, PluginInstallationId, + Timestamp, WorkerId, }; use crate::model::{ProjectId, RetryConfig}; use golem_wasm_ast::analysis::analysed_type::{field, list, option, record, str}; @@ -472,6 +474,8 @@ pub struct GrowMemoryParameters { pub struct ResourceParameters { pub timestamp: Timestamp, pub id: WorkerResourceId, + pub name: String, + pub owner: String, } #[derive(Clone, Debug, Serialize, PartialEq, Deserialize, IntoValue)] @@ -481,6 +485,7 @@ pub struct ResourceParameters { pub struct DescribeResourceParameters { pub timestamp: Timestamp, pub id: WorkerResourceId, + pub resource_owner: String, pub resource_name: String, #[wit_field(convert_vec = WitValue)] pub resource_params: Vec, @@ -592,6 +597,25 @@ pub struct ChangePersistenceLevelParameters { pub persistence_level: PersistenceLevel, } +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] +pub struct CreateAgentInstanceParameters { + pub timestamp: Timestamp, + pub key: AgentInstanceKey, + pub parameters: DataValue, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, IntoValue)] +#[cfg_attr(feature = "poem", derive(poem_openapi::Object))] +#[cfg_attr(feature = "poem", oai(rename_all = "camelCase"))] +#[serde(rename_all = "camelCase")] +pub struct DropAgentInstanceParameters { + pub timestamp: Timestamp, + pub key: AgentInstanceKey, +} + /// A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. /// /// Instead, it encodes all payloads with wasm-rpc `Value` types. This makes this the base type @@ -680,6 +704,10 @@ pub enum PublicOplogEntry { SetSpanAttribute(SetSpanAttributeParameters), /// Change the current persistence level ChangePersistenceLevel(ChangePersistenceLevelParameters), + /// Created a new agent instance + CreateAgentInstance(CreateAgentInstanceParameters), + /// Dropped an agent instance + DropAgentInstance(DropAgentInstanceParameters), } impl PublicOplogEntry { @@ -983,6 +1011,16 @@ impl PublicOplogEntry { || Self::string_match("change-persistence-level", &[], query_path, query) || Self::string_match("persistence-level", &[], query_path, query) } + PublicOplogEntry::CreateAgentInstance(_params) => { + Self::string_match("createagentinstance", &[], query_path, query) + || Self::string_match("create-agent-instance", &[], query_path, query) + // TODO: match in key and parameters + } + PublicOplogEntry::DropAgentInstance(_params) => { + Self::string_match("dropagentinstance", &[], query_path, query) + || Self::string_match("drop-agent-instance", &[], query_path, query) + // TODO: match in key and parameters + } } } diff --git a/golem-common/src/model/public_oplog/protobuf.rs b/golem-common/src/model/public_oplog/protobuf.rs index 5feaeb8abd..7fbfef43c4 100644 --- a/golem-common/src/model/public_oplog/protobuf.rs +++ b/golem-common/src/model/public_oplog/protobuf.rs @@ -16,21 +16,21 @@ use crate::model::invocation_context::{SpanId, TraceId}; use crate::model::oplog::{LogLevel, OplogIndex, WorkerResourceId}; use crate::model::public_oplog::{ ActivatePluginParameters, CancelInvocationParameters, ChangePersistenceLevelParameters, - ChangeRetryPolicyParameters, CreateParameters, DeactivatePluginParameters, - DescribeResourceParameters, EndRegionParameters, ErrorParameters, - ExportedFunctionCompletedParameters, ExportedFunctionInvokedParameters, - ExportedFunctionParameters, FailedUpdateParameters, FinishSpanParameters, GrowMemoryParameters, - ImportedFunctionInvokedParameters, JumpParameters, LogParameters, ManualUpdateParameters, - OplogCursor, PendingUpdateParameters, PendingWorkerInvocationParameters, - PluginInstallationDescription, PublicAttribute, PublicAttributeValue, - PublicDurableFunctionType, PublicExternalSpanData, PublicLocalSpanData, PublicOplogEntry, - PublicRetryConfig, PublicSpanData, PublicUpdateDescription, PublicWorkerInvocation, - ResourceParameters, RevertParameters, SetSpanAttributeParameters, + ChangeRetryPolicyParameters, CreateAgentInstanceParameters, CreateParameters, + DeactivatePluginParameters, DescribeResourceParameters, DropAgentInstanceParameters, + EndRegionParameters, ErrorParameters, ExportedFunctionCompletedParameters, + ExportedFunctionInvokedParameters, ExportedFunctionParameters, FailedUpdateParameters, + FinishSpanParameters, GrowMemoryParameters, ImportedFunctionInvokedParameters, JumpParameters, + LogParameters, ManualUpdateParameters, OplogCursor, PendingUpdateParameters, + PendingWorkerInvocationParameters, PluginInstallationDescription, PublicAttribute, + PublicAttributeValue, PublicDurableFunctionType, PublicExternalSpanData, PublicLocalSpanData, + PublicOplogEntry, PublicRetryConfig, PublicSpanData, PublicUpdateDescription, + PublicWorkerInvocation, ResourceParameters, RevertParameters, SetSpanAttributeParameters, SnapshotBasedUpdateParameters, StartSpanParameters, StringAttributeValue, SuccessfulUpdateParameters, TimestampParameter, WriteRemoteBatchedParameters, }; use crate::model::regions::OplogRegion; -use crate::model::Empty; +use crate::model::{AgentInstanceKey, Empty}; use golem_api_grpc::proto::golem::worker::oplog_entry::Entry; use golem_api_grpc::proto::golem::worker::{ invocation_span, oplog_entry, worker_invocation, wrapped_function_type, AttributeValue, @@ -363,6 +363,8 @@ impl TryFrom for PublicOplogEn .ok_or("Missing timestamp field")? .into(), id: WorkerResourceId(create_resource.resource_id), + name: create_resource.name, + owner: create_resource.owner, })) } oplog_entry::Entry::DropResource(drop_resource) => { @@ -372,6 +374,8 @@ impl TryFrom for PublicOplogEn .ok_or("Missing timestamp field")? .into(), id: WorkerResourceId(drop_resource.resource_id), + name: drop_resource.name, + owner: drop_resource.owner, })) } oplog_entry::Entry::DescribeResource(describe_resource) => Ok( @@ -387,6 +391,7 @@ impl TryFrom for PublicOplogEn .into_iter() .map(TryInto::try_into) .collect::, String>>()?, + resource_owner: describe_resource.resource_owner, }), ), oplog_entry::Entry::Log(log) => Ok(PublicOplogEntry::Log(LogParameters { @@ -486,6 +491,34 @@ impl TryFrom for PublicOplogEn persistence_level: change.persistence_level().into(), }, )), + Entry::CreateAgentInstance(create_agent) => Ok(PublicOplogEntry::CreateAgentInstance( + CreateAgentInstanceParameters { + timestamp: create_agent + .timestamp + .ok_or("Missing timestamp field")? + .into(), + key: AgentInstanceKey { + agent_type: create_agent.agent_type, + agent_id: create_agent.agent_id, + }, + parameters: create_agent + .agent_parameters + .ok_or("Missing agent_parameters field")? + .try_into()?, + }, + )), + Entry::DropAgentInstance(drop_agent) => Ok(PublicOplogEntry::DropAgentInstance( + DropAgentInstanceParameters { + timestamp: drop_agent + .timestamp + .ok_or("Missing timestamp field")? + .into(), + key: AgentInstanceKey { + agent_type: drop_agent.agent_type, + agent_id: drop_agent.agent_id, + }, + }, + )), } } } @@ -728,6 +761,8 @@ impl TryFrom for golem_api_grpc::proto::golem::worker::OplogEn golem_api_grpc::proto::golem::worker::CreateResourceParameters { timestamp: Some(create_resource.timestamp.into()), resource_id: create_resource.id.0, + name: create_resource.name, + owner: create_resource.owner, }, )), } @@ -738,6 +773,8 @@ impl TryFrom for golem_api_grpc::proto::golem::worker::OplogEn golem_api_grpc::proto::golem::worker::DropResourceParameters { timestamp: Some(drop_resource.timestamp.into()), resource_id: drop_resource.id.0, + name: drop_resource.name, + owner: drop_resource.owner, }, )), } @@ -754,6 +791,7 @@ impl TryFrom for golem_api_grpc::proto::golem::worker::OplogEn .into_iter() .map(|value| value.into()) .collect(), + resource_owner: describe_resource.resource_owner, }, )), } @@ -871,6 +909,29 @@ impl TryFrom for golem_api_grpc::proto::golem::worker::OplogEn )), } } + PublicOplogEntry::CreateAgentInstance(create_instance) => { + golem_api_grpc::proto::golem::worker::OplogEntry { + entry: Some(Entry::CreateAgentInstance( + golem_api_grpc::proto::golem::worker::CreateAgentInstanceParameters { + timestamp: Some(create_instance.timestamp.into()), + agent_type: create_instance.key.agent_type, + agent_id: create_instance.key.agent_id, + agent_parameters: Some(create_instance.parameters.into()), + }, + )), + } + } + PublicOplogEntry::DropAgentInstance(drop_instance) => { + golem_api_grpc::proto::golem::worker::OplogEntry { + entry: Some(Entry::DropAgentInstance( + golem_api_grpc::proto::golem::worker::DropAgentInstanceParameters { + timestamp: Some(drop_instance.timestamp.into()), + agent_type: drop_instance.key.agent_type, + agent_id: drop_instance.key.agent_id, + }, + )), + } + } }) } } diff --git a/golem-common/src/model/public_oplog/tests.rs b/golem-common/src/model/public_oplog/tests.rs index 7a219af601..11b938c7a2 100644 --- a/golem-common/src/model/public_oplog/tests.rs +++ b/golem-common/src/model/public_oplog/tests.rs @@ -432,6 +432,8 @@ fn create_resource_serialization_poem_serde_equivalence() { let entry = PublicOplogEntry::CreateResource(ResourceParameters { timestamp: rounded_ts(Timestamp::now_utc()), id: WorkerResourceId(100), + name: "test".to_string(), + owner: "owner".to_string(), }); let serialized = entry.to_json_string(); @@ -445,6 +447,8 @@ fn drop_resource_serialization_poem_serde_equivalence() { let entry = PublicOplogEntry::DropResource(ResourceParameters { timestamp: rounded_ts(Timestamp::now_utc()), id: WorkerResourceId(100), + name: "test".to_string(), + owner: "owner".to_string(), }); let serialized = entry.to_json_string(); @@ -469,6 +473,7 @@ fn describe_resource_serialization_poem_serde_equivalence() { typ: record(vec![field("x", s16()), field("y", s16())]), }, ], + resource_owner: "owner".to_string(), }); let serialized = entry.to_json_string(); diff --git a/golem-common/wit/deps/golem-1.x/golem-host.wit b/golem-common/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/golem-common/wit/deps/golem-1.x/golem-host.wit +++ b/golem-common/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/golem-common/wit/deps/golem-agent/common.wit b/golem-common/wit/deps/golem-agent/common.wit index c725c768d2..4282355cb3 100644 --- a/golem-common/wit/deps/golem-agent/common.wit +++ b/golem-common/wit/deps/golem-agent/common.wit @@ -1,7 +1,7 @@ package golem:agent; interface common { - use golem:rpc/types@0.2.2.{wit-type, wit-value}; + use golem:rpc/types@0.2.2.{value-and-type, wit-type, wit-value}; type url = string; @@ -103,6 +103,6 @@ interface common { invalid-method(string), invalid-type(string), invalid-agent-id(string), - custom-error(data-value), + custom-error(value-and-type), } } diff --git a/golem-common/wit/deps/golem-agent/guest.wit b/golem-common/wit/deps/golem-agent/guest.wit index e71b8c8e7c..4fe6473eea 100644 --- a/golem-common/wit/deps/golem-agent/guest.wit +++ b/golem-common/wit/deps/golem-agent/guest.wit @@ -15,6 +15,10 @@ interface guest { get-agent: func(agent-type: string, agent-id: string) -> agent; + /// Invokes an agent method on an agent of a given type and ID. + /// Equivalent of getting an agent with `get-agent` and calling `invoke` on that. + invoke-agent: func(agent-type: string, agent-id: string, method-name: string, input: data-value) -> result; + discover-agents: func() -> list; discover-agent-types: func() -> list; @@ -25,3 +29,7 @@ world agent-guest { import golem:rpc/types@0.2.2; export guest; } + +world agent-host { + export host; +} diff --git a/golem-common/wit/deps/golem-agent/host.wit b/golem-common/wit/deps/golem-agent/host.wit new file mode 100644 index 0000000000..0428b5cc86 --- /dev/null +++ b/golem-common/wit/deps/golem-agent/host.wit @@ -0,0 +1,8 @@ +package golem:agent; + +interface host { + use common.{data-value}; + + register-agent: func(agent-type: string, agent-id: string, constructor-parameters: data-value); + unregister-agent: func(agent-type: string, agent-id: string, constructor-parameters: data-value); +} diff --git a/golem-common/wit/deps/golem-rpc/wasm-rpc.wit b/golem-common/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/golem-common/wit/deps/golem-rpc/wasm-rpc.wit +++ b/golem-common/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/golem-common/wit/golem-common.wit b/golem-common/wit/golem-common.wit index cde50bbf86..3979bbb3d1 100644 --- a/golem-common/wit/golem-common.wit +++ b/golem-common/wit/golem-common.wit @@ -2,4 +2,5 @@ package golem:common; world golem-common { import golem:agent/guest; + import golem:agent/host; } diff --git a/golem-component-service/src/repo/component.rs b/golem-component-service/src/repo/component.rs index e6ca7f3689..5638db6579 100644 --- a/golem-component-service/src/repo/component.rs +++ b/golem-component-service/src/repo/component.rs @@ -127,8 +127,8 @@ impl ComponentRecord { ) }) .collect::, _>>()?, - root_package_name: value.metadata.root_package_name, - root_package_version: value.metadata.root_package_version, + root_package_name: value.metadata.root_package_name().clone(), + root_package_version: value.metadata.root_package_version().clone(), env: Json(value.env), transformed_env: Json(value.transformed_env), }) diff --git a/golem-component-service/src/service/component.rs b/golem-component-service/src/service/component.rs index 8de4feff33..2e6e9540f7 100644 --- a/golem-component-service/src/service/component.rs +++ b/golem-component-service/src/service/component.rs @@ -883,15 +883,15 @@ impl ComponentServiceDefault { info!( owner = %owner, - exports = ?component.metadata.exports, - dynamic_linking = ?component.metadata.dynamic_linking, + exports = ?component.metadata.exports(), + dynamic_linking = ?component.metadata.dynamic_linking(), "Uploaded component", ); let (component, transformed_data) = self.apply_transformations(component, data.clone()).await?; - if let Some(known_root_package_name) = &component.metadata.root_package_name { + if let Some(known_root_package_name) = &component.metadata.root_package_name() { if &component_name.0 != known_root_package_name { Err(ComponentError::InvalidComponentName { actual: component_name.0.clone(), @@ -954,7 +954,7 @@ impl ComponentServiceDefault { .get_constraint(&owner.to_string(), component_id.0) .await?; - let new_type_registry = FunctionDictionary::from_exports(&metadata.exports) + let new_type_registry = FunctionDictionary::from_exports(metadata.exports()) .map_err(|e| ComponentError::conversion_error("exports", e))?; if let Some(constraints) = constraints { @@ -967,8 +967,8 @@ impl ComponentServiceDefault { info!( owner = %owner, - exports = ?metadata.exports, - dynamic_linking = ?metadata.dynamic_linking, + exports = ?metadata.exports(), + dynamic_linking = ?metadata.dynamic_linking(), "Uploaded component", ); @@ -1121,8 +1121,8 @@ impl ComponentServiceDefault { component.metadata = ComponentMetadata::analyse_component( &data, - component.metadata.dynamic_linking, - component.metadata.agent_types, + component.metadata.dynamic_linking().clone(), + component.metadata.agent_types().to_vec(), ) .map_err(ComponentError::ComponentProcessingError)?; diff --git a/golem-component-service/src/service/plugin.rs b/golem-component-service/src/service/plugin.rs index fbcc1fd9f2..b8f7d005ad 100644 --- a/golem-component-service/src/service/plugin.rs +++ b/golem-component-service/src/service/plugin.rs @@ -121,7 +121,7 @@ impl PluginService { let implements_oplog_processor_interface = component .metadata - .exports + .exports() .iter() .any(is_valid_oplog_processor_implementation); diff --git a/golem-component-service/tests/all/service/mod.rs b/golem-component-service/tests/all/service/mod.rs index c9668eed33..9cd0c8e956 100644 --- a/golem-component-service/tests/all/service/mod.rs +++ b/golem-component-service/tests/all/service/mod.rs @@ -1070,7 +1070,7 @@ async fn test_library_plugin_creation( .unwrap() .expect("plugin not found"); - let exports = final_component.metadata.exports; + let exports = final_component.metadata.exports(); assert_eq!(exports.len(), 1); assert!(matches!( @@ -1158,7 +1158,7 @@ async fn test_app_plugin_creation( .unwrap() .expect("plugin not found"); - let exports = final_component.metadata.exports; + let exports = final_component.metadata.exports(); assert_eq!(exports.len(), 1); assert!(matches!( diff --git a/golem-debugging-service/Cargo.toml b/golem-debugging-service/Cargo.toml index e5b0e5d345..fc59e5c0a5 100644 --- a/golem-debugging-service/Cargo.toml +++ b/golem-debugging-service/Cargo.toml @@ -16,6 +16,7 @@ path = "src/server.rs" golem-worker-executor = { path = "../golem-worker-executor", version = "=0.0.0" } golem-common = { path = "../golem-common", version = "=0.0.0" } golem-api-grpc = { path = "../golem-api-grpc", version = "=0.0.0" } +golem-rib = { path = "../golem-rib", version = "=0.0.0" } golem-service-base = { path = "../golem-service-base", version = "=0.0.0" } golem-wasm-ast = { path = "../wasm-ast", version = "=0.0.0" } golem-wasm-rpc = { path = "../wasm-rpc", version = "=0.0.0" } diff --git a/golem-debugging-service/src/debug_context.rs b/golem-debugging-service/src/debug_context.rs index 1468914bb6..ccc5e170cf 100644 --- a/golem-debugging-service/src/debug_context.rs +++ b/golem-debugging-service/src/debug_context.rs @@ -15,6 +15,7 @@ use crate::additional_deps::AdditionalDeps; use anyhow::Error; use async_trait::async_trait; +use golem_common::model::agent::DataValue; use golem_common::model::invocation_context::{ self, AttributeValue, InvocationContextStack, SpanId, }; @@ -29,7 +30,7 @@ use golem_service_base::error::worker_executor::{InterruptKind, WorkerExecutorEr use golem_wasm_rpc::golem_rpc_0_2_x::types::{ Datetime, FutureInvokeResult, HostFutureInvokeResult, Pollable, WasmRpc, }; -use golem_wasm_rpc::wasmtime::ResourceStore; +use golem_wasm_rpc::wasmtime::{ResourceStore, ResourceTypeId}; use golem_wasm_rpc::{CancellationTokenEntry, ComponentId, Value, ValueAndType}; use golem_wasm_rpc::{HostWasmRpc, RpcError, Uri, WitValue}; use golem_worker_executor::durable_host::{ @@ -59,9 +60,9 @@ use golem_worker_executor::services::worker_proxy::WorkerProxy; use golem_worker_executor::services::{worker_enumeration, HasAll, HasConfig, HasOplogService}; use golem_worker_executor::worker::{RetryDecision, Worker}; use golem_worker_executor::workerctx::{ - DynamicLinking, ExternalOperations, FileSystemReading, FuelManagement, IndexedResourceStore, - InvocationContextManagement, InvocationHooks, InvocationManagement, LogEventEmitBehaviour, - StatusManagement, UpdateManagement, WorkerCtx, + AgentStore, DynamicLinking, ExternalOperations, FileSystemReading, FuelManagement, + IndexedResourceStore, InvocationContextManagement, InvocationHooks, InvocationManagement, + LogEventEmitBehaviour, StatusManagement, UpdateManagement, WorkerCtx, }; use std::collections::HashSet; use std::sync::{Arc, RwLock, Weak}; @@ -160,7 +161,7 @@ impl ExternalOperations for DebugContext { async fn on_shard_assignment_changed + Send + Sync + 'static>( this: &This, - ) -> Result<(), anyhow::Error> { + ) -> Result<(), Error> { DurableWorkerCtx::::on_shard_assignment_changed(this).await } @@ -194,10 +195,6 @@ impl InvocationManagement for DebugContext { self.durable_ctx.get_current_idempotency_key().await } - async fn get_current_invocation_context(&self) -> InvocationContextStack { - self.durable_ctx.get_current_invocation_context().await - } - async fn set_current_invocation_context( &mut self, stack: InvocationContextStack, @@ -205,6 +202,10 @@ impl InvocationManagement for DebugContext { self.durable_ctx.set_current_invocation_context(stack).await } + async fn get_current_invocation_context(&self) -> InvocationContextStack { + self.durable_ctx.get_current_invocation_context().await + } + fn is_live(&self) -> bool { self.durable_ctx.is_live() } @@ -314,27 +315,59 @@ impl UpdateManagement for DebugContext { impl IndexedResourceStore for DebugContext { fn get_indexed_resource( &self, + resource_owner: &str, resource_name: &str, resource_params: &[String], ) -> Option { self.durable_ctx - .get_indexed_resource(resource_name, resource_params) + .get_indexed_resource(resource_owner, resource_name, resource_params) } async fn store_indexed_resource( &mut self, + resource_owner: &str, resource_name: &str, resource_params: &[String], resource: WorkerResourceId, ) { self.durable_ctx - .store_indexed_resource(resource_name, resource_params, resource) + .store_indexed_resource(resource_owner, resource_name, resource_params, resource) .await } - fn drop_indexed_resource(&mut self, resource_name: &str, resource_params: &[String]) { + fn drop_indexed_resource( + &mut self, + resource_owner: &str, + resource_name: &str, + resource_params: &[String], + ) { + self.durable_ctx + .drop_indexed_resource(resource_owner, resource_name, resource_params) + } +} + +#[async_trait] +impl AgentStore for DebugContext { + async fn store_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { + self.durable_ctx + .store_agent_instance(agent_type, agent_id, parameters) + .await; + } + + async fn remove_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { self.durable_ctx - .drop_indexed_resource(resource_name, resource_params) + .remove_agent_instance(agent_type, agent_id, parameters) + .await; } } @@ -344,15 +377,15 @@ impl ResourceStore for DebugContext { self.durable_ctx.self_uri() } - async fn add(&mut self, resource: ResourceAny) -> u64 { - self.durable_ctx.add(resource).await + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64 { + self.durable_ctx.add(resource, name).await } - async fn get(&mut self, resource_id: u64) -> Option { + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { ResourceStore::get(&mut self.durable_ctx, resource_id).await } - async fn borrow(&self, resource_id: u64) -> Option { + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { self.durable_ctx.borrow(resource_id).await } } diff --git a/golem-debugging-service/src/debug_session.rs b/golem-debugging-service/src/debug_session.rs index 051b091831..4ff87d345e 100644 --- a/golem-debugging-service/src/debug_session.rs +++ b/golem-debugging-service/src/debug_session.rs @@ -22,7 +22,7 @@ use async_trait::async_trait; use bincode::Encode; use golem_common::model::auth::Namespace; use golem_common::model::oplog::{ - DurableFunctionType, IndexedResourceKey, OplogEntry, OplogIndex, OplogPayload, WorkerError, + DurableFunctionType, OplogEntry, OplogIndex, OplogPayload, WorkerError, }; use golem_common::model::public_oplog::{ CreateParameters, DescribeResourceParameters, ExportedFunctionCompletedParameters, @@ -34,6 +34,7 @@ use golem_common::model::{ WorkerMetadata, }; use golem_wasm_ast::analysis::AnalysedType; +use golem_wasm_rpc::wasmtime::ResourceTypeId; use golem_wasm_rpc::{Value, ValueAndType}; use golem_worker_executor::durable_host::http::serialized::{ SerializableErrorCode, SerializableHttpRequest, SerializableResponse, @@ -414,15 +415,30 @@ fn get_oplog_entry_from_public_oplog_entry( PublicOplogEntry::GrowMemory(GrowMemoryParameters { timestamp, delta }) => { Ok(OplogEntry::GrowMemory { timestamp, delta }) } - PublicOplogEntry::CreateResource(ResourceParameters { timestamp, id }) => { - Ok(OplogEntry::CreateResource { timestamp, id }) - } - PublicOplogEntry::DropResource(ResourceParameters { timestamp, id }) => { - Ok(OplogEntry::DropResource { timestamp, id }) - } + PublicOplogEntry::CreateResource(ResourceParameters { + timestamp, + id, + owner, + name, + }) => Ok(OplogEntry::CreateResource { + timestamp, + id, + resource_type_id: ResourceTypeId { owner, name }, + }), + PublicOplogEntry::DropResource(ResourceParameters { + timestamp, + id, + owner, + name, + }) => Ok(OplogEntry::DropResource { + timestamp, + id, + resource_type_id: ResourceTypeId { owner, name }, + }), PublicOplogEntry::DescribeResource(DescribeResourceParameters { timestamp, id, + resource_owner, resource_name, resource_params, }) => { @@ -434,10 +450,11 @@ fn get_oplog_entry_from_public_oplog_entry( Ok(OplogEntry::DescribeResource { timestamp, id, - indexed_resource: IndexedResourceKey { - resource_name, - resource_params, + resource_type_id: ResourceTypeId { + owner: resource_owner, + name: resource_name, }, + indexed_resource_parameters: resource_params, }) } PublicOplogEntry::Log(LogParameters { @@ -505,6 +522,19 @@ fn get_oplog_entry_from_public_oplog_entry( level: change_persistence_level.persistence_level, }) } + PublicOplogEntry::CreateAgentInstance(create_agent_instance) => { + Ok(OplogEntry::CreateAgentInstance { + timestamp: create_agent_instance.timestamp, + key: create_agent_instance.key, + parameters: create_agent_instance.parameters, + }) + } + PublicOplogEntry::DropAgentInstance(drop_agent_instance) => { + Ok(OplogEntry::DropAgentInstance { + timestamp: drop_agent_instance.timestamp, + key: drop_agent_instance.key, + }) + } } } diff --git a/golem-debugging-service/src/lib.rs b/golem-debugging-service/src/lib.rs index 31b8fb3d56..c82a898a03 100644 --- a/golem-debugging-service/src/lib.rs +++ b/golem-debugging-service/src/lib.rs @@ -35,7 +35,7 @@ use async_trait::async_trait; use golem_service_base::clients::auth::AuthService as BaseAuthService; use golem_service_base::storage::blob::BlobStorage; use golem_worker_executor::durable_host::DurableWorkerCtx; -use golem_worker_executor::preview2::{golem_api_1_x, golem_durability}; +use golem_worker_executor::preview2::{golem_agent, golem_api_1_x, golem_durability}; use golem_worker_executor::services::active_workers::ActiveWorkers; use golem_worker_executor::services::blob_store::BlobStoreService; use golem_worker_executor::services::component::ComponentService; @@ -353,6 +353,7 @@ pub fn create_debug_wasmtime_linker(engine: &Engine) -> anyhow::Result Option { self.durable_ctx - .get_indexed_resource(resource_name, resource_params) + .get_indexed_resource(resource_owner, resource_name, resource_params) } async fn store_indexed_resource( &mut self, + resource_owner: &str, resource_name: &str, resource_params: &[String], resource: WorkerResourceId, ) { self.durable_ctx - .store_indexed_resource(resource_name, resource_params, resource) + .store_indexed_resource(resource_owner, resource_name, resource_params, resource) .await } - fn drop_indexed_resource(&mut self, resource_name: &str, resource_params: &[String]) { + fn drop_indexed_resource( + &mut self, + resource_owner: &str, + resource_name: &str, + resource_params: &[String], + ) { + self.durable_ctx + .drop_indexed_resource(resource_owner, resource_name, resource_params) + } +} + +#[async_trait] +impl AgentStore for TestWorkerCtx { + async fn store_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { + self.durable_ctx + .store_agent_instance(agent_type, agent_id, parameters) + .await; + } + + async fn remove_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { self.durable_ctx - .drop_indexed_resource(resource_name, resource_params) + .remove_agent_instance(agent_type, agent_id, parameters) + .await; } } @@ -591,15 +624,15 @@ impl ResourceStore for TestWorkerCtx { self.durable_ctx.self_uri() } - async fn add(&mut self, resource: ResourceAny) -> u64 { - self.durable_ctx.add(resource).await + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64 { + self.durable_ctx.add(resource, name).await } - async fn get(&mut self, resource_id: u64) -> Option { + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { ResourceStore::get(&mut self.durable_ctx, resource_id).await } - async fn borrow(&self, resource_id: u64) -> Option { + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { self.durable_ctx.borrow(resource_id).await } } diff --git a/golem-registry-service/src/repo/model/component.rs b/golem-registry-service/src/repo/model/component.rs index 1256c8c346..f8db152c89 100644 --- a/golem-registry-service/src/repo/model/component.rs +++ b/golem-registry-service/src/repo/model/component.rs @@ -330,17 +330,7 @@ impl ComponentRevisionRecord { audit: DeletableRevisionAuditFields::deletion(created_by), component_type: 0, size: 0, - metadata: ComponentMetadata { - exports: vec![], - producers: vec![], - memories: vec![], - binary_wit: Default::default(), - root_package_name: None, - root_package_version: None, - dynamic_linking: Default::default(), - agent_types: Default::default(), - } - .into(), + metadata: ComponentMetadata::default().into(), env: Default::default(), status: ComponentStatus::Created, object_store_key: "".to_string(), diff --git a/golem-rib/src/compiler/byte_code.rs b/golem-rib/src/compiler/byte_code.rs index 5482d4ff6d..1fb09dfdc6 100644 --- a/golem-rib/src/compiler/byte_code.rs +++ b/golem-rib/src/compiler/byte_code.rs @@ -726,6 +726,7 @@ mod internal { value: Value::Flags(bitmap), typ: AnalysedType::Flags(TypeFlags { names: all_flags.iter().map(|n| n.to_string()).collect(), + owner: None, name: None, }), })); @@ -2037,6 +2038,7 @@ mod compiler_tests { resource_id: AnalysedResourceId(0), mode: AnalysedResourceMode::Owned, name: None, + owner: None, }), }), }], @@ -2070,6 +2072,7 @@ mod compiler_tests { resource_id: AnalysedResourceId(0), mode: AnalysedResourceMode::Owned, name: None, + owner: None, }), }), }, @@ -2082,6 +2085,7 @@ mod compiler_tests { resource_id: AnalysedResourceId(0), mode: AnalysedResourceMode::Borrowed, name: None, + owner: None, }), }, AnalysedFunctionParameter { diff --git a/golem-rib/src/compiler/type_with_unit.rs b/golem-rib/src/compiler/type_with_unit.rs index 5e76468570..1b58d38a19 100644 --- a/golem-rib/src/compiler/type_with_unit.rs +++ b/golem-rib/src/compiler/type_with_unit.rs @@ -86,6 +86,7 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { resource_id: analysed_resource_id, mode: analysed_resource_mode, name: None, + owner: None, }, ))) } @@ -152,6 +153,7 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { AnalysedType::List(TypeList { inner: Box::new(inferred_type.try_into()?), name: None, + owner: None, }), )), TypeInternal::Tuple(tuple) => Ok(AnalysedTypeWithUnit::analysed_type( @@ -161,6 +163,7 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { .map(|t| t.try_into()) .collect::, String>>()?, name: None, + owner: None, }), )), TypeInternal::Record(record) => Ok(AnalysedTypeWithUnit::analysed_type( @@ -175,24 +178,28 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { }) .collect::, String>>()?, name: None, + owner: None, }), )), TypeInternal::Flags(flags) => Ok(AnalysedTypeWithUnit::analysed_type( AnalysedType::Flags(TypeFlags { names: flags.clone(), name: None, + owner: None, }), )), TypeInternal::Enum(enums) => Ok(AnalysedTypeWithUnit::analysed_type( AnalysedType::Enum(TypeEnum { cases: enums.clone(), name: None, + owner: None, }), )), TypeInternal::Option(option) => Ok(AnalysedTypeWithUnit::analysed_type( AnalysedType::Option(TypeOption { inner: Box::new(option.try_into()?), name: None, + owner: None, }), )), TypeInternal::Result { ok, error } => Ok(AnalysedTypeWithUnit::analysed_type( @@ -201,6 +208,7 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { ok: ok.as_ref().and_then(|t| t.try_into().ok().map(Box::new)), err: error.as_ref().and_then(|t| t.try_into().ok().map(Box::new)), name: None, + owner: None, }), )), TypeInternal::Variant(variant) => Ok(AnalysedTypeWithUnit::analysed_type( @@ -215,6 +223,7 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { }) .collect::, String>>()?, name: None, + owner: None, }), )), TypeInternal::Resource { @@ -229,6 +238,7 @@ impl TryFrom<&InferredType> for AnalysedTypeWithUnit { AnalysedResourceMode::Borrowed }, name: None, + owner: None, }, ))), diff --git a/golem-rib/src/function_name.rs b/golem-rib/src/function_name.rs index 98cdfc88e6..ff7ff803c5 100644 --- a/golem-rib/src/function_name.rs +++ b/golem-rib/src/function_name.rs @@ -25,6 +25,14 @@ use std::fmt::Display; #[derive(PartialEq, Hash, Eq, Clone, Ord, PartialOrd)] pub struct SemVer(pub semver::Version); +impl SemVer { + pub fn parse(version: &str) -> Result { + semver::Version::parse(version) + .map(SemVer) + .map_err(|e| format!("Invalid semver string: {e}")) + } +} + impl std::fmt::Debug for SemVer { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) @@ -132,6 +140,26 @@ impl ParsedFunctionSite { } => Some(format!("{namespace}:{package}/{interface}@{}", version.0)), } } + + pub fn unversioned(&self) -> ParsedFunctionSite { + match self { + ParsedFunctionSite::Global => ParsedFunctionSite::Global, + ParsedFunctionSite::Interface { name } => { + ParsedFunctionSite::Interface { name: name.clone() } + } + ParsedFunctionSite::PackagedInterface { + namespace, + package, + interface, + version: _, + } => ParsedFunctionSite::PackagedInterface { + namespace: namespace.clone(), + package: package.clone(), + interface: interface.clone(), + version: None, + }, + } + } } #[derive(Debug, Hash, PartialEq, Eq, Clone, Ord, PartialOrd)] @@ -316,7 +344,7 @@ impl DynamicParsedFunctionReference { } } -#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Hash, Encode, Decode)] pub enum ParsedFunctionReference { Function { function: String, @@ -600,7 +628,7 @@ impl Display for DynamicParsedFunctionName { } } -#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)] +#[derive(Debug, PartialEq, Eq, Clone, Hash, Encode, Decode)] pub struct ParsedFunctionName { pub site: ParsedFunctionSite, pub function: ParsedFunctionReference, @@ -716,6 +744,13 @@ impl ParsedFunctionName { _ => None, } } + + pub fn with_site(&self, site: ParsedFunctionSite) -> Self { + Self { + site, + function: self.function.clone(), + } + } } #[cfg(feature = "protobuf")] diff --git a/golem-rib/src/interpreter/stack.rs b/golem-rib/src/interpreter/stack.rs index e38e0be6d6..7601f73394 100644 --- a/golem-rib/src/interpreter/stack.rs +++ b/golem-rib/src/interpreter/stack.rs @@ -205,6 +205,7 @@ impl InterpreterStack { AnalysedType::Enum(TypeEnum { cases: cases.into_iter().collect(), name: None, + owner: None, }), )); @@ -240,6 +241,7 @@ impl InterpreterStack { ok: ok_type.map(|x| Box::new(x.clone())), err: err_type.map(|x| Box::new(x.clone())), name: None, + owner: None, }), }); } @@ -256,6 +258,7 @@ impl InterpreterStack { ok: ok_type.map(|x| Box::new(x.clone())), err: err_type.map(|x| Box::new(x.clone())), name: None, + owner: None, }), }); } diff --git a/golem-rib/src/registry/function_dictionary.rs b/golem-rib/src/registry/function_dictionary.rs index 4574069cee..4b451dc90b 100644 --- a/golem-rib/src/registry/function_dictionary.rs +++ b/golem-rib/src/registry/function_dictionary.rs @@ -115,7 +115,7 @@ impl From<&ResourceMethodDictionary> for FunctionDictionary { } impl FunctionDictionary { - pub fn from_exports(exports: &Vec) -> Result { + pub fn from_exports(exports: &[AnalysedExport]) -> Result { let registry = FunctionTypeRegistry::from_export_metadata(exports); Self::from_function_type_registry(®istry) } diff --git a/golem-rib/src/registry/raw_type_registry.rs b/golem-rib/src/registry/raw_type_registry.rs index fe2fe454f3..0b82dc7113 100644 --- a/golem-rib/src/registry/raw_type_registry.rs +++ b/golem-rib/src/registry/raw_type_registry.rs @@ -86,7 +86,7 @@ impl FunctionTypeRegistry { } } - pub fn from_export_metadata(exports: &Vec) -> Self { + pub fn from_export_metadata(exports: &[AnalysedExport]) -> Self { let mut map = HashMap::new(); let mut types = HashSet::new(); diff --git a/golem-service-base/src/model/mod.rs b/golem-service-base/src/model/mod.rs index 0f4483135d..f60533db75 100644 --- a/golem-service-base/src/model/mod.rs +++ b/golem-service-base/src/model/mod.rs @@ -177,9 +177,7 @@ pub struct PublicOplogEntryWithIndex { pub entry: PublicOplogEntry, } -impl TryFrom - for PublicOplogEntryWithIndex -{ +impl TryFrom for PublicOplogEntryWithIndex { type Error = String; fn try_from(value: OplogEntryWithIndex) -> Result { @@ -190,9 +188,7 @@ impl TryFrom } } -impl TryFrom - for golem_api_grpc::proto::golem::worker::OplogEntryWithIndex -{ +impl TryFrom for OplogEntryWithIndex { type Error = String; fn try_from(value: PublicOplogEntryWithIndex) -> Result { @@ -357,42 +353,13 @@ impl From for golem_api_grpc::proto::golem::worker::UpdateRecord { } } -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Object)] -#[serde(rename_all = "camelCase")] -#[oai(rename_all = "camelCase")] -pub struct ResourceMetadata { - pub created_at: Timestamp, - pub indexed: Option, -} - -impl TryFrom for ResourceMetadata { - type Error = String; - - fn try_from( - value: golem_api_grpc::proto::golem::worker::ResourceMetadata, - ) -> Result { - Ok(Self { - created_at: value.created_at.ok_or("Missing created_at")?.into(), - indexed: value.indexed.map(|i| i.into()), - }) - } -} - -impl From for golem_api_grpc::proto::golem::worker::ResourceMetadata { - fn from(value: ResourceMetadata) -> Self { - Self { - created_at: Some(value.created_at.into()), - indexed: value.indexed.map(|i| i.into()), - } - } -} - #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Object)] #[serde(rename_all = "camelCase")] #[oai(rename_all = "camelCase")] pub struct IndexedWorkerMetadata { pub resource_name: String, pub resource_params: Vec, + pub resource_owner: String, } impl From for IndexedWorkerMetadata { @@ -400,6 +367,7 @@ impl From for Ind Self { resource_name: value.resource_name, resource_params: value.resource_params, + resource_owner: value.resource_owner, } } } @@ -409,6 +377,7 @@ impl From for golem_api_grpc::proto::golem::worker::Index Self { resource_name: value.resource_name, resource_params: value.resource_params, + resource_owner: value.resource_owner, } } } @@ -498,6 +467,28 @@ impl TryFrom for Component { } } +impl From for golem_api_grpc::proto::golem::component::Component { + fn from(value: Component) -> Self { + Self { + account_id: Some(value.owner.account_id.into()), + project_id: Some(value.owner.project_id.into()), + versioned_component_id: Some(value.versioned_component_id.into()), + component_name: value.component_name.0, + component_size: value.component_size, + metadata: Some(value.metadata.into()), + created_at: Some(SystemTime::from(value.created_at).into()), + component_type: Some(value.component_type as i32), + files: value.files.into_iter().map(Into::into).collect(), + installed_plugins: value + .installed_plugins + .into_iter() + .map(Into::into) + .collect(), + env: value.env, + } + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, Serialize, Deserialize, Object)] #[serde(rename_all = "camelCase")] #[oai(rename_all = "camelCase")] diff --git a/golem-service-base/src/testing.rs b/golem-service-base/src/testing.rs index 936686a5a7..c4fd3233e1 100644 --- a/golem-service-base/src/testing.rs +++ b/golem-service-base/src/testing.rs @@ -18,7 +18,7 @@ use golem_wasm_ast::analysis::AnalysedExport; use serde::{Deserialize, Serialize}; use crate::model::{Component, ComponentName}; -use golem_common::model::base64::Base64; +use golem_common::model::agent::AgentType; use golem_common::model::component::{ComponentOwner, VersionedComponentId}; use golem_common::model::component_metadata::{ ComponentMetadata, DynamicLinkedInstance, LinearMemory, @@ -47,6 +47,8 @@ pub struct LocalFileSystemComponentMetadata { #[serde(default)] pub env: HashMap, + + pub agent_types: Vec, } impl From for Component { @@ -62,16 +64,14 @@ impl From for Component { }, component_name: ComponentName(value.component_name), component_size: value.size, - metadata: ComponentMetadata { - exports: value.exports, - producers: vec![], - memories: value.memories, - binary_wit: Base64(vec![]), - root_package_name: None, - root_package_version: None, - dynamic_linking: value.dynamic_linking, - agent_types: vec![], - }, + metadata: ComponentMetadata::from_parts( + value.exports, + value.memories, + value.dynamic_linking, + None, + None, + value.agent_types, + ), created_at: Default::default(), component_type: value.component_type, files: value.files, diff --git a/golem-test-framework/Cargo.toml b/golem-test-framework/Cargo.toml index 1d318b916c..69d5510e1d 100644 --- a/golem-test-framework/Cargo.toml +++ b/golem-test-framework/Cargo.toml @@ -15,7 +15,7 @@ harness = false [dependencies] golem-api-grpc = { path = "../golem-api-grpc", version = "=0.0.0" } golem-client = { path = "../golem-client", version = "=0.0.0" } -golem-common = { path = "../golem-common", version = "=0.0.0" } +golem-common = { path = "../golem-common", version = "=0.0.0", features = ["agent-extraction"] } golem-rib = { path = "../golem-rib", version = "=0.0.0" } golem-service-base = { path = "../golem-service-base", version = "=0.0.0" } golem-wasm-ast = { path = "../wasm-ast", version = "=0.0.0" } diff --git a/golem-test-framework/src/components/component_service/filesystem.rs b/golem-test-framework/src/components/component_service/filesystem.rs index 8964c73eae..b516786a0e 100644 --- a/golem-test-framework/src/components/component_service/filesystem.rs +++ b/golem-test-framework/src/components/component_service/filesystem.rs @@ -18,7 +18,9 @@ use crate::components::component_service::{AddComponentError, ComponentService}; use crate::config::GolemClientProtocol; use anyhow::Context; use async_trait::async_trait; +use golem_api_grpc::proto::golem::component::v1::GetLatestComponentRequest; use golem_api_grpc::proto::golem::component::{Component, ComponentMetadata, VersionedComponentId}; +use golem_common::model::agent::extraction::extract_agent_types; use golem_common::model::component_metadata::DynamicLinkedInstance; use golem_common::model::{ component_metadata::{LinearMemory, RawComponentMetadata}, @@ -123,6 +125,12 @@ impl FileSystemComponentService { })? }; + let agent_types = if skip_analysis { + vec![] + } else { + extract_agent_types(&target_path).await.unwrap_or_default() + }; + let size = tokio::fs::metadata(&target_path) .await .map_err(|err| { @@ -144,6 +152,7 @@ impl FileSystemComponentService { dynamic_linking: dynamic_linking.clone(), wasm_filename, env: env.clone(), + agent_types, }; write_metadata_to_file( metadata, @@ -404,6 +413,18 @@ impl ComponentService for FileSystemComponentService { *versions.last().unwrap_or(&0) } + async fn get_latest_component_metadata( + &self, + token: &Uuid, + request: GetLatestComponentRequest, + ) -> crate::Result { + let component_id: ComponentId = request.component_id.unwrap().try_into().unwrap(); + let version = self.get_latest_version(token, &component_id).await; + let metadata = self.load_metadata(&component_id, version).await?; + let component: golem_service_base::model::Component = metadata.into(); + Ok(component.into()) + } + async fn get_component_size( &self, _token: &Uuid, diff --git a/golem-test-framework/src/components/mod.rs b/golem-test-framework/src/components/mod.rs index 2c1092f7f7..e9d34458bc 100644 --- a/golem-test-framework/src/components/mod.rs +++ b/golem-test-framework/src/components/mod.rs @@ -214,7 +214,7 @@ impl EnvVarBuilder { h2=warn,\ hyper=warn,\ tower=warn,\ - fred=warn" + fred=error" ), ) } diff --git a/golem-test-framework/src/components/worker_service/mod.rs b/golem-test-framework/src/components/worker_service/mod.rs index 7eb2cf20af..5bda4b8030 100644 --- a/golem-test-framework/src/components/worker_service/mod.rs +++ b/golem-test-framework/src/components/worker_service/mod.rs @@ -56,11 +56,11 @@ use golem_api_grpc::proto::golem::worker::v1::{ use golem_api_grpc::proto::golem::worker::worker_filter::Filter; use golem_api_grpc::proto::golem::worker::{ file_system_node, update_record, Cursor, DirectoryFileSystemNode, FailedUpdate, - FileFileSystemNode, FileSystemNode, IdempotencyKey, IndexedResourceMetadata, InvocationContext, - InvokeParameters, InvokeResult, InvokeResultTyped, LogEvent, OplogCursor, OplogEntry, - OplogEntryWithIndex, PendingUpdate, ResourceMetadata, SuccessfulUpdate, TargetWorkerId, - UpdateMode, UpdateRecord, WorkerCreatedAtFilter, WorkerEnvFilter, WorkerMetadata, - WorkerNameFilter, WorkerStatusFilter, WorkerVersionFilter, WorkerWasiConfigVarsFilter, + FileFileSystemNode, FileSystemNode, IdempotencyKey, InvocationContext, InvokeParameters, + InvokeResult, InvokeResultTyped, LogEvent, OplogCursor, OplogEntry, OplogEntryWithIndex, + PendingUpdate, SuccessfulUpdate, TargetWorkerId, UpdateMode, UpdateRecord, + WorkerCreatedAtFilter, WorkerEnvFilter, WorkerMetadata, WorkerNameFilter, WorkerStatusFilter, + WorkerVersionFilter, WorkerWasiConfigVarsFilter, }; use golem_client::api::ApiDefinitionClient as ApiDefinitionServiceHttpClient; use golem_client::api::ApiDefinitionClientLive as ApiDefinitionServiceHttpClientLive; @@ -1439,6 +1439,44 @@ async fn env_vars( fn http_worker_metadata_to_grpc( worker_metadata: golem_client::model::WorkerMetadata, ) -> WorkerMetadata { + let mut owned_resources = Vec::new(); + for instance in worker_metadata.exported_resource_instances { + owned_resources.push( + golem_api_grpc::proto::golem::worker::ResourceDescription { + description: Some( + golem_api_grpc::proto::golem::worker::resource_description::Description::ExportedResourceInstance( + golem_api_grpc::proto::golem::worker::ExportedResourceInstanceDescription { + resource_id: instance.key.resource_id.0, + resource_name: instance.description.resource_name, + resource_owner: instance.description.resource_owner, + created_at: Some(instance.description.created_at.into()), + is_indexed: instance.description.resource_params.is_some(), + resource_params: instance.description.resource_params.unwrap_or_default(), + }, + ), + ), + }, + ); + } + for instance in worker_metadata.agent_instances { + owned_resources.push( + golem_api_grpc::proto::golem::worker::ResourceDescription { + description: Some( + golem_api_grpc::proto::golem::worker::resource_description::Description::AgentInstance( + golem_api_grpc::proto::golem::worker::AgentInstanceDescription { + agent_type: instance.key.agent_type, + agent_id: instance.key.agent_id, + created_at: Some(instance.description.created_at.into()), + agent_parameters: Some(instance + .description + .agent_parameters + .into()), + }, + ), + ), + }, + ); + } WorkerMetadata { worker_id: Some(worker_metadata.worker_id.into()), created_by: Some(AccountId { @@ -1493,22 +1531,7 @@ fn http_worker_metadata_to_grpc( last_error: worker_metadata.last_error, component_size: worker_metadata.component_size, total_linear_memory_size: worker_metadata.total_linear_memory_size, - owned_resources: worker_metadata - .owned_resources - .into_iter() - .map(|(k, v)| { - ( - k.parse().unwrap(), - ResourceMetadata { - created_at: Some(SystemTime::from(v.created_at).into()), - indexed: v.indexed.map(|indexed| IndexedResourceMetadata { - resource_name: indexed.resource_name, - resource_params: indexed.resource_params, - }), - }, - ) - }) - .collect(), + owned_resources, active_plugins: worker_metadata .active_plugins .into_iter() diff --git a/golem-test-framework/src/dsl/debug_render.rs b/golem-test-framework/src/dsl/debug_render.rs index 40ee90f48b..07283002f9 100644 --- a/golem-test-framework/src/dsl/debug_render.rs +++ b/golem-test-framework/src/dsl/debug_render.rs @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +use golem_common::model::agent::{BinaryReference, DataValue, ElementValue, TextReference}; use golem_common::model::public_oplog::{ PluginInstallationDescription, PublicAttributeValue, PublicOplogEntry, PublicUpdateDescription, PublicWorkerInvocation, StringAttributeValue, @@ -363,6 +364,20 @@ pub fn debug_render_oplog_entry(entry: &PublicOplogEntry) -> String { ¶ms.persistence_level, ); } + PublicOplogEntry::CreateAgentInstance(params) => { + let _ = writeln!(result, "CREATE AGENT INSTANCE"); + let _ = writeln!(result, "{pad}at: {}", ¶ms.timestamp); + let _ = writeln!(result, "{pad}agent type: {}", ¶ms.key.agent_type); + let _ = writeln!(result, "{pad}agent id: {}", ¶ms.key.agent_id); + let _ = writeln!(result, "{pad}constructor params:"); + log_data_value(&mut result, pad, ¶ms.parameters); + } + PublicOplogEntry::DropAgentInstance(params) => { + let _ = writeln!(result, "DROP AGENT INSTANCE"); + let _ = writeln!(result, "{pad}at: {}", ¶ms.timestamp); + let _ = writeln!(result, "{pad}agent type: {}", ¶ms.key.agent_type); + let _ = writeln!(result, "{pad}agent id: {}", ¶ms.key.agent_id); + } } result @@ -382,5 +397,50 @@ fn log_plugin_description(output: &mut String, pad: &str, value: &PluginInstalla } fn value_to_string(value: &ValueAndType) -> String { - print_value_and_type(value).expect("Failed to convert value to string") + print_value_and_type(value).unwrap_or_else(|_| format!("{value:?}")) +} + +fn log_data_value(output: &mut String, pad: &str, value: &DataValue) { + match value { + DataValue::Tuple(values) => { + let _ = writeln!(output, "{pad} tuple:"); + for value in &values.elements { + log_element_value(output, &format!("{pad} "), value); + } + } + DataValue::Multimodal(values) => { + let _ = writeln!(output, "{pad} multi-modal:"); + for value in &values.elements { + log_element_value(output, &format!("{pad} "), &value.value); + } + } + } +} + +fn log_element_value(output: &mut String, pad: &str, value: &ElementValue) { + match value { + ElementValue::ComponentModel(value) => { + let _ = writeln!(output, "{pad}- {}", value_to_string(value)); + } + ElementValue::UnstructuredText(value) => match value { + TextReference::Url(url) => { + let _ = writeln!(output, "{pad}- URL: {}", url.value); + } + TextReference::Inline(inline) => { + let _ = writeln!(output, "{pad}- Inline: {}", inline.data); + if let Some(text_type) = &inline.text_type { + let _ = writeln!(output, "{pad} Language code: {}", text_type.language_code); + } + } + }, + ElementValue::UnstructuredBinary(value) => match value { + BinaryReference::Url(url) => { + let _ = writeln!(output, "{pad}- URL: {}", url.value); + } + BinaryReference::Inline(inline) => { + let _ = writeln!(output, "{pad}- Inline: {} bytes", inline.data.len()); + let _ = writeln!(output, "{pad} MIME type: {}", inline.binary_type.mime_type); + } + }, + } } diff --git a/golem-test-framework/src/dsl/mod.rs b/golem-test-framework/src/dsl/mod.rs index 30e4362526..b1e1f3f779 100644 --- a/golem-test-framework/src/dsl/mod.rs +++ b/golem-test-framework/src/dsl/mod.rs @@ -50,14 +50,15 @@ use golem_common::model::plugin::PluginWasmFileKey; use golem_common::model::public_oplog::PublicOplogEntry; use golem_common::model::regions::DeletedRegions; use golem_common::model::{ - AccountId, ComponentFilePath, ComponentFilePermissions, PluginInstallationId, ProjectId, - WorkerStatus, + AccountId, AgentInstanceDescription, AgentInstanceKey, ComponentFilePath, + ComponentFilePermissions, ExportedResourceInstanceDescription, ExportedResourceInstanceKey, + PluginInstallationId, ProjectId, WorkerResourceDescription, WorkerResourceKey, WorkerStatus, }; use golem_common::model::{ ComponentFileSystemNode, ComponentId, ComponentType, ComponentVersion, FailedUpdateRecord, IdempotencyKey, InitialComponentFile, InitialComponentFileKey, ScanCursor, SuccessfulUpdateRecord, TargetWorkerId, WorkerFilter, WorkerId, WorkerMetadata, - WorkerResourceDescription, WorkerStatusRecord, + WorkerStatusRecord, }; use golem_common::widen_infallible; use golem_service_base::model::{ComponentName, PublicOplogEntryWithIndex, RevertWorkerTarget}; @@ -2141,18 +2142,39 @@ pub fn to_worker_metadata( owned_resources: metadata .owned_resources .iter() - .map(|(k, v)| { - ( - WorkerResourceId(*k), - WorkerResourceDescription { - created_at: (*v - .created_at - .as_ref() - .expect("no timestamp on resource metadata")) - .into(), - indexed_resource_key: v.indexed.clone().map(|i| i.into()), - }, - ) + .map(|description| { + match &description.description { + Some(golem_api_grpc::proto::golem::worker::resource_description::Description::ExportedResourceInstance(desc)) => { + ( + WorkerResourceKey::ExportedResourceInstanceKey(ExportedResourceInstanceKey { resource_id: WorkerResourceId(desc.resource_id) }), + WorkerResourceDescription::ExportedResourceInstance(ExportedResourceInstanceDescription { + created_at: desc.created_at.expect("Missing created_at").into(), + resource_name: desc.resource_name.clone(), + resource_owner: desc.resource_owner.clone(), + resource_params: if desc.is_indexed { + Some(desc.resource_params.clone()) + } else { + None + } + }) + ) + } + Some(golem_api_grpc::proto::golem::worker::resource_description::Description::AgentInstance(desc)) => { + ( + WorkerResourceKey::AgentInstanceKey(AgentInstanceKey { + agent_type: desc.agent_type.clone(), + agent_id: desc.agent_id.clone() + }), + WorkerResourceDescription::AgentInstance(AgentInstanceDescription { + created_at: desc.created_at.expect("Missing created_at").into(), + agent_parameters: desc.clone().agent_parameters.expect("Missing agent_parameters").try_into().expect("invalid agent_parameters"), + }) + ) + } + None => { + panic!("Invalid resource description: {description:?}"); + } + } }) .collect(), active_plugins: HashSet::from_iter( diff --git a/golem-worker-executor/src/bootstrap.rs b/golem-worker-executor/src/bootstrap.rs index 2ab9777ab5..6d63db5981 100644 --- a/golem-worker-executor/src/bootstrap.rs +++ b/golem-worker-executor/src/bootstrap.rs @@ -13,7 +13,7 @@ // limitations under the License. use crate::durable_host::DurableWorkerCtx; -use crate::preview2::{golem_api_1_x, golem_durability}; +use crate::preview2::{golem_agent, golem_api_1_x, golem_durability}; use crate::services::active_workers::ActiveWorkers; use crate::services::blob_store::BlobStoreService; use crate::services::component::ComponentService; @@ -221,6 +221,7 @@ impl Bootstrap for ServerBootstrap { golem_api_1_x::oplog::add_to_linker_get_host(&mut linker, get_durable_ctx)?; golem_api_1_x::context::add_to_linker_get_host(&mut linker, get_durable_ctx)?; golem_durability::durability::add_to_linker_get_host(&mut linker, get_durable_ctx)?; + golem_agent::host::add_to_linker_get_host(&mut linker, get_durable_ctx)?; golem_wasm_rpc::golem_rpc_0_2_x::types::add_to_linker_get_host( &mut linker, get_durable_ctx, diff --git a/golem-worker-executor/src/durable_host/dynamic_linking/mod.rs b/golem-worker-executor/src/durable_host/dynamic_linking/mod.rs index 4b38d1ee71..2ae347b83f 100644 --- a/golem-worker-executor/src/durable_host/dynamic_linking/mod.rs +++ b/golem-worker-executor/src/durable_host/dynamic_linking/mod.rs @@ -49,7 +49,7 @@ impl DynamicLinking ComponentItem::ComponentInstance(ref inst) => { match component_metadata .metadata - .dynamic_linking + .dynamic_linking() .get(&name.to_string()) { Some(DynamicLinkedInstance::WasmRpc(rpc_metadata)) => { diff --git a/golem-worker-executor/src/durable_host/dynamic_linking/wasm_rpc.rs b/golem-worker-executor/src/durable_host/dynamic_linking/wasm_rpc.rs index 9c2a1cfa0b..cac4c3afed 100644 --- a/golem-worker-executor/src/durable_host/dynamic_linking/wasm_rpc.rs +++ b/golem-worker-executor/src/durable_host/dynamic_linking/wasm_rpc.rs @@ -16,12 +16,18 @@ use crate::durable_host::wasm_rpc::{create_rpc_connection_span, WasmRpcEntryPayl use crate::services::rpc::{RpcDemand, RpcError}; use crate::workerctx::WorkerCtx; use anyhow::{anyhow, Context}; -use golem_common::model::component_metadata::DynamicLinkedWasmRpc; +use golem_common::model::component_metadata::{DynamicLinkedWasmRpc, InvokableFunction}; use golem_common::model::invocation_context::SpanId; use golem_common::model::{ComponentId, ComponentType, OwnedWorkerId, TargetWorkerId, WorkerId}; +use golem_wasm_ast::analysis::analysed_type::str; +use golem_wasm_ast::analysis::{ + AnalysedResourceId, AnalysedResourceMode, AnalysedType, TypeHandle, +}; use golem_wasm_rpc::golem_rpc_0_2_x::types::{FutureInvokeResult, HostFutureInvokeResult}; -use golem_wasm_rpc::wasmtime::{decode_param, encode_output, ResourceStore}; -use golem_wasm_rpc::{CancellationTokenEntry, HostWasmRpc, Uri, Value, WasmRpcEntry, WitValue}; +use golem_wasm_rpc::wasmtime::{decode_param, encode_output, ResourceStore, ResourceTypeId}; +use golem_wasm_rpc::{ + CancellationTokenEntry, HostWasmRpc, IntoValue, Uri, Value, WasmRpcEntry, WitValue, +}; use itertools::Itertools; use rib::{ParsedFunctionName, ParsedFunctionReference}; use std::collections::HashMap; @@ -286,6 +292,20 @@ async fn dynamic_function_call>(); + match component_type { + ComponentType::Durable => { + analysed_param_types.insert(0, &str()); + } + ComponentType::Ephemeral => {} + } + let constructor_result = remote_invoke_and_await( target_constructor_name, params, param_types, + &constructor + .analysed_export + .parameters + .iter() + .map(|p| &p.typ) + .collect::>(), &mut store, handle, ) @@ -367,6 +406,20 @@ async fn dynamic_function_call>(); + + let worker_id_type = WorkerId::get_type(); + let component_id_type = ComponentId::get_type(); + match component_type { + ComponentType::Durable => { + analysed_param_types.insert(0, &worker_id_type); + } + ComponentType::Ephemeral => { + analysed_param_types.insert(0, &component_id_type); + } + } + let constructor_result = remote_invoke_and_await( target_constructor_name, params, param_types, + &analysed_param_types, &mut store, handle, ) @@ -435,10 +507,42 @@ async fn dynamic_function_call = handle.try_into_resource(&mut store)?; + let target_component_metadata = { + let remote_worker_id = { + let mut wasi = store.data_mut().as_wasi_view(); + let entry = wasi.table().get(&handle)?; + let payload = entry.payload.downcast_ref::().unwrap(); + payload.remote_worker_id().clone() + }; + store + .data() + .component_service() + .get_metadata( + &remote_worker_id.project_id, + &remote_worker_id.worker_id.component_id, + None, + ) + .await? + .metadata + }; + let target_function_metadata = target_component_metadata + .find_parsed_function(target_function_name) + .await + .map_err(|e| anyhow!("Failed to get target function metadata: {e}"))? + .ok_or_else(|| { + anyhow!( + "Target function {target_function_name} not found in component metadata" + ) + })?; + + let analysed_param_types = + get_analysed_param_types_on_rpc_resource(&target_function_metadata); + let result = remote_invoke_and_await( target_function_name, params, param_types, + &analysed_param_types, &mut store, handle, ) @@ -458,10 +562,42 @@ async fn dynamic_function_call = handle.try_into_resource(&mut store)?; + let target_component_metadata = { + let remote_worker_id = { + let mut wasi = store.data_mut().as_wasi_view(); + let entry = wasi.table().get(&handle)?; + let payload = entry.payload.downcast_ref::().unwrap(); + payload.remote_worker_id().clone() + }; + store + .data() + .component_service() + .get_metadata( + &remote_worker_id.project_id, + &remote_worker_id.worker_id.component_id, + None, + ) + .await? + .metadata + }; + let target_function_metadata = target_component_metadata + .find_parsed_function(target_function_name) + .await + .map_err(|e| anyhow!("Failed to get target function metadata: {e}"))? + .ok_or_else(|| { + anyhow!( + "Target function {target_function_name} not found in component metadata" + ) + })?; + + let analysed_param_types = + get_analysed_param_types_on_rpc_resource(&target_function_metadata); + remote_invoke( target_function_name, params, param_types, + &analysed_param_types, &mut store, handle, ) @@ -478,6 +614,36 @@ async fn dynamic_function_call = handle.try_into_resource(&mut store)?; + let target_component_metadata = { + let remote_worker_id = { + let mut wasi = store.data_mut().as_wasi_view(); + let entry = wasi.table().get(&handle)?; + let payload = entry.payload.downcast_ref::().unwrap(); + payload.remote_worker_id().clone() + }; + store + .data() + .component_service() + .get_metadata( + &remote_worker_id.project_id, + &remote_worker_id.worker_id.component_id, + None, + ) + .await? + .metadata + }; + let target_function_metadata = target_component_metadata + .find_parsed_function(target_function_name) + .await + .map_err(|e| anyhow!("Failed to get target function metadata: {e}"))? + .ok_or_else(|| { + anyhow!( + "Target function {target_function_name} not found in component metadata" + ) + })?; + let analysed_param_types = + get_analysed_param_types_on_rpc_resource(&target_function_metadata); + // function should have at least one parameter for the scheduled_for datetime. if !(!params.is_empty() && !param_types.is_empty()) { Err(anyhow!( @@ -492,6 +658,7 @@ async fn dynamic_function_call = handle.try_into_resource(&mut store)?; + let target_component_metadata = { + let remote_worker_id = { + let mut wasi = store.data_mut().as_wasi_view(); + let entry = wasi.table().get(&handle)?; + let payload = entry.payload.downcast_ref::().unwrap(); + payload.remote_worker_id().clone() + }; + store + .data() + .component_service() + .get_metadata( + &remote_worker_id.project_id, + &remote_worker_id.worker_id.component_id, + None, + ) + .await? + .metadata + }; + let target_function_metadata = target_component_metadata + .find_parsed_function(target_function_name) + .await + .map_err(|e| anyhow!("Failed to get target function metadata: {e}"))? + .ok_or_else(|| { + anyhow!( + "Target function {target_function_name} not found in component metadata" + ) + })?; + + let analysed_param_types = + get_analysed_param_types_on_rpc_resource(&target_function_metadata); + let result = remote_async_invoke_and_await( target_function_name, params, param_types, + &analysed_param_types, &mut store, handle, ) @@ -531,7 +730,16 @@ async fn dynamic_function_call = handle.try_into_resource(&mut store)?; let pollable = store.data_mut().subscribe(handle).await?; let pollable_any = pollable.try_into_resource_any(&mut store)?; - let resource_id = store.data_mut().add(pollable_any).await; + let resource_id = store + .data_mut() + .add( + pollable_any, + ResourceTypeId { + owner: "wasi:io@0.2.3/poll".to_string(), // TODO: move this to some constant so it's easier to get updated + name: "pollable".to_string(), + }, + ) + .await; let value_result = Value::Tuple(vec![Value::Handle { uri: store.data().self_uri().value, @@ -578,6 +786,29 @@ async fn dynamic_function_call Vec<&AnalysedType> { + let mut analysed_param_types = target_function_metadata + .analysed_export + .parameters + .iter() + .map(|p| &p.typ) + .collect::>(); + + analysed_param_types.insert( + 0, + &AnalysedType::Handle(TypeHandle { + name: None, + owner: None, + resource_id: AnalysedResourceId(u64::MAX), // NOTE: this is a fake value but currently it does not cause any issues + mode: AnalysedResourceMode::Borrowed, + }), + ); + + analysed_param_types +} + fn unwrap_constructor_result(constructor_result: Value) -> anyhow::Result<(Uri, u64)> { if let Value::Tuple(values) = constructor_result { if values.len() == 1 { @@ -643,11 +874,18 @@ async fn drop_linked_resource( params: &[Val], param_types: &[Type], + analysed_parameter_types: &[&AnalysedType], store: &mut StoreContextMut<'_, Ctx>, ) -> anyhow::Result> { let mut wit_value_params = Vec::new(); - for (idx, (param, typ)) in params.iter().zip(param_types).enumerate().skip(1) { - let value: Value = encode_output(param, typ, store.data_mut()) + for (idx, ((param, typ), analysed_type)) in params + .iter() + .zip(param_types) + .zip(analysed_parameter_types) + .enumerate() + .skip(1) + { + let value: Value = encode_output(param, typ, analysed_type, store.data_mut()) .await .map_err(|err| anyhow!(format!("Failed to encode parameter {idx}: {err}")))?; let wit_value: WitValue = value.into(); @@ -660,10 +898,11 @@ async fn remote_invoke_and_await, handle: Resource, ) -> anyhow::Result { - let wit_value_params = encode_parameters(params, param_types, store) + let wit_value_params = encode_parameters(params, param_types, analysed_param_types, store) .await .context(format!("Encoding parameters of {target_function_name}"))?; @@ -680,10 +919,11 @@ async fn remote_async_invoke_and_await, handle: Resource, ) -> anyhow::Result { - let wit_value_params = encode_parameters(params, param_types, store) + let wit_value_params = encode_parameters(params, param_types, analysed_param_types, store) .await .context(format!("Encoding parameters of {target_function_name}"))?; @@ -693,7 +933,16 @@ async fn remote_async_invoke_and_await( target_function_name: &ParsedFunctionName, params: &[Val], param_types: &[Type], + analysed_param_types: &[&AnalysedType], store: &mut StoreContextMut<'_, Ctx>, handle: Resource, ) -> anyhow::Result<()> { - let wit_value_params = encode_parameters(params, param_types, store) + let wit_value_params = encode_parameters(params, param_types, analysed_param_types, store) .await .context(format!("Encoding parameters of {target_function_name}"))?; @@ -726,10 +976,11 @@ async fn schedule_remote_invocation, handle: Resource, ) -> anyhow::Result> { - let wit_value_params = encode_parameters(params, param_types, store) + let wit_value_params = encode_parameters(params, param_types, analysed_param_types, store) .await .context(format!("Encoding parameters of {target_function_name}"))?; diff --git a/golem-worker-executor/src/durable_host/filesystem/types.rs b/golem-worker-executor/src/durable_host/filesystem/types.rs index f645458130..4d48b6df96 100644 --- a/golem-worker-executor/src/durable_host/filesystem/types.rs +++ b/golem-worker-executor/src/durable_host/filesystem/types.rs @@ -84,7 +84,7 @@ impl HostDescriptor for DurableWorkerCtx { async fn get_flags(&mut self, fd: Resource) -> Result { self.observe_function_call("filesystem::types::descriptor", "get_flags"); - let read_only = self.is_read_only(&fd)?; + let read_only = self.check_if_file_is_readonly(&fd)?; let wasi_view = &mut self.as_wasi_view(); let mut descriptor_flags = HostDescriptor::get_flags(wasi_view, fd).await?; diff --git a/golem-worker-executor/src/durable_host/golem/agent.rs b/golem-worker-executor/src/durable_host/golem/agent.rs new file mode 100644 index 0000000000..3dd6b975bb --- /dev/null +++ b/golem-worker-executor/src/durable_host/golem/agent.rs @@ -0,0 +1,71 @@ +// Copyright 2024-2025 Golem Cloud +// +// Licensed under the Golem Source License v1.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::durable_host::DurableWorkerCtx; +use crate::workerctx::{AgentStore, WorkerCtx}; +use anyhow::anyhow; +use golem_common::model::agent::bindings::golem::agent::host::{DataValue, Host}; +use golem_common::model::agent::DataSchema; + +impl Host for DurableWorkerCtx { + async fn register_agent( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) -> anyhow::Result<()> { + let agent = self + .component_metadata() + .metadata + .find_agent_type(&agent_type) + .await + .map_err(|e| anyhow!(e))? + .ok_or_else(|| anyhow!("Unknown agent type: {}", agent_type))?; + let parameters = get_data_value(parameters, agent.constructor.input_schema)?; + self.store_agent_instance(agent_type, agent_id, parameters) + .await; + + Ok(()) + } + + async fn unregister_agent( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) -> anyhow::Result<()> { + let agent = self + .component_metadata() + .metadata + .find_agent_type(&agent_type) + .await + .map_err(|e| anyhow!(e))? + .ok_or_else(|| anyhow!("Unknown agent type: {}", agent_type))?; + let parameters = get_data_value(parameters, agent.constructor.input_schema)?; + self.remove_agent_instance(agent_type, agent_id, parameters) + .await; + + Ok(()) + } +} + +fn get_data_value( + value: DataValue, + schema: DataSchema, +) -> anyhow::Result { + let parameters = golem_common::model::agent::DataValue::try_from_bindings(value, schema.into()) + .map_err(|err| anyhow!(err))?; + + Ok(parameters) +} diff --git a/golem-worker-executor/src/durable_host/golem/mod.rs b/golem-worker-executor/src/durable_host/golem/mod.rs index 49db6e46b5..0489c49406 100644 --- a/golem-worker-executor/src/durable_host/golem/mod.rs +++ b/golem-worker-executor/src/durable_host/golem/mod.rs @@ -12,5 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. +pub mod agent; pub mod invocation_context_api; pub mod v1x; diff --git a/golem-worker-executor/src/durable_host/golem/v1x.rs b/golem-worker-executor/src/durable_host/golem/v1x.rs index 416cf2e1d4..adbb67b33f 100644 --- a/golem-worker-executor/src/durable_host/golem/v1x.rs +++ b/golem-worker-executor/src/durable_host/golem/v1x.rs @@ -1198,6 +1198,13 @@ impl From for golem_common::model::Wo filter.value.into(), ) } + golem_api_1_x::host::WorkerPropertyFilter::WasiConfigVars(filter) => { + golem_common::model::WorkerFilter::new_wasi_config_vars( + filter.name, + filter.comparator.into(), + filter.value, + ) + } } } } @@ -1222,6 +1229,7 @@ impl From for golem_api_1_x::host::WorkerMe worker_id: value.worker_id.into(), args: value.args, env: value.env, + wasi_config_vars: value.wasi_config_vars.into_iter().collect(), status: value.last_known_status.status.into(), component_version: value.last_known_status.component_version, retry_count: 0, diff --git a/golem-worker-executor/src/durable_host/mod.rs b/golem-worker-executor/src/durable_host/mod.rs index 0daa7faf87..913a1d4b4a 100644 --- a/golem-worker-executor/src/durable_host/mod.rs +++ b/golem-worker-executor/src/durable_host/mod.rs @@ -65,15 +65,13 @@ use crate::services::{ }; use crate::services::{HasOplogService, HasPlugins}; use crate::wasi_host; -use crate::worker::invocation::{ - find_first_available_function, invoke_observed_and_traced, InvokeResult, -}; +use crate::worker::invocation::{invoke_observed_and_traced, InvokeResult}; use crate::worker::status::calculate_last_known_status; use crate::worker::{interpret_function_result, is_worker_error_retriable, RetryDecision, Worker}; use crate::workerctx::{ - ExternalOperations, FileSystemReading, IndexedResourceStore, InvocationContextManagement, - InvocationHooks, InvocationManagement, LogEventEmitBehaviour, PublicWorkerIo, StatusManagement, - UpdateManagement, WorkerCtx, + AgentStore, ExternalOperations, FileSystemReading, IndexedResourceStore, + InvocationContextManagement, InvocationHooks, InvocationManagement, LogEventEmitBehaviour, + PublicWorkerIo, StatusManagement, UpdateManagement, WorkerCtx, }; use anyhow::anyhow; use async_trait::async_trait; @@ -83,6 +81,7 @@ pub use durability::*; use futures::future::try_join_all; use futures::TryFutureExt; use futures::TryStreamExt; +use golem_common::model::agent::DataValue; use golem_common::model::invocation_context::{ AttributeValue, InvocationContextSpan, InvocationContextStack, SpanId, }; @@ -91,7 +90,10 @@ use golem_common::model::oplog::{ TimestampedUpdateDescription, UpdateDescription, WorkerError, WorkerResourceId, }; use golem_common::model::regions::{DeletedRegions, OplogRegion}; -use golem_common::model::{exports, AccountId, PluginInstallationId, ProjectId}; +use golem_common::model::{ + AccountId, AgentInstanceDescription, AgentInstanceKey, ExportedResourceInstanceDescription, + ExportedResourceInstanceKey, PluginInstallationId, ProjectId, WorkerResourceKey, +}; use golem_common::model::{ ComponentFilePath, ComponentFilePermissions, ComponentFileSystemNode, ComponentFileSystemNodeDetails, ComponentId, ComponentType, ComponentVersion, @@ -102,7 +104,7 @@ use golem_common::model::{ use golem_common::model::{RetryConfig, TargetWorkerId}; use golem_common::retries::get_delay; use golem_service_base::error::worker_executor::{InterruptKind, WorkerExecutorError}; -use golem_wasm_rpc::wasmtime::ResourceStore; +use golem_wasm_rpc::wasmtime::{ResourceStore, ResourceTypeId}; use golem_wasm_rpc::{Uri, Value, ValueAndType}; use replay_state::ReplayEvent; use std::collections::{BTreeMap, HashMap, HashSet}; @@ -279,7 +281,10 @@ impl DurableWorkerCtx { .expect("ResourceTable mutex must never fail") } - fn is_read_only(&mut self, fd: &Resource) -> Result { + fn check_if_file_is_readonly( + &mut self, + fd: &Resource, + ) -> Result { let table = Arc::get_mut(&mut self.table) .expect("ResourceTable is shared and cannot be borrowed mutably") .get_mut() @@ -296,7 +301,7 @@ impl DurableWorkerCtx { } fn fail_if_read_only(&mut self, fd: &Resource) -> FsResult<()> { - if self.is_read_only(fd)? { + if self.check_if_file_is_readonly(fd)? { Err(wasmtime_wasi::p2::bindings::filesystem::types::ErrorCode::NotPermitted.into()) } else { Ok(()) @@ -609,73 +614,82 @@ impl> DurableWorkerCtx { .await { Ok(Some(data)) => { - let failed = if let Some(load_snapshot) = find_first_available_function( - store, - instance, - vec![ - "golem:api/load-snapshot@1.1.0.{load}".to_string(), - "golem:api/load-snapshot@0.2.0.{load}".to_string(), - ], - ) { - let idempotency_key = IdempotencyKey::fresh(); - store - .as_context_mut() - .data_mut() - .durable_ctx_mut() - .set_current_idempotency_key(idempotency_key.clone()) - .await; - - store - .as_context_mut() - .data_mut() - .begin_call_snapshotting_function(); - let load_result = invoke_observed_and_traced( - load_snapshot, - vec![Value::List(data.iter().map(|b| Value::U8(*b)).collect())], - store, - instance, - ) - .await; - store - .as_context_mut() - .data_mut() - .end_call_snapshotting_function(); + let component_metadata = store + .as_context() + .data() + .component_metadata() + .metadata + .clone(); + + let failed = match component_metadata.load_snapshot().await { + Ok(Some(load_snapshot)) => { + let idempotency_key = IdempotencyKey::fresh(); + store + .as_context_mut() + .data_mut() + .durable_ctx_mut() + .set_current_idempotency_key(idempotency_key.clone()) + .await; - match load_result { - Err(error) => { - Some(format!("Manual update failed to load snapshot: {error}")) - } - Ok(InvokeResult::Failed { error, .. }) => { - let stderr = store - .as_context() - .data() - .get_public_state() - .event_service() - .get_last_invocation_errors(); - let error = error.to_string(&stderr); - Some(format!("Manual update failed to load snapshot: {error}")) - } - Ok(InvokeResult::Succeeded { output, .. }) => { - if let Some(output) = output { - match output { - Value::Result(Err(Some(boxed_error_value))) => { - match &*boxed_error_value { - Value::String(error) => - Some(format!("Manual update failed to load snapshot: {error}")), - _ => - Some("Unexpected result value from the snapshot load function".to_string()) + store + .as_context_mut() + .data_mut() + .begin_call_snapshotting_function(); + let load_result = invoke_observed_and_traced( + load_snapshot.name.to_string(), + vec![Value::List(data.iter().map(|b| Value::U8(*b)).collect())], + store, + instance, + &component_metadata, + ) + .await; + store + .as_context_mut() + .data_mut() + .end_call_snapshotting_function(); + + match load_result { + Err(error) => Some(format!( + "Manual update failed to load snapshot: {error}" + )), + Ok(InvokeResult::Failed { error, .. }) => { + let stderr = store + .as_context() + .data() + .get_public_state() + .event_service() + .get_last_invocation_errors(); + let error = error.to_string(&stderr); + Some(format!( + "Manual update failed to load snapshot: {error}" + )) + } + Ok(InvokeResult::Succeeded { output, .. }) => { + if let Some(output) = output { + match output { + Value::Result(Err(Some(boxed_error_value))) => { + match &*boxed_error_value { + Value::String(error) => + Some(format!("Manual update failed to load snapshot: {error}")), + _ => + Some("Unexpected result value from the snapshot load function".to_string()) + } } + _ => None } - _ => None + } else { + Some("Unexpected result value from the snapshot load function".to_string()) } - } else { - Some("Unexpected result value from the snapshot load function".to_string()) } + _ => None, } - _ => None, } - } else { - Some("Failed to find exported load-snapshot function".to_string()) + Ok(None) => { + Some("Failed to find exported load-snapshot function".to_string()) + } + Err(err) => Some(format!( + "Failed to find exported load-snapshot function: {err}" + )), }; if let Some(error) = failed { @@ -834,10 +848,12 @@ impl DurableWorkerCtx { ) .await?; - (*self.state.read_only_paths.write().unwrap()) = compute_read_only_paths(¤t_files); + let mut read_only_paths = self.state.read_only_paths.write().unwrap(); + *read_only_paths = compute_read_only_paths(¤t_files); // TODO: take config vars from component metadata - (*self.state.wasi_config_vars.write().unwrap()) = effective_wasi_config_vars( + let mut wasi_config_vars = self.state.wasi_config_vars.write().unwrap(); + *wasi_config_vars = effective_wasi_config_vars( self.state.initial_wasi_config_vars.clone(), BTreeMap::new(), ); @@ -1179,19 +1195,25 @@ impl ResourceStore for DurableWorkerCtx { self.state.self_uri() } - async fn add(&mut self, resource: ResourceAny) -> u64 { - let id = self.state.add(resource).await; + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64 { + let id = self.state.add(resource, name.clone()).await; let resource_id = WorkerResourceId(id); if self.state.is_live() { - let entry = OplogEntry::create_resource(resource_id); + let entry = OplogEntry::create_resource(resource_id, name.clone()); self.state.oplog.add(entry.clone()).await; self.update_worker_status(move |status| { status.owned_resources.insert( - resource_id, - WorkerResourceDescription { - created_at: entry.timestamp(), - indexed_resource_key: None, - }, + WorkerResourceKey::ExportedResourceInstanceKey(ExportedResourceInstanceKey { + resource_id, + }), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: entry.timestamp(), + resource_owner: name.owner, + resource_name: name.name, + resource_params: None, + }, + ), ); }) .await; @@ -1199,14 +1221,21 @@ impl ResourceStore for DurableWorkerCtx { id } - async fn get(&mut self, resource_id: u64) -> Option { + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { let result = self.state.borrow(resource_id).await; - if result.is_some() { + if let Some((resource_type_id, _)) = &result { let id = WorkerResourceId(resource_id); if self.state.is_live() { - self.state.oplog.add(OplogEntry::drop_resource(id)).await; + self.state + .oplog + .add(OplogEntry::drop_resource(id, resource_type_id.clone())) + .await; self.update_worker_status(move |status| { - status.owned_resources.remove(&id); + status + .owned_resources + .remove(&WorkerResourceKey::ExportedResourceInstanceKey( + ExportedResourceInstanceKey { resource_id: id }, + )); }) .await; } @@ -1214,7 +1243,7 @@ impl ResourceStore for DurableWorkerCtx { result } - async fn borrow(&self, resource_id: u64) -> Option { + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { self.state.borrow(resource_id).await } } @@ -1322,10 +1351,12 @@ impl UpdateManagement for DurableWorkerCtx { impl IndexedResourceStore for DurableWorkerCtx { fn get_indexed_resource( &self, + resource_owner: &str, resource_name: &str, resource_params: &[String], ) -> Option { let key = IndexedResourceKey { + resource_owner: resource_owner.to_string(), resource_name: resource_name.to_string(), resource_params: resource_params.to_vec(), }; @@ -1334,11 +1365,13 @@ impl IndexedResourceStore for DurableWorkerCtx { async fn store_indexed_resource( &mut self, + resource_owner: &str, resource_name: &str, resource_params: &[String], resource: WorkerResourceId, ) { let key = IndexedResourceKey { + resource_owner: resource_owner.to_string(), resource_name: resource_name.to_string(), resource_params: resource_params.to_vec(), }; @@ -1346,19 +1379,40 @@ impl IndexedResourceStore for DurableWorkerCtx { if self.state.is_live() { self.state .oplog - .add(OplogEntry::describe_resource(resource, key.clone())) + .add(OplogEntry::describe_resource( + resource, + ResourceTypeId { + owner: resource_owner.to_string(), + name: resource_name.to_string(), + }, + key.resource_params.clone(), + )) .await; self.update_worker_status(|status| { - if let Some(description) = status.owned_resources.get_mut(&resource) { - description.indexed_resource_key = Some(key); + if let Some(WorkerResourceDescription::ExportedResourceInstance(description)) = + status + .owned_resources + .get_mut(&WorkerResourceKey::ExportedResourceInstanceKey( + ExportedResourceInstanceKey { + resource_id: resource, + }, + )) + { + description.resource_params = Some(resource_params.to_vec()); } }) .await; } } - fn drop_indexed_resource(&mut self, resource_name: &str, resource_params: &[String]) { + fn drop_indexed_resource( + &mut self, + resource_owner: &str, + resource_name: &str, + resource_params: &[String], + ) { let key = IndexedResourceKey { + resource_owner: resource_owner.to_string(), resource_name: resource_name.to_string(), resource_params: resource_params.to_vec(), }; @@ -1366,6 +1420,72 @@ impl IndexedResourceStore for DurableWorkerCtx { } } +#[async_trait] +impl AgentStore for DurableWorkerCtx { + async fn store_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { + debug!(%agent_type, %agent_id, "Agent instance created"); + + let key = AgentInstanceKey { + agent_type, + agent_id, + }; + let description = AgentInstanceDescription { + created_at: Timestamp::now_utc(), + agent_parameters: parameters.clone(), + }; + self.state + .agent_instances + .insert(key.clone(), description.clone()); + if self.state.is_live() { + self.state + .oplog + .add(OplogEntry::create_agent_instance(key.clone(), parameters)) + .await; + self.update_worker_status(|status| { + status.owned_resources.insert( + WorkerResourceKey::AgentInstanceKey(key), + WorkerResourceDescription::AgentInstance(description.clone()), + ); + }) + .await; + } + } + + async fn remove_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + _parameters: DataValue, + ) { + debug!(%agent_type, %agent_id, "Agent instance dropped"); + + let key = AgentInstanceKey { + agent_type, + agent_id, + }; + + self.state.agent_instances.remove(&key); + + if self.state.is_live() { + self.state + .oplog + .add(OplogEntry::drop_agent_instance(key.clone())) + .await; + self.update_worker_status(|status| { + status + .owned_resources + .remove(&WorkerResourceKey::AgentInstanceKey(key)); + }) + .await; + } + } +} + #[async_trait] impl InvocationContextManagement for DurableWorkerCtx { async fn start_span( @@ -1640,18 +1760,26 @@ impl> ExternalOperations for Dur .set_current_invocation_context(invocation_context) .await?; + let component_metadata = store + .as_context() + .data() + .component_metadata() + .metadata + .clone(); + let full_function_name = function_name.to_string(); let invoke_result = invoke_observed_and_traced( full_function_name.clone(), function_input.clone(), store, instance, + &component_metadata, ) .instrument(span) .await; // We are removing the spans introduced by the invocation. Not calling `finish_span` here, - // as it would add FinishSpan oplog entries without corersponding StartSpan ones. Instead, + // as it would add FinishSpan oplog entries without corresponding StartSpan ones. Instead, // the oplog processor should assume that spans implicitly created by ExportedFunctionInvoked // are finished at ExportedFunctionCompleted. for span_id in local_span_ids { @@ -1669,19 +1797,20 @@ impl> ExternalOperations for Dur let component_metadata = store.as_context().data().component_metadata(); - match exports::function_by_name( - &component_metadata.metadata.exports, - &full_function_name, - ) { + match component_metadata + .metadata + .find_function(&full_function_name) + .await + { Ok(value) => { if let Some(value) = value { - let result = - interpret_function_result(output, value.result) - .map_err(|e| { - WorkerExecutorError::ValueMismatch { - details: e.join(", "), - } - })?; + let result = interpret_function_result( + output, + value.analysed_export.result, + ) + .map_err(|e| WorkerExecutorError::ValueMismatch { + details: e.join(", "), + })?; if let Err(err) = store .as_context_mut() .data_mut() @@ -2360,7 +2489,7 @@ struct PrivateDurableWorkerState { current_idempotency_key: Option, rpc: Arc, worker_proxy: Arc, - resources: HashMap, + resources: HashMap, last_resource_id: WorkerResourceId, replay_state: ReplayState, overridden_retry_policy: Option, @@ -2373,6 +2502,8 @@ struct PrivateDurableWorkerState { snapshotting_mode: Option, indexed_resources: HashMap, + agent_instances: HashMap, + component_metadata: golem_service_base::model::Component, total_linear_memory_size: u64, @@ -2461,6 +2592,7 @@ impl PrivateDurableWorkerState { open_http_requests: HashMap::new(), snapshotting_mode: None, indexed_resources: HashMap::new(), + agent_instances: HashMap::new(), component_metadata, total_linear_memory_size, replay_state, @@ -2666,19 +2798,19 @@ impl ResourceStore for PrivateDurableWorkerState { } } - async fn add(&mut self, resource: ResourceAny) -> u64 { + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64 { let id = self.last_resource_id; self.last_resource_id = self.last_resource_id.next(); - self.resources.insert(id, resource); + self.resources.insert(id, (name, resource)); id.0 } - async fn get(&mut self, resource_id: u64) -> Option { + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { let resource_id = WorkerResourceId(resource_id); self.resources.remove(&resource_id) } - async fn borrow(&self, resource_id: u64) -> Option { + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { self.resources.get(&WorkerResourceId(resource_id)).cloned() } } @@ -2935,7 +3067,7 @@ async fn update_filesystem( let exists = tokio::fs::try_exists(&path).map_err(|e| WorkerExecutorError::FileSystemError { path: file.path.to_rel_string(), reason: format!("Failed checking whether path exists: {e}") }).await?; if exists { - // Try removing it if it's an empty directory, this will fail otherwise and we can report the error. + // Try removing it if it's an empty directory; this will fail otherwise, and we can report the error. tokio::fs::remove_dir(&path).await.map_err(|e| WorkerExecutorError::FileSystemError { path: file.path.to_rel_string(), @@ -2990,7 +3122,7 @@ async fn update_filesystem( return Ok(UpdateFileSystemResult::NoChanges); } - // Try removing it if it's an empty directory, this will fail otherwise and we can report the error. + // Try removing it if it's an empty directory, this will fail otherwise, and we can report the error. tokio::fs::remove_dir(&path).await.map_err(|e| WorkerExecutorError::FileSystemError { path: file.path.to_rel_string(), diff --git a/golem-worker-executor/src/durable_host/wasm_rpc/mod.rs b/golem-worker-executor/src/durable_host/wasm_rpc/mod.rs index df26098ce7..ed32913c79 100644 --- a/golem-worker-executor/src/durable_host/wasm_rpc/mod.rs +++ b/golem-worker-executor/src/durable_host/wasm_rpc/mod.rs @@ -29,7 +29,6 @@ use crate::workerctx::{InvocationContextManagement, InvocationManagement, Worker use anyhow::anyhow; use async_trait::async_trait; use chrono::{DateTime, Utc}; -use golem_common::model::exports::function_by_name; use golem_common::model::invocation_context::{AttributeValue, InvocationContextSpan, SpanId}; use golem_common::model::oplog::{DurableFunctionType, OplogEntry, PersistenceLevel}; use golem_common::model::{ @@ -1165,11 +1164,11 @@ async fn try_get_typed_parameters( .get_metadata(project_id, component_id, None) .await { - if let Ok(Some(function)) = function_by_name(&component.metadata.exports, function_name) { - if function.parameters.len() == params.len() { + if let Ok(Some(function)) = component.metadata.find_function(function_name).await { + if function.analysed_export.parameters.len() == params.len() { return params .iter() - .zip(function.parameters) + .zip(function.analysed_export.parameters) .map(|(value, def)| ValueAndType::new(value.clone().into(), def.typ.clone())) .collect(); } diff --git a/golem-worker-executor/src/grpc/invocation.rs b/golem-worker-executor/src/grpc/invocation.rs index e936dfba69..6666338781 100644 --- a/golem-worker-executor/src/grpc/invocation.rs +++ b/golem-worker-executor/src/grpc/invocation.rs @@ -401,7 +401,7 @@ fn resolve_function<'t>( ParsedFunctionName::parse(function).map_err(WorkerExecutorError::invalid_request)?; let mut functions = Vec::new(); - for export in &component.metadata.exports { + for export in component.metadata.exports() { match export { AnalysedExport::Instance(interface) => { if matches!(parsed.site().interface_name(), Some(name) if name == interface.name) { diff --git a/golem-worker-executor/src/grpc/mod.rs b/golem-worker-executor/src/grpc/mod.rs index e19a9ad4ab..ed68d958e3 100644 --- a/golem-worker-executor/src/grpc/mod.rs +++ b/golem-worker-executor/src/grpc/mod.rs @@ -35,7 +35,7 @@ use futures::Stream; use futures::StreamExt; use gethostname::gethostname; use golem_api_grpc::proto::golem; -use golem_api_grpc::proto::golem::worker::{Cursor, ResourceMetadata, UpdateMode}; +use golem_api_grpc::proto::golem::worker::{Cursor, UpdateMode}; use golem_api_grpc::proto::golem::workerexecutor::v1::worker_executor_server::WorkerExecutor; use golem_api_grpc::proto::golem::workerexecutor::v1::{ ActivatePluginRequest, ActivatePluginResponse, CancelInvocationRequest, @@ -56,6 +56,7 @@ use golem_common::grpc::{ }; use golem_common::metrics::api::record_new_grpc_api_active_stream; use golem_common::model::oplog::{OplogIndex, UpdateDescription}; +use golem_common::model::protobuf::to_protobuf_resource_description; use golem_common::model::{ AccountId, ComponentFilePath, ComponentId, ComponentType, GetFileSystemNodeResult, IdempotencyKey, OwnedWorkerId, PluginInstallationId, ProjectId, ScanCursor, ShardId, @@ -960,10 +961,7 @@ impl + UsesAllDeps + Send + Sync + ) .await; - Ok(Self::create_proto_metadata( - metadata, - last_error_and_retry_count, - )) + Self::create_proto_metadata(metadata, last_error_and_retry_count) } async fn get_running_workers_metadata_internal( @@ -988,7 +986,7 @@ impl + UsesAllDeps + Send + Sync + let result: Vec = workers .into_iter() .map(|worker_metadata| Self::create_proto_metadata(worker_metadata, None)) - .collect(); + .collect::, _>>()?; Ok(result) } @@ -1040,7 +1038,8 @@ impl + UsesAllDeps + Send + Sync + &worker_metadata.last_known_status, ) .await; - let metadata = Self::create_proto_metadata(worker_metadata, last_error_and_retry_count); + let metadata = + Self::create_proto_metadata(worker_metadata, last_error_and_retry_count)?; result.push(metadata); } @@ -1687,7 +1686,7 @@ impl + UsesAllDeps + Send + Sync + fn create_proto_metadata( metadata: WorkerMetadata, last_error_and_retry_count: Option, - ) -> golem::worker::WorkerMetadata { + ) -> Result { let mut updates = Vec::new(); let latest_status = metadata.last_known_status; @@ -1740,20 +1739,18 @@ impl + UsesAllDeps + Send + Sync + + record.timestamp.as_ref().unwrap().nanos as i64 }); - let mut owned_resources = HashMap::new(); + let mut owned_resources = Vec::new(); for (resource_id, resource) in latest_status.owned_resources { - owned_resources.insert( - resource_id.0, - ResourceMetadata { - created_at: Some(resource.created_at.into()), - indexed: resource.indexed_resource_key.map(|t| t.into()), - }, + owned_resources.push( + to_protobuf_resource_description(resource_id, resource).map_err(|err| { + WorkerExecutorError::unknown(format!("Failed to create worker metadata: {err}")) + })?, ); } let active_plugins = latest_status.active_plugins; - golem::worker::WorkerMetadata { + Ok(golem::worker::WorkerMetadata { worker_id: Some(metadata.worker_id.into()), project_id: Some(metadata.project_id.into()), args: metadata.args.clone(), @@ -1786,7 +1783,7 @@ impl + UsesAllDeps + Send + Sync + .into_regions() .map(|region| region.into()) .collect(), - } + }) } } diff --git a/golem-worker-executor/src/model/public_oplog/mod.rs b/golem-worker-executor/src/model/public_oplog/mod.rs index 6747abd6fd..e135c13204 100644 --- a/golem-worker-executor/src/model/public_oplog/mod.rs +++ b/golem-worker-executor/src/model/public_oplog/mod.rs @@ -39,18 +39,19 @@ use crate::services::rpc::RpcError; use async_trait::async_trait; use bincode::Decode; use golem_api_grpc::proto::golem::worker::UpdateMode; -use golem_common::model::exports::{find_resource_site, function_by_name}; +use golem_common::model::exports::find_resource_site; use golem_common::model::lucene::Query; use golem_common::model::oplog::{OplogEntry, OplogIndex, SpanData, UpdateDescription}; use golem_common::model::public_oplog::{ ActivatePluginParameters, CancelInvocationParameters, ChangePersistenceLevelParameters, - ChangeRetryPolicyParameters, CreateParameters, DeactivatePluginParameters, - DescribeResourceParameters, EndRegionParameters, ErrorParameters, - ExportedFunctionCompletedParameters, ExportedFunctionInvokedParameters, - ExportedFunctionParameters, FailedUpdateParameters, FinishSpanParameters, GrowMemoryParameters, - ImportedFunctionInvokedParameters, JumpParameters, LogParameters, ManualUpdateParameters, - PendingUpdateParameters, PendingWorkerInvocationParameters, PluginInstallationDescription, - PublicAttribute, PublicExternalSpanData, PublicLocalSpanData, PublicOplogEntry, PublicSpanData, + ChangeRetryPolicyParameters, CreateAgentInstanceParameters, CreateParameters, + DeactivatePluginParameters, DescribeResourceParameters, DropAgentInstanceParameters, + EndRegionParameters, ErrorParameters, ExportedFunctionCompletedParameters, + ExportedFunctionInvokedParameters, ExportedFunctionParameters, FailedUpdateParameters, + FinishSpanParameters, GrowMemoryParameters, ImportedFunctionInvokedParameters, JumpParameters, + LogParameters, ManualUpdateParameters, PendingUpdateParameters, + PendingWorkerInvocationParameters, PluginInstallationDescription, PublicAttribute, + PublicExternalSpanData, PublicLocalSpanData, PublicOplogEntry, PublicSpanData, PublicUpdateDescription, PublicWorkerInvocation, ResourceParameters, RevertParameters, SetSpanAttributeParameters, SnapshotBasedUpdateParameters, StartSpanParameters, SuccessfulUpdateParameters, TimestampParameter, @@ -354,16 +355,16 @@ impl PublicOplogEntryOps for PublicOplogEntry { ) .await .map_err(|err| err.to_string())?; - let function = function_by_name(&metadata.metadata.exports, &function_name)?.ok_or( + let function = metadata.metadata.find_function(&function_name).await?.ok_or( format!("Exported function {function_name} not found in component {} version {component_version}", owned_worker_id.component_id()) )?; let parsed = ParsedFunctionName::parse(&function_name)?; let param_types: Box> = if parsed.function().is_indexed_resource() { - Box::new(function.parameters.iter().skip(1)) + Box::new(function.analysed_export.parameters.iter().skip(1)) } else { - Box::new(function.parameters.iter()) + Box::new(function.analysed_export.parameters.iter()) }; let request = param_types @@ -476,8 +477,7 @@ impl PublicOplogEntryOps for PublicOplogEntry { .await .map_err(|err| err.to_string())?; - let function = - function_by_name(&metadata.metadata.exports, &full_function_name)?; + let function = metadata.metadata.find_function(&full_function_name).await?; // It is not guaranteed that we can resolve the enqueued invocation's parameter types because // we only know the current component version. If the client enqueued an update earlier and assumes @@ -486,9 +486,10 @@ impl PublicOplogEntryOps for PublicOplogEntry { // If we cannot resolve the type, we leave the `function_input` field empty in the public oplog. let mut params = None; if let Some(function) = function { - if function.parameters.len() == function_input.len() { + if function.analysed_export.parameters.len() == function_input.len() { params = Some( function + .analysed_export .parameters .iter() .zip(function_input) @@ -600,22 +601,31 @@ impl PublicOplogEntryOps for PublicOplogEntry { delta, })) } - OplogEntry::CreateResource { timestamp, id } => { - Ok(PublicOplogEntry::CreateResource(ResourceParameters { - timestamp, - id, - })) - } - OplogEntry::DropResource { timestamp, id } => { - Ok(PublicOplogEntry::DropResource(ResourceParameters { - timestamp, - id, - })) - } + OplogEntry::CreateResource { + timestamp, + id, + resource_type_id, + } => Ok(PublicOplogEntry::CreateResource(ResourceParameters { + timestamp, + id, + name: resource_type_id.name, + owner: resource_type_id.owner, + })), + OplogEntry::DropResource { + timestamp, + id, + resource_type_id, + } => Ok(PublicOplogEntry::DropResource(ResourceParameters { + timestamp, + id, + name: resource_type_id.name, + owner: resource_type_id.owner, + })), OplogEntry::DescribeResource { timestamp, id, - indexed_resource, + resource_type_id, + indexed_resource_parameters, } => { let metadata = components .get_metadata( @@ -626,9 +636,10 @@ impl PublicOplogEntryOps for PublicOplogEntry { .await .map_err(|err| err.to_string())?; - let resource_name = indexed_resource.resource_name.clone(); + let resource_name = resource_type_id.name.clone(); + let resource_owner = resource_type_id.owner.clone(); let resource_constructor_name = ParsedFunctionName::new( - find_resource_site(&metadata.metadata.exports, &resource_name).ok_or( + find_resource_site(metadata.metadata.exports(), &resource_name).ok_or( format!( "Resource site for resource {} not found in component {} version {}", resource_name, @@ -640,15 +651,14 @@ impl PublicOplogEntryOps for PublicOplogEntry { resource: resource_name.clone(), }, ); - let constructor_def = function_by_name(&metadata.metadata.exports, &resource_constructor_name.to_string())?.ok_or( - format!("Resource constructor {resource_constructor_name} not found in component {} version {component_version}", owned_worker_id.component_id()) - )?; + let constructor_def = metadata.metadata.find_function(&resource_constructor_name.to_string()).await?.ok_or( + format!("Resource constructor {resource_constructor_name} not found in component {} version {component_version}", owned_worker_id.component_id()) + )?; let mut resource_params = Vec::new(); - for (value_str, param) in indexed_resource - .resource_params + for (value_str, param) in indexed_resource_parameters .iter() - .zip(constructor_def.parameters) + .zip(constructor_def.analysed_export.parameters) { let value_and_type = parse_value_and_type(¶m.typ, value_str)?; resource_params.push(value_and_type); @@ -659,6 +669,7 @@ impl PublicOplogEntryOps for PublicOplogEntry { id, resource_name, resource_params, + resource_owner, }, )) } @@ -784,6 +795,20 @@ impl PublicOplogEntryOps for PublicOplogEntry { persistence_level: level, }), ), + OplogEntry::CreateAgentInstance { + timestamp, + key, + parameters, + } => Ok(PublicOplogEntry::CreateAgentInstance( + CreateAgentInstanceParameters { + timestamp, + key, + parameters, + }, + )), + OplogEntry::DropAgentInstance { timestamp, key } => Ok( + PublicOplogEntry::DropAgentInstance(DropAgentInstanceParameters { timestamp, key }), + ), } } } diff --git a/golem-worker-executor/src/model/public_oplog/wit.rs b/golem-worker-executor/src/model/public_oplog/wit.rs index 041d7bc475..0ae3e00734 100644 --- a/golem-worker-executor/src/model/public_oplog/wit.rs +++ b/golem-worker-executor/src/model/public_oplog/wit.rs @@ -18,14 +18,15 @@ use crate::preview2::wasi::clocks::wall_clock::Datetime; use golem_common::base_model::ProjectId; use golem_common::model::public_oplog::{ ActivatePluginParameters, CancelInvocationParameters, ChangePersistenceLevelParameters, - ChangeRetryPolicyParameters, CreateParameters, DeactivatePluginParameters, - DescribeResourceParameters, EndRegionParameters, ErrorParameters, - ExportedFunctionCompletedParameters, ExportedFunctionInvokedParameters, - ExportedFunctionParameters, FailedUpdateParameters, FinishSpanParameters, GrowMemoryParameters, - ImportedFunctionInvokedParameters, JumpParameters, LogParameters, ManualUpdateParameters, - PendingUpdateParameters, PendingWorkerInvocationParameters, PluginInstallationDescription, - PublicAttributeValue, PublicDurableFunctionType, PublicRetryConfig, PublicSpanData, - PublicWorkerInvocation, ResourceParameters, RevertParameters, SetSpanAttributeParameters, + ChangeRetryPolicyParameters, CreateAgentInstanceParameters, CreateParameters, + DeactivatePluginParameters, DescribeResourceParameters, DropAgentInstanceParameters, + EndRegionParameters, ErrorParameters, ExportedFunctionCompletedParameters, + ExportedFunctionInvokedParameters, ExportedFunctionParameters, FailedUpdateParameters, + FinishSpanParameters, GrowMemoryParameters, ImportedFunctionInvokedParameters, JumpParameters, + LogParameters, ManualUpdateParameters, PendingUpdateParameters, + PendingWorkerInvocationParameters, PluginInstallationDescription, PublicAttributeValue, + PublicDurableFunctionType, PublicRetryConfig, PublicSpanData, PublicWorkerInvocation, + ResourceParameters, RevertParameters, SetSpanAttributeParameters, SnapshotBasedUpdateParameters, StartSpanParameters, StringAttributeValue, SuccessfulUpdateParameters, TimestampParameter, WriteRemoteBatchedParameters, }; @@ -202,23 +203,30 @@ impl From for oplog::OplogEntry { delta, }) } - PublicOplogEntry::CreateResource(ResourceParameters { timestamp, id }) => { - Self::CreateResource(oplog::CreateResourceParameters { - timestamp: timestamp.into(), - resource_id: id.0, - }) - } - PublicOplogEntry::DropResource(ResourceParameters { timestamp, id }) => { - Self::DropResource(oplog::DropResourceParameters { - timestamp: timestamp.into(), - resource_id: id.0, - }) - } + PublicOplogEntry::CreateResource(ResourceParameters { + timestamp, + id, + name: _, // TODO + owner: _, // TODO + }) => Self::CreateResource(oplog::CreateResourceParameters { + timestamp: timestamp.into(), + resource_id: id.0, + }), + PublicOplogEntry::DropResource(ResourceParameters { + timestamp, + id, + name: _, // TODO + owner: _, // TODO + }) => Self::DropResource(oplog::DropResourceParameters { + timestamp: timestamp.into(), + resource_id: id.0, + }), PublicOplogEntry::DescribeResource(DescribeResourceParameters { timestamp, id, resource_name, resource_params, + resource_owner: _, // TODO }) => Self::DescribeResource(oplog::DescribeResourceParameters { timestamp: timestamp.into(), resource_id: id.0, @@ -313,6 +321,28 @@ impl From for oplog::OplogEntry { timestamp: timestamp.into(), persistence_level: persistence_level.into(), }), + PublicOplogEntry::CreateAgentInstance(CreateAgentInstanceParameters { + timestamp, + key, + parameters, + }) => { + // TODO: add this to WIT - until then we temporarily represent with a log entry + Self::Log(oplog::LogParameters { + timestamp: timestamp.into(), + level: golem_common::model::oplog::LogLevel::Info.into(), + context: "CreateAgentInstance".to_string(), + message: format!("Key: {key:?}, Parameters: {parameters:?}"), + }) + } + PublicOplogEntry::DropAgentInstance(DropAgentInstanceParameters { timestamp, key }) => { + // TODO: add this to WIT - until then we temporarily represent with a log entry + Self::Log(oplog::LogParameters { + timestamp: timestamp.into(), + level: golem_common::model::oplog::LogLevel::Info.into(), + context: "CreateAgentInstance".to_string(), + message: format!("Key: {key:?}"), + }) + } } } } diff --git a/golem-worker-executor/src/preview2/mod.rs b/golem-worker-executor/src/preview2/mod.rs index 85300942cf..a319ba0866 100644 --- a/golem-worker-executor/src/preview2/mod.rs +++ b/golem-worker-executor/src/preview2/mod.rs @@ -57,3 +57,4 @@ pub type Pollable = golem_wasm_rpc::wasi::io::poll::Pollable; // reexports so that we don't have to change version numbers everywhere pub use self::golem::api1_1_7 as golem_api_1_x; pub use self::golem::durability as golem_durability; +pub use golem_common::model::agent::bindings::golem::agent as golem_agent; diff --git a/golem-worker-executor/src/services/oplog/tests.rs b/golem-worker-executor/src/services/oplog/tests.rs index c4379b05db..ae78eca24f 100644 --- a/golem-worker-executor/src/services/oplog/tests.rs +++ b/golem-worker-executor/src/services/oplog/tests.rs @@ -235,22 +235,34 @@ pub fn rounded(entry: OplogEntry) -> OplogEntry { timestamp: rounded_ts(timestamp), delta, }, - OplogEntry::CreateResource { timestamp, id } => OplogEntry::CreateResource { + OplogEntry::CreateResource { + timestamp, + id, + resource_type_id, + } => OplogEntry::CreateResource { timestamp: rounded_ts(timestamp), id, + resource_type_id, }, - OplogEntry::DropResource { timestamp, id } => OplogEntry::DropResource { + OplogEntry::DropResource { + timestamp, + id, + resource_type_id, + } => OplogEntry::DropResource { timestamp: rounded_ts(timestamp), id, + resource_type_id, }, OplogEntry::DescribeResource { timestamp, id, - indexed_resource, + resource_type_id, + indexed_resource_parameters, } => OplogEntry::DescribeResource { timestamp: rounded_ts(timestamp), id, - indexed_resource, + resource_type_id, + indexed_resource_parameters, }, OplogEntry::Log { timestamp, @@ -322,6 +334,19 @@ pub fn rounded(entry: OplogEntry) -> OplogEntry { level, } } + OplogEntry::CreateAgentInstance { + timestamp, + key, + parameters, + } => OplogEntry::CreateAgentInstance { + timestamp: rounded_ts(timestamp), + key, + parameters, + }, + OplogEntry::DropAgentInstance { timestamp, key } => OplogEntry::DropAgentInstance { + timestamp: rounded_ts(timestamp), + key, + }, } } diff --git a/golem-worker-executor/src/services/rpc.rs b/golem-worker-executor/src/services/rpc.rs index 8f728bf6ce..b8efd1858b 100644 --- a/golem-worker-executor/src/services/rpc.rs +++ b/golem-worker-executor/src/services/rpc.rs @@ -604,8 +604,8 @@ impl DirectWorkerInvocationRpc { { enrich_function_name_by_target_information( function_name, - target_component.metadata.root_package_name, - target_component.metadata.root_package_version, + target_component.metadata.root_package_name().clone(), + target_component.metadata.root_package_version().clone(), ) } else { // If we cannot get the target metadata, we just go with the original function name diff --git a/golem-worker-executor/src/worker/invocation.rs b/golem-worker-executor/src/worker/invocation.rs index ccca969162..41ee87843e 100644 --- a/golem-worker-executor/src/worker/invocation.rs +++ b/golem-worker-executor/src/worker/invocation.rs @@ -17,6 +17,7 @@ use crate::model::TrapType; use crate::virtual_export_compat; use crate::workerctx::{PublicWorkerIo, WorkerCtx}; use anyhow::anyhow; +use golem_common::model::component_metadata::{ComponentMetadata, InvokableFunction}; use golem_common::model::oplog::{WorkerError, WorkerResourceId}; use golem_common::model::{IdempotencyKey, WorkerStatus}; use golem_common::virtual_exports; @@ -46,6 +47,7 @@ pub async fn invoke_observed_and_traced( function_input: Vec, store: &mut impl AsContextMut, instance: &wasmtime::component::Instance, + component_metadata: &ComponentMetadata, ) -> Result { let mut store = store.as_context_mut(); let was_live_before = store.data().is_live(); @@ -57,6 +59,7 @@ pub async fn invoke_observed_and_traced( function_input, &mut store, instance, + component_metadata, ) .await; @@ -101,30 +104,6 @@ pub async fn invoke_observed_and_traced( } } -/// Returns the first function from the given list that is available on the instance -/// -/// This can be used to find an exported function when multiple versions of an interface -/// is supported, such as for the load-snapshot/save-snapshot interfaces. -/// -/// This function should not be used on the hot path. -pub fn find_first_available_function( - store: &mut impl AsContextMut, - instance: &wasmtime::component::Instance, - names: Vec, -) -> Option { - let mut store = store.as_context_mut(); - for name in names { - let parsed = ParsedFunctionName::parse(&name).ok()?; - - if let Ok(FindFunctionResult::ExportedFunction(_)) = - find_function(&mut store, instance, &parsed) - { - return Some(name); - } - } - None -} - fn find_function<'a, Ctx: WorkerCtx>( mut store: &mut StoreContextMut<'a, Ctx>, instance: &'a wasmtime::component::Instance, @@ -201,6 +180,7 @@ async fn invoke_observed( mut function_input: Vec, store: &mut impl AsContextMut, instance: &wasmtime::component::Instance, + component_metadata: &ComponentMetadata, ) -> Result { let mut store = store.as_context_mut(); @@ -235,9 +215,14 @@ async fn invoke_observed( let mut extra_fuel = 0; if parsed.function().is_indexed_resource() { - let resource_handle = - get_or_create_indexed_resource(&mut store, instance, &parsed, &full_function_name) - .await?; + let resource_handle = get_or_create_indexed_resource( + &mut store, + instance, + &parsed, + &full_function_name, + component_metadata, + ) + .await?; match resource_handle { InvokeResult::Succeeded { @@ -254,6 +239,16 @@ async fn invoke_observed( } } + let metadata = component_metadata + .find_parsed_function(&parsed) + .await + .map_err(WorkerExecutorError::runtime)? + .ok_or_else(|| { + WorkerExecutorError::invalid_request(format!( + "Could not find exported function: {parsed}" + )) + })?; + let mut call_result = match function { FindFunctionResult::ExportedFunction(function) => { let final_decoded_params = if parsed.function().is_indexed_resource() { @@ -273,6 +268,7 @@ async fn invoke_observed( function, final_decoded_params, &full_function_name, + &metadata, ) .await } @@ -375,10 +371,15 @@ async fn get_or_create_indexed_resource<'a, Ctx: WorkerCtx>( instance: &'a wasmtime::component::Instance, parsed_function_name: &ParsedFunctionName, raw_function_name: &str, + component_metadata: &ComponentMetadata, ) -> Result { let resource_name = parsed_function_name.function().resource_name().ok_or( WorkerExecutorError::invalid_request("Cannot extract resource name from function name"), )?; + let resource_owner = parsed_function_name + .site() + .interface_name() + .unwrap_or_default(); let resource_constructor_name = ParsedFunctionName::new( parsed_function_name.site().clone(), @@ -410,7 +411,7 @@ async fn get_or_create_indexed_resource<'a, Ctx: WorkerCtx>( match store .data() - .get_indexed_resource(resource_name, raw_constructor_params) + .get_indexed_resource(&resource_owner, resource_name, raw_constructor_params) { Some(resource_id) => { debug!("Using existing indexed resource with id {resource_id}"); @@ -451,11 +452,22 @@ async fn get_or_create_indexed_resource<'a, Ctx: WorkerCtx>( debug!("Creating new indexed resource with parameters {constructor_params:?}"); + let constructor_metadata = component_metadata + .find_parsed_function(&resource_constructor_name) + .await + .map_err(WorkerExecutorError::runtime)? + .ok_or_else(|| { + WorkerExecutorError::invalid_request(format!( + "Could not find resource constructor: {resource_constructor_name}" + )) + })?; + let constructor_result = invoke( store, resource_constructor, decoded_constructor_params, raw_function_name, + &constructor_metadata, ) .await?; @@ -465,6 +477,7 @@ async fn get_or_create_indexed_resource<'a, Ctx: WorkerCtx>( store .data_mut() .store_indexed_resource( + &resource_owner, resource_name, raw_constructor_params, WorkerResourceId(*resource_id), @@ -487,6 +500,7 @@ async fn invoke( function: Func, decoded_function_input: Vec, raw_function_name: &str, + metadata: &InvokableFunction, ) -> Result { let mut store = store.as_context_mut(); @@ -514,9 +528,14 @@ async fn invoke( "Function returned with more than one values, which is not supported", )) } else { - match results.iter().zip(types.iter()).next() { - Some((val, typ)) => { - let output = encode_output(val, typ, store.data_mut()) + match results + .iter() + .zip(types.iter()) + .zip(metadata.analysed_export.result.as_ref().map(|r| &r.typ)) + .next() + { + Some(((val, typ), analysed_type)) => { + let output = encode_output(val, typ, analysed_type, store.data_mut()) .await .map_err(WorkerExecutorError::from)?; Ok(InvokeResult::from_success(consumed_fuel, Some(output))) @@ -537,7 +556,7 @@ async fn invoke_http_handler( ) -> Result { let (sender, receiver) = tokio::sync::oneshot::channel(); - let proxy = Proxy::new(&mut *store, instance).unwrap(); + let proxy = Proxy::new(&mut *store, instance)?; let mut store_context = store.as_context_mut(); store_context.data_mut().borrow_fuel().await?; @@ -563,13 +582,11 @@ async fn invoke_http_handler( let incoming = store_context .data_mut() .as_wasi_http_view() - .new_incoming_request(scheme, hyper_request) - .unwrap(); + .new_incoming_request(scheme, hyper_request)?; let outgoing = store_context .data_mut() .as_wasi_http_view() - .new_response_outparam(sender) - .unwrap(); + .new_response_outparam(sender)?; // unsafety comes from scope_and_collect: // @@ -647,12 +664,17 @@ async fn drop_resource( debug!( "Dropping indexed resource {resource:?} with params {resource_params:?} in {raw_function_name}" ); - store - .data_mut() - .drop_indexed_resource(resource, resource_params); + store.data_mut().drop_indexed_resource( + &parsed_function_name + .site() + .interface_name() + .unwrap_or_default(), + resource, + resource_params, + ); } - if let Some(resource) = store.data_mut().get(resource_id).await { + if let Some((_, resource)) = store.data_mut().get(resource_id).await { debug!("Dropping resource {resource:?} in {raw_function_name}"); store.data_mut().borrow_fuel().await?; diff --git a/golem-worker-executor/src/worker/invocation_loop.rs b/golem-worker-executor/src/worker/invocation_loop.rs index f48624a69e..2fa0369975 100644 --- a/golem-worker-executor/src/worker/invocation_loop.rs +++ b/golem-worker-executor/src/worker/invocation_loop.rs @@ -16,9 +16,7 @@ use crate::model::{ReadFileResult, TrapType}; use crate::services::events::Event; use crate::services::oplog::{CommitLevel, OplogOps}; use crate::services::{HasEvents, HasOplog, HasWorker}; -use crate::worker::invocation::{ - find_first_available_function, invoke_observed_and_traced, InvokeResult, -}; +use crate::worker::invocation::{invoke_observed_and_traced, InvokeResult}; use crate::worker::{ interpret_function_result, QueuedWorkerInvocation, RetryDecision, RunningWorker, Worker, WorkerCommand, @@ -30,14 +28,14 @@ use drop_stream::DropStream; use futures::channel::oneshot; use futures::channel::oneshot::Sender; use golem_common::model::oplog::WorkerError; -use golem_common::model::{ - exports, ComponentFilePath, ComponentType, ComponentVersion, IdempotencyKey, OwnedWorkerId, - TimestampedWorkerInvocation, WorkerId, WorkerInvocation, -}; use golem_common::model::{ invocation_context::{AttributeValue, InvocationContextStack}, GetFileSystemNodeResult, }; +use golem_common::model::{ + ComponentFilePath, ComponentType, ComponentVersion, IdempotencyKey, OwnedWorkerId, + TimestampedWorkerInvocation, WorkerId, WorkerInvocation, +}; use golem_common::retries::get_delay; use golem_service_base::error::worker_executor::{InterruptKind, WorkerExecutorError}; use golem_wasm_ast::analysis::AnalysedFunctionResult; @@ -505,6 +503,8 @@ impl Invocation<'_, Ctx> { .set_current_idempotency_key(idempotency_key.clone()) .await; + let component_metadata = self.store.data().component_metadata().metadata.clone(); + Self::extend_invocation_context( &mut invocation_context, &idempotency_key, @@ -536,6 +536,7 @@ impl Invocation<'_, Ctx> { function_input.to_owned(), self.store, self.instance, + &component_metadata, ) .await; @@ -567,12 +568,14 @@ impl Invocation<'_, Ctx> { ) -> CommandOutcome { let component_metadata = self.store.as_context().data().component_metadata(); - let function_results = - exports::function_by_name(&component_metadata.metadata.exports, &full_function_name); + let function_results = component_metadata + .metadata + .find_function(&full_function_name) + .await; match function_results { - Ok(Some(export_function)) => { - let function_results = export_function.result.clone(); + Ok(Some(invokable_function)) => { + let function_results = invokable_function.analysed_export.result.clone(); match self .exported_function_invocation_finished_with_type( @@ -711,105 +714,118 @@ impl Invocation<'_, Ctx> { .await; idempotency_key }; - - if let Some(save_snapshot) = find_first_available_function( - self.store, - self.instance, - vec![ - "golem:api/save-snapshot@1.1.0.{save}".to_string(), - "golem:api/save-snapshot@0.2.0.{save}".to_string(), - ], - ) { - self.store.data_mut().begin_call_snapshotting_function(); - - let result = - invoke_observed_and_traced(save_snapshot, vec![], self.store, self.instance).await; - self.store.data_mut().end_call_snapshotting_function(); - - match result { - Ok(InvokeResult::Succeeded { output, .. }) => { - if let Some(bytes) = Self::decode_snapshot_result(output) { - match self - .store - .data() - .get_public_state() - .oplog() - .create_snapshot_based_update_description(target_version, &bytes) - .await - { - Ok(update_description) => { - // Enqueue the update - self.parent.enqueue_update(update_description).await; - - // Make sure to update the pending updates queue - self.store.data().update_pending_updates().await; - - // Reactivate the worker - CommandOutcome::BreakInnerLoop(RetryDecision::Immediate) - // Stop processing the queue to avoid race conditions - } - Err(error) => { - self.fail_update( - target_version, - format!( - "failed to store the snapshot for manual update: {error}" - ), - ) + let component_metadata = self.store.data().component_metadata().metadata.clone(); + + match component_metadata.save_snapshot().await { + Ok(Some(save_snapshot)) => { + self.store.data_mut().begin_call_snapshotting_function(); + + let result = invoke_observed_and_traced( + save_snapshot.name.to_string(), + vec![], + self.store, + self.instance, + &component_metadata, + ) + .await; + self.store.data_mut().end_call_snapshotting_function(); + + match result { + Ok(InvokeResult::Succeeded { output, .. }) => { + if let Some(bytes) = Self::decode_snapshot_result(output) { + match self + .store + .data() + .get_public_state() + .oplog() + .create_snapshot_based_update_description(target_version, &bytes) .await + { + Ok(update_description) => { + // Enqueue the update + self.parent.enqueue_update(update_description).await; + + // Make sure to update the pending updates queue + self.store.data().update_pending_updates().await; + + // Reactivate the worker + CommandOutcome::BreakInnerLoop(RetryDecision::Immediate) + // Stop processing the queue to avoid race conditions + } + Err(error) => { + self.fail_update( + target_version, + format!( + "failed to store the snapshot for manual update: {error}" + ), + ) + .await + } } + } else { + self.fail_update( + target_version, + "failed to get a snapshot for manual update: invalid snapshot result" + .to_string(), + ) + .await } - } else { + } + Ok(InvokeResult::Failed { error, .. }) => { + let stderr = self + .store + .data() + .get_public_state() + .event_service() + .get_last_invocation_errors(); + let error = error.to_string(&stderr); self.fail_update( target_version, - "failed to get a snapshot for manual update: invalid snapshot result" + format!("failed to get a snapshot for manual update: {error}"), + ) + .await + } + Ok(InvokeResult::Exited { .. }) => { + self.fail_update( + target_version, + "failed to get a snapshot for manual update: it called exit" .to_string(), ) .await } - } - Ok(InvokeResult::Failed { error, .. }) => { - let stderr = self - .store - .data() - .get_public_state() - .event_service() - .get_last_invocation_errors(); - let error = error.to_string(&stderr); - self.fail_update( - target_version, - format!("failed to get a snapshot for manual update: {error}"), - ) - .await - } - Ok(InvokeResult::Exited { .. }) => { - self.fail_update( - target_version, - "failed to get a snapshot for manual update: it called exit".to_string(), - ) - .await - } - Ok(InvokeResult::Interrupted { interrupt_kind, .. }) => { - self.fail_update( - target_version, - format!("failed to get a snapshot for manual update: {interrupt_kind:?}"), - ) - .await - } - Err(error) => { - self.fail_update( - target_version, - format!("failed to get a snapshot for manual update: {error:?}"), - ) - .await + Ok(InvokeResult::Interrupted { interrupt_kind, .. }) => { + self.fail_update( + target_version, + format!( + "failed to get a snapshot for manual update: {interrupt_kind:?}" + ), + ) + .await + } + Err(error) => { + self.fail_update( + target_version, + format!("failed to get a snapshot for manual update: {error:?}"), + ) + .await + } } } - } else { - self.fail_update( - target_version, - "failed to get a snapshot for manual update: save-snapshot is not exported" - .to_string(), - ) - .await + Ok(None) => { + self.fail_update( + target_version, + "failed to get a snapshot for manual update: save-snapshot is not exported" + .to_string(), + ) + .await + } + Err(error) => { + self.fail_update( + target_version, + format!("failed to get a snapshot for manual update: error while finding the exported save-snapshot function: {error}"), + ) + .await + } } } diff --git a/golem-worker-executor/src/worker/mod.rs b/golem-worker-executor/src/worker/mod.rs index 2e8d666459..2602aa4b25 100644 --- a/golem-worker-executor/src/worker/mod.rs +++ b/golem-worker-executor/src/worker/mod.rs @@ -1320,7 +1320,7 @@ impl Worker { component_size: component.component_size, total_linear_memory_size: component .metadata - .memories + .memories() .iter() .map(|m| m.initial) .sum(), diff --git a/golem-worker-executor/src/worker/status.rs b/golem-worker-executor/src/worker/status.rs index c676ead9f9..11db40b24c 100644 --- a/golem-worker-executor/src/worker/status.rs +++ b/golem-worker-executor/src/worker/status.rs @@ -2,14 +2,13 @@ use crate::services::{HasConfig, HasOplogService}; use crate::worker::is_worker_error_retriable; use async_recursion::async_recursion; use golem_common::base_model::{OplogIndex, PluginInstallationId}; -use golem_common::model::oplog::{ - OplogEntry, TimestampedUpdateDescription, UpdateDescription, WorkerResourceId, -}; +use golem_common::model::oplog::{OplogEntry, TimestampedUpdateDescription, UpdateDescription}; use golem_common::model::regions::{DeletedRegions, DeletedRegionsBuilder, OplogRegion}; use golem_common::model::{ + AgentInstanceDescription, ExportedResourceInstanceDescription, ExportedResourceInstanceKey, FailedUpdateRecord, IdempotencyKey, OwnedWorkerId, RetryConfig, SuccessfulUpdateRecord, TimestampedWorkerInvocation, WorkerInvocation, WorkerMetadata, WorkerResourceDescription, - WorkerStatus, WorkerStatusRecord, + WorkerResourceKey, WorkerStatus, WorkerStatusRecord, }; use golem_service_base::error::worker_executor::WorkerExecutorError; use std::collections::{BTreeMap, HashMap, HashSet, VecDeque}; @@ -110,11 +109,8 @@ where &new_entries, ); - let owned_resources = calculate_owned_resources( - last_known.owned_resources, - &skipped_regions, - &new_entries, - ); + let owned_resources = + collect_resources(last_known.owned_resources, &skipped_regions, &new_entries); let active_plugins = calculate_active_plugins(active_plugins, &deleted_regions, &new_entries); @@ -256,6 +252,8 @@ fn calculate_latest_worker_status( OplogEntry::ChangePersistenceLevel { .. } => { result = WorkerStatus::Running; } + OplogEntry::CreateAgentInstance { .. } => {} + OplogEntry::DropAgentInstance { .. } => {} } } result @@ -603,11 +601,11 @@ fn calculate_total_linear_memory_size( result } -fn calculate_owned_resources( - initial: HashMap, +fn collect_resources( + initial: HashMap, skipped_regions: &DeletedRegions, entries: &BTreeMap, -) -> HashMap { +) -> HashMap { let mut result = initial; for (idx, entry) in entries { // Skipping entries in deleted regions as they are not applied during replay @@ -616,27 +614,61 @@ fn calculate_owned_resources( } match entry { - OplogEntry::CreateResource { id, timestamp } => { + OplogEntry::CreateResource { + id, + timestamp, + resource_type_id, + } => { result.insert( - *id, - WorkerResourceDescription { - created_at: *timestamp, - indexed_resource_key: None, - }, + WorkerResourceKey::ExportedResourceInstanceKey(ExportedResourceInstanceKey { + resource_id: *id, + }), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: *timestamp, + resource_owner: resource_type_id.owner.clone(), + resource_name: resource_type_id.name.clone(), + resource_params: None, + }, + ), ); } OplogEntry::DropResource { id, .. } => { - result.remove(id); + result.remove(&WorkerResourceKey::ExportedResourceInstanceKey( + ExportedResourceInstanceKey { resource_id: *id }, + )); } OplogEntry::DescribeResource { id, - indexed_resource, + indexed_resource_parameters, .. } => { - if let Some(description) = result.get_mut(id) { - description.indexed_resource_key = Some(indexed_resource.clone()); + if let Some(WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + resource_params, .. + }, + )) = result.get_mut(&WorkerResourceKey::ExportedResourceInstanceKey( + ExportedResourceInstanceKey { resource_id: *id }, + )) { + *resource_params = Some(indexed_resource_parameters.clone()); } } + OplogEntry::CreateAgentInstance { + timestamp, + key, + parameters, + } => { + result.insert( + WorkerResourceKey::AgentInstanceKey(key.clone()), + WorkerResourceDescription::AgentInstance(AgentInstanceDescription { + created_at: *timestamp, + agent_parameters: parameters.clone(), + }), + ); + } + OplogEntry::DropAgentInstance { key, .. } => { + result.remove(&WorkerResourceKey::AgentInstanceKey(key.clone())); + } _ => {} } } diff --git a/golem-worker-executor/src/workerctx/default.rs b/golem-worker-executor/src/workerctx/default.rs index a9aa1b8dcb..425569dc89 100644 --- a/golem-worker-executor/src/workerctx/default.rs +++ b/golem-worker-executor/src/workerctx/default.rs @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use super::LogEventEmitBehaviour; +use super::{AgentStore, LogEventEmitBehaviour}; use crate::durable_host::{DurableWorkerCtx, DurableWorkerCtxView, PublicDurableWorkerState}; use crate::metrics::wasm::record_allocated_memory; use crate::model::{ @@ -46,6 +46,7 @@ use crate::workerctx::{ use anyhow::Error; use async_trait::async_trait; use golem_common::base_model::ProjectId; +use golem_common::model::agent::DataValue; use golem_common::model::invocation_context::{ self, AttributeValue, InvocationContextStack, SpanId, }; @@ -60,7 +61,7 @@ use golem_service_base::error::worker_executor::{InterruptKind, WorkerExecutorEr use golem_wasm_rpc::golem_rpc_0_2_x::types::{ Datetime, FutureInvokeResult, HostFutureInvokeResult, Pollable, WasmRpc, }; -use golem_wasm_rpc::wasmtime::ResourceStore; +use golem_wasm_rpc::wasmtime::{ResourceStore, ResourceTypeId}; use golem_wasm_rpc::{ CancellationTokenEntry, ComponentId, HostWasmRpc, RpcError, Uri, Value, ValueAndType, WitValue, }; @@ -391,15 +392,15 @@ impl ResourceStore for Context { self.durable_ctx.self_uri() } - async fn add(&mut self, resource: ResourceAny) -> u64 { - self.durable_ctx.add(resource).await + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64 { + self.durable_ctx.add(resource, name).await } - async fn get(&mut self, resource_id: u64) -> Option { + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { ResourceStore::get(&mut self.durable_ctx, resource_id).await } - async fn borrow(&self, resource_id: u64) -> Option { + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { self.durable_ctx.borrow(resource_id).await } } @@ -440,27 +441,59 @@ impl UpdateManagement for Context { impl IndexedResourceStore for Context { fn get_indexed_resource( &self, + resource_owner: &str, resource_name: &str, resource_params: &[String], ) -> Option { self.durable_ctx - .get_indexed_resource(resource_name, resource_params) + .get_indexed_resource(resource_owner, resource_name, resource_params) } async fn store_indexed_resource( &mut self, + resource_owner: &str, resource_name: &str, resource_params: &[String], resource: WorkerResourceId, ) { self.durable_ctx - .store_indexed_resource(resource_name, resource_params, resource) + .store_indexed_resource(resource_owner, resource_name, resource_params, resource) .await } - fn drop_indexed_resource(&mut self, resource_name: &str, resource_params: &[String]) { + fn drop_indexed_resource( + &mut self, + resource_owner: &str, + resource_name: &str, + resource_params: &[String], + ) { + self.durable_ctx + .drop_indexed_resource(resource_owner, resource_name, resource_params) + } +} + +#[async_trait] +impl AgentStore for Context { + async fn store_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { self.durable_ctx - .drop_indexed_resource(resource_name, resource_params) + .store_agent_instance(agent_type, agent_id, parameters) + .await + } + + async fn remove_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { + self.durable_ctx + .remove_agent_instance(agent_type, agent_id, parameters) + .await } } diff --git a/golem-worker-executor/src/workerctx/mod.rs b/golem-worker-executor/src/workerctx/mod.rs index a0888b7836..fda9c88761 100644 --- a/golem-worker-executor/src/workerctx/mod.rs +++ b/golem-worker-executor/src/workerctx/mod.rs @@ -76,6 +76,7 @@ pub trait WorkerCtx: + FileSystemReading + DynamicLinking + InvocationContextManagement + + AgentStore + Send + Sync + Sized @@ -349,16 +350,41 @@ pub trait UpdateManagement { pub trait IndexedResourceStore { fn get_indexed_resource( &self, + resource_owner: &str, resource_name: &str, resource_params: &[String], ) -> Option; async fn store_indexed_resource( &mut self, + resource_owner: &str, resource_name: &str, resource_params: &[String], resource: WorkerResourceId, ); - fn drop_indexed_resource(&mut self, resource_name: &str, resource_params: &[String]); + fn drop_indexed_resource( + &mut self, + resource_owner: &str, + resource_name: &str, + resource_params: &[String], + ); +} + +/// Stores information about living agent instances +#[async_trait] +pub trait AgentStore { + async fn store_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: golem_common::model::agent::DataValue, + ); + + async fn remove_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: golem_common::model::agent::DataValue, + ); } /// Operations not requiring an active worker context, but still depending on the diff --git a/golem-worker-executor/tests/agent.rs b/golem-worker-executor/tests/agent.rs new file mode 100644 index 0000000000..5bf6fbb8c9 --- /dev/null +++ b/golem-worker-executor/tests/agent.rs @@ -0,0 +1,229 @@ +// Copyright 2024-2025 Golem Cloud +// +// Licensed under the Golem Source License v1.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://license.golem.cloud/LICENSE +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::common::{start, TestContext}; +use crate::{LastUniqueId, Tracing, WorkerExecutorTestDependencies}; +use golem_common::model::agent::{DataValue, ElementValues}; +use golem_common::model::{AgentInstanceKey, WorkerResourceKey}; +use golem_test_framework::config::TestDependencies; +use golem_test_framework::dsl::TestDslUnsafe; +use golem_wasm_ast::analysis::wit_parser::SharedAnalysedTypeResolve; +use golem_wasm_rpc::{IntoValueAndType, Value, ValueAndType}; +use test_r::{inherit_test_dep, test, timeout}; +use tracing::debug; + +inherit_test_dep!(WorkerExecutorTestDependencies); +inherit_test_dep!(LastUniqueId); +inherit_test_dep!(Tracing); +inherit_test_dep!( + #[tagged_as("golem_host")] + SharedAnalysedTypeResolve +); + +#[test] +#[tracing::instrument] +#[timeout(120_000)] +async fn agent_resource_registration( + last_unique_id: &LastUniqueId, + deps: &WorkerExecutorTestDependencies, + _tracing: &Tracing, +) { + // In this test we use directly the exported agent functions to create an agent (not as + // an indexed resource) and then drop it, and verify that the agent implementation itself + // registered this created resource as an agent instance and then removed it when dropped. + // + // The test agent also exports two functions to create and drop a _second_ agent by itself from + // the guest side, and we verify that this one is also registered as an agent instance. + + let context = TestContext::new(last_unique_id); + let executor = start(deps, &context).await.unwrap().into_admin().await; + + let component_id = executor.component("low-level-agent").store().await; + let worker_id = executor.start_worker(&component_id, "agent-1").await; + + let agent1 = executor + .invoke_and_await( + &worker_id, + "golem:agent/guest.{[static]agent.create}", + vec![ + "test-agent-type".into_value_and_type(), + DataValue::Tuple(ElementValues { elements: vec![] }).into_value_and_type(), + ], + ) + .await + .unwrap(); + + debug!("Created agent1: {:?}", agent1); + let Value::Result(Ok(Some(agent1))) = &agent1[0] else { + panic!("Failed to create agent1: {agent1:?}"); + }; + + let component_metadata = executor.get_latest_component_metadata(&component_id).await; + + let get_id_function = component_metadata + .find_function("golem:agent/guest.{[method]agent.get-id}") + .await + .expect("Failed to get 'golem:agent/guest.{[method]agent.get-id}' in component metadata") + .expect("Function 'golem:agent/guest.{[method]agent.get-id}' is not in component metadata"); + + let agent1_id = executor + .invoke_and_await( + &worker_id, + "golem:agent/guest.{[method]agent.get-id}", + vec![ValueAndType::new( + *agent1.clone(), + get_id_function.analysed_export.parameters[0].typ.clone(), + )], + ) + .await + .unwrap(); + + debug!("Agent1 ID: {:?}", agent1_id); + + let (metadata1, _) = executor.get_worker_metadata(&worker_id).await.unwrap(); + debug!("Worker metadata after creating agent1: {:#?}", metadata1); + + let _ = executor + .invoke_and_await( + &worker_id, + "golem:agent/guest.{[method]agent.invoke}", + vec![ + ValueAndType::new( + *agent1.clone(), + get_id_function.analysed_export.parameters[0].typ.clone(), + ), + "create-inner".into_value_and_type(), + DataValue::Tuple(ElementValues { elements: vec![] }).into_value_and_type(), + ], + ) + .await + .unwrap(); + + let (metadata2, _) = executor.get_worker_metadata(&worker_id).await.unwrap(); + debug!( + "Worker metadata after creating inner agent: {:#?}", + metadata2 + ); + + let _ = executor + .invoke_and_await( + &worker_id, + "golem:agent/guest.{[method]agent.invoke}", + vec![ + ValueAndType::new( + *agent1.clone(), + get_id_function.analysed_export.parameters[0].typ.clone(), + ), + "drop-all-inner".into_value_and_type(), + DataValue::Tuple(ElementValues { elements: vec![] }).into_value_and_type(), + ], + ) + .await + .unwrap(); + + let (metadata3, _) = executor.get_worker_metadata(&worker_id).await.unwrap(); + debug!( + "Worker metadata after dropping inner agent: {:#?}", + metadata3 + ); + + let _ = executor + .invoke_and_await( + &worker_id, + "golem:agent/guest.{[drop]agent}", + vec![ValueAndType::new( + *agent1.clone(), + get_id_function.analysed_export.parameters[0].typ.clone(), + )], + ) + .await + .unwrap(); + + let (metadata4, _) = executor.get_worker_metadata(&worker_id).await.unwrap(); + debug!("Worker metadata after dropping agent1: {:#?}", metadata4); + + executor.check_oplog_is_queryable(&worker_id).await; + drop(executor); + + let mut ids1 = metadata1 + .last_known_status + .owned_resources + .iter() + .filter_map(|(key, _)| match key { + WorkerResourceKey::ExportedResourceInstanceKey(_) => None, + WorkerResourceKey::AgentInstanceKey(key) => Some(key.clone()), + }) + .collect::>(); + let mut ids2 = metadata2 + .last_known_status + .owned_resources + .iter() + .filter_map(|(key, _)| match key { + WorkerResourceKey::ExportedResourceInstanceKey(_) => None, + WorkerResourceKey::AgentInstanceKey(key) => Some(key.clone()), + }) + .collect::>(); + let mut ids3 = metadata3 + .last_known_status + .owned_resources + .iter() + .filter_map(|(key, _)| match key { + WorkerResourceKey::ExportedResourceInstanceKey(_) => None, + WorkerResourceKey::AgentInstanceKey(key) => Some(key.clone()), + }) + .collect::>(); + let mut ids4 = metadata4 + .last_known_status + .owned_resources + .iter() + .filter_map(|(key, _)| match key { + WorkerResourceKey::ExportedResourceInstanceKey(_) => None, + WorkerResourceKey::AgentInstanceKey(key) => Some(key.clone()), + }) + .collect::>(); + + ids1.sort(); + ids2.sort(); + ids3.sort(); + ids4.sort(); + + assert_eq!( + ids1, + vec![AgentInstanceKey { + agent_type: "TestAgent".to_string(), + agent_id: "agent-1".to_string() + }] + ); + assert_eq!( + ids2, + vec![ + AgentInstanceKey { + agent_type: "TestAgent".to_string(), + agent_id: "agent-1".to_string() + }, + AgentInstanceKey { + agent_type: "TestAgent".to_string(), + agent_id: "agent-2".to_string() + } + ] + ); + assert_eq!( + ids3, + vec![AgentInstanceKey { + agent_type: "TestAgent".to_string(), + agent_id: "agent-1".to_string() + }] + ); + assert_eq!(ids4, vec![]); +} diff --git a/golem-worker-executor/tests/api.rs b/golem-worker-executor/tests/api.rs index 515ec210df..db2443fd6e 100644 --- a/golem-worker-executor/tests/api.rs +++ b/golem-worker-executor/tests/api.rs @@ -23,11 +23,11 @@ use golem_api_grpc::proto::golem::workerexecutor::v1::CompletePromiseRequest; use golem_common::model::component_metadata::{ DynamicLinkedInstance, DynamicLinkedWasmRpc, WasmRpcTarget, }; -use golem_common::model::oplog::{IndexedResourceKey, OplogIndex, WorkerResourceId}; +use golem_common::model::oplog::OplogIndex; use golem_common::model::{ - ComponentId, ComponentType, FilterComparator, IdempotencyKey, PromiseId, ScanCursor, - StringFilterComparator, TargetWorkerId, Timestamp, WorkerFilter, WorkerId, WorkerMetadata, - WorkerResourceDescription, WorkerStatus, + ComponentId, ComponentType, ExportedResourceInstanceDescription, FilterComparator, + IdempotencyKey, PromiseId, ScanCursor, StringFilterComparator, TargetWorkerId, Timestamp, + WorkerFilter, WorkerId, WorkerMetadata, WorkerResourceDescription, WorkerStatus, }; use golem_test_framework::config::TestDependencies; use golem_test_framework::dsl::{ @@ -2721,25 +2721,21 @@ async fn counter_resource_test_1( .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); - resources1.sort_by_key(|(k, _v)| *k); + resources1.sort_by_key(|(k, _v)| k.clone()); check!( resources1 == vec![( - WorkerResourceId(0), - WorkerResourceDescription { - created_at: ts, - indexed_resource_key: None - } + "resource(0)".to_string(), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: ts, + resource_owner: "rpc:counters-exports/api".to_string(), + resource_name: "counter".to_string(), + resource_params: None + } + ) ),] ); @@ -2747,15 +2743,7 @@ async fn counter_resource_test_1( .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); check!(resources2 == vec![]); @@ -2860,56 +2848,42 @@ async fn counter_resource_test_2( .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); - resources1.sort_by_key(|(k, _v)| *k); - check!( - resources1 - == vec![ - ( - WorkerResourceId(0), - WorkerResourceDescription { + resources1.sort_by_key(|(k, _v)| k.clone()); + assert_eq!( + resources1, + vec![ + ( + "resource(0)".to_string(), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { created_at: ts, - indexed_resource_key: Some(IndexedResourceKey { - resource_name: "counter".to_string(), - resource_params: vec!["\"counter1\"".to_string()] - }) + resource_owner: "rpc:counters-exports/api".to_string(), + resource_name: "counter".to_string(), + resource_params: Some(vec!["\"counter1\"".to_string()]) } - ), - ( - WorkerResourceId(1), - WorkerResourceDescription { + ) + ), + ( + "resource(1)".to_string(), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { created_at: ts, - indexed_resource_key: Some(IndexedResourceKey { - resource_name: "counter".to_string(), - resource_params: vec!["\"counter2\"".to_string()] - }) + resource_owner: "rpc:counters-exports/api".to_string(), + resource_name: "counter".to_string(), + resource_params: Some(vec!["\"counter2\"".to_string()]) } ) - ] + ) + ] ); let resources2 = metadata2 .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); check!(resources2 == vec![]); diff --git a/golem-worker-executor/tests/common/mod.rs b/golem-worker-executor/tests/common/mod.rs index ccfc5b0fe6..ef72770941 100644 --- a/golem-worker-executor/tests/common/mod.rs +++ b/golem-worker-executor/tests/common/mod.rs @@ -7,6 +7,7 @@ use golem_api_grpc::proto::golem::workerexecutor::v1::{ GetRunningWorkersMetadataSuccessResponse, }; use golem_common::config::RedisConfig; +use golem_common::model::agent::DataValue; use golem_common::model::invocation_context::{ AttributeValue, InvocationContextSpan, InvocationContextStack, SpanId, }; @@ -33,7 +34,7 @@ use golem_test_framework::config::TestDependencies; use golem_test_framework::dsl::to_worker_metadata; use golem_wasm_rpc::golem_rpc_0_2_x::types::{FutureInvokeResult, WasmRpc}; use golem_wasm_rpc::golem_rpc_0_2_x::types::{HostFutureInvokeResult, Pollable}; -use golem_wasm_rpc::wasmtime::ResourceStore; +use golem_wasm_rpc::wasmtime::{ResourceStore, ResourceTypeId}; use golem_wasm_rpc::{HostWasmRpc, RpcError, Uri, Value, ValueAndType, WitValue}; use golem_worker_executor::durable_host::{ DurableWorkerCtx, DurableWorkerCtxView, PublicDurableWorkerState, @@ -42,7 +43,7 @@ use golem_worker_executor::model::{ CurrentResourceLimits, ExecutionStatus, LastError, ReadFileResult, TrapType, WorkerConfig, }; use golem_worker_executor::preview2::golem::durability; -use golem_worker_executor::preview2::golem_api_1_x; +use golem_worker_executor::preview2::{golem_agent, golem_api_1_x}; use golem_worker_executor::services::active_workers::ActiveWorkers; use golem_worker_executor::services::blob_store::BlobStoreService; use golem_worker_executor::services::component::ComponentService; @@ -79,9 +80,9 @@ use golem_worker_executor::services::{ use golem_worker_executor::wasi_host::create_linker; use golem_worker_executor::worker::{RetryDecision, Worker}; use golem_worker_executor::workerctx::{ - DynamicLinking, ExternalOperations, FileSystemReading, FuelManagement, IndexedResourceStore, - InvocationContextManagement, InvocationHooks, InvocationManagement, LogEventEmitBehaviour, - StatusManagement, UpdateManagement, WorkerCtx, + AgentStore, DynamicLinking, ExternalOperations, FileSystemReading, FuelManagement, + IndexedResourceStore, InvocationContextManagement, InvocationHooks, InvocationManagement, + LogEventEmitBehaviour, StatusManagement, UpdateManagement, WorkerCtx, }; use golem_worker_executor::{Bootstrap, RunDetails}; use prometheus::Registry; @@ -369,27 +370,59 @@ impl FuelManagement for TestWorkerCtx { impl IndexedResourceStore for TestWorkerCtx { fn get_indexed_resource( &self, + resource_owner: &str, resource_name: &str, resource_params: &[String], ) -> Option { self.durable_ctx - .get_indexed_resource(resource_name, resource_params) + .get_indexed_resource(resource_owner, resource_name, resource_params) } async fn store_indexed_resource( &mut self, + resource_owner: &str, resource_name: &str, resource_params: &[String], resource: WorkerResourceId, ) { self.durable_ctx - .store_indexed_resource(resource_name, resource_params, resource) + .store_indexed_resource(resource_owner, resource_name, resource_params, resource) .await } - fn drop_indexed_resource(&mut self, resource_name: &str, resource_params: &[String]) { + fn drop_indexed_resource( + &mut self, + resource_owner: &str, + resource_name: &str, + resource_params: &[String], + ) { + self.durable_ctx + .drop_indexed_resource(resource_owner, resource_name, resource_params) + } +} + +#[async_trait] +impl AgentStore for TestWorkerCtx { + async fn store_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { + self.durable_ctx + .store_agent_instance(agent_type, agent_id, parameters) + .await; + } + + async fn remove_agent_instance( + &mut self, + agent_type: String, + agent_id: String, + parameters: DataValue, + ) { self.durable_ctx - .drop_indexed_resource(resource_name, resource_params) + .remove_agent_instance(agent_type, agent_id, parameters) + .await; } } @@ -582,15 +615,15 @@ impl ResourceStore for TestWorkerCtx { self.durable_ctx.self_uri() } - async fn add(&mut self, resource: ResourceAny) -> u64 { - self.durable_ctx.add(resource).await + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64 { + self.durable_ctx.add(resource, name).await } - async fn get(&mut self, resource_id: u64) -> Option { + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { ResourceStore::get(&mut self.durable_ctx, resource_id).await } - async fn borrow(&self, resource_id: u64) -> Option { + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)> { self.durable_ctx.borrow(resource_id).await } } @@ -1122,6 +1155,7 @@ impl Bootstrap for ServerBootstrap { golem_api_1_x::oplog::add_to_linker_get_host(&mut linker, get_durable_ctx)?; golem_api_1_x::context::add_to_linker_get_host(&mut linker, get_durable_ctx)?; durability::durability::add_to_linker_get_host(&mut linker, get_durable_ctx)?; + golem_agent::host::add_to_linker_get_host(&mut linker, get_durable_ctx)?; golem_wasm_rpc::golem_rpc_0_2_x::types::add_to_linker_get_host( &mut linker, get_durable_ctx, diff --git a/golem-worker-executor/tests/compatibility/v1.rs b/golem-worker-executor/tests/compatibility/v1.rs index f2fbc1910c..6172731a09 100644 --- a/golem-worker-executor/tests/compatibility/v1.rs +++ b/golem-worker-executor/tests/compatibility/v1.rs @@ -24,7 +24,7 @@ use goldenfile::differs::Differ; use goldenfile::Mint; use golem_common::model::invocation_context::InvocationContextStack; use golem_common::model::oplog::{ - DurableFunctionType, IndexedResourceKey, LogLevel, OplogIndex, OplogPayload, PayloadId, + DurableFunctionType, LogLevel, OplogIndex, OplogPayload, PayloadId, TimestampedUpdateDescription, UpdateDescription, WorkerError, WorkerResourceId, }; use golem_common::model::regions::{DeletedRegions, OplogRegion}; @@ -32,7 +32,7 @@ use golem_common::model::RetryConfig; use golem_common::model::{ AccountId, ComponentId, FailedUpdateRecord, IdempotencyKey, PromiseId, ShardId, SuccessfulUpdateRecord, Timestamp, TimestampedWorkerInvocation, WorkerId, WorkerInvocation, - WorkerResourceDescription, WorkerStatus, + WorkerStatus, }; use golem_common::serialization::{deserialize, serialize}; use golem_service_base::error::worker_executor::{InterruptKind, WorkerExecutorError}; @@ -394,24 +394,6 @@ pub fn timestamp() { backward_compatible("timestamp", &mut mint, Timestamp::from(1724701938466)); } -#[test] -pub fn worker_resource_description() { - let wrd1 = WorkerResourceDescription { - created_at: Timestamp::from(1724701938466), - indexed_resource_key: None, - }; - let wrd2 = WorkerResourceDescription { - created_at: Timestamp::from(1724701938466), - indexed_resource_key: Some(IndexedResourceKey { - resource_name: "r1".to_string(), - resource_params: vec!["a".to_string(), "b".to_string()], - }), - }; - let mut mint = Mint::new("tests/goldenfiles"); - backward_compatible("worker_resource_description", &mut mint, wrd1); - backward_compatible("worker_resource_description_indexed", &mut mint, wrd2); -} - #[test] pub fn oplog_payload() { let op1 = OplogPayload::Inline(vec![0, 1, 2, 3, 4]); diff --git a/golem-worker-executor/tests/compatibility/v1_3.rs b/golem-worker-executor/tests/compatibility/v1_3.rs index 942c7accf1..c863e7e457 100644 --- a/golem-worker-executor/tests/compatibility/v1_3.rs +++ b/golem-worker-executor/tests/compatibility/v1_3.rs @@ -17,20 +17,23 @@ use goldenfile::Mint; use golem_common::base_model::{ ComponentId, OplogIndex, PluginInstallationId, ProjectId, PromiseId, WorkerId, }; +use golem_common::model::agent::{DataValue, ElementValue, ElementValues}; use golem_common::model::invocation_context::{ AttributeValue, InvocationContextStack, SpanId, TraceId, }; use golem_common::model::oplog::{ - DurableFunctionType, IndexedResourceKey, LogLevel, OplogEntry, OplogPayload, SpanData, - UpdateDescription, WorkerError, WorkerResourceId, + DurableFunctionType, LogLevel, OplogEntry, OplogPayload, SpanData, UpdateDescription, + WorkerError, WorkerResourceId, }; use golem_common::model::regions::OplogRegion; use golem_common::model::{ - AccountId, IdempotencyKey, OwnedWorkerId, RetryConfig, ScheduledAction, Timestamp, - WorkerInvocation, + AccountId, AgentInstanceDescription, ExportedResourceInstanceDescription, IdempotencyKey, + OwnedWorkerId, RetryConfig, ScheduledAction, Timestamp, WorkerInvocation, + WorkerResourceDescription, }; use golem_common::serialization::deserialize; -use golem_wasm_rpc::Value; +use golem_wasm_rpc::wasmtime::ResourceTypeId; +use golem_wasm_rpc::{IntoValueAndType, Value}; use std::collections::{BTreeMap, HashMap, HashSet}; use std::path::Path; use std::time::Duration; @@ -210,20 +213,29 @@ pub fn oplog_entry() { let oe21 = OplogEntry::CreateResource { timestamp: Timestamp::from(1724701938466), id: WorkerResourceId(1), + resource_type_id: ResourceTypeId { + name: "name".to_string(), + owner: "owner".to_string(), + }, }; let oe22 = OplogEntry::DropResource { timestamp: Timestamp::from(1724701938466), id: WorkerResourceId(1), + resource_type_id: ResourceTypeId { + name: "name".to_string(), + owner: "owner".to_string(), + }, }; let oe23 = OplogEntry::DescribeResource { timestamp: Timestamp::from(1724701938466), id: WorkerResourceId(1), - indexed_resource: IndexedResourceKey { - resource_name: "r1".to_string(), - resource_params: vec!["a".to_string(), "b".to_string()], + resource_type_id: ResourceTypeId { + name: "name".to_string(), + owner: "owner".to_string(), }, + indexed_resource_parameters: vec!["a".to_string(), "b".to_string()], }; let oe24 = OplogEntry::Log { @@ -439,3 +451,34 @@ pub fn oplog_entry() { backward_compatible("oplog_entry_finish_span", &mut mint, oe35); backward_compatible("oplog_entry_set_span_attribute", &mut mint, oe36); } + +#[test] +pub fn worker_resource_description() { + let wrd1 = + WorkerResourceDescription::ExportedResourceInstance(ExportedResourceInstanceDescription { + created_at: Timestamp::from(1724701938466), + resource_owner: "owner".to_string(), + resource_name: "name".to_string(), + resource_params: None, + }); + let wrd2 = + WorkerResourceDescription::ExportedResourceInstance(ExportedResourceInstanceDescription { + created_at: Timestamp::from(1724701938466), + resource_owner: "rpc:counters-export/api".to_string(), + resource_name: "counter".to_string(), + resource_params: Some(vec!["a".to_string(), "b".to_string()]), + }); + let wrd3 = WorkerResourceDescription::AgentInstance(AgentInstanceDescription { + created_at: Timestamp::from(1724701938466), + agent_parameters: DataValue::Tuple(ElementValues { + elements: vec![ + ElementValue::ComponentModel("a".into_value_and_type()), + ElementValue::ComponentModel(10.into_value_and_type()), + ], + }), + }); + let mut mint = Mint::new("tests/goldenfiles"); + backward_compatible("worker_resource_description", &mut mint, wrd1); + backward_compatible("worker_resource_description_indexed", &mut mint, wrd2); + backward_compatible("worker_resource_description_agent", &mut mint, wrd3); +} diff --git a/golem-worker-executor/tests/goldenfiles/oplog_entry_create_resource.bin b/golem-worker-executor/tests/goldenfiles/oplog_entry_create_resource.bin index 6e9b2f9e2c..9a0604aa27 100644 Binary files a/golem-worker-executor/tests/goldenfiles/oplog_entry_create_resource.bin and b/golem-worker-executor/tests/goldenfiles/oplog_entry_create_resource.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/oplog_entry_createa.bin b/golem-worker-executor/tests/goldenfiles/oplog_entry_createa.bin index 382aaa91d5..13cdf6350b 100644 Binary files a/golem-worker-executor/tests/goldenfiles/oplog_entry_createa.bin and b/golem-worker-executor/tests/goldenfiles/oplog_entry_createa.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/oplog_entry_describe_resource.bin b/golem-worker-executor/tests/goldenfiles/oplog_entry_describe_resource.bin index 7401beca20..826140913a 100644 Binary files a/golem-worker-executor/tests/goldenfiles/oplog_entry_describe_resource.bin and b/golem-worker-executor/tests/goldenfiles/oplog_entry_describe_resource.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/oplog_entry_drop_resource.bin b/golem-worker-executor/tests/goldenfiles/oplog_entry_drop_resource.bin index 1b5b7e0b45..4480f4fd98 100644 Binary files a/golem-worker-executor/tests/goldenfiles/oplog_entry_drop_resource.bin and b/golem-worker-executor/tests/goldenfiles/oplog_entry_drop_resource.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/oplog_entry_pending_worker_invocation.bin b/golem-worker-executor/tests/goldenfiles/oplog_entry_pending_worker_invocation.bin index 4db115f15a..579c7fe89d 100644 Binary files a/golem-worker-executor/tests/goldenfiles/oplog_entry_pending_worker_invocation.bin and b/golem-worker-executor/tests/goldenfiles/oplog_entry_pending_worker_invocation.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/oplog_entry_successful_update.bin b/golem-worker-executor/tests/goldenfiles/oplog_entry_successful_update.bin index c6ea3990b6..52a1a25412 100644 Binary files a/golem-worker-executor/tests/goldenfiles/oplog_entry_successful_update.bin and b/golem-worker-executor/tests/goldenfiles/oplog_entry_successful_update.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/worker_resource_description.bin b/golem-worker-executor/tests/goldenfiles/worker_resource_description.bin index 355210b165..d233626b1b 100644 Binary files a/golem-worker-executor/tests/goldenfiles/worker_resource_description.bin and b/golem-worker-executor/tests/goldenfiles/worker_resource_description.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/worker_resource_description_agent.bin b/golem-worker-executor/tests/goldenfiles/worker_resource_description_agent.bin new file mode 100644 index 0000000000..c572dc873c Binary files /dev/null and b/golem-worker-executor/tests/goldenfiles/worker_resource_description_agent.bin differ diff --git a/golem-worker-executor/tests/goldenfiles/worker_resource_description_indexed.bin b/golem-worker-executor/tests/goldenfiles/worker_resource_description_indexed.bin index dc5f7f6096..a120946319 100644 Binary files a/golem-worker-executor/tests/goldenfiles/worker_resource_description_indexed.bin and b/golem-worker-executor/tests/goldenfiles/worker_resource_description_indexed.bin differ diff --git a/golem-worker-executor/tests/lib.rs b/golem-worker-executor/tests/lib.rs index cfc5e70c43..a3d50950d0 100644 --- a/golem-worker-executor/tests/lib.rs +++ b/golem-worker-executor/tests/lib.rs @@ -42,6 +42,7 @@ use uuid::Uuid; mod common; +pub mod agent; pub mod api; pub mod blobstore; pub mod compatibility; @@ -73,10 +74,10 @@ tag_suite!(api, group1); tag_suite!(blobstore, group1); tag_suite!(keyvalue, group1); tag_suite!(http, group1); - tag_suite!(rdbms, group1); tag_suite!(guest_languages1, group2); +tag_suite!(agent, group2); tag_suite!(transactions, group3); tag_suite!(wasi, group3); diff --git a/golem-worker-executor/tests/revert.rs b/golem-worker-executor/tests/revert.rs index 49a8cde815..68e957a5c0 100644 --- a/golem-worker-executor/tests/revert.rs +++ b/golem-worker-executor/tests/revert.rs @@ -198,7 +198,7 @@ async fn revert_auto_update( let _ = executor.log_output(&worker_id).await; let target_version = executor - .update_component(&component_id, "update-test-v2") + .update_component(&component_id, "update-test-v2-11") .await; info!("Updated component to version {target_version}"); @@ -255,14 +255,18 @@ async fn revert_manual_update( let mut env = HashMap::new(); env.insert("PORT".to_string(), http_server.port().to_string()); - let component_id = executor.component("update-test-v2").unique().store().await; + let component_id = executor + .component("update-test-v2-11") + .unique() + .store() + .await; let worker_id = executor .start_worker_with(&component_id, "revert_manual_update", vec![], env, vec![]) .await; let _ = executor.log_output(&worker_id).await; let target_version = executor - .update_component(&component_id, "update-test-v3") + .update_component(&component_id, "update-test-v3-11") .await; info!("Updated component to version {target_version}"); diff --git a/golem-worker-service/src/gateway_api_definition/http/api_definition.rs b/golem-worker-service/src/gateway_api_definition/http/api_definition.rs index 329a6a116f..96f8c4eecf 100644 --- a/golem-worker-service/src/gateway_api_definition/http/api_definition.rs +++ b/golem-worker-service/src/gateway_api_definition/http/api_definition.rs @@ -680,13 +680,13 @@ impl ComponentMetadataDictionary { let component_info = ComponentDependencyKey { component_name: component.component_name.0.clone(), component_id: component.versioned_component_id.component_id.0, - root_package_name: component.metadata.root_package_name.clone(), - root_package_version: component.metadata.root_package_version.clone(), + root_package_name: component.metadata.root_package_name().clone(), + root_package_version: component.metadata.root_package_version().clone(), }; let component_details = ComponentDetails { component_info, - metadata: component.metadata.exports.clone(), + metadata: component.metadata.exports().to_vec(), }; metadata.insert(component.versioned_component_id.clone(), component_details); diff --git a/golem-worker-service/src/model.rs b/golem-worker-service/src/model.rs index 2c17d230fb..8dddc8c2a0 100644 --- a/golem-worker-service/src/model.rs +++ b/golem-worker-service/src/model.rs @@ -15,18 +15,38 @@ use crate::gateway_api_definition::{ApiDefinitionId, ApiVersion}; use crate::gateway_api_deployment::ApiSite; use derive_more::FromStr; +use golem_common::model::oplog::WorkerResourceId; use golem_common::model::regions::OplogRegion; use golem_common::model::worker::WasiConfigVars; -use golem_common::model::{AccountId, PluginInstallationId, ScanCursor, WorkerId}; +use golem_common::model::{ + AccountId, AgentInstanceDescription, AgentInstanceKey, ExportedResourceInstanceDescription, + ExportedResourceInstanceKey, PluginInstallationId, ScanCursor, WorkerId, +}; use golem_common::model::{ComponentVersion, ProjectId, Timestamp, WorkerStatus}; -use golem_service_base::model::{ResourceMetadata, UpdateRecord}; +use golem_service_base::model::UpdateRecord; use poem_openapi::{NewType, Object}; use serde::{Deserialize, Serialize}; use std::collections::{HashMap, HashSet}; use std::fmt::{Debug, Display}; use uuid::Uuid; -#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Object)] +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Object)] +#[serde(rename_all = "camelCase")] +#[oai(rename_all = "camelCase")] +pub struct AgentInstanceMetadata { + pub key: AgentInstanceKey, + pub description: AgentInstanceDescription, +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Object)] +#[serde(rename_all = "camelCase")] +#[oai(rename_all = "camelCase")] +pub struct ExportedResourceMetadata { + pub key: ExportedResourceInstanceKey, + pub description: ExportedResourceInstanceDescription, +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Object)] #[serde(rename_all = "camelCase")] #[oai(rename_all = "camelCase")] pub struct WorkerMetadata { @@ -45,7 +65,8 @@ pub struct WorkerMetadata { pub last_error: Option, pub component_size: u64, pub total_linear_memory_size: u64, - pub owned_resources: HashMap, + pub exported_resource_instances: Vec, + pub agent_instances: Vec, pub active_plugins: HashSet, /// Oplog regions that are skipped during the worker's state recovery, but describe /// the history of the worker. For example if an atomic region gets restarted, its partially @@ -61,6 +82,45 @@ impl TryFrom for WorkerMet fn try_from( value: golem_api_grpc::proto::golem::worker::WorkerMetadata, ) -> Result { + let mut exported_resource_instances = Vec::new(); + let mut agent_instances = Vec::new(); + + for desc in value.owned_resources { + match desc.description { + Some(golem_api_grpc::proto::golem::worker::resource_description::Description::ExportedResourceInstance(exported_resource)) => { + exported_resource_instances.push( + ExportedResourceMetadata { + key: ExportedResourceInstanceKey { resource_id: WorkerResourceId(exported_resource.resource_id) }, + description: ExportedResourceInstanceDescription { + created_at: exported_resource.created_at.ok_or("Missing created_at")?.into(), + resource_owner: exported_resource.resource_owner, + resource_name: exported_resource.resource_name, + resource_params: if exported_resource.is_indexed { + Some(exported_resource.resource_params) + } else { + None + }, + } + } + ); + } + Some(golem_api_grpc::proto::golem::worker::resource_description::Description::AgentInstance(agent_instance)) => { + agent_instances.push( + AgentInstanceMetadata { + key: AgentInstanceKey { + agent_type: agent_instance.agent_type, + agent_id: agent_instance.agent_id, + }, + description: AgentInstanceDescription { + created_at: agent_instance.created_at.ok_or("Missing created_at")?.into(), + agent_parameters: agent_instance.agent_parameters.ok_or("Missing agent_parameters")?.try_into()?, + }, + } + ); + } + None => continue, + } + } Ok(Self { worker_id: value.worker_id.ok_or("Missing worker_id")?.try_into()?, project_id: value.project_id.ok_or("Missing project_id")?.try_into()?, @@ -84,11 +144,8 @@ impl TryFrom for WorkerMet last_error: value.last_error, component_size: value.component_size, total_linear_memory_size: value.total_linear_memory_size, - owned_resources: value - .owned_resources - .into_iter() - .map(|(k, v)| v.try_into().map(|v| (k, v))) - .collect::, _>>()?, + exported_resource_instances, + agent_instances, active_plugins: value .active_plugins .into_iter() @@ -110,6 +167,45 @@ impl TryFrom for WorkerMet impl From for golem_api_grpc::proto::golem::worker::WorkerMetadata { fn from(value: WorkerMetadata) -> Self { + let mut owned_resources = Vec::new(); + for instance in value.exported_resource_instances { + owned_resources.push( + golem_api_grpc::proto::golem::worker::ResourceDescription { + description: Some( + golem_api_grpc::proto::golem::worker::resource_description::Description::ExportedResourceInstance( + golem_api_grpc::proto::golem::worker::ExportedResourceInstanceDescription { + resource_id: instance.key.resource_id.0, + resource_name: instance.description.resource_name, + resource_owner: instance.description.resource_owner, + created_at: Some(instance.description.created_at.into()), + is_indexed: instance.description.resource_params.is_some(), + resource_params: instance.description.resource_params.unwrap_or_default(), + }, + ), + ), + }, + ); + } + for instance in value.agent_instances { + owned_resources.push( + golem_api_grpc::proto::golem::worker::ResourceDescription { + description: Some( + golem_api_grpc::proto::golem::worker::resource_description::Description::AgentInstance( + golem_api_grpc::proto::golem::worker::AgentInstanceDescription { + agent_type: instance.key.agent_type, + agent_id: instance.key.agent_id, + created_at: Some(instance.description.created_at.into()), + agent_parameters: Some(instance + .description + .agent_parameters + .into()), + }, + ), + ), + }, + ); + } + Self { worker_id: Some(value.worker_id.into()), project_id: Some(value.project_id.into()), @@ -126,11 +222,7 @@ impl From for golem_api_grpc::proto::golem::worker::WorkerMetada last_error: value.last_error, component_size: value.component_size, total_linear_memory_size: value.total_linear_memory_size, - owned_resources: value - .owned_resources - .into_iter() - .map(|(k, v)| (k, v.into())) - .collect(), + owned_resources, active_plugins: value .active_plugins .into_iter() @@ -150,7 +242,7 @@ impl From for golem_api_grpc::proto::golem::worker::WorkerMetada } } -#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize, Object)] +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Object)] pub struct WorkersMetadataResponse { pub workers: Vec, pub cursor: Option, diff --git a/golem-worker-service/tests/api_gateway_end_to_end_tests.rs b/golem-worker-service/tests/api_gateway_end_to_end_tests.rs index bab7e889d5..8ca8885f75 100644 --- a/golem-worker-service/tests/api_gateway_end_to_end_tests.rs +++ b/golem-worker-service/tests/api_gateway_end_to_end_tests.rs @@ -2566,6 +2566,7 @@ mod internal { resource_id: AnalysedResourceId(0), mode: AnalysedResourceMode::Owned, name: None, + owner: None, }); let value_and_type = ValueAndType::new(handle, handle_type); diff --git a/golem-worker-service/tests/api_oas_convert_tests.rs b/golem-worker-service/tests/api_oas_convert_tests.rs index 2c5f9041c7..0f0f1fbd55 100644 --- a/golem-worker-service/tests/api_oas_convert_tests.rs +++ b/golem-worker-service/tests/api_oas_convert_tests.rs @@ -618,6 +618,7 @@ async fn test_multi_component_binding() { let mut types = HashMap::new(); let path_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "user".to_string(), typ: AnalysedType::Str(TypeStr), @@ -625,6 +626,7 @@ async fn test_multi_component_binding() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "path".to_string(), typ: path_record, @@ -664,6 +666,7 @@ async fn test_multi_component_binding() { let mut types = HashMap::new(); let path_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "user".to_string(), typ: AnalysedType::Str(TypeStr), @@ -671,6 +674,7 @@ async fn test_multi_component_binding() { }); let query_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "echo".to_string(), typ: AnalysedType::Str(TypeStr), @@ -678,6 +682,7 @@ async fn test_multi_component_binding() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "path".to_string(), @@ -696,6 +701,7 @@ async fn test_multi_component_binding() { let response_output = RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -825,6 +831,7 @@ async fn test_basic_types_and_record_conversion() { let mut types = HashMap::new(); let body_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "input".to_string(), typ: body_type, @@ -832,6 +839,7 @@ async fn test_basic_types_and_record_conversion() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "body".to_string(), typ: body_record, @@ -846,6 +854,7 @@ async fn test_basic_types_and_record_conversion() { RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -866,6 +875,7 @@ async fn test_basic_types_and_record_conversion() { let mut types = HashMap::new(); let path_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "user".to_string(), typ: AnalysedType::Str(TypeStr), @@ -873,6 +883,7 @@ async fn test_basic_types_and_record_conversion() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "path".to_string(), typ: path_record, @@ -937,6 +948,7 @@ async fn test_basic_types_and_record_conversion() { // Record route let record_type = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "id".to_string(), @@ -979,6 +991,7 @@ async fn test_basic_types_and_record_conversion() { // Enum route let enum_type = AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec!["low".to_string(), "medium".to_string(), "high".to_string()], }); @@ -1103,6 +1116,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { // Create request body with optional field let request_body_type = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "title".to_string(), @@ -1112,6 +1126,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { name: "priority".to_string(), typ: AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec!["low".to_string(), "medium".to_string(), "high".to_string()], }), }, @@ -1119,6 +1134,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { name: "deadline".to_string(), typ: AnalysedType::Option(TypeOption { name: None, + owner: None, inner: Box::new(AnalysedType::Str(TypeStr)), }), }, @@ -1130,6 +1146,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { let mut types = HashMap::new(); let body_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "input".to_string(), typ: request_body_type, @@ -1137,6 +1154,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { }); let path_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "user".to_string(), typ: AnalysedType::Str(TypeStr), @@ -1144,6 +1162,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "body".to_string(), @@ -1163,6 +1182,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { // Create response with Result type (oneOf) let todo_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "id".to_string(), @@ -1176,6 +1196,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { name: "priority".to_string(), typ: AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec!["low".to_string(), "medium".to_string(), "high".to_string()], }), }, @@ -1183,6 +1204,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { name: "status".to_string(), typ: AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec![ "backlog".to_string(), "in-progress".to_string(), @@ -1202,6 +1224,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { name: "deadline".to_string(), typ: AnalysedType::Option(TypeOption { name: None, + owner: None, inner: Box::new(AnalysedType::S64(TypeS64)), }), }, @@ -1210,6 +1233,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { let response_type = AnalysedType::Result(TypeResult { name: None, + owner: None, ok: Some(Box::new(todo_record)), err: Some(Box::new(AnalysedType::Str(TypeStr))), }); @@ -1217,6 +1241,7 @@ async fn test_complete_todo_structure_with_optional_and_oneof() { let response_output = RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -1340,6 +1365,7 @@ async fn test_variant_output_structure() { let mut types = HashMap::new(); let body_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "message".to_string(), typ: AnalysedType::Str(TypeStr), @@ -1347,6 +1373,7 @@ async fn test_variant_output_structure() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "body".to_string(), typ: body_record, @@ -1360,6 +1387,7 @@ async fn test_variant_output_structure() { // Create variant response type let variant_type = AnalysedType::Variant(TypeVariant { name: None, + owner: None, cases: vec![ NameOptionTypePair { name: "rand1".to_string(), @@ -1379,6 +1407,7 @@ async fn test_variant_output_structure() { let response_output = RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -1512,6 +1541,7 @@ async fn test_oas_conversion_full_structure_shopping_cart() { let mut types = HashMap::new(); let path_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "user".to_string(), typ: AnalysedType::Str(TypeStr), @@ -1519,6 +1549,7 @@ async fn test_oas_conversion_full_structure_shopping_cart() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "path".to_string(), typ: path_record, @@ -1532,6 +1563,7 @@ async fn test_oas_conversion_full_structure_shopping_cart() { // Create cart item record type let cart_item_type = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "product-id".to_string(), @@ -1555,12 +1587,14 @@ async fn test_oas_conversion_full_structure_shopping_cart() { // Create list of cart items let cart_items_list = AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(cart_item_type), }); let response_output = RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -1775,6 +1809,7 @@ async fn test_path_query_header_parameter_combinations() { // Create path record with both user and user_id let path_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "user".to_string(), @@ -1790,6 +1825,7 @@ async fn test_path_query_header_parameter_combinations() { // Create query record with limit and offset let query_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "limit".to_string(), @@ -1805,6 +1841,7 @@ async fn test_path_query_header_parameter_combinations() { // Create headers record with age and country let headers_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "age".to_string(), @@ -1820,6 +1857,7 @@ async fn test_path_query_header_parameter_combinations() { // Combine all into a single request record let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "path".to_string(), @@ -1861,6 +1899,7 @@ async fn test_path_query_header_parameter_combinations() { rib_output: Some(RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -1901,6 +1940,7 @@ async fn test_path_query_header_parameter_combinations() { rib_output: Some(RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -2099,6 +2139,7 @@ async fn test_comprehensive_analysed_type_coverage() { let mut types = HashMap::new(); let body_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "input".to_string(), typ: req_type, @@ -2106,6 +2147,7 @@ async fn test_comprehensive_analysed_type_coverage() { }); let request_record = AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "body".to_string(), typ: body_record, @@ -2133,6 +2175,7 @@ async fn test_comprehensive_analysed_type_coverage() { rib_output: Some(RibOutputTypeInfo { analysed_type: AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "status".to_string(), @@ -2159,6 +2202,7 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "boolean_val".to_string(), @@ -2200,11 +2244,13 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "list_val".to_string(), typ: AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(AnalysedType::Str(TypeStr)), }), }, @@ -2212,6 +2258,7 @@ async fn test_comprehensive_analysed_type_coverage() { name: "tuple_val".to_string(), typ: AnalysedType::Tuple(TypeTuple { name: None, + owner: None, items: vec![AnalysedType::Str(TypeStr), AnalysedType::U32(TypeU32)], }), }, @@ -2219,6 +2266,7 @@ async fn test_comprehensive_analysed_type_coverage() { name: "optional_val".to_string(), typ: AnalysedType::Option(TypeOption { name: None, + owner: None, inner: Box::new(AnalysedType::Str(TypeStr)), }), }, @@ -2226,6 +2274,7 @@ async fn test_comprehensive_analysed_type_coverage() { })), AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(AnalysedType::U32(TypeU32)), }), ))), @@ -2241,6 +2290,7 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "id".to_string(), @@ -2258,6 +2308,7 @@ async fn test_comprehensive_analysed_type_coverage() { })), AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "result_id".to_string(), @@ -2282,11 +2333,13 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "color".to_string(), typ: AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec!["red".to_string(), "green".to_string(), "blue".to_string()], }), }, @@ -2294,6 +2347,7 @@ async fn test_comprehensive_analysed_type_coverage() { name: "permissions".to_string(), typ: AnalysedType::Flags(TypeFlags { name: None, + owner: None, names: vec![ "read".to_string(), "write".to_string(), @@ -2305,6 +2359,7 @@ async fn test_comprehensive_analysed_type_coverage() { })), AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec![ "success".to_string(), "warning".to_string(), @@ -2324,11 +2379,13 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Result(TypeResult { name: None, + owner: None, ok: Some(Box::new(AnalysedType::Str(TypeStr))), err: Some(Box::new(AnalysedType::Str(TypeStr))), })), AnalysedType::Result(TypeResult { name: None, + owner: None, ok: Some(Box::new(AnalysedType::U64(TypeU64))), err: Some(Box::new(AnalysedType::Str(TypeStr))), }), @@ -2345,6 +2402,7 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Variant(TypeVariant { name: None, + owner: None, cases: vec![ NameOptionTypePair { name: "text".to_string(), @@ -2362,6 +2420,7 @@ async fn test_comprehensive_analysed_type_coverage() { })), AnalysedType::Variant(TypeVariant { name: None, + owner: None, cases: vec![ NameOptionTypePair { name: "success".to_string(), @@ -2386,13 +2445,16 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "optional_list".to_string(), typ: AnalysedType::Option(TypeOption { name: None, + owner: None, inner: Box::new(AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(AnalysedType::Str(TypeStr)), })), }), @@ -2401,8 +2463,10 @@ async fn test_comprehensive_analysed_type_coverage() { name: "result_record".to_string(), typ: AnalysedType::Result(TypeResult { name: None, + owner: None, ok: Some(Box::new(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![NameTypePair { name: "value".to_string(), typ: AnalysedType::U32(TypeU32), @@ -2415,8 +2479,10 @@ async fn test_comprehensive_analysed_type_coverage() { })), AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "id".to_string(), @@ -2426,6 +2492,7 @@ async fn test_comprehensive_analysed_type_coverage() { name: "status".to_string(), typ: AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: vec!["pending".to_string(), "completed".to_string()], }), }, @@ -2445,6 +2512,7 @@ async fn test_comprehensive_analysed_type_coverage() { 1, Some(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "s32_val".to_string(), @@ -2471,8 +2539,10 @@ async fn test_comprehensive_analysed_type_coverage() { Some(AnalysedType::Str(TypeStr)), AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "name".to_string(), @@ -2499,6 +2569,7 @@ async fn test_comprehensive_analysed_type_coverage() { None, // No request body AnalysedType::Record(TypeRecord { name: None, + owner: None, fields: vec![ NameTypePair { name: "api_version".to_string(), @@ -2508,6 +2579,7 @@ async fn test_comprehensive_analysed_type_coverage() { name: "supported_types".to_string(), typ: AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(AnalysedType::Str(TypeStr)), }), }, diff --git a/golem-worker-service/tests/services_tests.rs b/golem-worker-service/tests/services_tests.rs index 5b43ad68b6..3f47ff7e5f 100644 --- a/golem-worker-service/tests/services_tests.rs +++ b/golem-worker-service/tests/services_tests.rs @@ -16,7 +16,6 @@ use async_trait::async_trait; use chrono::Utc; use golem_common::config::{DbPostgresConfig, DbSqliteConfig, RedisConfig}; use golem_common::model::auth::{AuthCtx, Namespace, ProjectAction, TokenSecret}; -use golem_common::model::base64::Base64; use golem_common::model::component::{ComponentOwner, VersionedComponentId}; use golem_common::model::component_constraint::{FunctionConstraints, FunctionSignature}; use golem_common::model::{AccountId, ComponentId, ComponentType, ProjectId, RetryConfig}; @@ -409,16 +408,14 @@ impl TestComponentService { versioned_component_id: id.clone(), component_name: ComponentName("test".to_string()), component_size: 0, - metadata: ComponentMetadata { - exports: Self::get_metadata(), - producers: vec![], - memories: vec![], - binary_wit: Base64(vec![]), - root_package_name: Some("golem:it".to_string()), - root_package_version: None, - dynamic_linking: HashMap::new(), - agent_types: Vec::new(), - }, + metadata: ComponentMetadata::from_parts( + Self::get_metadata(), + vec![], + HashMap::new(), + Some("golem:it".to_string()), + None, + vec![], + ), created_at: Utc::now(), component_type: ComponentType::Durable, files: vec![], diff --git a/integration-tests/src/rib_repl/bootstrap.rs b/integration-tests/src/rib_repl/bootstrap.rs index dda46abcdd..90b264e11d 100644 --- a/integration-tests/src/rib_repl/bootstrap.rs +++ b/integration-tests/src/rib_repl/bootstrap.rs @@ -50,13 +50,13 @@ impl RibDependencyManager for TestRibReplDependencyManager { let component_dependency_key = ComponentDependencyKey { component_name, component_id: component_id.0, - root_package_name: metadata.root_package_name, - root_package_version: metadata.root_package_version, + root_package_name: metadata.root_package_name().clone(), + root_package_version: metadata.root_package_version().clone(), }; Ok(ComponentDependency::new( component_dependency_key, - metadata.exports, + metadata.exports().to_vec(), )) } } diff --git a/integration-tests/tests/api/plugins.rs b/integration-tests/tests/api/plugins.rs index 89dc98b272..5c7467d3e7 100644 --- a/integration-tests/tests/api/plugins.rs +++ b/integration-tests/tests/api/plugins.rs @@ -290,7 +290,7 @@ async fn component_transformer2(deps: &EnvBasedTestDependencies, _tracing: &Trac let patched_component_metadata = admin.get_latest_component_metadata(&component_id).await; - let exports = patched_component_metadata.exports; + let exports = patched_component_metadata.exports(); assert_eq!(exports.len(), 1); assert!(matches!( @@ -411,7 +411,7 @@ async fn component_transformer_env_var(deps: &EnvBasedTestDependencies, _tracing .unwrap(); let response_map = { - assert!(response.len() == 1); + assert_eq!(response.len(), 1); let_assert!(Value::Result(Ok(Some(response))) = &response[0]); let_assert!(Value::List(response) = response.as_ref()); diff --git a/integration-tests/tests/rib.rs b/integration-tests/tests/rib.rs index 97226ab38a..e4adbe5a76 100644 --- a/integration-tests/tests/rib.rs +++ b/integration-tests/tests/rib.rs @@ -79,11 +79,12 @@ async fn test_simple_rib(deps: &EnvBasedTestDependencies, worker_name: Option<&s let component_dependency_key = ComponentDependencyKey { component_name: "shopping-cart".to_string(), component_id: component_id.0, - root_package_name: metadata.root_package_name, - root_package_version: metadata.root_package_version, + root_package_name: metadata.root_package_name().clone(), + root_package_version: metadata.root_package_version().clone(), }; - let component_dependency = ComponentDependency::new(component_dependency_key, metadata.exports); + let component_dependency = + ComponentDependency::new(component_dependency_key, metadata.exports().to_vec()); let compiler_config = RibCompilerConfig::new(vec![component_dependency], vec![]); @@ -151,6 +152,7 @@ async fn test_simple_rib(deps: &EnvBasedTestDependencies, worker_name: Option<&s field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), )) ); @@ -165,11 +167,12 @@ async fn test_rib_for_loop(deps: &EnvBasedTestDependencies, worker_name: Option< let component_dependency_key = ComponentDependencyKey { component_name: "shopping-cart".to_string(), component_id: component_id.0, - root_package_name: metadata.root_package_name, - root_package_version: metadata.root_package_version, + root_package_name: metadata.root_package_name().clone(), + root_package_version: metadata.root_package_version().clone(), }; - let component_dependency = ComponentDependency::new(component_dependency_key, metadata.exports); + let component_dependency = + ComponentDependency::new(component_dependency_key, metadata.exports().to_vec()); let compiler_config = RibCompilerConfig::new(vec![component_dependency], vec![]); @@ -253,6 +256,7 @@ async fn test_rib_for_loop(deps: &EnvBasedTestDependencies, worker_name: Option< field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), )) ); @@ -270,11 +274,12 @@ async fn test_rib_with_resource_methods( let component_dependency_key = ComponentDependencyKey { component_name: "shopping-cart".to_string(), component_id: component_id.0, - root_package_name: metadata.root_package_name, - root_package_version: metadata.root_package_version, + root_package_name: metadata.root_package_name().clone(), + root_package_version: metadata.root_package_version().clone(), }; - let component_dependency = ComponentDependency::new(component_dependency_key, metadata.exports); + let component_dependency = + ComponentDependency::new(component_dependency_key, metadata.exports().to_vec()); let compiler_config = RibCompilerConfig::new(vec![component_dependency], vec![]); @@ -358,6 +363,7 @@ async fn test_rib_with_resource_methods( field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), )) ); diff --git a/integration-tests/tests/rib_repl.rs b/integration-tests/tests/rib_repl.rs index 5bbca651c2..f4d8283520 100644 --- a/integration-tests/tests/rib_repl.rs +++ b/integration-tests/tests/rib_repl.rs @@ -130,6 +130,7 @@ async fn test_repl_invoking_functions(deps: &EnvBasedTestDependencies, worker_na field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), ))) ); @@ -165,6 +166,7 @@ async fn test_repl_invoking_functions(deps: &EnvBasedTestDependencies, worker_na field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), ))) ); @@ -249,6 +251,7 @@ async fn test_repl_invoking_resource_methods( field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), ))) ); @@ -284,6 +287,7 @@ async fn test_repl_invoking_resource_methods( field("quantity", u32()), ]) .named("product-item") + .owned("golem:it/api") ), ))) ) @@ -330,13 +334,13 @@ impl RibDependencyManager for TestRibReplDependencyManager { let component_dependency_key = ComponentDependencyKey { component_name, component_id: component_id.0, - root_package_name: metadata.root_package_name, - root_package_version: metadata.root_package_version, + root_package_name: metadata.root_package_name().clone(), + root_package_version: metadata.root_package_version().clone(), }; Ok(ComponentDependency::new( component_dependency_key, - metadata.exports, + metadata.exports().to_vec(), )) } } diff --git a/integration-tests/tests/worker.rs b/integration-tests/tests/worker.rs index 0109491d17..fd64bc7106 100644 --- a/integration-tests/tests/worker.rs +++ b/integration-tests/tests/worker.rs @@ -27,12 +27,13 @@ use crate::Tracing; use axum::extract::Query; use axum::routing::get; use axum::Router; -use golem_common::model::oplog::{OplogIndex, WorkerResourceId}; +use golem_common::model::oplog::OplogIndex; use golem_common::model::public_oplog::{ExportedFunctionInvokedParameters, PublicOplogEntry}; use golem_common::model::{ ComponentFilePermissions, ComponentFileSystemNode, ComponentFileSystemNodeDetails, ComponentId, - FilterComparator, IdempotencyKey, ScanCursor, StringFilterComparator, TargetWorkerId, - Timestamp, WorkerFilter, WorkerId, WorkerMetadata, WorkerResourceDescription, WorkerStatus, + ExportedResourceInstanceDescription, FilterComparator, IdempotencyKey, ScanCursor, + StringFilterComparator, TargetWorkerId, Timestamp, WorkerFilter, WorkerId, WorkerMetadata, + WorkerResourceDescription, WorkerStatus, }; use golem_test_framework::config::{EnvBasedTestDependencies, TestDependencies}; use golem_wasm_ast::analysis::analysed_type; @@ -300,25 +301,21 @@ async fn counter_resource_test_1(deps: &EnvBasedTestDependencies, _tracing: &Tra .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); - resources1.sort_by_key(|(k, _v)| *k); + resources1.sort_by_key(|(k, _v)| k.clone()); check!( resources1 == vec![( - WorkerResourceId(0), - WorkerResourceDescription { - created_at: ts, - indexed_resource_key: None - } + "resource(0)".to_string(), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: ts, + resource_owner: "rpc:counters-exports/api".to_string(), + resource_name: "counter".to_string(), + resource_params: None + } + ) ),] ); @@ -326,15 +323,7 @@ async fn counter_resource_test_1(deps: &EnvBasedTestDependencies, _tracing: &Tra .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); check!(resources2 == vec![]); } @@ -457,25 +446,21 @@ async fn counter_resource_test_1_json(deps: &EnvBasedTestDependencies, _tracing: .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); - resources1.sort_by_key(|(k, _v)| *k); + resources1.sort_by_key(|(k, _v)| k.clone()); check!( resources1 == vec![( - WorkerResourceId(0), - WorkerResourceDescription { - created_at: ts, - indexed_resource_key: None - } + "resource(0)".to_string(), + WorkerResourceDescription::ExportedResourceInstance( + ExportedResourceInstanceDescription { + created_at: ts, + resource_owner: "rpc:counters-exports/api".to_string(), + resource_name: "counter".to_string(), + resource_params: None + } + ) ),] ); @@ -483,15 +468,7 @@ async fn counter_resource_test_1_json(deps: &EnvBasedTestDependencies, _tracing: .last_known_status .owned_resources .iter() - .map(|(k, v)| { - ( - *k, - WorkerResourceDescription { - created_at: ts, - ..v.clone() - }, - ) - }) + .map(|(k, v)| (k.to_string(), v.with_timestamp(ts))) .collect::>(); check!(resources2 == vec![]); } diff --git a/openapi/golem-component-service.yaml b/openapi/golem-component-service.yaml index 3a6ea46071..651621b803 100644 --- a/openapi/golem-component-service.yaml +++ b/openapi/golem-component-service.yaml @@ -2930,6 +2930,8 @@ components: properties: name: type: string + owner: + type: string cases: type: array items: @@ -2948,6 +2950,8 @@ components: properties: name: type: string + owner: + type: string names: type: array items: @@ -2961,6 +2965,8 @@ components: properties: name: type: string + owner: + type: string resource_id: type: integer format: uint64 @@ -2974,6 +2980,8 @@ components: properties: name: type: string + owner: + type: string inner: $ref: '#/components/schemas/AnalysedType' TypeOption: @@ -2984,6 +2992,8 @@ components: properties: name: type: string + owner: + type: string inner: $ref: '#/components/schemas/AnalysedType' TypeRecord: @@ -2994,6 +3004,8 @@ components: properties: name: type: string + owner: + type: string fields: type: array items: @@ -3004,6 +3016,8 @@ components: properties: name: type: string + owner: + type: string ok: $ref: '#/components/schemas/AnalysedType' err: @@ -3031,6 +3045,8 @@ components: properties: name: type: string + owner: + type: string items: type: array items: @@ -3055,6 +3071,8 @@ components: properties: name: type: string + owner: + type: string cases: type: array items: diff --git a/openapi/golem-service.yaml b/openapi/golem-service.yaml index 7401b0c5e9..8ad661f347 100644 --- a/openapi/golem-service.yaml +++ b/openapi/golem-service.yaml @@ -9188,6 +9188,8 @@ components: properties: name: type: string + owner: + type: string cases: type: array items: @@ -9206,6 +9208,8 @@ components: properties: name: type: string + owner: + type: string names: type: array items: @@ -9218,6 +9222,8 @@ components: properties: name: type: string + owner: + type: string resource_id: type: integer format: uint64 @@ -9232,6 +9238,8 @@ components: properties: name: type: string + owner: + type: string inner: $ref: '#/components/schemas/AnalysedType' required: @@ -9242,6 +9250,8 @@ components: properties: name: type: string + owner: + type: string inner: $ref: '#/components/schemas/AnalysedType' required: @@ -9252,6 +9262,8 @@ components: properties: name: type: string + owner: + type: string fields: type: array items: @@ -9264,6 +9276,8 @@ components: properties: name: type: string + owner: + type: string ok: $ref: '#/components/schemas/AnalysedType' err: @@ -9289,6 +9303,8 @@ components: properties: name: type: string + owner: + type: string items: type: array items: @@ -9313,6 +9329,8 @@ components: properties: name: type: string + owner: + type: string cases: type: array items: @@ -9372,6 +9390,40 @@ components: ActivatePluginResponse: title: ActivatePluginResponse type: object + AgentInstanceDescription: + title: AgentInstanceDescription + type: object + properties: + createdAt: + type: string + format: date-time + agentParameters: + $ref: '#/components/schemas/DataValue' + required: + - createdAt + - agentParameters + AgentInstanceKey: + title: AgentInstanceKey + type: object + properties: + agentType: + type: string + agentId: + type: string + required: + - agentType + - agentId + AgentInstanceMetadata: + title: AgentInstanceMetadata + type: object + properties: + key: + $ref: '#/components/schemas/AgentInstanceKey' + description: + $ref: '#/components/schemas/AgentInstanceDescription' + required: + - key + - description ApiDefinitionInfo: title: ApiDefinitionInfo type: object @@ -9450,6 +9502,54 @@ components: type: string required: - host + BinaryReference: + discriminator: + propertyName: type + mapping: + Url: '#/components/schemas/BinaryReference_Url' + Inline: '#/components/schemas/BinaryReference_BinarySource' + type: object + oneOf: + - $ref: '#/components/schemas/BinaryReference_Url' + - $ref: '#/components/schemas/BinaryReference_BinarySource' + BinaryReference_BinarySource: + allOf: + - type: object + properties: + type: + example: Inline + type: string + enum: + - Inline + required: + - type + - $ref: '#/components/schemas/BinarySource' + BinaryReference_Url: + allOf: + - type: object + properties: + type: + example: Url + type: string + enum: + - Url + required: + - type + - $ref: '#/components/schemas/Url' + BinarySource: + title: BinarySource + type: object + properties: + data: + type: array + items: + type: integer + format: uint8 + binaryType: + $ref: '#/components/schemas/BinaryType' + required: + - data + - binaryType CancelInvocationParameters: title: CancelInvocationParameters type: object @@ -9546,6 +9646,21 @@ components: required: - oplogIdx - data + CreateAgentInstanceParameters: + title: CreateAgentInstanceParameters + type: object + properties: + timestamp: + type: string + format: date-time + key: + $ref: '#/components/schemas/AgentInstanceKey' + parameters: + $ref: '#/components/schemas/DataValue' + required: + - timestamp + - key + - parameters CreateParameters: title: CreateParameters type: object @@ -9599,6 +9714,40 @@ components: - componentSize - initialTotalLinearMemorySize - initialActivePlugins + DataValue: + discriminator: + propertyName: type + mapping: + Tuple: '#/components/schemas/DataValue_ElementValues' + Multimodal: '#/components/schemas/DataValue_NamedElementValues' + type: object + oneOf: + - $ref: '#/components/schemas/DataValue_ElementValues' + - $ref: '#/components/schemas/DataValue_NamedElementValues' + DataValue_ElementValues: + allOf: + - type: object + properties: + type: + example: Tuple + type: string + enum: + - Tuple + required: + - type + - $ref: '#/components/schemas/ElementValues' + DataValue_NamedElementValues: + allOf: + - type: object + properties: + type: + example: Multimodal + type: string + enum: + - Multimodal + required: + - type + - $ref: '#/components/schemas/NamedElementValues' DeactivatePluginParameters: title: DeactivatePluginParameters type: object @@ -9627,6 +9776,8 @@ components: id: type: integer format: uint64 + resourceOwner: + type: string resourceName: type: string resourceParams: @@ -9636,6 +9787,7 @@ components: required: - timestamp - id + - resourceOwner - resourceName - resourceParams DomainRequest: @@ -9650,6 +9802,76 @@ components: required: - projectId - domainName + DropAgentInstanceParameters: + title: DropAgentInstanceParameters + type: object + properties: + timestamp: + type: string + format: date-time + key: + $ref: '#/components/schemas/AgentInstanceKey' + required: + - timestamp + - key + ElementValue: + discriminator: + propertyName: type + mapping: + ComponentModel: '#/components/schemas/ElementValue_ValueAndType' + UnstructuredText: '#/components/schemas/ElementValue_TextReference' + UnstructuredBinary: '#/components/schemas/ElementValue_BinaryReference' + type: object + oneOf: + - $ref: '#/components/schemas/ElementValue_ValueAndType' + - $ref: '#/components/schemas/ElementValue_TextReference' + - $ref: '#/components/schemas/ElementValue_BinaryReference' + ElementValue_BinaryReference: + allOf: + - type: object + properties: + type: + example: UnstructuredBinary + type: string + enum: + - UnstructuredBinary + required: + - type + - $ref: '#/components/schemas/BinaryReference' + ElementValue_TextReference: + allOf: + - type: object + properties: + type: + example: UnstructuredText + type: string + enum: + - UnstructuredText + required: + - type + - $ref: '#/components/schemas/TextReference' + ElementValue_ValueAndType: + allOf: + - type: object + properties: + type: + example: ComponentModel + type: string + enum: + - ComponentModel + required: + - type + - $ref: '#/components/schemas/ValueAndType' + ElementValues: + title: ElementValues + type: object + properties: + elements: + type: array + items: + $ref: '#/components/schemas/ElementValue' + required: + - elements EndRegionParameters: title: EndRegionParameters type: object @@ -9765,6 +9987,45 @@ components: - traceId - traceStates - invocationContext + ExportedResourceInstanceDescription: + title: ExportedResourceInstanceDescription + type: object + properties: + createdAt: + type: string + format: date-time + resourceOwner: + type: string + resourceName: + type: string + resourceParams: + type: array + items: + type: string + required: + - createdAt + - resourceOwner + - resourceName + ExportedResourceInstanceKey: + title: ExportedResourceInstanceKey + type: object + properties: + resourceId: + type: integer + format: uint64 + required: + - resourceId + ExportedResourceMetadata: + title: ExportedResourceMetadata + type: object + properties: + key: + $ref: '#/components/schemas/ExportedResourceInstanceKey' + description: + $ref: '#/components/schemas/ExportedResourceInstanceDescription' + required: + - key + - description FailedUpdate: title: FailedUpdate type: object @@ -10036,19 +10297,6 @@ components: - request - response - durableFunctionType - IndexedWorkerMetadata: - title: IndexedWorkerMetadata - type: object - properties: - resourceName: - type: string - resourceParams: - type: array - items: - type: string - required: - - resourceName - - resourceParams InterruptResponse: title: InterruptResponse type: object @@ -10134,6 +10382,27 @@ components: - Options - Trace - Head + NamedElementValue: + title: NamedElementValue + type: object + properties: + name: + type: string + value: + $ref: '#/components/schemas/ElementValue' + required: + - name + - value + NamedElementValues: + title: NamedElementValues + type: object + properties: + elements: + type: array + items: + $ref: '#/components/schemas/NamedElementValue' + required: + - elements OpenApiHttpApiDefinitionResponse: title: OpenApiHttpApiDefinitionResponse type: object @@ -10401,6 +10670,8 @@ components: FinishSpan: '#/components/schemas/PublicOplogEntry_FinishSpanParameters' SetSpanAttribute: '#/components/schemas/PublicOplogEntry_SetSpanAttributeParameters' ChangePersistenceLevel: '#/components/schemas/PublicOplogEntry_ChangePersistenceLevelParameters' + CreateAgentInstance: '#/components/schemas/PublicOplogEntry_CreateAgentInstanceParameters' + DropAgentInstance: '#/components/schemas/PublicOplogEntry_DropAgentInstanceParameters' type: object oneOf: - $ref: '#/components/schemas/PublicOplogEntry_CreateParameters' @@ -10436,6 +10707,8 @@ components: - $ref: '#/components/schemas/PublicOplogEntry_FinishSpanParameters' - $ref: '#/components/schemas/PublicOplogEntry_SetSpanAttributeParameters' - $ref: '#/components/schemas/PublicOplogEntry_ChangePersistenceLevelParameters' + - $ref: '#/components/schemas/PublicOplogEntry_CreateAgentInstanceParameters' + - $ref: '#/components/schemas/PublicOplogEntry_DropAgentInstanceParameters' PublicOplogEntryWithIndex: title: PublicOplogEntryWithIndex type: object @@ -10532,6 +10805,27 @@ components: required: - type - $ref: '#/components/schemas/ChangeRetryPolicyParameters' + PublicOplogEntry_CreateAgentInstanceParameters: + description: |- + A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. + + Instead, it encodes all payloads with wasm-rpc `Value` types. This makes this the base type + for exposing oplog entries through various APIs such as gRPC, REST and WIT. + + The rest of the system will always use `OplogEntry` internally - the only point where the + oplog payloads are decoded and re-encoded as `Value` is in this module, and it should only be used + before exposing an oplog entry through a public API. + allOf: + - type: object + properties: + type: + example: CreateAgentInstance + type: string + enum: + - CreateAgentInstance + required: + - type + - $ref: '#/components/schemas/CreateAgentInstanceParameters' PublicOplogEntry_CreateParameters: description: |- A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. @@ -10595,6 +10889,27 @@ components: required: - type - $ref: '#/components/schemas/DescribeResourceParameters' + PublicOplogEntry_DropAgentInstanceParameters: + description: |- + A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. + + Instead, it encodes all payloads with wasm-rpc `Value` types. This makes this the base type + for exposing oplog entries through various APIs such as gRPC, REST and WIT. + + The rest of the system will always use `OplogEntry` internally - the only point where the + oplog payloads are decoded and re-encoded as `Value` is in this module, and it should only be used + before exposing an oplog entry through a public API. + allOf: + - type: object + properties: + type: + example: DropAgentInstance + type: string + enum: + - DropAgentInstance + required: + - type + - $ref: '#/components/schemas/DropAgentInstanceParameters' PublicOplogEntry_EndRegionParameters: description: |- A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. @@ -11111,17 +11426,6 @@ components: required: - name - version - ResourceMetadata: - title: ResourceMetadata - type: object - properties: - createdAt: - type: string - format: date-time - indexed: - $ref: '#/components/schemas/IndexedWorkerMetadata' - required: - - createdAt ResourceParameters: title: ResourceParameters type: object @@ -11132,9 +11436,15 @@ components: id: type: integer format: uint64 + name: + type: string + owner: + type: string required: - timestamp - id + - name + - owner ResumeResponse: title: ResumeResponse type: object @@ -11393,6 +11703,50 @@ components: - target_version - new_component_size - new_active_plugins + TextReference: + discriminator: + propertyName: type + mapping: + Url: '#/components/schemas/TextReference_Url' + Inline: '#/components/schemas/TextReference_TextSource' + type: object + oneOf: + - $ref: '#/components/schemas/TextReference_Url' + - $ref: '#/components/schemas/TextReference_TextSource' + TextReference_TextSource: + allOf: + - type: object + properties: + type: + example: Inline + type: string + enum: + - Inline + required: + - type + - $ref: '#/components/schemas/TextSource' + TextReference_Url: + allOf: + - type: object + properties: + type: + example: Url + type: string + enum: + - Url + required: + - type + - $ref: '#/components/schemas/Url' + TextSource: + title: TextSource + type: object + properties: + data: + type: string + textType: + $ref: '#/components/schemas/TextType' + required: + - data TimestampParameter: title: TimestampParameter type: object @@ -11465,6 +11819,14 @@ components: UpdateWorkerResponse: title: UpdateWorkerResponse type: object + Url: + title: Url + type: object + properties: + value: + type: string + required: + - value ValueAndOptionalType: type: object properties: @@ -11771,10 +12133,14 @@ components: totalLinearMemorySize: type: integer format: uint64 - ownedResources: - type: object - additionalProperties: - $ref: '#/components/schemas/ResourceMetadata' + exportedResourceInstances: + type: array + items: + $ref: '#/components/schemas/ExportedResourceMetadata' + agentInstances: + type: array + items: + $ref: '#/components/schemas/AgentInstanceMetadata' activePlugins: type: array items: @@ -11808,7 +12174,8 @@ components: - createdAt - componentSize - totalLinearMemorySize - - ownedResources + - exportedResourceInstances + - agentInstances - activePlugins - skippedRegions - deletedRegions diff --git a/openapi/golem-worker-service.yaml b/openapi/golem-worker-service.yaml index 61df901b1b..0bba53f2ff 100644 --- a/openapi/golem-worker-service.yaml +++ b/openapi/golem-worker-service.yaml @@ -3430,6 +3430,40 @@ components: ActivatePluginResponse: type: object title: ActivatePluginResponse + AgentInstanceDescription: + type: object + title: AgentInstanceDescription + required: + - createdAt + - agentParameters + properties: + createdAt: + type: string + format: date-time + agentParameters: + $ref: '#/components/schemas/DataValue' + AgentInstanceKey: + type: object + title: AgentInstanceKey + required: + - agentType + - agentId + properties: + agentType: + type: string + agentId: + type: string + AgentInstanceMetadata: + type: object + title: AgentInstanceMetadata + required: + - key + - description + properties: + key: + $ref: '#/components/schemas/AgentInstanceKey' + description: + $ref: '#/components/schemas/AgentInstanceDescription' AnalysedResourceMode: type: string enum: @@ -3827,6 +3861,62 @@ components: type: string subdomain: type: string + BinaryReference: + type: object + oneOf: + - $ref: '#/components/schemas/BinaryReference_Url' + - $ref: '#/components/schemas/BinaryReference_BinarySource' + discriminator: + propertyName: type + mapping: + Url: '#/components/schemas/BinaryReference_Url' + Inline: '#/components/schemas/BinaryReference_BinarySource' + BinaryReference_BinarySource: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - Inline + example: Inline + - $ref: '#/components/schemas/BinarySource' + BinaryReference_Url: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - Url + example: Url + - $ref: '#/components/schemas/Url' + BinarySource: + type: object + title: BinarySource + required: + - data + - binaryType + properties: + data: + type: array + items: + type: integer + format: uint8 + binaryType: + $ref: '#/components/schemas/BinaryType' + BinaryType: + type: object + title: BinaryType + required: + - mimeType + properties: + mimeType: + type: string CancelInvocationParameters: type: object title: CancelInvocationParameters @@ -3928,6 +4018,21 @@ components: enum: - read-only - read-write + CreateAgentInstanceParameters: + type: object + title: CreateAgentInstanceParameters + required: + - timestamp + - key + - parameters + properties: + timestamp: + type: string + format: date-time + key: + $ref: '#/components/schemas/AgentInstanceKey' + parameters: + $ref: '#/components/schemas/DataValue' CreateParameters: type: object title: CreateParameters @@ -3981,6 +4086,40 @@ components: type: array items: $ref: '#/components/schemas/PluginInstallationDescription' + DataValue: + type: object + oneOf: + - $ref: '#/components/schemas/DataValue_ElementValues' + - $ref: '#/components/schemas/DataValue_NamedElementValues' + discriminator: + propertyName: type + mapping: + Tuple: '#/components/schemas/DataValue_ElementValues' + Multimodal: '#/components/schemas/DataValue_NamedElementValues' + DataValue_ElementValues: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - Tuple + example: Tuple + - $ref: '#/components/schemas/ElementValues' + DataValue_NamedElementValues: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - Multimodal + example: Multimodal + - $ref: '#/components/schemas/NamedElementValues' DeactivatePluginParameters: type: object title: DeactivatePluginParameters @@ -4005,6 +4144,7 @@ components: required: - timestamp - id + - resourceOwner - resourceName - resourceParams properties: @@ -4014,6 +4154,8 @@ components: id: type: integer format: uint64 + resourceOwner: + type: string resourceName: type: string resourceParams: @@ -4032,6 +4174,76 @@ components: format: uuid domainName: type: string + DropAgentInstanceParameters: + type: object + title: DropAgentInstanceParameters + required: + - timestamp + - key + properties: + timestamp: + type: string + format: date-time + key: + $ref: '#/components/schemas/AgentInstanceKey' + ElementValue: + type: object + oneOf: + - $ref: '#/components/schemas/ElementValue_ValueAndType' + - $ref: '#/components/schemas/ElementValue_TextReference' + - $ref: '#/components/schemas/ElementValue_BinaryReference' + discriminator: + propertyName: type + mapping: + ComponentModel: '#/components/schemas/ElementValue_ValueAndType' + UnstructuredText: '#/components/schemas/ElementValue_TextReference' + UnstructuredBinary: '#/components/schemas/ElementValue_BinaryReference' + ElementValue_BinaryReference: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - UnstructuredBinary + example: UnstructuredBinary + - $ref: '#/components/schemas/BinaryReference' + ElementValue_TextReference: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - UnstructuredText + example: UnstructuredText + - $ref: '#/components/schemas/TextReference' + ElementValue_ValueAndType: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - ComponentModel + example: ComponentModel + - $ref: '#/components/schemas/ValueAndType' + ElementValues: + type: object + title: ElementValues + required: + - elements + properties: + elements: + type: array + items: + $ref: '#/components/schemas/ElementValue' Empty: type: object title: Empty @@ -4168,6 +4380,45 @@ components: type: array items: $ref: '#/components/schemas/PublicSpanData' + ExportedResourceInstanceDescription: + type: object + title: ExportedResourceInstanceDescription + required: + - createdAt + - resourceOwner + - resourceName + properties: + createdAt: + type: string + format: date-time + resourceOwner: + type: string + resourceName: + type: string + resourceParams: + type: array + items: + type: string + ExportedResourceInstanceKey: + type: object + title: ExportedResourceInstanceKey + required: + - resourceId + properties: + resourceId: + type: integer + format: uint64 + ExportedResourceMetadata: + type: object + title: ExportedResourceMetadata + required: + - key + - description + properties: + key: + $ref: '#/components/schemas/ExportedResourceInstanceKey' + description: + $ref: '#/components/schemas/ExportedResourceInstanceDescription' FailedUpdate: type: object title: FailedUpdate @@ -4442,19 +4693,6 @@ components: $ref: '#/components/schemas/ValueAndType' durableFunctionType: $ref: '#/components/schemas/PublicDurableFunctionType' - IndexedWorkerMetadata: - type: object - title: IndexedWorkerMetadata - required: - - resourceName - - resourceParams - properties: - resourceName: - type: string - resourceParams: - type: array - items: - type: string InterruptResponse: type: object title: InterruptResponse @@ -4561,6 +4799,27 @@ components: type: string typ: $ref: '#/components/schemas/AnalysedType' + NamedElementValue: + type: object + title: NamedElementValue + required: + - name + - value + properties: + name: + type: string + value: + $ref: '#/components/schemas/ElementValue' + NamedElementValues: + type: object + title: NamedElementValues + required: + - elements + properties: + elements: + type: array + items: + $ref: '#/components/schemas/NamedElementValue' OpenApiHttpApiDefinitionResponse: type: object title: OpenApiHttpApiDefinitionResponse @@ -4827,6 +5086,8 @@ components: - $ref: '#/components/schemas/PublicOplogEntry_FinishSpanParameters' - $ref: '#/components/schemas/PublicOplogEntry_SetSpanAttributeParameters' - $ref: '#/components/schemas/PublicOplogEntry_ChangePersistenceLevelParameters' + - $ref: '#/components/schemas/PublicOplogEntry_CreateAgentInstanceParameters' + - $ref: '#/components/schemas/PublicOplogEntry_DropAgentInstanceParameters' discriminator: propertyName: type mapping: @@ -4863,6 +5124,8 @@ components: FinishSpan: '#/components/schemas/PublicOplogEntry_FinishSpanParameters' SetSpanAttribute: '#/components/schemas/PublicOplogEntry_SetSpanAttributeParameters' ChangePersistenceLevel: '#/components/schemas/PublicOplogEntry_ChangePersistenceLevelParameters' + CreateAgentInstance: '#/components/schemas/PublicOplogEntry_CreateAgentInstanceParameters' + DropAgentInstance: '#/components/schemas/PublicOplogEntry_DropAgentInstanceParameters' PublicOplogEntryWithIndex: type: object title: PublicOplogEntryWithIndex @@ -4959,6 +5222,27 @@ components: - ChangeRetryPolicy example: ChangeRetryPolicy - $ref: '#/components/schemas/ChangeRetryPolicyParameters' + PublicOplogEntry_CreateAgentInstanceParameters: + description: |- + A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. + + Instead, it encodes all payloads with wasm-rpc `Value` types. This makes this the base type + for exposing oplog entries through various APIs such as gRPC, REST and WIT. + + The rest of the system will always use `OplogEntry` internally - the only point where the + oplog payloads are decoded and re-encoded as `Value` is in this module, and it should only be used + before exposing an oplog entry through a public API. + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - CreateAgentInstance + example: CreateAgentInstance + - $ref: '#/components/schemas/CreateAgentInstanceParameters' PublicOplogEntry_CreateParameters: description: |- A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. @@ -5022,6 +5306,27 @@ components: - DescribeResource example: DescribeResource - $ref: '#/components/schemas/DescribeResourceParameters' + PublicOplogEntry_DropAgentInstanceParameters: + description: |- + A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. + + Instead, it encodes all payloads with wasm-rpc `Value` types. This makes this the base type + for exposing oplog entries through various APIs such as gRPC, REST and WIT. + + The rest of the system will always use `OplogEntry` internally - the only point where the + oplog payloads are decoded and re-encoded as `Value` is in this module, and it should only be used + before exposing an oplog entry through a public API. + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - DropAgentInstance + example: DropAgentInstance + - $ref: '#/components/schemas/DropAgentInstanceParameters' PublicOplogEntry_EndRegionParameters: description: |- A mirror of the core `OplogEntry` type, without the undefined arbitrary payloads. @@ -5538,23 +5843,14 @@ components: version: type: integer format: uint64 - ResourceMetadata: - type: object - title: ResourceMetadata - required: - - createdAt - properties: - createdAt: - type: string - format: date-time - indexed: - $ref: '#/components/schemas/IndexedWorkerMetadata' ResourceParameters: type: object title: ResourceParameters required: - timestamp - id + - name + - owner properties: timestamp: type: string @@ -5562,6 +5858,10 @@ components: id: type: integer format: uint64 + name: + type: string + owner: + type: string ResumeResponse: type: object title: ResumeResponse @@ -5820,6 +6120,58 @@ components: type: array items: $ref: '#/components/schemas/PluginInstallationDescription' + TextReference: + type: object + oneOf: + - $ref: '#/components/schemas/TextReference_Url' + - $ref: '#/components/schemas/TextReference_TextSource' + discriminator: + propertyName: type + mapping: + Url: '#/components/schemas/TextReference_Url' + Inline: '#/components/schemas/TextReference_TextSource' + TextReference_TextSource: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - Inline + example: Inline + - $ref: '#/components/schemas/TextSource' + TextReference_Url: + allOf: + - type: object + required: + - type + properties: + type: + type: string + enum: + - Url + example: Url + - $ref: '#/components/schemas/Url' + TextSource: + type: object + title: TextSource + required: + - data + properties: + data: + type: string + textType: + $ref: '#/components/schemas/TextType' + TextType: + type: object + title: TextType + required: + - languageCode + properties: + languageCode: + type: string TimestampParameter: type: object title: TimestampParameter @@ -5843,6 +6195,8 @@ components: properties: name: type: string + owner: + type: string cases: type: array items: @@ -5861,6 +6215,8 @@ components: properties: name: type: string + owner: + type: string names: type: array items: @@ -5874,6 +6230,8 @@ components: properties: name: type: string + owner: + type: string resource_id: type: integer format: uint64 @@ -5887,6 +6245,8 @@ components: properties: name: type: string + owner: + type: string inner: $ref: '#/components/schemas/AnalysedType' TypeOption: @@ -5897,6 +6257,8 @@ components: properties: name: type: string + owner: + type: string inner: $ref: '#/components/schemas/AnalysedType' TypeRecord: @@ -5907,6 +6269,8 @@ components: properties: name: type: string + owner: + type: string fields: type: array items: @@ -5917,6 +6281,8 @@ components: properties: name: type: string + owner: + type: string ok: $ref: '#/components/schemas/AnalysedType' err: @@ -5944,6 +6310,8 @@ components: properties: name: type: string + owner: + type: string items: type: array items: @@ -5968,6 +6336,8 @@ components: properties: name: type: string + owner: + type: string cases: type: array items: @@ -6035,6 +6405,14 @@ components: UpdateWorkerResponse: type: object title: UpdateWorkerResponse + Url: + type: object + title: Url + required: + - value + properties: + value: + type: string ValueAndOptionalType: type: object required: @@ -6318,7 +6696,8 @@ components: - createdAt - componentSize - totalLinearMemorySize - - ownedResources + - exportedResourceInstances + - agentInstances - activePlugins - skippedRegions - deletedRegions @@ -6368,10 +6747,14 @@ components: totalLinearMemorySize: type: integer format: uint64 - ownedResources: - type: object - additionalProperties: - $ref: '#/components/schemas/ResourceMetadata' + exportedResourceInstances: + type: array + items: + $ref: '#/components/schemas/ExportedResourceMetadata' + agentInstances: + type: array + items: + $ref: '#/components/schemas/AgentInstanceMetadata' activePlugins: type: array items: diff --git a/test-components/auction-example/Cargo.lock b/test-components/auction-example/Cargo.lock index 15cc510c61..91beaac35b 100644 --- a/test-components/auction-example/Cargo.lock +++ b/test-components/auction-example/Cargo.lock @@ -3,13 +3,10 @@ version = 4 [[package]] -name = "aho-corasick" -version = "1.1.3" +name = "adler2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" -dependencies = [ - "memchr", -] +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" [[package]] name = "android-tzdata" @@ -53,6 +50,18 @@ dependencies = [ "wit-bindgen-rt 0.40.0", ] +[[package]] +name = "auditable-serde" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7bf8143dfc3c0258df908843e169b5cc5fcf76c7718bd66135ef4a9cd558c5" +dependencies = [ + "semver", + "serde", + "serde_json", + "topological-sort", +] + [[package]] name = "autocfg" version = "1.4.0" @@ -71,12 +80,6 @@ version = "3.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf" -[[package]] -name = "bytes" -version = "1.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" - [[package]] name = "camino" version = "1.1.9" @@ -146,10 +149,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] -name = "either" -version = "1.15.0" +name = "crc32fast" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] [[package]] name = "equivalent" @@ -158,26 +175,118 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] -name = "errno" -version = "0.3.10" +name = "flate2" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d" +checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" dependencies = [ - "libc", - "windows-sys", + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn", ] [[package]] -name = "fastrand" -version = "2.3.0" +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" [[package]] -name = "fixedbitset" -version = "0.5.7" +name = "futures-util" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] [[package]] name = "getrandom" @@ -224,23 +333,21 @@ dependencies = [ [[package]] name = "golem-rust" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c988a314d2b3a6f1ccf8cf26f24253837a62e257f61f57ad33d30f83c17a2f2d" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "golem-rust-macro", "golem-wasm-rpc", "serde", "serde_json", "uuid", - "wit-bindgen-rt 0.40.0", + "wit-bindgen", ] [[package]] name = "golem-rust-macro" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bdaa58a3dfea9eec292d4e0529358be7fd4240cdc459dc7b5bf203727559edc" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "heck", "proc-macro2", @@ -250,14 +357,12 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" -version = "1.2.0-rc4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80de906d46b1ff00f7cd695ad1c6b57f4679089063ae9d65a0226e7d2c424cc6" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#b65adf9d20167fd33c71503e015a0b478a1234cb" dependencies = [ "cargo_metadata", "chrono", "git-version", - "prost-build", "uuid", "wit-bindgen-rt 0.40.0", ] @@ -267,6 +372,9 @@ name = "hashbrown" version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +dependencies = [ + "foldhash", +] [[package]] name = "heck" @@ -298,22 +406,127 @@ dependencies = [ ] [[package]] -name = "indexmap" -version = "2.8.0" +name = "icu_collections" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" dependencies = [ - "equivalent", - "hashbrown", + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005" + +[[package]] +name = "idna" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", ] [[package]] -name = "itertools" -version = "0.14.0" +name = "idna_adapter" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" dependencies = [ - "either", + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058" +dependencies = [ + "equivalent", + "hashbrown", + "serde", ] [[package]] @@ -332,6 +545,12 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" version = "0.2.171" @@ -339,10 +558,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6" [[package]] -name = "linux-raw-sys" -version = "0.9.3" +name = "litemap" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "log" @@ -357,10 +576,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] -name = "multimap" -version = "0.10.0" +name = "miniz_oxide" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", +] [[package]] name = "num-traits" @@ -378,13 +600,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] -name = "petgraph" -version = "0.7.1" +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "potential_utf" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772" +checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" dependencies = [ - "fixedbitset", - "indexmap", + "zerovec", ] [[package]] @@ -412,58 +651,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "prost" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" -dependencies = [ - "bytes", - "prost-derive", -] - -[[package]] -name = "prost-build" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf" -dependencies = [ - "heck", - "itertools", - "log", - "multimap", - "once_cell", - "petgraph", - "prettyplease", - "prost", - "prost-types", - "regex", - "syn", - "tempfile", -] - -[[package]] -name = "prost-derive" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" -dependencies = [ - "anyhow", - "itertools", - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "prost-types" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" -dependencies = [ - "prost", -] - [[package]] name = "quote" version = "1.0.40" @@ -509,48 +696,6 @@ dependencies = [ "getrandom 0.2.12", ] -[[package]] -name = "regex" -version = "1.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata", - "regex-syntax", -] - -[[package]] -name = "regex-automata" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax", -] - -[[package]] -name = "regex-syntax" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" - -[[package]] -name = "rustix" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e56a18552996ac8d29ecc3b190b4fdbb2d91ca4ec396de7bbffaf43f3d637e96" -dependencies = [ - "bitflags", - "errno", - "libc", - "linux-raw-sys", - "windows-sys", -] - [[package]] name = "rustversion" version = "1.0.20" @@ -616,6 +761,33 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "slab" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "spdx" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e17e880bafaeb362a7b751ec46bdc5b61445a188f80e0606e68167cd540fa3" +dependencies = [ + "smallvec", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + [[package]] name = "syn" version = "2.0.100" @@ -628,16 +800,14 @@ dependencies = [ ] [[package]] -name = "tempfile" -version = "3.19.1" +name = "synstructure" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ - "fastrand", - "getrandom 0.3.2", - "once_cell", - "rustix", - "windows-sys", + "proc-macro2", + "quote", + "syn", ] [[package]] @@ -660,12 +830,51 @@ dependencies = [ "syn", ] +[[package]] +name = "tinystr" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "topological-sort" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d" + [[package]] name = "unicode-ident" version = "1.0.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "url" +version = "2.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + [[package]] name = "uuid" version = "1.16.0" @@ -750,6 +959,47 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-encoder" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80bb72f02e7fbf07183443b27b0f3d4144abf8c114189f2e088ed95b696a7822" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce1ef0faabbbba6674e97a56bee857ccddf942785a336c8b47b42373c922a91d" +dependencies = [ + "anyhow", + "auditable-serde", + "flate2", + "indexmap", + "serde", + "serde_derive", + "serde_json", + "spdx", + "url", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f51cad774fb3c9461ab9bccc9c62dfb7388397b5deda31bf40e8108ccd678b2" +dependencies = [ + "bitflags", + "hashbrown", + "indexmap", + "semver", +] + [[package]] name = "windows-core" version = "0.52.0" @@ -765,15 +1015,6 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38" -[[package]] -name = "windows-sys" -version = "0.59.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" -dependencies = [ - "windows-targets", -] - [[package]] name = "windows-targets" version = "0.52.6" @@ -838,6 +1079,27 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +[[package]] +name = "wit-bindgen" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e7091ed6c9abfa4e0a2ef3b39d0539da992d841fcf32c255f64fb98764ffee5" +dependencies = [ + "wit-bindgen-rt 0.40.0", + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "398c650cec1278cfb72e214ba26ef3440ab726e66401bd39c04f465ee3979e6b" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + [[package]] name = "wit-bindgen-rt" version = "0.39.0" @@ -854,4 +1116,158 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68faed92ae696b93ea9a7b67ba6c37bf09d72c6d9a70fa824a743c3020212f11" dependencies = [ "bitflags", + "futures", + "once_cell", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83903c8dcd8084a8a67ae08190122cf0e25dc37bdc239070a00f47e22d3f0aae" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7bf7f20495bcc7dc9f24c5fbcac9e919ca5ebdb7a1b1841d74447d3c8dd0c60" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "635c3adc595422cbf2341a17fb73a319669cc8d33deed3a48368a841df86b676" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddf445ed5157046e4baf56f9138c124a0824d4d1657e7204d71886ad8ce2fc11" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn", ] diff --git a/test-components/auction-example/auction-registry/Cargo.toml b/test-components/auction-example/auction-registry/Cargo.toml index 3b9da28680..e483583908 100644 --- a/test-components/auction-example/auction-registry/Cargo.toml +++ b/test-components/auction-example/auction-registry/Cargo.toml @@ -22,7 +22,7 @@ path = "wit-generated" "golem:rpc/types@0.2.2" = "golem_rust::wasm_rpc::golem_rpc_0_2_x::types" [dependencies] -golem-rust = { version = "1.4.0" } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } once_cell = "1.19.0" rand = "0.8.5" diff --git a/test-components/auction.wasm b/test-components/auction.wasm index ca056b47f5..00744df631 100755 Binary files a/test-components/auction.wasm and b/test-components/auction.wasm differ diff --git a/test-components/auction_registry.wasm b/test-components/auction_registry.wasm index 10dfec6e33..845a17a312 100644 Binary files a/test-components/auction_registry.wasm and b/test-components/auction_registry.wasm differ diff --git a/test-components/auction_registry_composed.wasm b/test-components/auction_registry_composed.wasm index 62e64fd9f2..9d47fa5373 100644 Binary files a/test-components/auction_registry_composed.wasm and b/test-components/auction_registry_composed.wasm differ diff --git a/test-components/blob-store-service/wit/deps.lock b/test-components/blob-store-service/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/blob-store-service/wit/deps.lock +++ b/test-components/blob-store-service/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/blob-store-service/wit/deps.toml b/test-components/blob-store-service/wit/deps.toml index 7ba2d06e1d..36e3f89e5a 100644 --- a/test-components/blob-store-service/wit/deps.toml +++ b/test-components/blob-store-service/wit/deps.toml @@ -1,2 +1,2 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" diff --git a/test-components/blob-store-service/wit/deps/golem-1.x/golem-host.wit b/test-components/blob-store-service/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/blob-store-service/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/blob-store-service/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/blob-store-service/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/blob-store-service/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/blob-store-service/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/blob-store-service/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/build-components.sh b/test-components/build-components.sh index bff044da8a..b0ca7f8efb 100755 --- a/test-components/build-components.sh +++ b/test-components/build-components.sh @@ -4,7 +4,7 @@ IFS=$'\n\t' rust_test_components=("write-stdout" "write-stderr" "read-stdin" "clocks" "shopping-cart" "file-write-read-delete" "file-service" "http-client" "directories" "environment-service" "promise" "interruption" "clock-service" "option-service" "flags-service" "http-client-2" "stdio-cc" "failing-component" "variant-service" "key-value-service" "blob-store-service" "runtime-service" "networking" "shopping-cart-resource" -"update-test-v1" "update-test-v2-11" "update-test-v3-11" "update-test-v4" "rust-echo" "durability-overhead" "logging" "oplog-processor" "rdbms-service" "component-resolve" "http-client-3") +"update-test-v1" "update-test-v2-11" "update-test-v3-11" "update-test-v4" "rust-echo" "durability-overhead" "logging" "oplog-processor" "rdbms-service" "component-resolve" "http-client-3" "golem-rust-tests") zig_test_components=("zig-3") tinygo_test_components=("tinygo-wasi" "tinygo-wasi-http") grain_test_components=("grain-1") @@ -15,7 +15,7 @@ swift_test_components=("swift-1") c_test_components=("c-1" "large-initial-memory" "large-dynamic-memory") python_test_components=("python-1" "py-echo") -rust_test_apps=("auction-example" "rpc" "rust-service/rpc" "custom-durability") +rust_test_apps=("auction-example" "rpc" "rust-service/rpc" "custom-durability" "low-level-agent") ts_test_apps=("ts-rpc") # Optional arguments: diff --git a/test-components/caller-ts.wasm b/test-components/caller-ts.wasm index 1e86e1c978..543b536cbe 100644 Binary files a/test-components/caller-ts.wasm and b/test-components/caller-ts.wasm differ diff --git a/test-components/caller.wasm b/test-components/caller.wasm index eed23b7112..7877762ce7 100644 Binary files a/test-components/caller.wasm and b/test-components/caller.wasm differ diff --git a/test-components/caller_composed.wasm b/test-components/caller_composed.wasm index 5bc9ba6788..5a60663c11 100644 Binary files a/test-components/caller_composed.wasm and b/test-components/caller_composed.wasm differ diff --git a/test-components/child_component.wasm b/test-components/child_component.wasm index 9ef180ad59..231d4e01c2 100755 Binary files a/test-components/child_component.wasm and b/test-components/child_component.wasm differ diff --git a/test-components/clocks.wasm b/test-components/clocks.wasm index afcdbaaa6d..8bbb1a580f 100755 Binary files a/test-components/clocks.wasm and b/test-components/clocks.wasm differ diff --git a/test-components/component-resolve/src/bindings.rs b/test-components/component-resolve/src/bindings.rs index 89f0899880..627f910212 100644 --- a/test-components/component-resolve/src/bindings.rs +++ b/test-components/component-resolve/src/bindings.rs @@ -384,12 +384,31 @@ pub mod golem { } } #[derive(Clone)] + pub struct WorkerWasiConfigVarsFilter { + pub name: _rt::String, + pub comparator: StringFilterComparator, + pub value: _rt::String, + } + impl ::core::fmt::Debug for WorkerWasiConfigVarsFilter { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("WorkerWasiConfigVarsFilter") + .field("name", &self.name) + .field("comparator", &self.comparator) + .field("value", &self.value) + .finish() + } + } + #[derive(Clone)] pub enum WorkerPropertyFilter { Name(WorkerNameFilter), Status(WorkerStatusFilter), Version(WorkerVersionFilter), CreatedAt(WorkerCreatedAtFilter), Env(WorkerEnvFilter), + WasiConfigVars(WorkerWasiConfigVarsFilter), } impl ::core::fmt::Debug for WorkerPropertyFilter { fn fmt( @@ -418,6 +437,11 @@ pub mod golem { WorkerPropertyFilter::Env(e) => { f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish() } + WorkerPropertyFilter::WasiConfigVars(e) => { + f.debug_tuple("WorkerPropertyFilter::WasiConfigVars") + .field(e) + .finish() + } } } } @@ -454,6 +478,7 @@ pub mod golem { pub worker_id: WorkerId, pub args: _rt::Vec<_rt::String>, pub env: _rt::Vec<(_rt::String, _rt::String)>, + pub wasi_config_vars: _rt::Vec<(_rt::String, _rt::String)>, pub status: WorkerStatus, pub component_version: u64, pub retry_count: u64, @@ -467,6 +492,7 @@ pub mod golem { .field("worker-id", &self.worker_id) .field("args", &self.args) .field("env", &self.env) + .field("wasi-config-vars", &self.wasi_config_vars) .field("status", &self.status) .field("component-version", &self.component_version) .field("retry-count", &self.retry_count) @@ -590,47 +616,47 @@ pub mod golem { high_bits: high_bits1, low_bits: low_bits1, } = uuid0; - let (result14_0, result14_1, result14_2) = match filter { + let (result17_0, result17_1, result17_2) = match filter { Some(e) => { let WorkerAnyFilter { filters: filters2 } = e; - let vec13 = filters2; - let len13 = vec13.len(); - let layout13 = _rt::alloc::Layout::from_size_align_unchecked( - vec13.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec16 = filters2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result13 = if layout13.size() != 0 { - let ptr = _rt::alloc::alloc(layout13).cast::(); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout13); + _rt::alloc::handle_alloc_error(layout16); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec13.into_iter().enumerate() { - let base = result13 + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { let WorkerAllFilter { filters: filters3 } = e; - let vec12 = filters3; - let len12 = vec12.len(); - let layout12 = _rt::alloc::Layout::from_size_align_unchecked( - vec12.len() + let vec15 = filters3; + let len15 = vec15.len(); + let layout15 = _rt::alloc::Layout::from_size_align_unchecked( + vec15.len() * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); - let result12 = if layout12.size() != 0 { - let ptr = _rt::alloc::alloc(layout12).cast::(); + let result15 = if layout15.size() != 0 { + let ptr = _rt::alloc::alloc(layout15).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout12); + _rt::alloc::handle_alloc_error(layout15); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec12.into_iter().enumerate() { - let base = result12 + for (i, e) in vec15.into_iter().enumerate() { + let base = result15 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); { match e { @@ -709,18 +735,45 @@ pub mod golem { .add(8 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = ptr11.cast_mut(); } + WorkerPropertyFilter::WasiConfigVars(e) => { + *base.add(0).cast::() = (5i32) as u8; + let WorkerWasiConfigVarsFilter { + name: name12, + comparator: comparator12, + value: value12, + } = e; + let vec13 = name12; + let ptr13 = vec13.as_ptr().cast::(); + let len13 = vec13.len(); + *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::() = len13; + *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::() = (comparator12.clone() as i32) as u8; + let vec14 = value12; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr14.cast_mut(); + } } } } *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(0).cast::<*mut u8>() = result12; - cleanup_list.extend_from_slice(&[(result12, layout12)]); + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = result15; + cleanup_list.extend_from_slice(&[(result15, layout15)]); } } - cleanup_list.extend_from_slice(&[(result13, layout13)]); - (1i32, result13, len13) + cleanup_list.extend_from_slice(&[(result16, layout16)]); + (1i32, result16, len16) } None => (0i32, ::core::ptr::null_mut(), 0usize), }; @@ -728,7 +781,7 @@ pub mod golem { #[link(wasm_import_module = "golem:api/host@1.1.7")] unsafe extern "C" { #[link_name = "[constructor]get-workers"] - fn wit_import15( + fn wit_import18( _: i64, _: i64, _: i32, @@ -738,7 +791,7 @@ pub mod golem { ) -> i32; } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import15( + unsafe extern "C" fn wit_import18( _: i64, _: i64, _: i32, @@ -749,12 +802,12 @@ pub mod golem { unreachable!() } let ret = unsafe { - wit_import15( + wit_import18( _rt::as_i64(high_bits1), _rt::as_i64(low_bits1), - result14_0, - result14_1, - result14_2, + result17_0, + result17_1, + result17_2, match &precise { true => 1, false => 0, @@ -798,7 +851,7 @@ pub mod golem { } unsafe { wit_import1((self).handle() as i32, ptr0) }; let l2 = i32::from(*ptr0.add(0).cast::()); - let result29 = match l2 { + let result38 = match l2 { 0 => None, 1 => { let e = { @@ -808,13 +861,13 @@ pub mod golem { let l4 = *ptr0 .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base28 = l3; - let len28 = l4; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); - let e28 = { + let base37 = l3; + let len37 = l4; + let mut result37 = _rt::Vec::with_capacity(len37); + for i in 0..len37 { + let base = base37 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); + let e37 = { let l5 = *base.add(0).cast::(); let l6 = *base.add(8).cast::(); let l7 = *base.add(16).cast::<*mut u8>(); @@ -903,16 +956,60 @@ pub mod golem { len24 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l25 = i32::from( + let l25 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l26 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base33 = l25; + let len33 = l26; + let mut result33 = _rt::Vec::with_capacity(len33); + for i in 0..len33 { + let base = base33 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e33 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l31 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) + }; + result33.push(e33); + } + _rt::cabi_dealloc( + base33, + len33 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l34 = i32::from( *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l26 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l35 = *base + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l27 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l36 = *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -926,25 +1023,26 @@ pub mod golem { }, args: result15, env: result24, - status: WorkerStatus::_lift(l25 as u8), - component_version: l26 as u64, - retry_count: l27 as u64, + wasi_config_vars: result33, + status: WorkerStatus::_lift(l34 as u8), + component_version: l35 as u64, + retry_count: l36 as u64, } }; - result28.push(e28); + result37.push(e37); } _rt::cabi_dealloc( - base28, - len28 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base37, + len37 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - result28 + result37 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result29 + result38 } } } @@ -1646,11 +1744,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 40 + 6 * ::core::mem::size_of::<*const u8>()], + >; 40 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 40 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let ptr0 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] @@ -1748,18 +1846,62 @@ pub mod golem { len21 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l22 = i32::from( + let l22 = *ptr0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l23 = *ptr0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base30 = l22; + let len30 = l23; + let mut result30 = _rt::Vec::with_capacity(len30); + for i in 0..len30 { + let base = base30 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e30 = { + let l24 = *base.add(0).cast::<*mut u8>(); + let l25 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) + }; + result30.push(e30); + } + _rt::cabi_dealloc( + base30, + len30 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l31 = i32::from( *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l23 = *ptr0 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l32 = *ptr0 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l24 = *ptr0 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l33 = *ptr0 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let result25 = WorkerMetadata { + let result34 = WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::golem::rpc::types::Uuid { @@ -1771,11 +1913,12 @@ pub mod golem { }, args: result12, env: result21, - status: WorkerStatus::_lift(l22 as u8), - component_version: l23 as u64, - retry_count: l24 as u64, + wasi_config_vars: result30, + status: WorkerStatus::_lift(l31 as u8), + component_version: l32 as u64, + retry_count: l33 as u64, }; - result25 + result34 } } #[allow(unused_unsafe, clippy::all)] @@ -1786,11 +1929,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let super::super::super::golem::rpc::types::WorkerId { component_id: component_id0, @@ -1833,7 +1976,7 @@ pub mod golem { ) }; let l6 = i32::from(*ptr4.add(0).cast::()); - let result30 = match l6 { + let result39 = match l6 { 0 => None, 1 => { let e = { @@ -1925,16 +2068,60 @@ pub mod golem { len26 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l27 = i32::from( + let l27 = *ptr4 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *ptr4 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base35 = l27; + let len35 = l28; + let mut result35 = _rt::Vec::with_capacity(len35); + for i in 0..len35 { + let base = base35 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e35 = { + let l29 = *base.add(0).cast::<*mut u8>(); + let l30 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len31 = l30; + let bytes31 = _rt::Vec::from_raw_parts( + l29.cast(), + len31, + len31, + ); + let l32 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l33 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len34 = l33; + let bytes34 = _rt::Vec::from_raw_parts( + l32.cast(), + len34, + len34, + ); + (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) + }; + result35.push(e35); + } + _rt::cabi_dealloc( + base35, + len35 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l36 = i32::from( *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l28 = *ptr4 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l37 = *ptr4 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *ptr4 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + let l38 = *ptr4 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -1948,16 +2135,17 @@ pub mod golem { }, args: result17, env: result26, - status: WorkerStatus::_lift(l27 as u8), - component_version: l28 as u64, - retry_count: l29 as u64, + wasi_config_vars: result35, + status: WorkerStatus::_lift(l36 as u8), + component_version: l37 as u64, + retry_count: l38 as u64, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result30 + result39 } } #[allow(unused_unsafe, clippy::all)] @@ -2549,6 +2737,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -2558,6 +2747,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -5785,26 +5975,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -5822,83 +6016,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -5916,245 +6131,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6163,7 +6378,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6172,43 +6387,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -6216,89 +6431,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -6309,13 +6524,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -6327,156 +6542,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -6717,26 +6932,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -6754,83 +6973,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -6848,245 +7088,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7095,7 +7335,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7104,106 +7344,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -7211,158 +7456,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -7370,7 +7615,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -7387,66 +7632,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, + ); + _rt::string_lift(bytes37) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes41) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -8298,8 +8565,8 @@ pub(crate) use __export_component_resolve_impl as export; )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5434] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xb2)\x01A\x02\x01A\x14\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5590] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xce*\x01A\x02\x01A\x15\ \x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[\ method]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollab\ le.block\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\ @@ -8324,93 +8591,96 @@ pe\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0cprim-s8 -type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0dprim\ -f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\0\x10\ prim-string-type\0\0\x0bhandle-type\x01\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01\ -ks\x01r\x02\x04name\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\ -\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05values\x04\0\x03u\ -ri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0cre\ -cord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\x0bflags-value\ -\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coption-value\x01\x12\ -\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\ -\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08p\ -rim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\ -\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\ -\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03\ -typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01s\0\x06deni\ -ed\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09rpc-error\ -\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\x04\0\x12\ -cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15[construc\ -tor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm-rpc.ephe\ -meral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffun\ -ction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\ -\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wasm-rpc.inv\ -oke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0<\x04\0'\ -[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0escheduled-time\ -\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rpc.schedule\ --invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\ -\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-invocation\x01\ -@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-invoke-resu\ -lt.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[method]future-i\ -nvoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![method]cancellat\ -ion-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\0\x0aparse\ --uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\x03vnt-\ -\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-type\x01\ -L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\0\x03\ -\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x09worker-id\x01B{\x02\x03\x02\ -\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\ -\0\x02\x02\x03\x02\x01\x08\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x09\ -worker-id\x03\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x09worker-id\x07\ -\x09oplog-idx\x09\x04\0\x0apromise-id\x03\0\x0a\x01w\x04\0\x11component-version\x03\ -\0\x0c\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x0e\x01r\x01\x04uuid\x05\x04\ -\0\x0aproject-id\x03\0\x10\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x01\x09m\ -ax-delay\x01\x0amultiplieru\x11max-jitter-factor\x12\x04\0\x0cretry-policy\x03\0\ -\x13\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\ -\0\0\x04\0\x11persistence-level\x03\0\x15\x01m\x02\x09automatic\x0esnapshot-base\ -d\x04\0\x0bupdate-mode\x03\0\x17\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\ -\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x19\x01m\x04\x05\ -equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1b\ -\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06\ -exited\x04\0\x0dworker-status\x03\0\x1d\x01r\x02\x0acomparator\x1c\x05values\x04\ -\0\x12worker-name-filter\x03\0\x1f\x01r\x02\x0acomparator\x1a\x05value\x1e\x04\0\ -\x14worker-status-filter\x03\0!\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x15wo\ -rker-version-filter\x03\0#\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x18worker-\ -created-at-filter\x03\0%\x01r\x03\x04names\x0acomparator\x1c\x05values\x04\0\x11\ -worker-env-filter\x03\0'\x01q\x05\x04name\x01\x20\0\x06status\x01\"\0\x07version\ -\x01$\0\x0acreated-at\x01&\0\x03env\x01(\0\x04\0\x16worker-property-filter\x03\0\ -)\x01p*\x01r\x01\x07filters+\x04\0\x11worker-all-filter\x03\0,\x01p-\x01r\x01\x07\ -filters.\x04\0\x11worker-any-filter\x03\0/\x01ps\x01o\x02ss\x01p2\x01r\x06\x09wo\ -rker-id\x07\x04args1\x03env3\x06status\x1e\x11component-versionw\x0bretry-countw\ -\x04\0\x0fworker-metadata\x03\04\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert\ --to-oplog-index\x01\x09\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-work\ -er-target\x03\07\x01m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\09\x01k\ -0\x01i6\x01@\x03\x0ccomponent-id\x03\x06filter;\x07precise\x7f\0<\x04\0\x18[cons\ -tructor]get-workers\x01=\x01h6\x01p5\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[m\ -ethod]get-workers.get-next\x01A\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01B\x01p}\x01\ -@\x01\x0apromise-id\x0b\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\x0a\ -promise-id\x0b\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x0b\x04\ -data\xc3\0\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x0b\x01\0\ -\x04\0\x0edelete-promise\x01H\x01@\0\0\x09\x04\0\x0fget-oplog-index\x01I\x01@\x01\ -\x09oplog-idx\x09\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\ -\x04\0\x0coplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\ -\x09\x01\0\x04\0\x12mark-end-operation\x01L\x01@\0\0\x14\x04\0\x10get-retry-poli\ -cy\x01M\x01@\x01\x10new-retry-policy\x14\x01\0\x04\0\x10set-retry-policy\x01N\x01\ -@\0\0\x16\x04\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-\ -level\x16\x01\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14\ -get-idempotence-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempote\ -nce-mode\x01R\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09wo\ -rker-id\x07\x0etarget-version\x0d\x04mode\x18\x01\0\x04\0\x0dupdate-worker\x01T\x01\ -@\0\05\x04\0\x11get-self-metadata\x01U\x01k5\x01@\x01\x09worker-id\x07\0\xd6\0\x04\ -\0\x13get-worker-metadata\x01W\x01@\x03\x10source-worker-id\x07\x10target-worker\ --id\x07\x11oplog-idx-cut-off\x09\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09wor\ -ker-id\x07\x0drevert-target8\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x03\x01@\x01\ -\x13component-references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x07\x01\ -@\x02\x13component-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\ -\x01]\x04\0\x18resolve-worker-id-strict\x01]\x01@\x01\x08new-names\0:\x04\0\x04f\ -ork\x01^\x03\0\x14golem:api/host@1.1.7\x05\x0a\x02\x03\0\x04\x09worker-id\x02\x03\ -\0\x04\x0ccomponent-id\x01B\x09\x02\x03\x02\x01\x0b\x04\0\x09worker-id\x03\0\0\x02\ -\x03\x02\x01\x0c\x04\0\x0ccomponent-id\x03\0\x02\x01k\x03\x01k\x01\x01o\x03\x04\x05\ -\x05\x01@\0\0\x06\x04\0\x03run\x01\x07\x04\0\x1egolem:it/component-resolve-api\x05\ -\x0d\x04\0\x1agolem:it/component-resolve\x04\0\x0b\x17\x01\0\x11component-resolv\ -e\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10\ -wit-bindgen-rust\x060.41.0"; +ks\x01r\x03\x04name\x1b\x05owner\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\ +\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05va\ +lues\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\ +\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\ +\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coptio\ +n-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08\ +prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-\ +s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09p\ +rim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\ +\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\ +\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01\ +s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09\ +rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\ +\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15\ +[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm\ +-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-nam\ +es\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01\ +/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wa\ +sm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\ +\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0esche\ +duled-time\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rp\ +c.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunc\ +tion-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-inv\ +ocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-\ +invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[meth\ +od]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![metho\ +d]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\ +\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\ +\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-\ +type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\ +\0\x03\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x0evalue-and-type\x02\ +\x03\0\x03\x09worker-id\x01B\x7f\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\ +\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\x03\x02\x01\x08\x04\0\x04uu\ +id\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x0evalue-and-type\x03\0\x06\x02\x03\x02\x01\ +\x0a\x04\0\x09worker-id\x03\0\x08\x01w\x04\0\x0boplog-index\x03\0\x0a\x01r\x02\x09\ +worker-id\x09\x09oplog-idx\x0b\x04\0\x0apromise-id\x03\0\x0c\x01w\x04\0\x11compo\ +nent-version\x03\0\x0e\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x10\x01r\x01\ +\x04uuid\x05\x04\0\x0aproject-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09mi\ +n-delay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cre\ +try-policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effe\ +cts\0\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0e\ +snapshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0d\ +greater-equal\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\ +\x01m\x04\x05equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-compa\ +rator\x03\0\x1d\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retry\ +ing\x06failed\x06exited\x04\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\ +\x05values\x04\0\x12worker-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05valu\ +e\x20\x04\0\x14worker-status-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\ +\0\x15worker-version-filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18\ +worker-created-at-filter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x11worker-env-filter\x03\0)\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x1eworker-wasi-config-vars-filter\x03\0+\x01q\x06\x04name\x01\"\0\x06status\x01\ +$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\0\x10wasi-config-vars\x01\ +,\0\x04\0\x16worker-property-filter\x03\0-\x01p.\x01r\x01\x07filters/\x04\0\x11w\ +orker-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x11worker-any-filter\x03\ +\03\x01ps\x01o\x02ss\x01p6\x01r\x07\x09worker-id\x09\x04args5\x03env7\x10wasi-co\ +nfig-vars7\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\ +etadata\x03\08\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\ +\x0b\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0;\x01\ +m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\0=\x01k4\x01i:\x01@\x03\x0c\ +component-id\x03\x06filter?\x07precise\x7f\0\xc0\0\x04\0\x18[constructor]get-wor\ +kers\x01A\x01h:\x01p9\x01k\xc3\0\x01@\x01\x04self\xc2\0\0\xc4\0\x04\0\x1c[method\ +]get-workers.get-next\x01E\x01@\0\0\x0d\x04\0\x0ecreate-promise\x01F\x01p}\x01@\x01\ +\x0apromise-id\x0d\0\xc7\0\x04\0\x0dawait-promise\x01H\x01k\xc7\0\x01@\x01\x0apr\ +omise-id\x0d\0\xc9\0\x04\0\x0cpoll-promise\x01J\x01@\x02\x0apromise-id\x0d\x04da\ +ta\xc7\0\0\x7f\x04\0\x10complete-promise\x01K\x01@\x01\x0apromise-id\x0d\x01\0\x04\ +\0\x0edelete-promise\x01L\x01@\0\0\x0b\x04\0\x0fget-oplog-index\x01M\x01@\x01\x09\ +oplog-idx\x0b\x01\0\x04\0\x0fset-oplog-index\x01N\x01@\x01\x08replicas}\x01\0\x04\ +\0\x0coplog-commit\x01O\x04\0\x14mark-begin-operation\x01M\x01@\x01\x05begin\x0b\ +\x01\0\x04\0\x12mark-end-operation\x01P\x01@\0\0\x16\x04\0\x10get-retry-policy\x01\ +Q\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01R\x01@\0\0\ +\x18\x04\0\x1bget-oplog-persistence-level\x01S\x01@\x01\x15new-persistence-level\ +\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01T\x01@\0\0\x7f\x04\0\x14get-i\ +dempotence-mode\x01U\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-m\ +ode\x01V\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01W\x01@\x03\x09worker-\ +id\x09\x0etarget-version\x0f\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01X\x01@\0\ +\09\x04\0\x11get-self-metadata\x01Y\x01k9\x01@\x01\x09worker-id\x09\0\xda\0\x04\0\ +\x13get-worker-metadata\x01[\x01@\x03\x10source-worker-id\x09\x10target-worker-i\ +d\x09\x11oplog-idx-cut-off\x0b\x01\0\x04\0\x0bfork-worker\x01\\\x01@\x02\x09work\ +er-id\x09\x0drevert-target<\x01\0\x04\0\x0drevert-worker\x01]\x01k\x03\x01@\x01\x13\ +component-references\0\xde\0\x04\0\x14resolve-component-id\x01_\x01k\x09\x01@\x02\ +\x13component-references\x0bworker-names\0\xe0\0\x04\0\x11resolve-worker-id\x01a\ +\x04\0\x18resolve-worker-id-strict\x01a\x01@\x01\x08new-names\0>\x04\0\x04fork\x01\ +b\x03\0\x14golem:api/host@1.1.7\x05\x0b\x02\x03\0\x04\x09worker-id\x02\x03\0\x04\ +\x0ccomponent-id\x01B\x09\x02\x03\x02\x01\x0c\x04\0\x09worker-id\x03\0\0\x02\x03\ +\x02\x01\x0d\x04\0\x0ccomponent-id\x03\0\x02\x01k\x03\x01k\x01\x01o\x03\x04\x05\x05\ +\x01@\0\0\x06\x04\0\x03run\x01\x07\x04\0\x1egolem:it/component-resolve-api\x05\x0e\ +\x04\0\x1agolem:it/component-resolve\x04\0\x0b\x17\x01\0\x11component-resolve\x03\ +\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-\ +bindgen-rust\x060.41.0"; #[inline(never)] #[doc(hidden)] pub fn __link_custom_section_describing_imports() { diff --git a/test-components/component-resolve/wit/deps.lock b/test-components/component-resolve/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/component-resolve/wit/deps.lock +++ b/test-components/component-resolve/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/component-resolve/wit/deps.toml b/test-components/component-resolve/wit/deps.toml index 5dacfebe4b..6c10af03a6 100644 --- a/test-components/component-resolve/wit/deps.toml +++ b/test-components/component-resolve/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" diff --git a/test-components/component-resolve/wit/deps/golem-1.x/golem-host.wit b/test-components/component-resolve/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/component-resolve/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/component-resolve/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/component-resolve/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/component-resolve/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/component-resolve/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/component-resolve/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/component-transformer-example1/adapter/wit/deps.toml b/test-components/component-transformer-example1/adapter/wit/deps.toml index 5dacfebe4b..6c10af03a6 100644 --- a/test-components/component-transformer-example1/adapter/wit/deps.toml +++ b/test-components/component-transformer-example1/adapter/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" diff --git a/test-components/counter-ts.wasm b/test-components/counter-ts.wasm index 38af21b5aa..bd5126e9b3 100644 Binary files a/test-components/counter-ts.wasm and b/test-components/counter-ts.wasm differ diff --git a/test-components/counters.wasm b/test-components/counters.wasm index 06484d6df9..68046b0a49 100755 Binary files a/test-components/counters.wasm and b/test-components/counters.wasm differ diff --git a/test-components/custom-durability/Cargo.lock b/test-components/custom-durability/Cargo.lock index cf5b5660aa..ba6f54f5b2 100644 --- a/test-components/custom-durability/Cargo.lock +++ b/test-components/custom-durability/Cargo.lock @@ -355,7 +355,7 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" version = "0.0.0" -source = "git+https://github.com/golemcloud/golem?branch=type-names#6682aca89656b91f3e538729332b399f87249d26" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#b65adf9d20167fd33c71503e015a0b478a1234cb" dependencies = [ "cargo_metadata", "chrono", diff --git a/test-components/custom-durability/components-rust/golem-it/src/lib.rs b/test-components/custom-durability/components-rust/golem-it/src/lib.rs index 88245affdf..b1c3dc9912 100644 --- a/test-components/custom-durability/components-rust/golem-it/src/lib.rs +++ b/test-components/custom-durability/components-rust/golem-it/src/lib.rs @@ -25,7 +25,14 @@ impl IntoValue for StructuredInput { } fn add_to_type_builder(builder: T) -> T::Result { - builder.record(Some("StructuredInput".to_string())).field("payload").string().finish() + builder + .record( + Some("StructuredInput".to_string()), + Some("golem:it/golem-it-api".to_string()), + ) + .field("payload") + .string() + .finish() } } @@ -55,7 +62,14 @@ impl IntoValue for StructuredResult { } fn add_to_type_builder(builder: T) -> T::Result { - builder.record(Some("StructuredResult".to_string())).field("result").string().finish() + builder + .record( + Some("StructuredResult".to_string()), + Some("golem:it/golem-it-api".to_string()), + ) + .field("result") + .string() + .finish() } } @@ -89,7 +103,13 @@ impl IntoValue for UnusedError { } fn add_to_type_builder(builder: T) -> T::Result { - builder.variant(Some("UnusedError".to_string())).unit_case("unused-error").finish() + builder + .variant( + Some("UnusedError".to_string()), + Some("golem:it/golem-it-api".to_string()), + ) + .unit_case("unused-error") + .finish() } } diff --git a/test-components/custom-durability/wit/deps.lock b/test-components/custom-durability/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/custom-durability/wit/deps.lock +++ b/test-components/custom-durability/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/custom-durability/wit/deps.toml b/test-components/custom-durability/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/custom-durability/wit/deps.toml +++ b/test-components/custom-durability/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/custom-durability/wit/deps/golem-1.x/golem-host.wit b/test-components/custom-durability/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/custom-durability/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/custom-durability/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/custom-durability/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/custom-durability/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/custom-durability/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/custom-durability/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/custom_durability.wasm b/test-components/custom_durability.wasm index 03175c4046..7537b7e538 100644 Binary files a/test-components/custom_durability.wasm and b/test-components/custom_durability.wasm differ diff --git a/test-components/directories.wasm b/test-components/directories.wasm index 53c71b1226..f21bde046f 100755 Binary files a/test-components/directories.wasm and b/test-components/directories.wasm differ diff --git a/test-components/durability-overhead.wasm b/test-components/durability-overhead.wasm index 6fa8f759d3..27448e2ee4 100644 Binary files a/test-components/durability-overhead.wasm and b/test-components/durability-overhead.wasm differ diff --git a/test-components/durability-overhead/Cargo.lock b/test-components/durability-overhead/Cargo.lock index bd5cbae5ec..7d5e83cf6b 100644 --- a/test-components/durability-overhead/Cargo.lock +++ b/test-components/durability-overhead/Cargo.lock @@ -3,13 +3,10 @@ version = 4 [[package]] -name = "aho-corasick" -version = "1.1.3" +name = "adler2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" -dependencies = [ - "memchr", -] +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" [[package]] name = "android-tzdata" @@ -28,39 +25,45 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.97" +version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f" +checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100" [[package]] -name = "autocfg" -version = "1.4.0" +name = "auditable-serde" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" +checksum = "5c7bf8143dfc3c0258df908843e169b5cc5fcf76c7718bd66135ef4a9cd558c5" +dependencies = [ + "semver", + "serde", + "serde_json", + "topological-sort", +] [[package]] -name = "bitflags" -version = "2.6.0" +name = "autocfg" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] -name = "bumpalo" -version = "3.17.0" +name = "bitflags" +version = "2.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" [[package]] -name = "bytes" -version = "1.10.1" +name = "bumpalo" +version = "3.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" [[package]] name = "camino" -version = "1.1.9" +version = "1.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3" +checksum = "5d07aa9a93b00c76f71bc35d598bed923f6d4f3a9ca5c24b7737ae1a292841c0" dependencies = [ "serde", ] @@ -90,24 +93,24 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.17" +version = "1.2.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fcb57c740ae1daf453ae85f16e37396f672b039e00d9d866e07ddb24e328e3a" +checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e" dependencies = [ "shlex", ] [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" [[package]] name = "chrono" -version = "0.4.40" +version = "0.4.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c" +checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d" dependencies = [ "android-tzdata", "iana-time-zone", @@ -124,6 +127,26 @@ version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "durability-overhead" version = "0.0.1" @@ -132,12 +155,6 @@ dependencies = [ "wit-bindgen-rt 0.40.0", ] -[[package]] -name = "either" -version = "1.15.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" - [[package]] name = "equivalent" version = "1.0.2" @@ -145,32 +162,124 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] -name = "errno" -version = "0.3.10" +name = "flate2" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d" +checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" dependencies = [ - "libc", - "windows-sys 0.59.0", + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", ] [[package]] -name = "fastrand" -version = "2.3.0" +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] [[package]] -name = "fixedbitset" -version = "0.5.7" +name = "futures-sink" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] [[package]] name = "getrandom" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", @@ -200,23 +309,21 @@ dependencies = [ [[package]] name = "golem-rust" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c988a314d2b3a6f1ccf8cf26f24253837a62e257f61f57ad33d30f83c17a2f2d" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "golem-rust-macro", "golem-wasm-rpc", "serde", "serde_json", "uuid", - "wit-bindgen-rt 0.40.0", + "wit-bindgen", ] [[package]] name = "golem-rust-macro" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bdaa58a3dfea9eec292d4e0529358be7fd4240cdc459dc7b5bf203727559edc" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "heck", "proc-macro2", @@ -226,23 +333,24 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f4d8e4c5ddec0a7f5dbbb4feeaec3bfb2ab2c6cdbdb60c21d5d5f02a8fa68e4" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#b65adf9d20167fd33c71503e015a0b478a1234cb" dependencies = [ "cargo_metadata", "chrono", "git-version", - "prost-build", "uuid", "wit-bindgen-rt 0.40.0", ] [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] [[package]] name = "heck" @@ -252,9 +360,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" [[package]] name = "iana-time-zone" -version = "0.1.62" +version = "0.1.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2fd658b06e56721792c5df4475705b6cda790e9298d19d2f8af083457bcd127" +checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -275,29 +383,134 @@ dependencies = [ ] [[package]] -name = "indexmap" -version = "2.8.0" +name = "icu_collections" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" dependencies = [ - "equivalent", - "hashbrown", + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", ] [[package]] -name = "itertools" -version = "0.14.0" +name = "icu_locale_core" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" dependencies = [ - "either", + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005" + +[[package]] +name = "idna" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" +dependencies = [ + "equivalent", + "hashbrown", + "serde", ] [[package]] name = "itoa" -version = "1.0.11" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" [[package]] name = "js-sys" @@ -309,17 +522,23 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" -version = "0.2.155" +version = "0.2.175" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" [[package]] -name = "linux-raw-sys" -version = "0.4.15" +name = "litemap" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "log" @@ -329,15 +548,18 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" [[package]] name = "memchr" -version = "2.7.4" +version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" [[package]] -name = "multimap" -version = "0.10.0" +name = "miniz_oxide" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", +] [[package]] name = "num-traits" @@ -355,84 +577,49 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" [[package]] -name = "petgraph" -version = "0.7.1" +name = "percent-encoding" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772" -dependencies = [ - "fixedbitset", - "indexmap", -] +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" [[package]] -name = "prettyplease" -version = "0.2.31" +name = "pin-project-lite" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5316f57387668042f561aae71480de936257848f9c43ce528e311d89a07cadeb" -dependencies = [ - "proc-macro2", - "syn", -] - -[[package]] -name = "proc-macro2" -version = "1.0.94" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84" -dependencies = [ - "unicode-ident", -] +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" [[package]] -name = "prost" -version = "0.13.5" +name = "pin-utils" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" -dependencies = [ - "bytes", - "prost-derive", -] +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" [[package]] -name = "prost-build" -version = "0.13.5" +name = "potential_utf" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf" +checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" dependencies = [ - "heck", - "itertools", - "log", - "multimap", - "once_cell", - "petgraph", - "prettyplease", - "prost", - "prost-types", - "regex", - "syn", - "tempfile", + "zerovec", ] [[package]] -name = "prost-derive" -version = "0.13.5" +name = "prettyplease" +version = "0.2.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" +checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2" dependencies = [ - "anyhow", - "itertools", "proc-macro2", - "quote", "syn", ] [[package]] -name = "prost-types" -version = "0.13.5" +name = "proc-macro2" +version = "1.0.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" +checksum = "d61789d7719defeb74ea5fe81f2fdfdbd28a803847077cecce2ff14e1472f6f1" dependencies = [ - "prost", + "unicode-ident", ] [[package]] @@ -446,63 +633,21 @@ dependencies = [ [[package]] name = "r-efi" -version = "5.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5" - -[[package]] -name = "regex" -version = "1.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata", - "regex-syntax", -] - -[[package]] -name = "regex-automata" -version = "0.4.9" +version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax", -] - -[[package]] -name = "regex-syntax" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" - -[[package]] -name = "rustix" -version = "0.38.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f" -dependencies = [ - "bitflags", - "errno", - "libc", - "linux-raw-sys", - "windows-sys 0.52.0", -] +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" [[package]] name = "rustversion" -version = "1.0.20" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" -version = "1.0.18" +version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" [[package]] name = "semver" @@ -535,9 +680,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.140" +version = "1.0.142" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" dependencies = [ "itoa", "memchr", @@ -557,11 +702,38 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "slab" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "spdx" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e17e880bafaeb362a7b751ec46bdc5b61445a188f80e0606e68167cd540fa3" +dependencies = [ + "smallvec", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + [[package]] name = "syn" -version = "2.0.100" +version = "2.0.104" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0" +checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40" dependencies = [ "proc-macro2", "quote", @@ -569,53 +741,92 @@ dependencies = [ ] [[package]] -name = "tempfile" -version = "3.12.0" +name = "synstructure" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ - "cfg-if", - "fastrand", - "once_cell", - "rustix", - "windows-sys 0.59.0", + "proc-macro2", + "quote", + "syn", ] [[package]] name = "thiserror" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708" +checksum = "0b0949c3a6c842cbde3f1686d6eea5a010516deb7085f79db747562d4102f41e" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" +checksum = "cc5b44b4ab9c2fdd0e0512e6bece8388e214c0749f5862b114cc5b7a25daf227" dependencies = [ "proc-macro2", "quote", "syn", ] +[[package]] +name = "tinystr" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "topological-sort" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d" + [[package]] name = "unicode-ident" -version = "1.0.12" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" + +[[package]] +name = "unicode-xid" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "url" +version = "2.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" [[package]] name = "uuid" -version = "1.16.0" +version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9" +checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be" dependencies = [ "getrandom", + "js-sys", "serde", "sha1_smol", + "wasm-bindgen", ] [[package]] @@ -686,101 +897,125 @@ dependencies = [ ] [[package]] -name = "windows-core" -version = "0.52.0" +name = "wasm-encoder" +version = "0.227.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" +checksum = "80bb72f02e7fbf07183443b27b0f3d4144abf8c114189f2e088ed95b696a7822" dependencies = [ - "windows-targets", + "leb128fmt", + "wasmparser", ] [[package]] -name = "windows-link" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38" - -[[package]] -name = "windows-sys" -version = "0.52.0" +name = "wasm-metadata" +version = "0.227.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +checksum = "ce1ef0faabbbba6674e97a56bee857ccddf942785a336c8b47b42373c922a91d" dependencies = [ - "windows-targets", + "anyhow", + "auditable-serde", + "flate2", + "indexmap", + "serde", + "serde_derive", + "serde_json", + "spdx", + "url", + "wasm-encoder", + "wasmparser", ] [[package]] -name = "windows-sys" -version = "0.59.0" +name = "wasmparser" +version = "0.227.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +checksum = "0f51cad774fb3c9461ab9bccc9c62dfb7388397b5deda31bf40e8108ccd678b2" dependencies = [ - "windows-targets", + "bitflags", + "hashbrown", + "indexmap", + "semver", ] [[package]] -name = "windows-targets" -version = "0.52.6" +name = "windows-core" +version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", ] [[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.6" +name = "windows-implement" +version = "0.60.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" +checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] [[package]] -name = "windows_i686_gnu" -version = "0.52.6" +name = "windows-interface" +version = "0.59.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" +checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] [[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" +name = "windows-link" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" [[package]] -name = "windows_i686_msvc" -version = "0.52.6" +name = "windows-result" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link", +] [[package]] -name = "windows_x86_64_gnu" -version = "0.52.6" +name = "windows-strings" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link", +] [[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.6" +name = "wit-bindgen" +version = "0.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +checksum = "8e7091ed6c9abfa4e0a2ef3b39d0539da992d841fcf32c255f64fb98764ffee5" +dependencies = [ + "wit-bindgen-rt 0.40.0", + "wit-bindgen-rust-macro", +] [[package]] -name = "windows_x86_64_msvc" -version = "0.52.6" +name = "wit-bindgen-core" +version = "0.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +checksum = "398c650cec1278cfb72e214ba26ef3440ab726e66401bd39c04f465ee3979e6b" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] [[package]] name = "wit-bindgen-rt" @@ -798,4 +1033,158 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68faed92ae696b93ea9a7b67ba6c37bf09d72c6d9a70fa824a743c3020212f11" dependencies = [ "bitflags", + "futures", + "once_cell", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83903c8dcd8084a8a67ae08190122cf0e25dc37bdc239070a00f47e22d3f0aae" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7bf7f20495bcc7dc9f24c5fbcac9e919ca5ebdb7a1b1841d74447d3c8dd0c60" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "635c3adc595422cbf2341a17fb73a319669cc8d33deed3a48368a841df86b676" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddf445ed5157046e4baf56f9138c124a0824d4d1657e7204d71886ad8ce2fc11" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn", ] diff --git a/test-components/durability-overhead/Cargo.toml b/test-components/durability-overhead/Cargo.toml index 37539a60dd..0116ec74e2 100644 --- a/test-components/durability-overhead/Cargo.toml +++ b/test-components/durability-overhead/Cargo.toml @@ -12,7 +12,7 @@ lto = true opt-level = 's' [dependencies] -golem-rust = "1.4.0" +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } wit-bindgen-rt = { version = "0.40.0", features = ["bitflags"] } [package.metadata.component.target] diff --git a/test-components/environment-service.wasm b/test-components/environment-service.wasm index fe174b5663..4b75f33e1b 100755 Binary files a/test-components/environment-service.wasm and b/test-components/environment-service.wasm differ diff --git a/test-components/ephemeral.wasm b/test-components/ephemeral.wasm index 26c6b84c4e..80327600ed 100644 Binary files a/test-components/ephemeral.wasm and b/test-components/ephemeral.wasm differ diff --git a/test-components/file-service.wasm b/test-components/file-service.wasm index ed2cae0670..935cffdd87 100755 Binary files a/test-components/file-service.wasm and b/test-components/file-service.wasm differ diff --git a/test-components/file-service/wit/deps.lock b/test-components/file-service/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/file-service/wit/deps.lock +++ b/test-components/file-service/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/file-service/wit/deps.toml b/test-components/file-service/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/file-service/wit/deps.toml +++ b/test-components/file-service/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/file-service/wit/deps/golem-1.x/golem-host.wit b/test-components/file-service/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/file-service/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/file-service/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/file-service/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/file-service/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/file-service/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/file-service/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/golem-rust-tests.wasm b/test-components/golem-rust-tests.wasm old mode 100755 new mode 100644 index 8c21b82efc..bba45770dd Binary files a/test-components/golem-rust-tests.wasm and b/test-components/golem-rust-tests.wasm differ diff --git a/test-components/golem-rust-tests/Cargo.lock b/test-components/golem-rust-tests/Cargo.lock index 2b0e0cd894..428653a9ef 100644 --- a/test-components/golem-rust-tests/Cargo.lock +++ b/test-components/golem-rust-tests/Cargo.lock @@ -4,9 +4,9 @@ version = 4 [[package]] name = "adler2" -version = "2.0.0" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" [[package]] name = "android-tzdata" @@ -25,9 +25,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.97" +version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f" +checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100" [[package]] name = "auditable-serde" @@ -43,9 +43,9 @@ dependencies = [ [[package]] name = "autocfg" -version = "1.3.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "base64" @@ -55,15 +55,15 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" [[package]] name = "bitflags" -version = "2.6.0" +version = "2.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" [[package]] name = "bumpalo" -version = "3.16.0" +version = "3.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" [[package]] name = "bytes" @@ -73,9 +73,9 @@ checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" [[package]] name = "camino" -version = "1.1.9" +version = "1.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3" +checksum = "5d07aa9a93b00c76f71bc35d598bed923f6d4f3a9ca5c24b7737ae1a292841c0" dependencies = [ "serde", ] @@ -105,24 +105,24 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.17" +version = "1.2.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fcb57c740ae1daf453ae85f16e37396f672b039e00d9d866e07ddb24e328e3a" +checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e" dependencies = [ "shlex", ] [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" [[package]] name = "chrono" -version = "0.4.40" +version = "0.4.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c" +checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d" dependencies = [ "android-tzdata", "iana-time-zone", @@ -135,39 +135,50 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.6" +version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "crc32fast" -version = "1.4.2" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" dependencies = [ "cfg-if", ] +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "encoding_rs" -version = "0.8.34" +version = "0.8.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" dependencies = [ "cfg-if", ] [[package]] name = "equivalent" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "flate2" -version = "1.1.1" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece" +checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" dependencies = [ "crc32fast", "miniz_oxide", @@ -196,9 +207,9 @@ dependencies = [ [[package]] name = "futures" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" dependencies = [ "futures-channel", "futures-core", @@ -211,9 +222,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" dependencies = [ "futures-core", "futures-sink", @@ -221,15 +232,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" [[package]] name = "futures-executor" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" dependencies = [ "futures-core", "futures-task", @@ -244,9 +255,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" [[package]] name = "futures-macro" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" dependencies = [ "proc-macro2", "quote", @@ -255,21 +266,21 @@ dependencies = [ [[package]] name = "futures-sink" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" [[package]] name = "futures-task" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" [[package]] name = "futures-util" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" dependencies = [ "futures-channel", "futures-core", @@ -285,9 +296,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", @@ -318,6 +329,7 @@ dependencies = [ [[package]] name = "golem-rust" version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#3f188145088e43cababe90f9ffbf0d3cba6d5669" dependencies = [ "golem-rust-macro", "golem-wasm-rpc", @@ -330,6 +342,7 @@ dependencies = [ [[package]] name = "golem-rust-macro" version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#3f188145088e43cababe90f9ffbf0d3cba6d5669" dependencies = [ "heck", "proc-macro2", @@ -350,9 +363,8 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" -version = "1.2.2-dev.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb78923b9960cb060fd3a5565ec4fffef2805f51220e9341dfc96d99f5f60b19" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#783f103dd9a45fbbf43d2c5eb1ed6ef8dfa62ef3" dependencies = [ "cargo_metadata", "chrono", @@ -363,9 +375,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" dependencies = [ "foldhash", ] @@ -389,9 +401,9 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.62" +version = "0.1.63" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2fd658b06e56721792c5df4475705b6cda790e9298d19d2f8af083457bcd127" +checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -411,6 +423,92 @@ dependencies = [ "cc", ] +[[package]] +name = "icu_collections" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + [[package]] name = "id-arena" version = "2.2.1" @@ -419,19 +517,30 @@ checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005" [[package]] name = "idna" -version = "0.5.0" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" dependencies = [ - "unicode-bidi", - "unicode-normalization", + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", ] [[package]] name = "indexmap" -version = "2.8.0" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3954d50fe15b02142bf25d3b8bdadb634ec3948f103d04ffe3031bc8fe9d7058" +checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" dependencies = [ "equivalent", "hashbrown", @@ -440,9 +549,9 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.11" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" [[package]] name = "js-sys" @@ -462,21 +571,27 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" [[package]] name = "libc" -version = "0.2.155" +version = "0.2.175" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" + +[[package]] +name = "litemap" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "log" -version = "0.4.22" +version = "0.4.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" +checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" [[package]] name = "memchr" -version = "2.7.4" +version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" [[package]] name = "mime" @@ -486,9 +601,9 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" [[package]] name = "miniz_oxide" -version = "0.8.8" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" dependencies = [ "adler2", ] @@ -504,9 +619,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.19.0" +version = "1.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" [[package]] name = "percent-encoding" @@ -516,9 +631,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" [[package]] name = "pin-project-lite" -version = "0.2.14" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" [[package]] name = "pin-utils" @@ -526,11 +641,20 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "potential_utf" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" +dependencies = [ + "zerovec", +] + [[package]] name = "prettyplease" -version = "0.2.31" +version = "0.2.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5316f57387668042f561aae71480de936257848f9c43ce528e311d89a07cadeb" +checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2" dependencies = [ "proc-macro2", "syn", @@ -538,9 +662,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.94" +version = "1.0.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84" +checksum = "d61789d7719defeb74ea5fe81f2fdfdbd28a803847077cecce2ff14e1472f6f1" dependencies = [ "unicode-ident", ] @@ -556,9 +680,9 @@ dependencies = [ [[package]] name = "r-efi" -version = "5.2.0" +version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" [[package]] name = "reqwest" @@ -584,15 +708,15 @@ dependencies = [ [[package]] name = "rustversion" -version = "1.0.20" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" -version = "1.0.18" +version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" [[package]] name = "semver" @@ -625,9 +749,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.140" +version = "1.0.142" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" dependencies = [ "itoa", "memchr", @@ -661,33 +785,36 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "slab" -version = "0.4.9" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" [[package]] name = "smallvec" -version = "1.14.0" +version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" [[package]] name = "spdx" -version = "0.10.8" +version = "0.10.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58b69356da67e2fc1f542c71ea7e654a361a79c938e4424392ecf4fa065d2193" +checksum = "c3e17e880bafaeb362a7b751ec46bdc5b61445a188f80e0606e68167cd540fa3" dependencies = [ "smallvec", ] +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + [[package]] name = "syn" -version = "2.0.100" +version = "2.0.105" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0" +checksum = "7bc3fcb250e53458e712715cf74285c1f889686520d79294a9ef3bd7aa1fc619" dependencies = [ "proc-macro2", "quote", @@ -703,20 +830,31 @@ dependencies = [ "futures-core", ] +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "thiserror" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708" +checksum = "0b0949c3a6c842cbde3f1686d6eea5a010516deb7085f79db747562d4102f41e" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" +checksum = "cc5b44b4ab9c2fdd0e0512e6bece8388e214c0749f5862b114cc5b7a25daf227" dependencies = [ "proc-macro2", "quote", @@ -724,20 +862,15 @@ dependencies = [ ] [[package]] -name = "tinyvec" -version = "1.8.0" +name = "tinystr" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" dependencies = [ - "tinyvec_macros", + "displaydoc", + "zerovec", ] -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - [[package]] name = "topological-sort" version = "0.2.2" @@ -750,26 +883,11 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" -[[package]] -name = "unicode-bidi" -version = "0.3.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" - [[package]] name = "unicode-ident" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" - -[[package]] -name = "unicode-normalization" -version = "0.1.23" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" -dependencies = [ - "tinyvec", -] +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" [[package]] name = "unicode-xid" @@ -779,24 +897,32 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" [[package]] name = "url" -version = "2.5.2" +version = "2.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c" +checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" dependencies = [ "form_urlencoded", "idna", "percent-encoding", ] +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + [[package]] name = "uuid" -version = "1.16.0" +version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9" +checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be" dependencies = [ "getrandom", + "js-sys", "serde", "sha1_smol", + "wasm-bindgen", ] [[package]] @@ -909,82 +1035,62 @@ dependencies = [ [[package]] name = "windows-core" -version = "0.52.0" +version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" dependencies = [ - "windows-targets", + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", ] [[package]] -name = "windows-link" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38" - -[[package]] -name = "windows-targets" -version = "0.52.6" +name = "windows-implement" +version = "0.60.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", + "proc-macro2", + "quote", + "syn", ] [[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.6" +name = "windows-interface" +version = "0.59.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] [[package]] -name = "windows_x86_64_gnu" -version = "0.52.6" +name = "windows-link" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" [[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.6" +name = "windows-result" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link", +] [[package]] -name = "windows_x86_64_msvc" -version = "0.52.6" +name = "windows-strings" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link", +] [[package]] name = "wit-bindgen" @@ -1103,3 +1209,87 @@ dependencies = [ "unicode-xid", "wasmparser", ] + +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/test-components/golem-rust-tests/Cargo.toml b/test-components/golem-rust-tests/Cargo.toml index 9c0b602f27..00efc89d33 100644 --- a/test-components/golem-rust-tests/Cargo.toml +++ b/test-components/golem-rust-tests/Cargo.toml @@ -13,8 +13,8 @@ opt-level = 's' strip = true [dependencies] -golem-rust = { version = "1.4.0" } -golem-rust-macro = { version = "1.4.0" } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } +golem-rust-macro = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-april-2025", features = ["json"] } serde_json = "1.0.140" wit-bindgen-rt = { version = "0.40.0", features = ["bitflags"] } diff --git a/test-components/golem_it_ifs_update.wasm b/test-components/golem_it_ifs_update.wasm index d60903e2dc..b6b1725736 100644 Binary files a/test-components/golem_it_ifs_update.wasm and b/test-components/golem_it_ifs_update.wasm differ diff --git a/test-components/high-volume-logging/Cargo.toml b/test-components/high-volume-logging/Cargo.toml index 2e964c2b14..5c9c7c4dfd 100644 --- a/test-components/high-volume-logging/Cargo.toml +++ b/test-components/high-volume-logging/Cargo.toml @@ -7,7 +7,7 @@ opt-level = "s" lto = true [workspace.dependencies] -golem-rust = { version = "1.6.0", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-may-2025", features = ["json"] } serde = { version = "1", features = ["derive"] } serde_json = "1" diff --git a/test-components/http-client-2.wasm b/test-components/http-client-2.wasm index ef3394a8c8..600acdc420 100755 Binary files a/test-components/http-client-2.wasm and b/test-components/http-client-2.wasm differ diff --git a/test-components/http-client-3.wasm b/test-components/http-client-3.wasm index b19e5444c7..b583fe8622 100644 Binary files a/test-components/http-client-3.wasm and b/test-components/http-client-3.wasm differ diff --git a/test-components/http-client.wasm b/test-components/http-client.wasm index cdade5c85b..5480b5c2ab 100755 Binary files a/test-components/http-client.wasm and b/test-components/http-client.wasm differ diff --git a/test-components/http-client/wit/deps.lock b/test-components/http-client/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/http-client/wit/deps.lock +++ b/test-components/http-client/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/http-client/wit/deps.toml b/test-components/http-client/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/http-client/wit/deps.toml +++ b/test-components/http-client/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/http-client/wit/deps/golem-1.x/golem-host.wit b/test-components/http-client/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/http-client/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/http-client/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/http-client/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/http-client/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/http-client/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/http-client/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/ifs-update-inside-exported-function/Cargo.toml b/test-components/ifs-update-inside-exported-function/Cargo.toml index e9d026f4db..653444a45a 100644 --- a/test-components/ifs-update-inside-exported-function/Cargo.toml +++ b/test-components/ifs-update-inside-exported-function/Cargo.toml @@ -7,7 +7,7 @@ opt-level = "s" lto = true [workspace.dependencies] -golem-rust = { version = "1.6.0", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-march-2025", features = ["json"] } serde = { version = "1.0.0", features = ["derive"] } serde_json = "1.0" diff --git a/test-components/ifs-update-inside-exported-function/wit/deps.toml b/test-components/ifs-update-inside-exported-function/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/ifs-update-inside-exported-function/wit/deps.toml +++ b/test-components/ifs-update-inside-exported-function/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/ifs-update/Cargo.toml b/test-components/ifs-update/Cargo.toml index e9d026f4db..653444a45a 100644 --- a/test-components/ifs-update/Cargo.toml +++ b/test-components/ifs-update/Cargo.toml @@ -7,7 +7,7 @@ opt-level = "s" lto = true [workspace.dependencies] -golem-rust = { version = "1.6.0", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-march-2025", features = ["json"] } serde = { version = "1.0.0", features = ["derive"] } serde_json = "1.0" diff --git a/test-components/ifs-update/wit/deps.lock b/test-components/ifs-update/wit/deps.lock index 9a42eadd85..59f7971c63 100644 --- a/test-components/ifs-update/wit/deps.lock +++ b/test-components/ifs-update/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.1.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/type-owner.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "12db5ddfe0b783ca67608e61faf9cf5e11726f127fa313cc79a546397d79ad99" -sha512 = "3b89a3a32eafbe95425f7dac8398830e6b27703dbcc514f902c3129521e55a1dedcdad903a399c5489bd12bd032b26b89679d47855acee697e73d5f0dfbe4db0" +sha256 = "831dbbcffd5061289633f68704593d4d22e8c7a6c95b65493f0d103a8d1eed04" +sha512 = "4830f5095505702aeaeb5838810be9fe2d69929f3b7a2156621e34d350f270ab224d13e007ceab9b9a4f4990593b88c211209f644253767a04eb7f2bd4333fc9" [golem-durability] -sha256 = "35f2238c62623726ce12a9ea2eb0add50294005ff6e2e3db944799e750f5050d" -sha512 = "9c555d7f78aa0889a1d9a07a9c133fd38c85f5b71251603c08d44663669701b6bd8a77b07fab46fe27819163b8ec8a521e3b3291900f27f355088099f36a3e26" +sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" +sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "018014244e691a7db1a0488f2434f8618108af62ffb544e5d0c9be3860732dc5" -sha512 = "dbb12c0952f45e5e9621499a9a636165f428110dcf356bbf245308bd19e58693d81cba990be56df373c3552c0aa239af35aab0d5742cd6908b6d86b63f0bce7a" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/ifs-update/wit/deps.toml b/test-components/ifs-update/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/ifs-update/wit/deps.toml +++ b/test-components/ifs-update/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/ifs-update/wit/deps/golem-1.x/golem-host.wit b/test-components/ifs-update/wit/deps/golem-1.x/golem-host.wit index 2d3e400973..62dcef06eb 100644 --- a/test-components/ifs-update/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/ifs-update/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -24,6 +24,11 @@ interface host { value: string } + /// Represents a Golem project + record project-id { + uuid: uuid, + } + /// Configures how the executor retries failures record retry-policy { /// The maximum number of retries before the worker becomes permanently failed diff --git a/test-components/ifs-update/wit/deps/golem-1.x/golem-oplog.wit b/test-components/ifs-update/wit/deps/golem-1.x/golem-oplog.wit index 81e5cbeba6..fd06f8f001 100644 --- a/test-components/ifs-update/wit/deps/golem-1.x/golem-oplog.wit +++ b/test-components/ifs-update/wit/deps/golem-1.x/golem-oplog.wit @@ -5,7 +5,7 @@ interface oplog { use wasi:clocks/wall-clock@0.2.3.{datetime}; use golem:rpc/types@0.2.2.{wit-value}; - use host.{account-id, component-version, oplog-index, persistence-level, retry-policy, uuid, worker-id}; + use host.{account-id, component-version, oplog-index, persistence-level, project-id, retry-policy, uuid, worker-id}; use context.{attribute, attribute-value, span-id, trace-id}; variant wrapped-function-type { @@ -41,7 +41,8 @@ interface oplog { component-version: component-version, args: list, env: list>, - account-id: account-id, + created-by: account-id, + project-id: project-id, parent: option, component-size: u64, initial-total-linear-memory-size: u64, @@ -89,7 +90,7 @@ interface oplog { record exported-function-completed-parameters { timestamp: datetime, - response: wit-value, + response: option, consumed-fuel: s64 } diff --git a/test-components/ifs-update/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/ifs-update/wit/deps/golem-rpc/wasm-rpc.wit index ddc8ebcbb4..372919b05c 100644 --- a/test-components/ifs-update/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/ifs-update/wit/deps/golem-rpc/wasm-rpc.wit @@ -1,4 +1,4 @@ -package golem:rpc@0.2.1; +package golem:rpc@0.2.2; interface types { use wasi:clocks/wall-clock@0.2.3.{datetime}; @@ -59,7 +59,7 @@ interface types { } record wit-type { - nodes: list, + nodes: list, } type resource-id = u64; @@ -69,6 +69,12 @@ interface types { borrowed } + record named-wit-type-node { + name: option, + owner: option, + %type: wit-type-node + } + variant wit-type-node { record-type(list>), variant-type(list>>), diff --git a/test-components/invocation-context/Cargo.toml b/test-components/invocation-context/Cargo.toml index 58701ee61b..4d4d30ae25 100644 --- a/test-components/invocation-context/Cargo.toml +++ b/test-components/invocation-context/Cargo.toml @@ -7,7 +7,7 @@ opt-level = "s" lto = true [workspace.dependencies] -golem-rust = { version = "1.4.0" } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-march-2025", features = ["json"] } serde = { version = "1.0.0", features = ["derive"] } serde_json = "1.0" diff --git a/test-components/it_scheduled_invocation_client.wasm b/test-components/it_scheduled_invocation_client.wasm index a239868fa8..0caa1d27fc 100644 Binary files a/test-components/it_scheduled_invocation_client.wasm and b/test-components/it_scheduled_invocation_client.wasm differ diff --git a/test-components/it_scheduled_invocation_client_stubless.wasm b/test-components/it_scheduled_invocation_client_stubless.wasm index 8746a3cd41..3292f63e59 100644 Binary files a/test-components/it_scheduled_invocation_client_stubless.wasm and b/test-components/it_scheduled_invocation_client_stubless.wasm differ diff --git a/test-components/it_scheduled_invocation_server.wasm b/test-components/it_scheduled_invocation_server.wasm index b2c58948b8..61202b61a1 100644 Binary files a/test-components/it_scheduled_invocation_server.wasm and b/test-components/it_scheduled_invocation_server.wasm differ diff --git a/test-components/it_scheduled_invocation_server_stubless.wasm b/test-components/it_scheduled_invocation_server_stubless.wasm index ca82ca4951..5827e17ffe 100644 Binary files a/test-components/it_scheduled_invocation_server_stubless.wasm and b/test-components/it_scheduled_invocation_server_stubless.wasm differ diff --git a/test-components/js-1.wasm b/test-components/js-1.wasm index 5df49fef25..cab0b0db1f 100644 Binary files a/test-components/js-1.wasm and b/test-components/js-1.wasm differ diff --git a/test-components/js-1/wit/deps.lock b/test-components/js-1/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/js-1/wit/deps.lock +++ b/test-components/js-1/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/js-1/wit/deps.toml b/test-components/js-1/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/js-1/wit/deps.toml +++ b/test-components/js-1/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/js-1/wit/deps/golem-1.x/golem-host.wit b/test-components/js-1/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/js-1/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/js-1/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/js-1/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/js-1/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/js-1/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/js-1/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/js-2.wasm b/test-components/js-2.wasm index 86c68789fe..6f0a334c85 100644 Binary files a/test-components/js-2.wasm and b/test-components/js-2.wasm differ diff --git a/test-components/js-3.wasm b/test-components/js-3.wasm index 6b6a230db1..ed41e25b5d 100644 Binary files a/test-components/js-3.wasm and b/test-components/js-3.wasm differ diff --git a/test-components/js-4.wasm b/test-components/js-4.wasm index 6ec5fda0fe..acf20f209a 100644 Binary files a/test-components/js-4.wasm and b/test-components/js-4.wasm differ diff --git a/test-components/js-4/wit/deps.lock b/test-components/js-4/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/js-4/wit/deps.lock +++ b/test-components/js-4/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/js-4/wit/deps.toml b/test-components/js-4/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/js-4/wit/deps.toml +++ b/test-components/js-4/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/js-4/wit/deps/golem-1.x/golem-host.wit b/test-components/js-4/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/js-4/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/js-4/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/js-4/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/js-4/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/js-4/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/js-4/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/js-echo.wasm b/test-components/js-echo.wasm index 0e00b179ac..6f42db0d1f 100644 Binary files a/test-components/js-echo.wasm and b/test-components/js-echo.wasm differ diff --git a/test-components/key-value-service.wasm b/test-components/key-value-service.wasm index 8daaa72568..f36e4473d4 100755 Binary files a/test-components/key-value-service.wasm and b/test-components/key-value-service.wasm differ diff --git a/test-components/key-value-service/wit/deps.lock b/test-components/key-value-service/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/key-value-service/wit/deps.lock +++ b/test-components/key-value-service/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/key-value-service/wit/deps.toml b/test-components/key-value-service/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/key-value-service/wit/deps.toml +++ b/test-components/key-value-service/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/key-value-service/wit/deps/golem-1.x/golem-host.wit b/test-components/key-value-service/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/key-value-service/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/key-value-service/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/key-value-service/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/key-value-service/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/key-value-service/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/key-value-service/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/logging.wasm b/test-components/logging.wasm index 84316eb14e..c575f527b6 100644 Binary files a/test-components/logging.wasm and b/test-components/logging.wasm differ diff --git a/test-components/logging/Cargo.lock b/test-components/logging/Cargo.lock index 064661fe57..1db9fd582c 100644 --- a/test-components/logging/Cargo.lock +++ b/test-components/logging/Cargo.lock @@ -18,13 +18,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" [[package]] -name = "aho-corasick" -version = "1.1.3" +name = "adler2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" -dependencies = [ - "memchr", -] +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" [[package]] name = "android-tzdata" @@ -53,6 +50,18 @@ version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" +[[package]] +name = "auditable-serde" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7bf8143dfc3c0258df908843e169b5cc5fcf76c7718bd66135ef4a9cd558c5" +dependencies = [ + "semver", + "serde", + "serde_json", + "topological-sort", +] + [[package]] name = "autocfg" version = "1.3.0" @@ -69,7 +78,7 @@ dependencies = [ "cc", "cfg-if", "libc", - "miniz_oxide", + "miniz_oxide 0.7.4", "object", "rustc-demangle", ] @@ -183,10 +192,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] -name = "either" -version = "1.15.0" +name = "crc32fast" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] [[package]] name = "encoding_rs" @@ -220,10 +232,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a" [[package]] -name = "fixedbitset" -version = "0.5.7" +name = "flate2" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" +checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" +dependencies = [ + "crc32fast", + "miniz_oxide 0.8.9", +] [[package]] name = "fnv" @@ -231,6 +247,12 @@ version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + [[package]] name = "foreign-types" version = "0.3.2" @@ -255,6 +277,21 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "futures" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + [[package]] name = "futures-channel" version = "0.3.30" @@ -262,6 +299,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" dependencies = [ "futures-core", + "futures-sink", ] [[package]] @@ -270,6 +308,34 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" +[[package]] +name = "futures-executor" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "futures-sink" version = "0.3.30" @@ -288,10 +354,16 @@ version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" dependencies = [ + "futures-channel", "futures-core", + "futures-io", + "futures-macro", + "futures-sink", "futures-task", + "memchr", "pin-project-lite", "pin-utils", + "slab", ] [[package]] @@ -345,23 +417,21 @@ dependencies = [ [[package]] name = "golem-rust" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c988a314d2b3a6f1ccf8cf26f24253837a62e257f61f57ad33d30f83c17a2f2d" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "golem-rust-macro", "golem-wasm-rpc", "serde", "serde_json", "uuid", - "wit-bindgen-rt 0.40.0", + "wit-bindgen 0.40.0", ] [[package]] name = "golem-rust-macro" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bdaa58a3dfea9eec292d4e0529358be7fd4240cdc459dc7b5bf203727559edc" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "heck 0.5.0", "proc-macro2", @@ -371,14 +441,12 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f4d8e4c5ddec0a7f5dbbb4feeaec3bfb2ab2c6cdbdb60c21d5d5f02a8fa68e4" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#b65adf9d20167fd33c71503e015a0b478a1234cb" dependencies = [ "cargo_metadata", "chrono", "git-version", - "prost-build", "uuid", "wit-bindgen-rt 0.40.0", ] @@ -407,6 +475,9 @@ name = "hashbrown" version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +dependencies = [ + "foldhash", +] [[package]] name = "heck" @@ -598,15 +669,6 @@ version = "2.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" -[[package]] -name = "itertools" -version = "0.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" -dependencies = [ - "either", -] - [[package]] name = "itoa" version = "1.0.11" @@ -629,6 +691,12 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + [[package]] name = "libc" version = "0.2.155" @@ -683,6 +751,15 @@ dependencies = [ "adler", ] +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", +] + [[package]] name = "mio" version = "1.0.2" @@ -695,12 +772,6 @@ dependencies = [ "windows-sys 0.52.0", ] -[[package]] -name = "multimap" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03" - [[package]] name = "native-tls" version = "0.2.12" @@ -792,16 +863,6 @@ version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" -[[package]] -name = "petgraph" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772" -dependencies = [ - "fixedbitset", - "indexmap", -] - [[package]] name = "pin-project-lite" version = "0.2.14" @@ -848,58 +909,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "prost" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5" -dependencies = [ - "bytes", - "prost-derive", -] - -[[package]] -name = "prost-build" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf" -dependencies = [ - "heck 0.5.0", - "itertools", - "log", - "multimap", - "once_cell", - "petgraph", - "prettyplease", - "prost", - "prost-types", - "regex", - "syn", - "tempfile", -] - -[[package]] -name = "prost-derive" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" -dependencies = [ - "anyhow", - "itertools", - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "prost-types" -version = "0.13.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16" -dependencies = [ - "prost", -] - [[package]] name = "quote" version = "1.0.40" @@ -945,35 +954,6 @@ dependencies = [ "getrandom 0.2.15", ] -[[package]] -name = "regex" -version = "1.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata", - "regex-syntax", -] - -[[package]] -name = "regex-automata" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax", -] - -[[package]] -name = "regex-syntax" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" - [[package]] name = "reqwest" version = "0.12.15" @@ -1376,6 +1356,12 @@ dependencies = [ "tokio", ] +[[package]] +name = "topological-sort" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d" + [[package]] name = "tower" version = "0.5.2" @@ -1526,7 +1512,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "58aa5201b7f5d96ef2e747a1f60a6dbc38bdd1287ce5e046d1498bd7a793f74b" dependencies = [ "log", - "wit-bindgen", + "wit-bindgen 0.24.0", ] [[package]] @@ -1608,6 +1594,16 @@ dependencies = [ "leb128", ] +[[package]] +name = "wasm-encoder" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80bb72f02e7fbf07183443b27b0f3d4144abf8c114189f2e088ed95b696a7822" +dependencies = [ + "leb128fmt", + "wasmparser 0.227.1", +] + [[package]] name = "wasm-metadata" version = "0.202.0" @@ -1620,8 +1616,27 @@ dependencies = [ "serde_derive", "serde_json", "spdx", - "wasm-encoder", - "wasmparser", + "wasm-encoder 0.202.0", + "wasmparser 0.202.0", +] + +[[package]] +name = "wasm-metadata" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce1ef0faabbbba6674e97a56bee857ccddf942785a336c8b47b42373c922a91d" +dependencies = [ + "anyhow", + "auditable-serde", + "flate2", + "indexmap", + "serde", + "serde_derive", + "serde_json", + "spdx", + "url", + "wasm-encoder 0.227.1", + "wasmparser 0.227.1", ] [[package]] @@ -1635,6 +1650,18 @@ dependencies = [ "semver", ] +[[package]] +name = "wasmparser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f51cad774fb3c9461ab9bccc9c62dfb7388397b5deda31bf40e8108ccd678b2" +dependencies = [ + "bitflags", + "hashbrown", + "indexmap", + "semver", +] + [[package]] name = "web-sys" version = "0.3.69" @@ -1842,7 +1869,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9fb4e7653763780be47e38f479e9aa83c768aa6a3b2ed086dc2826fdbbb7e7f5" dependencies = [ "wit-bindgen-rt 0.24.0", - "wit-bindgen-rust-macro", + "wit-bindgen-rust-macro 0.24.0", +] + +[[package]] +name = "wit-bindgen" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e7091ed6c9abfa4e0a2ef3b39d0539da992d841fcf32c255f64fb98764ffee5" +dependencies = [ + "wit-bindgen-rt 0.40.0", + "wit-bindgen-rust-macro 0.40.0", ] [[package]] @@ -1852,7 +1889,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b67e11c950041849a10828c7600ea62a4077c01e8af72e8593253575428f91b" dependencies = [ "anyhow", - "wit-parser", + "wit-parser 0.202.0", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "398c650cec1278cfb72e214ba26ef3440ab726e66401bd39c04f465ee3979e6b" +dependencies = [ + "anyhow", + "heck 0.5.0", + "wit-parser 0.227.1", ] [[package]] @@ -1880,6 +1928,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68faed92ae696b93ea9a7b67ba6c37bf09d72c6d9a70fa824a743c3020212f11" dependencies = [ "bitflags", + "futures", + "once_cell", ] [[package]] @@ -1900,9 +1950,25 @@ dependencies = [ "anyhow", "heck 0.4.1", "indexmap", - "wasm-metadata", - "wit-bindgen-core", - "wit-component", + "wasm-metadata 0.202.0", + "wit-bindgen-core 0.24.0", + "wit-component 0.202.0", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83903c8dcd8084a8a67ae08190122cf0e25dc37bdc239070a00f47e22d3f0aae" +dependencies = [ + "anyhow", + "heck 0.5.0", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata 0.227.1", + "wit-bindgen-core 0.40.0", + "wit-component 0.227.1", ] [[package]] @@ -1915,8 +1981,23 @@ dependencies = [ "proc-macro2", "quote", "syn", - "wit-bindgen-core", - "wit-bindgen-rust", + "wit-bindgen-core 0.24.0", + "wit-bindgen-rust 0.24.0", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7bf7f20495bcc7dc9f24c5fbcac9e919ca5ebdb7a1b1841d74447d3c8dd0c60" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core 0.40.0", + "wit-bindgen-rust 0.40.0", ] [[package]] @@ -1932,10 +2013,29 @@ dependencies = [ "serde", "serde_derive", "serde_json", - "wasm-encoder", - "wasm-metadata", - "wasmparser", - "wit-parser", + "wasm-encoder 0.202.0", + "wasm-metadata 0.202.0", + "wasmparser 0.202.0", + "wit-parser 0.202.0", +] + +[[package]] +name = "wit-component" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "635c3adc595422cbf2341a17fb73a319669cc8d33deed3a48368a841df86b676" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder 0.227.1", + "wasm-metadata 0.227.1", + "wasmparser 0.227.1", + "wit-parser 0.227.1", ] [[package]] @@ -1953,7 +2053,25 @@ dependencies = [ "serde_derive", "serde_json", "unicode-xid", - "wasmparser", + "wasmparser 0.202.0", +] + +[[package]] +name = "wit-parser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddf445ed5157046e4baf56f9138c124a0824d4d1657e7204d71886ad8ce2fc11" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser 0.227.1", ] [[package]] diff --git a/test-components/logging/Cargo.toml b/test-components/logging/Cargo.toml index 8e3394d5b9..902b4e67d2 100644 --- a/test-components/logging/Cargo.toml +++ b/test-components/logging/Cargo.toml @@ -14,8 +14,8 @@ opt-level = 's' [dependencies] wit-bindgen-rt = { version = "0.40.0", features = ["bitflags"] } -golem-rust = { version = "1.4.0" } -golem-rust-macro = { version = "1.4.0" } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } +golem-rust-macro = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } log = { version = "0.4.22", features = ["kv"] } rand = "0.8.5" reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-march-2025", features = [ diff --git a/test-components/low-level-agent.wasm b/test-components/low-level-agent.wasm new file mode 100644 index 0000000000..dcee060326 Binary files /dev/null and b/test-components/low-level-agent.wasm differ diff --git a/test-components/low-level-agent/.gitignore b/test-components/low-level-agent/.gitignore new file mode 100644 index 0000000000..ed09b53992 --- /dev/null +++ b/test-components/low-level-agent/.gitignore @@ -0,0 +1,2 @@ +/golem-temp +/target diff --git a/test-components/low-level-agent/Cargo.lock b/test-components/low-level-agent/Cargo.lock new file mode 100644 index 0000000000..86fb3d1b35 --- /dev/null +++ b/test-components/low-level-agent/Cargo.lock @@ -0,0 +1,1298 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "android-tzdata" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100" + +[[package]] +name = "auditable-serde" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7bf8143dfc3c0258df908843e169b5cc5fcf76c7718bd66135ef4a9cd558c5" +dependencies = [ + "semver", + "serde", + "serde_json", + "topological-sort", +] + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bitflags" +version = "2.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" + +[[package]] +name = "bumpalo" +version = "3.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" + +[[package]] +name = "bytes" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" + +[[package]] +name = "camino" +version = "1.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d07aa9a93b00c76f71bc35d598bed923f6d4f3a9ca5c24b7737ae1a292841c0" +dependencies = [ + "serde", +] + +[[package]] +name = "cargo-platform" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea" +dependencies = [ + "serde", +] + +[[package]] +name = "cargo_metadata" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba" +dependencies = [ + "camino", + "cargo-platform", + "semver", + "serde", + "serde_json", + "thiserror", +] + +[[package]] +name = "cc" +version = "1.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e" +dependencies = [ + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" + +[[package]] +name = "chrono" +version = "0.4.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d" +dependencies = [ + "android-tzdata", + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "common-lib" +version = "0.1.0" + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "flate2" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "getrandom" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasi 0.14.2+wasi-0.2.4", +] + +[[package]] +name = "git-version" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad568aa3db0fcbc81f2f116137f263d7304f512a1209b35b85150d3ef88ad19" +dependencies = [ + "git-version-macro", +] + +[[package]] +name = "git-version-macro" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "golem-rust" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" +dependencies = [ + "golem-rust-macro", + "golem-wasm-rpc", + "serde", + "serde_json", + "uuid", + "wit-bindgen 0.40.0", +] + +[[package]] +name = "golem-rust-macro" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "golem-wasm-rpc" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#438c50328e7bdd0a5a912cd03d988458e9d7a745" +dependencies = [ + "cargo_metadata", + "chrono", + "git-version", + "uuid", + "wit-bindgen-rt 0.40.0", +] + +[[package]] +name = "golem_it" +version = "0.0.1" +dependencies = [ + "golem-rust", + "reqwest", + "serde", + "serde_json", + "wit-bindgen-rt 0.42.1", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "http" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005" + +[[package]] +name = "idna" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" +dependencies = [ + "equivalent", + "hashbrown", + "serde", +] + +[[package]] +name = "itoa" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" + +[[package]] +name = "js-sys" +version = "0.3.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "libc" +version = "0.2.175" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" + +[[package]] +name = "litemap" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" + +[[package]] +name = "log" +version = "0.4.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" + +[[package]] +name = "memchr" +version = "2.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" + +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "potential_utf" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" +dependencies = [ + "zerovec", +] + +[[package]] +name = "prettyplease" +version = "0.2.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.97" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d61789d7719defeb74ea5fe81f2fdfdbd28a803847077cecce2ff14e1472f6f1" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "reqwest" +version = "0.12.15" +source = "git+https://github.com/zivergetech/reqwest?branch=update-july-2025#9e0c586a3f2fc2f9fe32ddf46c2a49152777693b" +dependencies = [ + "base64", + "bytes", + "encoding_rs", + "http", + "mime", + "percent-encoding", + "serde", + "serde_json", + "serde_urlencoded", + "url", + "wasi 0.12.1+wasi-0.2.0", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "ryu" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" + +[[package]] +name = "semver" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0" +dependencies = [ + "serde", +] + +[[package]] +name = "serde" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.142" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "sha1_smol" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d" + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "slab" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "spdx" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e17e880bafaeb362a7b751ec46bdc5b61445a188f80e0606e68167cd540fa3" +dependencies = [ + "smallvec", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + +[[package]] +name = "syn" +version = "2.0.105" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bc3fcb250e53458e712715cf74285c1f889686520d79294a9ef3bd7aa1fc619" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "thiserror" +version = "2.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b0949c3a6c842cbde3f1686d6eea5a010516deb7085f79db747562d4102f41e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc5b44b4ab9c2fdd0e0512e6bece8388e214c0749f5862b114cc5b7a25daf227" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tinystr" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "topological-sort" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea68304e134ecd095ac6c3574494fc62b909f416c4fca77e440530221e549d3d" + +[[package]] +name = "unicode-ident" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "url" +version = "2.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "uuid" +version = "1.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be" +dependencies = [ + "getrandom", + "js-sys", + "serde", + "sha1_smol", + "wasm-bindgen", +] + +[[package]] +name = "wasi" +version = "0.12.1+wasi-0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af274f03e73b7d85551b3f9e97b8a04d5c9aec703cfc227a3fe0595a7561c67a" +dependencies = [ + "wit-bindgen 0.19.2", +] + +[[package]] +name = "wasi" +version = "0.14.2+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3" +dependencies = [ + "wit-bindgen-rt 0.39.0", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6" +dependencies = [ + "bumpalo", + "log", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-encoder" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80bb72f02e7fbf07183443b27b0f3d4144abf8c114189f2e088ed95b696a7822" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce1ef0faabbbba6674e97a56bee857ccddf942785a336c8b47b42373c922a91d" +dependencies = [ + "anyhow", + "auditable-serde", + "flate2", + "indexmap", + "serde", + "serde_derive", + "serde_json", + "spdx", + "url", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f51cad774fb3c9461ab9bccc9c62dfb7388397b5deda31bf40e8108ccd678b2" +dependencies = [ + "bitflags", + "hashbrown", + "indexmap", + "semver", +] + +[[package]] +name = "windows-core" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + +[[package]] +name = "windows-result" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" +dependencies = [ + "windows-link", +] + +[[package]] +name = "wit-bindgen" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b37d270da94012e0ac490ac633ad5bdd76a10a3fb15069edb033c1b771ce931f" +dependencies = [ + "bitflags", +] + +[[package]] +name = "wit-bindgen" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e7091ed6c9abfa4e0a2ef3b39d0539da992d841fcf32c255f64fb98764ffee5" +dependencies = [ + "wit-bindgen-rt 0.40.0", + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "398c650cec1278cfb72e214ba26ef3440ab726e66401bd39c04f465ee3979e6b" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + +[[package]] +name = "wit-bindgen-rt" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" +dependencies = [ + "bitflags", +] + +[[package]] +name = "wit-bindgen-rt" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68faed92ae696b93ea9a7b67ba6c37bf09d72c6d9a70fa824a743c3020212f11" +dependencies = [ + "bitflags", + "futures", + "once_cell", +] + +[[package]] +name = "wit-bindgen-rt" +version = "0.42.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "051105bab12bc78e161f8dfb3596e772dd6a01ebf9c4840988e00347e744966a" +dependencies = [ + "bitflags", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83903c8dcd8084a8a67ae08190122cf0e25dc37bdc239070a00f47e22d3f0aae" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7bf7f20495bcc7dc9f24c5fbcac9e919ca5ebdb7a1b1841d74447d3c8dd0c60" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "635c3adc595422cbf2341a17fb73a319669cc8d33deed3a48368a841df86b676" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.227.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddf445ed5157046e4baf56f9138c124a0824d4d1657e7204d71886ad8ce2fc11" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/test-components/low-level-agent/Cargo.toml b/test-components/low-level-agent/Cargo.toml new file mode 100644 index 0000000000..38ca3e65d8 --- /dev/null +++ b/test-components/low-level-agent/Cargo.toml @@ -0,0 +1,14 @@ +[workspace] +resolver = "2" +members = ["components-rust/*", "common-rust/*"] + +[profile.release] +opt-level = "s" +lto = true + +[workspace.dependencies] +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } +reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-july-2025", features = ["json"] } +serde = { version = "1", features = ["derive"] } +serde_json = "1" +wit-bindgen-rt = { version = "0.42.1", features = ["bitflags"] } diff --git a/test-components/low-level-agent/common-rust/common-lib/Cargo.toml b/test-components/low-level-agent/common-rust/common-lib/Cargo.toml new file mode 100644 index 0000000000..876f1d66d4 --- /dev/null +++ b/test-components/low-level-agent/common-rust/common-lib/Cargo.toml @@ -0,0 +1,4 @@ +[package] +name = "common-lib" +version = "0.1.0" +edition = "2021" diff --git a/test-components/low-level-agent/common-rust/common-lib/src/lib.rs b/test-components/low-level-agent/common-rust/common-lib/src/lib.rs new file mode 100644 index 0000000000..15c6dcba72 --- /dev/null +++ b/test-components/low-level-agent/common-rust/common-lib/src/lib.rs @@ -0,0 +1,3 @@ +pub fn example_common_function() -> &'static str { + "hello common" +} diff --git a/test-components/low-level-agent/common-rust/golem.yaml b/test-components/low-level-agent/common-rust/golem.yaml new file mode 100644 index 0000000000..292c27cc5e --- /dev/null +++ b/test-components/low-level-agent/common-rust/golem.yaml @@ -0,0 +1,53 @@ +# Schema for IDEA: +# $schema: https://schema.golem.cloud/app/golem/1.2.4/golem.schema.json +# Schema for vscode-yaml +# yaml-language-server: $schema=https://schema.golem.cloud/app/golem/1.2.4/golem.schema.json + +# See https://learn.golem.cloud/docs/app-manifest#field-reference for field reference +# For creating APIs see https://learn.golem.cloud/invoke/making-custom-apis + +templates: + rust: + profiles: + debug: + build: + - command: cargo component build + sources: + - src + - wit-generated + - ../../common-rust + - Cargo.toml + targets: + - ../../target/wasm32-wasip1/debug/{{ component_name | to_snake_case }}.wasm + sourceWit: wit + generatedWit: wit-generated + componentWasm: ../../target/wasm32-wasip1/debug/{{ component_name | to_snake_case }}.wasm + linkedWasm: ../../golem-temp/components/{{ component_name | to_snake_case }}_debug.wasm + clean: + - src/bindings.rs + customCommands: + copy: + - command: cp ../../golem-temp/components/{{ component_name | to_snake_case }}_debug.wasm ../../../low-level-agent.wasm + release: + build: + - command: cargo component build --release + sources: + - src + - wit-generated + - ../../common-rust + - Cargo.toml + targets: + - ../../target/wasm32-wasip1/release/{{ component_name | to_snake_case }}.wasm + sourceWit: wit + generatedWit: wit-generated + componentWasm: ../../target/wasm32-wasip1/release/{{ component_name | to_snake_case }}.wasm + linkedWasm: ../../golem-temp/components/{{ component_name | to_snake_case }}_release.wasm + clean: + - src/bindings.rs + customCommands: + copy: + - command: cp ../../golem-temp/components/{{ component_name | to_snake_case }}_release.wasm ../../../low-level-agent.wasm + defaultProfile: debug +customCommands: + cargo-clean: + - command: cargo clean diff --git a/test-components/low-level-agent/components-rust/.gitignore b/test-components/low-level-agent/components-rust/.gitignore new file mode 100644 index 0000000000..077f8ae54d --- /dev/null +++ b/test-components/low-level-agent/components-rust/.gitignore @@ -0,0 +1,2 @@ +/*/src/bindings.rs +/*/wit-generated diff --git a/test-components/low-level-agent/components-rust/golem-it/Cargo.lock b/test-components/low-level-agent/components-rust/golem-it/Cargo.lock new file mode 100644 index 0000000000..4a394e2366 --- /dev/null +++ b/test-components/low-level-agent/components-rust/golem-it/Cargo.lock @@ -0,0 +1,1376 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "addr2line" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" + +[[package]] +name = "autocfg" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" + +[[package]] +name = "backtrace" +version = "0.3.74" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-targets 0.52.6", +] + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "bitflags" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" + +[[package]] +name = "bumpalo" +version = "3.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" + +[[package]] +name = "bytes" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "325918d6fe32f23b19878fe4b34794ae41fc19ddbe53b10571a4874d44ffd39b" + +[[package]] +name = "cc" +version = "1.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c31a0499c1dc64f458ad13872de75c0eb7e3fdb0e67964610c914b034fc5956e" +dependencies = [ + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "golem-it" +version = "0.0.1" +dependencies = [ + "golem-rust", + "reqwest", + "serde", + "serde_json", + "wit-bindgen-rt", +] + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "errno" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33d852cb9b869c2a9b3df2f71a3074817f01e1844f839a144f5fcef059a4eb5d" +dependencies = [ + "libc", + "windows-sys 0.59.0", +] + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "pin-utils", +] + +[[package]] +name = "getrandom" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "gimli" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" + +[[package]] +name = "golem-rust" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c967eb388fb81f9b9f4df5d5b6634de803f21cd410c1bf687202794a4fbc0267" +dependencies = [ + "golem-rust-macro", + "serde", + "serde_json", + "uuid", + "wit-bindgen-rt", +] + +[[package]] +name = "golem-rust-macro" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bb87f831cfe4371427c63f5f4cabcc3bae1b66974c8fbcf22be9274fee3a7d1" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "h2" +version = "0.3.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "hashbrown" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "http" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + +[[package]] +name = "http-body" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" +dependencies = [ + "bytes", + "http", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d71d3574edd2771538b901e6549113b4006ece66150fb69c0fb6d9a2adae946" + +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + +[[package]] +name = "hyper" +version = "0.14.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7" +dependencies = [ + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", + "want", +] + +[[package]] +name = "hyper-tls" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" +dependencies = [ + "bytes", + "hyper", + "native-tls", + "tokio", + "tokio-native-tls", +] + +[[package]] +name = "icu_collections" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locid" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_locid_transform" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e" +dependencies = [ + "displaydoc", + "icu_locid", + "icu_locid_transform_data", + "icu_provider", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_locid_transform_data" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e" + +[[package]] +name = "icu_normalizer" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "utf16_iter", + "utf8_iter", + "write16", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516" + +[[package]] +name = "icu_properties" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locid_transform", + "icu_properties_data", + "icu_provider", + "tinystr", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569" + +[[package]] +name = "icu_provider" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9" +dependencies = [ + "displaydoc", + "icu_locid", + "icu_provider_macros", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_provider_macros" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "idna" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "ipnet" +version = "2.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddc24109865250148c2e0f3d25d4f0f479571723792d3802153c60922a4fb708" + +[[package]] +name = "itoa" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" + +[[package]] +name = "js-sys" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6717b6b5b077764fb5966237269cb3c64edddde4b14ce42647430a78ced9e7b7" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "libc" +version = "0.2.169" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a" + +[[package]] +name = "linux-raw-sys" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89" + +[[package]] +name = "litemap" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104" + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + +[[package]] +name = "miniz_oxide" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ffbe83022cedc1d264172192511ae958937694cd57ce297164951b8b3568394" +dependencies = [ + "adler2", +] + +[[package]] +name = "mio" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.52.0", +] + +[[package]] +name = "native-tls" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466" +dependencies = [ + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "object" +version = "0.36.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" + +[[package]] +name = "openssl" +version = "0.10.68" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6174bc48f102d208783c2c84bf931bb75927a617866870de8a4ea85597f871f5" +dependencies = [ + "bitflags", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "openssl-probe" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" + +[[package]] +name = "openssl-sys" +version = "0.9.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45abf306cbf99debc8195b66b7346498d7b10c210de50418b5ccd7ceba08c741" +dependencies = [ + "cc", + "libc", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "pin-project-lite" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915a1e146535de9163f3987b8944ed8cf49a18bb0056bcebcdcece385cece4ff" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkg-config" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2" + +[[package]] +name = "proc-macro2" +version = "1.0.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "reqwest" +version = "0.11.18" +source = "git+https://github.com/zivergetech/reqwest?branch=update-jun-2024#1cf59c67b93aa6292961f8948b93df5bca2753b6" +dependencies = [ + "base64", + "bytes", + "encoding_rs", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "hyper", + "hyper-tls", + "ipnet", + "js-sys", + "log", + "mime", + "native-tls", + "once_cell", + "percent-encoding", + "pin-project-lite", + "serde", + "serde_json", + "serde_urlencoded", + "tokio", + "tokio-native-tls", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "winreg", + "wit-bindgen-rt", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" + +[[package]] +name = "rustix" +version = "0.38.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f93dc38ecbab2eb790ff964bb77fa94faf256fd3e73285fd7ba0903b76bedb85" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.59.0", +] + +[[package]] +name = "ryu" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" + +[[package]] +name = "schannel" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d" +dependencies = [ + "windows-sys 0.59.0", +] + +[[package]] +name = "security-framework" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1863fd3768cd83c56a7f60faa4dc0d403f1b6df0a38c3c25f44b7894e45370d5" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "serde" +version = "1.0.216" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.216" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.134" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] + +[[package]] +name = "smallvec" +version = "1.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" + +[[package]] +name = "socket2" +version = "0.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c970269d99b64e60ec3bd6ad27270092a5394c4e309314b18ae3fe575695fbe8" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + +[[package]] +name = "syn" +version = "2.0.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d53cbcb5a243bd33b7858b1d7f4aca2153490815872d86d955d6ea29f743c035" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tempfile" +version = "3.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c" +dependencies = [ + "cfg-if", + "fastrand", + "once_cell", + "rustix", + "windows-sys 0.59.0", +] + +[[package]] +name = "tinystr" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tokio" +version = "1.42.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cec9b21b0450273377fc97bd4c33a8acffc8c996c987a7c5b319a0083707551" +dependencies = [ + "backtrace", + "bytes", + "libc", + "mio", + "pin-project-lite", + "socket2", + "windows-sys 0.52.0", +] + +[[package]] +name = "tokio-native-tls" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" +dependencies = [ + "native-tls", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c" +dependencies = [ + "once_cell", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "unicode-ident" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" + +[[package]] +name = "url" +version = "2.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "utf16_iter" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "uuid" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a" +dependencies = [ + "getrandom", +] + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "want" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" +dependencies = [ + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a474f6281d1d70c17ae7aa6a613c87fce69a127e2624002df63dcb39d6cf6396" +dependencies = [ + "cfg-if", + "once_cell", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f89bb38646b4f81674e8f5c3fb81b562be1fd936d84320f3264486418519c79" +dependencies = [ + "bumpalo", + "log", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.49" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38176d9b44ea84e9184eff0bc34cc167ed044f816accfe5922e54d84cf48eca2" +dependencies = [ + "cfg-if", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2cc6181fd9a7492eef6fef1f33961e3695e4579b9872a6f7c83aee556666d4fe" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30d7a95b763d3c45903ed6c81f156801839e5ee968bb07e534c44df0fcd330c2" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6" + +[[package]] +name = "web-sys" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04dd7223427d52553d3702c004d3b2fe07c148165faa56313cb00211e31c12bc" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winreg" +version = "0.50.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" +dependencies = [ + "cfg-if", + "windows-sys 0.48.0", +] + +[[package]] +name = "wit-bindgen-rt" +version = "0.26.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29c7526379ace8709ee9ab9f2bb50f112d95581063a59ef3097d9c10153886c9" +dependencies = [ + "bitflags", +] + +[[package]] +name = "write16" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936" + +[[package]] +name = "writeable" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51" + +[[package]] +name = "yoke" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "595eed982f7d355beb85837f651fa22e90b3c044842dc7f2c2842c086f295808" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerovec" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/test-components/low-level-agent/components-rust/golem-it/Cargo.toml b/test-components/low-level-agent/components-rust/golem-it/Cargo.toml new file mode 100644 index 0000000000..462b984dbd --- /dev/null +++ b/test-components/low-level-agent/components-rust/golem-it/Cargo.toml @@ -0,0 +1,43 @@ +[package] +name = "golem_it" +version = "0.0.1" +edition = "2021" + +[lib] +path = "src/lib.rs" +crate-type = ["cdylib"] +required-features = [] + +[dependencies] +# To use common shared libs, use the following: +# common-lib = { path = "../../common-rust/common-lib" } + +golem-rust = { workspace = true } +reqwest = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } +wit-bindgen-rt = { workspace = true } + +[package.metadata.component.target] +path = "wit-generated" + +[package.metadata.component.bindings.with] +"wasi:io/poll@0.2.3" = "golem_rust::wasm_rpc::wasi::io::poll" +"wasi:clocks/monotonic-clock@0.2.3" = "golem_rust::bindings::wasi::clocks::monotonic_clock" +"wasi:clocks/wall-clock@0.2.3" = "golem_rust::wasm_rpc::wasi::clocks::wall_clock" +"golem:rpc/types@0.2.2" = "golem_rust::wasm_rpc::golem_rpc_0_2_x::types" +"golem:api/host@1.1.7" = "golem_rust::bindings::golem::api::host" + +[package.metadata.component.target.dependencies] +"wasi:io" = { path = "wit-generated/deps/io" } +"wasi:clocks" = { path = "wit-generated/deps/clocks" } +"golem:rpc" = { path = "wit-generated/deps/golem-rpc" } +"golem:api" = { path = "wit-generated/deps/golem-1.x" } +"golem:agent" = { path = "wit-generated/deps/golem-agent" } +"golem:it-exports" = { path = "wit-generated/deps/golem_it-exports" } + +[package.metadata.component.bindings] +# See https://github.com/bytecodealliance/cargo-component/blob/main/src/metadata.rs#L62 + +# derives = ["serde::Serialize", "serde::Deserialize"] +# generate_unused_types = true \ No newline at end of file diff --git a/test-components/low-level-agent/components-rust/golem-it/golem.yaml b/test-components/low-level-agent/components-rust/golem-it/golem.yaml new file mode 100644 index 0000000000..19733ea677 --- /dev/null +++ b/test-components/low-level-agent/components-rust/golem-it/golem.yaml @@ -0,0 +1,19 @@ +# Schema for IDEA: +# $schema: https://schema.golem.cloud/app/golem/1.2.4/golem.schema.json +# Schema for vscode-yaml +# yaml-language-server: $schema=https://schema.golem.cloud/app/golem/1.2.4/golem.schema.json + +# See https://learn.golem.cloud/docs/app-manifest#field-reference for field reference +# For creating APIs see https://learn.golem.cloud/invoke/making-custom-apis + +components: + golem:it: + template: rust + +# Example for adding dependencies for Worker to Worker communication: +# See https://learn.golem.cloud/docs/app-manifest#fields_dependencies for more information +# +#dependencies: +# golem:it: +# - target: +# type: wasm-rpc diff --git a/test-components/low-level-agent/components-rust/golem-it/src/lib.rs b/test-components/low-level-agent/components-rust/golem-it/src/lib.rs new file mode 100644 index 0000000000..0ad1af1908 --- /dev/null +++ b/test-components/low-level-agent/components-rust/golem-it/src/lib.rs @@ -0,0 +1,210 @@ +#[allow(static_mut_refs)] +mod bindings; + +use crate::bindings::exports::golem::agent::guest::*; +use crate::bindings::golem::agent::common::{AgentConstructor, AgentMethod, DataSchema}; +use crate::bindings::golem::agent::host::{register_agent, unregister_agent}; +use std::cell::RefCell; +use std::collections::HashMap; +use std::rc::{Rc, Weak}; + +struct State { + agents: HashMap, + last_id: u64, +} + +thread_local! { + static STATE: RefCell = RefCell::new(State { + agents: HashMap::new(), + last_id: 0, + }); +} + +struct Component; + +impl Guest for Component { + type Agent = TestAgent; + + fn get_agent(_agent_type: String, agent_id: String) -> Agent { + STATE.with_borrow(|state| { + if let Some(agent) = state.agents.get(&agent_id) { + if let Some(agent) = agent.upgrade() { + Agent::new(agent) + } else { + panic!("Agent with id {} has been dropped", agent_id); + } + } else { + panic!("Agent with id {} not found", agent_id); + } + }) + } + + fn invoke_agent( + agent_type: String, + agent_id: String, + method_name: String, + input: DataValue, + ) -> Result { + if agent_type != "TestAgent" { + Err(AgentError::InvalidType(format!( + "Invalid agent type: {}", + agent_type + ))) + } else { + STATE.with_borrow(|state| { + if let Some(agent) = state.agents.get(&agent_id) { + if let Some(agent) = agent.upgrade() { + agent.invoke(method_name, input) + } else { + Err(AgentError::InvalidAgentId(format!( + "Agent with id {} has been dropped", + agent_id + ))) + } + } else { + Err(AgentError::InvalidAgentId(format!( + "Agent with id {} not found", + agent_id + ))) + } + }) + } + } + + fn discover_agents() -> Vec { + STATE.with(|state| { + state + .borrow() + .agents + .values() + .cloned() + .filter_map(|agent| agent.upgrade()) + .map(Agent::new) + .collect() + }) + } + + fn discover_agent_types() -> Vec { + vec![agent_type()] + } +} + +#[derive(Clone)] +struct WeakTestAgent { + state: Weak>, +} + +impl WeakTestAgent { + pub fn upgrade(&self) -> Option { + self.state.upgrade().map(|state| TestAgent { state }) + } +} + +#[derive(Clone)] +struct TestAgent { + state: Rc>, +} + +impl TestAgent { + pub fn new() -> Self { + STATE.with_borrow_mut(|state| { + let agent_id = format!("agent-{}", state.last_id + 1); + state.last_id += 1; + let agent = TestAgent { + state: Rc::new(RefCell::new(TestAgentState { + id: agent_id.clone(), + inner_agents: vec![], + })), + }; + state.agents.insert(agent_id.clone(), agent.downgrade()); + register_agent("TestAgent", &agent_id, &DataValue::Tuple(vec![])); + agent + }) + } + + pub fn downgrade(&self) -> WeakTestAgent { + WeakTestAgent { + state: Rc::downgrade(&self.state), + } + } +} + +impl GuestAgent for TestAgent { + fn create(_agent_type: String, _input: DataValue) -> Result { + let agent = TestAgent::new(); + let agent_resource = Agent::new(agent.clone()); + + Ok(agent_resource) + } + + fn get_id(&self) -> String { + self.state.borrow().id.clone() + } + + fn invoke(&self, method_name: String, _input: DataValue) -> Result { + match method_name.as_str() { + "create-inner" => { + let inner_agent = TestAgent::new(); + self.state.borrow_mut().inner_agents.push(inner_agent); + Ok(DataValue::Tuple(vec![])) + } + "drop-all-inner" => { + let inner_agents = &mut self.state.borrow_mut().inner_agents; + for agent in inner_agents.drain(..) { + STATE.with_borrow_mut(|state| { + state.agents.remove(&agent.state.borrow().id); + }); + } + Ok(DataValue::Tuple(vec![])) + } + _ => Err(AgentError::InvalidMethod("Method not found".to_string())), + } + } + + fn get_definition(&self) -> AgentType { + agent_type() + } +} + +fn agent_type() -> AgentType { + AgentType { + type_name: "TestAgent".to_string(), + description: "".to_string(), + constructor: AgentConstructor { + name: None, + description: "".to_string(), + prompt_hint: None, + input_schema: DataSchema::Tuple(vec![]), + }, + methods: vec![ + AgentMethod { + name: "create-inner".to_string(), + description: "Create a new agent from code".to_string(), + prompt_hint: None, + input_schema: DataSchema::Tuple(vec![]), + output_schema: DataSchema::Tuple(vec![]), + }, + AgentMethod { + name: "drop-all-inner".to_string(), + description: "Drop all inner agents from code".to_string(), + prompt_hint: None, + input_schema: DataSchema::Tuple(vec![]), + output_schema: DataSchema::Tuple(vec![]), + }, + ], + dependencies: vec![], + } +} + +struct TestAgentState { + id: String, + inner_agents: Vec, +} + +impl Drop for TestAgentState { + fn drop(&mut self) { + unregister_agent("TestAgent", &self.id, &DataValue::Tuple(vec![])) + } +} + +bindings::export!(Component with_types_in bindings); diff --git a/test-components/low-level-agent/components-rust/golem-it/wit/golem-it.wit b/test-components/low-level-agent/components-rust/golem-it/wit/golem-it.wit new file mode 100644 index 0000000000..90794c0a3c --- /dev/null +++ b/test-components/low-level-agent/components-rust/golem-it/wit/golem-it.wit @@ -0,0 +1,9 @@ +package golem:it; + +world golem-it { + import golem:api/host@1.1.7; + import golem:rpc/types@0.2.2; + export golem:agent/guest; + + import golem:agent/host; +} diff --git a/test-components/low-level-agent/golem.yaml b/test-components/low-level-agent/golem.yaml new file mode 100644 index 0000000000..8c3ee0bc65 --- /dev/null +++ b/test-components/low-level-agent/golem.yaml @@ -0,0 +1,13 @@ +# Schema for IDEA: +# $schema: https://schema.golem.cloud/app/golem/1.2.4/golem.schema.json +# Schema for vscode-yaml +# yaml-language-server: $schema=https://schema.golem.cloud/app/golem/1.2.4/golem.schema.json + +# See https://learn.golem.cloud/docs/app-manifest#field-reference for field reference +# For creating APIs see https://learn.golem.cloud/invoke/making-custom-apis + +includes: +- common-*/golem.yaml +- components-*/*/golem.yaml +witDeps: +- wit/deps diff --git a/test-components/low-level-agent/wit/common.wit b/test-components/low-level-agent/wit/common.wit new file mode 100644 index 0000000000..f74b228804 --- /dev/null +++ b/test-components/low-level-agent/wit/common.wit @@ -0,0 +1,7 @@ +// This file is used to make the 'wit' directory compatible with tools such as wit-bindgen. +// +// Do NOT add anything to this file, rather create a 'deps' directory, and place common WIT dependency packages there. +// Such dependencies can be referenced in the component WIT definitions, and will automatically be included when needed +// in the generated component wit directories. + +package common:root; diff --git a/test-components/low-level-agent/wit/deps.lock b/test-components/low-level-agent/wit/deps.lock new file mode 100644 index 0000000000..7bfe6cb5d7 --- /dev/null +++ b/test-components/low-level-agent/wit/deps.lock @@ -0,0 +1,71 @@ +[agent] +url = "https://github.com/golemcloud/golem-agentic/archive/type-owner.tar.gz" +sha256 = "92738a15004db69c4c7dd4c7d531d3fb40d10779ff130d2c0d008d3984d2f73f" +sha512 = "b37e4979adfe4f35c44786a1b79db9455ab56a02f28dfc6ae1cfb8d658bd92793d87e6aef98fa8b21c5ffdef1016893887199011953cae6744e74efefbd186af" +deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-agent", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] + +[all] +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" +sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" +sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" +deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] + +[blobstore] +sha256 = "f7857c92a8d540ebfe10c9ac3b8cfe160d2303ca638d59aec3c18406e084d367" +sha512 = "af647a1c40672c4b2b970b2f99de54d404e35b4aed430b00395d708dcec74eb6f03543b65605a90a1dbc3db5dbf1887b2b6ae9b6c6306475d119b312b4e91868" + +[cli] +sha256 = "4dadd13d55aaf626833d1f4b9c34a17b0f04e993babd09552b785cda3b95ea76" +sha512 = "898dcc4e8c15d18acc6b88dbe232336fa4d19019430a910dbc9e7aeaace3077a164af3be9f002de6e7e65ef693df340801ac0c7e421e9a746bf1b6d698a90835" + +[clocks] +sha256 = "93a701968a7dd3c5d69031bc0601681c468972fdf7e28a93bb6150a67d6ebe8b" +sha512 = "98fca567c7a01887b0fb38981f1772169b6ea8de475b546508f8b86738d84e44ba95cae81def40ac34e8809f5f60e85224077ab8cb6d6d5d6296acc1df73c159" + +[config] +sha256 = "31fe247a242af7abe32dfadcb4edbc7720f9c47c2bff34b7e5c75df915ab5eb9" +sha512 = "ce5367f3a104843852236799a3386a44da12ee5e287eb94075fd5252c1400b6ef84438f3b3e19f75fb3d842d82fe3a1bc999385fe59fc8e1696fed69bad69eac" + +[filesystem] +sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" +sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" + +["golem-1.x"] +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" + +[golem-agent] +sha256 = "5b4b7a7f7f6fca429cf241139e0ec56ef393559e355a3eee2f0a3ff66a0c516b" +sha512 = "27151b72ee8b0c68316198d89306de39f831d9ea7786e9d47676eee533de33a2116e6dcf0ff65ef07d24b85b1689bb83e5e7dbaf40a49fef29c0419e766fd40a" + +[golem-durability] +sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" +sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" + +[golem-rpc] +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" + +[http] +sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" +sha512 = "636150c464c0eb3d60bd212fc5d4012638c8cd4f89b583b87a38154ef99de828aac4296ac13c5cface10ee61e164fcfc43a5c104f916229dfdf49c0d11047677" + +[io] +sha256 = "1cccbfe4122686ea57a25cd368e8cdfc408cbcad089f47fb6685b6f92e96f050" +sha512 = "7a95f964c13da52611141acd89bc8876226497f128e99dd176a4270c5b5efbd8cc847b5fbd1a91258d028c646db99e0424d72590cf1caf20f9f3a3343fad5017" + +[keyvalue] +sha256 = "0b37334713ee32ddbf6c064ddc3fe8e5b730ff63b6381b45c87aa07a6ec700ca" +sha512 = "1ec372a657a2a9f602e781846984febfdc7c34c3dc8a2c83d5b282f5580edd1d556478bbbb2a34e97c618a03b05fcc1059d6f4a01dc27176f5e5702e5173507e" + +[logging] +sha256 = "7fb7216c713fd329ec91bb596127a1b95eec26290290b6de0c1ef294fba858c2" +sha512 = "ceb68410bb46176051b0eee54e1a60831ca2fe820892c5f5f739e76efd4fe6ee6dc5e307947e7118b68a2a757ed3a3b471d16eb0900bb9040de47fef4bf1b56f" + +[random] +sha256 = "dd0c91e7125172eb8fd4568e15ad9fc7305643015e6ece4396c3cc5e8c2bf79a" +sha512 = "d1ca2e7b0616a94a3b39d1b9450bb3fb595b01fd94a8626ad75433038dde40988ecb41ab93a374d569ab72163af3b30038d7bfc3499b9c07193181f4f1d9292a" + +[sockets] +sha256 = "2bc0f65a8046207ee3330ad7d63f6fafeafd4cc0ea4084f081bd5e4f7b177e74" +sha512 = "3e5490e41547dffa78d52631825d93da8d60f4af0246cbaf97e1ecb879285953a86d5f1f390b10c32f91dd7eaec6f43e625a26b1c92c32a0c86fde428aedaaab" diff --git a/test-components/low-level-agent/wit/deps.toml b/test-components/low-level-agent/wit/deps.toml new file mode 100644 index 0000000000..6f286cd13b --- /dev/null +++ b/test-components/low-level-agent/wit/deps.toml @@ -0,0 +1,2 @@ +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" +agent = "https://github.com/golemcloud/golem-agentic/archive/type-owner.tar.gz" diff --git a/test-components/low-level-agent/wit/deps/agent/main.wit b/test-components/low-level-agent/wit/deps/agent/main.wit new file mode 100644 index 0000000000..0e5cb88b34 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/agent/main.wit @@ -0,0 +1,5 @@ +package golem:agent-guest; + +world agent-guest { + include golem:agent/agent-guest; +} diff --git a/test-components/low-level-agent/wit/deps/all/main.wit b/test-components/low-level-agent/wit/deps/all/main.wit new file mode 100644 index 0000000000..0a1f74f41f --- /dev/null +++ b/test-components/low-level-agent/wit/deps/all/main.wit @@ -0,0 +1 @@ +package unused:main; diff --git a/test-components/low-level-agent/wit/deps/blobstore/blobstore.wit b/test-components/low-level-agent/wit/deps/blobstore/blobstore.wit new file mode 100644 index 0000000000..cc52516a57 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/blobstore/blobstore.wit @@ -0,0 +1,29 @@ +package wasi:blobstore; + +// wasi-cloud Blobstore service definition +interface blobstore { + use container.{container}; + use types.{error, container-name, object-id}; + + // creates a new empty container + create-container: func(name: container-name) -> result; + + // retrieves a container by name + get-container: func(name: container-name) -> result; + + // deletes a container and all objects within it + delete-container: func(name: container-name) -> result<_, error>; + + // returns true if the container exists + container-exists: func(name: container-name) -> result; + + // copies (duplicates) an object, to the same or a different container. + // returns an error if the target container does not exist. + // overwrites destination object if it already existed. + copy-object: func(src: object-id, dest: object-id) -> result<_, error>; + + // moves or renames an object, to the same or a different container + // returns an error if the destination container does not exist. + // overwrites destination object if it already existed. + move-object: func(src:object-id, dest: object-id) -> result<_, error>; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/blobstore/container.wit b/test-components/low-level-agent/wit/deps/blobstore/container.wit new file mode 100644 index 0000000000..0652def81d --- /dev/null +++ b/test-components/low-level-agent/wit/deps/blobstore/container.wit @@ -0,0 +1,68 @@ +package wasi:blobstore; + +// a Container is a collection of objects +interface container { + use wasi:io/streams@0.2.3.{ + input-stream, + output-stream, + }; + + use types.{ + container-metadata, + error, + incoming-value, + object-metadata, + object-name, + outgoing-value, + }; + + // this defines the `container` resource + resource container { + // returns container name + name: func() -> result; + + // returns container metadata + info: func() -> result; + + // retrieves an object or portion of an object, as a resource. + // Start and end offsets are inclusive. + // Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime + // of the data-blob resource, even if the object they came from is later deleted. + get-data: func(name: object-name, start: u64, end: u64) -> result; + + // creates or replaces an object with the data blob. + write-data: func(name: object-name, data: borrow) -> result<_, error>; + + // returns list of objects in the container. Order is undefined. + list-objects: func() -> result; + + // deletes object. + // does not return error if object did not exist. + delete-object: func(name: object-name) -> result<_, error>; + + // deletes multiple objects in the container + delete-objects: func(names: list) -> result<_, error>; + + // returns true if the object exists in this container + has-object: func(name: object-name) -> result; + + // returns metadata for the object + object-info: func(name: object-name) -> result; + + // removes all objects within the container, leaving the container empty. + clear: func() -> result<_, error>; + } + + // this defines the `stream-object-names` resource which is a representation of stream + resource stream-object-names { + // reads the next number of objects from the stream + // + // This function returns the list of objects read, and a boolean indicating if the end of the stream was reached. + read-stream-object-names: func(len: u64) -> result, bool>, error>; + + // skip the next number of objects in the stream + // + // This function returns the number of objects skipped, and a boolean indicating if the end of the stream was reached. + skip-stream-object-names: func(num: u64) -> result, error>; + } +} diff --git a/test-components/low-level-agent/wit/deps/blobstore/types.wit b/test-components/low-level-agent/wit/deps/blobstore/types.wit new file mode 100644 index 0000000000..42cfc95278 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/blobstore/types.wit @@ -0,0 +1,77 @@ +package wasi:blobstore; + +// Types used by blobstore +interface types { + use wasi:io/streams@0.2.3.{input-stream, output-stream}; + + // name of a container, a collection of objects. + // The container name may be any valid UTF-8 string. + type container-name = string; + + // name of an object within a container + // The object name may be any valid UTF-8 string. + type object-name = string; + + // TODO: define timestamp to include seconds since + // Unix epoch and nanoseconds + // https://github.com/WebAssembly/wasi-blob-store/issues/7 + type timestamp = u64; + + // size of an object, in bytes + type object-size = u64; + + type error = string; + + // information about a container + record container-metadata { + // the container's name + name: container-name, + // date and time container was created + created-at: timestamp, + } + + // information about an object + record object-metadata { + // the object's name + name: object-name, + // the object's parent container + container: container-name, + // date and time the object was created + created-at: timestamp, + // size of the object, in bytes + size: object-size, + } + + // identifier for an object that includes its container name + record object-id { + container: container-name, + object: object-name + } + + /// A data is the data stored in a data blob. The value can be of any type + /// that can be represented in a byte array. It provides a way to write the value + /// to the output-stream defined in the `wasi-io` interface. + // Soon: switch to `resource value { ... }` + resource outgoing-value { + new-outgoing-value: static func() -> outgoing-value; + outgoing-value-write-body: func() -> result; + } + + /// A incoming-value is a wrapper around a value. It provides a way to read the value + /// from the input-stream defined in the `wasi-io` interface. + /// + /// The incoming-value provides two ways to consume the value: + /// 1. `incoming-value-consume-sync` consumes the value synchronously and returns the + /// value as a list of bytes. + /// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the + /// value as an input-stream. + // Soon: switch to `resource incoming-value { ... }` + resource incoming-value { + incoming-value-consume-sync: func() -> result; + incoming-value-consume-async: func() -> result; + size: func() -> u64; + } + + type incoming-value-async-body = input-stream; + type incoming-value-sync-body = list; +} diff --git a/test-components/low-level-agent/wit/deps/blobstore/world.wit b/test-components/low-level-agent/wit/deps/blobstore/world.wit new file mode 100644 index 0000000000..4391d68b87 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/blobstore/world.wit @@ -0,0 +1,5 @@ +package wasi:blobstore; + +world blob-store { + import blobstore; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/cli/command.wit b/test-components/low-level-agent/wit/deps/cli/command.wit new file mode 100644 index 0000000000..3a81766d64 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/command.wit @@ -0,0 +1,10 @@ +package wasi:cli@0.2.3; + +@since(version = 0.2.0) +world command { + @since(version = 0.2.0) + include imports; + + @since(version = 0.2.0) + export run; +} diff --git a/test-components/low-level-agent/wit/deps/cli/environment.wit b/test-components/low-level-agent/wit/deps/cli/environment.wit new file mode 100644 index 0000000000..2f449bd7c1 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/environment.wit @@ -0,0 +1,22 @@ +@since(version = 0.2.0) +interface environment { + /// Get the POSIX-style environment variables. + /// + /// Each environment variable is provided as a pair of string variable names + /// and string value. + /// + /// Morally, these are a value import, but until value imports are available + /// in the component model, this import function should return the same + /// values each time it is called. + @since(version = 0.2.0) + get-environment: func() -> list>; + + /// Get the POSIX-style arguments to the program. + @since(version = 0.2.0) + get-arguments: func() -> list; + + /// Return a path that programs should use as their initial current working + /// directory, interpreting `.` as shorthand for this. + @since(version = 0.2.0) + initial-cwd: func() -> option; +} diff --git a/test-components/low-level-agent/wit/deps/cli/exit.wit b/test-components/low-level-agent/wit/deps/cli/exit.wit new file mode 100644 index 0000000000..427935c8d0 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/exit.wit @@ -0,0 +1,17 @@ +@since(version = 0.2.0) +interface exit { + /// Exit the current instance and any linked instances. + @since(version = 0.2.0) + exit: func(status: result); + + /// Exit the current instance and any linked instances, reporting the + /// specified status code to the host. + /// + /// The meaning of the code depends on the context, with 0 usually meaning + /// "success", and other values indicating various types of failure. + /// + /// This function does not return; the effect is analogous to a trap, but + /// without the connotation that something bad has happened. + @unstable(feature = cli-exit-with-code) + exit-with-code: func(status-code: u8); +} diff --git a/test-components/low-level-agent/wit/deps/cli/imports.wit b/test-components/low-level-agent/wit/deps/cli/imports.wit new file mode 100644 index 0000000000..8b4e3975ec --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/imports.wit @@ -0,0 +1,36 @@ +package wasi:cli@0.2.3; + +@since(version = 0.2.0) +world imports { + @since(version = 0.2.0) + include wasi:clocks/imports@0.2.3; + @since(version = 0.2.0) + include wasi:filesystem/imports@0.2.3; + @since(version = 0.2.0) + include wasi:sockets/imports@0.2.3; + @since(version = 0.2.0) + include wasi:random/imports@0.2.3; + @since(version = 0.2.0) + include wasi:io/imports@0.2.3; + + @since(version = 0.2.0) + import environment; + @since(version = 0.2.0) + import exit; + @since(version = 0.2.0) + import stdin; + @since(version = 0.2.0) + import stdout; + @since(version = 0.2.0) + import stderr; + @since(version = 0.2.0) + import terminal-input; + @since(version = 0.2.0) + import terminal-output; + @since(version = 0.2.0) + import terminal-stdin; + @since(version = 0.2.0) + import terminal-stdout; + @since(version = 0.2.0) + import terminal-stderr; +} diff --git a/test-components/low-level-agent/wit/deps/cli/run.wit b/test-components/low-level-agent/wit/deps/cli/run.wit new file mode 100644 index 0000000000..655346efb6 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/run.wit @@ -0,0 +1,6 @@ +@since(version = 0.2.0) +interface run { + /// Run the program. + @since(version = 0.2.0) + run: func() -> result; +} diff --git a/test-components/low-level-agent/wit/deps/cli/stdio.wit b/test-components/low-level-agent/wit/deps/cli/stdio.wit new file mode 100644 index 0000000000..1b54f5318a --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/stdio.wit @@ -0,0 +1,26 @@ +@since(version = 0.2.0) +interface stdin { + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream}; + + @since(version = 0.2.0) + get-stdin: func() -> input-stream; +} + +@since(version = 0.2.0) +interface stdout { + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{output-stream}; + + @since(version = 0.2.0) + get-stdout: func() -> output-stream; +} + +@since(version = 0.2.0) +interface stderr { + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{output-stream}; + + @since(version = 0.2.0) + get-stderr: func() -> output-stream; +} diff --git a/test-components/low-level-agent/wit/deps/cli/terminal.wit b/test-components/low-level-agent/wit/deps/cli/terminal.wit new file mode 100644 index 0000000000..d305498c64 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/cli/terminal.wit @@ -0,0 +1,62 @@ +/// Terminal input. +/// +/// In the future, this may include functions for disabling echoing, +/// disabling input buffering so that keyboard events are sent through +/// immediately, querying supported features, and so on. +@since(version = 0.2.0) +interface terminal-input { + /// The input side of a terminal. + @since(version = 0.2.0) + resource terminal-input; +} + +/// Terminal output. +/// +/// In the future, this may include functions for querying the terminal +/// size, being notified of terminal size changes, querying supported +/// features, and so on. +@since(version = 0.2.0) +interface terminal-output { + /// The output side of a terminal. + @since(version = 0.2.0) + resource terminal-output; +} + +/// An interface providing an optional `terminal-input` for stdin as a +/// link-time authority. +@since(version = 0.2.0) +interface terminal-stdin { + @since(version = 0.2.0) + use terminal-input.{terminal-input}; + + /// If stdin is connected to a terminal, return a `terminal-input` handle + /// allowing further interaction with it. + @since(version = 0.2.0) + get-terminal-stdin: func() -> option; +} + +/// An interface providing an optional `terminal-output` for stdout as a +/// link-time authority. +@since(version = 0.2.0) +interface terminal-stdout { + @since(version = 0.2.0) + use terminal-output.{terminal-output}; + + /// If stdout is connected to a terminal, return a `terminal-output` handle + /// allowing further interaction with it. + @since(version = 0.2.0) + get-terminal-stdout: func() -> option; +} + +/// An interface providing an optional `terminal-output` for stderr as a +/// link-time authority. +@since(version = 0.2.0) +interface terminal-stderr { + @since(version = 0.2.0) + use terminal-output.{terminal-output}; + + /// If stderr is connected to a terminal, return a `terminal-output` handle + /// allowing further interaction with it. + @since(version = 0.2.0) + get-terminal-stderr: func() -> option; +} diff --git a/test-components/low-level-agent/wit/deps/clocks/monotonic-clock.wit b/test-components/low-level-agent/wit/deps/clocks/monotonic-clock.wit new file mode 100644 index 0000000000..c676fb84d8 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/clocks/monotonic-clock.wit @@ -0,0 +1,50 @@ +package wasi:clocks@0.2.3; +/// WASI Monotonic Clock is a clock API intended to let users measure elapsed +/// time. +/// +/// It is intended to be portable at least between Unix-family platforms and +/// Windows. +/// +/// A monotonic clock is a clock which has an unspecified initial value, and +/// successive reads of the clock will produce non-decreasing values. +@since(version = 0.2.0) +interface monotonic-clock { + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + + /// An instant in time, in nanoseconds. An instant is relative to an + /// unspecified initial value, and can only be compared to instances from + /// the same monotonic-clock. + @since(version = 0.2.0) + type instant = u64; + + /// A duration of time, in nanoseconds. + @since(version = 0.2.0) + type duration = u64; + + /// Read the current value of the clock. + /// + /// The clock is monotonic, therefore calling this function repeatedly will + /// produce a sequence of non-decreasing values. + @since(version = 0.2.0) + now: func() -> instant; + + /// Query the resolution of the clock. Returns the duration of time + /// corresponding to a clock tick. + @since(version = 0.2.0) + resolution: func() -> duration; + + /// Create a `pollable` which will resolve once the specified instant + /// has occurred. + @since(version = 0.2.0) + subscribe-instant: func( + when: instant, + ) -> pollable; + + /// Create a `pollable` that will resolve after the specified duration has + /// elapsed from the time this function is invoked. + @since(version = 0.2.0) + subscribe-duration: func( + when: duration, + ) -> pollable; +} diff --git a/test-components/low-level-agent/wit/deps/clocks/timezone.wit b/test-components/low-level-agent/wit/deps/clocks/timezone.wit new file mode 100644 index 0000000000..b43e93b233 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/clocks/timezone.wit @@ -0,0 +1,55 @@ +package wasi:clocks@0.2.3; + +@unstable(feature = clocks-timezone) +interface timezone { + @unstable(feature = clocks-timezone) + use wall-clock.{datetime}; + + /// Return information needed to display the given `datetime`. This includes + /// the UTC offset, the time zone name, and a flag indicating whether + /// daylight saving time is active. + /// + /// If the timezone cannot be determined for the given `datetime`, return a + /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight + /// saving time. + @unstable(feature = clocks-timezone) + display: func(when: datetime) -> timezone-display; + + /// The same as `display`, but only return the UTC offset. + @unstable(feature = clocks-timezone) + utc-offset: func(when: datetime) -> s32; + + /// Information useful for displaying the timezone of a specific `datetime`. + /// + /// This information may vary within a single `timezone` to reflect daylight + /// saving time adjustments. + @unstable(feature = clocks-timezone) + record timezone-display { + /// The number of seconds difference between UTC time and the local + /// time of the timezone. + /// + /// The returned value will always be less than 86400 which is the + /// number of seconds in a day (24*60*60). + /// + /// In implementations that do not expose an actual time zone, this + /// should return 0. + utc-offset: s32, + + /// The abbreviated name of the timezone to display to a user. The name + /// `UTC` indicates Coordinated Universal Time. Otherwise, this should + /// reference local standards for the name of the time zone. + /// + /// In implementations that do not expose an actual time zone, this + /// should be the string `UTC`. + /// + /// In time zones that do not have an applicable name, a formatted + /// representation of the UTC offset may be returned, such as `-04:00`. + name: string, + + /// Whether daylight saving time is active. + /// + /// In implementations that do not expose an actual time zone, this + /// should return false. + in-daylight-saving-time: bool, + } +} diff --git a/test-components/low-level-agent/wit/deps/clocks/wall-clock.wit b/test-components/low-level-agent/wit/deps/clocks/wall-clock.wit new file mode 100644 index 0000000000..e00ce08933 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/clocks/wall-clock.wit @@ -0,0 +1,46 @@ +package wasi:clocks@0.2.3; +/// WASI Wall Clock is a clock API intended to let users query the current +/// time. The name "wall" makes an analogy to a "clock on the wall", which +/// is not necessarily monotonic as it may be reset. +/// +/// It is intended to be portable at least between Unix-family platforms and +/// Windows. +/// +/// A wall clock is a clock which measures the date and time according to +/// some external reference. +/// +/// External references may be reset, so this clock is not necessarily +/// monotonic, making it unsuitable for measuring elapsed time. +/// +/// It is intended for reporting the current date and time for humans. +@since(version = 0.2.0) +interface wall-clock { + /// A time and date in seconds plus nanoseconds. + @since(version = 0.2.0) + record datetime { + seconds: u64, + nanoseconds: u32, + } + + /// Read the current value of the clock. + /// + /// This clock is not monotonic, therefore calling this function repeatedly + /// will not necessarily produce a sequence of non-decreasing values. + /// + /// The returned timestamps represent the number of seconds since + /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch], + /// also known as [Unix Time]. + /// + /// The nanoseconds field of the output is always less than 1000000000. + /// + /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16 + /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time + @since(version = 0.2.0) + now: func() -> datetime; + + /// Query the resolution of the clock. + /// + /// The nanoseconds field of the output is always less than 1000000000. + @since(version = 0.2.0) + resolution: func() -> datetime; +} diff --git a/test-components/low-level-agent/wit/deps/clocks/world.wit b/test-components/low-level-agent/wit/deps/clocks/world.wit new file mode 100644 index 0000000000..05f04f797d --- /dev/null +++ b/test-components/low-level-agent/wit/deps/clocks/world.wit @@ -0,0 +1,11 @@ +package wasi:clocks@0.2.3; + +@since(version = 0.2.0) +world imports { + @since(version = 0.2.0) + import monotonic-clock; + @since(version = 0.2.0) + import wall-clock; + @unstable(feature = clocks-timezone) + import timezone; +} diff --git a/test-components/low-level-agent/wit/deps/config/store.wit b/test-components/low-level-agent/wit/deps/config/store.wit new file mode 100644 index 0000000000..794379a754 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/config/store.wit @@ -0,0 +1,30 @@ +interface store { + /// An error type that encapsulates the different errors that can occur fetching configuration values. + variant error { + /// This indicates an error from an "upstream" config source. + /// As this could be almost _anything_ (such as Vault, Kubernetes ConfigMaps, KeyValue buckets, etc), + /// the error message is a string. + upstream(string), + /// This indicates an error from an I/O operation. + /// As this could be almost _anything_ (such as a file read, network connection, etc), + /// the error message is a string. + /// Depending on how this ends up being consumed, + /// we may consider moving this to use the `wasi:io/error` type instead. + /// For simplicity right now in supporting multiple implementations, it is being left as a string. + io(string), + } + + /// Gets a configuration value of type `string` associated with the `key`. + /// + /// The value is returned as an `option`. If the key is not found, + /// `Ok(none)` is returned. If an error occurs, an `Err(error)` is returned. + get: func( + /// A string key to fetch + key: string + ) -> result, error>; + + /// Gets a list of configuration key-value pairs of type `string`. + /// + /// If an error occurs, an `Err(error)` is returned. + get-all: func() -> result>, error>; +} diff --git a/test-components/low-level-agent/wit/deps/config/world.wit b/test-components/low-level-agent/wit/deps/config/world.wit new file mode 100644 index 0000000000..f92f080a57 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/config/world.wit @@ -0,0 +1,6 @@ +package wasi:config@0.2.0-draft; + +world imports { + /// The interface for wasi:config/store + import store; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/filesystem/preopens.wit b/test-components/low-level-agent/wit/deps/filesystem/preopens.wit new file mode 100644 index 0000000000..cea97495b5 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/filesystem/preopens.wit @@ -0,0 +1,11 @@ +package wasi:filesystem@0.2.3; + +@since(version = 0.2.0) +interface preopens { + @since(version = 0.2.0) + use types.{descriptor}; + + /// Return the set of preopened directories, and their paths. + @since(version = 0.2.0) + get-directories: func() -> list>; +} diff --git a/test-components/low-level-agent/wit/deps/filesystem/types.wit b/test-components/low-level-agent/wit/deps/filesystem/types.wit new file mode 100644 index 0000000000..d229a21f48 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/filesystem/types.wit @@ -0,0 +1,672 @@ +package wasi:filesystem@0.2.3; +/// WASI filesystem is a filesystem API primarily intended to let users run WASI +/// programs that access their files on their existing filesystems, without +/// significant overhead. +/// +/// It is intended to be roughly portable between Unix-family platforms and +/// Windows, though it does not hide many of the major differences. +/// +/// Paths are passed as interface-type `string`s, meaning they must consist of +/// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain +/// paths which are not accessible by this API. +/// +/// The directory separator in WASI is always the forward-slash (`/`). +/// +/// All paths in WASI are relative paths, and are interpreted relative to a +/// `descriptor` referring to a base directory. If a `path` argument to any WASI +/// function starts with `/`, or if any step of resolving a `path`, including +/// `..` and symbolic link steps, reaches a directory outside of the base +/// directory, or reaches a symlink to an absolute or rooted path in the +/// underlying filesystem, the function fails with `error-code::not-permitted`. +/// +/// For more information about WASI path resolution and sandboxing, see +/// [WASI filesystem path resolution]. +/// +/// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md +@since(version = 0.2.0) +interface types { + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream, output-stream, error}; + @since(version = 0.2.0) + use wasi:clocks/wall-clock@0.2.3.{datetime}; + + /// File size or length of a region within a file. + @since(version = 0.2.0) + type filesize = u64; + + /// The type of a filesystem object referenced by a descriptor. + /// + /// Note: This was called `filetype` in earlier versions of WASI. + @since(version = 0.2.0) + enum descriptor-type { + /// The type of the descriptor or file is unknown or is different from + /// any of the other types specified. + unknown, + /// The descriptor refers to a block device inode. + block-device, + /// The descriptor refers to a character device inode. + character-device, + /// The descriptor refers to a directory inode. + directory, + /// The descriptor refers to a named pipe. + fifo, + /// The file refers to a symbolic link inode. + symbolic-link, + /// The descriptor refers to a regular file inode. + regular-file, + /// The descriptor refers to a socket. + socket, + } + + /// Descriptor flags. + /// + /// Note: This was called `fdflags` in earlier versions of WASI. + @since(version = 0.2.0) + flags descriptor-flags { + /// Read mode: Data can be read. + read, + /// Write mode: Data can be written to. + write, + /// Request that writes be performed according to synchronized I/O file + /// integrity completion. The data stored in the file and the file's + /// metadata are synchronized. This is similar to `O_SYNC` in POSIX. + /// + /// The precise semantics of this operation have not yet been defined for + /// WASI. At this time, it should be interpreted as a request, and not a + /// requirement. + file-integrity-sync, + /// Request that writes be performed according to synchronized I/O data + /// integrity completion. Only the data stored in the file is + /// synchronized. This is similar to `O_DSYNC` in POSIX. + /// + /// The precise semantics of this operation have not yet been defined for + /// WASI. At this time, it should be interpreted as a request, and not a + /// requirement. + data-integrity-sync, + /// Requests that reads be performed at the same level of integrity + /// requested for writes. This is similar to `O_RSYNC` in POSIX. + /// + /// The precise semantics of this operation have not yet been defined for + /// WASI. At this time, it should be interpreted as a request, and not a + /// requirement. + requested-write-sync, + /// Mutating directories mode: Directory contents may be mutated. + /// + /// When this flag is unset on a descriptor, operations using the + /// descriptor which would create, rename, delete, modify the data or + /// metadata of filesystem objects, or obtain another handle which + /// would permit any of those, shall fail with `error-code::read-only` if + /// they would otherwise succeed. + /// + /// This may only be set on directories. + mutate-directory, + } + + /// File attributes. + /// + /// Note: This was called `filestat` in earlier versions of WASI. + @since(version = 0.2.0) + record descriptor-stat { + /// File type. + %type: descriptor-type, + /// Number of hard links to the file. + link-count: link-count, + /// For regular files, the file size in bytes. For symbolic links, the + /// length in bytes of the pathname contained in the symbolic link. + size: filesize, + /// Last data access timestamp. + /// + /// If the `option` is none, the platform doesn't maintain an access + /// timestamp for this file. + data-access-timestamp: option, + /// Last data modification timestamp. + /// + /// If the `option` is none, the platform doesn't maintain a + /// modification timestamp for this file. + data-modification-timestamp: option, + /// Last file status-change timestamp. + /// + /// If the `option` is none, the platform doesn't maintain a + /// status-change timestamp for this file. + status-change-timestamp: option, + } + + /// Flags determining the method of how paths are resolved. + @since(version = 0.2.0) + flags path-flags { + /// As long as the resolved path corresponds to a symbolic link, it is + /// expanded. + symlink-follow, + } + + /// Open flags used by `open-at`. + @since(version = 0.2.0) + flags open-flags { + /// Create file if it does not exist, similar to `O_CREAT` in POSIX. + create, + /// Fail if not a directory, similar to `O_DIRECTORY` in POSIX. + directory, + /// Fail if file already exists, similar to `O_EXCL` in POSIX. + exclusive, + /// Truncate file to size 0, similar to `O_TRUNC` in POSIX. + truncate, + } + + /// Number of hard links to an inode. + @since(version = 0.2.0) + type link-count = u64; + + /// When setting a timestamp, this gives the value to set it to. + @since(version = 0.2.0) + variant new-timestamp { + /// Leave the timestamp set to its previous value. + no-change, + /// Set the timestamp to the current time of the system clock associated + /// with the filesystem. + now, + /// Set the timestamp to the given value. + timestamp(datetime), + } + + /// A directory entry. + record directory-entry { + /// The type of the file referred to by this directory entry. + %type: descriptor-type, + + /// The name of the object. + name: string, + } + + /// Error codes returned by functions, similar to `errno` in POSIX. + /// Not all of these error codes are returned by the functions provided by this + /// API; some are used in higher-level library layers, and others are provided + /// merely for alignment with POSIX. + enum error-code { + /// Permission denied, similar to `EACCES` in POSIX. + access, + /// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX. + would-block, + /// Connection already in progress, similar to `EALREADY` in POSIX. + already, + /// Bad descriptor, similar to `EBADF` in POSIX. + bad-descriptor, + /// Device or resource busy, similar to `EBUSY` in POSIX. + busy, + /// Resource deadlock would occur, similar to `EDEADLK` in POSIX. + deadlock, + /// Storage quota exceeded, similar to `EDQUOT` in POSIX. + quota, + /// File exists, similar to `EEXIST` in POSIX. + exist, + /// File too large, similar to `EFBIG` in POSIX. + file-too-large, + /// Illegal byte sequence, similar to `EILSEQ` in POSIX. + illegal-byte-sequence, + /// Operation in progress, similar to `EINPROGRESS` in POSIX. + in-progress, + /// Interrupted function, similar to `EINTR` in POSIX. + interrupted, + /// Invalid argument, similar to `EINVAL` in POSIX. + invalid, + /// I/O error, similar to `EIO` in POSIX. + io, + /// Is a directory, similar to `EISDIR` in POSIX. + is-directory, + /// Too many levels of symbolic links, similar to `ELOOP` in POSIX. + loop, + /// Too many links, similar to `EMLINK` in POSIX. + too-many-links, + /// Message too large, similar to `EMSGSIZE` in POSIX. + message-size, + /// Filename too long, similar to `ENAMETOOLONG` in POSIX. + name-too-long, + /// No such device, similar to `ENODEV` in POSIX. + no-device, + /// No such file or directory, similar to `ENOENT` in POSIX. + no-entry, + /// No locks available, similar to `ENOLCK` in POSIX. + no-lock, + /// Not enough space, similar to `ENOMEM` in POSIX. + insufficient-memory, + /// No space left on device, similar to `ENOSPC` in POSIX. + insufficient-space, + /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX. + not-directory, + /// Directory not empty, similar to `ENOTEMPTY` in POSIX. + not-empty, + /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX. + not-recoverable, + /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX. + unsupported, + /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX. + no-tty, + /// No such device or address, similar to `ENXIO` in POSIX. + no-such-device, + /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX. + overflow, + /// Operation not permitted, similar to `EPERM` in POSIX. + not-permitted, + /// Broken pipe, similar to `EPIPE` in POSIX. + pipe, + /// Read-only file system, similar to `EROFS` in POSIX. + read-only, + /// Invalid seek, similar to `ESPIPE` in POSIX. + invalid-seek, + /// Text file busy, similar to `ETXTBSY` in POSIX. + text-file-busy, + /// Cross-device link, similar to `EXDEV` in POSIX. + cross-device, + } + + /// File or memory access pattern advisory information. + @since(version = 0.2.0) + enum advice { + /// The application has no advice to give on its behavior with respect + /// to the specified data. + normal, + /// The application expects to access the specified data sequentially + /// from lower offsets to higher offsets. + sequential, + /// The application expects to access the specified data in a random + /// order. + random, + /// The application expects to access the specified data in the near + /// future. + will-need, + /// The application expects that it will not access the specified data + /// in the near future. + dont-need, + /// The application expects to access the specified data once and then + /// not reuse it thereafter. + no-reuse, + } + + /// A 128-bit hash value, split into parts because wasm doesn't have a + /// 128-bit integer type. + @since(version = 0.2.0) + record metadata-hash-value { + /// 64 bits of a 128-bit hash value. + lower: u64, + /// Another 64 bits of a 128-bit hash value. + upper: u64, + } + + /// A descriptor is a reference to a filesystem object, which may be a file, + /// directory, named pipe, special file, or other object on which filesystem + /// calls may be made. + @since(version = 0.2.0) + resource descriptor { + /// Return a stream for reading from a file, if available. + /// + /// May fail with an error-code describing why the file cannot be read. + /// + /// Multiple read, write, and append streams may be active on the same open + /// file and they do not interfere with each other. + /// + /// Note: This allows using `read-stream`, which is similar to `read` in POSIX. + @since(version = 0.2.0) + read-via-stream: func( + /// The offset within the file at which to start reading. + offset: filesize, + ) -> result; + + /// Return a stream for writing to a file, if available. + /// + /// May fail with an error-code describing why the file cannot be written. + /// + /// Note: This allows using `write-stream`, which is similar to `write` in + /// POSIX. + @since(version = 0.2.0) + write-via-stream: func( + /// The offset within the file at which to start writing. + offset: filesize, + ) -> result; + + /// Return a stream for appending to a file, if available. + /// + /// May fail with an error-code describing why the file cannot be appended. + /// + /// Note: This allows using `write-stream`, which is similar to `write` with + /// `O_APPEND` in POSIX. + @since(version = 0.2.0) + append-via-stream: func() -> result; + + /// Provide file advisory information on a descriptor. + /// + /// This is similar to `posix_fadvise` in POSIX. + @since(version = 0.2.0) + advise: func( + /// The offset within the file to which the advisory applies. + offset: filesize, + /// The length of the region to which the advisory applies. + length: filesize, + /// The advice. + advice: advice + ) -> result<_, error-code>; + + /// Synchronize the data of a file to disk. + /// + /// This function succeeds with no effect if the file descriptor is not + /// opened for writing. + /// + /// Note: This is similar to `fdatasync` in POSIX. + @since(version = 0.2.0) + sync-data: func() -> result<_, error-code>; + + /// Get flags associated with a descriptor. + /// + /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX. + /// + /// Note: This returns the value that was the `fs_flags` value returned + /// from `fdstat_get` in earlier versions of WASI. + @since(version = 0.2.0) + get-flags: func() -> result; + + /// Get the dynamic type of a descriptor. + /// + /// Note: This returns the same value as the `type` field of the `fd-stat` + /// returned by `stat`, `stat-at` and similar. + /// + /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided + /// by `fstat` in POSIX. + /// + /// Note: This returns the value that was the `fs_filetype` value returned + /// from `fdstat_get` in earlier versions of WASI. + @since(version = 0.2.0) + get-type: func() -> result; + + /// Adjust the size of an open file. If this increases the file's size, the + /// extra bytes are filled with zeros. + /// + /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI. + @since(version = 0.2.0) + set-size: func(size: filesize) -> result<_, error-code>; + + /// Adjust the timestamps of an open file or directory. + /// + /// Note: This is similar to `futimens` in POSIX. + /// + /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI. + @since(version = 0.2.0) + set-times: func( + /// The desired values of the data access timestamp. + data-access-timestamp: new-timestamp, + /// The desired values of the data modification timestamp. + data-modification-timestamp: new-timestamp, + ) -> result<_, error-code>; + + /// Read from a descriptor, without using and updating the descriptor's offset. + /// + /// This function returns a list of bytes containing the data that was + /// read, along with a bool which, when true, indicates that the end of the + /// file was reached. The returned list will contain up to `length` bytes; it + /// may return fewer than requested, if the end of the file is reached or + /// if the I/O operation is interrupted. + /// + /// In the future, this may change to return a `stream`. + /// + /// Note: This is similar to `pread` in POSIX. + @since(version = 0.2.0) + read: func( + /// The maximum number of bytes to read. + length: filesize, + /// The offset within the file at which to read. + offset: filesize, + ) -> result, bool>, error-code>; + + /// Write to a descriptor, without using and updating the descriptor's offset. + /// + /// It is valid to write past the end of a file; the file is extended to the + /// extent of the write, with bytes between the previous end and the start of + /// the write set to zero. + /// + /// In the future, this may change to take a `stream`. + /// + /// Note: This is similar to `pwrite` in POSIX. + @since(version = 0.2.0) + write: func( + /// Data to write + buffer: list, + /// The offset within the file at which to write. + offset: filesize, + ) -> result; + + /// Read directory entries from a directory. + /// + /// On filesystems where directories contain entries referring to themselves + /// and their parents, often named `.` and `..` respectively, these entries + /// are omitted. + /// + /// This always returns a new stream which starts at the beginning of the + /// directory. Multiple streams may be active on the same directory, and they + /// do not interfere with each other. + @since(version = 0.2.0) + read-directory: func() -> result; + + /// Synchronize the data and metadata of a file to disk. + /// + /// This function succeeds with no effect if the file descriptor is not + /// opened for writing. + /// + /// Note: This is similar to `fsync` in POSIX. + @since(version = 0.2.0) + sync: func() -> result<_, error-code>; + + /// Create a directory. + /// + /// Note: This is similar to `mkdirat` in POSIX. + @since(version = 0.2.0) + create-directory-at: func( + /// The relative path at which to create the directory. + path: string, + ) -> result<_, error-code>; + + /// Return the attributes of an open file or directory. + /// + /// Note: This is similar to `fstat` in POSIX, except that it does not return + /// device and inode information. For testing whether two descriptors refer to + /// the same underlying filesystem object, use `is-same-object`. To obtain + /// additional data that can be used do determine whether a file has been + /// modified, use `metadata-hash`. + /// + /// Note: This was called `fd_filestat_get` in earlier versions of WASI. + @since(version = 0.2.0) + stat: func() -> result; + + /// Return the attributes of a file or directory. + /// + /// Note: This is similar to `fstatat` in POSIX, except that it does not + /// return device and inode information. See the `stat` description for a + /// discussion of alternatives. + /// + /// Note: This was called `path_filestat_get` in earlier versions of WASI. + @since(version = 0.2.0) + stat-at: func( + /// Flags determining the method of how the path is resolved. + path-flags: path-flags, + /// The relative path of the file or directory to inspect. + path: string, + ) -> result; + + /// Adjust the timestamps of a file or directory. + /// + /// Note: This is similar to `utimensat` in POSIX. + /// + /// Note: This was called `path_filestat_set_times` in earlier versions of + /// WASI. + @since(version = 0.2.0) + set-times-at: func( + /// Flags determining the method of how the path is resolved. + path-flags: path-flags, + /// The relative path of the file or directory to operate on. + path: string, + /// The desired values of the data access timestamp. + data-access-timestamp: new-timestamp, + /// The desired values of the data modification timestamp. + data-modification-timestamp: new-timestamp, + ) -> result<_, error-code>; + + /// Create a hard link. + /// + /// Note: This is similar to `linkat` in POSIX. + @since(version = 0.2.0) + link-at: func( + /// Flags determining the method of how the path is resolved. + old-path-flags: path-flags, + /// The relative source path from which to link. + old-path: string, + /// The base directory for `new-path`. + new-descriptor: borrow, + /// The relative destination path at which to create the hard link. + new-path: string, + ) -> result<_, error-code>; + + /// Open a file or directory. + /// + /// If `flags` contains `descriptor-flags::mutate-directory`, and the base + /// descriptor doesn't have `descriptor-flags::mutate-directory` set, + /// `open-at` fails with `error-code::read-only`. + /// + /// If `flags` contains `write` or `mutate-directory`, or `open-flags` + /// contains `truncate` or `create`, and the base descriptor doesn't have + /// `descriptor-flags::mutate-directory` set, `open-at` fails with + /// `error-code::read-only`. + /// + /// Note: This is similar to `openat` in POSIX. + @since(version = 0.2.0) + open-at: func( + /// Flags determining the method of how the path is resolved. + path-flags: path-flags, + /// The relative path of the object to open. + path: string, + /// The method by which to open the file. + open-flags: open-flags, + /// Flags to use for the resulting descriptor. + %flags: descriptor-flags, + ) -> result; + + /// Read the contents of a symbolic link. + /// + /// If the contents contain an absolute or rooted path in the underlying + /// filesystem, this function fails with `error-code::not-permitted`. + /// + /// Note: This is similar to `readlinkat` in POSIX. + @since(version = 0.2.0) + readlink-at: func( + /// The relative path of the symbolic link from which to read. + path: string, + ) -> result; + + /// Remove a directory. + /// + /// Return `error-code::not-empty` if the directory is not empty. + /// + /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX. + @since(version = 0.2.0) + remove-directory-at: func( + /// The relative path to a directory to remove. + path: string, + ) -> result<_, error-code>; + + /// Rename a filesystem object. + /// + /// Note: This is similar to `renameat` in POSIX. + @since(version = 0.2.0) + rename-at: func( + /// The relative source path of the file or directory to rename. + old-path: string, + /// The base directory for `new-path`. + new-descriptor: borrow, + /// The relative destination path to which to rename the file or directory. + new-path: string, + ) -> result<_, error-code>; + + /// Create a symbolic link (also known as a "symlink"). + /// + /// If `old-path` starts with `/`, the function fails with + /// `error-code::not-permitted`. + /// + /// Note: This is similar to `symlinkat` in POSIX. + @since(version = 0.2.0) + symlink-at: func( + /// The contents of the symbolic link. + old-path: string, + /// The relative destination path at which to create the symbolic link. + new-path: string, + ) -> result<_, error-code>; + + /// Unlink a filesystem object that is not a directory. + /// + /// Return `error-code::is-directory` if the path refers to a directory. + /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX. + @since(version = 0.2.0) + unlink-file-at: func( + /// The relative path to a file to unlink. + path: string, + ) -> result<_, error-code>; + + /// Test whether two descriptors refer to the same filesystem object. + /// + /// In POSIX, this corresponds to testing whether the two descriptors have the + /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers. + /// wasi-filesystem does not expose device and inode numbers, so this function + /// may be used instead. + @since(version = 0.2.0) + is-same-object: func(other: borrow) -> bool; + + /// Return a hash of the metadata associated with a filesystem object referred + /// to by a descriptor. + /// + /// This returns a hash of the last-modification timestamp and file size, and + /// may also include the inode number, device number, birth timestamp, and + /// other metadata fields that may change when the file is modified or + /// replaced. It may also include a secret value chosen by the + /// implementation and not otherwise exposed. + /// + /// Implementations are encouraged to provide the following properties: + /// + /// - If the file is not modified or replaced, the computed hash value should + /// usually not change. + /// - If the object is modified or replaced, the computed hash value should + /// usually change. + /// - The inputs to the hash should not be easily computable from the + /// computed hash. + /// + /// However, none of these is required. + @since(version = 0.2.0) + metadata-hash: func() -> result; + + /// Return a hash of the metadata associated with a filesystem object referred + /// to by a directory descriptor and a relative path. + /// + /// This performs the same hash computation as `metadata-hash`. + @since(version = 0.2.0) + metadata-hash-at: func( + /// Flags determining the method of how the path is resolved. + path-flags: path-flags, + /// The relative path of the file or directory to inspect. + path: string, + ) -> result; + } + + /// A stream of directory entries. + @since(version = 0.2.0) + resource directory-entry-stream { + /// Read a single directory entry from a `directory-entry-stream`. + @since(version = 0.2.0) + read-directory-entry: func() -> result, error-code>; + } + + /// Attempts to extract a filesystem-related `error-code` from the stream + /// `error` provided. + /// + /// Stream operations which return `stream-error::last-operation-failed` + /// have a payload with more information about the operation that failed. + /// This payload can be passed through to this function to see if there's + /// filesystem-related information about the error to return. + /// + /// Note that this function is fallible because not all stream-related + /// errors are filesystem-related errors. + @since(version = 0.2.0) + filesystem-error-code: func(err: borrow) -> option; +} diff --git a/test-components/low-level-agent/wit/deps/filesystem/world.wit b/test-components/low-level-agent/wit/deps/filesystem/world.wit new file mode 100644 index 0000000000..29405bc2cc --- /dev/null +++ b/test-components/low-level-agent/wit/deps/filesystem/world.wit @@ -0,0 +1,9 @@ +package wasi:filesystem@0.2.3; + +@since(version = 0.2.0) +world imports { + @since(version = 0.2.0) + import types; + @since(version = 0.2.0) + import preopens; +} diff --git a/test-components/low-level-agent/wit/deps/golem-1.x/golem-context.wit b/test-components/low-level-agent/wit/deps/golem-1.x/golem-context.wit new file mode 100644 index 0000000000..54f1484c35 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-1.x/golem-context.wit @@ -0,0 +1,93 @@ +package golem:api@1.1.7; + +/// Invocation context support +interface context { + use wasi:clocks/wall-clock@0.2.3.{datetime}; + + /// Starts a new `span` with the given name, as a child of the current invocation context + start-span: func(name: string) -> span; + + /// Gets the current invocation context + /// + /// The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not + /// reflect that. + current-context: func() -> invocation-context; + + /// Allows or disallows forwarding of trace context headers in outgoing HTTP requests + /// + /// Returns the previous value of the setting + allow-forwarding-trace-context-headers: func(allow: bool) -> bool; + + /// Represents a unit of work or operation + resource span { + /// Gets the starting time of the span + started-at: func() -> datetime; + + /// Set an attribute on the span + set-attribute: func(name: string, value: attribute-value); + + /// Set multiple attributes on the span + set-attributes: func(attributes: list); + + /// Early finishes the span; otherwise it will be finished when the resource is dropped + finish: func(); + } + + /// Represents an invocation context wich allows querying the stack of attributes + /// created by automatic and user-defined spans. + resource invocation-context { + /// Gets the current trace id + trace-id: func() -> trace-id; + + /// Gets the current span id + span-id: func() -> span-id; + + /// Gets the parent context, if any; allows recursive processing of the invocation context. + /// + /// Alternatively, the attribute query methods can return inherited values without having to + /// traverse the stack manually. + parent: func() -> option; + + /// Gets the value of an attribute `key`. If `inherited` is true, the value is searched in the stack of spans, + /// otherwise only in the current span. + get-attribute: func(key: string, inherited: bool) -> option; + + /// Gets all attributes of the current invocation context. If `inherited` is true, it returns the merged set of attributes, each + /// key associated with the latest value found in the stack of spans. + get-attributes: func(inherited: bool) -> list; + + /// Gets the chain of attribute values associated with the given `key`. If the key does not exist in any of the + /// spans in the invocation context, the list is empty. The chain's first element contains the most recent (innermost) value. + get-attribute-chain: func(key: string) -> list; + + /// Gets all values of all attributes of the current invocation context. + get-attribute-chains: func() -> list; + + /// Gets the W3C Trace Context headers associated with the current invocation context + trace-context-headers: func() -> list>; + } + + /// An attribute of a span + record attribute { + key: string, + value: attribute-value + } + + /// A chain of attribute values, the first element representing the most recent value + record attribute-chain { + key: string, + values: list + } + + /// Possible span attribute value types + variant attribute-value { + /// A string value + %string(string) + } + + /// The trace represented by a 16 bytes hexadecimal string + type trace-id = string; + + /// The span represented by a 8 bytes hexadecimal string + type span-id = string; +} diff --git a/test-components/low-level-agent/wit/deps/golem-1.x/golem-host.wit b/test-components/low-level-agent/wit/deps/golem-1.x/golem-host.wit new file mode 100644 index 0000000000..80cbe329a0 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-1.x/golem-host.wit @@ -0,0 +1,306 @@ +package golem:api@1.1.7; + +/// The Golem host API provides low level access to Golem specific features such as promises and control over +/// the durability and transactional guarantees the executor provides. +interface host { + use wasi:clocks/monotonic-clock@0.2.3.{duration}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; + + /// An index into the persistent log storing all performed operations of a worker + type oplog-index = u64; + + /// A promise ID is a value that can be passed to an external Golem API to complete that promise + /// from an arbitrary external source, while Golem workers can await for this completion. + record promise-id { + worker-id: worker-id, + oplog-idx: oplog-index, + } + + /// Represents a Golem component's version + type component-version = u64; + + /// Represents a Golem Cloud account + record account-id { + value: string + } + + /// Represents a Golem project + record project-id { + uuid: uuid, + } + + /// Configures how the executor retries failures + record retry-policy { + /// The maximum number of retries before the worker becomes permanently failed + max-attempts: u32, + /// The minimum delay between retries (applied to the first retry) + min-delay: duration, + /// The maximum delay between retries + max-delay: duration, + /// Multiplier applied to the delay on each retry to implement exponential backoff + multiplier: f64, + /// The maximum amount of jitter to add to the delay + max-jitter-factor: option + } + + /// Configurable persistence level for workers + variant persistence-level { + persist-nothing, + persist-remote-side-effects, + smart + } + + /// Describes how to update a worker to a different component version + enum update-mode { + /// Automatic update tries to recover the worker using the new component version + /// and may fail if there is a divergence. + automatic, + + /// Manual, snapshot-based update uses a user-defined implementation of the `save-snapshot` interface + /// to store the worker's state, and a user-defined implementation of the `load-snapshot` interface to + /// load it into the new version. + snapshot-based + } + + enum filter-comparator { + equal, + not-equal, + greater-equal, + greater, + less-equal, + less + } + + enum string-filter-comparator { + equal, + not-equal, + like, + not-like + } + + enum worker-status { + /// The worker is running an invoked function + running, + /// The worker is ready to run an invoked function + idle, + /// An invocation is active but waiting for something (sleeping, waiting for a promise) + suspended, + /// The last invocation was interrupted but will be resumed + interrupted, + /// The last invocation failed and a retry was scheduled + retrying, + /// The last invocation failed and the worker can no longer be used + failed, + /// The worker exited after a successful invocation and can no longer be invoked + exited, + } + + record worker-name-filter { + comparator: string-filter-comparator, + value: string + } + + record worker-status-filter { + comparator: filter-comparator, + value: worker-status + } + + record worker-version-filter { + comparator: filter-comparator, + value: u64 + } + + record worker-created-at-filter { + comparator: filter-comparator, + value: u64 + } + + record worker-env-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + + variant worker-property-filter { + name(worker-name-filter), + status(worker-status-filter), + version(worker-version-filter), + created-at(worker-created-at-filter), + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) + } + + record worker-all-filter { + filters: list + } + + record worker-any-filter { + filters: list + } + + record worker-metadata { + worker-id: worker-id, + args: list, + env: list>, + wasi-config-vars: list>, + status: worker-status, + component-version: u64, + retry-count: u64 + } + + resource get-workers { + constructor(component-id: component-id, filter: option, precise: bool); + + get-next: func() -> option>; + } + + /// Target parameter for the `revert-worker` operation + variant revert-worker-target { + /// Revert to a specific oplog index. The given index will be the last one to be kept. + revert-to-oplog-index(oplog-index), + /// Revert the last N invocations. + revert-last-invocations(u64) + } + + /// Indicates which worker the code is running on after `fork` + enum fork-result { + /// The original worker that called `fork` + original, + /// The new worker + forked + } + + /// Create a new promise + create-promise: func() -> promise-id; + + /// Suspends execution until the given promise gets completed, and returns the payload passed to + /// the promise completion. + await-promise: func(promise-id: promise-id) -> list; + + /// Checks whether the given promise is completed. If not, it returns None. If the promise is completed, + /// it returns the payload passed to the promise completion. + poll-promise: func(promise-id: promise-id) -> option>; + + /// Completes the given promise with the given payload. Returns true if the promise was completed, false + /// if the promise was already completed. The payload is passed to the worker that is awaiting the promise. + complete-promise: func(promise-id: promise-id, data: list) -> bool; + + /// Deletes the given promise + delete-promise: func(promise-id: promise-id); + + /// Returns the current position in the persistent op log + get-oplog-index: func() -> oplog-index; + + /// Makes the current worker travel back in time and continue execution from the given position in the persistent + /// op log. + set-oplog-index: func(oplog-idx: oplog-index); + + /// Blocks the execution until the oplog has been written to at least the specified number of replicas, + /// or the maximum number of replicas if the requested number is higher. + oplog-commit: func(replicas: u8); + + /// Marks the beginning of an atomic operation. + /// In case of a failure within the region selected by `mark-begin-operation` and `mark-end-operation` + /// the whole region will be reexecuted on retry. + /// The end of the region is when `mark-end-operation` is called with the returned oplog-index. + mark-begin-operation: func() -> oplog-index; + + /// Commits this atomic operation. After `mark-end-operation` is called for a given index, further calls + /// with the same parameter will do nothing. + mark-end-operation: func(begin: oplog-index); + + /// Gets the current retry policy associated with the worker + get-retry-policy: func() -> retry-policy; + + /// Overrides the current retry policy associated with the worker. Following this call, `get-retry-policy` will return the + /// new retry policy. + set-retry-policy: func(new-retry-policy: retry-policy); + + /// Gets the worker's current persistence level. + get-oplog-persistence-level: func() -> persistence-level; + + /// Sets the worker's current persistence level. This can increase the performance of execution in cases where durable + /// execution is not required. + set-oplog-persistence-level: func(new-persistence-level: persistence-level); + + /// Gets the current idempotence mode. See `set-idempotence-mode` for details. + get-idempotence-mode: func() -> bool; + + /// Sets the current idempotence mode. The default is true. + /// True means side-effects are treated idempotent and Golem guarantees at-least-once semantics. + /// In case of false the executor provides at-most-once semantics, failing the worker in case it is + /// not known if the side effect was already executed. + set-idempotence-mode: func(idempotent: bool); + + /// Generates an idempotency key. This operation will never be replayed — + /// i.e. not only is this key generated, but it is persisted and committed, such that the key can be used in third-party systems (e.g. payment processing) + /// to introduce idempotence. + generate-idempotency-key: func() -> uuid; + + /// Initiates an update attempt for the given worker. The function returns immediately once the request has been processed, + /// not waiting for the worker to get updated. + update-worker: func(worker-id: worker-id, target-version: component-version, mode: update-mode); + + /// Get current worker metadata + get-self-metadata: func() -> worker-metadata; + + /// Get worker metadata + get-worker-metadata: func(worker-id: worker-id) -> option; + + /// Fork a worker to another worker at a given oplog index + fork-worker: func(source-worker-id: worker-id, target-worker-id: worker-id, oplog-idx-cut-off: oplog-index); + + /// Revert a worker to a previous state + revert-worker: func(worker-id: worker-id, revert-target: revert-worker-target); + + /// Get the component-id for a given component reference. + /// Returns none when no component with the specified reference exists. + /// The syntax of the component reference is implementation dependent. + /// + /// Golem OSS: "{component_name}" + /// Golem Cloud: + /// 1: "{component_name}" -> will resolve in current account and project + /// 2: "{project_name}/{component_name}" -> will resolve in current account + /// 3: "{account_id}/{project_name}/{component_name}" + resolve-component-id: func(component-reference: string) -> option; + + /// Get the worker-id for a given component and worker name. + /// Returns none when no component for the specified reference exists. + resolve-worker-id: func(component-reference: string, worker-name: string) -> option; + + /// Get the worker-id for a given component and worker name. + /// Returns none when no component for the specified component-reference or no worker with the specified worker-name exists. + resolve-worker-id-strict: func(component-reference: string, worker-name: string) -> option; + + /// Forks the current worker at the current execution point. The new worker gets the `new-name` worker name, + /// and this worker continues running as well. The return value is going to be different in this worker and + /// the forked worker. + fork: func(new-name: string) -> fork-result; +} + +/// Interface providing user-defined snapshotting capability. This can be used to perform manual update of workers +/// when the new component incompatible with the old one. +interface save-snapshot { + /// Saves the component's state into a user-defined snapshot + save: func() -> list; +} + +/// Interface providing user-defined snapshotting capability. This can be used to perform manual update of workers +/// when the new component incompatible with the old one. +interface load-snapshot { + /// Tries to load a user-defined snapshot, setting up the worker's state based on it. + /// The function can return with a failure to indicate that the update is not possible. + load: func(bytes: list) -> result<_, string>; +} + +world golem-host { + import host; + import save-snapshot; + import load-snapshot; +} diff --git a/test-components/low-level-agent/wit/deps/golem-1.x/golem-oplog-processor.wit b/test-components/low-level-agent/wit/deps/golem-1.x/golem-oplog-processor.wit new file mode 100644 index 0000000000..2c910fe303 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-1.x/golem-oplog-processor.wit @@ -0,0 +1,33 @@ +package golem:api@1.1.7; + +interface oplog-processor { + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use golem:rpc/types@0.2.2.{wit-value}; + + use host.{account-id, oplog-index, worker-metadata}; + use oplog.{oplog-entry}; + use golem:rpc/types@0.2.2.{component-id, worker-id}; + + record account-info { + account-id: account-id + } + + /// A processor resource is instantiated for each account having activated this oplog processor plugin. + /// There are no guarantees for the number of processors running at the same time, and different entries from the same worker + /// may be sent to different processor instances. + resource processor { + /// Initializes an oplog processor for a given component where the plugin was installed to. + /// The `account-info` parameters contains details of the account the installation belongs to. + /// The `component-id` parameter contains the identifier of the component the plugin was installed to. + /// The `config` parameter contains the configuration parameters for the plugin, as specified in the plugin installation + /// for the component. + constructor(account-info: account-info, component-id: component-id, config: list>); + + /// Called when one of the workers the plugin is activated on has written new entries to its oplog. + /// The `worker-id` parameter identifies the worker. + /// The `metadata` parameter contains the latest metadata of the worker. + /// The `first-entry-index` parameter contains the index of the first entry in the list of `entries`. + /// The `entries` parameteter always contains at least one element. + process: func(worker-id: worker-id, metadata: worker-metadata, first-entry-index: oplog-index, entries: list) -> result<_, string>; + } +} diff --git a/test-components/low-level-agent/wit/deps/golem-1.x/golem-oplog.wit b/test-components/low-level-agent/wit/deps/golem-1.x/golem-oplog.wit new file mode 100644 index 0000000000..fd06f8f001 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-1.x/golem-oplog.wit @@ -0,0 +1,341 @@ +package golem:api@1.1.7; + +/// Host interface for enumerating and searching for worker oplogs +interface oplog { + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use golem:rpc/types@0.2.2.{wit-value}; + + use host.{account-id, component-version, oplog-index, persistence-level, project-id, retry-policy, uuid, worker-id}; + use context.{attribute, attribute-value, span-id, trace-id}; + + variant wrapped-function-type { + /// The side-effect reads from the worker's local state (for example local file system, + /// random generator, etc.) + read-local, + /// The side-effect writes to the worker's local state (for example local file system) + write-local, + /// The side-effect reads from external state (for example a key-value store) + read-remote, + /// The side-effect manipulates external state (for example an RPC call) + write-remote, + /// The side-effect manipulates external state through multiple invoked functions (for example + /// a HTTP request where reading the response involves multiple host function calls) + /// + /// On the first invocation of the batch, the parameter should be `None` - this triggers + /// writing a `BeginRemoteWrite` entry in the oplog. Followup invocations should contain + /// this entry's index as the parameter. In batched remote writes it is the caller's responsibility + /// to manually write an `EndRemoteWrite` entry (using `end_function`) when the operation is completed. + write-remote-batched(option) + } + + record plugin-installation-description { + installation-id: uuid, + name: string, + version: string, + parameters: list> + } + + record create-parameters { + timestamp: datetime, + worker-id: worker-id, + component-version: component-version, + args: list, + env: list>, + created-by: account-id, + project-id: project-id, + parent: option, + component-size: u64, + initial-total-linear-memory-size: u64, + initial-active-plugins: list + } + + record imported-function-invoked-parameters { + timestamp: datetime, + function-name: string, + request: wit-value, + response: wit-value, + wrapped-function-type: wrapped-function-type, + } + + record local-span-data { + span-id: span-id, + start: datetime, + parent: option, + /// Optionally an index of the exported-function-invoked-parameters's invocation-context field + linked-context: option, + attributes: list, + inherited: bool + } + + record external-span-data { + span-id: span-id + } + + variant span-data { + local-span(local-span-data), + external-span(external-span-data) + } + + record exported-function-invoked-parameters { + timestamp: datetime, + function-name: string, + request: list, + idempotency-key: string, + trace-id: trace-id, + trace-states: list, + /// The first one is the invocation context stack associated with the exported function invocation, + /// and further stacks can be added that are referenced by the `linked-context` field of `local-span-data` + invocation-context: list> + } + + record exported-function-completed-parameters { + timestamp: datetime, + response: option, + consumed-fuel: s64 + } + + record error-parameters { + timestamp: datetime, + error: string + } + + record jump-parameters { + timestamp: datetime, + start: oplog-index, + end: oplog-index + } + + record change-retry-policy-parameters { + timestamp: datetime, + retry-policy: retry-policy + } + + record end-atomic-region-parameters { + timestamp: datetime, + begin-index: oplog-index + } + + record end-remote-write-parameters { + timestamp: datetime, + begin-index: oplog-index + } + + record exported-function-invocation-parameters { + idempotency-key: string, + function-name: string, + input: option> + } + + variant worker-invocation { + exported-function(exported-function-invocation-parameters), + manual-update(component-version) + } + + record pending-worker-invocation-parameters { + timestamp: datetime, + invocation: worker-invocation + } + + variant update-description { + /// Automatic update by replaying the oplog on the new version + auto-update, + /// Custom update by loading a given snapshot on the new version + snapshot-based(list) + } + + record pending-update-parameters { + timestamp: datetime, + target-version: component-version, + update-description: update-description + } + + record successful-update-parameters { + timestamp: datetime, + target-version: component-version, + new-component-size: u64, + new-active-plugins: list + } + + record failed-update-parameters { + timestamp: datetime, + target-version: component-version, + details: option + } + + record grow-memory-parameters { + timestamp: datetime, + delta: u64 + } + + type worker-resource-id = u64; + + record create-resource-parameters { + timestamp: datetime, + resource-id: worker-resource-id + } + + record drop-resource-parameters { + timestamp: datetime, + resource-id: worker-resource-id + } + + record describe-resource-parameters { + timestamp: datetime, + resource-id: worker-resource-id, + resource-name: string, + resource-params: list + } + + enum log-level { + stdout, + stderr, + trace, + debug, + info, + warn, + error, + critical + } + + record log-parameters { + timestamp: datetime, + level: log-level, + context: string, + message: string + } + + record activate-plugin-parameters { + timestamp: datetime, + plugin: plugin-installation-description + } + + record deactivate-plugin-parameters { + timestamp: datetime, + plugin: plugin-installation-description + } + + record revert-parameters { + timestamp: datetime, + start: oplog-index, + end: oplog-index + } + + record cancel-invocation-parameters { + timestamp: datetime, + idempotency-key: string + } + + record start-span-parameters { + timestamp: datetime, + span-id: span-id, + parent: option, + linked-context: option, + attributes: list, + } + + record finish-span-parameters { + timestamp: datetime, + span-id: span-id + } + + record set-span-attribute-parameters { + timestamp: datetime, + span-id: span-id, + key: string, + value: attribute-value + } + + record change-persistence-level-parameters { + timestamp: datetime, + persistence-level: persistence-level + } + + variant oplog-entry { + /// The initial worker oplog entry + create(create-parameters), + /// The worker invoked a host function + imported-function-invoked(imported-function-invoked-parameters), + /// The worker has been invoked + exported-function-invoked(exported-function-invoked-parameters), + /// The worker has completed an invocation + exported-function-completed(exported-function-completed-parameters), + /// Worker suspended + suspend(datetime), + /// Worker failed + error(error-parameters), + /// Marker entry added when get-oplog-index is called from the worker, to make the jumping behavior + /// more predictable. + no-op(datetime), + /// The worker needs to recover up to the given target oplog index and continue running from + /// the source oplog index from there + /// `jump` is an oplog region representing that from the end of that region we want to go back to the start and + /// ignore all recorded operations in between. + jump(jump-parameters), + /// Indicates that the worker has been interrupted at this point. + /// Only used to recompute the worker's (cached) status, has no effect on execution. + interrupted(datetime), + /// Indicates that the worker has been exited using WASI's exit function. + exited(datetime), + /// Overrides the worker's retry policy + change-retry-policy(change-retry-policy-parameters), + /// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during + /// recovery except if there is a corresponding `EndAtomicRegion` entry. + begin-atomic-region(datetime), + /// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this + /// entry are to be considered during recovery, and the begin/end markers can be removed during oplog + /// compaction. + end-atomic-region(end-atomic-region-parameters), + /// Begins a remote write operation. Only used when idempotence mode is off. In this case each + /// remote write must be surrounded by a `BeginRemoteWrite` and `EndRemoteWrite` log pair and + /// unfinished remote writes cannot be recovered. + begin-remote-write(datetime), + /// Marks the end of a remote write operation. Only used when idempotence mode is off. + end-remote-write(end-remote-write-parameters), + /// An invocation request arrived while the worker was busy + pending-worker-invocation(pending-worker-invocation-parameters), + /// An update request arrived and will be applied as soon the worker restarts + pending-update(pending-update-parameters), + /// An update was successfully applied + successful-update(successful-update-parameters), + /// An update failed to be applied + failed-update(failed-update-parameters), + /// Increased total linear memory size + grow-memory(grow-memory-parameters), + /// Created a resource instance + create-resource(create-resource-parameters), + /// Dropped a resource instance + drop-resource(drop-resource-parameters), + /// Adds additional information for a created resource instance + describe-resource(describe-resource-parameters), + /// The worker emitted a log message + log(log-parameters), + /// The worker's has been restarted, forgetting all its history + restart(datetime), + /// Activates a plugin + activate-plugin(activate-plugin-parameters), + /// Deactivates a plugin + deactivate-plugin(deactivate-plugin-parameters), + /// Revert a worker to a previous state + revert(revert-parameters), + /// Cancel a pending invocation + cancel-invocation(cancel-invocation-parameters), + /// Start a new span in the invocation context + start-span(start-span-parameters), + /// Finish an open span in the invocation context + finish-span(finish-span-parameters), + /// Set an attribute on an open span in the invocation context + set-span-attribute(set-span-attribute-parameters), + /// Change the current persistence level + change-persistence-level(change-persistence-level-parameters) + } + + resource get-oplog { + constructor(worker-id: worker-id, start: oplog-index); + get-next: func() -> option>; + } + + resource search-oplog { + constructor(worker-id: worker-id, text: string); + get-next: func() -> option>>; + } +} diff --git a/test-components/low-level-agent/wit/deps/golem-agent/common.wit b/test-components/low-level-agent/wit/deps/golem-agent/common.wit new file mode 100644 index 0000000000..4282355cb3 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-agent/common.wit @@ -0,0 +1,108 @@ +package golem:agent; + +interface common { + use golem:rpc/types@0.2.2.{value-and-type, wit-type, wit-value}; + + type url = string; + + record agent-type { + type-name: string, + description: string, + %constructor: agent-constructor, + methods: list, + dependencies: list, + } + + record agent-dependency { + type-name: string, + description: option, + %constructor: agent-constructor, + methods: list, + } + + record agent-method { + name: string, + description: string, + prompt-hint: option, + input-schema: data-schema, + output-schema: data-schema, + } + + record agent-constructor { + name: option, + description: string, + prompt-hint: option, + input-schema: data-schema, + } + + variant data-schema { + /// List of named elements + %tuple(list>), + /// List of named variants that can be used 0 or more times in a multimodal `data-value` + multimodal(list>), + } + + variant data-value { + /// List of element values, each corresponding to an element of the tuple `data-schema` + %tuple(list), + /// List of element values and their schema names; each name points to one named element of the corresponding + /// multimodal `data-schema`. + multimodal(list>), + } + + variant element-schema { + component-model(wit-type), + unstructured-text(text-descriptor), + unstructured-binary(binary-descriptor), + } + + variant element-value { + component-model(wit-value), + unstructured-text(text-reference), + unstructured-binary(binary-reference), + } + + record text-type { + language-code: string, + } + + variant text-reference { + url(string), + inline(text-source), + } + + record text-source { + data: string, + text-type: option, + } + + record text-descriptor { + restrictions: option>, + } + + record binary-descriptor { + restrictions: option>, + } + + record binary-type { + mime-type: string, + } + + variant binary-reference { + url(url), + inline(binary-source), + } + + record binary-source { + data: list, + binary-type: binary-type, + } + + variant agent-error { + invalid-input(string), + invalid-method(string), + invalid-type(string), + invalid-agent-id(string), + custom-error(value-and-type), + } +} diff --git a/test-components/low-level-agent/wit/deps/golem-agent/guest.wit b/test-components/low-level-agent/wit/deps/golem-agent/guest.wit new file mode 100644 index 0000000000..4fe6473eea --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-agent/guest.wit @@ -0,0 +1,35 @@ +package golem:agent; + +interface guest { + use common.{agent-error, agent-type, data-value}; + + resource agent { + create: static func(agent-type: string, input: data-value) -> result; + + get-id: func() -> string; + + invoke: func(method-name: string, input: data-value) -> result; + + get-definition: func() -> agent-type; + } + + get-agent: func(agent-type: string, agent-id: string) -> agent; + + /// Invokes an agent method on an agent of a given type and ID. + /// Equivalent of getting an agent with `get-agent` and calling `invoke` on that. + invoke-agent: func(agent-type: string, agent-id: string, method-name: string, input: data-value) -> result; + + discover-agents: func() -> list; + + discover-agent-types: func() -> list; +} + +world agent-guest { + import golem:api/host@1.1.7; + import golem:rpc/types@0.2.2; + export guest; +} + +world agent-host { + export host; +} diff --git a/test-components/low-level-agent/wit/deps/golem-agent/host.wit b/test-components/low-level-agent/wit/deps/golem-agent/host.wit new file mode 100644 index 0000000000..0428b5cc86 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-agent/host.wit @@ -0,0 +1,8 @@ +package golem:agent; + +interface host { + use common.{data-value}; + + register-agent: func(agent-type: string, agent-id: string, constructor-parameters: data-value); + unregister-agent: func(agent-type: string, agent-id: string, constructor-parameters: data-value); +} diff --git a/test-components/low-level-agent/wit/deps/golem-durability/golem-durability-1.2.wit b/test-components/low-level-agent/wit/deps/golem-durability/golem-durability-1.2.wit new file mode 100644 index 0000000000..b4f661d9f7 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-durability/golem-durability-1.2.wit @@ -0,0 +1,98 @@ +package golem:durability@1.2.1; + +interface durability { + use golem:api/host@1.1.7.{persistence-level}; + use golem:api/oplog@1.1.7.{oplog-index, wrapped-function-type}; + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use wasi:io/poll@0.2.3.{pollable}; + use golem:rpc/types@0.2.2.{value-and-type}; + + type durable-function-type = wrapped-function-type; + + record durable-execution-state { + is-live: bool, + persistence-level: persistence-level, + } + + enum oplog-entry-version { + v1, + v2 + } + + record persisted-durable-function-invocation { + timestamp: datetime, + function-name: string, + response: list, + function-type: durable-function-type, + entry-version: oplog-entry-version + } + + record persisted-typed-durable-function-invocation { + timestamp: datetime, + function-name: string, + response: value-and-type, + function-type: durable-function-type, + entry-version: oplog-entry-version + } + + /// Observes a function call (produces logs and metrics) + observe-function-call: func(iface: string, function: string); + + /// Marks the beginning of a durable function. + /// + /// There must be a corresponding call to `end-durable-function` after the function has + /// performed its work (it can be ended in a different context, for example after an async + /// pollable operation has been completed) + begin-durable-function: func(function-type: durable-function-type) -> oplog-index; + + /// Marks the end of a durable function + /// + /// This is a pair of `begin-durable-function` and should be called after the durable function + /// has performed and persisted or replayed its work. The `begin-index` should be the index + /// returned by `begin-durable-function`. + /// + /// Normally commit behavior is decided by the executor based on the `function-type`. However, in special + /// cases the `forced-commit` parameter can be used to force commit the oplog in an efficient way. + end-durable-function: func(function-type: durable-function-type, begin-index: oplog-index, forced-commit: bool); + + /// Gets the current durable execution state + current-durable-execution-state: func() -> durable-execution-state; + + /// Writes a record to the worker's oplog representing a durable function invocation + persist-durable-function-invocation: func( + function-name: string, + request: list, + response: list, + function-type: durable-function-type, + ); + + /// Writes a record to the worker's oplog representing a durable function invocation + /// + /// The request and response are defined as pairs of value and type, which makes it + /// self-describing for observers of oplogs. This is the recommended way to persist + /// third-party function invocations. + persist-typed-durable-function-invocation: func( + function-name: string, + request: value-and-type, + response: value-and-type, + function-type: durable-function-type, + ); + + /// Reads the next persisted durable function invocation from the oplog during replay + read-persisted-durable-function-invocation: func() -> persisted-durable-function-invocation; + + /// Reads the next persisted durable function invocation from the oplog during replay, assuming it + /// was created with `persist-typed-durable-function-invocation` + read-persisted-typed-durable-function-invocation: func() -> persisted-typed-durable-function-invocation; + + resource lazy-initialized-pollable { + /// Creates a `pollable` that is never ready until it gets attached to a real `pollable` implementation + /// using `set-lazy-initialized-pollable`. + constructor(); + + /// Sets the underlying `pollable` for a pollable created with `create-lazy-initialized-pollable`. + set: func(pollable: pollable); + + subscribe: func() -> pollable; + } +} diff --git a/test-components/low-level-agent/wit/deps/golem-rdbms/mysql.wit b/test-components/low-level-agent/wit/deps/golem-rdbms/mysql.wit new file mode 100644 index 0000000000..88ce29406d --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-rdbms/mysql.wit @@ -0,0 +1,140 @@ +package golem:rdbms@0.0.1; + +interface mysql { + use types.{date, time, timestamp}; + + variant error { + connection-failure(string), + query-parameter-failure(string), + query-execution-failure(string), + query-response-failure(string), + other(string) + } + + variant db-column-type { + boolean, + tinyint, + smallint, + mediumint, + int, + bigint, + tinyint-unsigned, + smallint-unsigned, + mediumint-unsigned, + int-unsigned, + bigint-unsigned, + float, + double, + decimal, + date, + datetime, + timestamp, + time, + year, + fixchar, + varchar, + tinytext, + text, + mediumtext, + longtext, + binary, + varbinary, + tinyblob, + blob, + mediumblob, + longblob, + enumeration, + set, + bit, + json + } + + record db-column { + ordinal: u64, + name: string, + db-type: db-column-type, + db-type-name: string + } + + /// Value descriptor for a single database value + variant db-value { + boolean(bool), + tinyint(s8), + smallint(s16), + // s24 + mediumint(s32), + int(s32), + bigint(s64), + tinyint-unsigned(u8), + smallint-unsigned(u16), + // u24 + mediumint-unsigned(u32), + int-unsigned(u32), + bigint-unsigned(u64), + float(f32), + double(f64), + decimal(string), + date(date), + datetime(timestamp), + timestamp(timestamp), + time(time), + year(u16), + fixchar(string), + varchar(string), + tinytext(string), + text(string), + mediumtext(string), + longtext(string), + binary(list), + varbinary(list), + tinyblob(list), + blob(list), + mediumblob(list), + longblob(list), + enumeration(string), + set(string), + bit(list), + json(string), + null + } + + /// A single row of values + record db-row { + values: list + } + + record db-result { + columns: list, + rows: list + } + + /// A potentially very large and lazy stream of rows: + resource db-result-stream { + get-columns: func() -> list; + get-next: func() -> option>; + } + + resource db-connection { + open: static func(address: string) -> result; + + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + begin-transaction: func() -> result; + } + + resource db-transaction { + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + commit: func() -> result<_, error>; + + rollback: func() -> result<_, error>; + } +} diff --git a/test-components/low-level-agent/wit/deps/golem-rdbms/postgres.wit b/test-components/low-level-agent/wit/deps/golem-rdbms/postgres.wit new file mode 100644 index 0000000000..58cdd98f96 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-rdbms/postgres.wit @@ -0,0 +1,281 @@ +package golem:rdbms@0.0.1; + +interface postgres { + use types.{date, time, timetz, timestamp, timestamptz, uuid, ip-address, mac-address}; + + variant error { + connection-failure(string), + query-parameter-failure(string), + query-execution-failure(string), + query-response-failure(string), + other(string) + } + + record interval { + months: s32, + days: s32, + microseconds: s64 + } + + variant int4bound { + included(s32), + excluded(s32), + unbounded + } + + variant int8bound { + included(s64), + excluded(s64), + unbounded + } + + variant numbound { + included(string), + excluded(string), + unbounded + } + + variant tsbound { + included(timestamp), + excluded(timestamp), + unbounded + } + + variant tstzbound { + included(timestamptz), + excluded(timestamptz), + unbounded + } + + variant datebound { + included(date), + excluded(date), + unbounded + } + + record int4range { + start: int4bound, + end: int4bound + } + + record int8range { + start: int8bound, + end: int8bound + } + + record numrange { + start: numbound, + end: numbound + } + + record tsrange { + start: tsbound, + end: tsbound + } + + record tstzrange { + start: tstzbound, + end: tstzbound + } + + record daterange { + start: datebound, + end: datebound + } + + record enumeration-type { + name: string + } + + record enumeration { + name: string, + value: string + } + + record composite-type { + name: string, + attributes: list> + } + + record composite { + name: string, + values: list + } + + record domain-type { + name: string, + base-type: lazy-db-column-type + } + + record domain { + name: string, + value: lazy-db-value + } + + record range-type { + name: string, + base-type: lazy-db-column-type + } + + variant value-bound { + included(lazy-db-value), + excluded(lazy-db-value), + unbounded + } + + record values-range { + start: value-bound, + end: value-bound + } + + record range { + name: string, + value: values-range + } + + variant db-column-type { + character, + int2, + int4, + int8, + float4, + float8, + numeric, + boolean, + text, + varchar, + bpchar, + timestamp, + timestamptz, + date, + time, + timetz, + interval, + bytea, + uuid, + xml, + json, + jsonb, + jsonpath, + inet, + cidr, + macaddr, + bit, + varbit, + int4range, + int8range, + numrange, + tsrange, + tstzrange, + daterange, + money, + oid, + enumeration(enumeration-type), + composite(composite-type), + domain(domain-type), + array(lazy-db-column-type), + range(range-type) + } + + variant db-value { + character(s8), + int2(s16), + int4(s32), + int8(s64), + float4(f32), + float8(f64), + numeric(string), + boolean(bool), + text(string), + varchar(string), + bpchar(string), + timestamp(timestamp), + timestamptz(timestamptz), + date(date), + time(time), + timetz(timetz), + interval(interval), + bytea(list), + json(string), + jsonb(string), + jsonpath(string), + xml(string), + uuid(uuid), + inet(ip-address), + cidr(ip-address), + macaddr(mac-address), + bit(list), + varbit(list), + int4range(int4range), + int8range(int8range), + numrange(numrange), + tsrange(tsrange), + tstzrange(tstzrange), + daterange(daterange), + money(s64), + oid(u32), + enumeration(enumeration), + composite(composite), + domain(domain), + array(list), + range(range), + null + } + + resource lazy-db-value { + constructor(value: db-value); + get: func() -> db-value; + } + + resource lazy-db-column-type { + constructor(value: db-column-type); + get: func() -> db-column-type; + } + + record db-column { + ordinal: u64, + name: string, + db-type: db-column-type, + db-type-name: string + } + + /// A single row of values + record db-row { + values: list + } + + record db-result { + columns: list, + rows: list + } + + /// A potentially very large and lazy stream of rows: + resource db-result-stream { + get-columns: func() -> list; + get-next: func() -> option>; + } + + resource db-connection { + open: static func(address: string) -> result; + + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + begin-transaction: func() -> result; + } + + resource db-transaction { + query: func(statement: string, params: list) -> result; + + query-stream: func(statement: string, params: list) -> result; + + execute: func(statement: string, params: list) -> result; + + commit: func() -> result<_, error>; + + rollback: func() -> result<_, error>; + } +} diff --git a/test-components/low-level-agent/wit/deps/golem-rdbms/types.wit b/test-components/low-level-agent/wit/deps/golem-rdbms/types.wit new file mode 100644 index 0000000000..76a8b39002 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-rdbms/types.wit @@ -0,0 +1,47 @@ +package golem:rdbms@0.0.1; + +interface types { + + record uuid { + high-bits: u64, + low-bits: u64 + } + + variant ip-address { + ipv4(tuple), + ipv6(tuple), + } + + record mac-address { + octets: tuple + } + + record date { + year: s32, + month: u8, + day: u8 + } + + record time { + hour: u8, + minute: u8, + second: u8, + nanosecond: u32 + } + + record timestamp { + date: date, + time: time + } + + record timestamptz { + timestamp: timestamp, + offset: s32 + } + + record timetz { + time: time, + offset: s32 + } + +} diff --git a/test-components/low-level-agent/wit/deps/golem-rdbms/world.wit b/test-components/low-level-agent/wit/deps/golem-rdbms/world.wit new file mode 100644 index 0000000000..1ee3ae9eae --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-rdbms/world.wit @@ -0,0 +1,6 @@ +package golem:rdbms@0.0.1; + +world imports { + import postgres; + import mysql; +} diff --git a/test-components/low-level-agent/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/low-level-agent/wit/deps/golem-rpc/wasm-rpc.wit new file mode 100644 index 0000000000..372919b05c --- /dev/null +++ b/test-components/low-level-agent/wit/deps/golem-rpc/wasm-rpc.wit @@ -0,0 +1,149 @@ +package golem:rpc@0.2.2; + +interface types { + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use wasi:io/poll@0.2.3.{pollable}; + + /// Represents a Golem worker + record worker-id { + component-id: component-id, + worker-name: string + } + + /// Represents a Golem component + record component-id { + uuid: uuid, + } + + /// UUID + record uuid { + high-bits: u64, + low-bits: u64 + } + + /// Parses a UUID from a string + parse-uuid: func(uuid: string) -> result; + + /// Converts a UUID to a string + uuid-to-string: func(uuid: uuid) -> string; + + type node-index = s32; + + record wit-value { + nodes: list, + } + + variant wit-node { + record-value(list), + variant-value(tuple>), + enum-value(u32), + flags-value(list), + tuple-value(list), + list-value(list), + option-value(option), + result-value(result, option>), + prim-u8(u8), + prim-u16(u16), + prim-u32(u32), + prim-u64(u64), + prim-s8(s8), + prim-s16(s16), + prim-s32(s32), + prim-s64(s64), + prim-float32(f32), + prim-float64(f64), + prim-char(char), + prim-bool(bool), + prim-string(string), + handle(tuple) + } + + record wit-type { + nodes: list, + } + + type resource-id = u64; + + enum resource-mode { + owned, + borrowed + } + + record named-wit-type-node { + name: option, + owner: option, + %type: wit-type-node + } + + variant wit-type-node { + record-type(list>), + variant-type(list>>), + enum-type(list), + flags-type(list), + tuple-type(list), + list-type(node-index), + option-type(node-index), + result-type(tuple, option>), + prim-u8-type, + prim-u16-type, + prim-u32-type, + prim-u64-type, + prim-s8-type, + prim-s16-type, + prim-s32-type, + prim-s64-type, + prim-f32-type, + prim-f64-type, + prim-char-type, + prim-bool-type, + prim-string-type, + handle-type(tuple) + } + + record value-and-type { + value: wit-value, + typ: wit-type + } + + record uri { + value: string, + } + + variant rpc-error { + protocol-error(string), + denied(string), + not-found(string), + remote-internal-error(string) + } + + resource wasm-rpc { + constructor(worker-id: worker-id); + ephemeral: static func(component-id: component-id) -> wasm-rpc; + + invoke-and-await: func(function-name: string, function-params: list) -> result; + invoke: func(function-name: string, function-params: list) -> result<_, rpc-error>; + + async-invoke-and-await: func(function-name: string, function-params: list) -> future-invoke-result; + + /// Schedule invocation for later + schedule-invocation: func(scheduled-time: datetime, function-name: string, function-params: list); + /// Schedule invocation for later. Call cancel on the returned resource to cancel the invocation before the scheduled time. + schedule-cancelable-invocation: func(scheduled-time: datetime, function-name: string, function-params: list) -> cancellation-token; + } + + resource future-invoke-result { + subscribe: func() -> pollable; + get: func() -> option>; + } + + resource cancellation-token { + cancel: func(); + } + + extract-value: func(vnt: value-and-type) -> wit-value; + extract-type: func(vnt: value-and-type) -> wit-type; +} + +world wit-value { + import types; +} diff --git a/test-components/low-level-agent/wit/deps/http/handler.wit b/test-components/low-level-agent/wit/deps/http/handler.wit new file mode 100644 index 0000000000..6a6c62966f --- /dev/null +++ b/test-components/low-level-agent/wit/deps/http/handler.wit @@ -0,0 +1,49 @@ +/// This interface defines a handler of incoming HTTP Requests. It should +/// be exported by components which can respond to HTTP Requests. +@since(version = 0.2.0) +interface incoming-handler { + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. +@since(version = 0.2.0) +interface outgoing-handler { + @since(version = 0.2.0) + 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`. + @since(version = 0.2.0) + handle: func( + request: outgoing-request, + options: option + ) -> result; +} diff --git a/test-components/low-level-agent/wit/deps/http/proxy.wit b/test-components/low-level-agent/wit/deps/http/proxy.wit new file mode 100644 index 0000000000..de3bbe8ae0 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/http/proxy.wit @@ -0,0 +1,50 @@ +package wasi:http@0.2.3; + +/// The `wasi:http/imports` world imports all the APIs for HTTP proxies. +/// It is intended to be `include`d in other worlds. +@since(version = 0.2.0) +world imports { + /// HTTP proxies have access to time and randomness. + @since(version = 0.2.0) + import wasi:clocks/monotonic-clock@0.2.3; + @since(version = 0.2.0) + import wasi:clocks/wall-clock@0.2.3; + @since(version = 0.2.0) + import wasi:random/random@0.2.3; + + /// Proxies have standard output and error streams which are expected to + /// terminate in a developer-facing console provided by the host. + @since(version = 0.2.0) + import wasi:cli/stdout@0.2.3; + @since(version = 0.2.0) + import wasi:cli/stderr@0.2.3; + + /// TODO: this is a temporary workaround until component tooling is able to + /// gracefully handle the absence of stdin. Hosts must return an eof stream + /// for this import, which is what wasi-libc + tooling will do automatically + /// when this import is properly removed. + @since(version = 0.2.0) + import wasi:cli/stdin@0.2.3; + + /// This is the default handler to use when user code simply wants to make an + /// HTTP request (e.g., via `fetch()`). + @since(version = 0.2.0) + import outgoing-handler; +} + +/// 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. +@since(version = 0.2.0) +world proxy { + @since(version = 0.2.0) + include imports; + + /// The host delivers incoming HTTP requests to a component by calling the + /// `handle` function of this exported interface. A host may arbitrarily reuse + /// or not reuse component instance when delivering incoming HTTP requests and + /// thus a component must be able to handle 0..N calls to `handle`. + @since(version = 0.2.0) + export incoming-handler; +} diff --git a/test-components/low-level-agent/wit/deps/http/types.wit b/test-components/low-level-agent/wit/deps/http/types.wit new file mode 100644 index 0000000000..2498f180ad --- /dev/null +++ b/test-components/low-level-agent/wit/deps/http/types.wit @@ -0,0 +1,673 @@ +/// 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. +@since(version = 0.2.0) +interface types { + @since(version = 0.2.0) + use wasi:clocks/monotonic-clock@0.2.3.{duration}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream, output-stream}; + @since(version = 0.2.0) + use wasi:io/error@0.2.3.{error as io-error}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + + /// This type corresponds to HTTP standard Methods. + @since(version = 0.2.0) + variant method { + get, + head, + post, + put, + delete, + connect, + options, + trace, + patch, + other(string) + } + + /// This type corresponds to HTTP standard Related Schemes. + @since(version = 0.2.0) + variant scheme { + HTTP, + HTTPS, + other(string) + } + + /// These cases are inspired by the IANA HTTP Proxy Error Types: + /// + @since(version = 0.2.0) + 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) + } + + /// Defines the case payload type for `DNS-error` above: + @since(version = 0.2.0) + record DNS-error-payload { + rcode: option, + info-code: option + } + + /// Defines the case payload type for `TLS-alert-received` above: + @since(version = 0.2.0) + record TLS-alert-received-payload { + alert-id: option, + alert-message: option + } + + /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above: + @since(version = 0.2.0) + record field-size-payload { + field-name: option, + field-size: 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. + @since(version = 0.2.0) + http-error-code: func(err: borrow) -> option; + + /// This type enumerates the different kinds of errors that may occur when + /// setting or appending to a `fields` resource. + @since(version = 0.2.0) + variant header-error { + /// This error indicates that a `field-name` 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-name` 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 names are always strings. + /// + /// Field names should always be treated as case insensitive by the `fields` + /// resource for the purposes of equality checking. + @since(version = 0.2.1) + type field-name = field-key; + + /// Field keys are always strings. + /// + /// Field keys should always be treated as case insensitive by the `fields` + /// resource for the purposes of equality checking. + /// + /// # Deprecation + /// + /// This type has been deprecated in favor of the `field-name` type. + @since(version = 0.2.0) + @deprecated(version = 0.2.2) + 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. + @since(version = 0.2.0) + 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`. + @since(version = 0.2.0) + resource fields { + + /// Construct an empty HTTP Fields. + /// + /// The resulting `fields` is mutable. + @since(version = 0.2.0) + constructor(); + + /// Construct an HTTP Fields. + /// + /// The resulting `fields` is mutable. + /// + /// The list represents each name-value pair in the Fields. Names + /// which have multiple values are represented by multiple entries in this + /// list with the same name. + /// + /// The tuple is a pair of the field name, represented as a string, and + /// Value, represented as a list of bytes. + /// + /// An error result will be returned if any `field-name` or `field-value` is + /// syntactically invalid, or if a field is forbidden. + @since(version = 0.2.0) + from-list: static func( + entries: list> + ) -> result; + + /// Get all of the values corresponding to a name. If the name is not present + /// in this `fields` or is syntactically invalid, an empty list is returned. + /// However, if the name is present but empty, this is represented by a list + /// with one or more empty field-values present. + @since(version = 0.2.0) + get: func(name: field-name) -> list; + + /// Returns `true` when the name is present in this `fields`. If the name is + /// syntactically invalid, `false` is returned. + @since(version = 0.2.0) + has: func(name: field-name) -> bool; + + /// Set all of the values for a name. Clears any existing values for that + /// name, if they have been set. + /// + /// Fails with `header-error.immutable` if the `fields` are immutable. + /// + /// Fails with `header-error.invalid-syntax` if the `field-name` or any of + /// the `field-value`s are syntactically invalid. + @since(version = 0.2.0) + set: func(name: field-name, value: list) -> result<_, header-error>; + + /// Delete all values for a name. Does nothing if no values for the name + /// exist. + /// + /// Fails with `header-error.immutable` if the `fields` are immutable. + /// + /// Fails with `header-error.invalid-syntax` if the `field-name` is + /// syntactically invalid. + @since(version = 0.2.0) + delete: func(name: field-name) -> result<_, header-error>; + + /// Append a value for a name. Does not change or delete any existing + /// values for that name. + /// + /// Fails with `header-error.immutable` if the `fields` are immutable. + /// + /// Fails with `header-error.invalid-syntax` if the `field-name` or + /// `field-value` are syntactically invalid. + @since(version = 0.2.0) + append: func(name: field-name, value: field-value) -> result<_, header-error>; + + /// Retrieve the full set of names and values in the Fields. Like the + /// constructor, the list represents each name-value pair. + /// + /// The outer list represents each name-value pair in the Fields. Names + /// which have multiple values are represented by multiple entries in this + /// list with the same name. + /// + /// The names and values are always returned in the original casing and in + /// the order in which they will be serialized for transport. + @since(version = 0.2.0) + entries: func() -> list>; + + /// Make a deep copy of the Fields. Equivalent in behavior to calling the + /// `fields` constructor on the return value of `entries`. The resulting + /// `fields` is mutable. + @since(version = 0.2.0) + clone: func() -> fields; + } + + /// Headers is an alias for Fields. + @since(version = 0.2.0) + type headers = fields; + + /// Trailers is an alias for Fields. + @since(version = 0.2.0) + type trailers = fields; + + /// Represents an incoming HTTP Request. + @since(version = 0.2.0) + resource incoming-request { + + /// Returns the method of the incoming request. + @since(version = 0.2.0) + method: func() -> method; + + /// Returns the path with query parameters from the request, as a string. + @since(version = 0.2.0) + path-with-query: func() -> option; + + /// Returns the protocol scheme from the request. + @since(version = 0.2.0) + scheme: func() -> option; + + /// Returns the authority of the Request's target URI, if present. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + headers: func() -> headers; + + /// Gives the `incoming-body` associated with this request. Will only + /// return success at most once, and subsequent calls will return error. + @since(version = 0.2.0) + consume: func() -> result; + } + + /// Represents an outgoing HTTP Request. + @since(version = 0.2.0) + 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`. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + body: func() -> result; + + /// Get the Method for the Request. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + set-scheme: func(scheme: option) -> result; + + /// Get the authority of the Request's target URI. 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. + @since(version = 0.2.0) + authority: func() -> option; + /// Set the authority of the Request's target URI. 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. + @since(version = 0.2.0) + 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 transferred to + /// another component by e.g. `outgoing-handler.handle`. + @since(version = 0.2.0) + 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`. + @since(version = 0.2.0) + resource request-options { + /// Construct a default `request-options` value. + @since(version = 0.2.0) + constructor(); + + /// The timeout for the initial connect to the HTTP Server. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + set-connect-timeout: func(duration: option) -> result; + + /// The timeout for receiving the first byte of the Response body. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + set-first-byte-timeout: func(duration: option) -> result; + + /// The timeout for receiving subsequent chunks of bytes in the Response + /// body stream. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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`. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + set: static func( + param: response-outparam, + response: result, + ); + } + + /// This type corresponds to the HTTP standard Status Code. + @since(version = 0.2.0) + type status-code = u16; + + /// Represents an incoming HTTP Response. + @since(version = 0.2.0) + resource incoming-response { + + /// Returns the status code from the incoming response. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + headers: func() -> headers; + + /// Returns the incoming body. May be called at most once. Returns error + /// if called additional times. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + %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. + @since(version = 0.2.0) + finish: static func(this: incoming-body) -> future-trailers; + } + + /// Represents a future which may eventually 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. + @since(version = 0.2.0) + resource future-trailers { + + /// Returns a pollable which becomes ready when either the trailers have + /// been received, or an error has occurred. When this pollable is ready, + /// the `get` method will return `some`. + @since(version = 0.2.0) + subscribe: func() -> pollable; + + /// Returns the contents of the trailers, or an error which occurred, + /// 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 occurred 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. + @since(version = 0.2.0) + get: func() -> option, error-code>>>; + } + + /// Represents an outgoing HTTP Response. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + constructor(headers: headers); + + /// Get the HTTP Status Code for the Response. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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 transferred to + /// another component by e.g. `outgoing-handler.handle`. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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 occurred. The implementation should propagate 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + 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. + @since(version = 0.2.0) + finish: static func( + this: outgoing-body, + trailers: option + ) -> result<_, error-code>; + } + + /// Represents a future which may eventually 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. + @since(version = 0.2.0) + resource future-incoming-response { + /// Returns a pollable which becomes ready when either the Response has + /// been received, or an error has occurred. When this pollable is ready, + /// the `get` method will return `some`. + @since(version = 0.2.0) + 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 received successfully, or that an error + /// occurred. Errors may also occur while consuming the response body, + /// but those will be reported by the `incoming-body` and its + /// `output-stream` child. + @since(version = 0.2.0) + get: func() -> option>>; + } +} diff --git a/test-components/low-level-agent/wit/deps/io/error.wit b/test-components/low-level-agent/wit/deps/io/error.wit new file mode 100644 index 0000000000..97c6068779 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/io/error.wit @@ -0,0 +1,34 @@ +package wasi:io@0.2.3; + +@since(version = 0.2.0) +interface error { + /// A resource which represents some error information. + /// + /// The only method provided by this resource is `to-debug-string`, + /// which provides some human-readable information about the error. + /// + /// In the `wasi:io` package, this resource is returned through the + /// `wasi:io/streams/stream-error` type. + /// + /// To provide more specific error information, other interfaces may + /// offer functions to "downcast" this error into more specific types. For example, + /// errors returned from streams derived from filesystem types can be described using + /// the filesystem's own error-code type. This is done using the function + /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow` + /// parameter and returns an `option`. + /// + /// The set of functions which can "downcast" an `error` into a more + /// concrete type is open. + @since(version = 0.2.0) + resource error { + /// Returns a string that is suitable to assist humans in debugging + /// this error. + /// + /// WARNING: The returned string should not be consumed mechanically! + /// It may change across platforms, hosts, or other implementation + /// details. Parsing this string is a major platform-compatibility + /// hazard. + @since(version = 0.2.0) + to-debug-string: func() -> string; + } +} diff --git a/test-components/low-level-agent/wit/deps/io/poll.wit b/test-components/low-level-agent/wit/deps/io/poll.wit new file mode 100644 index 0000000000..9bcbe8e036 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/io/poll.wit @@ -0,0 +1,47 @@ +package wasi:io@0.2.3; + +/// A poll API intended to let users wait for I/O events on multiple handles +/// at once. +@since(version = 0.2.0) +interface poll { + /// `pollable` represents a single I/O event which may be ready, or not. + @since(version = 0.2.0) + resource pollable { + + /// Return the readiness of a pollable. This function never blocks. + /// + /// Returns `true` when the pollable is ready, and `false` otherwise. + @since(version = 0.2.0) + ready: func() -> bool; + + /// `block` returns immediately if the pollable is ready, and otherwise + /// blocks until ready. + /// + /// This function is equivalent to calling `poll.poll` on a list + /// containing only this pollable. + @since(version = 0.2.0) + block: func(); + } + + /// Poll for completion on a set of pollables. + /// + /// This function takes a list of pollables, which identify I/O sources of + /// interest, and waits until one or more of the events is ready for I/O. + /// + /// The result `list` contains one or more indices of handles in the + /// argument list that is ready for I/O. + /// + /// This function traps if either: + /// - the list is empty, or: + /// - the list contains more elements than can be indexed with a `u32` value. + /// + /// A timeout can be implemented by adding a pollable from the + /// wasi-clocks API to the list. + /// + /// This function does not return a `result`; polling in itself does not + /// do any I/O so it doesn't fail. If any of the I/O sources identified by + /// the pollables has an error, it is indicated by marking the source as + /// being ready for I/O. + @since(version = 0.2.0) + poll: func(in: list>) -> list; +} diff --git a/test-components/low-level-agent/wit/deps/io/streams.wit b/test-components/low-level-agent/wit/deps/io/streams.wit new file mode 100644 index 0000000000..0de0846293 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/io/streams.wit @@ -0,0 +1,290 @@ +package wasi:io@0.2.3; + +/// WASI I/O is an I/O abstraction API which is currently focused on providing +/// stream types. +/// +/// In the future, the component model is expected to add built-in stream types; +/// when it does, they are expected to subsume this API. +@since(version = 0.2.0) +interface streams { + @since(version = 0.2.0) + use error.{error}; + @since(version = 0.2.0) + use poll.{pollable}; + + /// An error for input-stream and output-stream operations. + @since(version = 0.2.0) + variant stream-error { + /// The last operation (a write or flush) failed before completion. + /// + /// More information is available in the `error` payload. + /// + /// After this, the stream will be closed. All future operations return + /// `stream-error::closed`. + last-operation-failed(error), + /// The stream is closed: no more input will be accepted by the + /// stream. A closed output-stream will return this error on all + /// future operations. + closed + } + + /// An input bytestream. + /// + /// `input-stream`s are *non-blocking* to the extent practical on underlying + /// platforms. I/O operations always return promptly; if fewer bytes are + /// promptly available than requested, they return the number of bytes promptly + /// available, which could even be zero. To wait for data to be available, + /// use the `subscribe` function to obtain a `pollable` which can be polled + /// for using `wasi:io/poll`. + @since(version = 0.2.0) + resource input-stream { + /// Perform a non-blocking read from the stream. + /// + /// When the source of a `read` is binary data, the bytes from the source + /// are returned verbatim. When the source of a `read` is known to the + /// implementation to be text, bytes containing the UTF-8 encoding of the + /// text are returned. + /// + /// This function returns a list of bytes containing the read data, + /// when successful. The returned list will contain up to `len` bytes; + /// it may return fewer than requested, but not more. The list is + /// empty when no bytes are available for reading at this time. The + /// pollable given by `subscribe` will be ready when more bytes are + /// available. + /// + /// This function fails with a `stream-error` when the operation + /// encounters an error, giving `last-operation-failed`, or when the + /// stream is closed, giving `closed`. + /// + /// When the caller gives a `len` of 0, it represents a request to + /// read 0 bytes. If the stream is still open, this call should + /// succeed and return an empty list, or otherwise fail with `closed`. + /// + /// The `len` parameter is a `u64`, which could represent a list of u8 which + /// is not possible to allocate in wasm32, or not desirable to allocate as + /// as a return value by the callee. The callee may return a list of bytes + /// less than `len` in size while more bytes are available for reading. + @since(version = 0.2.0) + read: func( + /// The maximum number of bytes to read + len: u64 + ) -> result, stream-error>; + + /// Read bytes from a stream, after blocking until at least one byte can + /// be read. Except for blocking, behavior is identical to `read`. + @since(version = 0.2.0) + blocking-read: func( + /// The maximum number of bytes to read + len: u64 + ) -> result, stream-error>; + + /// Skip bytes from a stream. Returns number of bytes skipped. + /// + /// Behaves identical to `read`, except instead of returning a list + /// of bytes, returns the number of bytes consumed from the stream. + @since(version = 0.2.0) + skip: func( + /// The maximum number of bytes to skip. + len: u64, + ) -> result; + + /// Skip bytes from a stream, after blocking until at least one byte + /// can be skipped. Except for blocking behavior, identical to `skip`. + @since(version = 0.2.0) + blocking-skip: func( + /// The maximum number of bytes to skip. + len: u64, + ) -> result; + + /// Create a `pollable` which will resolve once either the specified stream + /// has bytes available to read or the other end of the stream has been + /// closed. + /// The created `pollable` is a child resource of the `input-stream`. + /// Implementations may trap if the `input-stream` is dropped before + /// all derived `pollable`s created with this function are dropped. + @since(version = 0.2.0) + subscribe: func() -> pollable; + } + + + /// An output bytestream. + /// + /// `output-stream`s are *non-blocking* to the extent practical on + /// underlying platforms. Except where specified otherwise, I/O operations also + /// always return promptly, after the number of bytes that can be written + /// promptly, which could even be zero. To wait for the stream to be ready to + /// accept data, the `subscribe` function to obtain a `pollable` which can be + /// polled for using `wasi:io/poll`. + /// + /// Dropping an `output-stream` while there's still an active write in + /// progress may result in the data being lost. Before dropping the stream, + /// be sure to fully flush your writes. + @since(version = 0.2.0) + resource output-stream { + /// Check readiness for writing. This function never blocks. + /// + /// Returns the number of bytes permitted for the next call to `write`, + /// or an error. Calling `write` with more bytes than this function has + /// permitted will trap. + /// + /// When this function returns 0 bytes, the `subscribe` pollable will + /// become ready when this function will report at least 1 byte, or an + /// error. + @since(version = 0.2.0) + check-write: func() -> result; + + /// Perform a write. This function never blocks. + /// + /// When the destination of a `write` is binary data, the bytes from + /// `contents` are written verbatim. When the destination of a `write` is + /// known to the implementation to be text, the bytes of `contents` are + /// transcoded from UTF-8 into the encoding of the destination and then + /// written. + /// + /// Precondition: check-write gave permit of Ok(n) and contents has a + /// length of less than or equal to n. Otherwise, this function will trap. + /// + /// returns Err(closed) without writing if the stream has closed since + /// the last call to check-write provided a permit. + @since(version = 0.2.0) + write: func( + contents: list + ) -> result<_, stream-error>; + + /// Perform a write of up to 4096 bytes, and then flush the stream. Block + /// until all of these operations are complete, or an error occurs. + /// + /// This is a convenience wrapper around the use of `check-write`, + /// `subscribe`, `write`, and `flush`, and is implemented with the + /// following pseudo-code: + /// + /// ```text + /// let pollable = this.subscribe(); + /// while !contents.is_empty() { + /// // Wait for the stream to become writable + /// pollable.block(); + /// let Ok(n) = this.check-write(); // eliding error handling + /// let len = min(n, contents.len()); + /// let (chunk, rest) = contents.split_at(len); + /// this.write(chunk ); // eliding error handling + /// contents = rest; + /// } + /// this.flush(); + /// // Wait for completion of `flush` + /// pollable.block(); + /// // Check for any errors that arose during `flush` + /// let _ = this.check-write(); // eliding error handling + /// ``` + @since(version = 0.2.0) + blocking-write-and-flush: func( + contents: list + ) -> result<_, stream-error>; + + /// Request to flush buffered output. This function never blocks. + /// + /// This tells the output-stream that the caller intends any buffered + /// output to be flushed. the output which is expected to be flushed + /// is all that has been passed to `write` prior to this call. + /// + /// Upon calling this function, the `output-stream` will not accept any + /// writes (`check-write` will return `ok(0)`) until the flush has + /// completed. The `subscribe` pollable will become ready when the + /// flush has completed and the stream can accept more writes. + @since(version = 0.2.0) + flush: func() -> result<_, stream-error>; + + /// Request to flush buffered output, and block until flush completes + /// and stream is ready for writing again. + @since(version = 0.2.0) + blocking-flush: func() -> result<_, stream-error>; + + /// Create a `pollable` which will resolve once the output-stream + /// is ready for more writing, or an error has occurred. When this + /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an + /// error. + /// + /// If the stream is closed, this pollable is always ready immediately. + /// + /// The created `pollable` is a child resource of the `output-stream`. + /// Implementations may trap if the `output-stream` is dropped before + /// all derived `pollable`s created with this function are dropped. + @since(version = 0.2.0) + subscribe: func() -> pollable; + + /// Write zeroes to a stream. + /// + /// This should be used precisely like `write` with the exact same + /// preconditions (must use check-write first), but instead of + /// passing a list of bytes, you simply pass the number of zero-bytes + /// that should be written. + @since(version = 0.2.0) + write-zeroes: func( + /// The number of zero-bytes to write + len: u64 + ) -> result<_, stream-error>; + + /// Perform a write of up to 4096 zeroes, and then flush the stream. + /// Block until all of these operations are complete, or an error + /// occurs. + /// + /// This is a convenience wrapper around the use of `check-write`, + /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with + /// the following pseudo-code: + /// + /// ```text + /// let pollable = this.subscribe(); + /// while num_zeroes != 0 { + /// // Wait for the stream to become writable + /// pollable.block(); + /// let Ok(n) = this.check-write(); // eliding error handling + /// let len = min(n, num_zeroes); + /// this.write-zeroes(len); // eliding error handling + /// num_zeroes -= len; + /// } + /// this.flush(); + /// // Wait for completion of `flush` + /// pollable.block(); + /// // Check for any errors that arose during `flush` + /// let _ = this.check-write(); // eliding error handling + /// ``` + @since(version = 0.2.0) + blocking-write-zeroes-and-flush: func( + /// The number of zero-bytes to write + len: u64 + ) -> result<_, stream-error>; + + /// Read from one stream and write to another. + /// + /// The behavior of splice is equivalent to: + /// 1. calling `check-write` on the `output-stream` + /// 2. calling `read` on the `input-stream` with the smaller of the + /// `check-write` permitted length and the `len` provided to `splice` + /// 3. calling `write` on the `output-stream` with that read data. + /// + /// Any error reported by the call to `check-write`, `read`, or + /// `write` ends the splice and reports that error. + /// + /// This function returns the number of bytes transferred; it may be less + /// than `len`. + @since(version = 0.2.0) + splice: func( + /// The stream to read from + src: borrow, + /// The number of bytes to splice + len: u64, + ) -> result; + + /// Read from one stream and write to another, with blocking. + /// + /// This is similar to `splice`, except that it blocks until the + /// `output-stream` is ready for writing, and the `input-stream` + /// is ready for reading, before performing the `splice`. + @since(version = 0.2.0) + blocking-splice: func( + /// The stream to read from + src: borrow, + /// The number of bytes to splice + len: u64, + ) -> result; + } +} diff --git a/test-components/low-level-agent/wit/deps/io/world.wit b/test-components/low-level-agent/wit/deps/io/world.wit new file mode 100644 index 0000000000..f1d2102dca --- /dev/null +++ b/test-components/low-level-agent/wit/deps/io/world.wit @@ -0,0 +1,10 @@ +package wasi:io@0.2.3; + +@since(version = 0.2.0) +world imports { + @since(version = 0.2.0) + import streams; + + @since(version = 0.2.0) + import poll; +} diff --git a/test-components/low-level-agent/wit/deps/keyvalue/atomic.wit b/test-components/low-level-agent/wit/deps/keyvalue/atomic.wit new file mode 100644 index 0000000000..1d32b7e32a --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/atomic.wit @@ -0,0 +1,31 @@ +/// A keyvalue interface that provides atomic operations. +/// +/// Atomic operations are single, indivisible operations. When a fault causes +/// an atomic operation to fail, it will appear to the invoker of the atomic +/// operation that the action either completed successfully or did nothing +/// at all. +interface atomic { + /// A keyvalue interface that provides atomic operations. + use types.{bucket, error, key}; + + /// Atomically increment the value associated with the key in the bucket by the + /// given delta. It returns the new value. + /// + /// If the key does not exist in the bucket, it creates a new key-value pair + /// with the value set to the given delta. + /// + /// If any other error occurs, it returns an `Err(error)`. + increment: func(bucket: borrow, key: key, delta: u64) -> result; + + /// Compare-and-swap (CAS) atomically updates the value associated with the key + /// in the bucket if the value matches the old value. This operation returns + /// `Ok(true)` if the swap was successful, `Ok(false)` if the value did not match, + /// + /// A successful CAS operation means the current value matched the `old` value + /// and was replaced with the `new` value. + /// + /// If the key does not exist in the bucket, it returns `Ok(false)`. + /// + /// If any other error occurs, it returns an `Err(error)`. + compare-and-swap: func(bucket: borrow, key: key, old: u64, new: u64) -> result; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/keyvalue/caching.wit b/test-components/low-level-agent/wit/deps/keyvalue/caching.wit new file mode 100644 index 0000000000..5880362a8c --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/caching.wit @@ -0,0 +1,98 @@ +// The `wasi:keyvalue/cache` interface defines the operations of a single +// instance of a "cache", which is a non-durable, weakly-consistent key-value +// store. "Non-durable" means that caches are allowed and expected to +// arbitrarily discard key-value entries. "Weakly-consistent" means that there +// are essentially no guarantees that operations will agree on their results: a +// get following a set may not observe the set value; multiple gets may observe +// different previous set values; etc. The only guarantee is that values are +// not materialized "out of thin air": if a `get` returns a value, that value +// was passed to a `set` operation at some point in time in the past. +// Additionally, caches MUST make a best effort to respect the supplied +// Time-to-Live values (within the usual limitations around time in a +// distributed setting). +interface cache { + use wasi:io/poll@0.2.3.{pollable}; + use types.{key, incoming-value, outgoing-value, error}; + + // The `get` operation returns the value passed by a previous `set` for the + // same key within the given TTL or none if there is no such value. + get: func(k: key) -> future-get-result; + + // This block defines a special resource type used by `get` to emulate + // `future,error>>`. In the return value + // of the `get` method, the outer `option` returns `none` when the pollable + // is not yet ready and the inner `option` returns `none` when the + // requested key wasn't present. + resource future-get-result { + future-get-result-get: func() -> option, error>>; + listen-to-future-get-result: func() -> pollable; + } + + // The `exists` operation returns whether a value was previously `set` for + // the given key within the TTL. + exists: func(k: key) -> future-exists-result; + + // This block defines a special resource type used by `exists` to emulate + // `future>`. + resource future-exists-result { + future-exists-result-get: func() -> option>; + listen-to-future-exists-result: func() -> pollable; + } + + // The `set` operation sets the given value for the given key for the given + // time-to-live (TTL) duration, if supplied, specified in milliseconds. If + // a TTL is not supplied, the key may be kept indefinitely (as-if a very + // large TTL were used). If the key is already present in the cache, the + // value is updated in-place. In the common case of computing and caching a + // value if the given key is not already in the cache, consider using + // `get-or-set` (below) intead of separate `get` and `set` operations. + set: func(k: key, v: borrow, TTL-ms: option) -> future-result; + + // This block defines a special resource type used by `set` and `delete` to + // emulate `future>`. + resource future-result { + future-result-get: func() -> option>; + listen-to-future-result: func() -> pollable; + } + + // The `get-or-set` operation asynchronously returns one of two cases + // enumerated by `get-or-set-entry`: in the `occupied` case, the given key + // already has a value present in the cache; in the `vacant` case, there + // was no value and the caller should write a value into the returned + // `vacancy`. This operation allows multiple concurrent `get-or-set` + // invocations to rendezvous such that only one invocation receives the + // `vacant` result while all other invocations wait until the vacancy is + // filled before receiving an `occupied` result. Implementations are not + // required to implement this rendezvous or to rendezvous in all possible + // cases. + variant get-or-set-entry { + occupied(incoming-value), + vacant(vacancy) + } + get-or-set: func(k: key) -> future-get-or-set-result; + + // This block defines a special resource type used by `get-or-set` to + // emulate `future>`. + resource future-get-or-set-result { + future-get-or-set-result-get: func() -> option>; + listen-to-future-get-or-set-result: func() -> pollable; + } + + // The following block defines the `vacancy` resource type. (When resource + // types are added, the `u32` type aliases can be replaced by proper + // `resource` types.) When the caller of `get-or-set` receives a `vacancy`, + // they must either call the `fill` method or drop the `vacancy` to + // indicate an error that prevents calling `fill`. An implementation MAY + // have a timeout that drops a vacancy that hasn't been filled in order + // to unblock other waiting `get-or-set` callers. + resource vacancy { + vacancy-fill: func(TTL-ms: option) -> outgoing-value; + } + + // The `delete` operation removes any value with the given key from the + // cache. Like all cache operations, `delete` is weakly ordered and thus + // concurrent `get` calls may still see deleted keys for a period of time. + // Additionally, due to weak ordering, concurrent `set` calls for the same + // key may or may not get deleted. + delete: func(k: key) -> future-result; +} diff --git a/test-components/low-level-agent/wit/deps/keyvalue/error.wit b/test-components/low-level-agent/wit/deps/keyvalue/error.wit new file mode 100644 index 0000000000..cd244f6fff --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/error.wit @@ -0,0 +1,20 @@ +interface wasi-keyvalue-error { + /// An error resource type for keyvalue operations. + /// + /// Common errors: + /// - Connectivity errors (e.g. network errors): when the client cannot establish + /// a connection to the keyvalue service. + /// - Authentication and Authorization errors: when the client fails to authenticate + /// or does not have the required permissions to perform the operation. + /// - Data errors: when the client sends incompatible or corrupted data. + /// - Resource errors: when the system runs out of resources (e.g. memory). + /// - Internal errors: unexpected errors on the server side. + /// + /// Currently, this provides only one function to return a string representation + /// of the error. In the future, this will be extended to provide more information + /// about the error. + // Soon: switch to `resource error { ... }` + resource error { + trace: func() -> string; + } +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/keyvalue/eventual-batch.wit b/test-components/low-level-agent/wit/deps/keyvalue/eventual-batch.wit new file mode 100644 index 0000000000..080999eeaa --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/eventual-batch.wit @@ -0,0 +1,81 @@ +/// A keyvalue interface that provides eventually consistent batch operations. +/// +/// A batch operation is an operation that operates on multiple keys at once. +/// +/// Batch operations are useful for reducing network round-trip time. For example, +/// if you want to get the values associated with 100 keys, you can either do 100 get +/// operations or you can do 1 batch get operation. The batch operation is +/// faster because it only needs to make 1 network call instead of 100. +/// +/// A batch operation does not guarantee atomicity, meaning that if the batch +/// operation fails, some of the keys may have been modified and some may not. +/// Transactional operations are being worked on and will be added in the future to +/// provide atomicity. +/// +/// Data consistency in a key value store refers to the gaurantee that once a +/// write operation completes, all subsequent read operations will return the +/// value that was written. +/// +/// The level of consistency in batch operations is **eventual consistency**, the same +/// with the readwrite interface. This interface does not guarantee strong consistency, +/// meaning that if a write operation completes, subsequent read operations may not return +/// the value that was written. +interface eventual-batch { + /// A keyvalue interface that provides batch get operations. + use types.{bucket, error, key, incoming-value, outgoing-value}; + + /// Get the values associated with the keys in the bucket. It returns a list of + /// incoming-value that can be consumed to get the value associated with the key. + /// + /// If any of the keys do not exist in the bucket, it returns a `none` value for + /// that key in the list. + /// + /// Note that the key-value pairs are guaranteed to be returned in the same order + /// + /// MAY show an out-of-date value if there are concurrent writes to the bucket. + /// + /// If any other error occurs, it returns an `Err(error)`. + get-many: func(bucket: borrow, keys: list) -> result>, error>; + + /// Get all the keys in the bucket. It returns a list of keys. + /// + /// Note that the keys are not guaranteed to be returned in any particular order. + /// + /// If the bucket is empty, it returns an empty list. + /// + /// MAY show an out-of-date list of keys if there are concurrent writes to the bucket. + /// + /// If any error occurs, it returns an `Err(error)`. + keys: func(bucket: borrow) -> result, error>; + + /// Set the values associated with the keys in the bucket. If the key already + /// exists in the bucket, it overwrites the value. + /// + /// Note that the key-value pairs are not guaranteed to be set in the order + /// they are provided. + /// + /// If any of the keys do not exist in the bucket, it creates a new key-value pair. + /// + /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it + /// does not rollback the key-value pairs that were already set. Thus, this batch operation + /// does not guarantee atomicity, implying that some key-value pairs could be + /// set while others might fail. + /// + /// Other concurrent operations may also be able to see the partial results. + set-many: func(bucket: borrow, key-values: list>>) -> result<_, error>; + + /// Delete the key-value pairs associated with the keys in the bucket. + /// + /// Note that the key-value pairs are not guaranteed to be deleted in the order + /// they are provided. + /// + /// If any of the keys do not exist in the bucket, it skips the key. + /// + /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it + /// does not rollback the key-value pairs that were already deleted. Thus, this batch operation + /// does not guarantee atomicity, implying that some key-value pairs could be + /// deleted while others might fail. + /// + /// Other concurrent operations may also be able to see the partial results. + delete-many: func(bucket: borrow, keys: list) -> result<_, error>; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/keyvalue/eventual.wit b/test-components/low-level-agent/wit/deps/keyvalue/eventual.wit new file mode 100644 index 0000000000..e6e33cfe74 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/eventual.wit @@ -0,0 +1,56 @@ +/// A keyvalue interface that provides eventually consistent CRUD operations. +/// +/// A CRUD operation is an operation that acts on a single key-value pair. +/// +/// The value in the key-value pair is defined as a `u8` byte array and the intention +/// is that it is the common denominator for all data types defined by different +/// key-value stores to handle data, ensuring compatibility between different +/// key-value stores. Note: the clients will be expecting serialization/deserialization overhead +/// to be handled by the key-value store. The value could be a serialized object from +/// JSON, HTML or vendor-specific data types like AWS S3 objects. +/// +/// Data consistency in a key value store refers to the gaurantee that once a +/// write operation completes, all subsequent read operations will return the +/// value that was written. +/// +/// The level of consistency in readwrite interfaces is **eventual consistency**, +/// which means that if a write operation completes successfully, all subsequent +/// read operations will eventually return the value that was written. In other words, +/// if we pause the updates to the system, the system eventually will return +/// the last updated value for read. +interface eventual { + /// A keyvalue interface that provides simple read and write operations. + use types.{bucket, error, incoming-value, key, outgoing-value}; + + /// Get the value associated with the key in the bucket. + /// + /// The value is returned as an option. If the key-value pair exists in the + /// bucket, it returns `Ok(value)`. If the key does not exist in the + /// bucket, it returns `Ok(none)`. + /// + /// If any other error occurs, it returns an `Err(error)`. + get: func(bucket: borrow, key: key) -> result, error>; + + /// Set the value associated with the key in the bucket. If the key already + /// exists in the bucket, it overwrites the value. + /// + /// If the key does not exist in the bucket, it creates a new key-value pair. + /// + /// If any other error occurs, it returns an `Err(error)`. + set: func(bucket: borrow, key: key, outgoing-value: borrow) -> result<_, error>; + + /// Delete the key-value pair associated with the key in the bucket. + /// + /// If the key does not exist in the bucket, it does nothing. + /// + /// If any other error occurs, it returns an `Err(error)`. + delete: func(bucket: borrow, key: key) -> result<_, error>; + + /// Check if the key exists in the bucket. + /// + /// If the key exists in the bucket, it returns `Ok(true)`. If the key does + /// not exist in the bucket, it returns `Ok(false)`. + /// + /// If any other error occurs, it returns an `Err(error)`. + exists: func(bucket: borrow, key: key) -> result; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/keyvalue/handle-watch.wit b/test-components/low-level-agent/wit/deps/keyvalue/handle-watch.wit new file mode 100644 index 0000000000..0ca7b37728 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/handle-watch.wit @@ -0,0 +1,17 @@ +/// A keyvalue interface that provides handle-watch operations. +/// +/// This interface is used to provide event-driven mechanisms to handle +/// keyvalue changes. +interface handle-watch { + /// A keyvalue interface that provides handle-watch operations. + use types.{bucket, key, incoming-value}; + + /// Handle the `set` event for the given bucket and key. + /// It returns a `incoming-value` that represents the new value being set. + /// The new value can be consumed by the handler. + on-set: func(bucket: bucket, key: key, incoming-value: borrow); + + /// Handle the `delete` event for the given bucket and key. + /// It returns a `key` that represents the key being deleted. + on-delete: func(bucket: bucket, key: key); +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/keyvalue/types.wit b/test-components/low-level-agent/wit/deps/keyvalue/types.wit new file mode 100644 index 0000000000..81ee803c0f --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/types.wit @@ -0,0 +1,72 @@ +// A generic keyvalue interface for WASI. +interface types { + /// A bucket is a collection of key-value pairs. Each key-value pair is stored + /// as a entry in the bucket, and the bucket itself acts as a collection of all + /// these entries. + /// + /// It is worth noting that the exact terminology for bucket in key-value stores + /// can very depending on the specific implementation. For example, + /// 1. Amazon DynamoDB calls a collection of key-value pairs a table + /// 2. Redis has hashes, sets, and sorted sets as different types of collections + /// 3. Cassandra calls a collection of key-value pairs a column family + /// 4. MongoDB calls a collection of key-value pairs a collection + /// 5. Riak calls a collection of key-value pairs a bucket + /// 6. Memcached calls a collection of key-value pairs a slab + /// 7. Azure Cosmos DB calls a collection of key-value pairs a container + /// + /// In this interface, we use the term `bucket` to refer to a collection of key-value + // Soon: switch to `resource bucket { ... }` + resource bucket { + /// Opens a bucket with the given name. + /// + /// If any error occurs, including if the bucket does not exist, it returns an `Err(error)`. + open-bucket: static func(name: string) -> result; + } + /// A key is a unique identifier for a value in a bucket. The key is used to + /// retrieve the value from the bucket. + type key = string; + + use wasi:io/streams@0.2.3.{input-stream, output-stream}; + use wasi-keyvalue-error.{ error }; + /// A value is the data stored in a key-value pair. The value can be of any type + /// that can be represented in a byte array. It provides a way to write the value + /// to the output-stream defined in the `wasi-io` interface. + // Soon: switch to `resource value { ... }` + resource outgoing-value { + new-outgoing-value: static func() -> outgoing-value; + /// Writes the value to the output-stream asynchronously. + /// If any other error occurs, it returns an `Err(error)`. + outgoing-value-write-body-async: func() -> result; + /// Writes the value to the output-stream synchronously. + /// If any other error occurs, it returns an `Err(error)`. + outgoing-value-write-body-sync: func(value: outgoing-value-body-sync) -> result<_, error>; + } + type outgoing-value-body-async = output-stream; + type outgoing-value-body-sync = list; + + /// A incoming-value is a wrapper around a value. It provides a way to read the value + /// from the `input-stream` defined in the `wasi-io` interface. + /// + /// The incoming-value provides two ways to consume the value: + /// 1. `incoming-value-consume-sync` consumes the value synchronously and returns the + /// value as a `list`. + /// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the + /// value as an `input-stream`. + /// In addition, it provides a `incoming-value-size` function to get the size of the value. + /// This is useful when the value is large and the caller wants to allocate a buffer of + /// the right size to consume the value. + // Soon: switch to `resource incoming-value { ... }` + resource incoming-value { + /// Consumes the value synchronously and returns the value as a list of bytes. + /// If any other error occurs, it returns an `Err(error)`. + incoming-value-consume-sync: func() -> result; + /// Consumes the value asynchronously and returns the value as an `input-stream`. + /// If any other error occurs, it returns an `Err(error)`. + incoming-value-consume-async: func() -> result; + /// The size of the value in bytes. + /// If the size is unknown or unavailable, this function returns an `Err(error)`. + incoming-value-size: func() -> result; + } + type incoming-value-async-body = input-stream; + type incoming-value-sync-body = list; +} diff --git a/test-components/low-level-agent/wit/deps/keyvalue/world.wit b/test-components/low-level-agent/wit/deps/keyvalue/world.wit new file mode 100644 index 0000000000..ea64fe5eed --- /dev/null +++ b/test-components/low-level-agent/wit/deps/keyvalue/world.wit @@ -0,0 +1,26 @@ +package wasi:keyvalue@0.1.0; + +/// The `wasi:keyvalue/imports` world provides common APIs for interacting +/// with key-value stores. Components targeting this world will be able to +/// do +/// 1. CRUD (create, read, update, delete) operations on key-value stores. +/// 2. Atomic `increment` and CAS (compare-and-swap) operations. +/// 3. Batch operations that can reduce the number of round trips to the network. +world imports { + /// The `eventual` capability allows the component to perform + /// eventually consistent CRUD operations on the key-value store. + import eventual; + + /// The `atomic` capability allows the component to perform atomic + /// `increment` and CAS (compare-and-swap) operations. + import atomic; + + /// The `eventual-batch` capability allows the component to perform eventually + /// consistent batch operations that can reduce the number of round trips to the network. + import eventual-batch; +} + +world keyvalue-handle-watch { + include imports; + export handle-watch; +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/logging/logging.wit b/test-components/low-level-agent/wit/deps/logging/logging.wit new file mode 100644 index 0000000000..adb5ee5fb2 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/logging/logging.wit @@ -0,0 +1,37 @@ +package wasi:logging; + +/// WASI Logging is a logging API intended to let users emit log messages with +/// simple priority levels and context values. +interface logging { + /// A log level, describing a kind of message. + enum level { + /// Describes messages about the values of variables and the flow of + /// control within a program. + trace, + + /// Describes messages likely to be of interest to someone debugging a + /// program. + debug, + + /// Describes messages likely to be of interest to someone monitoring a + /// program. + info, + + /// Describes messages indicating hazardous situations. + warn, + + /// Describes messages indicating serious errors. + error, + + /// Describes messages indicating fatal errors. + critical, + } + + /// Emit a log message. + /// + /// A log message has a `level` describing what kind of message is being + /// sent, a context, which is an uninterpreted string meant to help + /// consumers group similar messages, and a string containing the message + /// text. + log: func(level: level, context: string, message: string); +} \ No newline at end of file diff --git a/test-components/low-level-agent/wit/deps/random/insecure-seed.wit b/test-components/low-level-agent/wit/deps/random/insecure-seed.wit new file mode 100644 index 0000000000..67d024d5bf --- /dev/null +++ b/test-components/low-level-agent/wit/deps/random/insecure-seed.wit @@ -0,0 +1,27 @@ +package wasi:random@0.2.3; +/// The insecure-seed interface for seeding hash-map DoS resistance. +/// +/// It is intended to be portable at least between Unix-family platforms and +/// Windows. +@since(version = 0.2.0) +interface insecure-seed { + /// Return a 128-bit value that may contain a pseudo-random value. + /// + /// The returned value is not required to be computed from a CSPRNG, and may + /// even be entirely deterministic. Host implementations are encouraged to + /// provide pseudo-random values to any program exposed to + /// attacker-controlled content, to enable DoS protection built into many + /// languages' hash-map implementations. + /// + /// This function is intended to only be called once, by a source language + /// to initialize Denial Of Service (DoS) protection in its hash-map + /// implementation. + /// + /// # Expected future evolution + /// + /// This will likely be changed to a value import, to prevent it from being + /// called multiple times and potentially used for purposes other than DoS + /// protection. + @since(version = 0.2.0) + insecure-seed: func() -> tuple; +} diff --git a/test-components/low-level-agent/wit/deps/random/insecure.wit b/test-components/low-level-agent/wit/deps/random/insecure.wit new file mode 100644 index 0000000000..a07dfab327 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/random/insecure.wit @@ -0,0 +1,25 @@ +package wasi:random@0.2.3; +/// The insecure interface for insecure pseudo-random numbers. +/// +/// It is intended to be portable at least between Unix-family platforms and +/// Windows. +@since(version = 0.2.0) +interface insecure { + /// Return `len` insecure pseudo-random bytes. + /// + /// This function is not cryptographically secure. Do not use it for + /// anything related to security. + /// + /// There are no requirements on the values of the returned bytes, however + /// implementations are encouraged to return evenly distributed values with + /// a long period. + @since(version = 0.2.0) + get-insecure-random-bytes: func(len: u64) -> list; + + /// Return an insecure pseudo-random `u64` value. + /// + /// This function returns the same type of pseudo-random data as + /// `get-insecure-random-bytes`, represented as a `u64`. + @since(version = 0.2.0) + get-insecure-random-u64: func() -> u64; +} diff --git a/test-components/low-level-agent/wit/deps/random/random.wit b/test-components/low-level-agent/wit/deps/random/random.wit new file mode 100644 index 0000000000..91957e6330 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/random/random.wit @@ -0,0 +1,29 @@ +package wasi:random@0.2.3; +/// WASI Random is a random data API. +/// +/// It is intended to be portable at least between Unix-family platforms and +/// Windows. +@since(version = 0.2.0) +interface random { + /// Return `len` cryptographically-secure random or pseudo-random bytes. + /// + /// This function must produce data at least as cryptographically secure and + /// fast as an adequately seeded cryptographically-secure pseudo-random + /// number generator (CSPRNG). It must not block, from the perspective of + /// the calling program, under any circumstances, including on the first + /// request and on requests for numbers of bytes. The returned data must + /// always be unpredictable. + /// + /// This function must always return fresh data. Deterministic environments + /// must omit this function, rather than implementing it with deterministic + /// data. + @since(version = 0.2.0) + get-random-bytes: func(len: u64) -> list; + + /// Return a cryptographically-secure random or pseudo-random `u64` value. + /// + /// This function returns the same type of data as `get-random-bytes`, + /// represented as a `u64`. + @since(version = 0.2.0) + get-random-u64: func() -> u64; +} diff --git a/test-components/low-level-agent/wit/deps/random/world.wit b/test-components/low-level-agent/wit/deps/random/world.wit new file mode 100644 index 0000000000..0c1218f36e --- /dev/null +++ b/test-components/low-level-agent/wit/deps/random/world.wit @@ -0,0 +1,13 @@ +package wasi:random@0.2.3; + +@since(version = 0.2.0) +world imports { + @since(version = 0.2.0) + import random; + + @since(version = 0.2.0) + import insecure; + + @since(version = 0.2.0) + import insecure-seed; +} diff --git a/test-components/low-level-agent/wit/deps/sockets/instance-network.wit b/test-components/low-level-agent/wit/deps/sockets/instance-network.wit new file mode 100644 index 0000000000..5f6e6c1cc9 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/instance-network.wit @@ -0,0 +1,11 @@ + +/// This interface provides a value-export of the default network handle.. +@since(version = 0.2.0) +interface instance-network { + @since(version = 0.2.0) + use network.{network}; + + /// Get a handle to the default network. + @since(version = 0.2.0) + instance-network: func() -> network; +} diff --git a/test-components/low-level-agent/wit/deps/sockets/ip-name-lookup.wit b/test-components/low-level-agent/wit/deps/sockets/ip-name-lookup.wit new file mode 100644 index 0000000000..c1d8a47c16 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/ip-name-lookup.wit @@ -0,0 +1,56 @@ +@since(version = 0.2.0) +interface ip-name-lookup { + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + @since(version = 0.2.0) + use network.{network, error-code, ip-address}; + + /// Resolve an internet host name to a list of IP addresses. + /// + /// Unicode domain names are automatically converted to ASCII using IDNA encoding. + /// If the input is an IP address string, the address is parsed and returned + /// as-is without making any external requests. + /// + /// See the wasi-socket proposal README.md for a comparison with getaddrinfo. + /// + /// This function never blocks. It either immediately fails or immediately + /// returns successfully with a `resolve-address-stream` that can be used + /// to (asynchronously) fetch the results. + /// + /// # Typical errors + /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address. + /// + /// # References: + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + resolve-addresses: func(network: borrow, name: string) -> result; + + @since(version = 0.2.0) + resource resolve-address-stream { + /// Returns the next address from the resolver. + /// + /// This function should be called multiple times. On each call, it will + /// return the next address in connection order preference. If all + /// addresses have been exhausted, this function returns `none`. + /// + /// This function never returns IPv4-mapped IPv6 addresses. + /// + /// # Typical errors + /// - `name-unresolvable`: Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY) + /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN) + /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL) + /// - `would-block`: A result is not available yet. (EWOULDBLOCK, EAGAIN) + @since(version = 0.2.0) + resolve-next-address: func() -> result, error-code>; + + /// Create a `pollable` which will resolve once the stream is ready for I/O. + /// + /// Note: this function is here for WASI 0.2 only. + /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) + subscribe: func() -> pollable; + } +} diff --git a/test-components/low-level-agent/wit/deps/sockets/network.wit b/test-components/low-level-agent/wit/deps/sockets/network.wit new file mode 100644 index 0000000000..f3f60a3709 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/network.wit @@ -0,0 +1,169 @@ +@since(version = 0.2.0) +interface network { + @unstable(feature = network-error-code) + use wasi:io/error@0.2.3.{error}; + + /// An opaque resource that represents access to (a subset of) the network. + /// This enables context-based security for networking. + /// There is no need for this to map 1:1 to a physical network interface. + @since(version = 0.2.0) + resource network; + + /// Error codes. + /// + /// In theory, every API can return any error code. + /// In practice, API's typically only return the errors documented per API + /// combined with a couple of errors that are always possible: + /// - `unknown` + /// - `access-denied` + /// - `not-supported` + /// - `out-of-memory` + /// - `concurrency-conflict` + /// + /// See each individual API for what the POSIX equivalents are. They sometimes differ per API. + @since(version = 0.2.0) + enum error-code { + /// Unknown error + unknown, + + /// Access denied. + /// + /// POSIX equivalent: EACCES, EPERM + access-denied, + + /// The operation is not supported. + /// + /// POSIX equivalent: EOPNOTSUPP + not-supported, + + /// One of the arguments is invalid. + /// + /// POSIX equivalent: EINVAL + invalid-argument, + + /// Not enough memory to complete the operation. + /// + /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY + out-of-memory, + + /// The operation timed out before it could finish completely. + timeout, + + /// This operation is incompatible with another asynchronous operation that is already in progress. + /// + /// POSIX equivalent: EALREADY + concurrency-conflict, + + /// Trying to finish an asynchronous operation that: + /// - has not been started yet, or: + /// - was already finished by a previous `finish-*` call. + /// + /// Note: this is scheduled to be removed when `future`s are natively supported. + not-in-progress, + + /// The operation has been aborted because it could not be completed immediately. + /// + /// Note: this is scheduled to be removed when `future`s are natively supported. + would-block, + + + /// The operation is not valid in the socket's current state. + invalid-state, + + /// A new socket resource could not be created because of a system limit. + new-socket-limit, + + /// A bind operation failed because the provided address is not an address that the `network` can bind to. + address-not-bindable, + + /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available. + address-in-use, + + /// The remote address is not reachable + remote-unreachable, + + + /// The TCP connection was forcefully rejected + connection-refused, + + /// The TCP connection was reset. + connection-reset, + + /// A TCP connection was aborted. + connection-aborted, + + + /// The size of a datagram sent to a UDP socket exceeded the maximum + /// supported size. + datagram-too-large, + + + /// Name does not exist or has no suitable associated IP addresses. + name-unresolvable, + + /// A temporary failure in name resolution occurred. + temporary-resolver-failure, + + /// A permanent failure in name resolution occurred. + permanent-resolver-failure, + } + + /// Attempts to extract a network-related `error-code` from the stream + /// `error` provided. + /// + /// Stream operations which return `stream-error::last-operation-failed` + /// have a payload with more information about the operation that failed. + /// This payload can be passed through to this function to see if there's + /// network-related information about the error to return. + /// + /// Note that this function is fallible because not all stream-related + /// errors are network-related errors. + @unstable(feature = network-error-code) + network-error-code: func(err: borrow) -> option; + + @since(version = 0.2.0) + enum ip-address-family { + /// Similar to `AF_INET` in POSIX. + ipv4, + + /// Similar to `AF_INET6` in POSIX. + ipv6, + } + + @since(version = 0.2.0) + type ipv4-address = tuple; + @since(version = 0.2.0) + type ipv6-address = tuple; + + @since(version = 0.2.0) + variant ip-address { + ipv4(ipv4-address), + ipv6(ipv6-address), + } + + @since(version = 0.2.0) + record ipv4-socket-address { + /// sin_port + port: u16, + /// sin_addr + address: ipv4-address, + } + + @since(version = 0.2.0) + record ipv6-socket-address { + /// sin6_port + port: u16, + /// sin6_flowinfo + flow-info: u32, + /// sin6_addr + address: ipv6-address, + /// sin6_scope_id + scope-id: u32, + } + + @since(version = 0.2.0) + variant ip-socket-address { + ipv4(ipv4-socket-address), + ipv6(ipv6-socket-address), + } +} diff --git a/test-components/low-level-agent/wit/deps/sockets/tcp-create-socket.wit b/test-components/low-level-agent/wit/deps/sockets/tcp-create-socket.wit new file mode 100644 index 0000000000..eedbd30768 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/tcp-create-socket.wit @@ -0,0 +1,30 @@ +@since(version = 0.2.0) +interface tcp-create-socket { + @since(version = 0.2.0) + use network.{network, error-code, ip-address-family}; + @since(version = 0.2.0) + use tcp.{tcp-socket}; + + /// Create a new TCP socket. + /// + /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX. + /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise. + /// + /// This function does not require a network capability handle. This is considered to be safe because + /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect` + /// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world. + /// + /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations. + /// + /// # Typical errors + /// - `not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT) + /// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + create-tcp-socket: func(address-family: ip-address-family) -> result; +} diff --git a/test-components/low-level-agent/wit/deps/sockets/tcp.wit b/test-components/low-level-agent/wit/deps/sockets/tcp.wit new file mode 100644 index 0000000000..b4cd87fcef --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/tcp.wit @@ -0,0 +1,387 @@ +@since(version = 0.2.0) +interface tcp { + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream, output-stream}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + @since(version = 0.2.0) + use wasi:clocks/monotonic-clock@0.2.3.{duration}; + @since(version = 0.2.0) + use network.{network, error-code, ip-socket-address, ip-address-family}; + + @since(version = 0.2.0) + enum shutdown-type { + /// Similar to `SHUT_RD` in POSIX. + receive, + + /// Similar to `SHUT_WR` in POSIX. + send, + + /// Similar to `SHUT_RDWR` in POSIX. + both, + } + + /// A TCP socket resource. + /// + /// The socket can be in one of the following states: + /// - `unbound` + /// - `bind-in-progress` + /// - `bound` (See note below) + /// - `listen-in-progress` + /// - `listening` + /// - `connect-in-progress` + /// - `connected` + /// - `closed` + /// See + /// for more information. + /// + /// Note: Except where explicitly mentioned, whenever this documentation uses + /// the term "bound" without backticks it actually means: in the `bound` state *or higher*. + /// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`) + /// + /// In addition to the general error codes documented on the + /// `network::error-code` type, TCP socket methods may always return + /// `error(invalid-state)` when in the `closed` state. + @since(version = 0.2.0) + resource tcp-socket { + /// Bind the socket to a specific network on the provided IP address and port. + /// + /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which + /// network interface(s) to bind to. + /// If the TCP/UDP port is zero, the socket will be bound to a random free port. + /// + /// Bind can be attempted multiple times on the same socket, even with + /// different arguments on each iteration. But never concurrently and + /// only as long as the previous bind failed. Once a bind succeeds, the + /// binding can't be changed anymore. + /// + /// # Typical errors + /// - `invalid-argument`: The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows) + /// - `invalid-argument`: `local-address` is not a unicast address. (EINVAL) + /// - `invalid-argument`: `local-address` is an IPv4-mapped IPv6 address. (EINVAL) + /// - `invalid-state`: The socket is already bound. (EINVAL) + /// - `address-in-use`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows) + /// - `address-in-use`: Address is already in use. (EADDRINUSE) + /// - `address-not-bindable`: `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL) + /// - `not-in-progress`: A `bind` operation is not in progress. + /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) + /// + /// # Implementors note + /// When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT + /// state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR + /// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior + /// and SO_REUSEADDR performs something different entirely. + /// + /// Unlike in POSIX, in WASI the bind operation is async. This enables + /// interactive WASI hosts to inject permission prompts. Runtimes that + /// don't want to make use of this ability can simply call the native + /// `bind` as part of either `start-bind` or `finish-bind`. + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-bind: func(network: borrow, local-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) + finish-bind: func() -> result<_, error-code>; + + /// Connect to a remote endpoint. + /// + /// On success: + /// - the socket is transitioned into the `connected` state. + /// - a pair of streams is returned that can be used to read & write to the connection + /// + /// After a failed connection attempt, the socket will be in the `closed` + /// state and the only valid action left is to `drop` the socket. A single + /// socket can not be used to connect more than once. + /// + /// # Typical errors + /// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) + /// - `invalid-argument`: `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS) + /// - `invalid-argument`: `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos) + /// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows) + /// - `invalid-argument`: The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows) + /// - `invalid-argument`: The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`. + /// - `invalid-state`: The socket is already in the `connected` state. (EISCONN) + /// - `invalid-state`: The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows) + /// - `timeout`: Connection timed out. (ETIMEDOUT) + /// - `connection-refused`: The connection was forcefully rejected. (ECONNREFUSED) + /// - `connection-reset`: The connection was reset. (ECONNRESET) + /// - `connection-aborted`: The connection was aborted. (ECONNABORTED) + /// - `remote-unreachable`: The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) + /// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD) + /// - `not-in-progress`: A connect operation is not in progress. + /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) + /// + /// # Implementors note + /// The POSIX equivalent of `start-connect` is the regular `connect` syscall. + /// Because all WASI sockets are non-blocking this is expected to return + /// EINPROGRESS, which should be translated to `ok()` in WASI. + /// + /// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT` + /// with a timeout of 0 on the socket descriptor. Followed by a check for + /// the `SO_ERROR` socket option, in case the poll signaled readiness. + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-connect: func(network: borrow, remote-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) + finish-connect: func() -> result, error-code>; + + /// Start listening for new connections. + /// + /// Transitions the socket into the `listening` state. + /// + /// Unlike POSIX, the socket must already be explicitly bound. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not bound to any local address. (EDESTADDRREQ) + /// - `invalid-state`: The socket is already in the `connected` state. (EISCONN, EINVAL on BSD) + /// - `invalid-state`: The socket is already in the `listening` state. + /// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE) + /// - `not-in-progress`: A listen operation is not in progress. + /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) + /// + /// # Implementors note + /// Unlike in POSIX, in WASI the listen operation is async. This enables + /// interactive WASI hosts to inject permission prompts. Runtimes that + /// don't want to make use of this ability can simply call the native + /// `listen` as part of either `start-listen` or `finish-listen`. + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-listen: func() -> result<_, error-code>; + @since(version = 0.2.0) + finish-listen: func() -> result<_, error-code>; + + /// Accept a new client socket. + /// + /// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket: + /// - `address-family` + /// - `keep-alive-enabled` + /// - `keep-alive-idle-time` + /// - `keep-alive-interval` + /// - `keep-alive-count` + /// - `hop-limit` + /// - `receive-buffer-size` + /// - `send-buffer-size` + /// + /// On success, this function returns the newly accepted client socket along with + /// a pair of streams that can be used to read & write to the connection. + /// + /// # Typical errors + /// - `invalid-state`: Socket is not in the `listening` state. (EINVAL) + /// - `would-block`: No pending connections at the moment. (EWOULDBLOCK, EAGAIN) + /// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED) + /// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + accept: func() -> result, error-code>; + + /// Get the bound local address. + /// + /// POSIX mentions: + /// > If the socket has not been bound to a local name, the value + /// > stored in the object pointed to by `address` is unspecified. + /// + /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not bound to any local address. + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + local-address: func() -> result; + + /// Get the remote address. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + remote-address: func() -> result; + + /// Whether the socket is in the `listening` state. + /// + /// Equivalent to the SO_ACCEPTCONN socket option. + @since(version = 0.2.0) + is-listening: func() -> bool; + + /// Whether this is a IPv4 or IPv6 socket. + /// + /// Equivalent to the SO_DOMAIN socket option. + @since(version = 0.2.0) + address-family: func() -> ip-address-family; + + /// Hints the desired listen queue size. Implementations are free to ignore this. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// Any other value will never cause an error, but it might be silently clamped and/or rounded. + /// + /// # Typical errors + /// - `not-supported`: (set) The platform does not support changing the backlog size after the initial listen. + /// - `invalid-argument`: (set) The provided value was 0. + /// - `invalid-state`: (set) The socket is in the `connect-in-progress` or `connected` state. + @since(version = 0.2.0) + set-listen-backlog-size: func(value: u64) -> result<_, error-code>; + + /// Enables or disables keepalive. + /// + /// The keepalive behavior can be adjusted using: + /// - `keep-alive-idle-time` + /// - `keep-alive-interval` + /// - `keep-alive-count` + /// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true. + /// + /// Equivalent to the SO_KEEPALIVE socket option. + @since(version = 0.2.0) + keep-alive-enabled: func() -> result; + @since(version = 0.2.0) + set-keep-alive-enabled: func(value: bool) -> result<_, error-code>; + + /// Amount of time the connection has to be idle before TCP starts sending keepalive packets. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// Any other value will never cause an error, but it might be silently clamped and/or rounded. + /// I.e. after setting a value, reading the same setting back may return a different value. + /// + /// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS) + /// + /// # Typical errors + /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) + keep-alive-idle-time: func() -> result; + @since(version = 0.2.0) + set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>; + + /// The time between keepalive packets. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// Any other value will never cause an error, but it might be silently clamped and/or rounded. + /// I.e. after setting a value, reading the same setting back may return a different value. + /// + /// Equivalent to the TCP_KEEPINTVL socket option. + /// + /// # Typical errors + /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) + keep-alive-interval: func() -> result; + @since(version = 0.2.0) + set-keep-alive-interval: func(value: duration) -> result<_, error-code>; + + /// The maximum amount of keepalive packets TCP should send before aborting the connection. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// Any other value will never cause an error, but it might be silently clamped and/or rounded. + /// I.e. after setting a value, reading the same setting back may return a different value. + /// + /// Equivalent to the TCP_KEEPCNT socket option. + /// + /// # Typical errors + /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) + keep-alive-count: func() -> result; + @since(version = 0.2.0) + set-keep-alive-count: func(value: u32) -> result<_, error-code>; + + /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// + /// # Typical errors + /// - `invalid-argument`: (set) The TTL value must be 1 or higher. + @since(version = 0.2.0) + hop-limit: func() -> result; + @since(version = 0.2.0) + set-hop-limit: func(value: u8) -> result<_, error-code>; + + /// The kernel buffer space reserved for sends/receives on this socket. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// Any other value will never cause an error, but it might be silently clamped and/or rounded. + /// I.e. after setting a value, reading the same setting back may return a different value. + /// + /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options. + /// + /// # Typical errors + /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) + receive-buffer-size: func() -> result; + @since(version = 0.2.0) + set-receive-buffer-size: func(value: u64) -> result<_, error-code>; + @since(version = 0.2.0) + send-buffer-size: func() -> result; + @since(version = 0.2.0) + set-send-buffer-size: func(value: u64) -> result<_, error-code>; + + /// Create a `pollable` which can be used to poll for, or block on, + /// completion of any of the asynchronous operations of this socket. + /// + /// When `finish-bind`, `finish-listen`, `finish-connect` or `accept` + /// return `error(would-block)`, this pollable can be used to wait for + /// their success or failure, after which the method can be retried. + /// + /// The pollable is not limited to the async operation that happens to be + /// in progress at the time of calling `subscribe` (if any). Theoretically, + /// `subscribe` only has to be called once per socket and can then be + /// (re)used for the remainder of the socket's lifetime. + /// + /// See + /// for more information. + /// + /// Note: this function is here for WASI 0.2 only. + /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) + subscribe: func() -> pollable; + + /// Initiate a graceful shutdown. + /// + /// - `receive`: The socket is not expecting to receive any data from + /// the peer. The `input-stream` associated with this socket will be + /// closed. Any data still in the receive queue at time of calling + /// this method will be discarded. + /// - `send`: The socket has no more data to send to the peer. The `output-stream` + /// associated with this socket will be closed and a FIN packet will be sent. + /// - `both`: Same effect as `receive` & `send` combined. + /// + /// This function is idempotent; shutting down a direction more than once + /// has no effect and returns `ok`. + /// + /// The shutdown function does not close (drop) the socket. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>; + } +} diff --git a/test-components/low-level-agent/wit/deps/sockets/udp-create-socket.wit b/test-components/low-level-agent/wit/deps/sockets/udp-create-socket.wit new file mode 100644 index 0000000000..e8eeacbfef --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/udp-create-socket.wit @@ -0,0 +1,30 @@ +@since(version = 0.2.0) +interface udp-create-socket { + @since(version = 0.2.0) + use network.{network, error-code, ip-address-family}; + @since(version = 0.2.0) + use udp.{udp-socket}; + + /// Create a new UDP socket. + /// + /// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX. + /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise. + /// + /// This function does not require a network capability handle. This is considered to be safe because + /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind` is called, + /// the socket is effectively an in-memory configuration object, unable to communicate with the outside world. + /// + /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations. + /// + /// # Typical errors + /// - `not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT) + /// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) + /// + /// # References: + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + create-udp-socket: func(address-family: ip-address-family) -> result; +} diff --git a/test-components/low-level-agent/wit/deps/sockets/udp.wit b/test-components/low-level-agent/wit/deps/sockets/udp.wit new file mode 100644 index 0000000000..01901ca27f --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/udp.wit @@ -0,0 +1,288 @@ +@since(version = 0.2.0) +interface udp { + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + @since(version = 0.2.0) + use network.{network, error-code, ip-socket-address, ip-address-family}; + + /// A received datagram. + @since(version = 0.2.0) + record incoming-datagram { + /// The payload. + /// + /// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes. + data: list, + + /// The source address. + /// + /// This field is guaranteed to match the remote address the stream was initialized with, if any. + /// + /// Equivalent to the `src_addr` out parameter of `recvfrom`. + remote-address: ip-socket-address, + } + + /// A datagram to be sent out. + @since(version = 0.2.0) + record outgoing-datagram { + /// The payload. + data: list, + + /// The destination address. + /// + /// The requirements on this field depend on how the stream was initialized: + /// - with a remote address: this field must be None or match the stream's remote address exactly. + /// - without a remote address: this field is required. + /// + /// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise it is equivalent to `sendto`. + remote-address: option, + } + + /// A UDP socket handle. + @since(version = 0.2.0) + resource udp-socket { + /// Bind the socket to a specific network on the provided IP address and port. + /// + /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which + /// network interface(s) to bind to. + /// If the port is zero, the socket will be bound to a random free port. + /// + /// # Typical errors + /// - `invalid-argument`: The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows) + /// - `invalid-state`: The socket is already bound. (EINVAL) + /// - `address-in-use`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows) + /// - `address-in-use`: Address is already in use. (EADDRINUSE) + /// - `address-not-bindable`: `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL) + /// - `not-in-progress`: A `bind` operation is not in progress. + /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) + /// + /// # Implementors note + /// Unlike in POSIX, in WASI the bind operation is async. This enables + /// interactive WASI hosts to inject permission prompts. Runtimes that + /// don't want to make use of this ability can simply call the native + /// `bind` as part of either `start-bind` or `finish-bind`. + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + start-bind: func(network: borrow, local-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) + finish-bind: func() -> result<_, error-code>; + + /// Set up inbound & outbound communication channels, optionally to a specific peer. + /// + /// This function only changes the local socket configuration and does not generate any network traffic. + /// On success, the `remote-address` of the socket is updated. The `local-address` may be updated as well, + /// based on the best network path to `remote-address`. + /// + /// When a `remote-address` is provided, the returned streams are limited to communicating with that specific peer: + /// - `send` can only be used to send to this destination. + /// - `receive` will only return datagrams sent from the provided `remote-address`. + /// + /// This method may be called multiple times on the same socket to change its association, but + /// only the most recently returned pair of streams will be operational. Implementations may trap if + /// the streams returned by a previous invocation haven't been dropped yet before calling `stream` again. + /// + /// The POSIX equivalent in pseudo-code is: + /// ```text + /// if (was previously connected) { + /// connect(s, AF_UNSPEC) + /// } + /// if (remote_address is Some) { + /// connect(s, remote_address) + /// } + /// ``` + /// + /// Unlike in POSIX, the socket must already be explicitly bound. + /// + /// # Typical errors + /// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) + /// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL) + /// - `invalid-argument`: The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL) + /// - `invalid-state`: The socket is not bound. + /// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD) + /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) + /// - `connection-refused`: The connection was refused. (ECONNREFUSED) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + %stream: func(remote-address: option) -> result, error-code>; + + /// Get the current bound address. + /// + /// POSIX mentions: + /// > If the socket has not been bound to a local name, the value + /// > stored in the object pointed to by `address` is unspecified. + /// + /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not bound to any local address. + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + local-address: func() -> result; + + /// Get the address the socket is currently streaming to. + /// + /// # Typical errors + /// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN) + /// + /// # References + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + remote-address: func() -> result; + + /// Whether this is a IPv4 or IPv6 socket. + /// + /// Equivalent to the SO_DOMAIN socket option. + @since(version = 0.2.0) + address-family: func() -> ip-address-family; + + /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// + /// # Typical errors + /// - `invalid-argument`: (set) The TTL value must be 1 or higher. + @since(version = 0.2.0) + unicast-hop-limit: func() -> result; + @since(version = 0.2.0) + set-unicast-hop-limit: func(value: u8) -> result<_, error-code>; + + /// The kernel buffer space reserved for sends/receives on this socket. + /// + /// If the provided value is 0, an `invalid-argument` error is returned. + /// Any other value will never cause an error, but it might be silently clamped and/or rounded. + /// I.e. after setting a value, reading the same setting back may return a different value. + /// + /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options. + /// + /// # Typical errors + /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) + receive-buffer-size: func() -> result; + @since(version = 0.2.0) + set-receive-buffer-size: func(value: u64) -> result<_, error-code>; + @since(version = 0.2.0) + send-buffer-size: func() -> result; + @since(version = 0.2.0) + set-send-buffer-size: func(value: u64) -> result<_, error-code>; + + /// Create a `pollable` which will resolve once the socket is ready for I/O. + /// + /// Note: this function is here for WASI 0.2 only. + /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) + subscribe: func() -> pollable; + } + + @since(version = 0.2.0) + resource incoming-datagram-stream { + /// Receive messages on the socket. + /// + /// This function attempts to receive up to `max-results` datagrams on the socket without blocking. + /// The returned list may contain fewer elements than requested, but never more. + /// + /// This function returns successfully with an empty list when either: + /// - `max-results` is 0, or: + /// - `max-results` is greater than 0, but no results are immediately available. + /// This function never returns `error(would-block)`. + /// + /// # Typical errors + /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) + /// - `connection-refused`: The connection was refused. (ECONNREFUSED) + /// + /// # References + /// - + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + receive: func(max-results: u64) -> result, error-code>; + + /// Create a `pollable` which will resolve once the stream is ready to receive again. + /// + /// Note: this function is here for WASI 0.2 only. + /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) + subscribe: func() -> pollable; + } + + @since(version = 0.2.0) + resource outgoing-datagram-stream { + /// Check readiness for sending. This function never blocks. + /// + /// Returns the number of datagrams permitted for the next call to `send`, + /// or an error. Calling `send` with more datagrams than this function has + /// permitted will trap. + /// + /// When this function returns ok(0), the `subscribe` pollable will + /// become ready when this function will report at least ok(1), or an + /// error. + /// + /// Never returns `would-block`. + check-send: func() -> result; + + /// Send messages on the socket. + /// + /// This function attempts to send all provided `datagrams` on the socket without blocking and + /// returns how many messages were actually sent (or queued for sending). This function never + /// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)` is returned. + /// + /// This function semantically behaves the same as iterating the `datagrams` list and sequentially + /// sending each individual datagram until either the end of the list has been reached or the first error occurred. + /// If at least one datagram has been sent successfully, this function never returns an error. + /// + /// If the input list is empty, the function returns `ok(0)`. + /// + /// Each call to `send` must be permitted by a preceding `check-send`. Implementations must trap if + /// either `check-send` was not called or `datagrams` contains more items than `check-send` permitted. + /// + /// # Typical errors + /// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) + /// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL) + /// - `invalid-argument`: The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL) + /// - `invalid-argument`: The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `stream`. (EISCONN) + /// - `invalid-argument`: The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ) + /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) + /// - `connection-refused`: The connection was refused. (ECONNREFUSED) + /// - `datagram-too-large`: The datagram is too large. (EMSGSIZE) + /// + /// # References + /// - + /// - + /// - + /// - + /// - + /// - + /// - + /// - + @since(version = 0.2.0) + send: func(datagrams: list) -> result; + + /// Create a `pollable` which will resolve once the stream is ready to send again. + /// + /// Note: this function is here for WASI 0.2 only. + /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) + subscribe: func() -> pollable; + } +} diff --git a/test-components/low-level-agent/wit/deps/sockets/world.wit b/test-components/low-level-agent/wit/deps/sockets/world.wit new file mode 100644 index 0000000000..2f0ad0d7c9 --- /dev/null +++ b/test-components/low-level-agent/wit/deps/sockets/world.wit @@ -0,0 +1,19 @@ +package wasi:sockets@0.2.3; + +@since(version = 0.2.0) +world imports { + @since(version = 0.2.0) + import instance-network; + @since(version = 0.2.0) + import network; + @since(version = 0.2.0) + import udp; + @since(version = 0.2.0) + import udp-create-socket; + @since(version = 0.2.0) + import tcp; + @since(version = 0.2.0) + import tcp-create-socket; + @since(version = 0.2.0) + import ip-name-lookup; +} diff --git a/test-components/networking.wasm b/test-components/networking.wasm index 4b14c7f971..5021d00154 100755 Binary files a/test-components/networking.wasm and b/test-components/networking.wasm differ diff --git a/test-components/networking/src/bindings.rs b/test-components/networking/src/bindings.rs index 15a6a5920d..8dad5d9648 100644 --- a/test-components/networking/src/bindings.rs +++ b/test-components/networking/src/bindings.rs @@ -384,12 +384,31 @@ pub mod golem { } } #[derive(Clone)] + pub struct WorkerWasiConfigVarsFilter { + pub name: _rt::String, + pub comparator: StringFilterComparator, + pub value: _rt::String, + } + impl ::core::fmt::Debug for WorkerWasiConfigVarsFilter { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("WorkerWasiConfigVarsFilter") + .field("name", &self.name) + .field("comparator", &self.comparator) + .field("value", &self.value) + .finish() + } + } + #[derive(Clone)] pub enum WorkerPropertyFilter { Name(WorkerNameFilter), Status(WorkerStatusFilter), Version(WorkerVersionFilter), CreatedAt(WorkerCreatedAtFilter), Env(WorkerEnvFilter), + WasiConfigVars(WorkerWasiConfigVarsFilter), } impl ::core::fmt::Debug for WorkerPropertyFilter { fn fmt( @@ -418,6 +437,11 @@ pub mod golem { WorkerPropertyFilter::Env(e) => { f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish() } + WorkerPropertyFilter::WasiConfigVars(e) => { + f.debug_tuple("WorkerPropertyFilter::WasiConfigVars") + .field(e) + .finish() + } } } } @@ -454,6 +478,7 @@ pub mod golem { pub worker_id: WorkerId, pub args: _rt::Vec<_rt::String>, pub env: _rt::Vec<(_rt::String, _rt::String)>, + pub wasi_config_vars: _rt::Vec<(_rt::String, _rt::String)>, pub status: WorkerStatus, pub component_version: u64, pub retry_count: u64, @@ -467,6 +492,7 @@ pub mod golem { .field("worker-id", &self.worker_id) .field("args", &self.args) .field("env", &self.env) + .field("wasi-config-vars", &self.wasi_config_vars) .field("status", &self.status) .field("component-version", &self.component_version) .field("retry-count", &self.retry_count) @@ -590,47 +616,47 @@ pub mod golem { high_bits: high_bits1, low_bits: low_bits1, } = uuid0; - let (result14_0, result14_1, result14_2) = match filter { + let (result17_0, result17_1, result17_2) = match filter { Some(e) => { let WorkerAnyFilter { filters: filters2 } = e; - let vec13 = filters2; - let len13 = vec13.len(); - let layout13 = _rt::alloc::Layout::from_size_align_unchecked( - vec13.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec16 = filters2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result13 = if layout13.size() != 0 { - let ptr = _rt::alloc::alloc(layout13).cast::(); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout13); + _rt::alloc::handle_alloc_error(layout16); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec13.into_iter().enumerate() { - let base = result13 + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { let WorkerAllFilter { filters: filters3 } = e; - let vec12 = filters3; - let len12 = vec12.len(); - let layout12 = _rt::alloc::Layout::from_size_align_unchecked( - vec12.len() + let vec15 = filters3; + let len15 = vec15.len(); + let layout15 = _rt::alloc::Layout::from_size_align_unchecked( + vec15.len() * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); - let result12 = if layout12.size() != 0 { - let ptr = _rt::alloc::alloc(layout12).cast::(); + let result15 = if layout15.size() != 0 { + let ptr = _rt::alloc::alloc(layout15).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout12); + _rt::alloc::handle_alloc_error(layout15); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec12.into_iter().enumerate() { - let base = result12 + for (i, e) in vec15.into_iter().enumerate() { + let base = result15 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); { match e { @@ -709,18 +735,45 @@ pub mod golem { .add(8 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = ptr11.cast_mut(); } + WorkerPropertyFilter::WasiConfigVars(e) => { + *base.add(0).cast::() = (5i32) as u8; + let WorkerWasiConfigVarsFilter { + name: name12, + comparator: comparator12, + value: value12, + } = e; + let vec13 = name12; + let ptr13 = vec13.as_ptr().cast::(); + let len13 = vec13.len(); + *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::() = len13; + *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::() = (comparator12.clone() as i32) as u8; + let vec14 = value12; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr14.cast_mut(); + } } } } *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(0).cast::<*mut u8>() = result12; - cleanup_list.extend_from_slice(&[(result12, layout12)]); + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = result15; + cleanup_list.extend_from_slice(&[(result15, layout15)]); } } - cleanup_list.extend_from_slice(&[(result13, layout13)]); - (1i32, result13, len13) + cleanup_list.extend_from_slice(&[(result16, layout16)]); + (1i32, result16, len16) } None => (0i32, ::core::ptr::null_mut(), 0usize), }; @@ -728,7 +781,7 @@ pub mod golem { #[link(wasm_import_module = "golem:api/host@1.1.7")] unsafe extern "C" { #[link_name = "[constructor]get-workers"] - fn wit_import15( + fn wit_import18( _: i64, _: i64, _: i32, @@ -738,7 +791,7 @@ pub mod golem { ) -> i32; } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import15( + unsafe extern "C" fn wit_import18( _: i64, _: i64, _: i32, @@ -749,12 +802,12 @@ pub mod golem { unreachable!() } let ret = unsafe { - wit_import15( + wit_import18( _rt::as_i64(high_bits1), _rt::as_i64(low_bits1), - result14_0, - result14_1, - result14_2, + result17_0, + result17_1, + result17_2, match &precise { true => 1, false => 0, @@ -798,7 +851,7 @@ pub mod golem { } unsafe { wit_import1((self).handle() as i32, ptr0) }; let l2 = i32::from(*ptr0.add(0).cast::()); - let result29 = match l2 { + let result38 = match l2 { 0 => None, 1 => { let e = { @@ -808,13 +861,13 @@ pub mod golem { let l4 = *ptr0 .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base28 = l3; - let len28 = l4; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); - let e28 = { + let base37 = l3; + let len37 = l4; + let mut result37 = _rt::Vec::with_capacity(len37); + for i in 0..len37 { + let base = base37 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); + let e37 = { let l5 = *base.add(0).cast::(); let l6 = *base.add(8).cast::(); let l7 = *base.add(16).cast::<*mut u8>(); @@ -903,16 +956,60 @@ pub mod golem { len24 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l25 = i32::from( + let l25 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l26 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base33 = l25; + let len33 = l26; + let mut result33 = _rt::Vec::with_capacity(len33); + for i in 0..len33 { + let base = base33 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e33 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l31 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) + }; + result33.push(e33); + } + _rt::cabi_dealloc( + base33, + len33 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l34 = i32::from( *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l26 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l35 = *base + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l27 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l36 = *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -926,25 +1023,26 @@ pub mod golem { }, args: result15, env: result24, - status: WorkerStatus::_lift(l25 as u8), - component_version: l26 as u64, - retry_count: l27 as u64, + wasi_config_vars: result33, + status: WorkerStatus::_lift(l34 as u8), + component_version: l35 as u64, + retry_count: l36 as u64, } }; - result28.push(e28); + result37.push(e37); } _rt::cabi_dealloc( - base28, - len28 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base37, + len37 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - result28 + result37 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result29 + result38 } } } @@ -1646,11 +1744,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 40 + 6 * ::core::mem::size_of::<*const u8>()], + >; 40 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 40 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let ptr0 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] @@ -1748,18 +1846,62 @@ pub mod golem { len21 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l22 = i32::from( + let l22 = *ptr0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l23 = *ptr0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base30 = l22; + let len30 = l23; + let mut result30 = _rt::Vec::with_capacity(len30); + for i in 0..len30 { + let base = base30 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e30 = { + let l24 = *base.add(0).cast::<*mut u8>(); + let l25 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) + }; + result30.push(e30); + } + _rt::cabi_dealloc( + base30, + len30 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l31 = i32::from( *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l23 = *ptr0 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l32 = *ptr0 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l24 = *ptr0 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l33 = *ptr0 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let result25 = WorkerMetadata { + let result34 = WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::golem::rpc::types::Uuid { @@ -1771,11 +1913,12 @@ pub mod golem { }, args: result12, env: result21, - status: WorkerStatus::_lift(l22 as u8), - component_version: l23 as u64, - retry_count: l24 as u64, + wasi_config_vars: result30, + status: WorkerStatus::_lift(l31 as u8), + component_version: l32 as u64, + retry_count: l33 as u64, }; - result25 + result34 } } #[allow(unused_unsafe, clippy::all)] @@ -1786,11 +1929,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let super::super::super::golem::rpc::types::WorkerId { component_id: component_id0, @@ -1833,7 +1976,7 @@ pub mod golem { ) }; let l6 = i32::from(*ptr4.add(0).cast::()); - let result30 = match l6 { + let result39 = match l6 { 0 => None, 1 => { let e = { @@ -1925,16 +2068,60 @@ pub mod golem { len26 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l27 = i32::from( + let l27 = *ptr4 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *ptr4 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base35 = l27; + let len35 = l28; + let mut result35 = _rt::Vec::with_capacity(len35); + for i in 0..len35 { + let base = base35 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e35 = { + let l29 = *base.add(0).cast::<*mut u8>(); + let l30 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len31 = l30; + let bytes31 = _rt::Vec::from_raw_parts( + l29.cast(), + len31, + len31, + ); + let l32 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l33 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len34 = l33; + let bytes34 = _rt::Vec::from_raw_parts( + l32.cast(), + len34, + len34, + ); + (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) + }; + result35.push(e35); + } + _rt::cabi_dealloc( + base35, + len35 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l36 = i32::from( *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l28 = *ptr4 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l37 = *ptr4 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *ptr4 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + let l38 = *ptr4 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -1948,16 +2135,17 @@ pub mod golem { }, args: result17, env: result26, - status: WorkerStatus::_lift(l27 as u8), - component_version: l28 as u64, - retry_count: l29 as u64, + wasi_config_vars: result35, + status: WorkerStatus::_lift(l36 as u8), + component_version: l37 as u64, + retry_count: l38 as u64, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result30 + result39 } } #[allow(unused_unsafe, clippy::all)] @@ -2549,6 +2737,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -2558,6 +2747,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -5785,26 +5975,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -5822,83 +6016,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -5916,245 +6131,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6163,7 +6378,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6172,43 +6387,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -6216,89 +6431,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -6309,13 +6524,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -6327,156 +6542,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -6717,26 +6932,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -6754,83 +6973,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -6848,245 +7088,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7095,7 +7335,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7104,106 +7344,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -7211,158 +7456,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -7370,7 +7615,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -7387,66 +7632,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, + ); + _rt::string_lift(bytes37) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes41) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -8929,8 +9196,8 @@ pub(crate) use __export_networking_impl as export; )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 6485] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xd41\x01A\x02\x01A\x1b\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 6641] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xf02\x01A\x02\x01A\x1c\ \x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[\ method]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollab\ le.block\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\ @@ -8955,111 +9222,114 @@ pe\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0cprim-s8 -type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0dprim\ -f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\0\x10\ prim-string-type\0\0\x0bhandle-type\x01\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01\ -ks\x01r\x02\x04name\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\ -\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05values\x04\0\x03u\ -ri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0cre\ -cord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\x0bflags-value\ -\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coption-value\x01\x12\ -\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\ -\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08p\ -rim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\ -\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\ -\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03\ -typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01s\0\x06deni\ -ed\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09rpc-error\ -\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\x04\0\x12\ -cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15[construc\ -tor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm-rpc.ephe\ -meral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffun\ -ction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\ -\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wasm-rpc.inv\ -oke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0<\x04\0'\ -[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0escheduled-time\ -\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rpc.schedule\ --invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\ -\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-invocation\x01\ -@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-invoke-resu\ -lt.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[method]future-i\ -nvoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![method]cancellat\ -ion-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\0\x0aparse\ --uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\x03vnt-\ -\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-type\x01\ -L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\0\x03\ -\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x09worker-id\x01B{\x02\x03\x02\ -\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\ -\0\x02\x02\x03\x02\x01\x08\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x09\ -worker-id\x03\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x09worker-id\x07\ -\x09oplog-idx\x09\x04\0\x0apromise-id\x03\0\x0a\x01w\x04\0\x11component-version\x03\ -\0\x0c\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x0e\x01r\x01\x04uuid\x05\x04\ -\0\x0aproject-id\x03\0\x10\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x01\x09m\ -ax-delay\x01\x0amultiplieru\x11max-jitter-factor\x12\x04\0\x0cretry-policy\x03\0\ -\x13\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\ -\0\0\x04\0\x11persistence-level\x03\0\x15\x01m\x02\x09automatic\x0esnapshot-base\ -d\x04\0\x0bupdate-mode\x03\0\x17\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\ -\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x19\x01m\x04\x05\ -equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1b\ -\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06\ -exited\x04\0\x0dworker-status\x03\0\x1d\x01r\x02\x0acomparator\x1c\x05values\x04\ -\0\x12worker-name-filter\x03\0\x1f\x01r\x02\x0acomparator\x1a\x05value\x1e\x04\0\ -\x14worker-status-filter\x03\0!\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x15wo\ -rker-version-filter\x03\0#\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x18worker-\ -created-at-filter\x03\0%\x01r\x03\x04names\x0acomparator\x1c\x05values\x04\0\x11\ -worker-env-filter\x03\0'\x01q\x05\x04name\x01\x20\0\x06status\x01\"\0\x07version\ -\x01$\0\x0acreated-at\x01&\0\x03env\x01(\0\x04\0\x16worker-property-filter\x03\0\ -)\x01p*\x01r\x01\x07filters+\x04\0\x11worker-all-filter\x03\0,\x01p-\x01r\x01\x07\ -filters.\x04\0\x11worker-any-filter\x03\0/\x01ps\x01o\x02ss\x01p2\x01r\x06\x09wo\ -rker-id\x07\x04args1\x03env3\x06status\x1e\x11component-versionw\x0bretry-countw\ -\x04\0\x0fworker-metadata\x03\04\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert\ --to-oplog-index\x01\x09\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-work\ -er-target\x03\07\x01m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\09\x01k\ -0\x01i6\x01@\x03\x0ccomponent-id\x03\x06filter;\x07precise\x7f\0<\x04\0\x18[cons\ -tructor]get-workers\x01=\x01h6\x01p5\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[m\ -ethod]get-workers.get-next\x01A\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01B\x01p}\x01\ -@\x01\x0apromise-id\x0b\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\x0a\ -promise-id\x0b\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x0b\x04\ -data\xc3\0\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x0b\x01\0\ -\x04\0\x0edelete-promise\x01H\x01@\0\0\x09\x04\0\x0fget-oplog-index\x01I\x01@\x01\ -\x09oplog-idx\x09\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\ -\x04\0\x0coplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\ -\x09\x01\0\x04\0\x12mark-end-operation\x01L\x01@\0\0\x14\x04\0\x10get-retry-poli\ -cy\x01M\x01@\x01\x10new-retry-policy\x14\x01\0\x04\0\x10set-retry-policy\x01N\x01\ -@\0\0\x16\x04\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-\ -level\x16\x01\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14\ -get-idempotence-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempote\ -nce-mode\x01R\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09wo\ -rker-id\x07\x0etarget-version\x0d\x04mode\x18\x01\0\x04\0\x0dupdate-worker\x01T\x01\ -@\0\05\x04\0\x11get-self-metadata\x01U\x01k5\x01@\x01\x09worker-id\x07\0\xd6\0\x04\ -\0\x13get-worker-metadata\x01W\x01@\x03\x10source-worker-id\x07\x10target-worker\ --id\x07\x11oplog-idx-cut-off\x09\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09wor\ -ker-id\x07\x0drevert-target8\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x03\x01@\x01\ -\x13component-references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x07\x01\ -@\x02\x13component-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\ -\x01]\x04\0\x18resolve-worker-id-strict\x01]\x01@\x01\x08new-names\0:\x04\0\x04f\ -ork\x01^\x03\0\x14golem:api/host@1.1.7\x05\x0a\x01B\x11\x04\0\x07network\x03\x01\ -\x01m\x15\x07unknown\x0daccess-denied\x0dnot-supported\x10invalid-argument\x0dou\ -t-of-memory\x07timeout\x14concurrency-conflict\x0fnot-in-progress\x0bwould-block\ -\x0dinvalid-state\x10new-socket-limit\x14address-not-bindable\x0eaddress-in-use\x12\ -remote-unreachable\x12connection-refused\x10connection-reset\x12connection-abort\ -ed\x12datagram-too-large\x11name-unresolvable\x1atemporary-resolver-failure\x1ap\ -ermanent-resolver-failure\x04\0\x0aerror-code\x03\0\x01\x01m\x02\x04ipv4\x04ipv6\ -\x04\0\x11ip-address-family\x03\0\x03\x01o\x04}}}}\x04\0\x0cipv4-address\x03\0\x05\ -\x01o\x08{{{{{{{{\x04\0\x0cipv6-address\x03\0\x07\x01q\x02\x04ipv4\x01\x06\0\x04\ -ipv6\x01\x08\0\x04\0\x0aip-address\x03\0\x09\x01r\x02\x04port{\x07address\x06\x04\ -\0\x13ipv4-socket-address\x03\0\x0b\x01r\x04\x04port{\x09flow-infoy\x07address\x08\ -\x08scope-idy\x04\0\x13ipv6-socket-address\x03\0\x0d\x01q\x02\x04ipv4\x01\x0c\0\x04\ -ipv6\x01\x0e\0\x04\0\x11ip-socket-address\x03\0\x0f\x03\0\x1awasi:sockets/networ\ -k@0.2.3\x05\x0b\x02\x03\0\x05\x07network\x02\x03\0\x05\x0aerror-code\x02\x03\0\x05\ +ks\x01r\x03\x04name\x1b\x05owner\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\ +\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05va\ +lues\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\ +\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\ +\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coptio\ +n-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08\ +prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-\ +s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09p\ +rim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\ +\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\ +\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01\ +s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09\ +rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\ +\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15\ +[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm\ +-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-nam\ +es\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01\ +/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wa\ +sm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\ +\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0esche\ +duled-time\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rp\ +c.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunc\ +tion-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-inv\ +ocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-\ +invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[meth\ +od]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![metho\ +d]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\ +\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\ +\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-\ +type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\ +\0\x03\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x0evalue-and-type\x02\ +\x03\0\x03\x09worker-id\x01B\x7f\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\ +\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\x03\x02\x01\x08\x04\0\x04uu\ +id\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x0evalue-and-type\x03\0\x06\x02\x03\x02\x01\ +\x0a\x04\0\x09worker-id\x03\0\x08\x01w\x04\0\x0boplog-index\x03\0\x0a\x01r\x02\x09\ +worker-id\x09\x09oplog-idx\x0b\x04\0\x0apromise-id\x03\0\x0c\x01w\x04\0\x11compo\ +nent-version\x03\0\x0e\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x10\x01r\x01\ +\x04uuid\x05\x04\0\x0aproject-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09mi\ +n-delay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cre\ +try-policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effe\ +cts\0\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0e\ +snapshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0d\ +greater-equal\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\ +\x01m\x04\x05equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-compa\ +rator\x03\0\x1d\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retry\ +ing\x06failed\x06exited\x04\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\ +\x05values\x04\0\x12worker-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05valu\ +e\x20\x04\0\x14worker-status-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\ +\0\x15worker-version-filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18\ +worker-created-at-filter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x11worker-env-filter\x03\0)\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x1eworker-wasi-config-vars-filter\x03\0+\x01q\x06\x04name\x01\"\0\x06status\x01\ +$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\0\x10wasi-config-vars\x01\ +,\0\x04\0\x16worker-property-filter\x03\0-\x01p.\x01r\x01\x07filters/\x04\0\x11w\ +orker-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x11worker-any-filter\x03\ +\03\x01ps\x01o\x02ss\x01p6\x01r\x07\x09worker-id\x09\x04args5\x03env7\x10wasi-co\ +nfig-vars7\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\ +etadata\x03\08\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\ +\x0b\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0;\x01\ +m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\0=\x01k4\x01i:\x01@\x03\x0c\ +component-id\x03\x06filter?\x07precise\x7f\0\xc0\0\x04\0\x18[constructor]get-wor\ +kers\x01A\x01h:\x01p9\x01k\xc3\0\x01@\x01\x04self\xc2\0\0\xc4\0\x04\0\x1c[method\ +]get-workers.get-next\x01E\x01@\0\0\x0d\x04\0\x0ecreate-promise\x01F\x01p}\x01@\x01\ +\x0apromise-id\x0d\0\xc7\0\x04\0\x0dawait-promise\x01H\x01k\xc7\0\x01@\x01\x0apr\ +omise-id\x0d\0\xc9\0\x04\0\x0cpoll-promise\x01J\x01@\x02\x0apromise-id\x0d\x04da\ +ta\xc7\0\0\x7f\x04\0\x10complete-promise\x01K\x01@\x01\x0apromise-id\x0d\x01\0\x04\ +\0\x0edelete-promise\x01L\x01@\0\0\x0b\x04\0\x0fget-oplog-index\x01M\x01@\x01\x09\ +oplog-idx\x0b\x01\0\x04\0\x0fset-oplog-index\x01N\x01@\x01\x08replicas}\x01\0\x04\ +\0\x0coplog-commit\x01O\x04\0\x14mark-begin-operation\x01M\x01@\x01\x05begin\x0b\ +\x01\0\x04\0\x12mark-end-operation\x01P\x01@\0\0\x16\x04\0\x10get-retry-policy\x01\ +Q\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01R\x01@\0\0\ +\x18\x04\0\x1bget-oplog-persistence-level\x01S\x01@\x01\x15new-persistence-level\ +\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01T\x01@\0\0\x7f\x04\0\x14get-i\ +dempotence-mode\x01U\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-m\ +ode\x01V\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01W\x01@\x03\x09worker-\ +id\x09\x0etarget-version\x0f\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01X\x01@\0\ +\09\x04\0\x11get-self-metadata\x01Y\x01k9\x01@\x01\x09worker-id\x09\0\xda\0\x04\0\ +\x13get-worker-metadata\x01[\x01@\x03\x10source-worker-id\x09\x10target-worker-i\ +d\x09\x11oplog-idx-cut-off\x0b\x01\0\x04\0\x0bfork-worker\x01\\\x01@\x02\x09work\ +er-id\x09\x0drevert-target<\x01\0\x04\0\x0drevert-worker\x01]\x01k\x03\x01@\x01\x13\ +component-references\0\xde\0\x04\0\x14resolve-component-id\x01_\x01k\x09\x01@\x02\ +\x13component-references\x0bworker-names\0\xe0\0\x04\0\x11resolve-worker-id\x01a\ +\x04\0\x18resolve-worker-id-strict\x01a\x01@\x01\x08new-names\0>\x04\0\x04fork\x01\ +b\x03\0\x14golem:api/host@1.1.7\x05\x0b\x01B\x11\x04\0\x07network\x03\x01\x01m\x15\ +\x07unknown\x0daccess-denied\x0dnot-supported\x10invalid-argument\x0dout-of-memo\ +ry\x07timeout\x14concurrency-conflict\x0fnot-in-progress\x0bwould-block\x0dinval\ +id-state\x10new-socket-limit\x14address-not-bindable\x0eaddress-in-use\x12remote\ +-unreachable\x12connection-refused\x10connection-reset\x12connection-aborted\x12\ +datagram-too-large\x11name-unresolvable\x1atemporary-resolver-failure\x1apermane\ +nt-resolver-failure\x04\0\x0aerror-code\x03\0\x01\x01m\x02\x04ipv4\x04ipv6\x04\0\ +\x11ip-address-family\x03\0\x03\x01o\x04}}}}\x04\0\x0cipv4-address\x03\0\x05\x01\ +o\x08{{{{{{{{\x04\0\x0cipv6-address\x03\0\x07\x01q\x02\x04ipv4\x01\x06\0\x04ipv6\ +\x01\x08\0\x04\0\x0aip-address\x03\0\x09\x01r\x02\x04port{\x07address\x06\x04\0\x13\ +ipv4-socket-address\x03\0\x0b\x01r\x04\x04port{\x09flow-infoy\x07address\x08\x08\ +scope-idy\x04\0\x13ipv6-socket-address\x03\0\x0d\x01q\x02\x04ipv4\x01\x0c\0\x04i\ +pv6\x01\x0e\0\x04\0\x11ip-socket-address\x03\0\x0f\x03\0\x1awasi:sockets/network\ +@0.2.3\x05\x0c\x02\x03\0\x05\x07network\x02\x03\0\x05\x0aerror-code\x02\x03\0\x05\ \x0aip-address\x01B\x16\x02\x03\x02\x01\x01\x04\0\x08pollable\x03\0\0\x02\x03\x02\ -\x01\x0c\x04\0\x07network\x03\0\x02\x02\x03\x02\x01\x0d\x04\0\x0aerror-code\x03\0\ -\x04\x02\x03\x02\x01\x0e\x04\0\x0aip-address\x03\0\x06\x04\0\x16resolve-address-\ +\x01\x0d\x04\0\x07network\x03\0\x02\x02\x03\x02\x01\x0e\x04\0\x0aerror-code\x03\0\ +\x04\x02\x03\x02\x01\x0f\x04\0\x0aip-address\x03\0\x06\x04\0\x16resolve-address-\ stream\x03\x01\x01h\x08\x01k\x07\x01j\x01\x0a\x01\x05\x01@\x01\x04self\x09\0\x0b\ \x04\03[method]resolve-address-stream.resolve-next-address\x01\x0c\x01i\x01\x01@\ \x01\x04self\x09\0\x0d\x04\0([method]resolve-address-stream.subscribe\x01\x0e\x01\ h\x03\x01i\x08\x01j\x01\x10\x01\x05\x01@\x02\x07network\x0f\x04names\0\x11\x04\0\ -\x11resolve-addresses\x01\x12\x03\0!wasi:sockets/ip-name-lookup@0.2.3\x05\x0f\x01\ -B\x05\x02\x03\x02\x01\x0c\x04\0\x07network\x03\0\0\x01i\x01\x01@\0\0\x02\x04\0\x10\ -instance-network\x01\x03\x03\0#wasi:sockets/instance-network@0.2.3\x05\x10\x01B\x03\ -\x01ps\x01@\0\0\0\x04\0\x03get\x01\x01\x04\0\x0cgolem:it/api\x05\x11\x04\0\x13go\ +\x11resolve-addresses\x01\x12\x03\0!wasi:sockets/ip-name-lookup@0.2.3\x05\x10\x01\ +B\x05\x02\x03\x02\x01\x0d\x04\0\x07network\x03\0\0\x01i\x01\x01@\0\0\x02\x04\0\x10\ +instance-network\x01\x03\x03\0#wasi:sockets/instance-network@0.2.3\x05\x11\x01B\x03\ +\x01ps\x01@\0\0\0\x04\0\x03get\x01\x01\x04\0\x0cgolem:it/api\x05\x12\x04\0\x13go\ lem:it/networking\x04\0\x0b\x10\x01\0\x0anetworking\x03\0\0\0G\x09producers\x01\x0c\ processed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.41.0"; #[inline(never)] diff --git a/test-components/networking/wit/deps.lock b/test-components/networking/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/networking/wit/deps.lock +++ b/test-components/networking/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/networking/wit/deps.toml b/test-components/networking/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/networking/wit/deps.toml +++ b/test-components/networking/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/networking/wit/deps/golem-1.x/golem-host.wit b/test-components/networking/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/networking/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/networking/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/networking/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/networking/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/networking/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/networking/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/oplog-processor.wasm b/test-components/oplog-processor.wasm index 9fab0a1d1b..de4ec1d19a 100644 Binary files a/test-components/oplog-processor.wasm and b/test-components/oplog-processor.wasm differ diff --git a/test-components/oplog-processor/src/bindings.rs b/test-components/oplog-processor/src/bindings.rs index fd8ed9eb31..5e787d57ed 100644 --- a/test-components/oplog-processor/src/bindings.rs +++ b/test-components/oplog-processor/src/bindings.rs @@ -411,12 +411,31 @@ pub mod golem { } } #[derive(Clone)] + pub struct WorkerWasiConfigVarsFilter { + pub name: _rt::String, + pub comparator: StringFilterComparator, + pub value: _rt::String, + } + impl ::core::fmt::Debug for WorkerWasiConfigVarsFilter { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("WorkerWasiConfigVarsFilter") + .field("name", &self.name) + .field("comparator", &self.comparator) + .field("value", &self.value) + .finish() + } + } + #[derive(Clone)] pub enum WorkerPropertyFilter { Name(WorkerNameFilter), Status(WorkerStatusFilter), Version(WorkerVersionFilter), CreatedAt(WorkerCreatedAtFilter), Env(WorkerEnvFilter), + WasiConfigVars(WorkerWasiConfigVarsFilter), } impl ::core::fmt::Debug for WorkerPropertyFilter { fn fmt( @@ -445,6 +464,11 @@ pub mod golem { WorkerPropertyFilter::Env(e) => { f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish() } + WorkerPropertyFilter::WasiConfigVars(e) => { + f.debug_tuple("WorkerPropertyFilter::WasiConfigVars") + .field(e) + .finish() + } } } } @@ -481,6 +505,7 @@ pub mod golem { pub worker_id: WorkerId, pub args: _rt::Vec<_rt::String>, pub env: _rt::Vec<(_rt::String, _rt::String)>, + pub wasi_config_vars: _rt::Vec<(_rt::String, _rt::String)>, pub status: WorkerStatus, pub component_version: u64, pub retry_count: u64, @@ -494,6 +519,7 @@ pub mod golem { .field("worker-id", &self.worker_id) .field("args", &self.args) .field("env", &self.env) + .field("wasi-config-vars", &self.wasi_config_vars) .field("status", &self.status) .field("component-version", &self.component_version) .field("retry-count", &self.retry_count) @@ -617,47 +643,47 @@ pub mod golem { high_bits: high_bits1, low_bits: low_bits1, } = uuid0; - let (result14_0, result14_1, result14_2) = match filter { + let (result17_0, result17_1, result17_2) = match filter { Some(e) => { let WorkerAnyFilter { filters: filters2 } = e; - let vec13 = filters2; - let len13 = vec13.len(); - let layout13 = _rt::alloc::Layout::from_size_align_unchecked( - vec13.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec16 = filters2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result13 = if layout13.size() != 0 { - let ptr = _rt::alloc::alloc(layout13).cast::(); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout13); + _rt::alloc::handle_alloc_error(layout16); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec13.into_iter().enumerate() { - let base = result13 + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { let WorkerAllFilter { filters: filters3 } = e; - let vec12 = filters3; - let len12 = vec12.len(); - let layout12 = _rt::alloc::Layout::from_size_align_unchecked( - vec12.len() + let vec15 = filters3; + let len15 = vec15.len(); + let layout15 = _rt::alloc::Layout::from_size_align_unchecked( + vec15.len() * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); - let result12 = if layout12.size() != 0 { - let ptr = _rt::alloc::alloc(layout12).cast::(); + let result15 = if layout15.size() != 0 { + let ptr = _rt::alloc::alloc(layout15).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout12); + _rt::alloc::handle_alloc_error(layout15); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec12.into_iter().enumerate() { - let base = result12 + for (i, e) in vec15.into_iter().enumerate() { + let base = result15 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); { match e { @@ -736,18 +762,45 @@ pub mod golem { .add(8 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = ptr11.cast_mut(); } + WorkerPropertyFilter::WasiConfigVars(e) => { + *base.add(0).cast::() = (5i32) as u8; + let WorkerWasiConfigVarsFilter { + name: name12, + comparator: comparator12, + value: value12, + } = e; + let vec13 = name12; + let ptr13 = vec13.as_ptr().cast::(); + let len13 = vec13.len(); + *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::() = len13; + *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::() = (comparator12.clone() as i32) as u8; + let vec14 = value12; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr14.cast_mut(); + } } } } *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(0).cast::<*mut u8>() = result12; - cleanup_list.extend_from_slice(&[(result12, layout12)]); + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = result15; + cleanup_list.extend_from_slice(&[(result15, layout15)]); } } - cleanup_list.extend_from_slice(&[(result13, layout13)]); - (1i32, result13, len13) + cleanup_list.extend_from_slice(&[(result16, layout16)]); + (1i32, result16, len16) } None => (0i32, ::core::ptr::null_mut(), 0usize), }; @@ -755,7 +808,7 @@ pub mod golem { #[link(wasm_import_module = "golem:api/host@1.1.7")] unsafe extern "C" { #[link_name = "[constructor]get-workers"] - fn wit_import15( + fn wit_import18( _: i64, _: i64, _: i32, @@ -765,7 +818,7 @@ pub mod golem { ) -> i32; } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import15( + unsafe extern "C" fn wit_import18( _: i64, _: i64, _: i32, @@ -776,12 +829,12 @@ pub mod golem { unreachable!() } let ret = unsafe { - wit_import15( + wit_import18( _rt::as_i64(high_bits1), _rt::as_i64(low_bits1), - result14_0, - result14_1, - result14_2, + result17_0, + result17_1, + result17_2, match &precise { true => 1, false => 0, @@ -825,7 +878,7 @@ pub mod golem { } unsafe { wit_import1((self).handle() as i32, ptr0) }; let l2 = i32::from(*ptr0.add(0).cast::()); - let result29 = match l2 { + let result38 = match l2 { 0 => None, 1 => { let e = { @@ -835,13 +888,13 @@ pub mod golem { let l4 = *ptr0 .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base28 = l3; - let len28 = l4; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); - let e28 = { + let base37 = l3; + let len37 = l4; + let mut result37 = _rt::Vec::with_capacity(len37); + for i in 0..len37 { + let base = base37 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); + let e37 = { let l5 = *base.add(0).cast::(); let l6 = *base.add(8).cast::(); let l7 = *base.add(16).cast::<*mut u8>(); @@ -930,16 +983,60 @@ pub mod golem { len24 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l25 = i32::from( + let l25 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l26 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base33 = l25; + let len33 = l26; + let mut result33 = _rt::Vec::with_capacity(len33); + for i in 0..len33 { + let base = base33 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e33 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l31 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) + }; + result33.push(e33); + } + _rt::cabi_dealloc( + base33, + len33 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l34 = i32::from( *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l26 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l35 = *base + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l27 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l36 = *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -953,25 +1050,26 @@ pub mod golem { }, args: result15, env: result24, - status: WorkerStatus::_lift(l25 as u8), - component_version: l26 as u64, - retry_count: l27 as u64, + wasi_config_vars: result33, + status: WorkerStatus::_lift(l34 as u8), + component_version: l35 as u64, + retry_count: l36 as u64, } }; - result28.push(e28); + result37.push(e37); } _rt::cabi_dealloc( - base28, - len28 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base37, + len37 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - result28 + result37 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result29 + result38 } } } @@ -1673,11 +1771,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 40 + 6 * ::core::mem::size_of::<*const u8>()], + >; 40 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 40 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let ptr0 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] @@ -1775,18 +1873,62 @@ pub mod golem { len21 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l22 = i32::from( + let l22 = *ptr0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l23 = *ptr0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base30 = l22; + let len30 = l23; + let mut result30 = _rt::Vec::with_capacity(len30); + for i in 0..len30 { + let base = base30 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e30 = { + let l24 = *base.add(0).cast::<*mut u8>(); + let l25 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) + }; + result30.push(e30); + } + _rt::cabi_dealloc( + base30, + len30 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l31 = i32::from( *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l23 = *ptr0 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l32 = *ptr0 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l24 = *ptr0 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l33 = *ptr0 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let result25 = WorkerMetadata { + let result34 = WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::golem::rpc::types::Uuid { @@ -1798,11 +1940,12 @@ pub mod golem { }, args: result12, env: result21, - status: WorkerStatus::_lift(l22 as u8), - component_version: l23 as u64, - retry_count: l24 as u64, + wasi_config_vars: result30, + status: WorkerStatus::_lift(l31 as u8), + component_version: l32 as u64, + retry_count: l33 as u64, }; - result25 + result34 } } #[allow(unused_unsafe, clippy::all)] @@ -1813,11 +1956,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let super::super::super::golem::rpc::types::WorkerId { component_id: component_id0, @@ -1860,7 +2003,7 @@ pub mod golem { ) }; let l6 = i32::from(*ptr4.add(0).cast::()); - let result30 = match l6 { + let result39 = match l6 { 0 => None, 1 => { let e = { @@ -1952,16 +2095,60 @@ pub mod golem { len26 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l27 = i32::from( + let l27 = *ptr4 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *ptr4 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base35 = l27; + let len35 = l28; + let mut result35 = _rt::Vec::with_capacity(len35); + for i in 0..len35 { + let base = base35 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e35 = { + let l29 = *base.add(0).cast::<*mut u8>(); + let l30 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len31 = l30; + let bytes31 = _rt::Vec::from_raw_parts( + l29.cast(), + len31, + len31, + ); + let l32 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l33 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len34 = l33; + let bytes34 = _rt::Vec::from_raw_parts( + l32.cast(), + len34, + len34, + ); + (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) + }; + result35.push(e35); + } + _rt::cabi_dealloc( + base35, + len35 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l36 = i32::from( *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l28 = *ptr4 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l37 = *ptr4 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *ptr4 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + let l38 = *ptr4 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -1975,16 +2162,17 @@ pub mod golem { }, args: result17, env: result26, - status: WorkerStatus::_lift(l27 as u8), - component_version: l28 as u64, - retry_count: l29 as u64, + wasi_config_vars: result35, + status: WorkerStatus::_lift(l36 as u8), + component_version: l37 as u64, + retry_count: l38 as u64, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result30 + result39 } } #[allow(unused_unsafe, clippy::all)] @@ -11928,6 +12116,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -11937,6 +12126,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -15164,26 +15354,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -15201,83 +15395,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -15295,245 +15510,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -15542,7 +15757,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -15551,43 +15766,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -15595,89 +15810,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -15688,13 +15903,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -15706,156 +15921,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -16096,26 +16311,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -16133,83 +16352,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -16227,245 +16467,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -16474,7 +16714,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -16483,106 +16723,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -16590,158 +16835,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -16749,7 +16994,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -16766,66 +17011,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes37) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, + ); + _rt::string_lift(bytes41) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -17548,380 +17815,424 @@ pub mod exports { len25 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l26 = i32::from( + let l26 = *arg0 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l27 = *arg0 + .add(40 + 9 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base34 = l26; + let len34 = l27; + let mut result34 = _rt::Vec::with_capacity(len34); + for i in 0..len34 { + let base = base34 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e34 = { + let l28 = *base.add(0).cast::<*mut u8>(); + let l29 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len30 = l29; + let bytes30 = _rt::Vec::from_raw_parts( + l28.cast(), + len30, + len30, + ); + let l31 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l32 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len33 = l32; + let bytes33 = _rt::Vec::from_raw_parts( + l31.cast(), + len33, + len33, + ); + (_rt::string_lift(bytes30), _rt::string_lift(bytes33)) + }; + result34.push(e34); + } + _rt::cabi_dealloc( + base34, + len34 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l35 = i32::from( *arg0 - .add(40 + 8 * ::core::mem::size_of::<*const u8>()) + .add(40 + 10 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l27 = *arg0 - .add(48 + 8 * ::core::mem::size_of::<*const u8>()) + let l36 = *arg0 + .add(48 + 10 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l28 = *arg0 - .add(56 + 8 * ::core::mem::size_of::<*const u8>()) + let l37 = *arg0 + .add(56 + 10 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *arg0 - .add(64 + 8 * ::core::mem::size_of::<*const u8>()) + let l38 = *arg0 + .add(64 + 10 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l30 = *arg0 - .add(72 + 8 * ::core::mem::size_of::<*const u8>()) + let l39 = *arg0 + .add(72 + 10 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l31 = *arg0 - .add(72 + 9 * ::core::mem::size_of::<*const u8>()) + let l40 = *arg0 + .add(72 + 11 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base656 = l30; - let len656 = l31; - let mut result656 = _rt::Vec::with_capacity(len656); - for i in 0..len656 { - let base = base656 + let base665 = l39; + let len665 = l40; + let mut result665 = _rt::Vec::with_capacity(len665); + for i in 0..len665 { + let base = base665 .add(i * (104 + 12 * ::core::mem::size_of::<*const u8>())); - let e656 = { - let l32 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::api::oplog::OplogEntry as V655; - let v655 = match l32 { + let e665 = { + let l41 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::api::oplog::OplogEntry as V664; + let v664 = match l41 { 0 => { - let e655 = { - let l33 = *base.add(8).cast::(); - let l34 = *base.add(16).cast::(); - let l35 = *base.add(24).cast::(); - let l36 = *base.add(32).cast::(); - let l37 = *base.add(40).cast::<*mut u8>(); - let l38 = *base + let e664 = { + let l42 = *base.add(8).cast::(); + let l43 = *base.add(16).cast::(); + let l44 = *base.add(24).cast::(); + let l45 = *base.add(32).cast::(); + let l46 = *base.add(40).cast::<*mut u8>(); + let l47 = *base .add(40 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len39 = l38; - let bytes39 = _rt::Vec::from_raw_parts( - l37.cast(), - len39, - len39, + let len48 = l47; + let bytes48 = _rt::Vec::from_raw_parts( + l46.cast(), + len48, + len48, ); - let l40 = *base + let l49 = *base .add(40 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l41 = *base + let l50 = *base .add(48 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l42 = *base + let l51 = *base .add(48 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base46 = l41; - let len46 = l42; - let mut result46 = _rt::Vec::with_capacity(len46); - for i in 0..len46 { - let base = base46 + let base55 = l50; + let len55 = l51; + let mut result55 = _rt::Vec::with_capacity(len55); + for i in 0..len55 { + let base = base55 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e46 = { - let l43 = *base.add(0).cast::<*mut u8>(); - let l44 = *base + let e55 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len45 = l44; - let bytes45 = _rt::Vec::from_raw_parts( - l43.cast(), - len45, - len45, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - _rt::string_lift(bytes45) + _rt::string_lift(bytes54) }; - result46.push(e46); + result55.push(e55); } _rt::cabi_dealloc( - base46, - len46 * (2 * ::core::mem::size_of::<*const u8>()), + base55, + len55 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l47 = *base + let l56 = *base .add(48 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l48 = *base + let l57 = *base .add(48 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base55 = l47; - let len55 = l48; - let mut result55 = _rt::Vec::with_capacity(len55); - for i in 0..len55 { - let base = base55 + let base64 = l56; + let len64 = l57; + let mut result64 = _rt::Vec::with_capacity(len64); + for i in 0..len64 { + let base = base64 .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e55 = { - let l49 = *base.add(0).cast::<*mut u8>(); - let l50 = *base + let e64 = { + let l58 = *base.add(0).cast::<*mut u8>(); + let l59 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len51 = l50; - let bytes51 = _rt::Vec::from_raw_parts( - l49.cast(), - len51, - len51, + let len60 = l59; + let bytes60 = _rt::Vec::from_raw_parts( + l58.cast(), + len60, + len60, ); - let l52 = *base + let l61 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l53 = *base + let l62 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len54 = l53; - let bytes54 = _rt::Vec::from_raw_parts( - l52.cast(), - len54, - len54, + let len63 = l62; + let bytes63 = _rt::Vec::from_raw_parts( + l61.cast(), + len63, + len63, ); - (_rt::string_lift(bytes51), _rt::string_lift(bytes54)) + (_rt::string_lift(bytes60), _rt::string_lift(bytes63)) }; - result55.push(e55); + result64.push(e64); } _rt::cabi_dealloc( - base55, - len55 * (4 * ::core::mem::size_of::<*const u8>()), + base64, + len64 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l56 = *base + let l65 = *base .add(48 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l57 = *base + let l66 = *base .add(48 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len58 = l57; - let bytes58 = _rt::Vec::from_raw_parts( - l56.cast(), - len58, - len58, + let len67 = l66; + let bytes67 = _rt::Vec::from_raw_parts( + l65.cast(), + len67, + len67, ); - let l59 = *base + let l68 = *base .add(48 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l60 = *base + let l69 = *base .add(56 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l61 = i32::from( + let l70 = i32::from( *base .add(64 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l67 = *base + let l76 = *base .add(88 + 10 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l68 = *base + let l77 = *base .add(96 + 10 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l69 = *base + let l78 = *base .add(104 + 10 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l70 = *base + let l79 = *base .add(104 + 11 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base88 = l69; - let len88 = l70; - let mut result88 = _rt::Vec::with_capacity(len88); - for i in 0..len88 { - let base = base88 + let base97 = l78; + let len97 = l79; + let mut result97 = _rt::Vec::with_capacity(len97); + for i in 0..len97 { + let base = base97 .add(i * (16 + 6 * ::core::mem::size_of::<*const u8>())); - let e88 = { - let l71 = *base.add(0).cast::(); - let l72 = *base.add(8).cast::(); - let l73 = *base.add(16).cast::<*mut u8>(); - let l74 = *base + let e97 = { + let l80 = *base.add(0).cast::(); + let l81 = *base.add(8).cast::(); + let l82 = *base.add(16).cast::<*mut u8>(); + let l83 = *base .add(16 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len84 = l83; + let bytes84 = _rt::Vec::from_raw_parts( + l82.cast(), + len84, + len84, ); - let l76 = *base + let l85 = *base .add(16 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l77 = *base + let l86 = *base .add(16 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len78 = l77; - let bytes78 = _rt::Vec::from_raw_parts( - l76.cast(), - len78, - len78, + let len87 = l86; + let bytes87 = _rt::Vec::from_raw_parts( + l85.cast(), + len87, + len87, ); - let l79 = *base + let l88 = *base .add(16 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l80 = *base + let l89 = *base .add(16 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base87 = l79; - let len87 = l80; - let mut result87 = _rt::Vec::with_capacity(len87); - for i in 0..len87 { - let base = base87 + let base96 = l88; + let len96 = l89; + let mut result96 = _rt::Vec::with_capacity(len96); + for i in 0..len96 { + let base = base96 .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e87 = { - let l81 = *base.add(0).cast::<*mut u8>(); - let l82 = *base + let e96 = { + let l90 = *base.add(0).cast::<*mut u8>(); + let l91 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len83 = l82; - let bytes83 = _rt::Vec::from_raw_parts( - l81.cast(), - len83, - len83, + let len92 = l91; + let bytes92 = _rt::Vec::from_raw_parts( + l90.cast(), + len92, + len92, ); - let l84 = *base + let l93 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l85 = *base + let l94 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len86 = l85; - let bytes86 = _rt::Vec::from_raw_parts( - l84.cast(), - len86, - len86, + let len95 = l94; + let bytes95 = _rt::Vec::from_raw_parts( + l93.cast(), + len95, + len95, ); - (_rt::string_lift(bytes83), _rt::string_lift(bytes86)) + (_rt::string_lift(bytes92), _rt::string_lift(bytes95)) }; - result87.push(e87); + result96.push(e96); } _rt::cabi_dealloc( - base87, - len87 * (4 * ::core::mem::size_of::<*const u8>()), + base96, + len96 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::PluginInstallationDescription { installation_id: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l71 as u64, - low_bits: l72 as u64, + high_bits: l80 as u64, + low_bits: l81 as u64, }, - name: _rt::string_lift(bytes75), - version: _rt::string_lift(bytes78), - parameters: result87, + name: _rt::string_lift(bytes84), + version: _rt::string_lift(bytes87), + parameters: result96, } }; - result88.push(e88); + result97.push(e97); } _rt::cabi_dealloc( - base88, - len88 * (16 + 6 * ::core::mem::size_of::<*const u8>()), + base97, + len97 * (16 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::api::oplog::CreateParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l33 as u64, - nanoseconds: l34 as u32, + seconds: l42 as u64, + nanoseconds: l43 as u32, }, worker_id: super::super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l35 as u64, - low_bits: l36 as u64, + high_bits: l44 as u64, + low_bits: l45 as u64, }, }, - worker_name: _rt::string_lift(bytes39), + worker_name: _rt::string_lift(bytes48), }, - component_version: l40 as u64, - args: result46, - env: result55, + component_version: l49 as u64, + args: result55, + env: result64, created_by: super::super::super::super::golem::api::host::AccountId { - value: _rt::string_lift(bytes58), + value: _rt::string_lift(bytes67), }, project_id: super::super::super::super::golem::api::host::ProjectId { uuid: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l59 as u64, - low_bits: l60 as u64, + high_bits: l68 as u64, + low_bits: l69 as u64, }, }, - parent: match l61 { + parent: match l70 { 0 => None, 1 => { let e = { - let l62 = *base + let l71 = *base .add(72 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l63 = *base + let l72 = *base .add(80 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l64 = *base + let l73 = *base .add(88 + 8 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l65 = *base + let l74 = *base .add(88 + 9 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len66 = l65; - let bytes66 = _rt::Vec::from_raw_parts( - l64.cast(), - len66, - len66, + let len75 = l74; + let bytes75 = _rt::Vec::from_raw_parts( + l73.cast(), + len75, + len75, ); super::super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l62 as u64, - low_bits: l63 as u64, + high_bits: l71 as u64, + low_bits: l72 as u64, }, }, - worker_name: _rt::string_lift(bytes66), + worker_name: _rt::string_lift(bytes75), } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - component_size: l67 as u64, - initial_total_linear_memory_size: l68 as u64, - initial_active_plugins: result88, + component_size: l76 as u64, + initial_total_linear_memory_size: l77 as u64, + initial_active_plugins: result97, } }; - V655::Create(e655) + V664::Create(e664) } 1 => { - let e655 = { - let l89 = *base.add(8).cast::(); - let l90 = *base.add(16).cast::(); - let l91 = *base.add(24).cast::<*mut u8>(); - let l92 = *base + let e664 = { + let l98 = *base.add(8).cast::(); + let l99 = *base.add(16).cast::(); + let l100 = *base.add(24).cast::<*mut u8>(); + let l101 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len93 = l92; - let bytes93 = _rt::Vec::from_raw_parts( - l91.cast(), - len93, - len93, + let len102 = l101; + let bytes102 = _rt::Vec::from_raw_parts( + l100.cast(), + len102, + len102, ); - let l94 = *base + let l103 = *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l95 = *base + let l104 = *base .add(24 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base141 = l94; - let len141 = l95; - let mut result141 = _rt::Vec::with_capacity(len141); - for i in 0..len141 { - let base = base141 + let base150 = l103; + let len150 = l104; + let mut result150 = _rt::Vec::with_capacity(len150); + for i in 0..len150 { + let base = base150 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e141 = { - let l96 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::rpc::types::WitNode as V140; - let v140 = match l96 { + let e150 = { + let l105 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::rpc::types::WitNode as V149; + let v149 = match l105 { 0 => { - let e140 = { - let l97 = *base.add(8).cast::<*mut u8>(); - let l98 = *base + let e149 = { + let l106 = *base.add(8).cast::<*mut u8>(); + let l107 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len99 = l98; - _rt::Vec::from_raw_parts(l97.cast(), len99, len99) + let len108 = l107; + _rt::Vec::from_raw_parts(l106.cast(), len108, len108) }; - V140::RecordValue(e140) + V149::RecordValue(e149) } 1 => { - let e140 = { - let l100 = *base.add(8).cast::(); - let l101 = i32::from(*base.add(12).cast::()); + let e149 = { + let l109 = *base.add(8).cast::(); + let l110 = i32::from(*base.add(12).cast::()); ( - l100 as u32, - match l101 { + l109 as u32, + match l110 { 0 => None, 1 => { let e = { - let l102 = *base.add(16).cast::(); - l102 + let l111 = *base.add(16).cast::(); + l111 }; Some(e) } @@ -17929,89 +18240,89 @@ pub mod exports { }, ) }; - V140::VariantValue(e140) + V149::VariantValue(e149) } 2 => { - let e140 = { - let l103 = *base.add(8).cast::(); - l103 as u32 + let e149 = { + let l112 = *base.add(8).cast::(); + l112 as u32 }; - V140::EnumValue(e140) + V149::EnumValue(e149) } 3 => { - let e140 = { - let l104 = *base.add(8).cast::<*mut u8>(); - let l105 = *base + let e149 = { + let l113 = *base.add(8).cast::<*mut u8>(); + let l114 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base107 = l104; - let len107 = l105; - let mut result107 = _rt::Vec::with_capacity(len107); - for i in 0..len107 { - let base = base107.add(i * 1); - let e107 = { - let l106 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l106 as u8) + let base116 = l113; + let len116 = l114; + let mut result116 = _rt::Vec::with_capacity(len116); + for i in 0..len116 { + let base = base116.add(i * 1); + let e116 = { + let l115 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l115 as u8) }; - result107.push(e107); + result116.push(e116); } - _rt::cabi_dealloc(base107, len107 * 1, 1); - result107 + _rt::cabi_dealloc(base116, len116 * 1, 1); + result116 }; - V140::FlagsValue(e140) + V149::FlagsValue(e149) } 4 => { - let e140 = { - let l108 = *base.add(8).cast::<*mut u8>(); - let l109 = *base + let e149 = { + let l117 = *base.add(8).cast::<*mut u8>(); + let l118 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len110 = l109; - _rt::Vec::from_raw_parts(l108.cast(), len110, len110) + let len119 = l118; + _rt::Vec::from_raw_parts(l117.cast(), len119, len119) }; - V140::TupleValue(e140) + V149::TupleValue(e149) } 5 => { - let e140 = { - let l111 = *base.add(8).cast::<*mut u8>(); - let l112 = *base + let e149 = { + let l120 = *base.add(8).cast::<*mut u8>(); + let l121 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len113 = l112; - _rt::Vec::from_raw_parts(l111.cast(), len113, len113) + let len122 = l121; + _rt::Vec::from_raw_parts(l120.cast(), len122, len122) }; - V140::ListValue(e140) + V149::ListValue(e149) } 6 => { - let e140 = { - let l114 = i32::from(*base.add(8).cast::()); - match l114 { + let e149 = { + let l123 = i32::from(*base.add(8).cast::()); + match l123 { 0 => None, 1 => { let e = { - let l115 = *base.add(12).cast::(); - l115 + let l124 = *base.add(12).cast::(); + l124 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V140::OptionValue(e140) + V149::OptionValue(e149) } 7 => { - let e140 = { - let l116 = i32::from(*base.add(8).cast::()); - match l116 { + let e149 = { + let l125 = i32::from(*base.add(8).cast::()); + match l125 { 0 => { let e = { - let l117 = i32::from(*base.add(12).cast::()); - match l117 { + let l126 = i32::from(*base.add(12).cast::()); + match l126 { 0 => None, 1 => { let e = { - let l118 = *base.add(16).cast::(); - l118 + let l127 = *base.add(16).cast::(); + l127 }; Some(e) } @@ -18022,13 +18333,13 @@ pub mod exports { } 1 => { let e = { - let l119 = i32::from(*base.add(12).cast::()); - match l119 { + let l128 = i32::from(*base.add(12).cast::()); + match l128 { 0 => None, 1 => { let e = { - let l120 = *base.add(16).cast::(); - l120 + let l129 = *base.add(16).cast::(); + l129 }; Some(e) } @@ -18040,182 +18351,182 @@ pub mod exports { _ => _rt::invalid_enum_discriminant(), } }; - V140::ResultValue(e140) + V149::ResultValue(e149) } 8 => { - let e140 = { - let l121 = i32::from(*base.add(8).cast::()); - l121 as u8 + let e149 = { + let l130 = i32::from(*base.add(8).cast::()); + l130 as u8 }; - V140::PrimU8(e140) + V149::PrimU8(e149) } 9 => { - let e140 = { - let l122 = i32::from(*base.add(8).cast::()); - l122 as u16 + let e149 = { + let l131 = i32::from(*base.add(8).cast::()); + l131 as u16 }; - V140::PrimU16(e140) + V149::PrimU16(e149) } 10 => { - let e140 = { - let l123 = *base.add(8).cast::(); - l123 as u32 + let e149 = { + let l132 = *base.add(8).cast::(); + l132 as u32 }; - V140::PrimU32(e140) + V149::PrimU32(e149) } 11 => { - let e140 = { - let l124 = *base.add(8).cast::(); - l124 as u64 + let e149 = { + let l133 = *base.add(8).cast::(); + l133 as u64 }; - V140::PrimU64(e140) + V149::PrimU64(e149) } 12 => { - let e140 = { - let l125 = i32::from(*base.add(8).cast::()); - l125 as i8 + let e149 = { + let l134 = i32::from(*base.add(8).cast::()); + l134 as i8 }; - V140::PrimS8(e140) + V149::PrimS8(e149) } 13 => { - let e140 = { - let l126 = i32::from(*base.add(8).cast::()); - l126 as i16 + let e149 = { + let l135 = i32::from(*base.add(8).cast::()); + l135 as i16 }; - V140::PrimS16(e140) + V149::PrimS16(e149) } 14 => { - let e140 = { - let l127 = *base.add(8).cast::(); - l127 + let e149 = { + let l136 = *base.add(8).cast::(); + l136 }; - V140::PrimS32(e140) + V149::PrimS32(e149) } 15 => { - let e140 = { - let l128 = *base.add(8).cast::(); - l128 + let e149 = { + let l137 = *base.add(8).cast::(); + l137 }; - V140::PrimS64(e140) + V149::PrimS64(e149) } 16 => { - let e140 = { - let l129 = *base.add(8).cast::(); - l129 + let e149 = { + let l138 = *base.add(8).cast::(); + l138 }; - V140::PrimFloat32(e140) + V149::PrimFloat32(e149) } 17 => { - let e140 = { - let l130 = *base.add(8).cast::(); - l130 + let e149 = { + let l139 = *base.add(8).cast::(); + l139 }; - V140::PrimFloat64(e140) + V149::PrimFloat64(e149) } 18 => { - let e140 = { - let l131 = *base.add(8).cast::(); - _rt::char_lift(l131 as u32) + let e149 = { + let l140 = *base.add(8).cast::(); + _rt::char_lift(l140 as u32) }; - V140::PrimChar(e140) + V149::PrimChar(e149) } 19 => { - let e140 = { - let l132 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l132 as u8) + let e149 = { + let l141 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l141 as u8) }; - V140::PrimBool(e140) + V149::PrimBool(e149) } 20 => { - let e140 = { - let l133 = *base.add(8).cast::<*mut u8>(); - let l134 = *base + let e149 = { + let l142 = *base.add(8).cast::<*mut u8>(); + let l143 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len135 = l134; - let bytes135 = _rt::Vec::from_raw_parts( - l133.cast(), - len135, - len135, + let len144 = l143; + let bytes144 = _rt::Vec::from_raw_parts( + l142.cast(), + len144, + len144, ); - _rt::string_lift(bytes135) + _rt::string_lift(bytes144) }; - V140::PrimString(e140) + V149::PrimString(e149) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e140 = { - let l136 = *base.add(8).cast::<*mut u8>(); - let l137 = *base + let e149 = { + let l145 = *base.add(8).cast::<*mut u8>(); + let l146 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len138 = l137; - let bytes138 = _rt::Vec::from_raw_parts( - l136.cast(), - len138, - len138, + let len147 = l146; + let bytes147 = _rt::Vec::from_raw_parts( + l145.cast(), + len147, + len147, ); - let l139 = *base + let l148 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( super::super::super::super::golem::rpc::types::Uri { - value: _rt::string_lift(bytes138), + value: _rt::string_lift(bytes147), }, - l139 as u64, + l148 as u64, ) }; - V140::Handle(e140) + V149::Handle(e149) } }; - v140 + v149 }; - result141.push(e141); + result150.push(e150); } _rt::cabi_dealloc( - base141, - len141 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base150, + len150 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let l142 = *base + let l151 = *base .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l143 = *base + let l152 = *base .add(24 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base189 = l142; - let len189 = l143; - let mut result189 = _rt::Vec::with_capacity(len189); - for i in 0..len189 { - let base = base189 + let base198 = l151; + let len198 = l152; + let mut result198 = _rt::Vec::with_capacity(len198); + for i in 0..len198 { + let base = base198 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e189 = { - let l144 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::rpc::types::WitNode as V188; - let v188 = match l144 { + let e198 = { + let l153 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::rpc::types::WitNode as V197; + let v197 = match l153 { 0 => { - let e188 = { - let l145 = *base.add(8).cast::<*mut u8>(); - let l146 = *base + let e197 = { + let l154 = *base.add(8).cast::<*mut u8>(); + let l155 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len147 = l146; - _rt::Vec::from_raw_parts(l145.cast(), len147, len147) + let len156 = l155; + _rt::Vec::from_raw_parts(l154.cast(), len156, len156) }; - V188::RecordValue(e188) + V197::RecordValue(e197) } 1 => { - let e188 = { - let l148 = *base.add(8).cast::(); - let l149 = i32::from(*base.add(12).cast::()); + let e197 = { + let l157 = *base.add(8).cast::(); + let l158 = i32::from(*base.add(12).cast::()); ( - l148 as u32, - match l149 { + l157 as u32, + match l158 { 0 => None, 1 => { let e = { - let l150 = *base.add(16).cast::(); - l150 + let l159 = *base.add(16).cast::(); + l159 }; Some(e) } @@ -18223,89 +18534,89 @@ pub mod exports { }, ) }; - V188::VariantValue(e188) + V197::VariantValue(e197) } 2 => { - let e188 = { - let l151 = *base.add(8).cast::(); - l151 as u32 + let e197 = { + let l160 = *base.add(8).cast::(); + l160 as u32 }; - V188::EnumValue(e188) + V197::EnumValue(e197) } 3 => { - let e188 = { - let l152 = *base.add(8).cast::<*mut u8>(); - let l153 = *base + let e197 = { + let l161 = *base.add(8).cast::<*mut u8>(); + let l162 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base155 = l152; - let len155 = l153; - let mut result155 = _rt::Vec::with_capacity(len155); - for i in 0..len155 { - let base = base155.add(i * 1); - let e155 = { - let l154 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l154 as u8) + let base164 = l161; + let len164 = l162; + let mut result164 = _rt::Vec::with_capacity(len164); + for i in 0..len164 { + let base = base164.add(i * 1); + let e164 = { + let l163 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l163 as u8) }; - result155.push(e155); + result164.push(e164); } - _rt::cabi_dealloc(base155, len155 * 1, 1); - result155 + _rt::cabi_dealloc(base164, len164 * 1, 1); + result164 }; - V188::FlagsValue(e188) + V197::FlagsValue(e197) } 4 => { - let e188 = { - let l156 = *base.add(8).cast::<*mut u8>(); - let l157 = *base + let e197 = { + let l165 = *base.add(8).cast::<*mut u8>(); + let l166 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len158 = l157; - _rt::Vec::from_raw_parts(l156.cast(), len158, len158) + let len167 = l166; + _rt::Vec::from_raw_parts(l165.cast(), len167, len167) }; - V188::TupleValue(e188) + V197::TupleValue(e197) } 5 => { - let e188 = { - let l159 = *base.add(8).cast::<*mut u8>(); - let l160 = *base + let e197 = { + let l168 = *base.add(8).cast::<*mut u8>(); + let l169 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len161 = l160; - _rt::Vec::from_raw_parts(l159.cast(), len161, len161) + let len170 = l169; + _rt::Vec::from_raw_parts(l168.cast(), len170, len170) }; - V188::ListValue(e188) + V197::ListValue(e197) } 6 => { - let e188 = { - let l162 = i32::from(*base.add(8).cast::()); - match l162 { + let e197 = { + let l171 = i32::from(*base.add(8).cast::()); + match l171 { 0 => None, 1 => { let e = { - let l163 = *base.add(12).cast::(); - l163 + let l172 = *base.add(12).cast::(); + l172 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V188::OptionValue(e188) + V197::OptionValue(e197) } 7 => { - let e188 = { - let l164 = i32::from(*base.add(8).cast::()); - match l164 { + let e197 = { + let l173 = i32::from(*base.add(8).cast::()); + match l173 { 0 => { let e = { - let l165 = i32::from(*base.add(12).cast::()); - match l165 { + let l174 = i32::from(*base.add(12).cast::()); + match l174 { 0 => None, 1 => { let e = { - let l166 = *base.add(16).cast::(); - l166 + let l175 = *base.add(16).cast::(); + l175 }; Some(e) } @@ -18316,13 +18627,13 @@ pub mod exports { } 1 => { let e = { - let l167 = i32::from(*base.add(12).cast::()); - match l167 { + let l176 = i32::from(*base.add(12).cast::()); + match l176 { 0 => None, 1 => { let e = { - let l168 = *base.add(16).cast::(); - l168 + let l177 = *base.add(16).cast::(); + l177 }; Some(e) } @@ -18334,260 +18645,260 @@ pub mod exports { _ => _rt::invalid_enum_discriminant(), } }; - V188::ResultValue(e188) + V197::ResultValue(e197) } 8 => { - let e188 = { - let l169 = i32::from(*base.add(8).cast::()); - l169 as u8 + let e197 = { + let l178 = i32::from(*base.add(8).cast::()); + l178 as u8 }; - V188::PrimU8(e188) + V197::PrimU8(e197) } 9 => { - let e188 = { - let l170 = i32::from(*base.add(8).cast::()); - l170 as u16 + let e197 = { + let l179 = i32::from(*base.add(8).cast::()); + l179 as u16 }; - V188::PrimU16(e188) + V197::PrimU16(e197) } 10 => { - let e188 = { - let l171 = *base.add(8).cast::(); - l171 as u32 + let e197 = { + let l180 = *base.add(8).cast::(); + l180 as u32 }; - V188::PrimU32(e188) + V197::PrimU32(e197) } 11 => { - let e188 = { - let l172 = *base.add(8).cast::(); - l172 as u64 + let e197 = { + let l181 = *base.add(8).cast::(); + l181 as u64 }; - V188::PrimU64(e188) + V197::PrimU64(e197) } 12 => { - let e188 = { - let l173 = i32::from(*base.add(8).cast::()); - l173 as i8 + let e197 = { + let l182 = i32::from(*base.add(8).cast::()); + l182 as i8 }; - V188::PrimS8(e188) + V197::PrimS8(e197) } 13 => { - let e188 = { - let l174 = i32::from(*base.add(8).cast::()); - l174 as i16 + let e197 = { + let l183 = i32::from(*base.add(8).cast::()); + l183 as i16 }; - V188::PrimS16(e188) + V197::PrimS16(e197) } 14 => { - let e188 = { - let l175 = *base.add(8).cast::(); - l175 + let e197 = { + let l184 = *base.add(8).cast::(); + l184 }; - V188::PrimS32(e188) + V197::PrimS32(e197) } 15 => { - let e188 = { - let l176 = *base.add(8).cast::(); - l176 + let e197 = { + let l185 = *base.add(8).cast::(); + l185 }; - V188::PrimS64(e188) + V197::PrimS64(e197) } 16 => { - let e188 = { - let l177 = *base.add(8).cast::(); - l177 + let e197 = { + let l186 = *base.add(8).cast::(); + l186 }; - V188::PrimFloat32(e188) + V197::PrimFloat32(e197) } 17 => { - let e188 = { - let l178 = *base.add(8).cast::(); - l178 + let e197 = { + let l187 = *base.add(8).cast::(); + l187 }; - V188::PrimFloat64(e188) + V197::PrimFloat64(e197) } 18 => { - let e188 = { - let l179 = *base.add(8).cast::(); - _rt::char_lift(l179 as u32) + let e197 = { + let l188 = *base.add(8).cast::(); + _rt::char_lift(l188 as u32) }; - V188::PrimChar(e188) + V197::PrimChar(e197) } 19 => { - let e188 = { - let l180 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l180 as u8) + let e197 = { + let l189 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l189 as u8) }; - V188::PrimBool(e188) + V197::PrimBool(e197) } 20 => { - let e188 = { - let l181 = *base.add(8).cast::<*mut u8>(); - let l182 = *base + let e197 = { + let l190 = *base.add(8).cast::<*mut u8>(); + let l191 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len183 = l182; - let bytes183 = _rt::Vec::from_raw_parts( - l181.cast(), - len183, - len183, + let len192 = l191; + let bytes192 = _rt::Vec::from_raw_parts( + l190.cast(), + len192, + len192, ); - _rt::string_lift(bytes183) + _rt::string_lift(bytes192) }; - V188::PrimString(e188) + V197::PrimString(e197) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e188 = { - let l184 = *base.add(8).cast::<*mut u8>(); - let l185 = *base + let e197 = { + let l193 = *base.add(8).cast::<*mut u8>(); + let l194 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len186 = l185; - let bytes186 = _rt::Vec::from_raw_parts( - l184.cast(), - len186, - len186, + let len195 = l194; + let bytes195 = _rt::Vec::from_raw_parts( + l193.cast(), + len195, + len195, ); - let l187 = *base + let l196 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( super::super::super::super::golem::rpc::types::Uri { - value: _rt::string_lift(bytes186), + value: _rt::string_lift(bytes195), }, - l187 as u64, + l196 as u64, ) }; - V188::Handle(e188) + V197::Handle(e197) } }; - v188 + v197 }; - result189.push(e189); + result198.push(e198); } _rt::cabi_dealloc( - base189, - len189 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base198, + len198 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let l190 = i32::from( + let l199 = i32::from( *base .add(24 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - use super::super::super::super::golem::api::oplog::WrappedFunctionType as V193; - let v193 = match l190 { - 0 => V193::ReadLocal, - 1 => V193::WriteLocal, - 2 => V193::ReadRemote, - 3 => V193::WriteRemote, + use super::super::super::super::golem::api::oplog::WrappedFunctionType as V202; + let v202 = match l199 { + 0 => V202::ReadLocal, + 1 => V202::WriteLocal, + 2 => V202::ReadRemote, + 3 => V202::WriteRemote, n => { debug_assert_eq!(n, 4, "invalid enum discriminant"); - let e193 = { - let l191 = i32::from( + let e202 = { + let l200 = i32::from( *base .add(32 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - match l191 { + match l200 { 0 => None, 1 => { let e = { - let l192 = *base + let l201 = *base .add(40 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l192 as u64 + l201 as u64 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V193::WriteRemoteBatched(e193) + V202::WriteRemoteBatched(e202) } }; super::super::super::super::golem::api::oplog::ImportedFunctionInvokedParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l89 as u64, - nanoseconds: l90 as u32, + seconds: l98 as u64, + nanoseconds: l99 as u32, }, - function_name: _rt::string_lift(bytes93), + function_name: _rt::string_lift(bytes102), request: super::super::super::super::golem::rpc::types::WitValue { - nodes: result141, + nodes: result150, }, response: super::super::super::super::golem::rpc::types::WitValue { - nodes: result189, + nodes: result198, }, - wrapped_function_type: v193, + wrapped_function_type: v202, } }; - V655::ImportedFunctionInvoked(e655) + V664::ImportedFunctionInvoked(e664) } 2 => { - let e655 = { - let l194 = *base.add(8).cast::(); - let l195 = *base.add(16).cast::(); - let l196 = *base.add(24).cast::<*mut u8>(); - let l197 = *base + let e664 = { + let l203 = *base.add(8).cast::(); + let l204 = *base.add(16).cast::(); + let l205 = *base.add(24).cast::<*mut u8>(); + let l206 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len198 = l197; - let bytes198 = _rt::Vec::from_raw_parts( - l196.cast(), - len198, - len198, + let len207 = l206; + let bytes207 = _rt::Vec::from_raw_parts( + l205.cast(), + len207, + len207, ); - let l199 = *base + let l208 = *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l200 = *base + let l209 = *base .add(24 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base249 = l199; - let len249 = l200; - let mut result249 = _rt::Vec::with_capacity(len249); - for i in 0..len249 { - let base = base249 + let base258 = l208; + let len258 = l209; + let mut result258 = _rt::Vec::with_capacity(len258); + for i in 0..len258 { + let base = base258 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e249 = { - let l201 = *base.add(0).cast::<*mut u8>(); - let l202 = *base + let e258 = { + let l210 = *base.add(0).cast::<*mut u8>(); + let l211 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base248 = l201; - let len248 = l202; - let mut result248 = _rt::Vec::with_capacity(len248); - for i in 0..len248 { - let base = base248 + let base257 = l210; + let len257 = l211; + let mut result257 = _rt::Vec::with_capacity(len257); + for i in 0..len257 { + let base = base257 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e248 = { - let l203 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::rpc::types::WitNode as V247; - let v247 = match l203 { + let e257 = { + let l212 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::rpc::types::WitNode as V256; + let v256 = match l212 { 0 => { - let e247 = { - let l204 = *base.add(8).cast::<*mut u8>(); - let l205 = *base + let e256 = { + let l213 = *base.add(8).cast::<*mut u8>(); + let l214 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len206 = l205; - _rt::Vec::from_raw_parts(l204.cast(), len206, len206) + let len215 = l214; + _rt::Vec::from_raw_parts(l213.cast(), len215, len215) }; - V247::RecordValue(e247) + V256::RecordValue(e256) } 1 => { - let e247 = { - let l207 = *base.add(8).cast::(); - let l208 = i32::from(*base.add(12).cast::()); + let e256 = { + let l216 = *base.add(8).cast::(); + let l217 = i32::from(*base.add(12).cast::()); ( - l207 as u32, - match l208 { + l216 as u32, + match l217 { 0 => None, 1 => { let e = { - let l209 = *base.add(16).cast::(); - l209 + let l218 = *base.add(16).cast::(); + l218 }; Some(e) } @@ -18595,89 +18906,89 @@ pub mod exports { }, ) }; - V247::VariantValue(e247) + V256::VariantValue(e256) } 2 => { - let e247 = { - let l210 = *base.add(8).cast::(); - l210 as u32 + let e256 = { + let l219 = *base.add(8).cast::(); + l219 as u32 }; - V247::EnumValue(e247) + V256::EnumValue(e256) } 3 => { - let e247 = { - let l211 = *base.add(8).cast::<*mut u8>(); - let l212 = *base + let e256 = { + let l220 = *base.add(8).cast::<*mut u8>(); + let l221 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base214 = l211; - let len214 = l212; - let mut result214 = _rt::Vec::with_capacity(len214); - for i in 0..len214 { - let base = base214.add(i * 1); - let e214 = { - let l213 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l213 as u8) + let base223 = l220; + let len223 = l221; + let mut result223 = _rt::Vec::with_capacity(len223); + for i in 0..len223 { + let base = base223.add(i * 1); + let e223 = { + let l222 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l222 as u8) }; - result214.push(e214); + result223.push(e223); } - _rt::cabi_dealloc(base214, len214 * 1, 1); - result214 + _rt::cabi_dealloc(base223, len223 * 1, 1); + result223 }; - V247::FlagsValue(e247) + V256::FlagsValue(e256) } 4 => { - let e247 = { - let l215 = *base.add(8).cast::<*mut u8>(); - let l216 = *base + let e256 = { + let l224 = *base.add(8).cast::<*mut u8>(); + let l225 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len217 = l216; - _rt::Vec::from_raw_parts(l215.cast(), len217, len217) + let len226 = l225; + _rt::Vec::from_raw_parts(l224.cast(), len226, len226) }; - V247::TupleValue(e247) + V256::TupleValue(e256) } 5 => { - let e247 = { - let l218 = *base.add(8).cast::<*mut u8>(); - let l219 = *base + let e256 = { + let l227 = *base.add(8).cast::<*mut u8>(); + let l228 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len220 = l219; - _rt::Vec::from_raw_parts(l218.cast(), len220, len220) + let len229 = l228; + _rt::Vec::from_raw_parts(l227.cast(), len229, len229) }; - V247::ListValue(e247) + V256::ListValue(e256) } 6 => { - let e247 = { - let l221 = i32::from(*base.add(8).cast::()); - match l221 { + let e256 = { + let l230 = i32::from(*base.add(8).cast::()); + match l230 { 0 => None, 1 => { let e = { - let l222 = *base.add(12).cast::(); - l222 + let l231 = *base.add(12).cast::(); + l231 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V247::OptionValue(e247) + V256::OptionValue(e256) } 7 => { - let e247 = { - let l223 = i32::from(*base.add(8).cast::()); - match l223 { + let e256 = { + let l232 = i32::from(*base.add(8).cast::()); + match l232 { 0 => { let e = { - let l224 = i32::from(*base.add(12).cast::()); - match l224 { + let l233 = i32::from(*base.add(12).cast::()); + match l233 { 0 => None, 1 => { let e = { - let l225 = *base.add(16).cast::(); - l225 + let l234 = *base.add(16).cast::(); + l234 }; Some(e) } @@ -18688,13 +18999,13 @@ pub mod exports { } 1 => { let e = { - let l226 = i32::from(*base.add(12).cast::()); - match l226 { + let l235 = i32::from(*base.add(12).cast::()); + match l235 { 0 => None, 1 => { let e = { - let l227 = *base.add(16).cast::(); - l227 + let l236 = *base.add(16).cast::(); + l236 }; Some(e) } @@ -18706,488 +19017,488 @@ pub mod exports { _ => _rt::invalid_enum_discriminant(), } }; - V247::ResultValue(e247) + V256::ResultValue(e256) } 8 => { - let e247 = { - let l228 = i32::from(*base.add(8).cast::()); - l228 as u8 + let e256 = { + let l237 = i32::from(*base.add(8).cast::()); + l237 as u8 }; - V247::PrimU8(e247) + V256::PrimU8(e256) } 9 => { - let e247 = { - let l229 = i32::from(*base.add(8).cast::()); - l229 as u16 + let e256 = { + let l238 = i32::from(*base.add(8).cast::()); + l238 as u16 }; - V247::PrimU16(e247) + V256::PrimU16(e256) } 10 => { - let e247 = { - let l230 = *base.add(8).cast::(); - l230 as u32 + let e256 = { + let l239 = *base.add(8).cast::(); + l239 as u32 }; - V247::PrimU32(e247) + V256::PrimU32(e256) } 11 => { - let e247 = { - let l231 = *base.add(8).cast::(); - l231 as u64 + let e256 = { + let l240 = *base.add(8).cast::(); + l240 as u64 }; - V247::PrimU64(e247) + V256::PrimU64(e256) } 12 => { - let e247 = { - let l232 = i32::from(*base.add(8).cast::()); - l232 as i8 + let e256 = { + let l241 = i32::from(*base.add(8).cast::()); + l241 as i8 }; - V247::PrimS8(e247) + V256::PrimS8(e256) } 13 => { - let e247 = { - let l233 = i32::from(*base.add(8).cast::()); - l233 as i16 + let e256 = { + let l242 = i32::from(*base.add(8).cast::()); + l242 as i16 }; - V247::PrimS16(e247) + V256::PrimS16(e256) } 14 => { - let e247 = { - let l234 = *base.add(8).cast::(); - l234 + let e256 = { + let l243 = *base.add(8).cast::(); + l243 }; - V247::PrimS32(e247) + V256::PrimS32(e256) } 15 => { - let e247 = { - let l235 = *base.add(8).cast::(); - l235 + let e256 = { + let l244 = *base.add(8).cast::(); + l244 }; - V247::PrimS64(e247) + V256::PrimS64(e256) } 16 => { - let e247 = { - let l236 = *base.add(8).cast::(); - l236 + let e256 = { + let l245 = *base.add(8).cast::(); + l245 }; - V247::PrimFloat32(e247) + V256::PrimFloat32(e256) } 17 => { - let e247 = { - let l237 = *base.add(8).cast::(); - l237 + let e256 = { + let l246 = *base.add(8).cast::(); + l246 }; - V247::PrimFloat64(e247) + V256::PrimFloat64(e256) } 18 => { - let e247 = { - let l238 = *base.add(8).cast::(); - _rt::char_lift(l238 as u32) + let e256 = { + let l247 = *base.add(8).cast::(); + _rt::char_lift(l247 as u32) }; - V247::PrimChar(e247) + V256::PrimChar(e256) } 19 => { - let e247 = { - let l239 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l239 as u8) + let e256 = { + let l248 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l248 as u8) }; - V247::PrimBool(e247) + V256::PrimBool(e256) } 20 => { - let e247 = { - let l240 = *base.add(8).cast::<*mut u8>(); - let l241 = *base + let e256 = { + let l249 = *base.add(8).cast::<*mut u8>(); + let l250 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len242 = l241; - let bytes242 = _rt::Vec::from_raw_parts( - l240.cast(), - len242, - len242, + let len251 = l250; + let bytes251 = _rt::Vec::from_raw_parts( + l249.cast(), + len251, + len251, ); - _rt::string_lift(bytes242) + _rt::string_lift(bytes251) }; - V247::PrimString(e247) + V256::PrimString(e256) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e247 = { - let l243 = *base.add(8).cast::<*mut u8>(); - let l244 = *base + let e256 = { + let l252 = *base.add(8).cast::<*mut u8>(); + let l253 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len245 = l244; - let bytes245 = _rt::Vec::from_raw_parts( - l243.cast(), - len245, - len245, + let len254 = l253; + let bytes254 = _rt::Vec::from_raw_parts( + l252.cast(), + len254, + len254, ); - let l246 = *base + let l255 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( super::super::super::super::golem::rpc::types::Uri { - value: _rt::string_lift(bytes245), + value: _rt::string_lift(bytes254), }, - l246 as u64, + l255 as u64, ) }; - V247::Handle(e247) + V256::Handle(e256) } }; - v247 + v256 }; - result248.push(e248); + result257.push(e257); } _rt::cabi_dealloc( - base248, - len248 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base257, + len257 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::rpc::types::WitValue { - nodes: result248, + nodes: result257, } }; - result249.push(e249); + result258.push(e258); } _rt::cabi_dealloc( - base249, - len249 * (2 * ::core::mem::size_of::<*const u8>()), + base258, + len258 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l250 = *base + let l259 = *base .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l251 = *base + let l260 = *base .add(24 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len252 = l251; - let bytes252 = _rt::Vec::from_raw_parts( - l250.cast(), - len252, - len252, + let len261 = l260; + let bytes261 = _rt::Vec::from_raw_parts( + l259.cast(), + len261, + len261, ); - let l253 = *base + let l262 = *base .add(24 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l254 = *base + let l263 = *base .add(24 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len255 = l254; - let bytes255 = _rt::Vec::from_raw_parts( - l253.cast(), - len255, - len255, + let len264 = l263; + let bytes264 = _rt::Vec::from_raw_parts( + l262.cast(), + len264, + len264, ); - let l256 = *base + let l265 = *base .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l257 = *base + let l266 = *base .add(24 + 9 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base261 = l256; - let len261 = l257; - let mut result261 = _rt::Vec::with_capacity(len261); - for i in 0..len261 { - let base = base261 + let base270 = l265; + let len270 = l266; + let mut result270 = _rt::Vec::with_capacity(len270); + for i in 0..len270 { + let base = base270 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e261 = { - let l258 = *base.add(0).cast::<*mut u8>(); - let l259 = *base + let e270 = { + let l267 = *base.add(0).cast::<*mut u8>(); + let l268 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len260 = l259; - let bytes260 = _rt::Vec::from_raw_parts( - l258.cast(), - len260, - len260, + let len269 = l268; + let bytes269 = _rt::Vec::from_raw_parts( + l267.cast(), + len269, + len269, ); - _rt::string_lift(bytes260) + _rt::string_lift(bytes269) }; - result261.push(e261); + result270.push(e270); } _rt::cabi_dealloc( - base261, - len261 * (2 * ::core::mem::size_of::<*const u8>()), + base270, + len270 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l262 = *base + let l271 = *base .add(24 + 10 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l263 = *base + let l272 = *base .add(24 + 11 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base295 = l262; - let len295 = l263; - let mut result295 = _rt::Vec::with_capacity(len295); - for i in 0..len295 { - let base = base295 + let base304 = l271; + let len304 = l272; + let mut result304 = _rt::Vec::with_capacity(len304); + for i in 0..len304 { + let base = base304 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e295 = { - let l264 = *base.add(0).cast::<*mut u8>(); - let l265 = *base + let e304 = { + let l273 = *base.add(0).cast::<*mut u8>(); + let l274 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base294 = l264; - let len294 = l265; - let mut result294 = _rt::Vec::with_capacity(len294); - for i in 0..len294 { - let base = base294 + let base303 = l273; + let len303 = l274; + let mut result303 = _rt::Vec::with_capacity(len303); + for i in 0..len303 { + let base = base303 .add(i * (56 + 6 * ::core::mem::size_of::<*const u8>())); - let e294 = { - let l266 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::api::oplog::SpanData as V293; - let v293 = match l266 { + let e303 = { + let l275 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::api::oplog::SpanData as V302; + let v302 = match l275 { 0 => { - let e293 = { - let l267 = *base.add(8).cast::<*mut u8>(); - let l268 = *base + let e302 = { + let l276 = *base.add(8).cast::<*mut u8>(); + let l277 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len269 = l268; - let bytes269 = _rt::Vec::from_raw_parts( - l267.cast(), - len269, - len269, + let len278 = l277; + let bytes278 = _rt::Vec::from_raw_parts( + l276.cast(), + len278, + len278, ); - let l270 = *base + let l279 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l271 = *base + let l280 = *base .add(16 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l272 = i32::from( + let l281 = i32::from( *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l276 = i32::from( + let l285 = i32::from( *base .add(32 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l278 = *base + let l287 = *base .add(48 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l279 = *base + let l288 = *base .add(48 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base288 = l278; - let len288 = l279; - let mut result288 = _rt::Vec::with_capacity(len288); - for i in 0..len288 { - let base = base288 + let base297 = l287; + let len297 = l288; + let mut result297 = _rt::Vec::with_capacity(len297); + for i in 0..len297 { + let base = base297 .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e288 = { - let l280 = *base.add(0).cast::<*mut u8>(); - let l281 = *base + let e297 = { + let l289 = *base.add(0).cast::<*mut u8>(); + let l290 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len282 = l281; - let bytes282 = _rt::Vec::from_raw_parts( - l280.cast(), - len282, - len282, + let len291 = l290; + let bytes291 = _rt::Vec::from_raw_parts( + l289.cast(), + len291, + len291, ); - let l283 = i32::from( + let l292 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - use super::super::super::super::golem::api::context::AttributeValue as V287; - let v287 = match l283 { + use super::super::super::super::golem::api::context::AttributeValue as V296; + let v296 = match l292 { n => { debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e287 = { - let l284 = *base + let e296 = { + let l293 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l285 = *base + let l294 = *base .add(4 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len286 = l285; - let bytes286 = _rt::Vec::from_raw_parts( - l284.cast(), - len286, - len286, + let len295 = l294; + let bytes295 = _rt::Vec::from_raw_parts( + l293.cast(), + len295, + len295, ); - _rt::string_lift(bytes286) + _rt::string_lift(bytes295) }; - V287::String(e287) + V296::String(e296) } }; super::super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes282), - value: v287, + key: _rt::string_lift(bytes291), + value: v296, } }; - result288.push(e288); + result297.push(e297); } _rt::cabi_dealloc( - base288, - len288 * (5 * ::core::mem::size_of::<*const u8>()), + base297, + len297 * (5 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l289 = i32::from( + let l298 = i32::from( *base .add(48 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); super::super::super::super::golem::api::oplog::LocalSpanData { - span_id: _rt::string_lift(bytes269), + span_id: _rt::string_lift(bytes278), start: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l270 as u64, - nanoseconds: l271 as u32, + seconds: l279 as u64, + nanoseconds: l280 as u32, }, - parent: match l272 { + parent: match l281 { 0 => None, 1 => { let e = { - let l273 = *base + let l282 = *base .add(24 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l274 = *base + let l283 = *base .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len275 = l274; - let bytes275 = _rt::Vec::from_raw_parts( - l273.cast(), - len275, - len275, + let len284 = l283; + let bytes284 = _rt::Vec::from_raw_parts( + l282.cast(), + len284, + len284, ); - _rt::string_lift(bytes275) + _rt::string_lift(bytes284) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - linked_context: match l276 { + linked_context: match l285 { 0 => None, 1 => { let e = { - let l277 = *base + let l286 = *base .add(40 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(); - l277 as u64 + l286 as u64 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - attributes: result288, - inherited: _rt::bool_lift(l289 as u8), + attributes: result297, + inherited: _rt::bool_lift(l298 as u8), } }; - V293::LocalSpan(e293) + V302::LocalSpan(e302) } n => { debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e293 = { - let l290 = *base.add(8).cast::<*mut u8>(); - let l291 = *base + let e302 = { + let l299 = *base.add(8).cast::<*mut u8>(); + let l300 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len292 = l291; - let bytes292 = _rt::Vec::from_raw_parts( - l290.cast(), - len292, - len292, + let len301 = l300; + let bytes301 = _rt::Vec::from_raw_parts( + l299.cast(), + len301, + len301, ); super::super::super::super::golem::api::oplog::ExternalSpanData { - span_id: _rt::string_lift(bytes292), + span_id: _rt::string_lift(bytes301), } }; - V293::ExternalSpan(e293) + V302::ExternalSpan(e302) } }; - v293 + v302 }; - result294.push(e294); + result303.push(e303); } _rt::cabi_dealloc( - base294, - len294 * (56 + 6 * ::core::mem::size_of::<*const u8>()), + base303, + len303 * (56 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - result294 + result303 }; - result295.push(e295); + result304.push(e304); } _rt::cabi_dealloc( - base295, - len295 * (2 * ::core::mem::size_of::<*const u8>()), + base304, + len304 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::ExportedFunctionInvokedParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l194 as u64, - nanoseconds: l195 as u32, + seconds: l203 as u64, + nanoseconds: l204 as u32, }, - function_name: _rt::string_lift(bytes198), - request: result249, - idempotency_key: _rt::string_lift(bytes252), - trace_id: _rt::string_lift(bytes255), - trace_states: result261, - invocation_context: result295, + function_name: _rt::string_lift(bytes207), + request: result258, + idempotency_key: _rt::string_lift(bytes261), + trace_id: _rt::string_lift(bytes264), + trace_states: result270, + invocation_context: result304, } }; - V655::ExportedFunctionInvoked(e655) + V664::ExportedFunctionInvoked(e664) } 3 => { - let e655 = { - let l296 = *base.add(8).cast::(); - let l297 = *base.add(16).cast::(); - let l298 = i32::from(*base.add(24).cast::()); - let l347 = *base + let e664 = { + let l305 = *base.add(8).cast::(); + let l306 = *base.add(16).cast::(); + let l307 = i32::from(*base.add(24).cast::()); + let l356 = *base .add(32 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); super::super::super::super::golem::api::oplog::ExportedFunctionCompletedParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l296 as u64, - nanoseconds: l297 as u32, + seconds: l305 as u64, + nanoseconds: l306 as u32, }, - response: match l298 { + response: match l307 { 0 => None, 1 => { let e = { - let l299 = *base + let l308 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l300 = *base + let l309 = *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base346 = l299; - let len346 = l300; - let mut result346 = _rt::Vec::with_capacity(len346); - for i in 0..len346 { - let base = base346 + let base355 = l308; + let len355 = l309; + let mut result355 = _rt::Vec::with_capacity(len355); + for i in 0..len355 { + let base = base355 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e346 = { - let l301 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::rpc::types::WitNode as V345; - let v345 = match l301 { + let e355 = { + let l310 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::rpc::types::WitNode as V354; + let v354 = match l310 { 0 => { - let e345 = { - let l302 = *base.add(8).cast::<*mut u8>(); - let l303 = *base + let e354 = { + let l311 = *base.add(8).cast::<*mut u8>(); + let l312 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len304 = l303; - _rt::Vec::from_raw_parts(l302.cast(), len304, len304) + let len313 = l312; + _rt::Vec::from_raw_parts(l311.cast(), len313, len313) }; - V345::RecordValue(e345) + V354::RecordValue(e354) } 1 => { - let e345 = { - let l305 = *base.add(8).cast::(); - let l306 = i32::from(*base.add(12).cast::()); + let e354 = { + let l314 = *base.add(8).cast::(); + let l315 = i32::from(*base.add(12).cast::()); ( - l305 as u32, - match l306 { + l314 as u32, + match l315 { 0 => None, 1 => { let e = { - let l307 = *base.add(16).cast::(); - l307 + let l316 = *base.add(16).cast::(); + l316 }; Some(e) } @@ -19195,89 +19506,89 @@ pub mod exports { }, ) }; - V345::VariantValue(e345) + V354::VariantValue(e354) } 2 => { - let e345 = { - let l308 = *base.add(8).cast::(); - l308 as u32 + let e354 = { + let l317 = *base.add(8).cast::(); + l317 as u32 }; - V345::EnumValue(e345) + V354::EnumValue(e354) } 3 => { - let e345 = { - let l309 = *base.add(8).cast::<*mut u8>(); - let l310 = *base + let e354 = { + let l318 = *base.add(8).cast::<*mut u8>(); + let l319 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base312 = l309; - let len312 = l310; - let mut result312 = _rt::Vec::with_capacity(len312); - for i in 0..len312 { - let base = base312.add(i * 1); - let e312 = { - let l311 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l311 as u8) + let base321 = l318; + let len321 = l319; + let mut result321 = _rt::Vec::with_capacity(len321); + for i in 0..len321 { + let base = base321.add(i * 1); + let e321 = { + let l320 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l320 as u8) }; - result312.push(e312); + result321.push(e321); } - _rt::cabi_dealloc(base312, len312 * 1, 1); - result312 + _rt::cabi_dealloc(base321, len321 * 1, 1); + result321 }; - V345::FlagsValue(e345) + V354::FlagsValue(e354) } 4 => { - let e345 = { - let l313 = *base.add(8).cast::<*mut u8>(); - let l314 = *base + let e354 = { + let l322 = *base.add(8).cast::<*mut u8>(); + let l323 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len315 = l314; - _rt::Vec::from_raw_parts(l313.cast(), len315, len315) + let len324 = l323; + _rt::Vec::from_raw_parts(l322.cast(), len324, len324) }; - V345::TupleValue(e345) + V354::TupleValue(e354) } 5 => { - let e345 = { - let l316 = *base.add(8).cast::<*mut u8>(); - let l317 = *base + let e354 = { + let l325 = *base.add(8).cast::<*mut u8>(); + let l326 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len318 = l317; - _rt::Vec::from_raw_parts(l316.cast(), len318, len318) + let len327 = l326; + _rt::Vec::from_raw_parts(l325.cast(), len327, len327) }; - V345::ListValue(e345) + V354::ListValue(e354) } 6 => { - let e345 = { - let l319 = i32::from(*base.add(8).cast::()); - match l319 { + let e354 = { + let l328 = i32::from(*base.add(8).cast::()); + match l328 { 0 => None, 1 => { let e = { - let l320 = *base.add(12).cast::(); - l320 + let l329 = *base.add(12).cast::(); + l329 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V345::OptionValue(e345) + V354::OptionValue(e354) } 7 => { - let e345 = { - let l321 = i32::from(*base.add(8).cast::()); - match l321 { + let e354 = { + let l330 = i32::from(*base.add(8).cast::()); + match l330 { 0 => { let e = { - let l322 = i32::from(*base.add(12).cast::()); - match l322 { + let l331 = i32::from(*base.add(12).cast::()); + match l331 { 0 => None, 1 => { let e = { - let l323 = *base.add(16).cast::(); - l323 + let l332 = *base.add(16).cast::(); + l332 }; Some(e) } @@ -19288,13 +19599,13 @@ pub mod exports { } 1 => { let e = { - let l324 = i32::from(*base.add(12).cast::()); - match l324 { + let l333 = i32::from(*base.add(12).cast::()); + match l333 { 0 => None, 1 => { let e = { - let l325 = *base.add(16).cast::(); - l325 + let l334 = *base.add(16).cast::(); + l334 }; Some(e) } @@ -19306,266 +19617,266 @@ pub mod exports { _ => _rt::invalid_enum_discriminant(), } }; - V345::ResultValue(e345) + V354::ResultValue(e354) } 8 => { - let e345 = { - let l326 = i32::from(*base.add(8).cast::()); - l326 as u8 + let e354 = { + let l335 = i32::from(*base.add(8).cast::()); + l335 as u8 }; - V345::PrimU8(e345) + V354::PrimU8(e354) } 9 => { - let e345 = { - let l327 = i32::from(*base.add(8).cast::()); - l327 as u16 + let e354 = { + let l336 = i32::from(*base.add(8).cast::()); + l336 as u16 }; - V345::PrimU16(e345) + V354::PrimU16(e354) } 10 => { - let e345 = { - let l328 = *base.add(8).cast::(); - l328 as u32 + let e354 = { + let l337 = *base.add(8).cast::(); + l337 as u32 }; - V345::PrimU32(e345) + V354::PrimU32(e354) } 11 => { - let e345 = { - let l329 = *base.add(8).cast::(); - l329 as u64 + let e354 = { + let l338 = *base.add(8).cast::(); + l338 as u64 }; - V345::PrimU64(e345) + V354::PrimU64(e354) } 12 => { - let e345 = { - let l330 = i32::from(*base.add(8).cast::()); - l330 as i8 + let e354 = { + let l339 = i32::from(*base.add(8).cast::()); + l339 as i8 }; - V345::PrimS8(e345) + V354::PrimS8(e354) } 13 => { - let e345 = { - let l331 = i32::from(*base.add(8).cast::()); - l331 as i16 + let e354 = { + let l340 = i32::from(*base.add(8).cast::()); + l340 as i16 }; - V345::PrimS16(e345) + V354::PrimS16(e354) } 14 => { - let e345 = { - let l332 = *base.add(8).cast::(); - l332 + let e354 = { + let l341 = *base.add(8).cast::(); + l341 }; - V345::PrimS32(e345) + V354::PrimS32(e354) } 15 => { - let e345 = { - let l333 = *base.add(8).cast::(); - l333 + let e354 = { + let l342 = *base.add(8).cast::(); + l342 }; - V345::PrimS64(e345) + V354::PrimS64(e354) } 16 => { - let e345 = { - let l334 = *base.add(8).cast::(); - l334 + let e354 = { + let l343 = *base.add(8).cast::(); + l343 }; - V345::PrimFloat32(e345) + V354::PrimFloat32(e354) } 17 => { - let e345 = { - let l335 = *base.add(8).cast::(); - l335 + let e354 = { + let l344 = *base.add(8).cast::(); + l344 }; - V345::PrimFloat64(e345) + V354::PrimFloat64(e354) } 18 => { - let e345 = { - let l336 = *base.add(8).cast::(); - _rt::char_lift(l336 as u32) + let e354 = { + let l345 = *base.add(8).cast::(); + _rt::char_lift(l345 as u32) }; - V345::PrimChar(e345) + V354::PrimChar(e354) } 19 => { - let e345 = { - let l337 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l337 as u8) + let e354 = { + let l346 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l346 as u8) }; - V345::PrimBool(e345) + V354::PrimBool(e354) } 20 => { - let e345 = { - let l338 = *base.add(8).cast::<*mut u8>(); - let l339 = *base + let e354 = { + let l347 = *base.add(8).cast::<*mut u8>(); + let l348 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len340 = l339; - let bytes340 = _rt::Vec::from_raw_parts( - l338.cast(), - len340, - len340, + let len349 = l348; + let bytes349 = _rt::Vec::from_raw_parts( + l347.cast(), + len349, + len349, ); - _rt::string_lift(bytes340) + _rt::string_lift(bytes349) }; - V345::PrimString(e345) + V354::PrimString(e354) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e345 = { - let l341 = *base.add(8).cast::<*mut u8>(); - let l342 = *base + let e354 = { + let l350 = *base.add(8).cast::<*mut u8>(); + let l351 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len343 = l342; - let bytes343 = _rt::Vec::from_raw_parts( - l341.cast(), - len343, - len343, + let len352 = l351; + let bytes352 = _rt::Vec::from_raw_parts( + l350.cast(), + len352, + len352, ); - let l344 = *base + let l353 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( super::super::super::super::golem::rpc::types::Uri { - value: _rt::string_lift(bytes343), + value: _rt::string_lift(bytes352), }, - l344 as u64, + l353 as u64, ) }; - V345::Handle(e345) + V354::Handle(e354) } }; - v345 + v354 }; - result346.push(e346); + result355.push(e355); } _rt::cabi_dealloc( - base346, - len346 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base355, + len355 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::rpc::types::WitValue { - nodes: result346, + nodes: result355, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - consumed_fuel: l347, + consumed_fuel: l356, } }; - V655::ExportedFunctionCompleted(e655) + V664::ExportedFunctionCompleted(e664) } 4 => { - let e655 = { - let l348 = *base.add(8).cast::(); - let l349 = *base.add(16).cast::(); + let e664 = { + let l357 = *base.add(8).cast::(); + let l358 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l348 as u64, - nanoseconds: l349 as u32, + seconds: l357 as u64, + nanoseconds: l358 as u32, } }; - V655::Suspend(e655) + V664::Suspend(e664) } 5 => { - let e655 = { - let l350 = *base.add(8).cast::(); - let l351 = *base.add(16).cast::(); - let l352 = *base.add(24).cast::<*mut u8>(); - let l353 = *base + let e664 = { + let l359 = *base.add(8).cast::(); + let l360 = *base.add(16).cast::(); + let l361 = *base.add(24).cast::<*mut u8>(); + let l362 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len354 = l353; - let bytes354 = _rt::Vec::from_raw_parts( - l352.cast(), - len354, - len354, + let len363 = l362; + let bytes363 = _rt::Vec::from_raw_parts( + l361.cast(), + len363, + len363, ); super::super::super::super::golem::api::oplog::ErrorParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l350 as u64, - nanoseconds: l351 as u32, + seconds: l359 as u64, + nanoseconds: l360 as u32, }, - error: _rt::string_lift(bytes354), + error: _rt::string_lift(bytes363), } }; - V655::Error(e655) + V664::Error(e664) } 6 => { - let e655 = { - let l355 = *base.add(8).cast::(); - let l356 = *base.add(16).cast::(); + let e664 = { + let l364 = *base.add(8).cast::(); + let l365 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l355 as u64, - nanoseconds: l356 as u32, + seconds: l364 as u64, + nanoseconds: l365 as u32, } }; - V655::NoOp(e655) + V664::NoOp(e664) } 7 => { - let e655 = { - let l357 = *base.add(8).cast::(); - let l358 = *base.add(16).cast::(); - let l359 = *base.add(24).cast::(); - let l360 = *base.add(32).cast::(); + let e664 = { + let l366 = *base.add(8).cast::(); + let l367 = *base.add(16).cast::(); + let l368 = *base.add(24).cast::(); + let l369 = *base.add(32).cast::(); super::super::super::super::golem::api::oplog::JumpParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l357 as u64, - nanoseconds: l358 as u32, + seconds: l366 as u64, + nanoseconds: l367 as u32, }, - start: l359 as u64, - end: l360 as u64, + start: l368 as u64, + end: l369 as u64, } }; - V655::Jump(e655) + V664::Jump(e664) } 8 => { - let e655 = { - let l361 = *base.add(8).cast::(); - let l362 = *base.add(16).cast::(); + let e664 = { + let l370 = *base.add(8).cast::(); + let l371 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l361 as u64, - nanoseconds: l362 as u32, + seconds: l370 as u64, + nanoseconds: l371 as u32, } }; - V655::Interrupted(e655) + V664::Interrupted(e664) } 9 => { - let e655 = { - let l363 = *base.add(8).cast::(); - let l364 = *base.add(16).cast::(); + let e664 = { + let l372 = *base.add(8).cast::(); + let l373 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l363 as u64, - nanoseconds: l364 as u32, + seconds: l372 as u64, + nanoseconds: l373 as u32, } }; - V655::Exited(e655) + V664::Exited(e664) } 10 => { - let e655 = { - let l365 = *base.add(8).cast::(); - let l366 = *base.add(16).cast::(); - let l367 = *base.add(24).cast::(); - let l368 = *base.add(32).cast::(); - let l369 = *base.add(40).cast::(); - let l370 = *base.add(48).cast::(); - let l371 = i32::from(*base.add(56).cast::()); + let e664 = { + let l374 = *base.add(8).cast::(); + let l375 = *base.add(16).cast::(); + let l376 = *base.add(24).cast::(); + let l377 = *base.add(32).cast::(); + let l378 = *base.add(40).cast::(); + let l379 = *base.add(48).cast::(); + let l380 = i32::from(*base.add(56).cast::()); super::super::super::super::golem::api::oplog::ChangeRetryPolicyParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l365 as u64, - nanoseconds: l366 as u32, + seconds: l374 as u64, + nanoseconds: l375 as u32, }, retry_policy: super::super::super::super::golem::api::host::RetryPolicy { - max_attempts: l367 as u32, - min_delay: l368 as u64, - max_delay: l369 as u64, - multiplier: l370, - max_jitter_factor: match l371 { + max_attempts: l376 as u32, + min_delay: l377 as u64, + max_delay: l378 as u64, + multiplier: l379, + max_jitter_factor: match l380 { 0 => None, 1 => { let e = { - let l372 = *base.add(64).cast::(); - l372 + let l381 = *base.add(64).cast::(); + l381 }; Some(e) } @@ -19574,153 +19885,153 @@ pub mod exports { }, } }; - V655::ChangeRetryPolicy(e655) + V664::ChangeRetryPolicy(e664) } 11 => { - let e655 = { - let l373 = *base.add(8).cast::(); - let l374 = *base.add(16).cast::(); + let e664 = { + let l382 = *base.add(8).cast::(); + let l383 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l373 as u64, - nanoseconds: l374 as u32, + seconds: l382 as u64, + nanoseconds: l383 as u32, } }; - V655::BeginAtomicRegion(e655) + V664::BeginAtomicRegion(e664) } 12 => { - let e655 = { - let l375 = *base.add(8).cast::(); - let l376 = *base.add(16).cast::(); - let l377 = *base.add(24).cast::(); + let e664 = { + let l384 = *base.add(8).cast::(); + let l385 = *base.add(16).cast::(); + let l386 = *base.add(24).cast::(); super::super::super::super::golem::api::oplog::EndAtomicRegionParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l375 as u64, - nanoseconds: l376 as u32, + seconds: l384 as u64, + nanoseconds: l385 as u32, }, - begin_index: l377 as u64, + begin_index: l386 as u64, } }; - V655::EndAtomicRegion(e655) + V664::EndAtomicRegion(e664) } 13 => { - let e655 = { - let l378 = *base.add(8).cast::(); - let l379 = *base.add(16).cast::(); + let e664 = { + let l387 = *base.add(8).cast::(); + let l388 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l378 as u64, - nanoseconds: l379 as u32, + seconds: l387 as u64, + nanoseconds: l388 as u32, } }; - V655::BeginRemoteWrite(e655) + V664::BeginRemoteWrite(e664) } 14 => { - let e655 = { - let l380 = *base.add(8).cast::(); - let l381 = *base.add(16).cast::(); - let l382 = *base.add(24).cast::(); + let e664 = { + let l389 = *base.add(8).cast::(); + let l390 = *base.add(16).cast::(); + let l391 = *base.add(24).cast::(); super::super::super::super::golem::api::oplog::EndRemoteWriteParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l380 as u64, - nanoseconds: l381 as u32, + seconds: l389 as u64, + nanoseconds: l390 as u32, }, - begin_index: l382 as u64, + begin_index: l391 as u64, } }; - V655::EndRemoteWrite(e655) + V664::EndRemoteWrite(e664) } 15 => { - let e655 = { - let l383 = *base.add(8).cast::(); - let l384 = *base.add(16).cast::(); - let l385 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::oplog::WorkerInvocation as V445; - let v445 = match l385 { + let e664 = { + let l392 = *base.add(8).cast::(); + let l393 = *base.add(16).cast::(); + let l394 = i32::from(*base.add(24).cast::()); + use super::super::super::super::golem::api::oplog::WorkerInvocation as V454; + let v454 = match l394 { 0 => { - let e445 = { - let l386 = *base.add(32).cast::<*mut u8>(); - let l387 = *base + let e454 = { + let l395 = *base.add(32).cast::<*mut u8>(); + let l396 = *base .add(32 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len388 = l387; - let bytes388 = _rt::Vec::from_raw_parts( - l386.cast(), - len388, - len388, + let len397 = l396; + let bytes397 = _rt::Vec::from_raw_parts( + l395.cast(), + len397, + len397, ); - let l389 = *base + let l398 = *base .add(32 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l390 = *base + let l399 = *base .add(32 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len391 = l390; - let bytes391 = _rt::Vec::from_raw_parts( - l389.cast(), - len391, - len391, + let len400 = l399; + let bytes400 = _rt::Vec::from_raw_parts( + l398.cast(), + len400, + len400, ); - let l392 = i32::from( + let l401 = i32::from( *base .add(32 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(), ); super::super::super::super::golem::api::oplog::ExportedFunctionInvocationParameters { - idempotency_key: _rt::string_lift(bytes388), - function_name: _rt::string_lift(bytes391), - input: match l392 { + idempotency_key: _rt::string_lift(bytes397), + function_name: _rt::string_lift(bytes400), + input: match l401 { 0 => None, 1 => { let e = { - let l393 = *base + let l402 = *base .add(32 + 5 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l394 = *base + let l403 = *base .add(32 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base443 = l393; - let len443 = l394; - let mut result443 = _rt::Vec::with_capacity(len443); - for i in 0..len443 { - let base = base443 + let base452 = l402; + let len452 = l403; + let mut result452 = _rt::Vec::with_capacity(len452); + for i in 0..len452 { + let base = base452 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e443 = { - let l395 = *base.add(0).cast::<*mut u8>(); - let l396 = *base + let e452 = { + let l404 = *base.add(0).cast::<*mut u8>(); + let l405 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base442 = l395; - let len442 = l396; - let mut result442 = _rt::Vec::with_capacity(len442); - for i in 0..len442 { - let base = base442 + let base451 = l404; + let len451 = l405; + let mut result451 = _rt::Vec::with_capacity(len451); + for i in 0..len451 { + let base = base451 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e442 = { - let l397 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::rpc::types::WitNode as V441; - let v441 = match l397 { + let e451 = { + let l406 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::rpc::types::WitNode as V450; + let v450 = match l406 { 0 => { - let e441 = { - let l398 = *base.add(8).cast::<*mut u8>(); - let l399 = *base + let e450 = { + let l407 = *base.add(8).cast::<*mut u8>(); + let l408 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len400 = l399; - _rt::Vec::from_raw_parts(l398.cast(), len400, len400) + let len409 = l408; + _rt::Vec::from_raw_parts(l407.cast(), len409, len409) }; - V441::RecordValue(e441) + V450::RecordValue(e450) } 1 => { - let e441 = { - let l401 = *base.add(8).cast::(); - let l402 = i32::from(*base.add(12).cast::()); + let e450 = { + let l410 = *base.add(8).cast::(); + let l411 = i32::from(*base.add(12).cast::()); ( - l401 as u32, - match l402 { + l410 as u32, + match l411 { 0 => None, 1 => { let e = { - let l403 = *base.add(16).cast::(); - l403 + let l412 = *base.add(16).cast::(); + l412 }; Some(e) } @@ -19728,89 +20039,89 @@ pub mod exports { }, ) }; - V441::VariantValue(e441) + V450::VariantValue(e450) } 2 => { - let e441 = { - let l404 = *base.add(8).cast::(); - l404 as u32 + let e450 = { + let l413 = *base.add(8).cast::(); + l413 as u32 }; - V441::EnumValue(e441) + V450::EnumValue(e450) } 3 => { - let e441 = { - let l405 = *base.add(8).cast::<*mut u8>(); - let l406 = *base + let e450 = { + let l414 = *base.add(8).cast::<*mut u8>(); + let l415 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base408 = l405; - let len408 = l406; - let mut result408 = _rt::Vec::with_capacity(len408); - for i in 0..len408 { - let base = base408.add(i * 1); - let e408 = { - let l407 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l407 as u8) + let base417 = l414; + let len417 = l415; + let mut result417 = _rt::Vec::with_capacity(len417); + for i in 0..len417 { + let base = base417.add(i * 1); + let e417 = { + let l416 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l416 as u8) }; - result408.push(e408); + result417.push(e417); } - _rt::cabi_dealloc(base408, len408 * 1, 1); - result408 + _rt::cabi_dealloc(base417, len417 * 1, 1); + result417 }; - V441::FlagsValue(e441) + V450::FlagsValue(e450) } 4 => { - let e441 = { - let l409 = *base.add(8).cast::<*mut u8>(); - let l410 = *base + let e450 = { + let l418 = *base.add(8).cast::<*mut u8>(); + let l419 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len411 = l410; - _rt::Vec::from_raw_parts(l409.cast(), len411, len411) + let len420 = l419; + _rt::Vec::from_raw_parts(l418.cast(), len420, len420) }; - V441::TupleValue(e441) + V450::TupleValue(e450) } 5 => { - let e441 = { - let l412 = *base.add(8).cast::<*mut u8>(); - let l413 = *base + let e450 = { + let l421 = *base.add(8).cast::<*mut u8>(); + let l422 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len414 = l413; - _rt::Vec::from_raw_parts(l412.cast(), len414, len414) + let len423 = l422; + _rt::Vec::from_raw_parts(l421.cast(), len423, len423) }; - V441::ListValue(e441) + V450::ListValue(e450) } 6 => { - let e441 = { - let l415 = i32::from(*base.add(8).cast::()); - match l415 { + let e450 = { + let l424 = i32::from(*base.add(8).cast::()); + match l424 { 0 => None, 1 => { let e = { - let l416 = *base.add(12).cast::(); - l416 + let l425 = *base.add(12).cast::(); + l425 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V441::OptionValue(e441) + V450::OptionValue(e450) } 7 => { - let e441 = { - let l417 = i32::from(*base.add(8).cast::()); - match l417 { + let e450 = { + let l426 = i32::from(*base.add(8).cast::()); + match l426 { 0 => { let e = { - let l418 = i32::from(*base.add(12).cast::()); - match l418 { + let l427 = i32::from(*base.add(12).cast::()); + match l427 { 0 => None, 1 => { let e = { - let l419 = *base.add(16).cast::(); - l419 + let l428 = *base.add(16).cast::(); + l428 }; Some(e) } @@ -19821,13 +20132,13 @@ pub mod exports { } 1 => { let e = { - let l420 = i32::from(*base.add(12).cast::()); - match l420 { + let l429 = i32::from(*base.add(12).cast::()); + match l429 { 0 => None, 1 => { let e = { - let l421 = *base.add(16).cast::(); - l421 + let l430 = *base.add(16).cast::(); + l430 }; Some(e) } @@ -19839,155 +20150,155 @@ pub mod exports { _ => _rt::invalid_enum_discriminant(), } }; - V441::ResultValue(e441) + V450::ResultValue(e450) } 8 => { - let e441 = { - let l422 = i32::from(*base.add(8).cast::()); - l422 as u8 + let e450 = { + let l431 = i32::from(*base.add(8).cast::()); + l431 as u8 }; - V441::PrimU8(e441) + V450::PrimU8(e450) } 9 => { - let e441 = { - let l423 = i32::from(*base.add(8).cast::()); - l423 as u16 + let e450 = { + let l432 = i32::from(*base.add(8).cast::()); + l432 as u16 }; - V441::PrimU16(e441) + V450::PrimU16(e450) } 10 => { - let e441 = { - let l424 = *base.add(8).cast::(); - l424 as u32 + let e450 = { + let l433 = *base.add(8).cast::(); + l433 as u32 }; - V441::PrimU32(e441) + V450::PrimU32(e450) } 11 => { - let e441 = { - let l425 = *base.add(8).cast::(); - l425 as u64 + let e450 = { + let l434 = *base.add(8).cast::(); + l434 as u64 }; - V441::PrimU64(e441) + V450::PrimU64(e450) } 12 => { - let e441 = { - let l426 = i32::from(*base.add(8).cast::()); - l426 as i8 + let e450 = { + let l435 = i32::from(*base.add(8).cast::()); + l435 as i8 }; - V441::PrimS8(e441) + V450::PrimS8(e450) } 13 => { - let e441 = { - let l427 = i32::from(*base.add(8).cast::()); - l427 as i16 + let e450 = { + let l436 = i32::from(*base.add(8).cast::()); + l436 as i16 }; - V441::PrimS16(e441) + V450::PrimS16(e450) } 14 => { - let e441 = { - let l428 = *base.add(8).cast::(); - l428 + let e450 = { + let l437 = *base.add(8).cast::(); + l437 }; - V441::PrimS32(e441) + V450::PrimS32(e450) } 15 => { - let e441 = { - let l429 = *base.add(8).cast::(); - l429 + let e450 = { + let l438 = *base.add(8).cast::(); + l438 }; - V441::PrimS64(e441) + V450::PrimS64(e450) } 16 => { - let e441 = { - let l430 = *base.add(8).cast::(); - l430 + let e450 = { + let l439 = *base.add(8).cast::(); + l439 }; - V441::PrimFloat32(e441) + V450::PrimFloat32(e450) } 17 => { - let e441 = { - let l431 = *base.add(8).cast::(); - l431 + let e450 = { + let l440 = *base.add(8).cast::(); + l440 }; - V441::PrimFloat64(e441) + V450::PrimFloat64(e450) } 18 => { - let e441 = { - let l432 = *base.add(8).cast::(); - _rt::char_lift(l432 as u32) + let e450 = { + let l441 = *base.add(8).cast::(); + _rt::char_lift(l441 as u32) }; - V441::PrimChar(e441) + V450::PrimChar(e450) } 19 => { - let e441 = { - let l433 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l433 as u8) + let e450 = { + let l442 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l442 as u8) }; - V441::PrimBool(e441) + V450::PrimBool(e450) } 20 => { - let e441 = { - let l434 = *base.add(8).cast::<*mut u8>(); - let l435 = *base + let e450 = { + let l443 = *base.add(8).cast::<*mut u8>(); + let l444 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len436 = l435; - let bytes436 = _rt::Vec::from_raw_parts( - l434.cast(), - len436, - len436, + let len445 = l444; + let bytes445 = _rt::Vec::from_raw_parts( + l443.cast(), + len445, + len445, ); - _rt::string_lift(bytes436) + _rt::string_lift(bytes445) }; - V441::PrimString(e441) + V450::PrimString(e450) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e441 = { - let l437 = *base.add(8).cast::<*mut u8>(); - let l438 = *base + let e450 = { + let l446 = *base.add(8).cast::<*mut u8>(); + let l447 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len439 = l438; - let bytes439 = _rt::Vec::from_raw_parts( - l437.cast(), - len439, - len439, + let len448 = l447; + let bytes448 = _rt::Vec::from_raw_parts( + l446.cast(), + len448, + len448, ); - let l440 = *base + let l449 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( super::super::super::super::golem::rpc::types::Uri { - value: _rt::string_lift(bytes439), + value: _rt::string_lift(bytes448), }, - l440 as u64, + l449 as u64, ) }; - V441::Handle(e441) + V450::Handle(e450) } }; - v441 + v450 }; - result442.push(e442); + result451.push(e451); } _rt::cabi_dealloc( - base442, - len442 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base451, + len451 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::rpc::types::WitValue { - nodes: result442, + nodes: result451, } }; - result443.push(e443); + result452.push(e452); } _rt::cabi_dealloc( - base443, - len443 * (2 * ::core::mem::size_of::<*const u8>()), + base452, + len452 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result443 + result452 }; Some(e) } @@ -19995,205 +20306,205 @@ pub mod exports { }, } }; - V445::ExportedFunction(e445) + V454::ExportedFunction(e454) } n => { debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e445 = { - let l444 = *base.add(32).cast::(); - l444 as u64 + let e454 = { + let l453 = *base.add(32).cast::(); + l453 as u64 }; - V445::ManualUpdate(e445) + V454::ManualUpdate(e454) } }; super::super::super::super::golem::api::oplog::PendingWorkerInvocationParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l383 as u64, - nanoseconds: l384 as u32, + seconds: l392 as u64, + nanoseconds: l393 as u32, }, - invocation: v445, + invocation: v454, } }; - V655::PendingWorkerInvocation(e655) + V664::PendingWorkerInvocation(e664) } 16 => { - let e655 = { - let l446 = *base.add(8).cast::(); - let l447 = *base.add(16).cast::(); - let l448 = *base.add(24).cast::(); - let l449 = i32::from(*base.add(32).cast::()); - use super::super::super::super::golem::api::oplog::UpdateDescription as V453; - let v453 = match l449 { - 0 => V453::AutoUpdate, + let e664 = { + let l455 = *base.add(8).cast::(); + let l456 = *base.add(16).cast::(); + let l457 = *base.add(24).cast::(); + let l458 = i32::from(*base.add(32).cast::()); + use super::super::super::super::golem::api::oplog::UpdateDescription as V462; + let v462 = match l458 { + 0 => V462::AutoUpdate, n => { debug_assert_eq!(n, 1, "invalid enum discriminant"); - let e453 = { - let l450 = *base + let e462 = { + let l459 = *base .add(32 + 1 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l451 = *base + let l460 = *base .add(32 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len452 = l451; - _rt::Vec::from_raw_parts(l450.cast(), len452, len452) + let len461 = l460; + _rt::Vec::from_raw_parts(l459.cast(), len461, len461) }; - V453::SnapshotBased(e453) + V462::SnapshotBased(e462) } }; super::super::super::super::golem::api::oplog::PendingUpdateParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l446 as u64, - nanoseconds: l447 as u32, + seconds: l455 as u64, + nanoseconds: l456 as u32, }, - target_version: l448 as u64, - update_description: v453, + target_version: l457 as u64, + update_description: v462, } }; - V655::PendingUpdate(e655) + V664::PendingUpdate(e664) } 17 => { - let e655 = { - let l454 = *base.add(8).cast::(); - let l455 = *base.add(16).cast::(); - let l456 = *base.add(24).cast::(); - let l457 = *base.add(32).cast::(); - let l458 = *base.add(40).cast::<*mut u8>(); - let l459 = *base + let e664 = { + let l463 = *base.add(8).cast::(); + let l464 = *base.add(16).cast::(); + let l465 = *base.add(24).cast::(); + let l466 = *base.add(32).cast::(); + let l467 = *base.add(40).cast::<*mut u8>(); + let l468 = *base .add(40 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base477 = l458; - let len477 = l459; - let mut result477 = _rt::Vec::with_capacity(len477); - for i in 0..len477 { - let base = base477 + let base486 = l467; + let len486 = l468; + let mut result486 = _rt::Vec::with_capacity(len486); + for i in 0..len486 { + let base = base486 .add(i * (16 + 6 * ::core::mem::size_of::<*const u8>())); - let e477 = { - let l460 = *base.add(0).cast::(); - let l461 = *base.add(8).cast::(); - let l462 = *base.add(16).cast::<*mut u8>(); - let l463 = *base + let e486 = { + let l469 = *base.add(0).cast::(); + let l470 = *base.add(8).cast::(); + let l471 = *base.add(16).cast::<*mut u8>(); + let l472 = *base .add(16 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len464 = l463; - let bytes464 = _rt::Vec::from_raw_parts( - l462.cast(), - len464, - len464, + let len473 = l472; + let bytes473 = _rt::Vec::from_raw_parts( + l471.cast(), + len473, + len473, ); - let l465 = *base + let l474 = *base .add(16 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l466 = *base + let l475 = *base .add(16 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len467 = l466; - let bytes467 = _rt::Vec::from_raw_parts( - l465.cast(), - len467, - len467, + let len476 = l475; + let bytes476 = _rt::Vec::from_raw_parts( + l474.cast(), + len476, + len476, ); - let l468 = *base + let l477 = *base .add(16 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l469 = *base + let l478 = *base .add(16 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base476 = l468; - let len476 = l469; - let mut result476 = _rt::Vec::with_capacity(len476); - for i in 0..len476 { - let base = base476 + let base485 = l477; + let len485 = l478; + let mut result485 = _rt::Vec::with_capacity(len485); + for i in 0..len485 { + let base = base485 .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e476 = { - let l470 = *base.add(0).cast::<*mut u8>(); - let l471 = *base + let e485 = { + let l479 = *base.add(0).cast::<*mut u8>(); + let l480 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len472 = l471; - let bytes472 = _rt::Vec::from_raw_parts( - l470.cast(), - len472, - len472, + let len481 = l480; + let bytes481 = _rt::Vec::from_raw_parts( + l479.cast(), + len481, + len481, ); - let l473 = *base + let l482 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l474 = *base + let l483 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len475 = l474; - let bytes475 = _rt::Vec::from_raw_parts( - l473.cast(), - len475, - len475, + let len484 = l483; + let bytes484 = _rt::Vec::from_raw_parts( + l482.cast(), + len484, + len484, ); - (_rt::string_lift(bytes472), _rt::string_lift(bytes475)) + (_rt::string_lift(bytes481), _rt::string_lift(bytes484)) }; - result476.push(e476); + result485.push(e485); } _rt::cabi_dealloc( - base476, - len476 * (4 * ::core::mem::size_of::<*const u8>()), + base485, + len485 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::PluginInstallationDescription { installation_id: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l460 as u64, - low_bits: l461 as u64, + high_bits: l469 as u64, + low_bits: l470 as u64, }, - name: _rt::string_lift(bytes464), - version: _rt::string_lift(bytes467), - parameters: result476, + name: _rt::string_lift(bytes473), + version: _rt::string_lift(bytes476), + parameters: result485, } }; - result477.push(e477); + result486.push(e486); } _rt::cabi_dealloc( - base477, - len477 * (16 + 6 * ::core::mem::size_of::<*const u8>()), + base486, + len486 * (16 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::api::oplog::SuccessfulUpdateParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l454 as u64, - nanoseconds: l455 as u32, + seconds: l463 as u64, + nanoseconds: l464 as u32, }, - target_version: l456 as u64, - new_component_size: l457 as u64, - new_active_plugins: result477, + target_version: l465 as u64, + new_component_size: l466 as u64, + new_active_plugins: result486, } }; - V655::SuccessfulUpdate(e655) + V664::SuccessfulUpdate(e664) } 18 => { - let e655 = { - let l478 = *base.add(8).cast::(); - let l479 = *base.add(16).cast::(); - let l480 = *base.add(24).cast::(); - let l481 = i32::from(*base.add(32).cast::()); + let e664 = { + let l487 = *base.add(8).cast::(); + let l488 = *base.add(16).cast::(); + let l489 = *base.add(24).cast::(); + let l490 = i32::from(*base.add(32).cast::()); super::super::super::super::golem::api::oplog::FailedUpdateParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l478 as u64, - nanoseconds: l479 as u32, + seconds: l487 as u64, + nanoseconds: l488 as u32, }, - target_version: l480 as u64, - details: match l481 { + target_version: l489 as u64, + details: match l490 { 0 => None, 1 => { let e = { - let l482 = *base + let l491 = *base .add(32 + 1 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l483 = *base + let l492 = *base .add(32 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len484 = l483; - let bytes484 = _rt::Vec::from_raw_parts( - l482.cast(), - len484, - len484, + let len493 = l492; + let bytes493 = _rt::Vec::from_raw_parts( + l491.cast(), + len493, + len493, ); - _rt::string_lift(bytes484) + _rt::string_lift(bytes493) }; Some(e) } @@ -20201,118 +20512,118 @@ pub mod exports { }, } }; - V655::FailedUpdate(e655) + V664::FailedUpdate(e664) } 19 => { - let e655 = { - let l485 = *base.add(8).cast::(); - let l486 = *base.add(16).cast::(); - let l487 = *base.add(24).cast::(); + let e664 = { + let l494 = *base.add(8).cast::(); + let l495 = *base.add(16).cast::(); + let l496 = *base.add(24).cast::(); super::super::super::super::golem::api::oplog::GrowMemoryParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l485 as u64, - nanoseconds: l486 as u32, + seconds: l494 as u64, + nanoseconds: l495 as u32, }, - delta: l487 as u64, + delta: l496 as u64, } }; - V655::GrowMemory(e655) + V664::GrowMemory(e664) } 20 => { - let e655 = { - let l488 = *base.add(8).cast::(); - let l489 = *base.add(16).cast::(); - let l490 = *base.add(24).cast::(); + let e664 = { + let l497 = *base.add(8).cast::(); + let l498 = *base.add(16).cast::(); + let l499 = *base.add(24).cast::(); super::super::super::super::golem::api::oplog::CreateResourceParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l488 as u64, - nanoseconds: l489 as u32, + seconds: l497 as u64, + nanoseconds: l498 as u32, }, - resource_id: l490 as u64, + resource_id: l499 as u64, } }; - V655::CreateResource(e655) + V664::CreateResource(e664) } 21 => { - let e655 = { - let l491 = *base.add(8).cast::(); - let l492 = *base.add(16).cast::(); - let l493 = *base.add(24).cast::(); + let e664 = { + let l500 = *base.add(8).cast::(); + let l501 = *base.add(16).cast::(); + let l502 = *base.add(24).cast::(); super::super::super::super::golem::api::oplog::DropResourceParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l491 as u64, - nanoseconds: l492 as u32, + seconds: l500 as u64, + nanoseconds: l501 as u32, }, - resource_id: l493 as u64, + resource_id: l502 as u64, } }; - V655::DropResource(e655) + V664::DropResource(e664) } 22 => { - let e655 = { - let l494 = *base.add(8).cast::(); - let l495 = *base.add(16).cast::(); - let l496 = *base.add(24).cast::(); - let l497 = *base.add(32).cast::<*mut u8>(); - let l498 = *base + let e664 = { + let l503 = *base.add(8).cast::(); + let l504 = *base.add(16).cast::(); + let l505 = *base.add(24).cast::(); + let l506 = *base.add(32).cast::<*mut u8>(); + let l507 = *base .add(32 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len499 = l498; - let bytes499 = _rt::Vec::from_raw_parts( - l497.cast(), - len499, - len499, + let len508 = l507; + let bytes508 = _rt::Vec::from_raw_parts( + l506.cast(), + len508, + len508, ); - let l500 = *base + let l509 = *base .add(32 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l501 = *base + let l510 = *base .add(32 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base550 = l500; - let len550 = l501; - let mut result550 = _rt::Vec::with_capacity(len550); - for i in 0..len550 { - let base = base550 + let base559 = l509; + let len559 = l510; + let mut result559 = _rt::Vec::with_capacity(len559); + for i in 0..len559 { + let base = base559 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e550 = { - let l502 = *base.add(0).cast::<*mut u8>(); - let l503 = *base + let e559 = { + let l511 = *base.add(0).cast::<*mut u8>(); + let l512 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base549 = l502; - let len549 = l503; - let mut result549 = _rt::Vec::with_capacity(len549); - for i in 0..len549 { - let base = base549 + let base558 = l511; + let len558 = l512; + let mut result558 = _rt::Vec::with_capacity(len558); + for i in 0..len558 { + let base = base558 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e549 = { - let l504 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::rpc::types::WitNode as V548; - let v548 = match l504 { + let e558 = { + let l513 = i32::from(*base.add(0).cast::()); + use super::super::super::super::golem::rpc::types::WitNode as V557; + let v557 = match l513 { 0 => { - let e548 = { - let l505 = *base.add(8).cast::<*mut u8>(); - let l506 = *base + let e557 = { + let l514 = *base.add(8).cast::<*mut u8>(); + let l515 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len507 = l506; - _rt::Vec::from_raw_parts(l505.cast(), len507, len507) + let len516 = l515; + _rt::Vec::from_raw_parts(l514.cast(), len516, len516) }; - V548::RecordValue(e548) + V557::RecordValue(e557) } 1 => { - let e548 = { - let l508 = *base.add(8).cast::(); - let l509 = i32::from(*base.add(12).cast::()); + let e557 = { + let l517 = *base.add(8).cast::(); + let l518 = i32::from(*base.add(12).cast::()); ( - l508 as u32, - match l509 { + l517 as u32, + match l518 { 0 => None, 1 => { let e = { - let l510 = *base.add(16).cast::(); - l510 + let l519 = *base.add(16).cast::(); + l519 }; Some(e) } @@ -20320,89 +20631,89 @@ pub mod exports { }, ) }; - V548::VariantValue(e548) + V557::VariantValue(e557) } 2 => { - let e548 = { - let l511 = *base.add(8).cast::(); - l511 as u32 + let e557 = { + let l520 = *base.add(8).cast::(); + l520 as u32 }; - V548::EnumValue(e548) + V557::EnumValue(e557) } 3 => { - let e548 = { - let l512 = *base.add(8).cast::<*mut u8>(); - let l513 = *base + let e557 = { + let l521 = *base.add(8).cast::<*mut u8>(); + let l522 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base515 = l512; - let len515 = l513; - let mut result515 = _rt::Vec::with_capacity(len515); - for i in 0..len515 { - let base = base515.add(i * 1); - let e515 = { - let l514 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l514 as u8) + let base524 = l521; + let len524 = l522; + let mut result524 = _rt::Vec::with_capacity(len524); + for i in 0..len524 { + let base = base524.add(i * 1); + let e524 = { + let l523 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l523 as u8) }; - result515.push(e515); + result524.push(e524); } - _rt::cabi_dealloc(base515, len515 * 1, 1); - result515 + _rt::cabi_dealloc(base524, len524 * 1, 1); + result524 }; - V548::FlagsValue(e548) + V557::FlagsValue(e557) } 4 => { - let e548 = { - let l516 = *base.add(8).cast::<*mut u8>(); - let l517 = *base + let e557 = { + let l525 = *base.add(8).cast::<*mut u8>(); + let l526 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len518 = l517; - _rt::Vec::from_raw_parts(l516.cast(), len518, len518) + let len527 = l526; + _rt::Vec::from_raw_parts(l525.cast(), len527, len527) }; - V548::TupleValue(e548) + V557::TupleValue(e557) } 5 => { - let e548 = { - let l519 = *base.add(8).cast::<*mut u8>(); - let l520 = *base + let e557 = { + let l528 = *base.add(8).cast::<*mut u8>(); + let l529 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len521 = l520; - _rt::Vec::from_raw_parts(l519.cast(), len521, len521) + let len530 = l529; + _rt::Vec::from_raw_parts(l528.cast(), len530, len530) }; - V548::ListValue(e548) + V557::ListValue(e557) } 6 => { - let e548 = { - let l522 = i32::from(*base.add(8).cast::()); - match l522 { + let e557 = { + let l531 = i32::from(*base.add(8).cast::()); + match l531 { 0 => None, 1 => { let e = { - let l523 = *base.add(12).cast::(); - l523 + let l532 = *base.add(12).cast::(); + l532 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - V548::OptionValue(e548) + V557::OptionValue(e557) } 7 => { - let e548 = { - let l524 = i32::from(*base.add(8).cast::()); - match l524 { + let e557 = { + let l533 = i32::from(*base.add(8).cast::()); + match l533 { 0 => { let e = { - let l525 = i32::from(*base.add(12).cast::()); - match l525 { + let l534 = i32::from(*base.add(12).cast::()); + match l534 { 0 => None, 1 => { let e = { - let l526 = *base.add(16).cast::(); - l526 + let l535 = *base.add(16).cast::(); + l535 }; Some(e) } @@ -20413,13 +20724,13 @@ pub mod exports { } 1 => { let e = { - let l527 = i32::from(*base.add(12).cast::()); - match l527 { + let l536 = i32::from(*base.add(12).cast::()); + match l536 { 0 => None, 1 => { let e = { - let l528 = *base.add(16).cast::(); - l528 + let l537 = *base.add(16).cast::(); + l537 }; Some(e) } @@ -20431,707 +20742,707 @@ pub mod exports { _ => _rt::invalid_enum_discriminant(), } }; - V548::ResultValue(e548) + V557::ResultValue(e557) } 8 => { - let e548 = { - let l529 = i32::from(*base.add(8).cast::()); - l529 as u8 + let e557 = { + let l538 = i32::from(*base.add(8).cast::()); + l538 as u8 }; - V548::PrimU8(e548) + V557::PrimU8(e557) } 9 => { - let e548 = { - let l530 = i32::from(*base.add(8).cast::()); - l530 as u16 + let e557 = { + let l539 = i32::from(*base.add(8).cast::()); + l539 as u16 }; - V548::PrimU16(e548) + V557::PrimU16(e557) } 10 => { - let e548 = { - let l531 = *base.add(8).cast::(); - l531 as u32 + let e557 = { + let l540 = *base.add(8).cast::(); + l540 as u32 }; - V548::PrimU32(e548) + V557::PrimU32(e557) } 11 => { - let e548 = { - let l532 = *base.add(8).cast::(); - l532 as u64 + let e557 = { + let l541 = *base.add(8).cast::(); + l541 as u64 }; - V548::PrimU64(e548) + V557::PrimU64(e557) } 12 => { - let e548 = { - let l533 = i32::from(*base.add(8).cast::()); - l533 as i8 + let e557 = { + let l542 = i32::from(*base.add(8).cast::()); + l542 as i8 }; - V548::PrimS8(e548) + V557::PrimS8(e557) } 13 => { - let e548 = { - let l534 = i32::from(*base.add(8).cast::()); - l534 as i16 + let e557 = { + let l543 = i32::from(*base.add(8).cast::()); + l543 as i16 }; - V548::PrimS16(e548) + V557::PrimS16(e557) } 14 => { - let e548 = { - let l535 = *base.add(8).cast::(); - l535 + let e557 = { + let l544 = *base.add(8).cast::(); + l544 }; - V548::PrimS32(e548) + V557::PrimS32(e557) } 15 => { - let e548 = { - let l536 = *base.add(8).cast::(); - l536 + let e557 = { + let l545 = *base.add(8).cast::(); + l545 }; - V548::PrimS64(e548) + V557::PrimS64(e557) } 16 => { - let e548 = { - let l537 = *base.add(8).cast::(); - l537 + let e557 = { + let l546 = *base.add(8).cast::(); + l546 }; - V548::PrimFloat32(e548) + V557::PrimFloat32(e557) } 17 => { - let e548 = { - let l538 = *base.add(8).cast::(); - l538 + let e557 = { + let l547 = *base.add(8).cast::(); + l547 }; - V548::PrimFloat64(e548) + V557::PrimFloat64(e557) } 18 => { - let e548 = { - let l539 = *base.add(8).cast::(); - _rt::char_lift(l539 as u32) + let e557 = { + let l548 = *base.add(8).cast::(); + _rt::char_lift(l548 as u32) }; - V548::PrimChar(e548) + V557::PrimChar(e557) } 19 => { - let e548 = { - let l540 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l540 as u8) + let e557 = { + let l549 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l549 as u8) }; - V548::PrimBool(e548) + V557::PrimBool(e557) } 20 => { - let e548 = { - let l541 = *base.add(8).cast::<*mut u8>(); - let l542 = *base + let e557 = { + let l550 = *base.add(8).cast::<*mut u8>(); + let l551 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len543 = l542; - let bytes543 = _rt::Vec::from_raw_parts( - l541.cast(), - len543, - len543, + let len552 = l551; + let bytes552 = _rt::Vec::from_raw_parts( + l550.cast(), + len552, + len552, ); - _rt::string_lift(bytes543) + _rt::string_lift(bytes552) }; - V548::PrimString(e548) + V557::PrimString(e557) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e548 = { - let l544 = *base.add(8).cast::<*mut u8>(); - let l545 = *base + let e557 = { + let l553 = *base.add(8).cast::<*mut u8>(); + let l554 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len546 = l545; - let bytes546 = _rt::Vec::from_raw_parts( - l544.cast(), - len546, - len546, + let len555 = l554; + let bytes555 = _rt::Vec::from_raw_parts( + l553.cast(), + len555, + len555, ); - let l547 = *base + let l556 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( super::super::super::super::golem::rpc::types::Uri { - value: _rt::string_lift(bytes546), + value: _rt::string_lift(bytes555), }, - l547 as u64, + l556 as u64, ) }; - V548::Handle(e548) + V557::Handle(e557) } }; - v548 + v557 }; - result549.push(e549); + result558.push(e558); } _rt::cabi_dealloc( - base549, - len549 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base558, + len558 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::rpc::types::WitValue { - nodes: result549, + nodes: result558, } }; - result550.push(e550); + result559.push(e559); } _rt::cabi_dealloc( - base550, - len550 * (2 * ::core::mem::size_of::<*const u8>()), + base559, + len559 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::DescribeResourceParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l494 as u64, - nanoseconds: l495 as u32, + seconds: l503 as u64, + nanoseconds: l504 as u32, }, - resource_id: l496 as u64, - resource_name: _rt::string_lift(bytes499), - resource_params: result550, + resource_id: l505 as u64, + resource_name: _rt::string_lift(bytes508), + resource_params: result559, } }; - V655::DescribeResource(e655) + V664::DescribeResource(e664) } 23 => { - let e655 = { - let l551 = *base.add(8).cast::(); - let l552 = *base.add(16).cast::(); - let l553 = i32::from(*base.add(24).cast::()); - let l554 = *base + let e664 = { + let l560 = *base.add(8).cast::(); + let l561 = *base.add(16).cast::(); + let l562 = i32::from(*base.add(24).cast::()); + let l563 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l555 = *base + let l564 = *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len556 = l555; - let bytes556 = _rt::Vec::from_raw_parts( - l554.cast(), - len556, - len556, + let len565 = l564; + let bytes565 = _rt::Vec::from_raw_parts( + l563.cast(), + len565, + len565, ); - let l557 = *base + let l566 = *base .add(24 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l558 = *base + let l567 = *base .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len559 = l558; - let bytes559 = _rt::Vec::from_raw_parts( - l557.cast(), - len559, - len559, + let len568 = l567; + let bytes568 = _rt::Vec::from_raw_parts( + l566.cast(), + len568, + len568, ); super::super::super::super::golem::api::oplog::LogParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l551 as u64, - nanoseconds: l552 as u32, + seconds: l560 as u64, + nanoseconds: l561 as u32, }, level: super::super::super::super::golem::api::oplog::LogLevel::_lift( - l553 as u8, + l562 as u8, ), - context: _rt::string_lift(bytes556), - message: _rt::string_lift(bytes559), + context: _rt::string_lift(bytes565), + message: _rt::string_lift(bytes568), } }; - V655::Log(e655) + V664::Log(e664) } 24 => { - let e655 = { - let l560 = *base.add(8).cast::(); - let l561 = *base.add(16).cast::(); + let e664 = { + let l569 = *base.add(8).cast::(); + let l570 = *base.add(16).cast::(); super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l560 as u64, - nanoseconds: l561 as u32, + seconds: l569 as u64, + nanoseconds: l570 as u32, } }; - V655::Restart(e655) + V664::Restart(e664) } 25 => { - let e655 = { - let l562 = *base.add(8).cast::(); - let l563 = *base.add(16).cast::(); - let l564 = *base.add(24).cast::(); - let l565 = *base.add(32).cast::(); - let l566 = *base.add(40).cast::<*mut u8>(); - let l567 = *base + let e664 = { + let l571 = *base.add(8).cast::(); + let l572 = *base.add(16).cast::(); + let l573 = *base.add(24).cast::(); + let l574 = *base.add(32).cast::(); + let l575 = *base.add(40).cast::<*mut u8>(); + let l576 = *base .add(40 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len568 = l567; - let bytes568 = _rt::Vec::from_raw_parts( - l566.cast(), - len568, - len568, + let len577 = l576; + let bytes577 = _rt::Vec::from_raw_parts( + l575.cast(), + len577, + len577, ); - let l569 = *base + let l578 = *base .add(40 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l570 = *base + let l579 = *base .add(40 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len571 = l570; - let bytes571 = _rt::Vec::from_raw_parts( - l569.cast(), - len571, - len571, + let len580 = l579; + let bytes580 = _rt::Vec::from_raw_parts( + l578.cast(), + len580, + len580, ); - let l572 = *base + let l581 = *base .add(40 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l573 = *base + let l582 = *base .add(40 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base580 = l572; - let len580 = l573; - let mut result580 = _rt::Vec::with_capacity(len580); - for i in 0..len580 { - let base = base580 + let base589 = l581; + let len589 = l582; + let mut result589 = _rt::Vec::with_capacity(len589); + for i in 0..len589 { + let base = base589 .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e580 = { - let l574 = *base.add(0).cast::<*mut u8>(); - let l575 = *base + let e589 = { + let l583 = *base.add(0).cast::<*mut u8>(); + let l584 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len576 = l575; - let bytes576 = _rt::Vec::from_raw_parts( - l574.cast(), - len576, - len576, + let len585 = l584; + let bytes585 = _rt::Vec::from_raw_parts( + l583.cast(), + len585, + len585, ); - let l577 = *base + let l586 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l578 = *base + let l587 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len579 = l578; - let bytes579 = _rt::Vec::from_raw_parts( - l577.cast(), - len579, - len579, + let len588 = l587; + let bytes588 = _rt::Vec::from_raw_parts( + l586.cast(), + len588, + len588, ); - (_rt::string_lift(bytes576), _rt::string_lift(bytes579)) + (_rt::string_lift(bytes585), _rt::string_lift(bytes588)) }; - result580.push(e580); + result589.push(e589); } _rt::cabi_dealloc( - base580, - len580 * (4 * ::core::mem::size_of::<*const u8>()), + base589, + len589 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::ActivatePluginParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l562 as u64, - nanoseconds: l563 as u32, + seconds: l571 as u64, + nanoseconds: l572 as u32, }, plugin: super::super::super::super::golem::api::oplog::PluginInstallationDescription { installation_id: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l564 as u64, - low_bits: l565 as u64, + high_bits: l573 as u64, + low_bits: l574 as u64, }, - name: _rt::string_lift(bytes568), - version: _rt::string_lift(bytes571), - parameters: result580, + name: _rt::string_lift(bytes577), + version: _rt::string_lift(bytes580), + parameters: result589, }, } }; - V655::ActivatePlugin(e655) + V664::ActivatePlugin(e664) } 26 => { - let e655 = { - let l581 = *base.add(8).cast::(); - let l582 = *base.add(16).cast::(); - let l583 = *base.add(24).cast::(); - let l584 = *base.add(32).cast::(); - let l585 = *base.add(40).cast::<*mut u8>(); - let l586 = *base + let e664 = { + let l590 = *base.add(8).cast::(); + let l591 = *base.add(16).cast::(); + let l592 = *base.add(24).cast::(); + let l593 = *base.add(32).cast::(); + let l594 = *base.add(40).cast::<*mut u8>(); + let l595 = *base .add(40 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len587 = l586; - let bytes587 = _rt::Vec::from_raw_parts( - l585.cast(), - len587, - len587, + let len596 = l595; + let bytes596 = _rt::Vec::from_raw_parts( + l594.cast(), + len596, + len596, ); - let l588 = *base + let l597 = *base .add(40 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l589 = *base + let l598 = *base .add(40 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len590 = l589; - let bytes590 = _rt::Vec::from_raw_parts( - l588.cast(), - len590, - len590, + let len599 = l598; + let bytes599 = _rt::Vec::from_raw_parts( + l597.cast(), + len599, + len599, ); - let l591 = *base + let l600 = *base .add(40 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l592 = *base + let l601 = *base .add(40 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base599 = l591; - let len599 = l592; - let mut result599 = _rt::Vec::with_capacity(len599); - for i in 0..len599 { - let base = base599 + let base608 = l600; + let len608 = l601; + let mut result608 = _rt::Vec::with_capacity(len608); + for i in 0..len608 { + let base = base608 .add(i * (4 * ::core::mem::size_of::<*const u8>())); - let e599 = { - let l593 = *base.add(0).cast::<*mut u8>(); - let l594 = *base + let e608 = { + let l602 = *base.add(0).cast::<*mut u8>(); + let l603 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len595 = l594; - let bytes595 = _rt::Vec::from_raw_parts( - l593.cast(), - len595, - len595, + let len604 = l603; + let bytes604 = _rt::Vec::from_raw_parts( + l602.cast(), + len604, + len604, ); - let l596 = *base + let l605 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l597 = *base + let l606 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len598 = l597; - let bytes598 = _rt::Vec::from_raw_parts( - l596.cast(), - len598, - len598, + let len607 = l606; + let bytes607 = _rt::Vec::from_raw_parts( + l605.cast(), + len607, + len607, ); - (_rt::string_lift(bytes595), _rt::string_lift(bytes598)) + (_rt::string_lift(bytes604), _rt::string_lift(bytes607)) }; - result599.push(e599); + result608.push(e608); } _rt::cabi_dealloc( - base599, - len599 * (4 * ::core::mem::size_of::<*const u8>()), + base608, + len608 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::DeactivatePluginParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l581 as u64, - nanoseconds: l582 as u32, + seconds: l590 as u64, + nanoseconds: l591 as u32, }, plugin: super::super::super::super::golem::api::oplog::PluginInstallationDescription { installation_id: super::super::super::super::golem::rpc::types::Uuid { - high_bits: l583 as u64, - low_bits: l584 as u64, + high_bits: l592 as u64, + low_bits: l593 as u64, }, - name: _rt::string_lift(bytes587), - version: _rt::string_lift(bytes590), - parameters: result599, + name: _rt::string_lift(bytes596), + version: _rt::string_lift(bytes599), + parameters: result608, }, } }; - V655::DeactivatePlugin(e655) + V664::DeactivatePlugin(e664) } 27 => { - let e655 = { - let l600 = *base.add(8).cast::(); - let l601 = *base.add(16).cast::(); - let l602 = *base.add(24).cast::(); - let l603 = *base.add(32).cast::(); + let e664 = { + let l609 = *base.add(8).cast::(); + let l610 = *base.add(16).cast::(); + let l611 = *base.add(24).cast::(); + let l612 = *base.add(32).cast::(); super::super::super::super::golem::api::oplog::RevertParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l600 as u64, - nanoseconds: l601 as u32, + seconds: l609 as u64, + nanoseconds: l610 as u32, }, - start: l602 as u64, - end: l603 as u64, + start: l611 as u64, + end: l612 as u64, } }; - V655::Revert(e655) + V664::Revert(e664) } 28 => { - let e655 = { - let l604 = *base.add(8).cast::(); - let l605 = *base.add(16).cast::(); - let l606 = *base.add(24).cast::<*mut u8>(); - let l607 = *base + let e664 = { + let l613 = *base.add(8).cast::(); + let l614 = *base.add(16).cast::(); + let l615 = *base.add(24).cast::<*mut u8>(); + let l616 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len608 = l607; - let bytes608 = _rt::Vec::from_raw_parts( - l606.cast(), - len608, - len608, + let len617 = l616; + let bytes617 = _rt::Vec::from_raw_parts( + l615.cast(), + len617, + len617, ); super::super::super::super::golem::api::oplog::CancelInvocationParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l604 as u64, - nanoseconds: l605 as u32, + seconds: l613 as u64, + nanoseconds: l614 as u32, }, - idempotency_key: _rt::string_lift(bytes608), + idempotency_key: _rt::string_lift(bytes617), } }; - V655::CancelInvocation(e655) + V664::CancelInvocation(e664) } 29 => { - let e655 = { - let l609 = *base.add(8).cast::(); - let l610 = *base.add(16).cast::(); - let l611 = *base.add(24).cast::<*mut u8>(); - let l612 = *base + let e664 = { + let l618 = *base.add(8).cast::(); + let l619 = *base.add(16).cast::(); + let l620 = *base.add(24).cast::<*mut u8>(); + let l621 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len613 = l612; - let bytes613 = _rt::Vec::from_raw_parts( - l611.cast(), - len613, - len613, + let len622 = l621; + let bytes622 = _rt::Vec::from_raw_parts( + l620.cast(), + len622, + len622, ); - let l614 = i32::from( + let l623 = i32::from( *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l618 = i32::from( + let l627 = i32::from( *base .add(24 + 5 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l622 = *base + let l631 = *base .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l623 = *base + let l632 = *base .add(24 + 9 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base632 = l622; - let len632 = l623; - let mut result632 = _rt::Vec::with_capacity(len632); - for i in 0..len632 { - let base = base632 + let base641 = l631; + let len641 = l632; + let mut result641 = _rt::Vec::with_capacity(len641); + for i in 0..len641 { + let base = base641 .add(i * (5 * ::core::mem::size_of::<*const u8>())); - let e632 = { - let l624 = *base.add(0).cast::<*mut u8>(); - let l625 = *base + let e641 = { + let l633 = *base.add(0).cast::<*mut u8>(); + let l634 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len626 = l625; - let bytes626 = _rt::Vec::from_raw_parts( - l624.cast(), - len626, - len626, + let len635 = l634; + let bytes635 = _rt::Vec::from_raw_parts( + l633.cast(), + len635, + len635, ); - let l627 = i32::from( + let l636 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - use super::super::super::super::golem::api::context::AttributeValue as V631; - let v631 = match l627 { + use super::super::super::super::golem::api::context::AttributeValue as V640; + let v640 = match l636 { n => { debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e631 = { - let l628 = *base + let e640 = { + let l637 = *base .add(3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l629 = *base + let l638 = *base .add(4 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len630 = l629; - let bytes630 = _rt::Vec::from_raw_parts( - l628.cast(), - len630, - len630, + let len639 = l638; + let bytes639 = _rt::Vec::from_raw_parts( + l637.cast(), + len639, + len639, ); - _rt::string_lift(bytes630) + _rt::string_lift(bytes639) }; - V631::String(e631) + V640::String(e640) } }; super::super::super::super::golem::api::context::Attribute { - key: _rt::string_lift(bytes626), - value: v631, + key: _rt::string_lift(bytes635), + value: v640, } }; - result632.push(e632); + result641.push(e641); } _rt::cabi_dealloc( - base632, - len632 * (5 * ::core::mem::size_of::<*const u8>()), + base641, + len641 * (5 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::oplog::StartSpanParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l609 as u64, - nanoseconds: l610 as u32, + seconds: l618 as u64, + nanoseconds: l619 as u32, }, - span_id: _rt::string_lift(bytes613), - parent: match l614 { + span_id: _rt::string_lift(bytes622), + parent: match l623 { 0 => None, 1 => { let e = { - let l615 = *base + let l624 = *base .add(24 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l616 = *base + let l625 = *base .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len617 = l616; - let bytes617 = _rt::Vec::from_raw_parts( - l615.cast(), - len617, - len617, + let len626 = l625; + let bytes626 = _rt::Vec::from_raw_parts( + l624.cast(), + len626, + len626, ); - _rt::string_lift(bytes617) + _rt::string_lift(bytes626) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - linked_context: match l618 { + linked_context: match l627 { 0 => None, 1 => { let e = { - let l619 = *base + let l628 = *base .add(24 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l620 = *base + let l629 = *base .add(24 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len621 = l620; - let bytes621 = _rt::Vec::from_raw_parts( - l619.cast(), - len621, - len621, + let len630 = l629; + let bytes630 = _rt::Vec::from_raw_parts( + l628.cast(), + len630, + len630, ); - _rt::string_lift(bytes621) + _rt::string_lift(bytes630) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - attributes: result632, + attributes: result641, } }; - V655::StartSpan(e655) + V664::StartSpan(e664) } 30 => { - let e655 = { - let l633 = *base.add(8).cast::(); - let l634 = *base.add(16).cast::(); - let l635 = *base.add(24).cast::<*mut u8>(); - let l636 = *base + let e664 = { + let l642 = *base.add(8).cast::(); + let l643 = *base.add(16).cast::(); + let l644 = *base.add(24).cast::<*mut u8>(); + let l645 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len637 = l636; - let bytes637 = _rt::Vec::from_raw_parts( - l635.cast(), - len637, - len637, + let len646 = l645; + let bytes646 = _rt::Vec::from_raw_parts( + l644.cast(), + len646, + len646, ); super::super::super::super::golem::api::oplog::FinishSpanParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l633 as u64, - nanoseconds: l634 as u32, + seconds: l642 as u64, + nanoseconds: l643 as u32, }, - span_id: _rt::string_lift(bytes637), + span_id: _rt::string_lift(bytes646), } }; - V655::FinishSpan(e655) + V664::FinishSpan(e664) } 31 => { - let e655 = { - let l638 = *base.add(8).cast::(); - let l639 = *base.add(16).cast::(); - let l640 = *base.add(24).cast::<*mut u8>(); - let l641 = *base + let e664 = { + let l647 = *base.add(8).cast::(); + let l648 = *base.add(16).cast::(); + let l649 = *base.add(24).cast::<*mut u8>(); + let l650 = *base .add(24 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len642 = l641; - let bytes642 = _rt::Vec::from_raw_parts( - l640.cast(), - len642, - len642, + let len651 = l650; + let bytes651 = _rt::Vec::from_raw_parts( + l649.cast(), + len651, + len651, ); - let l643 = *base + let l652 = *base .add(24 + 2 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l644 = *base + let l653 = *base .add(24 + 3 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len645 = l644; - let bytes645 = _rt::Vec::from_raw_parts( - l643.cast(), - len645, - len645, + let len654 = l653; + let bytes654 = _rt::Vec::from_raw_parts( + l652.cast(), + len654, + len654, ); - let l646 = i32::from( + let l655 = i32::from( *base .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - use super::super::super::super::golem::api::context::AttributeValue as V650; - let v650 = match l646 { + use super::super::super::super::golem::api::context::AttributeValue as V659; + let v659 = match l655 { n => { debug_assert_eq!(n, 0, "invalid enum discriminant"); - let e650 = { - let l647 = *base + let e659 = { + let l656 = *base .add(24 + 5 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l648 = *base + let l657 = *base .add(24 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len649 = l648; - let bytes649 = _rt::Vec::from_raw_parts( - l647.cast(), - len649, - len649, + let len658 = l657; + let bytes658 = _rt::Vec::from_raw_parts( + l656.cast(), + len658, + len658, ); - _rt::string_lift(bytes649) + _rt::string_lift(bytes658) }; - V650::String(e650) + V659::String(e659) } }; super::super::super::super::golem::api::oplog::SetSpanAttributeParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l638 as u64, - nanoseconds: l639 as u32, + seconds: l647 as u64, + nanoseconds: l648 as u32, }, - span_id: _rt::string_lift(bytes642), - key: _rt::string_lift(bytes645), - value: v650, + span_id: _rt::string_lift(bytes651), + key: _rt::string_lift(bytes654), + value: v659, } }; - V655::SetSpanAttribute(e655) + V664::SetSpanAttribute(e664) } n => { debug_assert_eq!(n, 32, "invalid enum discriminant"); - let e655 = { - let l651 = *base.add(8).cast::(); - let l652 = *base.add(16).cast::(); - let l653 = i32::from(*base.add(24).cast::()); - use super::super::super::super::golem::api::host::PersistenceLevel as V654; - let v654 = match l653 { - 0 => V654::PersistNothing, - 1 => V654::PersistRemoteSideEffects, + let e664 = { + let l660 = *base.add(8).cast::(); + let l661 = *base.add(16).cast::(); + let l662 = i32::from(*base.add(24).cast::()); + use super::super::super::super::golem::api::host::PersistenceLevel as V663; + let v663 = match l662 { + 0 => V663::PersistNothing, + 1 => V663::PersistRemoteSideEffects, n => { debug_assert_eq!(n, 2, "invalid enum discriminant"); - V654::Smart + V663::Smart } }; super::super::super::super::golem::api::oplog::ChangePersistenceLevelParameters { timestamp: super::super::super::super::wasi::clocks::wall_clock::Datetime { - seconds: l651 as u64, - nanoseconds: l652 as u32, + seconds: l660 as u64, + nanoseconds: l661 as u32, }, - persistence_level: v654, + persistence_level: v663, } }; - V655::ChangePersistenceLevel(e655) + V664::ChangePersistenceLevel(e664) } }; - v655 + v664 }; - result656.push(e656); + result665.push(e665); } _rt::cabi_dealloc( - base656, - len656 * (104 + 12 * ::core::mem::size_of::<*const u8>()), + base665, + len665 * (104 + 12 * ::core::mem::size_of::<*const u8>()), 8, ); - let result657 = T::process( + let result666 = T::process( unsafe { ProcessorBorrow::lift(l0 as u32 as usize) }.get(), super::super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::super::golem::rpc::types::ComponentId { @@ -21154,40 +21465,41 @@ pub mod exports { }, args: result16, env: result25, + wasi_config_vars: result34, status: super::super::super::super::golem::api::host::WorkerStatus::_lift( - l26 as u8, + l35 as u8, ), - component_version: l27 as u64, - retry_count: l28 as u64, + component_version: l36 as u64, + retry_count: l37 as u64, }, - l29 as u64, - result656, + l38 as u64, + result665, ); _rt::cabi_dealloc( arg0, - 72 + 10 * ::core::mem::size_of::<*const u8>(), + 72 + 12 * ::core::mem::size_of::<*const u8>(), 8, ); - let ptr658 = (&raw mut _RET_AREA.0).cast::(); - match result657 { + let ptr667 = (&raw mut _RET_AREA.0).cast::(); + match result666 { Ok(_) => { - *ptr658.add(0).cast::() = (0i32) as u8; + *ptr667.add(0).cast::() = (0i32) as u8; } Err(e) => { - *ptr658.add(0).cast::() = (1i32) as u8; - let vec659 = (e.into_bytes()).into_boxed_slice(); - let ptr659 = vec659.as_ptr().cast::(); - let len659 = vec659.len(); - ::core::mem::forget(vec659); - *ptr658 + *ptr667.add(0).cast::() = (1i32) as u8; + let vec668 = (e.into_bytes()).into_boxed_slice(); + let ptr668 = vec668.as_ptr().cast::(); + let len668 = vec668.len(); + ::core::mem::forget(vec668); + *ptr667 .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = len659; - *ptr658 + .cast::() = len668; + *ptr667 .add(::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr659.cast_mut(); + .cast::<*mut u8>() = ptr668.cast_mut(); } }; - ptr658 + ptr667 } #[doc(hidden)] #[allow(non_snake_case)] @@ -21712,8 +22024,8 @@ pub(crate) use __export_oplog_processor_impl as export; )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 10959] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xc9T\x01A\x02\x01A'\x01\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 11115] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xe5U\x01A\x02\x01A(\x01\ B\x05\x01r\x02\x07secondsw\x0bnanosecondsy\x04\0\x08datetime\x03\0\0\x01@\0\0\x01\ \x04\0\x03now\x01\x02\x04\0\x0aresolution\x01\x02\x03\0\x1cwasi:clocks/wall-cloc\ k@0.2.3\x05\0\x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\ @@ -21733,209 +22045,212 @@ ype\x01\x17\0\x0cprim-u8-type\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dp rim-u64-type\0\0\x0cprim-s8-type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0d\ prim-s64-type\0\0\x0dprim-f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\ \x0eprim-bool-type\0\0\x10prim-string-type\0\0\x0bhandle-type\x01\x18\0\x04\0\x0d\ -wit-type-node\x03\0\x19\x01ks\x01r\x02\x04name\x1b\x04type\x1a\x04\0\x13named-wi\ -t-type-node\x03\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\ -\x01r\x01\x05values\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\ -\x01o\x02\"w\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-\ -value\x01y\0\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\ -\0\x0coption-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u1\ -6\x01{\0\x08prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01\ -|\0\x08prim-s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\ -\x01u\0\x09prim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06hand\ -le\x01&\0\x04\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\ -\0*\x01r\x02\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0epro\ -tocol-error\x01s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-error\ -\x01s\0\x04\0\x09rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invo\ -ke-result\x03\x01\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-i\ -d\x09\03\x04\0\x15[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\ -\0\x1a[static]wasm-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04sel\ -f6\x0dfunction-names\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke-and-aw\ -ait\x019\x01j\0\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\ -\0\x17[method]wasm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0f\ -function-params7\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04\ -self6\x0escheduled-time\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[m\ -ethod]wasm-rpc.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-tim\ -e\x01\x0dfunction-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-c\ -ancelable-invocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[m\ -ethod]future-invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\ -\0\x20[method]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\ -\0![method]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\ -\0\x04\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\ -\x01@\x01\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0c\ -extract-type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x04\x01B\x0f\x02\x03\x02\x01\ -\x03\x04\0\x08pollable\x03\0\0\x01w\x04\0\x07instant\x03\0\x02\x01w\x04\0\x08dur\ -ation\x03\0\x04\x01@\0\0\x03\x04\0\x03now\x01\x06\x01@\0\0\x05\x04\0\x0aresoluti\ -on\x01\x07\x01i\x01\x01@\x01\x04when\x03\0\x08\x04\0\x11subscribe-instant\x01\x09\ -\x01@\x01\x04when\x05\0\x08\x04\0\x12subscribe-duration\x01\x0a\x03\0!wasi:clock\ -s/monotonic-clock@0.2.3\x05\x05\x02\x03\0\x03\x08duration\x02\x03\0\x02\x0ccompo\ -nent-id\x02\x03\0\x02\x04uuid\x02\x03\0\x02\x09worker-id\x01B{\x02\x03\x02\x01\x06\ -\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\ -\x03\x02\x01\x08\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x09worker-id\x03\ -\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x09worker-id\x07\x09oplog-id\ -x\x09\x04\0\x0apromise-id\x03\0\x0a\x01w\x04\0\x11component-version\x03\0\x0c\x01\ -r\x01\x05values\x04\0\x0aaccount-id\x03\0\x0e\x01r\x01\x04uuid\x05\x04\0\x0aproj\ -ect-id\x03\0\x10\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x01\x09max-delay\x01\ -\x0amultiplieru\x11max-jitter-factor\x12\x04\0\x0cretry-policy\x03\0\x13\x01q\x03\ -\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\0\0\x04\0\x11\ -persistence-level\x03\0\x15\x01m\x02\x09automatic\x0esnapshot-based\x04\0\x0bupd\ -ate-mode\x03\0\x17\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\x07greater\x0a\ -less-equal\x04less\x04\0\x11filter-comparator\x03\0\x19\x01m\x04\x05equal\x09not\ --equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1b\x01m\x07\x07\ -running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06exited\x04\0\ -\x0dworker-status\x03\0\x1d\x01r\x02\x0acomparator\x1c\x05values\x04\0\x12worker\ --name-filter\x03\0\x1f\x01r\x02\x0acomparator\x1a\x05value\x1e\x04\0\x14worker-s\ -tatus-filter\x03\0!\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x15worker-version\ --filter\x03\0#\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x18worker-created-at-f\ -ilter\x03\0%\x01r\x03\x04names\x0acomparator\x1c\x05values\x04\0\x11worker-env-f\ -ilter\x03\0'\x01q\x05\x04name\x01\x20\0\x06status\x01\"\0\x07version\x01$\0\x0ac\ -reated-at\x01&\0\x03env\x01(\0\x04\0\x16worker-property-filter\x03\0)\x01p*\x01r\ -\x01\x07filters+\x04\0\x11worker-all-filter\x03\0,\x01p-\x01r\x01\x07filters.\x04\ -\0\x11worker-any-filter\x03\0/\x01ps\x01o\x02ss\x01p2\x01r\x06\x09worker-id\x07\x04\ -args1\x03env3\x06status\x1e\x11component-versionw\x0bretry-countw\x04\0\x0fworke\ -r-metadata\x03\04\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\ -\x01\x09\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0\ -7\x01m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\09\x01k0\x01i6\x01@\x03\ -\x0ccomponent-id\x03\x06filter;\x07precise\x7f\0<\x04\0\x18[constructor]get-work\ -ers\x01=\x01h6\x01p5\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[method]get-worker\ -s.get-next\x01A\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01B\x01p}\x01@\x01\x0aprom\ -ise-id\x0b\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\x0apromise-id\ -\x0b\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x0b\x04data\xc3\0\ -\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x0b\x01\0\x04\0\x0e\ -delete-promise\x01H\x01@\0\0\x09\x04\0\x0fget-oplog-index\x01I\x01@\x01\x09oplog\ --idx\x09\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\x04\0\x0c\ -oplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\x09\x01\0\ -\x04\0\x12mark-end-operation\x01L\x01@\0\0\x14\x04\0\x10get-retry-policy\x01M\x01\ -@\x01\x10new-retry-policy\x14\x01\0\x04\0\x10set-retry-policy\x01N\x01@\0\0\x16\x04\ -\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-level\x16\x01\ -\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14get-idempoten\ -ce-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-mode\x01R\ -\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09worker-id\x07\x0e\ -target-version\x0d\x04mode\x18\x01\0\x04\0\x0dupdate-worker\x01T\x01@\0\05\x04\0\ -\x11get-self-metadata\x01U\x01k5\x01@\x01\x09worker-id\x07\0\xd6\0\x04\0\x13get-\ -worker-metadata\x01W\x01@\x03\x10source-worker-id\x07\x10target-worker-id\x07\x11\ -oplog-idx-cut-off\x09\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09worker-id\x07\x0d\ -revert-target8\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x03\x01@\x01\x13component-\ -references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x07\x01@\x02\x13compo\ -nent-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\x01]\x04\0\x18\ -resolve-worker-id-strict\x01]\x01@\x01\x08new-names\0:\x04\0\x04fork\x01^\x03\0\x14\ -golem:api/host@1.1.7\x05\x0a\x01B7\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\0\ -\x04\0\x04span\x03\x01\x04\0\x12invocation-context\x03\x01\x01q\x01\x06string\x01\ -s\0\x04\0\x0fattribute-value\x03\0\x04\x01r\x02\x03keys\x05value\x05\x04\0\x09at\ -tribute\x03\0\x06\x01p\x05\x01r\x02\x03keys\x06values\x08\x04\0\x0fattribute-cha\ -in\x03\0\x09\x01s\x04\0\x08trace-id\x03\0\x0b\x01s\x04\0\x07span-id\x03\0\x0d\x01\ -h\x02\x01@\x01\x04self\x0f\0\x01\x04\0\x17[method]span.started-at\x01\x10\x01@\x03\ -\x04self\x0f\x04names\x05value\x05\x01\0\x04\0\x1a[method]span.set-attribute\x01\ -\x11\x01p\x07\x01@\x02\x04self\x0f\x0aattributes\x12\x01\0\x04\0\x1b[method]span\ -.set-attributes\x01\x13\x01@\x01\x04self\x0f\x01\0\x04\0\x13[method]span.finish\x01\ -\x14\x01h\x03\x01@\x01\x04self\x15\0\x0c\x04\0#[method]invocation-context.trace-\ -id\x01\x16\x01@\x01\x04self\x15\0\x0e\x04\0\"[method]invocation-context.span-id\x01\ -\x17\x01i\x03\x01k\x18\x01@\x01\x04self\x15\0\x19\x04\0![method]invocation-conte\ -xt.parent\x01\x1a\x01k\x05\x01@\x03\x04self\x15\x03keys\x09inherited\x7f\0\x1b\x04\ -\0([method]invocation-context.get-attribute\x01\x1c\x01@\x02\x04self\x15\x09inhe\ -rited\x7f\0\x12\x04\0)[method]invocation-context.get-attributes\x01\x1d\x01@\x02\ -\x04self\x15\x03keys\0\x08\x04\0.[method]invocation-context.get-attribute-chain\x01\ -\x1e\x01p\x0a\x01@\x01\x04self\x15\0\x1f\x04\0/[method]invocation-context.get-at\ -tribute-chains\x01\x20\x01o\x02ss\x01p!\x01@\x01\x04self\x15\0\"\x04\00[method]i\ -nvocation-context.trace-context-headers\x01#\x01i\x02\x01@\x01\x04names\0$\x04\0\ -\x0astart-span\x01%\x01@\0\0\x18\x04\0\x0fcurrent-context\x01&\x01@\x01\x05allow\ -\x7f\0\x7f\x04\0&allow-forwarding-trace-context-headers\x01'\x03\0\x17golem:api/\ -context@1.1.7\x05\x0b\x02\x03\0\x02\x09wit-value\x02\x03\0\x04\x0aaccount-id\x02\ -\x03\0\x04\x11component-version\x02\x03\0\x04\x0boplog-index\x02\x03\0\x04\x11pe\ -rsistence-level\x02\x03\0\x04\x0aproject-id\x02\x03\0\x04\x0cretry-policy\x02\x03\ -\0\x04\x04uuid\x02\x03\0\x04\x09worker-id\x02\x03\0\x05\x09attribute\x02\x03\0\x05\ -\x0fattribute-value\x02\x03\0\x05\x07span-id\x02\x03\0\x05\x08trace-id\x01B\x89\x01\ -\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\0\x02\x03\x02\x01\x0c\x04\0\x09wit-\ -value\x03\0\x02\x02\x03\x02\x01\x0d\x04\0\x0aaccount-id\x03\0\x04\x02\x03\x02\x01\ -\x0e\x04\0\x11component-version\x03\0\x06\x02\x03\x02\x01\x0f\x04\0\x0boplog-ind\ -ex\x03\0\x08\x02\x03\x02\x01\x10\x04\0\x11persistence-level\x03\0\x0a\x02\x03\x02\ -\x01\x11\x04\0\x0aproject-id\x03\0\x0c\x02\x03\x02\x01\x12\x04\0\x0cretry-policy\ -\x03\0\x0e\x02\x03\x02\x01\x13\x04\0\x04uuid\x03\0\x10\x02\x03\x02\x01\x14\x04\0\ -\x09worker-id\x03\0\x12\x02\x03\x02\x01\x15\x04\0\x09attribute\x03\0\x14\x02\x03\ -\x02\x01\x16\x04\0\x0fattribute-value\x03\0\x16\x02\x03\x02\x01\x17\x04\0\x07spa\ -n-id\x03\0\x18\x02\x03\x02\x01\x18\x04\0\x08trace-id\x03\0\x1a\x01k\x09\x01q\x05\ -\x0aread-local\0\0\x0bwrite-local\0\0\x0bread-remote\0\0\x0cwrite-remote\0\0\x14\ -write-remote-batched\x01\x1c\0\x04\0\x15wrapped-function-type\x03\0\x1d\x01o\x02\ -ss\x01p\x1f\x01r\x04\x0finstallation-id\x11\x04names\x07versions\x0aparameters\x20\ -\x04\0\x1fplugin-installation-description\x03\0!\x01ps\x01k\x13\x01p\"\x01r\x0b\x09\ -timestamp\x01\x09worker-id\x13\x11component-version\x07\x04args#\x03env\x20\x0ac\ -reated-by\x05\x0aproject-id\x0d\x06parent$\x0ecomponent-sizew\x20initial-total-l\ -inear-memory-sizew\x16initial-active-plugins%\x04\0\x11create-parameters\x03\0&\x01\ -r\x05\x09timestamp\x01\x0dfunction-names\x07request\x03\x08response\x03\x15wrapp\ -ed-function-type\x1e\x04\0$imported-function-invoked-parameters\x03\0(\x01k\x19\x01\ -kw\x01p\x15\x01r\x06\x07span-id\x19\x05start\x01\x06parent*\x0elinked-context+\x0a\ -attributes,\x09inherited\x7f\x04\0\x0flocal-span-data\x03\0-\x01r\x01\x07span-id\ -\x19\x04\0\x12external-span-data\x03\0/\x01q\x02\x0alocal-span\x01.\0\x0dexterna\ -l-span\x010\0\x04\0\x09span-data\x03\01\x01p\x03\x01p2\x01p4\x01r\x07\x09timesta\ -mp\x01\x0dfunction-names\x07request3\x0fidempotency-keys\x08trace-id\x1b\x0ctrac\ -e-states#\x12invocation-context5\x04\0$exported-function-invoked-parameters\x03\0\ -6\x01k\x03\x01r\x03\x09timestamp\x01\x08response8\x0dconsumed-fuelx\x04\0&export\ -ed-function-completed-parameters\x03\09\x01r\x02\x09timestamp\x01\x05errors\x04\0\ -\x10error-parameters\x03\0;\x01r\x03\x09timestamp\x01\x05start\x09\x03end\x09\x04\ -\0\x0fjump-parameters\x03\0=\x01r\x02\x09timestamp\x01\x0cretry-policy\x0f\x04\0\ -\x1echange-retry-policy-parameters\x03\0?\x01r\x02\x09timestamp\x01\x0bbegin-ind\ -ex\x09\x04\0\x1cend-atomic-region-parameters\x03\0A\x01r\x02\x09timestamp\x01\x0b\ -begin-index\x09\x04\0\x1bend-remote-write-parameters\x03\0C\x01k3\x01r\x03\x0fid\ -empotency-keys\x0dfunction-names\x05input\xc5\0\x04\0'exported-function-invocati\ -on-parameters\x03\0F\x01q\x02\x11exported-function\x01\xc7\0\0\x0dmanual-update\x01\ -\x07\0\x04\0\x11worker-invocation\x03\0H\x01r\x02\x09timestamp\x01\x0ainvocation\ -\xc9\0\x04\0$pending-worker-invocation-parameters\x03\0J\x01p}\x01q\x02\x0bauto-\ -update\0\0\x0esnapshot-based\x01\xcc\0\0\x04\0\x12update-description\x03\0M\x01r\ -\x03\x09timestamp\x01\x0etarget-version\x07\x12update-description\xce\0\x04\0\x19\ -pending-update-parameters\x03\0O\x01r\x04\x09timestamp\x01\x0etarget-version\x07\ -\x12new-component-sizew\x12new-active-plugins%\x04\0\x1csuccessful-update-parame\ -ters\x03\0Q\x01ks\x01r\x03\x09timestamp\x01\x0etarget-version\x07\x07details\xd3\ -\0\x04\0\x18failed-update-parameters\x03\0T\x01r\x02\x09timestamp\x01\x05deltaw\x04\ -\0\x16grow-memory-parameters\x03\0V\x01w\x04\0\x12worker-resource-id\x03\0X\x01r\ -\x02\x09timestamp\x01\x0bresource-id\xd9\0\x04\0\x1acreate-resource-parameters\x03\ -\0Z\x01r\x02\x09timestamp\x01\x0bresource-id\xd9\0\x04\0\x18drop-resource-parame\ -ters\x03\0\\\x01r\x04\x09timestamp\x01\x0bresource-id\xd9\0\x0dresource-names\x0f\ -resource-params3\x04\0\x1cdescribe-resource-parameters\x03\0^\x01m\x08\x06stdout\ -\x06stderr\x05trace\x05debug\x04info\x04warn\x05error\x08critical\x04\0\x09log-l\ -evel\x03\0`\x01r\x04\x09timestamp\x01\x05level\xe1\0\x07contexts\x07messages\x04\ -\0\x0elog-parameters\x03\0b\x01r\x02\x09timestamp\x01\x06plugin\"\x04\0\x1aactiv\ -ate-plugin-parameters\x03\0d\x01r\x02\x09timestamp\x01\x06plugin\"\x04\0\x1cdeac\ -tivate-plugin-parameters\x03\0f\x01r\x03\x09timestamp\x01\x05start\x09\x03end\x09\ -\x04\0\x11revert-parameters\x03\0h\x01r\x02\x09timestamp\x01\x0fidempotency-keys\ -\x04\0\x1ccancel-invocation-parameters\x03\0j\x01r\x05\x09timestamp\x01\x07span-\ -id\x19\x06parent*\x0elinked-context*\x0aattributes,\x04\0\x15start-span-paramete\ -rs\x03\0l\x01r\x02\x09timestamp\x01\x07span-id\x19\x04\0\x16finish-span-paramete\ -rs\x03\0n\x01r\x04\x09timestamp\x01\x07span-id\x19\x03keys\x05value\x17\x04\0\x1d\ -set-span-attribute-parameters\x03\0p\x01r\x02\x09timestamp\x01\x11persistence-le\ -vel\x0b\x04\0#change-persistence-level-parameters\x03\0r\x01q!\x06create\x01'\0\x19\ -imported-function-invoked\x01)\0\x19exported-function-invoked\x017\0\x1bexported\ --function-completed\x01:\0\x07suspend\x01\x01\0\x05error\x01<\0\x05no-op\x01\x01\ -\0\x04jump\x01>\0\x0binterrupted\x01\x01\0\x06exited\x01\x01\0\x13change-retry-p\ -olicy\x01\xc0\0\0\x13begin-atomic-region\x01\x01\0\x11end-atomic-region\x01\xc2\0\ -\0\x12begin-remote-write\x01\x01\0\x10end-remote-write\x01\xc4\0\0\x19pending-wo\ -rker-invocation\x01\xcb\0\0\x0epending-update\x01\xd0\0\0\x11successful-update\x01\ -\xd2\0\0\x0dfailed-update\x01\xd5\0\0\x0bgrow-memory\x01\xd7\0\0\x0fcreate-resou\ -rce\x01\xdb\0\0\x0ddrop-resource\x01\xdd\0\0\x11describe-resource\x01\xdf\0\0\x03\ -log\x01\xe3\0\0\x07restart\x01\x01\0\x0factivate-plugin\x01\xe5\0\0\x11deactivat\ -e-plugin\x01\xe7\0\0\x06revert\x01\xe9\0\0\x11cancel-invocation\x01\xeb\0\0\x0as\ -tart-span\x01\xed\0\0\x0bfinish-span\x01\xef\0\0\x12set-span-attribute\x01\xf1\0\ -\0\x18change-persistence-level\x01\xf3\0\0\x04\0\x0boplog-entry\x03\0t\x04\0\x09\ -get-oplog\x03\x01\x04\0\x0csearch-oplog\x03\x01\x01iv\x01@\x02\x09worker-id\x13\x05\ -start\x09\0\xf8\0\x04\0\x16[constructor]get-oplog\x01y\x01hv\x01p\xf5\0\x01k\xfb\ -\0\x01@\x01\x04self\xfa\0\0\xfc\0\x04\0\x1a[method]get-oplog.get-next\x01}\x01iw\ -\x01@\x02\x09worker-id\x13\x04texts\0\xfe\0\x04\0\x19[constructor]search-oplog\x01\ -\x7f\x01hw\x01o\x02\x09\xf5\0\x01p\x81\x01\x01k\x82\x01\x01@\x01\x04self\x80\x01\ -\0\x83\x01\x04\0\x1d[method]search-oplog.get-next\x01\x84\x01\x03\0\x15golem:api\ -/oplog@1.1.7\x05\x19\x01B\x03\x01ps\x01@\0\0\0\x04\0\x15get-invoked-functions\x01\ -\x01\x04\0\x13golem:component/api\x05\x1a\x02\x03\0\x04\x0fworker-metadata\x02\x03\ -\0\x06\x0boplog-entry\x01B\x1d\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\0\x02\ -\x03\x02\x01\x0c\x04\0\x09wit-value\x03\0\x02\x02\x03\x02\x01\x0d\x04\0\x0aaccou\ -nt-id\x03\0\x04\x02\x03\x02\x01\x0f\x04\0\x0boplog-index\x03\0\x06\x02\x03\x02\x01\ -\x1b\x04\0\x0fworker-metadata\x03\0\x08\x02\x03\x02\x01\x1c\x04\0\x0boplog-entry\ -\x03\0\x0a\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x0c\x02\x03\x02\x01\x09\ -\x04\0\x09worker-id\x03\0\x0e\x01r\x01\x0aaccount-id\x05\x04\0\x0caccount-info\x03\ -\0\x10\x04\0\x09processor\x03\x01\x01o\x02ss\x01p\x13\x01i\x12\x01@\x03\x0caccou\ -nt-info\x11\x0ccomponent-id\x0d\x06config\x14\0\x15\x04\0\x16[constructor]proces\ -sor\x01\x16\x01h\x12\x01p\x0b\x01j\0\x01s\x01@\x05\x04self\x17\x09worker-id\x0f\x08\ -metadata\x09\x11first-entry-index\x07\x07entries\x18\0\x19\x04\0\x19[method]proc\ -essor.process\x01\x1a\x04\0\x1fgolem:api/oplog-processor@1.1.7\x05\x1d\x04\0\x1f\ -golem:component/oplog-processor\x04\0\x0b\x15\x01\0\x0foplog-processor\x03\0\0\0\ -G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindge\ -n-rust\x060.41.0"; +wit-type-node\x03\0\x19\x01ks\x01r\x03\x04name\x1b\x05owner\x1b\x04type\x1a\x04\0\ +\x13named-wit-type-node\x03\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-ty\ +pe\x03\0\x1f\x01r\x01\x05values\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\ +\x12\x01\x12\x01o\x02\"w\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01\ +#\0\x0aenum-value\x01y\0\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-\ +value\x01\x16\0\x0coption-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\ +\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08\ +prim-s16\x01|\0\x08prim-s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0c\ +prim-float64\x01u\0\x09prim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01\ +s\0\x06handle\x01&\0\x04\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09\ +wit-value\x03\0*\x01r\x02\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01\ +q\x04\x0eprotocol-error\x01s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-in\ +ternal-error\x01s\0\x04\0\x09rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14\ +future-invoke-result\x03\x01\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09\ +worker-id\x09\03\x04\0\x15[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\ +\03\x04\0\x1a[static]wasm-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\ +\x04self6\x0dfunction-names\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke\ +-and-await\x019\x01j\0\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-para\ +ms7\0:\x04\0\x17[method]wasm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction\ +-names\x0ffunction-params7\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\ +\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\x0ffunction-params7\x01\ +\0\x04\0$[method]wasm-rpc.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0esc\ +heduled-time\x01\x0dfunction-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc\ +.schedule-cancelable-invocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\ +\0\x04\0&[method]future-invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\ +\0\xc4\0\x04\0\x20[method]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\ +\0\x01\0\x04\0![method]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\ +\x04uuids\0\xc8\0\x04\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid\ +-to-string\x01J\x01@\x01\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\ +\0\x20\x04\0\x0cextract-type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x04\x01B\x0f\ +\x02\x03\x02\x01\x03\x04\0\x08pollable\x03\0\0\x01w\x04\0\x07instant\x03\0\x02\x01\ +w\x04\0\x08duration\x03\0\x04\x01@\0\0\x03\x04\0\x03now\x01\x06\x01@\0\0\x05\x04\ +\0\x0aresolution\x01\x07\x01i\x01\x01@\x01\x04when\x03\0\x08\x04\0\x11subscribe-\ +instant\x01\x09\x01@\x01\x04when\x05\0\x08\x04\0\x12subscribe-duration\x01\x0a\x03\ +\0!wasi:clocks/monotonic-clock@0.2.3\x05\x05\x02\x03\0\x03\x08duration\x02\x03\0\ +\x02\x0ccomponent-id\x02\x03\0\x02\x04uuid\x02\x03\0\x02\x0evalue-and-type\x02\x03\ +\0\x02\x09worker-id\x01B\x7f\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\ +\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\x03\x02\x01\x08\x04\0\x04uuid\x03\ +\0\x04\x02\x03\x02\x01\x09\x04\0\x0evalue-and-type\x03\0\x06\x02\x03\x02\x01\x0a\ +\x04\0\x09worker-id\x03\0\x08\x01w\x04\0\x0boplog-index\x03\0\x0a\x01r\x02\x09wo\ +rker-id\x09\x09oplog-idx\x0b\x04\0\x0apromise-id\x03\0\x0c\x01w\x04\0\x11compone\ +nt-version\x03\0\x0e\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x10\x01r\x01\x04\ +uuid\x05\x04\0\x0aproject-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09min-de\ +lay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cretry-\ +policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\ +\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0esn\ +apshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0dgr\ +eater-equal\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\ +\x01m\x04\x05equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-compa\ +rator\x03\0\x1d\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retry\ +ing\x06failed\x06exited\x04\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\ +\x05values\x04\0\x12worker-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05valu\ +e\x20\x04\0\x14worker-status-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\ +\0\x15worker-version-filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18\ +worker-created-at-filter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x11worker-env-filter\x03\0)\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x1eworker-wasi-config-vars-filter\x03\0+\x01q\x06\x04name\x01\"\0\x06status\x01\ +$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\0\x10wasi-config-vars\x01\ +,\0\x04\0\x16worker-property-filter\x03\0-\x01p.\x01r\x01\x07filters/\x04\0\x11w\ +orker-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x11worker-any-filter\x03\ +\03\x01ps\x01o\x02ss\x01p6\x01r\x07\x09worker-id\x09\x04args5\x03env7\x10wasi-co\ +nfig-vars7\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\ +etadata\x03\08\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\ +\x0b\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0;\x01\ +m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\0=\x01k4\x01i:\x01@\x03\x0c\ +component-id\x03\x06filter?\x07precise\x7f\0\xc0\0\x04\0\x18[constructor]get-wor\ +kers\x01A\x01h:\x01p9\x01k\xc3\0\x01@\x01\x04self\xc2\0\0\xc4\0\x04\0\x1c[method\ +]get-workers.get-next\x01E\x01@\0\0\x0d\x04\0\x0ecreate-promise\x01F\x01p}\x01@\x01\ +\x0apromise-id\x0d\0\xc7\0\x04\0\x0dawait-promise\x01H\x01k\xc7\0\x01@\x01\x0apr\ +omise-id\x0d\0\xc9\0\x04\0\x0cpoll-promise\x01J\x01@\x02\x0apromise-id\x0d\x04da\ +ta\xc7\0\0\x7f\x04\0\x10complete-promise\x01K\x01@\x01\x0apromise-id\x0d\x01\0\x04\ +\0\x0edelete-promise\x01L\x01@\0\0\x0b\x04\0\x0fget-oplog-index\x01M\x01@\x01\x09\ +oplog-idx\x0b\x01\0\x04\0\x0fset-oplog-index\x01N\x01@\x01\x08replicas}\x01\0\x04\ +\0\x0coplog-commit\x01O\x04\0\x14mark-begin-operation\x01M\x01@\x01\x05begin\x0b\ +\x01\0\x04\0\x12mark-end-operation\x01P\x01@\0\0\x16\x04\0\x10get-retry-policy\x01\ +Q\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01R\x01@\0\0\ +\x18\x04\0\x1bget-oplog-persistence-level\x01S\x01@\x01\x15new-persistence-level\ +\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01T\x01@\0\0\x7f\x04\0\x14get-i\ +dempotence-mode\x01U\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-m\ +ode\x01V\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01W\x01@\x03\x09worker-\ +id\x09\x0etarget-version\x0f\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01X\x01@\0\ +\09\x04\0\x11get-self-metadata\x01Y\x01k9\x01@\x01\x09worker-id\x09\0\xda\0\x04\0\ +\x13get-worker-metadata\x01[\x01@\x03\x10source-worker-id\x09\x10target-worker-i\ +d\x09\x11oplog-idx-cut-off\x0b\x01\0\x04\0\x0bfork-worker\x01\\\x01@\x02\x09work\ +er-id\x09\x0drevert-target<\x01\0\x04\0\x0drevert-worker\x01]\x01k\x03\x01@\x01\x13\ +component-references\0\xde\0\x04\0\x14resolve-component-id\x01_\x01k\x09\x01@\x02\ +\x13component-references\x0bworker-names\0\xe0\0\x04\0\x11resolve-worker-id\x01a\ +\x04\0\x18resolve-worker-id-strict\x01a\x01@\x01\x08new-names\0>\x04\0\x04fork\x01\ +b\x03\0\x14golem:api/host@1.1.7\x05\x0b\x01B7\x02\x03\x02\x01\x02\x04\0\x08datet\ +ime\x03\0\0\x04\0\x04span\x03\x01\x04\0\x12invocation-context\x03\x01\x01q\x01\x06\ +string\x01s\0\x04\0\x0fattribute-value\x03\0\x04\x01r\x02\x03keys\x05value\x05\x04\ +\0\x09attribute\x03\0\x06\x01p\x05\x01r\x02\x03keys\x06values\x08\x04\0\x0fattri\ +bute-chain\x03\0\x09\x01s\x04\0\x08trace-id\x03\0\x0b\x01s\x04\0\x07span-id\x03\0\ +\x0d\x01h\x02\x01@\x01\x04self\x0f\0\x01\x04\0\x17[method]span.started-at\x01\x10\ +\x01@\x03\x04self\x0f\x04names\x05value\x05\x01\0\x04\0\x1a[method]span.set-attr\ +ibute\x01\x11\x01p\x07\x01@\x02\x04self\x0f\x0aattributes\x12\x01\0\x04\0\x1b[me\ +thod]span.set-attributes\x01\x13\x01@\x01\x04self\x0f\x01\0\x04\0\x13[method]spa\ +n.finish\x01\x14\x01h\x03\x01@\x01\x04self\x15\0\x0c\x04\0#[method]invocation-co\ +ntext.trace-id\x01\x16\x01@\x01\x04self\x15\0\x0e\x04\0\"[method]invocation-cont\ +ext.span-id\x01\x17\x01i\x03\x01k\x18\x01@\x01\x04self\x15\0\x19\x04\0![method]i\ +nvocation-context.parent\x01\x1a\x01k\x05\x01@\x03\x04self\x15\x03keys\x09inheri\ +ted\x7f\0\x1b\x04\0([method]invocation-context.get-attribute\x01\x1c\x01@\x02\x04\ +self\x15\x09inherited\x7f\0\x12\x04\0)[method]invocation-context.get-attributes\x01\ +\x1d\x01@\x02\x04self\x15\x03keys\0\x08\x04\0.[method]invocation-context.get-att\ +ribute-chain\x01\x1e\x01p\x0a\x01@\x01\x04self\x15\0\x1f\x04\0/[method]invocatio\ +n-context.get-attribute-chains\x01\x20\x01o\x02ss\x01p!\x01@\x01\x04self\x15\0\"\ +\x04\00[method]invocation-context.trace-context-headers\x01#\x01i\x02\x01@\x01\x04\ +names\0$\x04\0\x0astart-span\x01%\x01@\0\0\x18\x04\0\x0fcurrent-context\x01&\x01\ +@\x01\x05allow\x7f\0\x7f\x04\0&allow-forwarding-trace-context-headers\x01'\x03\0\ +\x17golem:api/context@1.1.7\x05\x0c\x02\x03\0\x02\x09wit-value\x02\x03\0\x04\x0a\ +account-id\x02\x03\0\x04\x11component-version\x02\x03\0\x04\x0boplog-index\x02\x03\ +\0\x04\x11persistence-level\x02\x03\0\x04\x0aproject-id\x02\x03\0\x04\x0cretry-p\ +olicy\x02\x03\0\x04\x04uuid\x02\x03\0\x04\x09worker-id\x02\x03\0\x05\x09attribut\ +e\x02\x03\0\x05\x0fattribute-value\x02\x03\0\x05\x07span-id\x02\x03\0\x05\x08tra\ +ce-id\x01B\x89\x01\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\0\x02\x03\x02\x01\ +\x0d\x04\0\x09wit-value\x03\0\x02\x02\x03\x02\x01\x0e\x04\0\x0aaccount-id\x03\0\x04\ +\x02\x03\x02\x01\x0f\x04\0\x11component-version\x03\0\x06\x02\x03\x02\x01\x10\x04\ +\0\x0boplog-index\x03\0\x08\x02\x03\x02\x01\x11\x04\0\x11persistence-level\x03\0\ +\x0a\x02\x03\x02\x01\x12\x04\0\x0aproject-id\x03\0\x0c\x02\x03\x02\x01\x13\x04\0\ +\x0cretry-policy\x03\0\x0e\x02\x03\x02\x01\x14\x04\0\x04uuid\x03\0\x10\x02\x03\x02\ +\x01\x15\x04\0\x09worker-id\x03\0\x12\x02\x03\x02\x01\x16\x04\0\x09attribute\x03\ +\0\x14\x02\x03\x02\x01\x17\x04\0\x0fattribute-value\x03\0\x16\x02\x03\x02\x01\x18\ +\x04\0\x07span-id\x03\0\x18\x02\x03\x02\x01\x19\x04\0\x08trace-id\x03\0\x1a\x01k\ +\x09\x01q\x05\x0aread-local\0\0\x0bwrite-local\0\0\x0bread-remote\0\0\x0cwrite-r\ +emote\0\0\x14write-remote-batched\x01\x1c\0\x04\0\x15wrapped-function-type\x03\0\ +\x1d\x01o\x02ss\x01p\x1f\x01r\x04\x0finstallation-id\x11\x04names\x07versions\x0a\ +parameters\x20\x04\0\x1fplugin-installation-description\x03\0!\x01ps\x01k\x13\x01\ +p\"\x01r\x0b\x09timestamp\x01\x09worker-id\x13\x11component-version\x07\x04args#\ +\x03env\x20\x0acreated-by\x05\x0aproject-id\x0d\x06parent$\x0ecomponent-sizew\x20\ +initial-total-linear-memory-sizew\x16initial-active-plugins%\x04\0\x11create-par\ +ameters\x03\0&\x01r\x05\x09timestamp\x01\x0dfunction-names\x07request\x03\x08res\ +ponse\x03\x15wrapped-function-type\x1e\x04\0$imported-function-invoked-parameter\ +s\x03\0(\x01k\x19\x01kw\x01p\x15\x01r\x06\x07span-id\x19\x05start\x01\x06parent*\ +\x0elinked-context+\x0aattributes,\x09inherited\x7f\x04\0\x0flocal-span-data\x03\ +\0-\x01r\x01\x07span-id\x19\x04\0\x12external-span-data\x03\0/\x01q\x02\x0alocal\ +-span\x01.\0\x0dexternal-span\x010\0\x04\0\x09span-data\x03\01\x01p\x03\x01p2\x01\ +p4\x01r\x07\x09timestamp\x01\x0dfunction-names\x07request3\x0fidempotency-keys\x08\ +trace-id\x1b\x0ctrace-states#\x12invocation-context5\x04\0$exported-function-inv\ +oked-parameters\x03\06\x01k\x03\x01r\x03\x09timestamp\x01\x08response8\x0dconsum\ +ed-fuelx\x04\0&exported-function-completed-parameters\x03\09\x01r\x02\x09timesta\ +mp\x01\x05errors\x04\0\x10error-parameters\x03\0;\x01r\x03\x09timestamp\x01\x05s\ +tart\x09\x03end\x09\x04\0\x0fjump-parameters\x03\0=\x01r\x02\x09timestamp\x01\x0c\ +retry-policy\x0f\x04\0\x1echange-retry-policy-parameters\x03\0?\x01r\x02\x09time\ +stamp\x01\x0bbegin-index\x09\x04\0\x1cend-atomic-region-parameters\x03\0A\x01r\x02\ +\x09timestamp\x01\x0bbegin-index\x09\x04\0\x1bend-remote-write-parameters\x03\0C\ +\x01k3\x01r\x03\x0fidempotency-keys\x0dfunction-names\x05input\xc5\0\x04\0'expor\ +ted-function-invocation-parameters\x03\0F\x01q\x02\x11exported-function\x01\xc7\0\ +\0\x0dmanual-update\x01\x07\0\x04\0\x11worker-invocation\x03\0H\x01r\x02\x09time\ +stamp\x01\x0ainvocation\xc9\0\x04\0$pending-worker-invocation-parameters\x03\0J\x01\ +p}\x01q\x02\x0bauto-update\0\0\x0esnapshot-based\x01\xcc\0\0\x04\0\x12update-des\ +cription\x03\0M\x01r\x03\x09timestamp\x01\x0etarget-version\x07\x12update-descri\ +ption\xce\0\x04\0\x19pending-update-parameters\x03\0O\x01r\x04\x09timestamp\x01\x0e\ +target-version\x07\x12new-component-sizew\x12new-active-plugins%\x04\0\x1csucces\ +sful-update-parameters\x03\0Q\x01ks\x01r\x03\x09timestamp\x01\x0etarget-version\x07\ +\x07details\xd3\0\x04\0\x18failed-update-parameters\x03\0T\x01r\x02\x09timestamp\ +\x01\x05deltaw\x04\0\x16grow-memory-parameters\x03\0V\x01w\x04\0\x12worker-resou\ +rce-id\x03\0X\x01r\x02\x09timestamp\x01\x0bresource-id\xd9\0\x04\0\x1acreate-res\ +ource-parameters\x03\0Z\x01r\x02\x09timestamp\x01\x0bresource-id\xd9\0\x04\0\x18\ +drop-resource-parameters\x03\0\\\x01r\x04\x09timestamp\x01\x0bresource-id\xd9\0\x0d\ +resource-names\x0fresource-params3\x04\0\x1cdescribe-resource-parameters\x03\0^\x01\ +m\x08\x06stdout\x06stderr\x05trace\x05debug\x04info\x04warn\x05error\x08critical\ +\x04\0\x09log-level\x03\0`\x01r\x04\x09timestamp\x01\x05level\xe1\0\x07contexts\x07\ +messages\x04\0\x0elog-parameters\x03\0b\x01r\x02\x09timestamp\x01\x06plugin\"\x04\ +\0\x1aactivate-plugin-parameters\x03\0d\x01r\x02\x09timestamp\x01\x06plugin\"\x04\ +\0\x1cdeactivate-plugin-parameters\x03\0f\x01r\x03\x09timestamp\x01\x05start\x09\ +\x03end\x09\x04\0\x11revert-parameters\x03\0h\x01r\x02\x09timestamp\x01\x0fidemp\ +otency-keys\x04\0\x1ccancel-invocation-parameters\x03\0j\x01r\x05\x09timestamp\x01\ +\x07span-id\x19\x06parent*\x0elinked-context*\x0aattributes,\x04\0\x15start-span\ +-parameters\x03\0l\x01r\x02\x09timestamp\x01\x07span-id\x19\x04\0\x16finish-span\ +-parameters\x03\0n\x01r\x04\x09timestamp\x01\x07span-id\x19\x03keys\x05value\x17\ +\x04\0\x1dset-span-attribute-parameters\x03\0p\x01r\x02\x09timestamp\x01\x11pers\ +istence-level\x0b\x04\0#change-persistence-level-parameters\x03\0r\x01q!\x06crea\ +te\x01'\0\x19imported-function-invoked\x01)\0\x19exported-function-invoked\x017\0\ +\x1bexported-function-completed\x01:\0\x07suspend\x01\x01\0\x05error\x01<\0\x05n\ +o-op\x01\x01\0\x04jump\x01>\0\x0binterrupted\x01\x01\0\x06exited\x01\x01\0\x13ch\ +ange-retry-policy\x01\xc0\0\0\x13begin-atomic-region\x01\x01\0\x11end-atomic-reg\ +ion\x01\xc2\0\0\x12begin-remote-write\x01\x01\0\x10end-remote-write\x01\xc4\0\0\x19\ +pending-worker-invocation\x01\xcb\0\0\x0epending-update\x01\xd0\0\0\x11successfu\ +l-update\x01\xd2\0\0\x0dfailed-update\x01\xd5\0\0\x0bgrow-memory\x01\xd7\0\0\x0f\ +create-resource\x01\xdb\0\0\x0ddrop-resource\x01\xdd\0\0\x11describe-resource\x01\ +\xdf\0\0\x03log\x01\xe3\0\0\x07restart\x01\x01\0\x0factivate-plugin\x01\xe5\0\0\x11\ +deactivate-plugin\x01\xe7\0\0\x06revert\x01\xe9\0\0\x11cancel-invocation\x01\xeb\ +\0\0\x0astart-span\x01\xed\0\0\x0bfinish-span\x01\xef\0\0\x12set-span-attribute\x01\ +\xf1\0\0\x18change-persistence-level\x01\xf3\0\0\x04\0\x0boplog-entry\x03\0t\x04\ +\0\x09get-oplog\x03\x01\x04\0\x0csearch-oplog\x03\x01\x01iv\x01@\x02\x09worker-i\ +d\x13\x05start\x09\0\xf8\0\x04\0\x16[constructor]get-oplog\x01y\x01hv\x01p\xf5\0\ +\x01k\xfb\0\x01@\x01\x04self\xfa\0\0\xfc\0\x04\0\x1a[method]get-oplog.get-next\x01\ +}\x01iw\x01@\x02\x09worker-id\x13\x04texts\0\xfe\0\x04\0\x19[constructor]search-\ +oplog\x01\x7f\x01hw\x01o\x02\x09\xf5\0\x01p\x81\x01\x01k\x82\x01\x01@\x01\x04sel\ +f\x80\x01\0\x83\x01\x04\0\x1d[method]search-oplog.get-next\x01\x84\x01\x03\0\x15\ +golem:api/oplog@1.1.7\x05\x1a\x01B\x03\x01ps\x01@\0\0\0\x04\0\x15get-invoked-fun\ +ctions\x01\x01\x04\0\x13golem:component/api\x05\x1b\x02\x03\0\x04\x0fworker-meta\ +data\x02\x03\0\x06\x0boplog-entry\x01B\x1d\x02\x03\x02\x01\x02\x04\0\x08datetime\ +\x03\0\0\x02\x03\x02\x01\x0d\x04\0\x09wit-value\x03\0\x02\x02\x03\x02\x01\x0e\x04\ +\0\x0aaccount-id\x03\0\x04\x02\x03\x02\x01\x10\x04\0\x0boplog-index\x03\0\x06\x02\ +\x03\x02\x01\x1c\x04\0\x0fworker-metadata\x03\0\x08\x02\x03\x02\x01\x1d\x04\0\x0b\ +oplog-entry\x03\0\x0a\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x0c\x02\x03\ +\x02\x01\x0a\x04\0\x09worker-id\x03\0\x0e\x01r\x01\x0aaccount-id\x05\x04\0\x0cac\ +count-info\x03\0\x10\x04\0\x09processor\x03\x01\x01o\x02ss\x01p\x13\x01i\x12\x01\ +@\x03\x0caccount-info\x11\x0ccomponent-id\x0d\x06config\x14\0\x15\x04\0\x16[cons\ +tructor]processor\x01\x16\x01h\x12\x01p\x0b\x01j\0\x01s\x01@\x05\x04self\x17\x09\ +worker-id\x0f\x08metadata\x09\x11first-entry-index\x07\x07entries\x18\0\x19\x04\0\ +\x19[method]processor.process\x01\x1a\x04\0\x1fgolem:api/oplog-processor@1.1.7\x05\ +\x1e\x04\0\x1fgolem:component/oplog-processor\x04\0\x0b\x15\x01\0\x0foplog-proce\ +ssor\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\ +\x10wit-bindgen-rust\x060.41.0"; #[inline(never)] #[doc(hidden)] pub fn __link_custom_section_describing_imports() { diff --git a/test-components/oplog-processor/wit/deps.lock b/test-components/oplog-processor/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/oplog-processor/wit/deps.lock +++ b/test-components/oplog-processor/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/oplog-processor/wit/deps.toml b/test-components/oplog-processor/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/oplog-processor/wit/deps.toml +++ b/test-components/oplog-processor/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/oplog-processor/wit/deps/golem-1.x/golem-host.wit b/test-components/oplog-processor/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/oplog-processor/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/oplog-processor/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/oplog-processor/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/oplog-processor/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/oplog-processor/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/oplog-processor/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/parent_component.wasm b/test-components/parent_component.wasm index 4529e283c9..0a1794ed8a 100644 Binary files a/test-components/parent_component.wasm and b/test-components/parent_component.wasm differ diff --git a/test-components/parent_component_composed.wasm b/test-components/parent_component_composed.wasm index de7716ea30..fb1b180cb6 100644 Binary files a/test-components/parent_component_composed.wasm and b/test-components/parent_component_composed.wasm differ diff --git a/test-components/promise/src/bindings.rs b/test-components/promise/src/bindings.rs index 731fdade1a..ab41a09907 100644 --- a/test-components/promise/src/bindings.rs +++ b/test-components/promise/src/bindings.rs @@ -384,12 +384,31 @@ pub mod golem { } } #[derive(Clone)] + pub struct WorkerWasiConfigVarsFilter { + pub name: _rt::String, + pub comparator: StringFilterComparator, + pub value: _rt::String, + } + impl ::core::fmt::Debug for WorkerWasiConfigVarsFilter { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("WorkerWasiConfigVarsFilter") + .field("name", &self.name) + .field("comparator", &self.comparator) + .field("value", &self.value) + .finish() + } + } + #[derive(Clone)] pub enum WorkerPropertyFilter { Name(WorkerNameFilter), Status(WorkerStatusFilter), Version(WorkerVersionFilter), CreatedAt(WorkerCreatedAtFilter), Env(WorkerEnvFilter), + WasiConfigVars(WorkerWasiConfigVarsFilter), } impl ::core::fmt::Debug for WorkerPropertyFilter { fn fmt( @@ -418,6 +437,11 @@ pub mod golem { WorkerPropertyFilter::Env(e) => { f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish() } + WorkerPropertyFilter::WasiConfigVars(e) => { + f.debug_tuple("WorkerPropertyFilter::WasiConfigVars") + .field(e) + .finish() + } } } } @@ -454,6 +478,7 @@ pub mod golem { pub worker_id: WorkerId, pub args: _rt::Vec<_rt::String>, pub env: _rt::Vec<(_rt::String, _rt::String)>, + pub wasi_config_vars: _rt::Vec<(_rt::String, _rt::String)>, pub status: WorkerStatus, pub component_version: u64, pub retry_count: u64, @@ -467,6 +492,7 @@ pub mod golem { .field("worker-id", &self.worker_id) .field("args", &self.args) .field("env", &self.env) + .field("wasi-config-vars", &self.wasi_config_vars) .field("status", &self.status) .field("component-version", &self.component_version) .field("retry-count", &self.retry_count) @@ -590,47 +616,47 @@ pub mod golem { high_bits: high_bits1, low_bits: low_bits1, } = uuid0; - let (result14_0, result14_1, result14_2) = match filter { + let (result17_0, result17_1, result17_2) = match filter { Some(e) => { let WorkerAnyFilter { filters: filters2 } = e; - let vec13 = filters2; - let len13 = vec13.len(); - let layout13 = _rt::alloc::Layout::from_size_align_unchecked( - vec13.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec16 = filters2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result13 = if layout13.size() != 0 { - let ptr = _rt::alloc::alloc(layout13).cast::(); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout13); + _rt::alloc::handle_alloc_error(layout16); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec13.into_iter().enumerate() { - let base = result13 + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { let WorkerAllFilter { filters: filters3 } = e; - let vec12 = filters3; - let len12 = vec12.len(); - let layout12 = _rt::alloc::Layout::from_size_align_unchecked( - vec12.len() + let vec15 = filters3; + let len15 = vec15.len(); + let layout15 = _rt::alloc::Layout::from_size_align_unchecked( + vec15.len() * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); - let result12 = if layout12.size() != 0 { - let ptr = _rt::alloc::alloc(layout12).cast::(); + let result15 = if layout15.size() != 0 { + let ptr = _rt::alloc::alloc(layout15).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout12); + _rt::alloc::handle_alloc_error(layout15); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec12.into_iter().enumerate() { - let base = result12 + for (i, e) in vec15.into_iter().enumerate() { + let base = result15 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); { match e { @@ -709,18 +735,45 @@ pub mod golem { .add(8 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = ptr11.cast_mut(); } + WorkerPropertyFilter::WasiConfigVars(e) => { + *base.add(0).cast::() = (5i32) as u8; + let WorkerWasiConfigVarsFilter { + name: name12, + comparator: comparator12, + value: value12, + } = e; + let vec13 = name12; + let ptr13 = vec13.as_ptr().cast::(); + let len13 = vec13.len(); + *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::() = len13; + *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::() = (comparator12.clone() as i32) as u8; + let vec14 = value12; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr14.cast_mut(); + } } } } *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(0).cast::<*mut u8>() = result12; - cleanup_list.extend_from_slice(&[(result12, layout12)]); + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = result15; + cleanup_list.extend_from_slice(&[(result15, layout15)]); } } - cleanup_list.extend_from_slice(&[(result13, layout13)]); - (1i32, result13, len13) + cleanup_list.extend_from_slice(&[(result16, layout16)]); + (1i32, result16, len16) } None => (0i32, ::core::ptr::null_mut(), 0usize), }; @@ -728,7 +781,7 @@ pub mod golem { #[link(wasm_import_module = "golem:api/host@1.1.7")] unsafe extern "C" { #[link_name = "[constructor]get-workers"] - fn wit_import15( + fn wit_import18( _: i64, _: i64, _: i32, @@ -738,7 +791,7 @@ pub mod golem { ) -> i32; } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import15( + unsafe extern "C" fn wit_import18( _: i64, _: i64, _: i32, @@ -749,12 +802,12 @@ pub mod golem { unreachable!() } let ret = unsafe { - wit_import15( + wit_import18( _rt::as_i64(high_bits1), _rt::as_i64(low_bits1), - result14_0, - result14_1, - result14_2, + result17_0, + result17_1, + result17_2, match &precise { true => 1, false => 0, @@ -798,7 +851,7 @@ pub mod golem { } unsafe { wit_import1((self).handle() as i32, ptr0) }; let l2 = i32::from(*ptr0.add(0).cast::()); - let result29 = match l2 { + let result38 = match l2 { 0 => None, 1 => { let e = { @@ -808,13 +861,13 @@ pub mod golem { let l4 = *ptr0 .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base28 = l3; - let len28 = l4; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); - let e28 = { + let base37 = l3; + let len37 = l4; + let mut result37 = _rt::Vec::with_capacity(len37); + for i in 0..len37 { + let base = base37 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); + let e37 = { let l5 = *base.add(0).cast::(); let l6 = *base.add(8).cast::(); let l7 = *base.add(16).cast::<*mut u8>(); @@ -903,16 +956,60 @@ pub mod golem { len24 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l25 = i32::from( + let l25 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l26 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base33 = l25; + let len33 = l26; + let mut result33 = _rt::Vec::with_capacity(len33); + for i in 0..len33 { + let base = base33 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e33 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l31 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) + }; + result33.push(e33); + } + _rt::cabi_dealloc( + base33, + len33 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l34 = i32::from( *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l26 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l35 = *base + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l27 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l36 = *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -926,25 +1023,26 @@ pub mod golem { }, args: result15, env: result24, - status: WorkerStatus::_lift(l25 as u8), - component_version: l26 as u64, - retry_count: l27 as u64, + wasi_config_vars: result33, + status: WorkerStatus::_lift(l34 as u8), + component_version: l35 as u64, + retry_count: l36 as u64, } }; - result28.push(e28); + result37.push(e37); } _rt::cabi_dealloc( - base28, - len28 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base37, + len37 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - result28 + result37 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result29 + result38 } } } @@ -1646,11 +1744,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 40 + 6 * ::core::mem::size_of::<*const u8>()], + >; 40 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 40 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let ptr0 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] @@ -1748,18 +1846,62 @@ pub mod golem { len21 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l22 = i32::from( + let l22 = *ptr0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l23 = *ptr0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base30 = l22; + let len30 = l23; + let mut result30 = _rt::Vec::with_capacity(len30); + for i in 0..len30 { + let base = base30 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e30 = { + let l24 = *base.add(0).cast::<*mut u8>(); + let l25 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) + }; + result30.push(e30); + } + _rt::cabi_dealloc( + base30, + len30 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l31 = i32::from( *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l23 = *ptr0 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l32 = *ptr0 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l24 = *ptr0 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l33 = *ptr0 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let result25 = WorkerMetadata { + let result34 = WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::golem::rpc::types::Uuid { @@ -1771,11 +1913,12 @@ pub mod golem { }, args: result12, env: result21, - status: WorkerStatus::_lift(l22 as u8), - component_version: l23 as u64, - retry_count: l24 as u64, + wasi_config_vars: result30, + status: WorkerStatus::_lift(l31 as u8), + component_version: l32 as u64, + retry_count: l33 as u64, }; - result25 + result34 } } #[allow(unused_unsafe, clippy::all)] @@ -1786,11 +1929,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let super::super::super::golem::rpc::types::WorkerId { component_id: component_id0, @@ -1833,7 +1976,7 @@ pub mod golem { ) }; let l6 = i32::from(*ptr4.add(0).cast::()); - let result30 = match l6 { + let result39 = match l6 { 0 => None, 1 => { let e = { @@ -1925,16 +2068,60 @@ pub mod golem { len26 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l27 = i32::from( + let l27 = *ptr4 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *ptr4 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base35 = l27; + let len35 = l28; + let mut result35 = _rt::Vec::with_capacity(len35); + for i in 0..len35 { + let base = base35 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e35 = { + let l29 = *base.add(0).cast::<*mut u8>(); + let l30 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len31 = l30; + let bytes31 = _rt::Vec::from_raw_parts( + l29.cast(), + len31, + len31, + ); + let l32 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l33 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len34 = l33; + let bytes34 = _rt::Vec::from_raw_parts( + l32.cast(), + len34, + len34, + ); + (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) + }; + result35.push(e35); + } + _rt::cabi_dealloc( + base35, + len35 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l36 = i32::from( *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l28 = *ptr4 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l37 = *ptr4 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *ptr4 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + let l38 = *ptr4 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -1948,16 +2135,17 @@ pub mod golem { }, args: result17, env: result26, - status: WorkerStatus::_lift(l27 as u8), - component_version: l28 as u64, - retry_count: l29 as u64, + wasi_config_vars: result35, + status: WorkerStatus::_lift(l36 as u8), + component_version: l37 as u64, + retry_count: l38 as u64, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result30 + result39 } } #[allow(unused_unsafe, clippy::all)] @@ -2549,6 +2737,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -2558,6 +2747,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -5785,26 +5975,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -5822,83 +6016,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -5916,245 +6131,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6163,7 +6378,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6172,43 +6387,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -6216,89 +6431,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -6309,13 +6524,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -6327,156 +6542,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -6717,26 +6932,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -6754,83 +6973,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -6848,245 +7088,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7095,7 +7335,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7104,106 +7344,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -7211,158 +7456,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -7370,7 +7615,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -7387,66 +7632,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, + ); + _rt::string_lift(bytes37) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes41) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -8334,8 +8601,8 @@ pub(crate) use __export_promise_impl as export; )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5392] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\x92)\x01A\x02\x01A\x13\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5548] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xae*\x01A\x02\x01A\x14\ \x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[\ method]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollab\ le.block\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\ @@ -8360,92 +8627,95 @@ pe\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0cprim-s8 -type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0dprim\ -f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\0\x10\ prim-string-type\0\0\x0bhandle-type\x01\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01\ -ks\x01r\x02\x04name\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\ -\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05values\x04\0\x03u\ -ri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0cre\ -cord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\x0bflags-value\ -\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coption-value\x01\x12\ -\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\ -\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08p\ -rim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\ -\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\ -\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03\ -typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01s\0\x06deni\ -ed\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09rpc-error\ -\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\x04\0\x12\ -cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15[construc\ -tor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm-rpc.ephe\ -meral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffun\ -ction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\ -\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wasm-rpc.inv\ -oke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0<\x04\0'\ -[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0escheduled-time\ -\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rpc.schedule\ --invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\ -\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-invocation\x01\ -@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-invoke-resu\ -lt.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[method]future-i\ -nvoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![method]cancellat\ -ion-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\0\x0aparse\ --uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\x03vnt-\ -\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-type\x01\ -L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\0\x03\ -\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x09worker-id\x01B{\x02\x03\x02\ -\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\ -\0\x02\x02\x03\x02\x01\x08\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x09\ -worker-id\x03\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x09worker-id\x07\ -\x09oplog-idx\x09\x04\0\x0apromise-id\x03\0\x0a\x01w\x04\0\x11component-version\x03\ -\0\x0c\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x0e\x01r\x01\x04uuid\x05\x04\ -\0\x0aproject-id\x03\0\x10\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x01\x09m\ -ax-delay\x01\x0amultiplieru\x11max-jitter-factor\x12\x04\0\x0cretry-policy\x03\0\ -\x13\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\ -\0\0\x04\0\x11persistence-level\x03\0\x15\x01m\x02\x09automatic\x0esnapshot-base\ -d\x04\0\x0bupdate-mode\x03\0\x17\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\ -\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x19\x01m\x04\x05\ -equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1b\ -\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06\ -exited\x04\0\x0dworker-status\x03\0\x1d\x01r\x02\x0acomparator\x1c\x05values\x04\ -\0\x12worker-name-filter\x03\0\x1f\x01r\x02\x0acomparator\x1a\x05value\x1e\x04\0\ -\x14worker-status-filter\x03\0!\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x15wo\ -rker-version-filter\x03\0#\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x18worker-\ -created-at-filter\x03\0%\x01r\x03\x04names\x0acomparator\x1c\x05values\x04\0\x11\ -worker-env-filter\x03\0'\x01q\x05\x04name\x01\x20\0\x06status\x01\"\0\x07version\ -\x01$\0\x0acreated-at\x01&\0\x03env\x01(\0\x04\0\x16worker-property-filter\x03\0\ -)\x01p*\x01r\x01\x07filters+\x04\0\x11worker-all-filter\x03\0,\x01p-\x01r\x01\x07\ -filters.\x04\0\x11worker-any-filter\x03\0/\x01ps\x01o\x02ss\x01p2\x01r\x06\x09wo\ -rker-id\x07\x04args1\x03env3\x06status\x1e\x11component-versionw\x0bretry-countw\ -\x04\0\x0fworker-metadata\x03\04\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert\ --to-oplog-index\x01\x09\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-work\ -er-target\x03\07\x01m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\09\x01k\ -0\x01i6\x01@\x03\x0ccomponent-id\x03\x06filter;\x07precise\x7f\0<\x04\0\x18[cons\ -tructor]get-workers\x01=\x01h6\x01p5\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[m\ -ethod]get-workers.get-next\x01A\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01B\x01p}\x01\ -@\x01\x0apromise-id\x0b\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\x0a\ -promise-id\x0b\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x0b\x04\ -data\xc3\0\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x0b\x01\0\ -\x04\0\x0edelete-promise\x01H\x01@\0\0\x09\x04\0\x0fget-oplog-index\x01I\x01@\x01\ -\x09oplog-idx\x09\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\ -\x04\0\x0coplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\ -\x09\x01\0\x04\0\x12mark-end-operation\x01L\x01@\0\0\x14\x04\0\x10get-retry-poli\ -cy\x01M\x01@\x01\x10new-retry-policy\x14\x01\0\x04\0\x10set-retry-policy\x01N\x01\ -@\0\0\x16\x04\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-\ -level\x16\x01\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14\ -get-idempotence-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempote\ -nce-mode\x01R\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09wo\ -rker-id\x07\x0etarget-version\x0d\x04mode\x18\x01\0\x04\0\x0dupdate-worker\x01T\x01\ -@\0\05\x04\0\x11get-self-metadata\x01U\x01k5\x01@\x01\x09worker-id\x07\0\xd6\0\x04\ -\0\x13get-worker-metadata\x01W\x01@\x03\x10source-worker-id\x07\x10target-worker\ --id\x07\x11oplog-idx-cut-off\x09\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09wor\ -ker-id\x07\x0drevert-target8\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x03\x01@\x01\ -\x13component-references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x07\x01\ -@\x02\x13component-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\ -\x01]\x04\0\x18resolve-worker-id-strict\x01]\x01@\x01\x08new-names\0:\x04\0\x04f\ -ork\x01^\x03\0\x14golem:api/host@1.1.7\x05\x0a\x02\x03\0\x04\x0apromise-id\x01B\x0a\ -\x02\x03\x02\x01\x0b\x04\0\x0apromise-id\x03\0\0\x01@\0\0\x01\x04\0\x06create\x01\ -\x02\x01p}\x01@\x01\x02id\x01\0\x03\x04\0\x05await\x01\x04\x01k\x03\x01@\x01\x02\ -id\x01\0\x05\x04\0\x04poll\x01\x06\x04\0\x0cgolem:it/api\x05\x0c\x04\0\x10golem:\ -it/promise\x04\0\x0b\x0d\x01\0\x07promise\x03\0\0\0G\x09producers\x01\x0cprocess\ -ed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.41.0"; +ks\x01r\x03\x04name\x1b\x05owner\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\ +\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05va\ +lues\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\ +\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\ +\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coptio\ +n-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08\ +prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-\ +s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09p\ +rim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\ +\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\ +\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01\ +s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09\ +rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\ +\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15\ +[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm\ +-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-nam\ +es\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01\ +/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wa\ +sm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\ +\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0esche\ +duled-time\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rp\ +c.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunc\ +tion-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-inv\ +ocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-\ +invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[meth\ +od]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![metho\ +d]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\ +\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\ +\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-\ +type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\ +\0\x03\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x0evalue-and-type\x02\ +\x03\0\x03\x09worker-id\x01B\x7f\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\ +\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\x03\x02\x01\x08\x04\0\x04uu\ +id\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x0evalue-and-type\x03\0\x06\x02\x03\x02\x01\ +\x0a\x04\0\x09worker-id\x03\0\x08\x01w\x04\0\x0boplog-index\x03\0\x0a\x01r\x02\x09\ +worker-id\x09\x09oplog-idx\x0b\x04\0\x0apromise-id\x03\0\x0c\x01w\x04\0\x11compo\ +nent-version\x03\0\x0e\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x10\x01r\x01\ +\x04uuid\x05\x04\0\x0aproject-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09mi\ +n-delay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cre\ +try-policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effe\ +cts\0\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0e\ +snapshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0d\ +greater-equal\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\ +\x01m\x04\x05equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-compa\ +rator\x03\0\x1d\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retry\ +ing\x06failed\x06exited\x04\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\ +\x05values\x04\0\x12worker-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05valu\ +e\x20\x04\0\x14worker-status-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\ +\0\x15worker-version-filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18\ +worker-created-at-filter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x11worker-env-filter\x03\0)\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x1eworker-wasi-config-vars-filter\x03\0+\x01q\x06\x04name\x01\"\0\x06status\x01\ +$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\0\x10wasi-config-vars\x01\ +,\0\x04\0\x16worker-property-filter\x03\0-\x01p.\x01r\x01\x07filters/\x04\0\x11w\ +orker-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x11worker-any-filter\x03\ +\03\x01ps\x01o\x02ss\x01p6\x01r\x07\x09worker-id\x09\x04args5\x03env7\x10wasi-co\ +nfig-vars7\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\ +etadata\x03\08\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\ +\x0b\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0;\x01\ +m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\0=\x01k4\x01i:\x01@\x03\x0c\ +component-id\x03\x06filter?\x07precise\x7f\0\xc0\0\x04\0\x18[constructor]get-wor\ +kers\x01A\x01h:\x01p9\x01k\xc3\0\x01@\x01\x04self\xc2\0\0\xc4\0\x04\0\x1c[method\ +]get-workers.get-next\x01E\x01@\0\0\x0d\x04\0\x0ecreate-promise\x01F\x01p}\x01@\x01\ +\x0apromise-id\x0d\0\xc7\0\x04\0\x0dawait-promise\x01H\x01k\xc7\0\x01@\x01\x0apr\ +omise-id\x0d\0\xc9\0\x04\0\x0cpoll-promise\x01J\x01@\x02\x0apromise-id\x0d\x04da\ +ta\xc7\0\0\x7f\x04\0\x10complete-promise\x01K\x01@\x01\x0apromise-id\x0d\x01\0\x04\ +\0\x0edelete-promise\x01L\x01@\0\0\x0b\x04\0\x0fget-oplog-index\x01M\x01@\x01\x09\ +oplog-idx\x0b\x01\0\x04\0\x0fset-oplog-index\x01N\x01@\x01\x08replicas}\x01\0\x04\ +\0\x0coplog-commit\x01O\x04\0\x14mark-begin-operation\x01M\x01@\x01\x05begin\x0b\ +\x01\0\x04\0\x12mark-end-operation\x01P\x01@\0\0\x16\x04\0\x10get-retry-policy\x01\ +Q\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01R\x01@\0\0\ +\x18\x04\0\x1bget-oplog-persistence-level\x01S\x01@\x01\x15new-persistence-level\ +\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01T\x01@\0\0\x7f\x04\0\x14get-i\ +dempotence-mode\x01U\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-m\ +ode\x01V\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01W\x01@\x03\x09worker-\ +id\x09\x0etarget-version\x0f\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01X\x01@\0\ +\09\x04\0\x11get-self-metadata\x01Y\x01k9\x01@\x01\x09worker-id\x09\0\xda\0\x04\0\ +\x13get-worker-metadata\x01[\x01@\x03\x10source-worker-id\x09\x10target-worker-i\ +d\x09\x11oplog-idx-cut-off\x0b\x01\0\x04\0\x0bfork-worker\x01\\\x01@\x02\x09work\ +er-id\x09\x0drevert-target<\x01\0\x04\0\x0drevert-worker\x01]\x01k\x03\x01@\x01\x13\ +component-references\0\xde\0\x04\0\x14resolve-component-id\x01_\x01k\x09\x01@\x02\ +\x13component-references\x0bworker-names\0\xe0\0\x04\0\x11resolve-worker-id\x01a\ +\x04\0\x18resolve-worker-id-strict\x01a\x01@\x01\x08new-names\0>\x04\0\x04fork\x01\ +b\x03\0\x14golem:api/host@1.1.7\x05\x0b\x02\x03\0\x04\x0apromise-id\x01B\x0a\x02\ +\x03\x02\x01\x0c\x04\0\x0apromise-id\x03\0\0\x01@\0\0\x01\x04\0\x06create\x01\x02\ +\x01p}\x01@\x01\x02id\x01\0\x03\x04\0\x05await\x01\x04\x01k\x03\x01@\x01\x02id\x01\ +\0\x05\x04\0\x04poll\x01\x06\x04\0\x0cgolem:it/api\x05\x0d\x04\0\x10golem:it/pro\ +mise\x04\0\x0b\x0d\x01\0\x07promise\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\ +\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.41.0"; #[inline(never)] #[doc(hidden)] pub fn __link_custom_section_describing_imports() { diff --git a/test-components/promise/wit/deps.lock b/test-components/promise/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/promise/wit/deps.lock +++ b/test-components/promise/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/promise/wit/deps.toml b/test-components/promise/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/promise/wit/deps.toml +++ b/test-components/promise/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/promise/wit/deps/golem-1.x/golem-host.wit b/test-components/promise/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/promise/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/promise/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/promise/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/promise/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/promise/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/promise/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/rdbms-service.wasm b/test-components/rdbms-service.wasm index d489d33245..7d465ba089 100644 Binary files a/test-components/rdbms-service.wasm and b/test-components/rdbms-service.wasm differ diff --git a/test-components/rpc/Cargo.lock b/test-components/rpc/Cargo.lock index 34a168f6ff..2af0281f66 100644 --- a/test-components/rpc/Cargo.lock +++ b/test-components/rpc/Cargo.lock @@ -345,7 +345,7 @@ dependencies = [ [[package]] name = "golem-rust" version = "0.0.0" -source = "git+https://github.com/golemcloud/golem-rust?branch=golem-rpc-0.2.2#ab09bbf6d84fe882eaa3d6b59908da71e253a52a" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "golem-rust-macro", "golem-wasm-rpc", @@ -358,7 +358,7 @@ dependencies = [ [[package]] name = "golem-rust-macro" version = "0.0.0" -source = "git+https://github.com/golemcloud/golem-rust?branch=golem-rpc-0.2.2#ab09bbf6d84fe882eaa3d6b59908da71e253a52a" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#bbe9c53581733248d91f27858489ae2df653bed4" dependencies = [ "heck", "proc-macro2", @@ -369,7 +369,7 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" version = "0.0.0" -source = "git+https://github.com/golemcloud/golem?branch=type-names#aa8937287522422ddaf9298c72c4e79bbc3e9545" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#b65adf9d20167fd33c71503e015a0b478a1234cb" dependencies = [ "cargo_metadata", "chrono", diff --git a/test-components/rpc/caller/Cargo.toml b/test-components/rpc/caller/Cargo.toml index 1f484b52cc..5bbc6066dc 100644 --- a/test-components/rpc/caller/Cargo.toml +++ b/test-components/rpc/caller/Cargo.toml @@ -26,7 +26,7 @@ path = "wit-generated" "golem:api/host@1.1.7" = "golem_rust::bindings::golem::api::host" [dependencies] -golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "golem-rpc-0.2.2" } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } once_cell = "1.19.0" rand = "0.8.5" diff --git a/test-components/rpc/ephemeral/Cargo.toml b/test-components/rpc/ephemeral/Cargo.toml index f385886a47..0da8a5214c 100644 --- a/test-components/rpc/ephemeral/Cargo.toml +++ b/test-components/rpc/ephemeral/Cargo.toml @@ -10,7 +10,7 @@ path = "wit-generated" "rpc:ephemeral-exports" = { path = "wit-generated/deps/rpc_ephemeral-exports" } [dependencies] -golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "golem-rpc-0.2.2" } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner" } once_cell = "1.17.1" rand = "0.8.5" diff --git a/test-components/rpc/wit-deps/deps.lock b/test-components/rpc/wit-deps/deps.lock index f9076e4884..59f7971c63 100644 --- a/test-components/rpc/wit-deps/deps.lock +++ b/test-components/rpc/wit-deps/deps.lock @@ -1,57 +1,61 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/v1.2.0.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/type-owner.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" -deps = ["blobstore", "cli", "clocks", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] +deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] [blobstore] -sha256 = "eb50ec776eac937b2ef90b41a281d0dd7c94f0b076466d917bd0f2ed5b01d39d" -sha512 = "b40613b47a8ba236a7b3ff85cb7e3c5b8f665a6c359fc539ca01f0b2170538a47c80eb991df8f4d5ca162f4dc6e0ca4311e23ad5ce88b85b30570dedf78fcffe" +sha256 = "f7857c92a8d540ebfe10c9ac3b8cfe160d2303ca638d59aec3c18406e084d367" +sha512 = "af647a1c40672c4b2b970b2f99de54d404e35b4aed430b00395d708dcec74eb6f03543b65605a90a1dbc3db5dbf1887b2b6ae9b6c6306475d119b312b4e91868" [cli] -sha256 = "285865a31d777181b075f39e92bcfe59c89cd6bacce660be1b9a627646956258" -sha512 = "da2622210a9e3eea82b99f1a5b8a44ce5443d009cb943f7bca0bf9cf4360829b289913d7ee727c011f0f72994ea7dc8e661ebcc0a6b34b587297d80cd9b3f7e8" +sha256 = "4dadd13d55aaf626833d1f4b9c34a17b0f04e993babd09552b785cda3b95ea76" +sha512 = "898dcc4e8c15d18acc6b88dbe232336fa4d19019430a910dbc9e7aeaace3077a164af3be9f002de6e7e65ef693df340801ac0c7e421e9a746bf1b6d698a90835" [clocks] -sha256 = "468b4d12892fe926b8eb5d398dbf579d566c93231fa44f415440572c695b7613" -sha512 = "e6b53a07221f1413953c9797c68f08b815fdaebf66419bbc1ea3e8b7dece73731062693634731f311a03957b268cf9cc509c518bd15e513c318aa04a8459b93a" +sha256 = "93a701968a7dd3c5d69031bc0601681c468972fdf7e28a93bb6150a67d6ebe8b" +sha512 = "98fca567c7a01887b0fb38981f1772169b6ea8de475b546508f8b86738d84e44ba95cae81def40ac34e8809f5f60e85224077ab8cb6d6d5d6296acc1df73c159" + +[config] +sha256 = "31fe247a242af7abe32dfadcb4edbc7720f9c47c2bff34b7e5c75df915ab5eb9" +sha512 = "ce5367f3a104843852236799a3386a44da12ee5e287eb94075fd5252c1400b6ef84438f3b3e19f75fb3d842d82fe3a1bc999385fe59fc8e1696fed69bad69eac" [filesystem] -sha256 = "498c465cfd04587db40f970fff2185daa597d074c20b68a8bcbae558f261499b" -sha512 = "ead452f9b7bfb88593a502ec00d76d4228003d51c40fd0408aebc32d35c94673551b00230d730873361567cc209ec218c41fb4e95bad194268592c49e7964347" +sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" +sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "2787c96144b95a334a8abed873b8231e286126691337ff05c37318d71b462972" -sha512 = "442a5f8cb59fd715520fd7ebdaf2823d9a83b493db4493039237997cd277f8e519a72228322cce352c0d2ce6327bcbda383331c8923d9a6a00e4edce3a12bff6" +sha256 = "831dbbcffd5061289633f68704593d4d22e8c7a6c95b65493f0d103a8d1eed04" +sha512 = "4830f5095505702aeaeb5838810be9fe2d69929f3b7a2156621e34d350f270ab224d13e007ceab9b9a4f4990593b88c211209f644253767a04eb7f2bd4333fc9" [golem-durability] -sha256 = "b0d068502eb2a9a0ae7100ec33ba67ffc1133d26ce6868950e7cdfa48cef0f68" -sha512 = "1db57e4d5e183ea900906c10b32781e79e7d6871b1f302f1cd52e9545388b9e473ae4427369a0e1e32ea5fb2bee62f2f41eba2cda579c96afc91c68eaee1cc4d" +sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" +sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "8e19b68aef0362c2f18d19b8f41de60420af930c5b34be21c3f8c057903f7c5e" -sha512 = "4738cfbb11abc962a340cea6d7a6237a48af245c0661bfbd4e8a16e4bc9034daf4abd3d535ae081009408be776b83e4edc7c728585dd2a682ef866efc86ffa78" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] -sha256 = "8f44402bde16c48e28c47dc53eab0b26af5b3b3482a1852cf77673e0880ba1c1" -sha512 = "760695f9a25c25bf75a25b731cb21c3bda9e288e450edda823324ecbc73d5d798bbb5de2edad999566980836f037463ee9e57d61789d04b3f3e381475b1a9a0f" +sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" +sha512 = "636150c464c0eb3d60bd212fc5d4012638c8cd4f89b583b87a38154ef99de828aac4296ac13c5cface10ee61e164fcfc43a5c104f916229dfdf49c0d11047677" [io] -sha256 = "5a3b0b9774ad733d4fa144a694018b03158c21e6168234e81ed02d49a78ef9cb" -sha512 = "f88e836b2264b7a0ec8e51b79420331c42b4973ccc283c556802103e0b6a8daa5ecdf00bd984851fe52db07e703d75c1970c5fba1614b6c990d97734cad22d67" +sha256 = "1cccbfe4122686ea57a25cd368e8cdfc408cbcad089f47fb6685b6f92e96f050" +sha512 = "7a95f964c13da52611141acd89bc8876226497f128e99dd176a4270c5b5efbd8cc847b5fbd1a91258d028c646db99e0424d72590cf1caf20f9f3a3343fad5017" [keyvalue] -sha256 = "efceed91e17be50f52681ef73043f54298e2f11b48a5befdcbc92a7aea941bed" -sha512 = "b019a3333c6dadbab8c067085a5110566cfb7c3f3d9a65d482ccdac85a62eb0bdfed0ca1bbf7dafabf622ca0c6cf39b865cc234412bcbb2ff1290386cda031fa" +sha256 = "0b37334713ee32ddbf6c064ddc3fe8e5b730ff63b6381b45c87aa07a6ec700ca" +sha512 = "1ec372a657a2a9f602e781846984febfdc7c34c3dc8a2c83d5b282f5580edd1d556478bbbb2a34e97c618a03b05fcc1059d6f4a01dc27176f5e5702e5173507e" [logging] sha256 = "7fb7216c713fd329ec91bb596127a1b95eec26290290b6de0c1ef294fba858c2" sha512 = "ceb68410bb46176051b0eee54e1a60831ca2fe820892c5f5f739e76efd4fe6ee6dc5e307947e7118b68a2a757ed3a3b471d16eb0900bb9040de47fef4bf1b56f" [random] -sha256 = "7371d03c037d924caba2587fb2e7c5773a0d3c5fcecbf7971e0e0ba57973c53d" -sha512 = "964c4e8925a53078e4d94ba907b54f89a0b7e154f46823a505391471466c17f53c8692682e5c85771712acd88b348686173fc07c53a3cfe3d301b8cd8ddd0de4" +sha256 = "dd0c91e7125172eb8fd4568e15ad9fc7305643015e6ece4396c3cc5e8c2bf79a" +sha512 = "d1ca2e7b0616a94a3b39d1b9450bb3fb595b01fd94a8626ad75433038dde40988ecb41ab93a374d569ab72163af3b30038d7bfc3499b9c07193181f4f1d9292a" [sockets] -sha256 = "b0869b7cbbaea1410308cd379207f5841db5e30f1e1c1d9fe0582b560b668f24" -sha512 = "198a7bcf4d405b7761e1b5a0a94cdd1e144adb0c6cfbe2b64e380d377de5ac3171a4cf3f840b81ff2ef54be990c95c121f48910796228c0f54b0c3c6e973e317" +sha256 = "2bc0f65a8046207ee3330ad7d63f6fafeafd4cc0ea4084f081bd5e4f7b177e74" +sha512 = "3e5490e41547dffa78d52631825d93da8d60f4af0246cbaf97e1ecb879285953a86d5f1f390b10c32f91dd7eaec6f43e625a26b1c92c32a0c86fde428aedaaab" diff --git a/test-components/rpc/wit-deps/deps.toml b/test-components/rpc/wit-deps/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/rpc/wit-deps/deps.toml +++ b/test-components/rpc/wit-deps/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/rpc/wit-deps/golem-1.x/golem-host.wit b/test-components/rpc/wit-deps/golem-1.x/golem-host.wit index bb932f7675..62dcef06eb 100644 --- a/test-components/rpc/wit-deps/golem-1.x/golem-host.wit +++ b/test-components/rpc/wit-deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; diff --git a/test-components/rpc/wit-deps/golem-rpc/wasm-rpc.wit b/test-components/rpc/wit-deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/rpc/wit-deps/golem-rpc/wasm-rpc.wit +++ b/test-components/rpc/wit-deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/runtime-service.wasm b/test-components/runtime-service.wasm index edb73510fb..0da5c95d39 100644 Binary files a/test-components/runtime-service.wasm and b/test-components/runtime-service.wasm differ diff --git a/test-components/runtime-service/src/bindings.rs b/test-components/runtime-service/src/bindings.rs index a9e97a3776..867bd2ed81 100644 --- a/test-components/runtime-service/src/bindings.rs +++ b/test-components/runtime-service/src/bindings.rs @@ -384,12 +384,31 @@ pub mod golem { } } #[derive(Clone)] + pub struct WorkerWasiConfigVarsFilter { + pub name: _rt::String, + pub comparator: StringFilterComparator, + pub value: _rt::String, + } + impl ::core::fmt::Debug for WorkerWasiConfigVarsFilter { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("WorkerWasiConfigVarsFilter") + .field("name", &self.name) + .field("comparator", &self.comparator) + .field("value", &self.value) + .finish() + } + } + #[derive(Clone)] pub enum WorkerPropertyFilter { Name(WorkerNameFilter), Status(WorkerStatusFilter), Version(WorkerVersionFilter), CreatedAt(WorkerCreatedAtFilter), Env(WorkerEnvFilter), + WasiConfigVars(WorkerWasiConfigVarsFilter), } impl ::core::fmt::Debug for WorkerPropertyFilter { fn fmt( @@ -418,6 +437,11 @@ pub mod golem { WorkerPropertyFilter::Env(e) => { f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish() } + WorkerPropertyFilter::WasiConfigVars(e) => { + f.debug_tuple("WorkerPropertyFilter::WasiConfigVars") + .field(e) + .finish() + } } } } @@ -454,6 +478,7 @@ pub mod golem { pub worker_id: WorkerId, pub args: _rt::Vec<_rt::String>, pub env: _rt::Vec<(_rt::String, _rt::String)>, + pub wasi_config_vars: _rt::Vec<(_rt::String, _rt::String)>, pub status: WorkerStatus, pub component_version: u64, pub retry_count: u64, @@ -467,6 +492,7 @@ pub mod golem { .field("worker-id", &self.worker_id) .field("args", &self.args) .field("env", &self.env) + .field("wasi-config-vars", &self.wasi_config_vars) .field("status", &self.status) .field("component-version", &self.component_version) .field("retry-count", &self.retry_count) @@ -590,47 +616,47 @@ pub mod golem { high_bits: high_bits1, low_bits: low_bits1, } = uuid0; - let (result14_0, result14_1, result14_2) = match filter { + let (result17_0, result17_1, result17_2) = match filter { Some(e) => { let WorkerAnyFilter { filters: filters2 } = e; - let vec13 = filters2; - let len13 = vec13.len(); - let layout13 = _rt::alloc::Layout::from_size_align_unchecked( - vec13.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec16 = filters2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result13 = if layout13.size() != 0 { - let ptr = _rt::alloc::alloc(layout13).cast::(); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout13); + _rt::alloc::handle_alloc_error(layout16); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec13.into_iter().enumerate() { - let base = result13 + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { let WorkerAllFilter { filters: filters3 } = e; - let vec12 = filters3; - let len12 = vec12.len(); - let layout12 = _rt::alloc::Layout::from_size_align_unchecked( - vec12.len() + let vec15 = filters3; + let len15 = vec15.len(); + let layout15 = _rt::alloc::Layout::from_size_align_unchecked( + vec15.len() * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); - let result12 = if layout12.size() != 0 { - let ptr = _rt::alloc::alloc(layout12).cast::(); + let result15 = if layout15.size() != 0 { + let ptr = _rt::alloc::alloc(layout15).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout12); + _rt::alloc::handle_alloc_error(layout15); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec12.into_iter().enumerate() { - let base = result12 + for (i, e) in vec15.into_iter().enumerate() { + let base = result15 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); { match e { @@ -709,18 +735,45 @@ pub mod golem { .add(8 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = ptr11.cast_mut(); } + WorkerPropertyFilter::WasiConfigVars(e) => { + *base.add(0).cast::() = (5i32) as u8; + let WorkerWasiConfigVarsFilter { + name: name12, + comparator: comparator12, + value: value12, + } = e; + let vec13 = name12; + let ptr13 = vec13.as_ptr().cast::(); + let len13 = vec13.len(); + *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::() = len13; + *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::() = (comparator12.clone() as i32) as u8; + let vec14 = value12; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr14.cast_mut(); + } } } } *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(0).cast::<*mut u8>() = result12; - cleanup_list.extend_from_slice(&[(result12, layout12)]); + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = result15; + cleanup_list.extend_from_slice(&[(result15, layout15)]); } } - cleanup_list.extend_from_slice(&[(result13, layout13)]); - (1i32, result13, len13) + cleanup_list.extend_from_slice(&[(result16, layout16)]); + (1i32, result16, len16) } None => (0i32, ::core::ptr::null_mut(), 0usize), }; @@ -728,7 +781,7 @@ pub mod golem { #[link(wasm_import_module = "golem:api/host@1.1.7")] unsafe extern "C" { #[link_name = "[constructor]get-workers"] - fn wit_import15( + fn wit_import18( _: i64, _: i64, _: i32, @@ -738,7 +791,7 @@ pub mod golem { ) -> i32; } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import15( + unsafe extern "C" fn wit_import18( _: i64, _: i64, _: i32, @@ -749,12 +802,12 @@ pub mod golem { unreachable!() } let ret = unsafe { - wit_import15( + wit_import18( _rt::as_i64(high_bits1), _rt::as_i64(low_bits1), - result14_0, - result14_1, - result14_2, + result17_0, + result17_1, + result17_2, match &precise { true => 1, false => 0, @@ -798,7 +851,7 @@ pub mod golem { } unsafe { wit_import1((self).handle() as i32, ptr0) }; let l2 = i32::from(*ptr0.add(0).cast::()); - let result29 = match l2 { + let result38 = match l2 { 0 => None, 1 => { let e = { @@ -808,13 +861,13 @@ pub mod golem { let l4 = *ptr0 .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base28 = l3; - let len28 = l4; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); - let e28 = { + let base37 = l3; + let len37 = l4; + let mut result37 = _rt::Vec::with_capacity(len37); + for i in 0..len37 { + let base = base37 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); + let e37 = { let l5 = *base.add(0).cast::(); let l6 = *base.add(8).cast::(); let l7 = *base.add(16).cast::<*mut u8>(); @@ -903,16 +956,60 @@ pub mod golem { len24 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l25 = i32::from( + let l25 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l26 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base33 = l25; + let len33 = l26; + let mut result33 = _rt::Vec::with_capacity(len33); + for i in 0..len33 { + let base = base33 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e33 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l31 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) + }; + result33.push(e33); + } + _rt::cabi_dealloc( + base33, + len33 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l34 = i32::from( *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l26 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l35 = *base + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l27 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l36 = *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -926,25 +1023,26 @@ pub mod golem { }, args: result15, env: result24, - status: WorkerStatus::_lift(l25 as u8), - component_version: l26 as u64, - retry_count: l27 as u64, + wasi_config_vars: result33, + status: WorkerStatus::_lift(l34 as u8), + component_version: l35 as u64, + retry_count: l36 as u64, } }; - result28.push(e28); + result37.push(e37); } _rt::cabi_dealloc( - base28, - len28 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base37, + len37 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - result28 + result37 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result29 + result38 } } } @@ -1646,11 +1744,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 40 + 6 * ::core::mem::size_of::<*const u8>()], + >; 40 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 40 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let ptr0 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] @@ -1748,18 +1846,62 @@ pub mod golem { len21 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l22 = i32::from( + let l22 = *ptr0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l23 = *ptr0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base30 = l22; + let len30 = l23; + let mut result30 = _rt::Vec::with_capacity(len30); + for i in 0..len30 { + let base = base30 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e30 = { + let l24 = *base.add(0).cast::<*mut u8>(); + let l25 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) + }; + result30.push(e30); + } + _rt::cabi_dealloc( + base30, + len30 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l31 = i32::from( *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l23 = *ptr0 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l32 = *ptr0 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l24 = *ptr0 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l33 = *ptr0 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let result25 = WorkerMetadata { + let result34 = WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::golem::rpc::types::Uuid { @@ -1771,11 +1913,12 @@ pub mod golem { }, args: result12, env: result21, - status: WorkerStatus::_lift(l22 as u8), - component_version: l23 as u64, - retry_count: l24 as u64, + wasi_config_vars: result30, + status: WorkerStatus::_lift(l31 as u8), + component_version: l32 as u64, + retry_count: l33 as u64, }; - result25 + result34 } } #[allow(unused_unsafe, clippy::all)] @@ -1786,11 +1929,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let super::super::super::golem::rpc::types::WorkerId { component_id: component_id0, @@ -1833,7 +1976,7 @@ pub mod golem { ) }; let l6 = i32::from(*ptr4.add(0).cast::()); - let result30 = match l6 { + let result39 = match l6 { 0 => None, 1 => { let e = { @@ -1925,16 +2068,60 @@ pub mod golem { len26 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l27 = i32::from( + let l27 = *ptr4 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *ptr4 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base35 = l27; + let len35 = l28; + let mut result35 = _rt::Vec::with_capacity(len35); + for i in 0..len35 { + let base = base35 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e35 = { + let l29 = *base.add(0).cast::<*mut u8>(); + let l30 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len31 = l30; + let bytes31 = _rt::Vec::from_raw_parts( + l29.cast(), + len31, + len31, + ); + let l32 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l33 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len34 = l33; + let bytes34 = _rt::Vec::from_raw_parts( + l32.cast(), + len34, + len34, + ); + (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) + }; + result35.push(e35); + } + _rt::cabi_dealloc( + base35, + len35 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l36 = i32::from( *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l28 = *ptr4 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l37 = *ptr4 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *ptr4 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + let l38 = *ptr4 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -1948,16 +2135,17 @@ pub mod golem { }, args: result17, env: result26, - status: WorkerStatus::_lift(l27 as u8), - component_version: l28 as u64, - retry_count: l29 as u64, + wasi_config_vars: result35, + status: WorkerStatus::_lift(l36 as u8), + component_version: l37 as u64, + retry_count: l38 as u64, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result30 + result39 } } #[allow(unused_unsafe, clippy::all)] @@ -2549,6 +2737,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -2558,6 +2747,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -5785,26 +5975,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -5822,83 +6016,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -5916,245 +6131,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6163,7 +6378,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6172,43 +6387,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -6216,89 +6431,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -6309,13 +6524,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -6327,156 +6542,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -6717,26 +6932,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -6754,83 +6973,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -6848,245 +7088,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7095,7 +7335,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7104,106 +7344,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -7211,158 +7456,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -7370,7 +7615,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -7387,66 +7632,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, + ); + _rt::string_lift(bytes37) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes41) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -16034,7 +16301,7 @@ pub mod exports { arg5: i32, ) -> *mut u8 { #[cfg(target_arch = "wasm32")] _rt::run_ctors_once(); - let result23 = T::get_workers( + let result30 = T::get_workers( super::super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::super::golem::rpc::types::Uuid { high_bits: arg0 as u64, @@ -16045,29 +16312,29 @@ pub mod exports { 0 => None, 1 => { let e = { - let base22 = arg3; - let len22 = arg4; - let mut result22 = _rt::Vec::with_capacity(len22); - for i in 0..len22 { - let base = base22 + let base29 = arg3; + let len29 = arg4; + let mut result29 = _rt::Vec::with_capacity(len29); + for i in 0..len29 { + let base = base29 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e22 = { + let e29 = { let l0 = *base.add(0).cast::<*mut u8>(); let l1 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base21 = l0; - let len21 = l1; - let mut result21 = _rt::Vec::with_capacity(len21); - for i in 0..len21 { - let base = base21 + let base28 = l0; + let len28 = l1; + let mut result28 = _rt::Vec::with_capacity(len28); + for i in 0..len28 { + let base = base28 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); - let e21 = { + let e28 = { let l2 = i32::from(*base.add(0).cast::()); - use super::super::super::super::golem::api::host::WorkerPropertyFilter as V20; - let v20 = match l2 { + use super::super::super::super::golem::api::host::WorkerPropertyFilter as V27; + let v27 = match l2 { 0 => { - let e20 = { + let e27 = { let l3 = i32::from(*base.add(8).cast::()); let l4 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) @@ -16088,10 +16355,10 @@ pub mod exports { value: _rt::string_lift(bytes6), } }; - V20::Name(e20) + V27::Name(e27) } 1 => { - let e20 = { + let e27 = { let l7 = i32::from(*base.add(8).cast::()); let l8 = i32::from(*base.add(9).cast::()); super::super::super::super::golem::api::host::WorkerStatusFilter { @@ -16103,10 +16370,10 @@ pub mod exports { ), } }; - V20::Status(e20) + V27::Status(e27) } 2 => { - let e20 = { + let e27 = { let l9 = i32::from(*base.add(8).cast::()); let l10 = *base.add(16).cast::(); super::super::super::super::golem::api::host::WorkerVersionFilter { @@ -16116,10 +16383,10 @@ pub mod exports { value: l10 as u64, } }; - V20::Version(e20) + V27::Version(e27) } 3 => { - let e20 = { + let e27 = { let l11 = i32::from(*base.add(8).cast::()); let l12 = *base.add(16).cast::(); super::super::super::super::golem::api::host::WorkerCreatedAtFilter { @@ -16129,11 +16396,10 @@ pub mod exports { value: l12 as u64, } }; - V20::CreatedAt(e20) + V27::CreatedAt(e27) } - n => { - debug_assert_eq!(n, 4, "invalid enum discriminant"); - let e20 = { + 4 => { + let e27 = { let l13 = *base.add(8).cast::<*mut u8>(); let l14 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) @@ -16169,31 +16435,71 @@ pub mod exports { value: _rt::string_lift(bytes19), } }; - V20::Env(e20) + V27::Env(e27) + } + n => { + debug_assert_eq!(n, 5, "invalid enum discriminant"); + let e27 = { + let l20 = *base.add(8).cast::<*mut u8>(); + let l21 = *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len22 = l21; + let bytes22 = _rt::Vec::from_raw_parts( + l20.cast(), + len22, + len22, + ); + let l23 = i32::from( + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l24 = *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l25 = *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + super::super::super::super::golem::api::host::WorkerWasiConfigVarsFilter { + name: _rt::string_lift(bytes22), + comparator: super::super::super::super::golem::api::host::StringFilterComparator::_lift( + l23 as u8, + ), + value: _rt::string_lift(bytes26), + } + }; + V27::WasiConfigVars(e27) } }; - v20 + v27 }; - result21.push(e21); + result28.push(e28); } _rt::cabi_dealloc( - base21, - len21 * (16 + 4 * ::core::mem::size_of::<*const u8>()), + base28, + len28 * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); super::super::super::super::golem::api::host::WorkerAllFilter { - filters: result21, + filters: result28, } }; - result22.push(e22); + result29.push(e29); } _rt::cabi_dealloc( - base22, - len22 * (2 * ::core::mem::size_of::<*const u8>()), + base29, + len29 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); super::super::super::super::golem::api::host::WorkerAnyFilter { - filters: result22, + filters: result29, } }; Some(e) @@ -16202,150 +16508,197 @@ pub mod exports { }, _rt::bool_lift(arg5 as u8), ); - let ptr24 = (&raw mut _RET_AREA.0).cast::(); - let vec36 = result23; - let len36 = vec36.len(); - let layout36 = _rt::alloc::Layout::from_size_align_unchecked( - vec36.len() * (40 + 6 * ::core::mem::size_of::<*const u8>()), + let ptr31 = (&raw mut _RET_AREA.0).cast::(); + let vec47 = result30; + let len47 = vec47.len(); + let layout47 = _rt::alloc::Layout::from_size_align_unchecked( + vec47.len() * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - let result36 = if layout36.size() != 0 { - let ptr = _rt::alloc::alloc(layout36).cast::(); + let result47 = if layout47.size() != 0 { + let ptr = _rt::alloc::alloc(layout47).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout36); + _rt::alloc::handle_alloc_error(layout47); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec36.into_iter().enumerate() { - let base = result36 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec47.into_iter().enumerate() { + let base = result47 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); { let super::super::super::super::golem::api::host::WorkerMetadata { - worker_id: worker_id25, - args: args25, - env: env25, - status: status25, - component_version: component_version25, - retry_count: retry_count25, + worker_id: worker_id32, + args: args32, + env: env32, + wasi_config_vars: wasi_config_vars32, + status: status32, + component_version: component_version32, + retry_count: retry_count32, } = e; let super::super::super::super::golem::rpc::types::WorkerId { - component_id: component_id26, - worker_name: worker_name26, - } = worker_id25; + component_id: component_id33, + worker_name: worker_name33, + } = worker_id32; let super::super::super::super::golem::rpc::types::ComponentId { - uuid: uuid27, - } = component_id26; + uuid: uuid34, + } = component_id33; let super::super::super::super::golem::rpc::types::Uuid { - high_bits: high_bits28, - low_bits: low_bits28, - } = uuid27; - *base.add(0).cast::() = _rt::as_i64(high_bits28); - *base.add(8).cast::() = _rt::as_i64(low_bits28); - let vec29 = (worker_name26.into_bytes()).into_boxed_slice(); - let ptr29 = vec29.as_ptr().cast::(); - let len29 = vec29.len(); - ::core::mem::forget(vec29); + high_bits: high_bits35, + low_bits: low_bits35, + } = uuid34; + *base.add(0).cast::() = _rt::as_i64(high_bits35); + *base.add(8).cast::() = _rt::as_i64(low_bits35); + let vec36 = (worker_name33.into_bytes()).into_boxed_slice(); + let ptr36 = vec36.as_ptr().cast::(); + let len36 = vec36.len(); + ::core::mem::forget(vec36); *base .add(16 + 1 * ::core::mem::size_of::<*const u8>()) - .cast::() = len29; - *base.add(16).cast::<*mut u8>() = ptr29.cast_mut(); - let vec31 = args25; - let len31 = vec31.len(); - let layout31 = _rt::alloc::Layout::from_size_align_unchecked( - vec31.len() * (2 * ::core::mem::size_of::<*const u8>()), + .cast::() = len36; + *base.add(16).cast::<*mut u8>() = ptr36.cast_mut(); + let vec38 = args32; + let len38 = vec38.len(); + let layout38 = _rt::alloc::Layout::from_size_align_unchecked( + vec38.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result31 = if layout31.size() != 0 { - let ptr = _rt::alloc::alloc(layout31).cast::(); + let result38 = if layout38.size() != 0 { + let ptr = _rt::alloc::alloc(layout38).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout31); + _rt::alloc::handle_alloc_error(layout38); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec31.into_iter().enumerate() { - let base = result31 + for (i, e) in vec38.into_iter().enumerate() { + let base = result38 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec30 = (e.into_bytes()).into_boxed_slice(); - let ptr30 = vec30.as_ptr().cast::(); - let len30 = vec30.len(); - ::core::mem::forget(vec30); + let vec37 = (e.into_bytes()).into_boxed_slice(); + let ptr37 = vec37.as_ptr().cast::(); + let len37 = vec37.len(); + ::core::mem::forget(vec37); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len30; - *base.add(0).cast::<*mut u8>() = ptr30.cast_mut(); + .cast::() = len37; + *base.add(0).cast::<*mut u8>() = ptr37.cast_mut(); } } *base .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len31; + .cast::() = len38; *base .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result31; - let vec35 = env25; - let len35 = vec35.len(); - let layout35 = _rt::alloc::Layout::from_size_align_unchecked( - vec35.len() * (4 * ::core::mem::size_of::<*const u8>()), + .cast::<*mut u8>() = result38; + let vec42 = env32; + let len42 = vec42.len(); + let layout42 = _rt::alloc::Layout::from_size_align_unchecked( + vec42.len() * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result35 = if layout35.size() != 0 { - let ptr = _rt::alloc::alloc(layout35).cast::(); + let result42 = if layout42.size() != 0 { + let ptr = _rt::alloc::alloc(layout42).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout35); + _rt::alloc::handle_alloc_error(layout42); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec35.into_iter().enumerate() { - let base = result35 + for (i, e) in vec42.into_iter().enumerate() { + let base = result42 .add(i * (4 * ::core::mem::size_of::<*const u8>())); { - let (t32_0, t32_1) = e; - let vec33 = (t32_0.into_bytes()).into_boxed_slice(); - let ptr33 = vec33.as_ptr().cast::(); - let len33 = vec33.len(); - ::core::mem::forget(vec33); + let (t39_0, t39_1) = e; + let vec40 = (t39_0.into_bytes()).into_boxed_slice(); + let ptr40 = vec40.as_ptr().cast::(); + let len40 = vec40.len(); + ::core::mem::forget(vec40); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len33; - *base.add(0).cast::<*mut u8>() = ptr33.cast_mut(); - let vec34 = (t32_1.into_bytes()).into_boxed_slice(); - let ptr34 = vec34.as_ptr().cast::(); - let len34 = vec34.len(); - ::core::mem::forget(vec34); + .cast::() = len40; + *base.add(0).cast::<*mut u8>() = ptr40.cast_mut(); + let vec41 = (t39_1.into_bytes()).into_boxed_slice(); + let ptr41 = vec41.as_ptr().cast::(); + let len41 = vec41.len(); + ::core::mem::forget(vec41); *base .add(3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len34; + .cast::() = len41; *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr34.cast_mut(); + .cast::<*mut u8>() = ptr41.cast_mut(); } } *base .add(16 + 5 * ::core::mem::size_of::<*const u8>()) - .cast::() = len35; + .cast::() = len42; *base .add(16 + 4 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result35; + .cast::<*mut u8>() = result42; + let vec46 = wasi_config_vars32; + let len46 = vec46.len(); + let layout46 = _rt::alloc::Layout::from_size_align_unchecked( + vec46.len() * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let result46 = if layout46.size() != 0 { + let ptr = _rt::alloc::alloc(layout46).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout46); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec46.into_iter().enumerate() { + let base = result46 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + { + let (t43_0, t43_1) = e; + let vec44 = (t43_0.into_bytes()).into_boxed_slice(); + let ptr44 = vec44.as_ptr().cast::(); + let len44 = vec44.len(); + ::core::mem::forget(vec44); + *base + .add(::core::mem::size_of::<*const u8>()) + .cast::() = len44; + *base.add(0).cast::<*mut u8>() = ptr44.cast_mut(); + let vec45 = (t43_1.into_bytes()).into_boxed_slice(); + let ptr45 = vec45.as_ptr().cast::(); + let len45 = vec45.len(); + ::core::mem::forget(vec45); + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = len45; + *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr45.cast_mut(); + } + } + *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len46; *base .add(16 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = (status25.clone() as i32) as u8; + .cast::<*mut u8>() = result46; *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(component_version25); + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) + .cast::() = (status32.clone() as i32) as u8; *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(retry_count25); + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(component_version32); + *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(retry_count32); } } - *ptr24.add(::core::mem::size_of::<*const u8>()).cast::() = len36; - *ptr24.add(0).cast::<*mut u8>() = result36; - ptr24 + *ptr31.add(::core::mem::size_of::<*const u8>()).cast::() = len47; + *ptr31.add(0).cast::<*mut u8>() = result47; + ptr31 } #[doc(hidden)] #[allow(non_snake_case)] @@ -16354,11 +16707,11 @@ pub mod exports { let l1 = *arg0 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base16 = l0; - let len16 = l1; - for i in 0..len16 { - let base = base16 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); + let base23 = l0; + let len23 = l1; + for i in 0..len23 { + let base = base23 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); { let l2 = *base.add(16).cast::<*mut u8>(); let l3 = *base @@ -16420,11 +16773,42 @@ pub mod exports { len15 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); + let l16 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l17 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base22 = l16; + let len22 = l17; + for i in 0..len22 { + let base = base22 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + { + let l18 = *base.add(0).cast::<*mut u8>(); + let l19 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + _rt::cabi_dealloc(l18, l19, 1); + let l20 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l21 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + _rt::cabi_dealloc(l20, l21, 1); + } + } + _rt::cabi_dealloc( + base22, + len22 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); } } _rt::cabi_dealloc( - base16, - len16 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base23, + len23 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); } @@ -16438,6 +16822,7 @@ pub mod exports { worker_id: worker_id2, args: args2, env: env2, + wasi_config_vars: wasi_config_vars2, status: status2, component_version: component_version2, retry_count: retry_count2, @@ -16544,14 +16929,60 @@ pub mod exports { *ptr1 .add(16 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = result12; + let vec16 = wasi_config_vars2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout16); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + { + let (t13_0, t13_1) = e; + let vec14 = (t13_0.into_bytes()).into_boxed_slice(); + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + ::core::mem::forget(vec14); + *base + .add(::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base.add(0).cast::<*mut u8>() = ptr14.cast_mut(); + let vec15 = (t13_1.into_bytes()).into_boxed_slice(); + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + ::core::mem::forget(vec15); + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + } + *ptr1 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len16; *ptr1 .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result16; + *ptr1 + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::() = (status2.clone() as i32) as u8; *ptr1 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i64(component_version2); *ptr1 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i64(retry_count2); ptr1 } @@ -16618,6 +17049,37 @@ pub mod exports { len13 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); + let l14 = *arg0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l15 = *arg0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base20 = l14; + let len20 = l15; + for i in 0..len20 { + let base = base20 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + { + let l16 = *base.add(0).cast::<*mut u8>(); + let l17 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + _rt::cabi_dealloc(l16, l17, 1); + let l18 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l19 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + _rt::cabi_dealloc(l18, l19, 1); + } + } + _rt::cabi_dealloc( + base20, + len20 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); } #[doc(hidden)] #[allow(non_snake_case)] @@ -16647,6 +17109,7 @@ pub mod exports { worker_id: worker_id3, args: args3, env: env3, + wasi_config_vars: wasi_config_vars3, status: status3, component_version: component_version3, retry_count: retry_count3, @@ -16753,14 +17216,60 @@ pub mod exports { *ptr2 .add(24 + 4 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = result13; + let vec17 = wasi_config_vars3; + let len17 = vec17.len(); + let layout17 = _rt::alloc::Layout::from_size_align_unchecked( + vec17.len() * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let result17 = if layout17.size() != 0 { + let ptr = _rt::alloc::alloc(layout17).cast::(); + if ptr.is_null() { + _rt::alloc::handle_alloc_error(layout17); + } + ptr + } else { + ::core::ptr::null_mut() + }; + for (i, e) in vec17.into_iter().enumerate() { + let base = result17 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + { + let (t14_0, t14_1) = e; + let vec15 = (t14_0.into_bytes()).into_boxed_slice(); + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + ::core::mem::forget(vec15); + *base + .add(::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = ptr15.cast_mut(); + let vec16 = (t14_1.into_bytes()).into_boxed_slice(); + let ptr16 = vec16.as_ptr().cast::(); + let len16 = vec16.len(); + ::core::mem::forget(vec16); + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = len16; + *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr16.cast_mut(); + } + } + *ptr2 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len17; *ptr2 .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result17; + *ptr2 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::() = (status3.clone() as i32) as u8; *ptr2 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i64(component_version3); *ptr2 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i64(retry_count3); } None => { @@ -16838,6 +17347,37 @@ pub mod exports { len14 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); + let l15 = *arg0 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l16 = *arg0 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base21 = l15; + let len21 = l16; + for i in 0..len21 { + let base = base21 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + { + let l17 = *base.add(0).cast::<*mut u8>(); + let l18 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + _rt::cabi_dealloc(l17, l18, 1); + let l19 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l20 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + _rt::cabi_dealloc(l19, l20, 1); + } + } + _rt::cabi_dealloc( + base21, + len21 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); } } } @@ -16977,11 +17517,11 @@ pub mod exports { struct _RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); static mut _RET_AREA: _RetArea = _RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); } } @@ -17264,12 +17804,12 @@ pub(crate) use __export_runtime_service_impl as export; )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 11928] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\x92\\\x01A\x02\x01A(\ -\x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[\ -method]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollab\ -le.block\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\ -\0\x12wasi:io/poll@0.2.3\x05\0\x02\x03\0\0\x08pollable\x01B\x0f\x02\x03\x02\x01\x01\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 12084] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xae]\x01A\x02\x01A)\x01\ +B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[meth\ +od]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollable.b\ +lock\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\0\ +\x12wasi:io/poll@0.2.3\x05\0\x02\x03\0\0\x08pollable\x01B\x0f\x02\x03\x02\x01\x01\ \x04\0\x08pollable\x03\0\0\x01w\x04\0\x07instant\x03\0\x02\x01w\x04\0\x08duratio\ n\x03\0\x04\x01@\0\0\x03\x04\0\x03now\x01\x06\x01@\0\0\x05\x04\0\x0aresolution\x01\ \x07\x01i\x01\x01@\x01\x04when\x03\0\x08\x04\0\x11subscribe-instant\x01\x09\x01@\ @@ -17290,221 +17830,224 @@ pe\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0cprim-s8 -type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0dprim\ -f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\0\x10\ prim-string-type\0\0\x0bhandle-type\x01\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01\ -ks\x01r\x02\x04name\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\ -\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05values\x04\0\x03u\ -ri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0cre\ -cord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\x0bflags-value\ -\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coption-value\x01\x12\ -\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\ -\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08p\ -rim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\ -\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\ -\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03\ -typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01s\0\x06deni\ -ed\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09rpc-error\ -\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\x04\0\x12\ -cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15[construc\ -tor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm-rpc.ephe\ -meral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffun\ -ction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\ -\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wasm-rpc.inv\ -oke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0<\x04\0'\ -[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0escheduled-time\ -\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rpc.schedule\ --invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\ -\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-invocation\x01\ -@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-invoke-resu\ -lt.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[method]future-i\ -nvoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![method]cancellat\ -ion-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\0\x0aparse\ --uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\x03vnt-\ -\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-type\x01\ -L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\0\x03\ -\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x09worker-id\x01B{\x02\x03\x02\ -\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\ -\0\x02\x02\x03\x02\x01\x08\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x09\ -worker-id\x03\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x09worker-id\x07\ -\x09oplog-idx\x09\x04\0\x0apromise-id\x03\0\x0a\x01w\x04\0\x11component-version\x03\ -\0\x0c\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x0e\x01r\x01\x04uuid\x05\x04\ -\0\x0aproject-id\x03\0\x10\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x01\x09m\ -ax-delay\x01\x0amultiplieru\x11max-jitter-factor\x12\x04\0\x0cretry-policy\x03\0\ -\x13\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\ -\0\0\x04\0\x11persistence-level\x03\0\x15\x01m\x02\x09automatic\x0esnapshot-base\ -d\x04\0\x0bupdate-mode\x03\0\x17\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\ -\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x19\x01m\x04\x05\ -equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1b\ -\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06\ -exited\x04\0\x0dworker-status\x03\0\x1d\x01r\x02\x0acomparator\x1c\x05values\x04\ -\0\x12worker-name-filter\x03\0\x1f\x01r\x02\x0acomparator\x1a\x05value\x1e\x04\0\ -\x14worker-status-filter\x03\0!\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x15wo\ -rker-version-filter\x03\0#\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x18worker-\ -created-at-filter\x03\0%\x01r\x03\x04names\x0acomparator\x1c\x05values\x04\0\x11\ -worker-env-filter\x03\0'\x01q\x05\x04name\x01\x20\0\x06status\x01\"\0\x07version\ -\x01$\0\x0acreated-at\x01&\0\x03env\x01(\0\x04\0\x16worker-property-filter\x03\0\ -)\x01p*\x01r\x01\x07filters+\x04\0\x11worker-all-filter\x03\0,\x01p-\x01r\x01\x07\ -filters.\x04\0\x11worker-any-filter\x03\0/\x01ps\x01o\x02ss\x01p2\x01r\x06\x09wo\ -rker-id\x07\x04args1\x03env3\x06status\x1e\x11component-versionw\x0bretry-countw\ -\x04\0\x0fworker-metadata\x03\04\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert\ --to-oplog-index\x01\x09\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-work\ -er-target\x03\07\x01m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\09\x01k\ -0\x01i6\x01@\x03\x0ccomponent-id\x03\x06filter;\x07precise\x7f\0<\x04\0\x18[cons\ -tructor]get-workers\x01=\x01h6\x01p5\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[m\ -ethod]get-workers.get-next\x01A\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01B\x01p}\x01\ -@\x01\x0apromise-id\x0b\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\x0a\ -promise-id\x0b\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x0b\x04\ -data\xc3\0\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x0b\x01\0\ -\x04\0\x0edelete-promise\x01H\x01@\0\0\x09\x04\0\x0fget-oplog-index\x01I\x01@\x01\ -\x09oplog-idx\x09\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\ -\x04\0\x0coplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\ -\x09\x01\0\x04\0\x12mark-end-operation\x01L\x01@\0\0\x14\x04\0\x10get-retry-poli\ -cy\x01M\x01@\x01\x10new-retry-policy\x14\x01\0\x04\0\x10set-retry-policy\x01N\x01\ -@\0\0\x16\x04\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-\ -level\x16\x01\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14\ -get-idempotence-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempote\ -nce-mode\x01R\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09wo\ -rker-id\x07\x0etarget-version\x0d\x04mode\x18\x01\0\x04\0\x0dupdate-worker\x01T\x01\ -@\0\05\x04\0\x11get-self-metadata\x01U\x01k5\x01@\x01\x09worker-id\x07\0\xd6\0\x04\ -\0\x13get-worker-metadata\x01W\x01@\x03\x10source-worker-id\x07\x10target-worker\ --id\x07\x11oplog-idx-cut-off\x09\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09wor\ -ker-id\x07\x0drevert-target8\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x03\x01@\x01\ -\x13component-references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x07\x01\ -@\x02\x13component-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\ -\x01]\x04\0\x18resolve-worker-id-strict\x01]\x01@\x01\x08new-names\0:\x04\0\x04f\ -ork\x01^\x03\0\x14golem:api/host@1.1.7\x05\x0a\x01B\x04\x04\0\x05error\x03\x01\x01\ -h\0\x01@\x01\x04self\x01\0s\x04\0\x1d[method]error.to-debug-string\x01\x02\x03\0\ -\x13wasi:io/error@0.2.3\x05\x0b\x02\x03\0\x05\x05error\x01B(\x02\x03\x02\x01\x0c\ -\x04\0\x05error\x03\0\0\x02\x03\x02\x01\x01\x04\0\x08pollable\x03\0\x02\x01i\x01\ -\x01q\x02\x15last-operation-failed\x01\x04\0\x06closed\0\0\x04\0\x0cstream-error\ -\x03\0\x05\x04\0\x0cinput-stream\x03\x01\x04\0\x0doutput-stream\x03\x01\x01h\x07\ -\x01p}\x01j\x01\x0a\x01\x06\x01@\x02\x04self\x09\x03lenw\0\x0b\x04\0\x19[method]\ -input-stream.read\x01\x0c\x04\0\"[method]input-stream.blocking-read\x01\x0c\x01j\ -\x01w\x01\x06\x01@\x02\x04self\x09\x03lenw\0\x0d\x04\0\x19[method]input-stream.s\ -kip\x01\x0e\x04\0\"[method]input-stream.blocking-skip\x01\x0e\x01i\x03\x01@\x01\x04\ -self\x09\0\x0f\x04\0\x1e[method]input-stream.subscribe\x01\x10\x01h\x08\x01@\x01\ -\x04self\x11\0\x0d\x04\0![method]output-stream.check-write\x01\x12\x01j\0\x01\x06\ -\x01@\x02\x04self\x11\x08contents\x0a\0\x13\x04\0\x1b[method]output-stream.write\ -\x01\x14\x04\0.[method]output-stream.blocking-write-and-flush\x01\x14\x01@\x01\x04\ -self\x11\0\x13\x04\0\x1b[method]output-stream.flush\x01\x15\x04\0$[method]output\ --stream.blocking-flush\x01\x15\x01@\x01\x04self\x11\0\x0f\x04\0\x1f[method]outpu\ -t-stream.subscribe\x01\x16\x01@\x02\x04self\x11\x03lenw\0\x13\x04\0\"[method]out\ -put-stream.write-zeroes\x01\x17\x04\05[method]output-stream.blocking-write-zeroe\ -s-and-flush\x01\x17\x01@\x03\x04self\x11\x03src\x09\x03lenw\0\x0d\x04\0\x1c[meth\ -od]output-stream.splice\x01\x18\x04\0%[method]output-stream.blocking-splice\x01\x18\ -\x03\0\x15wasi:io/streams@0.2.3\x05\x0d\x02\x03\0\x06\x0cinput-stream\x02\x03\0\x06\ -\x0doutput-stream\x01B\xc1\x01\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\ -\x03\x02\x01\x0e\x04\0\x0cinput-stream\x03\0\x02\x02\x03\x02\x01\x0f\x04\0\x0dou\ -tput-stream\x03\0\x04\x02\x03\x02\x01\x0c\x04\0\x08io-error\x03\0\x06\x02\x03\x02\ -\x01\x01\x04\0\x08pollable\x03\0\x08\x01q\x0a\x03get\0\0\x04head\0\0\x04post\0\0\ -\x03put\0\0\x06delete\0\0\x07connect\0\0\x07options\0\0\x05trace\0\0\x05patch\0\0\ -\x05other\x01s\0\x04\0\x06method\x03\0\x0a\x01q\x03\x04HTTP\0\0\x05HTTPS\0\0\x05\ -other\x01s\0\x04\0\x06scheme\x03\0\x0c\x01ks\x01k{\x01r\x02\x05rcode\x0e\x09info\ --code\x0f\x04\0\x11DNS-error-payload\x03\0\x10\x01k}\x01r\x02\x08alert-id\x12\x0d\ -alert-message\x0e\x04\0\x1aTLS-alert-received-payload\x03\0\x13\x01ky\x01r\x02\x0a\ -field-name\x0e\x0afield-size\x15\x04\0\x12field-size-payload\x03\0\x16\x01kw\x01\ -k\x17\x01q'\x0bDNS-timeout\0\0\x09DNS-error\x01\x11\0\x15destination-not-found\0\ -\0\x17destination-unavailable\0\0\x19destination-IP-prohibited\0\0\x19destinatio\ -n-IP-unroutable\0\0\x12connection-refused\0\0\x15connection-terminated\0\0\x12co\ -nnection-timeout\0\0\x17connection-read-timeout\0\0\x18connection-write-timeout\0\ -\0\x18connection-limit-reached\0\0\x12TLS-protocol-error\0\0\x15TLS-certificate-\ -error\0\0\x12TLS-alert-received\x01\x14\0\x13HTTP-request-denied\0\0\x1cHTTP-req\ -uest-length-required\0\0\x16HTTP-request-body-size\x01\x18\0\x1bHTTP-request-met\ -hod-invalid\0\0\x18HTTP-request-URI-invalid\0\0\x19HTTP-request-URI-too-long\0\0\ -\x20HTTP-request-header-section-size\x01\x15\0\x18HTTP-request-header-size\x01\x19\ -\0!HTTP-request-trailer-section-size\x01\x15\0\x19HTTP-request-trailer-size\x01\x17\ -\0\x18HTTP-response-incomplete\0\0!HTTP-response-header-section-size\x01\x15\0\x19\ -HTTP-response-header-size\x01\x17\0\x17HTTP-response-body-size\x01\x18\0\"HTTP-r\ -esponse-trailer-section-size\x01\x15\0\x1aHTTP-response-trailer-size\x01\x17\0\x1d\ -HTTP-response-transfer-coding\x01\x0e\0\x1cHTTP-response-content-coding\x01\x0e\0\ -\x15HTTP-response-timeout\0\0\x13HTTP-upgrade-failed\0\0\x13HTTP-protocol-error\0\ -\0\x0dloop-detected\0\0\x13configuration-error\0\0\x0einternal-error\x01\x0e\0\x04\ -\0\x0aerror-code\x03\0\x1a\x01q\x03\x0einvalid-syntax\0\0\x09forbidden\0\0\x09im\ -mutable\0\0\x04\0\x0cheader-error\x03\0\x1c\x01s\x04\0\x09field-key\x03\0\x1e\x04\ -\0\x0afield-name\x03\0\x1f\x01p}\x04\0\x0bfield-value\x03\0!\x04\0\x06fields\x03\ -\x01\x04\0\x07headers\x03\0#\x04\0\x08trailers\x03\0#\x04\0\x10incoming-request\x03\ -\x01\x04\0\x10outgoing-request\x03\x01\x04\0\x0frequest-options\x03\x01\x04\0\x11\ -response-outparam\x03\x01\x01{\x04\0\x0bstatus-code\x03\0*\x04\0\x11incoming-res\ -ponse\x03\x01\x04\0\x0dincoming-body\x03\x01\x04\0\x0ffuture-trailers\x03\x01\x04\ -\0\x11outgoing-response\x03\x01\x04\0\x0doutgoing-body\x03\x01\x04\0\x18future-i\ -ncoming-response\x03\x01\x01i#\x01@\0\02\x04\0\x13[constructor]fields\x013\x01o\x02\ -\x20\"\x01p4\x01j\x012\x01\x1d\x01@\x01\x07entries5\06\x04\0\x18[static]fields.f\ -rom-list\x017\x01h#\x01p\"\x01@\x02\x04self8\x04name\x20\09\x04\0\x12[method]fie\ -lds.get\x01:\x01@\x02\x04self8\x04name\x20\0\x7f\x04\0\x12[method]fields.has\x01\ -;\x01j\0\x01\x1d\x01@\x03\x04self8\x04name\x20\x05value9\0<\x04\0\x12[method]fie\ -lds.set\x01=\x01@\x02\x04self8\x04name\x20\0<\x04\0\x15[method]fields.delete\x01\ ->\x01@\x03\x04self8\x04name\x20\x05value\"\0<\x04\0\x15[method]fields.append\x01\ -?\x01@\x01\x04self8\05\x04\0\x16[method]fields.entries\x01@\x01@\x01\x04self8\02\ -\x04\0\x14[method]fields.clone\x01A\x01h&\x01@\x01\x04self\xc2\0\0\x0b\x04\0\x1f\ -[method]incoming-request.method\x01C\x01@\x01\x04self\xc2\0\0\x0e\x04\0([method]\ -incoming-request.path-with-query\x01D\x01k\x0d\x01@\x01\x04self\xc2\0\0\xc5\0\x04\ -\0\x1f[method]incoming-request.scheme\x01F\x04\0\"[method]incoming-request.autho\ -rity\x01D\x01i$\x01@\x01\x04self\xc2\0\0\xc7\0\x04\0\x20[method]incoming-request\ -.headers\x01H\x01i-\x01j\x01\xc9\0\0\x01@\x01\x04self\xc2\0\0\xca\0\x04\0\x20[me\ -thod]incoming-request.consume\x01K\x01i'\x01@\x01\x07headers\xc7\0\0\xcc\0\x04\0\ -\x1d[constructor]outgoing-request\x01M\x01h'\x01i0\x01j\x01\xcf\0\0\x01@\x01\x04\ -self\xce\0\0\xd0\0\x04\0\x1d[method]outgoing-request.body\x01Q\x01@\x01\x04self\xce\ -\0\0\x0b\x04\0\x1f[method]outgoing-request.method\x01R\x01j\0\0\x01@\x02\x04self\ -\xce\0\x06method\x0b\0\xd3\0\x04\0#[method]outgoing-request.set-method\x01T\x01@\ -\x01\x04self\xce\0\0\x0e\x04\0([method]outgoing-request.path-with-query\x01U\x01\ -@\x02\x04self\xce\0\x0fpath-with-query\x0e\0\xd3\0\x04\0,[method]outgoing-reques\ -t.set-path-with-query\x01V\x01@\x01\x04self\xce\0\0\xc5\0\x04\0\x1f[method]outgo\ -ing-request.scheme\x01W\x01@\x02\x04self\xce\0\x06scheme\xc5\0\0\xd3\0\x04\0#[me\ -thod]outgoing-request.set-scheme\x01X\x04\0\"[method]outgoing-request.authority\x01\ -U\x01@\x02\x04self\xce\0\x09authority\x0e\0\xd3\0\x04\0&[method]outgoing-request\ -.set-authority\x01Y\x01@\x01\x04self\xce\0\0\xc7\0\x04\0\x20[method]outgoing-req\ -uest.headers\x01Z\x01i(\x01@\0\0\xdb\0\x04\0\x1c[constructor]request-options\x01\ -\\\x01h(\x01k\x01\x01@\x01\x04self\xdd\0\0\xde\0\x04\0'[method]request-options.c\ -onnect-timeout\x01_\x01@\x02\x04self\xdd\0\x08duration\xde\0\0\xd3\0\x04\0+[meth\ -od]request-options.set-connect-timeout\x01`\x04\0*[method]request-options.first-\ -byte-timeout\x01_\x04\0.[method]request-options.set-first-byte-timeout\x01`\x04\0\ --[method]request-options.between-bytes-timeout\x01_\x04\01[method]request-option\ -s.set-between-bytes-timeout\x01`\x01i)\x01i/\x01j\x01\xe2\0\x01\x1b\x01@\x02\x05\ -param\xe1\0\x08response\xe3\0\x01\0\x04\0\x1d[static]response-outparam.set\x01d\x01\ -h,\x01@\x01\x04self\xe5\0\0+\x04\0\x20[method]incoming-response.status\x01f\x01@\ -\x01\x04self\xe5\0\0\xc7\0\x04\0![method]incoming-response.headers\x01g\x01@\x01\ -\x04self\xe5\0\0\xca\0\x04\0![method]incoming-response.consume\x01h\x01h-\x01i\x03\ -\x01j\x01\xea\0\0\x01@\x01\x04self\xe9\0\0\xeb\0\x04\0\x1c[method]incoming-body.\ -stream\x01l\x01i.\x01@\x01\x04this\xc9\0\0\xed\0\x04\0\x1c[static]incoming-body.\ -finish\x01n\x01h.\x01i\x09\x01@\x01\x04self\xef\0\0\xf0\0\x04\0![method]future-t\ -railers.subscribe\x01q\x01i%\x01k\xf2\0\x01j\x01\xf3\0\x01\x1b\x01j\x01\xf4\0\0\x01\ -k\xf5\0\x01@\x01\x04self\xef\0\0\xf6\0\x04\0\x1b[method]future-trailers.get\x01w\ -\x01@\x01\x07headers\xc7\0\0\xe2\0\x04\0\x1e[constructor]outgoing-response\x01x\x01\ -h/\x01@\x01\x04self\xf9\0\0+\x04\0%[method]outgoing-response.status-code\x01z\x01\ -@\x02\x04self\xf9\0\x0bstatus-code+\0\xd3\0\x04\0)[method]outgoing-response.set-\ -status-code\x01{\x01@\x01\x04self\xf9\0\0\xc7\0\x04\0![method]outgoing-response.\ -headers\x01|\x01@\x01\x04self\xf9\0\0\xd0\0\x04\0\x1e[method]outgoing-response.b\ -ody\x01}\x01h0\x01i\x05\x01j\x01\xff\0\0\x01@\x01\x04self\xfe\0\0\x80\x01\x04\0\x1b\ -[method]outgoing-body.write\x01\x81\x01\x01j\0\x01\x1b\x01@\x02\x04this\xcf\0\x08\ -trailers\xf3\0\0\x82\x01\x04\0\x1c[static]outgoing-body.finish\x01\x83\x01\x01h1\ -\x01@\x01\x04self\x84\x01\0\xf0\0\x04\0*[method]future-incoming-response.subscri\ -be\x01\x85\x01\x01i,\x01j\x01\x86\x01\x01\x1b\x01j\x01\x87\x01\0\x01k\x88\x01\x01\ -@\x01\x04self\x84\x01\0\x89\x01\x04\0$[method]future-incoming-response.get\x01\x8a\ -\x01\x01h\x07\x01k\x1b\x01@\x01\x03err\x8b\x01\0\x8c\x01\x04\0\x0fhttp-error-cod\ -e\x01\x8d\x01\x03\0\x15wasi:http/types@0.2.3\x05\x10\x02\x03\0\x07\x10outgoing-r\ -equest\x02\x03\0\x07\x0frequest-options\x02\x03\0\x07\x18future-incoming-respons\ -e\x02\x03\0\x07\x0aerror-code\x01B\x0f\x02\x03\x02\x01\x11\x04\0\x10outgoing-req\ -uest\x03\0\0\x02\x03\x02\x01\x12\x04\0\x0frequest-options\x03\0\x02\x02\x03\x02\x01\ -\x13\x04\0\x18future-incoming-response\x03\0\x04\x02\x03\x02\x01\x14\x04\0\x0aer\ -ror-code\x03\0\x06\x01i\x01\x01i\x03\x01k\x09\x01i\x05\x01j\x01\x0b\x01\x07\x01@\ -\x02\x07request\x08\x07options\x0a\0\x0c\x04\0\x06handle\x01\x0d\x03\0\x20wasi:h\ -ttp/outgoing-handler@0.2.3\x05\x15\x02\x03\0\x04\x0ccomponent-id\x02\x03\0\x04\x09\ -worker-id\x02\x03\0\x04\x11component-version\x02\x03\0\x04\x0bupdate-mode\x02\x03\ -\0\x04\x11worker-any-filter\x02\x03\0\x04\x0fworker-metadata\x02\x03\0\x04\x04uu\ -id\x01B'\x02\x03\x02\x01\x16\x04\0\x0ccomponent-id\x03\0\0\x02\x03\x02\x01\x17\x04\ -\0\x09worker-id\x03\0\x02\x02\x03\x02\x01\x18\x04\0\x11component-version\x03\0\x04\ -\x02\x03\x02\x01\x19\x04\0\x0bupdate-mode\x03\0\x06\x02\x03\x02\x01\x1a\x04\0\x11\ -worker-any-filter\x03\0\x08\x02\x03\x02\x01\x1b\x04\0\x0fworker-metadata\x03\0\x0a\ -\x02\x03\x02\x01\x1c\x04\0\x04uuid\x03\0\x0c\x01@\0\0w\x04\0\x04jump\x01\x0e\x01\ -@\x01\x0bmax-retriesw\x01\0\x04\0\x1cfail-with-custom-max-retries\x01\x0f\x01@\x01\ -\x08replicas}\x01\0\x04\0\x0fexplicit-commit\x01\x10\x01@\0\x01\0\x04\0\x0datomi\ -c-region\x01\x11\x01@\x01\x07enabled\x7f\x01\0\x04\0\x10idempotence-flag\x01\x12\ -\x04\0\x0fpersist-nothing\x01\x11\x01k\x09\x01p\x0b\x01@\x03\x0ccomponent-id\x01\ -\x06filter\x13\x07precise\x7f\0\x14\x04\0\x0bget-workers\x01\x15\x01@\0\0\x0b\x04\ -\0\x11get-self-metadata\x01\x16\x01k\x0b\x01@\x01\x09worker-id\x03\0\x17\x04\0\x13\ -get-worker-metadata\x01\x18\x01@\x03\x09worker-id\x03\x11component-version\x05\x0b\ -update-mode\x07\x01\0\x04\0\x0dupdate-worker\x01\x19\x01o\x02\x0d\x0d\x01@\0\0\x1a\ -\x04\0\x19generate-idempotency-keys\x01\x1b\x04\0\x0cgolem:it/api\x05\x1d\x04\0\x18\ -golem:it/runtime-service\x04\0\x0b\x15\x01\0\x0fruntime-service\x03\0\0\0G\x09pr\ -oducers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x06\ +ks\x01r\x03\x04name\x1b\x05owner\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\ +\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05va\ +lues\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\ +\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\ +\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coptio\ +n-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08\ +prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-\ +s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09p\ +rim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\ +\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\ +\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01\ +s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09\ +rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\ +\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15\ +[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm\ +-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-nam\ +es\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01\ +/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wa\ +sm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\ +\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0esche\ +duled-time\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rp\ +c.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunc\ +tion-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-inv\ +ocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-\ +invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[meth\ +od]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![metho\ +d]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\ +\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\ +\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-\ +type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\ +\0\x03\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x0evalue-and-type\x02\ +\x03\0\x03\x09worker-id\x01B\x7f\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\ +\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\x03\x02\x01\x08\x04\0\x04uu\ +id\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x0evalue-and-type\x03\0\x06\x02\x03\x02\x01\ +\x0a\x04\0\x09worker-id\x03\0\x08\x01w\x04\0\x0boplog-index\x03\0\x0a\x01r\x02\x09\ +worker-id\x09\x09oplog-idx\x0b\x04\0\x0apromise-id\x03\0\x0c\x01w\x04\0\x11compo\ +nent-version\x03\0\x0e\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x10\x01r\x01\ +\x04uuid\x05\x04\0\x0aproject-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09mi\ +n-delay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cre\ +try-policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effe\ +cts\0\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0e\ +snapshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0d\ +greater-equal\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\ +\x01m\x04\x05equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-compa\ +rator\x03\0\x1d\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retry\ +ing\x06failed\x06exited\x04\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\ +\x05values\x04\0\x12worker-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05valu\ +e\x20\x04\0\x14worker-status-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\ +\0\x15worker-version-filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18\ +worker-created-at-filter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x11worker-env-filter\x03\0)\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x1eworker-wasi-config-vars-filter\x03\0+\x01q\x06\x04name\x01\"\0\x06status\x01\ +$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\0\x10wasi-config-vars\x01\ +,\0\x04\0\x16worker-property-filter\x03\0-\x01p.\x01r\x01\x07filters/\x04\0\x11w\ +orker-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x11worker-any-filter\x03\ +\03\x01ps\x01o\x02ss\x01p6\x01r\x07\x09worker-id\x09\x04args5\x03env7\x10wasi-co\ +nfig-vars7\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\ +etadata\x03\08\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\ +\x0b\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0;\x01\ +m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\0=\x01k4\x01i:\x01@\x03\x0c\ +component-id\x03\x06filter?\x07precise\x7f\0\xc0\0\x04\0\x18[constructor]get-wor\ +kers\x01A\x01h:\x01p9\x01k\xc3\0\x01@\x01\x04self\xc2\0\0\xc4\0\x04\0\x1c[method\ +]get-workers.get-next\x01E\x01@\0\0\x0d\x04\0\x0ecreate-promise\x01F\x01p}\x01@\x01\ +\x0apromise-id\x0d\0\xc7\0\x04\0\x0dawait-promise\x01H\x01k\xc7\0\x01@\x01\x0apr\ +omise-id\x0d\0\xc9\0\x04\0\x0cpoll-promise\x01J\x01@\x02\x0apromise-id\x0d\x04da\ +ta\xc7\0\0\x7f\x04\0\x10complete-promise\x01K\x01@\x01\x0apromise-id\x0d\x01\0\x04\ +\0\x0edelete-promise\x01L\x01@\0\0\x0b\x04\0\x0fget-oplog-index\x01M\x01@\x01\x09\ +oplog-idx\x0b\x01\0\x04\0\x0fset-oplog-index\x01N\x01@\x01\x08replicas}\x01\0\x04\ +\0\x0coplog-commit\x01O\x04\0\x14mark-begin-operation\x01M\x01@\x01\x05begin\x0b\ +\x01\0\x04\0\x12mark-end-operation\x01P\x01@\0\0\x16\x04\0\x10get-retry-policy\x01\ +Q\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01R\x01@\0\0\ +\x18\x04\0\x1bget-oplog-persistence-level\x01S\x01@\x01\x15new-persistence-level\ +\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01T\x01@\0\0\x7f\x04\0\x14get-i\ +dempotence-mode\x01U\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-m\ +ode\x01V\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01W\x01@\x03\x09worker-\ +id\x09\x0etarget-version\x0f\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01X\x01@\0\ +\09\x04\0\x11get-self-metadata\x01Y\x01k9\x01@\x01\x09worker-id\x09\0\xda\0\x04\0\ +\x13get-worker-metadata\x01[\x01@\x03\x10source-worker-id\x09\x10target-worker-i\ +d\x09\x11oplog-idx-cut-off\x0b\x01\0\x04\0\x0bfork-worker\x01\\\x01@\x02\x09work\ +er-id\x09\x0drevert-target<\x01\0\x04\0\x0drevert-worker\x01]\x01k\x03\x01@\x01\x13\ +component-references\0\xde\0\x04\0\x14resolve-component-id\x01_\x01k\x09\x01@\x02\ +\x13component-references\x0bworker-names\0\xe0\0\x04\0\x11resolve-worker-id\x01a\ +\x04\0\x18resolve-worker-id-strict\x01a\x01@\x01\x08new-names\0>\x04\0\x04fork\x01\ +b\x03\0\x14golem:api/host@1.1.7\x05\x0b\x01B\x04\x04\0\x05error\x03\x01\x01h\0\x01\ +@\x01\x04self\x01\0s\x04\0\x1d[method]error.to-debug-string\x01\x02\x03\0\x13was\ +i:io/error@0.2.3\x05\x0c\x02\x03\0\x05\x05error\x01B(\x02\x03\x02\x01\x0d\x04\0\x05\ +error\x03\0\0\x02\x03\x02\x01\x01\x04\0\x08pollable\x03\0\x02\x01i\x01\x01q\x02\x15\ +last-operation-failed\x01\x04\0\x06closed\0\0\x04\0\x0cstream-error\x03\0\x05\x04\ +\0\x0cinput-stream\x03\x01\x04\0\x0doutput-stream\x03\x01\x01h\x07\x01p}\x01j\x01\ +\x0a\x01\x06\x01@\x02\x04self\x09\x03lenw\0\x0b\x04\0\x19[method]input-stream.re\ +ad\x01\x0c\x04\0\"[method]input-stream.blocking-read\x01\x0c\x01j\x01w\x01\x06\x01\ +@\x02\x04self\x09\x03lenw\0\x0d\x04\0\x19[method]input-stream.skip\x01\x0e\x04\0\ +\"[method]input-stream.blocking-skip\x01\x0e\x01i\x03\x01@\x01\x04self\x09\0\x0f\ +\x04\0\x1e[method]input-stream.subscribe\x01\x10\x01h\x08\x01@\x01\x04self\x11\0\ +\x0d\x04\0![method]output-stream.check-write\x01\x12\x01j\0\x01\x06\x01@\x02\x04\ +self\x11\x08contents\x0a\0\x13\x04\0\x1b[method]output-stream.write\x01\x14\x04\0\ +.[method]output-stream.blocking-write-and-flush\x01\x14\x01@\x01\x04self\x11\0\x13\ +\x04\0\x1b[method]output-stream.flush\x01\x15\x04\0$[method]output-stream.blocki\ +ng-flush\x01\x15\x01@\x01\x04self\x11\0\x0f\x04\0\x1f[method]output-stream.subsc\ +ribe\x01\x16\x01@\x02\x04self\x11\x03lenw\0\x13\x04\0\"[method]output-stream.wri\ +te-zeroes\x01\x17\x04\05[method]output-stream.blocking-write-zeroes-and-flush\x01\ +\x17\x01@\x03\x04self\x11\x03src\x09\x03lenw\0\x0d\x04\0\x1c[method]output-strea\ +m.splice\x01\x18\x04\0%[method]output-stream.blocking-splice\x01\x18\x03\0\x15wa\ +si:io/streams@0.2.3\x05\x0e\x02\x03\0\x06\x0cinput-stream\x02\x03\0\x06\x0doutpu\ +t-stream\x01B\xc1\x01\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\ +\x0f\x04\0\x0cinput-stream\x03\0\x02\x02\x03\x02\x01\x10\x04\0\x0doutput-stream\x03\ +\0\x04\x02\x03\x02\x01\x0d\x04\0\x08io-error\x03\0\x06\x02\x03\x02\x01\x01\x04\0\ +\x08pollable\x03\0\x08\x01q\x0a\x03get\0\0\x04head\0\0\x04post\0\0\x03put\0\0\x06\ +delete\0\0\x07connect\0\0\x07options\0\0\x05trace\0\0\x05patch\0\0\x05other\x01s\ +\0\x04\0\x06method\x03\0\x0a\x01q\x03\x04HTTP\0\0\x05HTTPS\0\0\x05other\x01s\0\x04\ +\0\x06scheme\x03\0\x0c\x01ks\x01k{\x01r\x02\x05rcode\x0e\x09info-code\x0f\x04\0\x11\ +DNS-error-payload\x03\0\x10\x01k}\x01r\x02\x08alert-id\x12\x0dalert-message\x0e\x04\ +\0\x1aTLS-alert-received-payload\x03\0\x13\x01ky\x01r\x02\x0afield-name\x0e\x0af\ +ield-size\x15\x04\0\x12field-size-payload\x03\0\x16\x01kw\x01k\x17\x01q'\x0bDNS-\ +timeout\0\0\x09DNS-error\x01\x11\0\x15destination-not-found\0\0\x17destination-u\ +navailable\0\0\x19destination-IP-prohibited\0\0\x19destination-IP-unroutable\0\0\ +\x12connection-refused\0\0\x15connection-terminated\0\0\x12connection-timeout\0\0\ +\x17connection-read-timeout\0\0\x18connection-write-timeout\0\0\x18connection-li\ +mit-reached\0\0\x12TLS-protocol-error\0\0\x15TLS-certificate-error\0\0\x12TLS-al\ +ert-received\x01\x14\0\x13HTTP-request-denied\0\0\x1cHTTP-request-length-require\ +d\0\0\x16HTTP-request-body-size\x01\x18\0\x1bHTTP-request-method-invalid\0\0\x18\ +HTTP-request-URI-invalid\0\0\x19HTTP-request-URI-too-long\0\0\x20HTTP-request-he\ +ader-section-size\x01\x15\0\x18HTTP-request-header-size\x01\x19\0!HTTP-request-t\ +railer-section-size\x01\x15\0\x19HTTP-request-trailer-size\x01\x17\0\x18HTTP-res\ +ponse-incomplete\0\0!HTTP-response-header-section-size\x01\x15\0\x19HTTP-respons\ +e-header-size\x01\x17\0\x17HTTP-response-body-size\x01\x18\0\"HTTP-response-trai\ +ler-section-size\x01\x15\0\x1aHTTP-response-trailer-size\x01\x17\0\x1dHTTP-respo\ +nse-transfer-coding\x01\x0e\0\x1cHTTP-response-content-coding\x01\x0e\0\x15HTTP-\ +response-timeout\0\0\x13HTTP-upgrade-failed\0\0\x13HTTP-protocol-error\0\0\x0dlo\ +op-detected\0\0\x13configuration-error\0\0\x0einternal-error\x01\x0e\0\x04\0\x0a\ +error-code\x03\0\x1a\x01q\x03\x0einvalid-syntax\0\0\x09forbidden\0\0\x09immutabl\ +e\0\0\x04\0\x0cheader-error\x03\0\x1c\x01s\x04\0\x09field-key\x03\0\x1e\x04\0\x0a\ +field-name\x03\0\x1f\x01p}\x04\0\x0bfield-value\x03\0!\x04\0\x06fields\x03\x01\x04\ +\0\x07headers\x03\0#\x04\0\x08trailers\x03\0#\x04\0\x10incoming-request\x03\x01\x04\ +\0\x10outgoing-request\x03\x01\x04\0\x0frequest-options\x03\x01\x04\0\x11respons\ +e-outparam\x03\x01\x01{\x04\0\x0bstatus-code\x03\0*\x04\0\x11incoming-response\x03\ +\x01\x04\0\x0dincoming-body\x03\x01\x04\0\x0ffuture-trailers\x03\x01\x04\0\x11ou\ +tgoing-response\x03\x01\x04\0\x0doutgoing-body\x03\x01\x04\0\x18future-incoming-\ +response\x03\x01\x01i#\x01@\0\02\x04\0\x13[constructor]fields\x013\x01o\x02\x20\"\ +\x01p4\x01j\x012\x01\x1d\x01@\x01\x07entries5\06\x04\0\x18[static]fields.from-li\ +st\x017\x01h#\x01p\"\x01@\x02\x04self8\x04name\x20\09\x04\0\x12[method]fields.ge\ +t\x01:\x01@\x02\x04self8\x04name\x20\0\x7f\x04\0\x12[method]fields.has\x01;\x01j\ +\0\x01\x1d\x01@\x03\x04self8\x04name\x20\x05value9\0<\x04\0\x12[method]fields.se\ +t\x01=\x01@\x02\x04self8\x04name\x20\0<\x04\0\x15[method]fields.delete\x01>\x01@\ +\x03\x04self8\x04name\x20\x05value\"\0<\x04\0\x15[method]fields.append\x01?\x01@\ +\x01\x04self8\05\x04\0\x16[method]fields.entries\x01@\x01@\x01\x04self8\02\x04\0\ +\x14[method]fields.clone\x01A\x01h&\x01@\x01\x04self\xc2\0\0\x0b\x04\0\x1f[metho\ +d]incoming-request.method\x01C\x01@\x01\x04self\xc2\0\0\x0e\x04\0([method]incomi\ +ng-request.path-with-query\x01D\x01k\x0d\x01@\x01\x04self\xc2\0\0\xc5\0\x04\0\x1f\ +[method]incoming-request.scheme\x01F\x04\0\"[method]incoming-request.authority\x01\ +D\x01i$\x01@\x01\x04self\xc2\0\0\xc7\0\x04\0\x20[method]incoming-request.headers\ +\x01H\x01i-\x01j\x01\xc9\0\0\x01@\x01\x04self\xc2\0\0\xca\0\x04\0\x20[method]inc\ +oming-request.consume\x01K\x01i'\x01@\x01\x07headers\xc7\0\0\xcc\0\x04\0\x1d[con\ +structor]outgoing-request\x01M\x01h'\x01i0\x01j\x01\xcf\0\0\x01@\x01\x04self\xce\ +\0\0\xd0\0\x04\0\x1d[method]outgoing-request.body\x01Q\x01@\x01\x04self\xce\0\0\x0b\ +\x04\0\x1f[method]outgoing-request.method\x01R\x01j\0\0\x01@\x02\x04self\xce\0\x06\ +method\x0b\0\xd3\0\x04\0#[method]outgoing-request.set-method\x01T\x01@\x01\x04se\ +lf\xce\0\0\x0e\x04\0([method]outgoing-request.path-with-query\x01U\x01@\x02\x04s\ +elf\xce\0\x0fpath-with-query\x0e\0\xd3\0\x04\0,[method]outgoing-request.set-path\ +-with-query\x01V\x01@\x01\x04self\xce\0\0\xc5\0\x04\0\x1f[method]outgoing-reques\ +t.scheme\x01W\x01@\x02\x04self\xce\0\x06scheme\xc5\0\0\xd3\0\x04\0#[method]outgo\ +ing-request.set-scheme\x01X\x04\0\"[method]outgoing-request.authority\x01U\x01@\x02\ +\x04self\xce\0\x09authority\x0e\0\xd3\0\x04\0&[method]outgoing-request.set-autho\ +rity\x01Y\x01@\x01\x04self\xce\0\0\xc7\0\x04\0\x20[method]outgoing-request.heade\ +rs\x01Z\x01i(\x01@\0\0\xdb\0\x04\0\x1c[constructor]request-options\x01\\\x01h(\x01\ +k\x01\x01@\x01\x04self\xdd\0\0\xde\0\x04\0'[method]request-options.connect-timeo\ +ut\x01_\x01@\x02\x04self\xdd\0\x08duration\xde\0\0\xd3\0\x04\0+[method]request-o\ +ptions.set-connect-timeout\x01`\x04\0*[method]request-options.first-byte-timeout\ +\x01_\x04\0.[method]request-options.set-first-byte-timeout\x01`\x04\0-[method]re\ +quest-options.between-bytes-timeout\x01_\x04\01[method]request-options.set-betwe\ +en-bytes-timeout\x01`\x01i)\x01i/\x01j\x01\xe2\0\x01\x1b\x01@\x02\x05param\xe1\0\ +\x08response\xe3\0\x01\0\x04\0\x1d[static]response-outparam.set\x01d\x01h,\x01@\x01\ +\x04self\xe5\0\0+\x04\0\x20[method]incoming-response.status\x01f\x01@\x01\x04sel\ +f\xe5\0\0\xc7\0\x04\0![method]incoming-response.headers\x01g\x01@\x01\x04self\xe5\ +\0\0\xca\0\x04\0![method]incoming-response.consume\x01h\x01h-\x01i\x03\x01j\x01\xea\ +\0\0\x01@\x01\x04self\xe9\0\0\xeb\0\x04\0\x1c[method]incoming-body.stream\x01l\x01\ +i.\x01@\x01\x04this\xc9\0\0\xed\0\x04\0\x1c[static]incoming-body.finish\x01n\x01\ +h.\x01i\x09\x01@\x01\x04self\xef\0\0\xf0\0\x04\0![method]future-trailers.subscri\ +be\x01q\x01i%\x01k\xf2\0\x01j\x01\xf3\0\x01\x1b\x01j\x01\xf4\0\0\x01k\xf5\0\x01@\ +\x01\x04self\xef\0\0\xf6\0\x04\0\x1b[method]future-trailers.get\x01w\x01@\x01\x07\ +headers\xc7\0\0\xe2\0\x04\0\x1e[constructor]outgoing-response\x01x\x01h/\x01@\x01\ +\x04self\xf9\0\0+\x04\0%[method]outgoing-response.status-code\x01z\x01@\x02\x04s\ +elf\xf9\0\x0bstatus-code+\0\xd3\0\x04\0)[method]outgoing-response.set-status-cod\ +e\x01{\x01@\x01\x04self\xf9\0\0\xc7\0\x04\0![method]outgoing-response.headers\x01\ +|\x01@\x01\x04self\xf9\0\0\xd0\0\x04\0\x1e[method]outgoing-response.body\x01}\x01\ +h0\x01i\x05\x01j\x01\xff\0\0\x01@\x01\x04self\xfe\0\0\x80\x01\x04\0\x1b[method]o\ +utgoing-body.write\x01\x81\x01\x01j\0\x01\x1b\x01@\x02\x04this\xcf\0\x08trailers\ +\xf3\0\0\x82\x01\x04\0\x1c[static]outgoing-body.finish\x01\x83\x01\x01h1\x01@\x01\ +\x04self\x84\x01\0\xf0\0\x04\0*[method]future-incoming-response.subscribe\x01\x85\ +\x01\x01i,\x01j\x01\x86\x01\x01\x1b\x01j\x01\x87\x01\0\x01k\x88\x01\x01@\x01\x04\ +self\x84\x01\0\x89\x01\x04\0$[method]future-incoming-response.get\x01\x8a\x01\x01\ +h\x07\x01k\x1b\x01@\x01\x03err\x8b\x01\0\x8c\x01\x04\0\x0fhttp-error-code\x01\x8d\ +\x01\x03\0\x15wasi:http/types@0.2.3\x05\x11\x02\x03\0\x07\x10outgoing-request\x02\ +\x03\0\x07\x0frequest-options\x02\x03\0\x07\x18future-incoming-response\x02\x03\0\ +\x07\x0aerror-code\x01B\x0f\x02\x03\x02\x01\x12\x04\0\x10outgoing-request\x03\0\0\ +\x02\x03\x02\x01\x13\x04\0\x0frequest-options\x03\0\x02\x02\x03\x02\x01\x14\x04\0\ +\x18future-incoming-response\x03\0\x04\x02\x03\x02\x01\x15\x04\0\x0aerror-code\x03\ +\0\x06\x01i\x01\x01i\x03\x01k\x09\x01i\x05\x01j\x01\x0b\x01\x07\x01@\x02\x07requ\ +est\x08\x07options\x0a\0\x0c\x04\0\x06handle\x01\x0d\x03\0\x20wasi:http/outgoing\ +-handler@0.2.3\x05\x16\x02\x03\0\x04\x0ccomponent-id\x02\x03\0\x04\x09worker-id\x02\ +\x03\0\x04\x11component-version\x02\x03\0\x04\x0bupdate-mode\x02\x03\0\x04\x11wo\ +rker-any-filter\x02\x03\0\x04\x0fworker-metadata\x02\x03\0\x04\x04uuid\x01B'\x02\ +\x03\x02\x01\x17\x04\0\x0ccomponent-id\x03\0\0\x02\x03\x02\x01\x18\x04\0\x09work\ +er-id\x03\0\x02\x02\x03\x02\x01\x19\x04\0\x11component-version\x03\0\x04\x02\x03\ +\x02\x01\x1a\x04\0\x0bupdate-mode\x03\0\x06\x02\x03\x02\x01\x1b\x04\0\x11worker-\ +any-filter\x03\0\x08\x02\x03\x02\x01\x1c\x04\0\x0fworker-metadata\x03\0\x0a\x02\x03\ +\x02\x01\x1d\x04\0\x04uuid\x03\0\x0c\x01@\0\0w\x04\0\x04jump\x01\x0e\x01@\x01\x0b\ +max-retriesw\x01\0\x04\0\x1cfail-with-custom-max-retries\x01\x0f\x01@\x01\x08rep\ +licas}\x01\0\x04\0\x0fexplicit-commit\x01\x10\x01@\0\x01\0\x04\0\x0datomic-regio\ +n\x01\x11\x01@\x01\x07enabled\x7f\x01\0\x04\0\x10idempotence-flag\x01\x12\x04\0\x0f\ +persist-nothing\x01\x11\x01k\x09\x01p\x0b\x01@\x03\x0ccomponent-id\x01\x06filter\ +\x13\x07precise\x7f\0\x14\x04\0\x0bget-workers\x01\x15\x01@\0\0\x0b\x04\0\x11get\ +-self-metadata\x01\x16\x01k\x0b\x01@\x01\x09worker-id\x03\0\x17\x04\0\x13get-wor\ +ker-metadata\x01\x18\x01@\x03\x09worker-id\x03\x11component-version\x05\x0bupdat\ +e-mode\x07\x01\0\x04\0\x0dupdate-worker\x01\x19\x01o\x02\x0d\x0d\x01@\0\0\x1a\x04\ +\0\x19generate-idempotency-keys\x01\x1b\x04\0\x0cgolem:it/api\x05\x1e\x04\0\x18g\ +olem:it/runtime-service\x04\0\x0b\x15\x01\0\x0fruntime-service\x03\0\0\0G\x09pro\ +ducers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x06\ 0.41.0"; #[inline(never)] #[doc(hidden)] diff --git a/test-components/runtime-service/wit/deps.lock b/test-components/runtime-service/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/runtime-service/wit/deps.lock +++ b/test-components/runtime-service/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/runtime-service/wit/deps.toml b/test-components/runtime-service/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/runtime-service/wit/deps.toml +++ b/test-components/runtime-service/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/runtime-service/wit/deps/golem-1.x/golem-host.wit b/test-components/runtime-service/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/runtime-service/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/runtime-service/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/runtime-service/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/runtime-service/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/runtime-service/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/runtime-service/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/scheduled-invocation/client/wit/client.wit b/test-components/scheduled-invocation/client/wit/client.wit index 34a56f90de..c00ee40468 100644 --- a/test-components/scheduled-invocation/client/wit/client.wit +++ b/test-components/scheduled-invocation/client/wit/client.wit @@ -10,8 +10,8 @@ interface client-api { } world client { - import wasi:clocks/wall-clock@0.2.0; - import golem:api/host@1.1.6; + import wasi:clocks/wall-clock@0.2.3; + import golem:api/host@1.1.7; export client-api; } diff --git a/test-components/scheduled-invocation/wit-deps/blobstore/container.wit b/test-components/scheduled-invocation/wit-deps/blobstore/container.wit index 3b9e8d5acc..0652def81d 100644 --- a/test-components/scheduled-invocation/wit-deps/blobstore/container.wit +++ b/test-components/scheduled-invocation/wit-deps/blobstore/container.wit @@ -2,7 +2,7 @@ package wasi:blobstore; // a Container is a collection of objects interface container { - use wasi:io/streams@0.2.0.{ + use wasi:io/streams@0.2.3.{ input-stream, output-stream, }; @@ -65,4 +65,4 @@ interface container { // This function returns the number of objects skipped, and a boolean indicating if the end of the stream was reached. skip-stream-object-names: func(num: u64) -> result, error>; } -} \ No newline at end of file +} diff --git a/test-components/scheduled-invocation/wit-deps/blobstore/types.wit b/test-components/scheduled-invocation/wit-deps/blobstore/types.wit index b90f74d7e9..42cfc95278 100644 --- a/test-components/scheduled-invocation/wit-deps/blobstore/types.wit +++ b/test-components/scheduled-invocation/wit-deps/blobstore/types.wit @@ -2,7 +2,7 @@ package wasi:blobstore; // Types used by blobstore interface types { - use wasi:io/streams@0.2.0.{input-stream, output-stream}; + use wasi:io/streams@0.2.3.{input-stream, output-stream}; // name of a container, a collection of objects. // The container name may be any valid UTF-8 string. @@ -74,4 +74,4 @@ interface types { type incoming-value-async-body = input-stream; type incoming-value-sync-body = list; -} \ No newline at end of file +} diff --git a/test-components/scheduled-invocation/wit-deps/cli/command.wit b/test-components/scheduled-invocation/wit-deps/cli/command.wit index d8005bd388..3a81766d64 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/command.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/command.wit @@ -1,7 +1,10 @@ -package wasi:cli@0.2.0; +package wasi:cli@0.2.3; +@since(version = 0.2.0) world command { + @since(version = 0.2.0) include imports; + @since(version = 0.2.0) export run; } diff --git a/test-components/scheduled-invocation/wit-deps/cli/environment.wit b/test-components/scheduled-invocation/wit-deps/cli/environment.wit index 70065233e8..2f449bd7c1 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/environment.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/environment.wit @@ -1,3 +1,4 @@ +@since(version = 0.2.0) interface environment { /// Get the POSIX-style environment variables. /// @@ -7,12 +8,15 @@ interface environment { /// Morally, these are a value import, but until value imports are available /// in the component model, this import function should return the same /// values each time it is called. + @since(version = 0.2.0) get-environment: func() -> list>; /// Get the POSIX-style arguments to the program. + @since(version = 0.2.0) get-arguments: func() -> list; /// Return a path that programs should use as their initial current working /// directory, interpreting `.` as shorthand for this. + @since(version = 0.2.0) initial-cwd: func() -> option; } diff --git a/test-components/scheduled-invocation/wit-deps/cli/exit.wit b/test-components/scheduled-invocation/wit-deps/cli/exit.wit index d0c2b82ae2..427935c8d0 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/exit.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/exit.wit @@ -1,4 +1,17 @@ +@since(version = 0.2.0) interface exit { /// Exit the current instance and any linked instances. + @since(version = 0.2.0) exit: func(status: result); + + /// Exit the current instance and any linked instances, reporting the + /// specified status code to the host. + /// + /// The meaning of the code depends on the context, with 0 usually meaning + /// "success", and other values indicating various types of failure. + /// + /// This function does not return; the effect is analogous to a trap, but + /// without the connotation that something bad has happened. + @unstable(feature = cli-exit-with-code) + exit-with-code: func(status-code: u8); } diff --git a/test-components/scheduled-invocation/wit-deps/cli/imports.wit b/test-components/scheduled-invocation/wit-deps/cli/imports.wit index 083b84a036..8b4e3975ec 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/imports.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/imports.wit @@ -1,20 +1,36 @@ -package wasi:cli@0.2.0; +package wasi:cli@0.2.3; +@since(version = 0.2.0) world imports { - include wasi:clocks/imports@0.2.0; - include wasi:filesystem/imports@0.2.0; - include wasi:sockets/imports@0.2.0; - include wasi:random/imports@0.2.0; - include wasi:io/imports@0.2.0; + @since(version = 0.2.0) + include wasi:clocks/imports@0.2.3; + @since(version = 0.2.0) + include wasi:filesystem/imports@0.2.3; + @since(version = 0.2.0) + include wasi:sockets/imports@0.2.3; + @since(version = 0.2.0) + include wasi:random/imports@0.2.3; + @since(version = 0.2.0) + include wasi:io/imports@0.2.3; + @since(version = 0.2.0) import environment; + @since(version = 0.2.0) import exit; + @since(version = 0.2.0) import stdin; + @since(version = 0.2.0) import stdout; + @since(version = 0.2.0) import stderr; + @since(version = 0.2.0) import terminal-input; + @since(version = 0.2.0) import terminal-output; + @since(version = 0.2.0) import terminal-stdin; + @since(version = 0.2.0) import terminal-stdout; + @since(version = 0.2.0) import terminal-stderr; } diff --git a/test-components/scheduled-invocation/wit-deps/cli/run.wit b/test-components/scheduled-invocation/wit-deps/cli/run.wit index a70ee8c038..655346efb6 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/run.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/run.wit @@ -1,4 +1,6 @@ +@since(version = 0.2.0) interface run { /// Run the program. + @since(version = 0.2.0) run: func() -> result; } diff --git a/test-components/scheduled-invocation/wit-deps/cli/stdio.wit b/test-components/scheduled-invocation/wit-deps/cli/stdio.wit index 31ef35b5a7..1b54f5318a 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/stdio.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/stdio.wit @@ -1,17 +1,26 @@ +@since(version = 0.2.0) interface stdin { - use wasi:io/streams@0.2.0.{input-stream}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream}; + @since(version = 0.2.0) get-stdin: func() -> input-stream; } +@since(version = 0.2.0) interface stdout { - use wasi:io/streams@0.2.0.{output-stream}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{output-stream}; + @since(version = 0.2.0) get-stdout: func() -> output-stream; } +@since(version = 0.2.0) interface stderr { - use wasi:io/streams@0.2.0.{output-stream}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{output-stream}; + @since(version = 0.2.0) get-stderr: func() -> output-stream; } diff --git a/test-components/scheduled-invocation/wit-deps/cli/terminal.wit b/test-components/scheduled-invocation/wit-deps/cli/terminal.wit index 38c724efc8..d305498c64 100644 --- a/test-components/scheduled-invocation/wit-deps/cli/terminal.wit +++ b/test-components/scheduled-invocation/wit-deps/cli/terminal.wit @@ -3,8 +3,10 @@ /// In the future, this may include functions for disabling echoing, /// disabling input buffering so that keyboard events are sent through /// immediately, querying supported features, and so on. +@since(version = 0.2.0) interface terminal-input { /// The input side of a terminal. + @since(version = 0.2.0) resource terminal-input; } @@ -13,37 +15,48 @@ interface terminal-input { /// In the future, this may include functions for querying the terminal /// size, being notified of terminal size changes, querying supported /// features, and so on. +@since(version = 0.2.0) interface terminal-output { /// The output side of a terminal. + @since(version = 0.2.0) resource terminal-output; } /// An interface providing an optional `terminal-input` for stdin as a /// link-time authority. +@since(version = 0.2.0) interface terminal-stdin { + @since(version = 0.2.0) use terminal-input.{terminal-input}; /// If stdin is connected to a terminal, return a `terminal-input` handle /// allowing further interaction with it. + @since(version = 0.2.0) get-terminal-stdin: func() -> option; } /// An interface providing an optional `terminal-output` for stdout as a /// link-time authority. +@since(version = 0.2.0) interface terminal-stdout { + @since(version = 0.2.0) use terminal-output.{terminal-output}; /// If stdout is connected to a terminal, return a `terminal-output` handle /// allowing further interaction with it. + @since(version = 0.2.0) get-terminal-stdout: func() -> option; } /// An interface providing an optional `terminal-output` for stderr as a /// link-time authority. +@since(version = 0.2.0) interface terminal-stderr { + @since(version = 0.2.0) use terminal-output.{terminal-output}; /// If stderr is connected to a terminal, return a `terminal-output` handle /// allowing further interaction with it. + @since(version = 0.2.0) get-terminal-stderr: func() -> option; } diff --git a/test-components/scheduled-invocation/wit-deps/clocks/monotonic-clock.wit b/test-components/scheduled-invocation/wit-deps/clocks/monotonic-clock.wit index 4e4dc3a199..c676fb84d8 100644 --- a/test-components/scheduled-invocation/wit-deps/clocks/monotonic-clock.wit +++ b/test-components/scheduled-invocation/wit-deps/clocks/monotonic-clock.wit @@ -1,4 +1,4 @@ -package wasi:clocks@0.2.0; +package wasi:clocks@0.2.3; /// WASI Monotonic Clock is a clock API intended to let users measure elapsed /// time. /// @@ -7,38 +7,43 @@ package wasi:clocks@0.2.0; /// /// A monotonic clock is a clock which has an unspecified initial value, and /// successive reads of the clock will produce non-decreasing values. -/// -/// It is intended for measuring elapsed time. +@since(version = 0.2.0) interface monotonic-clock { - use wasi:io/poll@0.2.0.{pollable}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; /// An instant in time, in nanoseconds. An instant is relative to an /// unspecified initial value, and can only be compared to instances from /// the same monotonic-clock. + @since(version = 0.2.0) type instant = u64; /// A duration of time, in nanoseconds. + @since(version = 0.2.0) type duration = u64; /// Read the current value of the clock. /// /// The clock is monotonic, therefore calling this function repeatedly will /// produce a sequence of non-decreasing values. + @since(version = 0.2.0) now: func() -> instant; /// Query the resolution of the clock. Returns the duration of time /// corresponding to a clock tick. + @since(version = 0.2.0) resolution: func() -> duration; /// Create a `pollable` which will resolve once the specified instant - /// occured. + /// has occurred. + @since(version = 0.2.0) subscribe-instant: func( when: instant, ) -> pollable; - /// Create a `pollable` which will resolve once the given duration has - /// elapsed, starting at the time at which this function was called. - /// occured. + /// Create a `pollable` that will resolve after the specified duration has + /// elapsed from the time this function is invoked. + @since(version = 0.2.0) subscribe-duration: func( when: duration, ) -> pollable; diff --git a/test-components/scheduled-invocation/wit-deps/clocks/timezone.wit b/test-components/scheduled-invocation/wit-deps/clocks/timezone.wit new file mode 100644 index 0000000000..b43e93b233 --- /dev/null +++ b/test-components/scheduled-invocation/wit-deps/clocks/timezone.wit @@ -0,0 +1,55 @@ +package wasi:clocks@0.2.3; + +@unstable(feature = clocks-timezone) +interface timezone { + @unstable(feature = clocks-timezone) + use wall-clock.{datetime}; + + /// Return information needed to display the given `datetime`. This includes + /// the UTC offset, the time zone name, and a flag indicating whether + /// daylight saving time is active. + /// + /// If the timezone cannot be determined for the given `datetime`, return a + /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight + /// saving time. + @unstable(feature = clocks-timezone) + display: func(when: datetime) -> timezone-display; + + /// The same as `display`, but only return the UTC offset. + @unstable(feature = clocks-timezone) + utc-offset: func(when: datetime) -> s32; + + /// Information useful for displaying the timezone of a specific `datetime`. + /// + /// This information may vary within a single `timezone` to reflect daylight + /// saving time adjustments. + @unstable(feature = clocks-timezone) + record timezone-display { + /// The number of seconds difference between UTC time and the local + /// time of the timezone. + /// + /// The returned value will always be less than 86400 which is the + /// number of seconds in a day (24*60*60). + /// + /// In implementations that do not expose an actual time zone, this + /// should return 0. + utc-offset: s32, + + /// The abbreviated name of the timezone to display to a user. The name + /// `UTC` indicates Coordinated Universal Time. Otherwise, this should + /// reference local standards for the name of the time zone. + /// + /// In implementations that do not expose an actual time zone, this + /// should be the string `UTC`. + /// + /// In time zones that do not have an applicable name, a formatted + /// representation of the UTC offset may be returned, such as `-04:00`. + name: string, + + /// Whether daylight saving time is active. + /// + /// In implementations that do not expose an actual time zone, this + /// should return false. + in-daylight-saving-time: bool, + } +} diff --git a/test-components/scheduled-invocation/wit-deps/clocks/wall-clock.wit b/test-components/scheduled-invocation/wit-deps/clocks/wall-clock.wit index 440ca0f336..e00ce08933 100644 --- a/test-components/scheduled-invocation/wit-deps/clocks/wall-clock.wit +++ b/test-components/scheduled-invocation/wit-deps/clocks/wall-clock.wit @@ -1,4 +1,4 @@ -package wasi:clocks@0.2.0; +package wasi:clocks@0.2.3; /// WASI Wall Clock is a clock API intended to let users query the current /// time. The name "wall" makes an analogy to a "clock on the wall", which /// is not necessarily monotonic as it may be reset. @@ -13,8 +13,10 @@ package wasi:clocks@0.2.0; /// monotonic, making it unsuitable for measuring elapsed time. /// /// It is intended for reporting the current date and time for humans. +@since(version = 0.2.0) interface wall-clock { /// A time and date in seconds plus nanoseconds. + @since(version = 0.2.0) record datetime { seconds: u64, nanoseconds: u32, @@ -33,10 +35,12 @@ interface wall-clock { /// /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16 /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time + @since(version = 0.2.0) now: func() -> datetime; /// Query the resolution of the clock. /// /// The nanoseconds field of the output is always less than 1000000000. + @since(version = 0.2.0) resolution: func() -> datetime; } diff --git a/test-components/scheduled-invocation/wit-deps/clocks/world.wit b/test-components/scheduled-invocation/wit-deps/clocks/world.wit index c0224572a5..05f04f797d 100644 --- a/test-components/scheduled-invocation/wit-deps/clocks/world.wit +++ b/test-components/scheduled-invocation/wit-deps/clocks/world.wit @@ -1,6 +1,11 @@ -package wasi:clocks@0.2.0; +package wasi:clocks@0.2.3; +@since(version = 0.2.0) world imports { + @since(version = 0.2.0) import monotonic-clock; + @since(version = 0.2.0) import wall-clock; + @unstable(feature = clocks-timezone) + import timezone; } diff --git a/test-components/scheduled-invocation/wit-deps/config/store.wit b/test-components/scheduled-invocation/wit-deps/config/store.wit new file mode 100644 index 0000000000..794379a754 --- /dev/null +++ b/test-components/scheduled-invocation/wit-deps/config/store.wit @@ -0,0 +1,30 @@ +interface store { + /// An error type that encapsulates the different errors that can occur fetching configuration values. + variant error { + /// This indicates an error from an "upstream" config source. + /// As this could be almost _anything_ (such as Vault, Kubernetes ConfigMaps, KeyValue buckets, etc), + /// the error message is a string. + upstream(string), + /// This indicates an error from an I/O operation. + /// As this could be almost _anything_ (such as a file read, network connection, etc), + /// the error message is a string. + /// Depending on how this ends up being consumed, + /// we may consider moving this to use the `wasi:io/error` type instead. + /// For simplicity right now in supporting multiple implementations, it is being left as a string. + io(string), + } + + /// Gets a configuration value of type `string` associated with the `key`. + /// + /// The value is returned as an `option`. If the key is not found, + /// `Ok(none)` is returned. If an error occurs, an `Err(error)` is returned. + get: func( + /// A string key to fetch + key: string + ) -> result, error>; + + /// Gets a list of configuration key-value pairs of type `string`. + /// + /// If an error occurs, an `Err(error)` is returned. + get-all: func() -> result>, error>; +} diff --git a/test-components/scheduled-invocation/wit-deps/config/world.wit b/test-components/scheduled-invocation/wit-deps/config/world.wit new file mode 100644 index 0000000000..f92f080a57 --- /dev/null +++ b/test-components/scheduled-invocation/wit-deps/config/world.wit @@ -0,0 +1,6 @@ +package wasi:config@0.2.0-draft; + +world imports { + /// The interface for wasi:config/store + import store; +} \ No newline at end of file diff --git a/test-components/scheduled-invocation/wit-deps/deps.lock b/test-components/scheduled-invocation/wit-deps/deps.lock index f9076e4884..3933395b22 100644 --- a/test-components/scheduled-invocation/wit-deps/deps.lock +++ b/test-components/scheduled-invocation/wit-deps/deps.lock @@ -1,57 +1,61 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/v1.2.0.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" -deps = ["blobstore", "cli", "clocks", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] +deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] [blobstore] -sha256 = "eb50ec776eac937b2ef90b41a281d0dd7c94f0b076466d917bd0f2ed5b01d39d" -sha512 = "b40613b47a8ba236a7b3ff85cb7e3c5b8f665a6c359fc539ca01f0b2170538a47c80eb991df8f4d5ca162f4dc6e0ca4311e23ad5ce88b85b30570dedf78fcffe" +sha256 = "f7857c92a8d540ebfe10c9ac3b8cfe160d2303ca638d59aec3c18406e084d367" +sha512 = "af647a1c40672c4b2b970b2f99de54d404e35b4aed430b00395d708dcec74eb6f03543b65605a90a1dbc3db5dbf1887b2b6ae9b6c6306475d119b312b4e91868" [cli] -sha256 = "285865a31d777181b075f39e92bcfe59c89cd6bacce660be1b9a627646956258" -sha512 = "da2622210a9e3eea82b99f1a5b8a44ce5443d009cb943f7bca0bf9cf4360829b289913d7ee727c011f0f72994ea7dc8e661ebcc0a6b34b587297d80cd9b3f7e8" +sha256 = "4dadd13d55aaf626833d1f4b9c34a17b0f04e993babd09552b785cda3b95ea76" +sha512 = "898dcc4e8c15d18acc6b88dbe232336fa4d19019430a910dbc9e7aeaace3077a164af3be9f002de6e7e65ef693df340801ac0c7e421e9a746bf1b6d698a90835" [clocks] -sha256 = "468b4d12892fe926b8eb5d398dbf579d566c93231fa44f415440572c695b7613" -sha512 = "e6b53a07221f1413953c9797c68f08b815fdaebf66419bbc1ea3e8b7dece73731062693634731f311a03957b268cf9cc509c518bd15e513c318aa04a8459b93a" +sha256 = "93a701968a7dd3c5d69031bc0601681c468972fdf7e28a93bb6150a67d6ebe8b" +sha512 = "98fca567c7a01887b0fb38981f1772169b6ea8de475b546508f8b86738d84e44ba95cae81def40ac34e8809f5f60e85224077ab8cb6d6d5d6296acc1df73c159" + +[config] +sha256 = "31fe247a242af7abe32dfadcb4edbc7720f9c47c2bff34b7e5c75df915ab5eb9" +sha512 = "ce5367f3a104843852236799a3386a44da12ee5e287eb94075fd5252c1400b6ef84438f3b3e19f75fb3d842d82fe3a1bc999385fe59fc8e1696fed69bad69eac" [filesystem] -sha256 = "498c465cfd04587db40f970fff2185daa597d074c20b68a8bcbae558f261499b" -sha512 = "ead452f9b7bfb88593a502ec00d76d4228003d51c40fd0408aebc32d35c94673551b00230d730873361567cc209ec218c41fb4e95bad194268592c49e7964347" +sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" +sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "2787c96144b95a334a8abed873b8231e286126691337ff05c37318d71b462972" -sha512 = "442a5f8cb59fd715520fd7ebdaf2823d9a83b493db4493039237997cd277f8e519a72228322cce352c0d2ce6327bcbda383331c8923d9a6a00e4edce3a12bff6" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] -sha256 = "b0d068502eb2a9a0ae7100ec33ba67ffc1133d26ce6868950e7cdfa48cef0f68" -sha512 = "1db57e4d5e183ea900906c10b32781e79e7d6871b1f302f1cd52e9545388b9e473ae4427369a0e1e32ea5fb2bee62f2f41eba2cda579c96afc91c68eaee1cc4d" +sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" +sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "8e19b68aef0362c2f18d19b8f41de60420af930c5b34be21c3f8c057903f7c5e" -sha512 = "4738cfbb11abc962a340cea6d7a6237a48af245c0661bfbd4e8a16e4bc9034daf4abd3d535ae081009408be776b83e4edc7c728585dd2a682ef866efc86ffa78" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] -sha256 = "8f44402bde16c48e28c47dc53eab0b26af5b3b3482a1852cf77673e0880ba1c1" -sha512 = "760695f9a25c25bf75a25b731cb21c3bda9e288e450edda823324ecbc73d5d798bbb5de2edad999566980836f037463ee9e57d61789d04b3f3e381475b1a9a0f" +sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" +sha512 = "636150c464c0eb3d60bd212fc5d4012638c8cd4f89b583b87a38154ef99de828aac4296ac13c5cface10ee61e164fcfc43a5c104f916229dfdf49c0d11047677" [io] -sha256 = "5a3b0b9774ad733d4fa144a694018b03158c21e6168234e81ed02d49a78ef9cb" -sha512 = "f88e836b2264b7a0ec8e51b79420331c42b4973ccc283c556802103e0b6a8daa5ecdf00bd984851fe52db07e703d75c1970c5fba1614b6c990d97734cad22d67" +sha256 = "1cccbfe4122686ea57a25cd368e8cdfc408cbcad089f47fb6685b6f92e96f050" +sha512 = "7a95f964c13da52611141acd89bc8876226497f128e99dd176a4270c5b5efbd8cc847b5fbd1a91258d028c646db99e0424d72590cf1caf20f9f3a3343fad5017" [keyvalue] -sha256 = "efceed91e17be50f52681ef73043f54298e2f11b48a5befdcbc92a7aea941bed" -sha512 = "b019a3333c6dadbab8c067085a5110566cfb7c3f3d9a65d482ccdac85a62eb0bdfed0ca1bbf7dafabf622ca0c6cf39b865cc234412bcbb2ff1290386cda031fa" +sha256 = "0b37334713ee32ddbf6c064ddc3fe8e5b730ff63b6381b45c87aa07a6ec700ca" +sha512 = "1ec372a657a2a9f602e781846984febfdc7c34c3dc8a2c83d5b282f5580edd1d556478bbbb2a34e97c618a03b05fcc1059d6f4a01dc27176f5e5702e5173507e" [logging] sha256 = "7fb7216c713fd329ec91bb596127a1b95eec26290290b6de0c1ef294fba858c2" sha512 = "ceb68410bb46176051b0eee54e1a60831ca2fe820892c5f5f739e76efd4fe6ee6dc5e307947e7118b68a2a757ed3a3b471d16eb0900bb9040de47fef4bf1b56f" [random] -sha256 = "7371d03c037d924caba2587fb2e7c5773a0d3c5fcecbf7971e0e0ba57973c53d" -sha512 = "964c4e8925a53078e4d94ba907b54f89a0b7e154f46823a505391471466c17f53c8692682e5c85771712acd88b348686173fc07c53a3cfe3d301b8cd8ddd0de4" +sha256 = "dd0c91e7125172eb8fd4568e15ad9fc7305643015e6ece4396c3cc5e8c2bf79a" +sha512 = "d1ca2e7b0616a94a3b39d1b9450bb3fb595b01fd94a8626ad75433038dde40988ecb41ab93a374d569ab72163af3b30038d7bfc3499b9c07193181f4f1d9292a" [sockets] -sha256 = "b0869b7cbbaea1410308cd379207f5841db5e30f1e1c1d9fe0582b560b668f24" -sha512 = "198a7bcf4d405b7761e1b5a0a94cdd1e144adb0c6cfbe2b64e380d377de5ac3171a4cf3f840b81ff2ef54be990c95c121f48910796228c0f54b0c3c6e973e317" +sha256 = "2bc0f65a8046207ee3330ad7d63f6fafeafd4cc0ea4084f081bd5e4f7b177e74" +sha512 = "3e5490e41547dffa78d52631825d93da8d60f4af0246cbaf97e1ecb879285953a86d5f1f390b10c32f91dd7eaec6f43e625a26b1c92c32a0c86fde428aedaaab" diff --git a/test-components/scheduled-invocation/wit-deps/deps.toml b/test-components/scheduled-invocation/wit-deps/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/scheduled-invocation/wit-deps/deps.toml +++ b/test-components/scheduled-invocation/wit-deps/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/scheduled-invocation/wit-deps/filesystem/preopens.wit b/test-components/scheduled-invocation/wit-deps/filesystem/preopens.wit index da801f6d60..cea97495b5 100644 --- a/test-components/scheduled-invocation/wit-deps/filesystem/preopens.wit +++ b/test-components/scheduled-invocation/wit-deps/filesystem/preopens.wit @@ -1,8 +1,11 @@ -package wasi:filesystem@0.2.0; +package wasi:filesystem@0.2.3; +@since(version = 0.2.0) interface preopens { + @since(version = 0.2.0) use types.{descriptor}; - /// Return the set of preopened directories, and their path. + /// Return the set of preopened directories, and their paths. + @since(version = 0.2.0) get-directories: func() -> list>; } diff --git a/test-components/scheduled-invocation/wit-deps/filesystem/types.wit b/test-components/scheduled-invocation/wit-deps/filesystem/types.wit index 11108fcda2..d229a21f48 100644 --- a/test-components/scheduled-invocation/wit-deps/filesystem/types.wit +++ b/test-components/scheduled-invocation/wit-deps/filesystem/types.wit @@ -1,4 +1,4 @@ -package wasi:filesystem@0.2.0; +package wasi:filesystem@0.2.3; /// WASI filesystem is a filesystem API primarily intended to let users run WASI /// programs that access their files on their existing filesystems, without /// significant overhead. @@ -23,16 +23,21 @@ package wasi:filesystem@0.2.0; /// [WASI filesystem path resolution]. /// /// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md +@since(version = 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}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream, output-stream, error}; + @since(version = 0.2.0) + use wasi:clocks/wall-clock@0.2.3.{datetime}; /// File size or length of a region within a file. + @since(version = 0.2.0) type filesize = u64; /// The type of a filesystem object referenced by a descriptor. /// /// Note: This was called `filetype` in earlier versions of WASI. + @since(version = 0.2.0) enum descriptor-type { /// The type of the descriptor or file is unknown or is different from /// any of the other types specified. @@ -56,6 +61,7 @@ interface types { /// Descriptor flags. /// /// Note: This was called `fdflags` in earlier versions of WASI. + @since(version = 0.2.0) flags descriptor-flags { /// Read mode: Data can be read. read, @@ -77,7 +83,7 @@ interface types { /// WASI. At this time, it should be interpreted as a request, and not a /// requirement. data-integrity-sync, - /// Requests that reads be performed at the same level of integrety + /// Requests that reads be performed at the same level of integrity /// requested for writes. This is similar to `O_RSYNC` in POSIX. /// /// The precise semantics of this operation have not yet been defined for @@ -99,6 +105,7 @@ interface types { /// File attributes. /// /// Note: This was called `filestat` in earlier versions of WASI. + @since(version = 0.2.0) record descriptor-stat { /// File type. %type: descriptor-type, @@ -125,6 +132,7 @@ interface types { } /// Flags determining the method of how paths are resolved. + @since(version = 0.2.0) flags path-flags { /// As long as the resolved path corresponds to a symbolic link, it is /// expanded. @@ -132,6 +140,7 @@ interface types { } /// Open flags used by `open-at`. + @since(version = 0.2.0) flags open-flags { /// Create file if it does not exist, similar to `O_CREAT` in POSIX. create, @@ -144,9 +153,11 @@ interface types { } /// Number of hard links to an inode. + @since(version = 0.2.0) type link-count = u64; /// When setting a timestamp, this gives the value to set it to. + @since(version = 0.2.0) variant new-timestamp { /// Leave the timestamp set to its previous value. no-change, @@ -248,6 +259,7 @@ interface types { } /// File or memory access pattern advisory information. + @since(version = 0.2.0) enum advice { /// The application has no advice to give on its behavior with respect /// to the specified data. @@ -271,6 +283,7 @@ interface types { /// A 128-bit hash value, split into parts because wasm doesn't have a /// 128-bit integer type. + @since(version = 0.2.0) record metadata-hash-value { /// 64 bits of a 128-bit hash value. lower: u64, @@ -281,6 +294,7 @@ interface types { /// A descriptor is a reference to a filesystem object, which may be a file, /// directory, named pipe, special file, or other object on which filesystem /// calls may be made. + @since(version = 0.2.0) resource descriptor { /// Return a stream for reading from a file, if available. /// @@ -290,6 +304,7 @@ interface types { /// file and they do not interfere with each other. /// /// Note: This allows using `read-stream`, which is similar to `read` in POSIX. + @since(version = 0.2.0) read-via-stream: func( /// The offset within the file at which to start reading. offset: filesize, @@ -301,6 +316,7 @@ interface types { /// /// Note: This allows using `write-stream`, which is similar to `write` in /// POSIX. + @since(version = 0.2.0) write-via-stream: func( /// The offset within the file at which to start writing. offset: filesize, @@ -311,12 +327,14 @@ interface types { /// May fail with an error-code describing why the file cannot be appended. /// /// Note: This allows using `write-stream`, which is similar to `write` with - /// `O_APPEND` in in POSIX. + /// `O_APPEND` in POSIX. + @since(version = 0.2.0) append-via-stream: func() -> result; /// Provide file advisory information on a descriptor. /// /// This is similar to `posix_fadvise` in POSIX. + @since(version = 0.2.0) advise: func( /// The offset within the file to which the advisory applies. offset: filesize, @@ -332,6 +350,7 @@ interface types { /// opened for writing. /// /// Note: This is similar to `fdatasync` in POSIX. + @since(version = 0.2.0) sync-data: func() -> result<_, error-code>; /// Get flags associated with a descriptor. @@ -340,6 +359,7 @@ interface types { /// /// Note: This returns the value that was the `fs_flags` value returned /// from `fdstat_get` in earlier versions of WASI. + @since(version = 0.2.0) get-flags: func() -> result; /// Get the dynamic type of a descriptor. @@ -352,12 +372,14 @@ interface types { /// /// Note: This returns the value that was the `fs_filetype` value returned /// from `fdstat_get` in earlier versions of WASI. + @since(version = 0.2.0) get-type: func() -> result; /// Adjust the size of an open file. If this increases the file's size, the /// extra bytes are filled with zeros. /// /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI. + @since(version = 0.2.0) set-size: func(size: filesize) -> result<_, error-code>; /// Adjust the timestamps of an open file or directory. @@ -365,6 +387,7 @@ interface types { /// Note: This is similar to `futimens` in POSIX. /// /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI. + @since(version = 0.2.0) set-times: func( /// The desired values of the data access timestamp. data-access-timestamp: new-timestamp, @@ -383,6 +406,7 @@ interface types { /// In the future, this may change to return a `stream`. /// /// Note: This is similar to `pread` in POSIX. + @since(version = 0.2.0) read: func( /// The maximum number of bytes to read. length: filesize, @@ -399,6 +423,7 @@ interface types { /// In the future, this may change to take a `stream`. /// /// Note: This is similar to `pwrite` in POSIX. + @since(version = 0.2.0) write: func( /// Data to write buffer: list, @@ -415,6 +440,7 @@ interface types { /// This always returns a new stream which starts at the beginning of the /// directory. Multiple streams may be active on the same directory, and they /// do not interfere with each other. + @since(version = 0.2.0) read-directory: func() -> result; /// Synchronize the data and metadata of a file to disk. @@ -423,11 +449,13 @@ interface types { /// opened for writing. /// /// Note: This is similar to `fsync` in POSIX. + @since(version = 0.2.0) sync: func() -> result<_, error-code>; /// Create a directory. /// /// Note: This is similar to `mkdirat` in POSIX. + @since(version = 0.2.0) create-directory-at: func( /// The relative path at which to create the directory. path: string, @@ -442,6 +470,7 @@ interface types { /// modified, use `metadata-hash`. /// /// Note: This was called `fd_filestat_get` in earlier versions of WASI. + @since(version = 0.2.0) stat: func() -> result; /// Return the attributes of a file or directory. @@ -451,6 +480,7 @@ interface types { /// discussion of alternatives. /// /// Note: This was called `path_filestat_get` in earlier versions of WASI. + @since(version = 0.2.0) stat-at: func( /// Flags determining the method of how the path is resolved. path-flags: path-flags, @@ -464,6 +494,7 @@ interface types { /// /// Note: This was called `path_filestat_set_times` in earlier versions of /// WASI. + @since(version = 0.2.0) set-times-at: func( /// Flags determining the method of how the path is resolved. path-flags: path-flags, @@ -478,6 +509,7 @@ interface types { /// Create a hard link. /// /// Note: This is similar to `linkat` in POSIX. + @since(version = 0.2.0) link-at: func( /// Flags determining the method of how the path is resolved. old-path-flags: path-flags, @@ -491,12 +523,6 @@ interface types { /// Open a file or directory. /// - /// The returned descriptor is not guaranteed to be the lowest-numbered - /// descriptor not currently open/ it is randomized to prevent applications - /// from depending on making assumptions about indexes, since this is - /// error-prone in multi-threaded contexts. The returned descriptor is - /// guaranteed to be less than 2**31. - /// /// If `flags` contains `descriptor-flags::mutate-directory`, and the base /// descriptor doesn't have `descriptor-flags::mutate-directory` set, /// `open-at` fails with `error-code::read-only`. @@ -507,6 +533,7 @@ interface types { /// `error-code::read-only`. /// /// Note: This is similar to `openat` in POSIX. + @since(version = 0.2.0) open-at: func( /// Flags determining the method of how the path is resolved. path-flags: path-flags, @@ -524,6 +551,7 @@ interface types { /// filesystem, this function fails with `error-code::not-permitted`. /// /// Note: This is similar to `readlinkat` in POSIX. + @since(version = 0.2.0) readlink-at: func( /// The relative path of the symbolic link from which to read. path: string, @@ -534,6 +562,7 @@ interface types { /// Return `error-code::not-empty` if the directory is not empty. /// /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX. + @since(version = 0.2.0) remove-directory-at: func( /// The relative path to a directory to remove. path: string, @@ -542,6 +571,7 @@ interface types { /// Rename a filesystem object. /// /// Note: This is similar to `renameat` in POSIX. + @since(version = 0.2.0) rename-at: func( /// The relative source path of the file or directory to rename. old-path: string, @@ -557,6 +587,7 @@ interface types { /// `error-code::not-permitted`. /// /// Note: This is similar to `symlinkat` in POSIX. + @since(version = 0.2.0) symlink-at: func( /// The contents of the symbolic link. old-path: string, @@ -568,6 +599,7 @@ interface types { /// /// Return `error-code::is-directory` if the path refers to a directory. /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX. + @since(version = 0.2.0) unlink-file-at: func( /// The relative path to a file to unlink. path: string, @@ -579,6 +611,7 @@ interface types { /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers. /// wasi-filesystem does not expose device and inode numbers, so this function /// may be used instead. + @since(version = 0.2.0) is-same-object: func(other: borrow) -> bool; /// Return a hash of the metadata associated with a filesystem object referred @@ -590,7 +623,7 @@ interface types { /// replaced. It may also include a secret value chosen by the /// implementation and not otherwise exposed. /// - /// Implementations are encourated to provide the following properties: + /// Implementations are encouraged to provide the following properties: /// /// - If the file is not modified or replaced, the computed hash value should /// usually not change. @@ -600,12 +633,14 @@ interface types { /// computed hash. /// /// However, none of these is required. + @since(version = 0.2.0) metadata-hash: func() -> result; /// Return a hash of the metadata associated with a filesystem object referred /// to by a directory descriptor and a relative path. /// /// This performs the same hash computation as `metadata-hash`. + @since(version = 0.2.0) metadata-hash-at: func( /// Flags determining the method of how the path is resolved. path-flags: path-flags, @@ -615,8 +650,10 @@ interface types { } /// A stream of directory entries. + @since(version = 0.2.0) resource directory-entry-stream { /// Read a single directory entry from a `directory-entry-stream`. + @since(version = 0.2.0) read-directory-entry: func() -> result, error-code>; } @@ -630,5 +667,6 @@ interface types { /// /// Note that this function is fallible because not all stream-related /// errors are filesystem-related errors. + @since(version = 0.2.0) filesystem-error-code: func(err: borrow) -> option; } diff --git a/test-components/scheduled-invocation/wit-deps/filesystem/world.wit b/test-components/scheduled-invocation/wit-deps/filesystem/world.wit index 663f57920d..29405bc2cc 100644 --- a/test-components/scheduled-invocation/wit-deps/filesystem/world.wit +++ b/test-components/scheduled-invocation/wit-deps/filesystem/world.wit @@ -1,6 +1,9 @@ -package wasi:filesystem@0.2.0; +package wasi:filesystem@0.2.3; +@since(version = 0.2.0) world imports { + @since(version = 0.2.0) import types; + @since(version = 0.2.0) import preopens; } diff --git a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-context.wit b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-context.wit index 5137bc6489..54f1484c35 100644 --- a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-context.wit +++ b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-context.wit @@ -1,8 +1,8 @@ -package golem:api@1.1.6; +package golem:api@1.1.7; /// Invocation context support interface context { - use wasi:clocks/wall-clock@0.2.0.{datetime}; + use wasi:clocks/wall-clock@0.2.3.{datetime}; /// Starts a new `span` with the given name, as a child of the current invocation context start-span: func(name: string) -> span; diff --git a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-host.wit b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-host.wit index 74782eb966..80cbe329a0 100644 --- a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-host.wit +++ b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-host.wit @@ -1,10 +1,10 @@ -package golem:api@1.1.6; +package golem:api@1.1.7; /// The Golem host API provides low level access to Golem specific features such as promises and control over /// the durability and transactional guarantees the executor provides. interface host { - use wasi:clocks/monotonic-clock@0.2.0.{duration}; - use golem:rpc/types@0.2.0.{component-id, uuid, worker-id}; + use wasi:clocks/monotonic-clock@0.2.3.{duration}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -24,6 +24,11 @@ interface host { value: string } + /// Represents a Golem project + record project-id { + uuid: uuid, + } + /// Configures how the executor retries failures record retry-policy { /// The maximum number of retries before the worker becomes permanently failed @@ -116,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -136,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 @@ -155,6 +168,14 @@ interface host { revert-last-invocations(u64) } + /// Indicates which worker the code is running on after `fork` + enum fork-result { + /// The original worker that called `fork` + original, + /// The new worker + forked + } + /// Create a new promise create-promise: func() -> promise-id; @@ -256,6 +277,11 @@ interface host { /// Get the worker-id for a given component and worker name. /// Returns none when no component for the specified component-reference or no worker with the specified worker-name exists. resolve-worker-id-strict: func(component-reference: string, worker-name: string) -> option; + + /// Forks the current worker at the current execution point. The new worker gets the `new-name` worker name, + /// and this worker continues running as well. The return value is going to be different in this worker and + /// the forked worker. + fork: func(new-name: string) -> fork-result; } /// Interface providing user-defined snapshotting capability. This can be used to perform manual update of workers diff --git a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog-processor.wit b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog-processor.wit index 8a8ffda77d..2c910fe303 100644 --- a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog-processor.wit +++ b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog-processor.wit @@ -1,12 +1,12 @@ -package golem:api@1.1.6; +package golem:api@1.1.7; interface oplog-processor { - use wasi:clocks/wall-clock@0.2.0.{datetime}; - use golem:rpc/types@0.2.0.{wit-value}; + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use golem:rpc/types@0.2.2.{wit-value}; use host.{account-id, oplog-index, worker-metadata}; use oplog.{oplog-entry}; - use golem:rpc/types@0.2.0.{component-id, worker-id}; + use golem:rpc/types@0.2.2.{component-id, worker-id}; record account-info { account-id: account-id diff --git a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog.wit b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog.wit index b742c6cc79..fd06f8f001 100644 --- a/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog.wit +++ b/test-components/scheduled-invocation/wit-deps/golem-1.x/golem-oplog.wit @@ -1,11 +1,11 @@ -package golem:api@1.1.6; +package golem:api@1.1.7; /// Host interface for enumerating and searching for worker oplogs interface oplog { - use wasi:clocks/wall-clock@0.2.0.{datetime}; - use golem:rpc/types@0.2.0.{wit-value}; + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use golem:rpc/types@0.2.2.{wit-value}; - use host.{account-id, component-version, oplog-index, retry-policy, uuid, worker-id}; + use host.{account-id, component-version, oplog-index, persistence-level, project-id, retry-policy, uuid, worker-id}; use context.{attribute, attribute-value, span-id, trace-id}; variant wrapped-function-type { @@ -41,7 +41,8 @@ interface oplog { component-version: component-version, args: list, env: list>, - account-id: account-id, + created-by: account-id, + project-id: project-id, parent: option, component-size: u64, initial-total-linear-memory-size: u64, @@ -89,7 +90,7 @@ interface oplog { record exported-function-completed-parameters { timestamp: datetime, - response: wit-value, + response: option, consumed-fuel: s64 } @@ -244,6 +245,11 @@ interface oplog { value: attribute-value } + record change-persistence-level-parameters { + timestamp: datetime, + persistence-level: persistence-level + } + variant oplog-entry { /// The initial worker oplog entry create(create-parameters), @@ -319,6 +325,8 @@ interface oplog { finish-span(finish-span-parameters), /// Set an attribute on an open span in the invocation context set-span-attribute(set-span-attribute-parameters), + /// Change the current persistence level + change-persistence-level(change-persistence-level-parameters) } resource get-oplog { diff --git a/test-components/scheduled-invocation/wit-deps/golem-durability/golem-durability-1.2.wit b/test-components/scheduled-invocation/wit-deps/golem-durability/golem-durability-1.2.wit index da2815e491..b4f661d9f7 100644 --- a/test-components/scheduled-invocation/wit-deps/golem-durability/golem-durability-1.2.wit +++ b/test-components/scheduled-invocation/wit-deps/golem-durability/golem-durability-1.2.wit @@ -1,10 +1,11 @@ -package golem:durability@1.2.0; +package golem:durability@1.2.1; interface durability { - use golem:api/host@1.1.6.{persistence-level}; - use golem:api/oplog@1.1.6.{oplog-index, wrapped-function-type}; - use wasi:clocks/wall-clock@0.2.0.{datetime}; - use golem:rpc/types@0.2.0.{value-and-type}; + use golem:api/host@1.1.7.{persistence-level}; + use golem:api/oplog@1.1.7.{oplog-index, wrapped-function-type}; + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use wasi:io/poll@0.2.3.{pollable}; + use golem:rpc/types@0.2.2.{value-and-type}; type durable-function-type = wrapped-function-type; @@ -26,6 +27,14 @@ interface durability { entry-version: oplog-entry-version } + record persisted-typed-durable-function-invocation { + timestamp: datetime, + function-name: string, + response: value-and-type, + function-type: durable-function-type, + entry-version: oplog-entry-version + } + /// Observes a function call (produces logs and metrics) observe-function-call: func(iface: string, function: string); @@ -71,4 +80,19 @@ interface durability { /// Reads the next persisted durable function invocation from the oplog during replay read-persisted-durable-function-invocation: func() -> persisted-durable-function-invocation; + + /// Reads the next persisted durable function invocation from the oplog during replay, assuming it + /// was created with `persist-typed-durable-function-invocation` + read-persisted-typed-durable-function-invocation: func() -> persisted-typed-durable-function-invocation; + + resource lazy-initialized-pollable { + /// Creates a `pollable` that is never ready until it gets attached to a real `pollable` implementation + /// using `set-lazy-initialized-pollable`. + constructor(); + + /// Sets the underlying `pollable` for a pollable created with `create-lazy-initialized-pollable`. + set: func(pollable: pollable); + + subscribe: func() -> pollable; + } } diff --git a/test-components/scheduled-invocation/wit-deps/golem-rpc/wasm-rpc.wit b/test-components/scheduled-invocation/wit-deps/golem-rpc/wasm-rpc.wit index d81e19e2dd..372919b05c 100644 --- a/test-components/scheduled-invocation/wit-deps/golem-rpc/wasm-rpc.wit +++ b/test-components/scheduled-invocation/wit-deps/golem-rpc/wasm-rpc.wit @@ -1,8 +1,8 @@ -package golem:rpc@0.2.0; +package golem:rpc@0.2.2; interface types { - use wasi:clocks/wall-clock@0.2.0.{datetime}; - use wasi:io/poll@0.2.0.{pollable}; + use wasi:clocks/wall-clock@0.2.3.{datetime}; + use wasi:io/poll@0.2.3.{pollable}; /// Represents a Golem worker record worker-id { @@ -59,7 +59,7 @@ interface types { } record wit-type { - nodes: list, + nodes: list, } type resource-id = u64; @@ -69,6 +69,12 @@ interface types { borrowed } + record named-wit-type-node { + name: option, + owner: option, + %type: wit-type-node + } + variant wit-type-node { record-type(list>), variant-type(list>>), diff --git a/test-components/scheduled-invocation/wit-deps/http/handler.wit b/test-components/scheduled-invocation/wit-deps/http/handler.wit index a34a0649d5..6a6c62966f 100644 --- a/test-components/scheduled-invocation/wit-deps/http/handler.wit +++ b/test-components/scheduled-invocation/wit-deps/http/handler.wit @@ -1,6 +1,8 @@ /// This interface defines a handler of incoming HTTP Requests. It should /// be exported by components which can respond to HTTP Requests. +@since(version = 0.2.0) interface incoming-handler { + @since(version = 0.2.0) use types.{incoming-request, response-outparam}; /// This function is invoked with an incoming HTTP Request, and a resource @@ -13,6 +15,7 @@ interface incoming-handler { /// 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. + @since(version = 0.2.0) handle: func( request: incoming-request, response-out: response-outparam @@ -21,7 +24,9 @@ interface incoming-handler { /// This interface defines a handler of outgoing HTTP Requests. It should be /// imported by components which wish to make HTTP Requests. +@since(version = 0.2.0) interface outgoing-handler { + @since(version = 0.2.0) use types.{ outgoing-request, request-options, future-incoming-response, error-code }; @@ -36,6 +41,7 @@ interface outgoing-handler { /// 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`. + @since(version = 0.2.0) handle: func( request: outgoing-request, options: option diff --git a/test-components/scheduled-invocation/wit-deps/http/proxy.wit b/test-components/scheduled-invocation/wit-deps/http/proxy.wit index 687c24d233..de3bbe8ae0 100644 --- a/test-components/scheduled-invocation/wit-deps/http/proxy.wit +++ b/test-components/scheduled-invocation/wit-deps/http/proxy.wit @@ -1,32 +1,50 @@ -package wasi:http@0.2.0; +package wasi:http@0.2.3; -/// 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 { +/// The `wasi:http/imports` world imports all the APIs for HTTP proxies. +/// It is intended to be `include`d in other worlds. +@since(version = 0.2.0) +world imports { /// HTTP proxies have access to time and randomness. - include wasi:clocks/imports@0.2.0; - import wasi:random/random@0.2.0; + @since(version = 0.2.0) + import wasi:clocks/monotonic-clock@0.2.3; + @since(version = 0.2.0) + import wasi:clocks/wall-clock@0.2.3; + @since(version = 0.2.0) + import wasi:random/random@0.2.3; /// Proxies have standard output and error streams which are expected to /// terminate in a developer-facing console provided by the host. - import wasi:cli/stdout@0.2.0; - import wasi:cli/stderr@0.2.0; + @since(version = 0.2.0) + import wasi:cli/stdout@0.2.3; + @since(version = 0.2.0) + import wasi:cli/stderr@0.2.3; /// TODO: this is a temporary workaround until component tooling is able to /// gracefully handle the absence of stdin. Hosts must return an eof stream /// for this import, which is what wasi-libc + tooling will do automatically /// when this import is properly removed. - import wasi:cli/stdin@0.2.0; + @since(version = 0.2.0) + import wasi:cli/stdin@0.2.3; /// This is the default handler to use when user code simply wants to make an /// HTTP request (e.g., via `fetch()`). + @since(version = 0.2.0) import outgoing-handler; +} + +/// 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. +@since(version = 0.2.0) +world proxy { + @since(version = 0.2.0) + include imports; /// The host delivers incoming HTTP requests to a component by calling the /// `handle` function of this exported interface. A host may arbitrarily reuse /// or not reuse component instance when delivering incoming HTTP requests and /// thus a component must be able to handle 0..N calls to `handle`. + @since(version = 0.2.0) export incoming-handler; } diff --git a/test-components/scheduled-invocation/wit-deps/http/types.wit b/test-components/scheduled-invocation/wit-deps/http/types.wit index 755ac6a6bc..2498f180ad 100644 --- a/test-components/scheduled-invocation/wit-deps/http/types.wit +++ b/test-components/scheduled-invocation/wit-deps/http/types.wit @@ -1,13 +1,19 @@ /// 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. +@since(version = 0.2.0) 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}; + @since(version = 0.2.0) + use wasi:clocks/monotonic-clock@0.2.3.{duration}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream, output-stream}; + @since(version = 0.2.0) + use wasi:io/error@0.2.3.{error as io-error}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; /// This type corresponds to HTTP standard Methods. + @since(version = 0.2.0) variant method { get, head, @@ -22,6 +28,7 @@ interface types { } /// This type corresponds to HTTP standard Related Schemes. + @since(version = 0.2.0) variant scheme { HTTP, HTTPS, @@ -29,7 +36,8 @@ interface types { } /// 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 + /// + @since(version = 0.2.0) variant error-code { DNS-timeout, DNS-error(DNS-error-payload), @@ -78,18 +86,21 @@ interface types { } /// Defines the case payload type for `DNS-error` above: + @since(version = 0.2.0) record DNS-error-payload { rcode: option, info-code: option } /// Defines the case payload type for `TLS-alert-received` above: + @since(version = 0.2.0) record TLS-alert-received-payload { alert-id: option, alert-message: option } /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above: + @since(version = 0.2.0) record field-size-payload { field-name: option, field-size: option @@ -106,17 +117,19 @@ interface types { /// /// Note that this function is fallible because not all io-errors are /// http-related errors. + @since(version = 0.2.0) http-error-code: func(err: borrow) -> option; /// This type enumerates the different kinds of errors that may occur when /// setting or appending to a `fields` resource. + @since(version = 0.2.0) variant header-error { - /// This error indicates that a `field-key` or `field-value` was + /// This error indicates that a `field-name` 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 + /// This error indicates that a forbidden `field-name` was used when trying /// to set a header in a `fields`. forbidden, @@ -125,12 +138,29 @@ interface types { immutable, } + /// Field names are always strings. + /// + /// Field names should always be treated as case insensitive by the `fields` + /// resource for the purposes of equality checking. + @since(version = 0.2.1) + type field-name = field-key; + /// Field keys are always strings. + /// + /// Field keys should always be treated as case insensitive by the `fields` + /// resource for the purposes of equality checking. + /// + /// # Deprecation + /// + /// This type has been deprecated in favor of the `field-name` type. + @since(version = 0.2.0) + @deprecated(version = 0.2.2) 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. + @since(version = 0.2.0) type field-value = list; /// This following block defines the `fields` resource which corresponds to @@ -143,93 +173,120 @@ interface types { /// `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`. + @since(version = 0.2.0) resource fields { /// Construct an empty HTTP Fields. /// /// The resulting `fields` is mutable. + @since(version = 0.2.0) constructor(); /// Construct an HTTP Fields. /// /// The resulting `fields` is mutable. /// - /// The list represents each key-value pair in the Fields. Keys + /// The list represents each name-value pair in the Fields. Names /// which have multiple values are represented by multiple entries in this - /// list with the same key. + /// list with the same name. /// - /// 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. + /// The tuple is a pair of the field name, represented as a string, and + /// Value, represented as a list of bytes. /// - /// An error result will be returned if any header or value was - /// syntactically invalid, or if a header was forbidden. + /// An error result will be returned if any `field-name` or `field-value` is + /// syntactically invalid, or if a field is forbidden. + @since(version = 0.2.0) from-list: static func( - entries: list> + 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; + /// Get all of the values corresponding to a name. If the name is not present + /// in this `fields` or is syntactically invalid, an empty list is returned. + /// However, if the name is present but empty, this is represented by a list + /// with one or more empty field-values present. + @since(version = 0.2.0) + get: func(name: field-name) -> list; - /// Returns `true` when the key is present in this `fields`. If the key is + /// Returns `true` when the name is present in this `fields`. If the name is /// syntactically invalid, `false` is returned. - has: func(name: field-key) -> bool; + @since(version = 0.2.0) + has: func(name: field-name) -> bool; - /// Set all of the values for a key. Clears any existing values for that - /// key, if they have been set. + /// Set all of the values for a name. Clears any existing values for that + /// name, 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>; + /// + /// Fails with `header-error.invalid-syntax` if the `field-name` or any of + /// the `field-value`s are syntactically invalid. + @since(version = 0.2.0) + set: func(name: field-name, value: list) -> result<_, header-error>; - /// Delete all values for a key. Does nothing if no values for the key + /// Delete all values for a name. Does nothing if no values for the name /// exist. /// /// Fails with `header-error.immutable` if the `fields` are immutable. - delete: func(name: field-key) -> result<_, header-error>; + /// + /// Fails with `header-error.invalid-syntax` if the `field-name` is + /// syntactically invalid. + @since(version = 0.2.0) + delete: func(name: field-name) -> result<_, header-error>; - /// Append a value for a key. Does not change or delete any existing - /// values for that key. + /// Append a value for a name. Does not change or delete any existing + /// values for that name. /// /// Fails with `header-error.immutable` if the `fields` are immutable. - append: func(name: field-key, value: field-value) -> result<_, header-error>; + /// + /// Fails with `header-error.invalid-syntax` if the `field-name` or + /// `field-value` are syntactically invalid. + @since(version = 0.2.0) + append: func(name: field-name, 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. + /// Retrieve the full set of names and values in the Fields. Like the + /// constructor, the list represents each name-value pair. /// - /// The outer list represents each key-value pair in the Fields. Keys + /// The outer list represents each name-value pair in the Fields. Names /// which have multiple values are represented by multiple entries in this - /// list with the same key. - entries: func() -> list>; + /// list with the same name. + /// + /// The names and values are always returned in the original casing and in + /// the order in which they will be serialized for transport. + @since(version = 0.2.0) + entries: func() -> list>; - /// Make a deep copy of the Fields. Equivelant in behavior to calling the + /// Make a deep copy of the Fields. Equivalent in behavior to calling the /// `fields` constructor on the return value of `entries`. The resulting /// `fields` is mutable. + @since(version = 0.2.0) clone: func() -> fields; } /// Headers is an alias for Fields. + @since(version = 0.2.0) type headers = fields; /// Trailers is an alias for Fields. + @since(version = 0.2.0) type trailers = fields; /// Represents an incoming HTTP Request. + @since(version = 0.2.0) resource incoming-request { /// Returns the method of the incoming request. + @since(version = 0.2.0) method: func() -> method; /// Returns the path with query parameters from the request, as a string. + @since(version = 0.2.0) path-with-query: func() -> option; /// Returns the protocol scheme from the request. + @since(version = 0.2.0) scheme: func() -> option; - /// Returns the authority from the request, if it was present. + /// Returns the authority of the Request's target URI, if present. + @since(version = 0.2.0) authority: func() -> option; /// Get the `headers` associated with the request. @@ -240,14 +297,17 @@ interface types { /// 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. + @since(version = 0.2.0) headers: func() -> headers; /// Gives the `incoming-body` associated with this request. Will only /// return success at most once, and subsequent calls will return error. + @since(version = 0.2.0) consume: func() -> result; } /// Represents an outgoing HTTP Request. + @since(version = 0.2.0) resource outgoing-request { /// Construct a new `outgoing-request` with a default `method` of `GET`, and @@ -260,6 +320,7 @@ interface types { /// 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`. + @since(version = 0.2.0) constructor( headers: headers ); @@ -270,38 +331,47 @@ interface types { /// 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. + @since(version = 0.2.0) body: func() -> result; /// Get the Method for the Request. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) 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 + /// Get the authority of the Request's target URI. 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. + @since(version = 0.2.0) 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 + /// Set the authority of the Request's target URI. 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. + /// not a syntactically valid URI authority. + @since(version = 0.2.0) set-authority: func(authority: option) -> result; /// Get the headers associated with the Request. @@ -310,8 +380,9 @@ interface types { /// `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 + /// `outgoing-request` is dropped, or its ownership is transferred to /// another component by e.g. `outgoing-handler.handle`. + @since(version = 0.2.0) headers: func() -> headers; } @@ -321,31 +392,39 @@ interface types { /// /// These timeouts are separate from any the user may use to bound a /// blocking call to `wasi:io/poll.poll`. + @since(version = 0.2.0) resource request-options { /// Construct a default `request-options` value. + @since(version = 0.2.0) constructor(); /// The timeout for the initial connect to the HTTP Server. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) set-connect-timeout: func(duration: option) -> result; /// The timeout for receiving the first byte of the Response body. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) set-first-byte-timeout: func(duration: option) -> result; /// The timeout for receiving subsequent chunks of bytes in the Response /// body stream. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) set-between-bytes-timeout: func(duration: option) -> result; } @@ -354,6 +433,7 @@ interface types { /// 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`. + @since(version = 0.2.0) resource response-outparam { /// Set the value of the `response-outparam` to either send a response, @@ -365,6 +445,7 @@ interface types { /// /// The user may provide an `error` to `response` to allow the /// implementation determine how to respond with an HTTP error response. + @since(version = 0.2.0) set: static func( param: response-outparam, response: result, @@ -372,12 +453,15 @@ interface types { } /// This type corresponds to the HTTP standard Status Code. + @since(version = 0.2.0) type status-code = u16; /// Represents an incoming HTTP Response. + @since(version = 0.2.0) resource incoming-response { /// Returns the status code from the incoming response. + @since(version = 0.2.0) status: func() -> status-code; /// Returns the headers from the incoming response. @@ -387,10 +471,12 @@ interface types { /// /// This headers resource is a child: it must be dropped before the parent /// `incoming-response` is dropped. + @since(version = 0.2.0) headers: func() -> headers; /// Returns the incoming body. May be called at most once. Returns error /// if called additional times. + @since(version = 0.2.0) consume: func() -> result; } @@ -402,6 +488,7 @@ interface types { /// 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. + @since(version = 0.2.0) resource incoming-body { /// Returns the contents of the body, as a stream of bytes. @@ -419,26 +506,30 @@ interface types { /// 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. + @since(version = 0.2.0) %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. + @since(version = 0.2.0) finish: static func(this: incoming-body) -> future-trailers; } - /// Represents a future which may eventaully return trailers, or an error. + /// Represents a future which may eventually 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. + @since(version = 0.2.0) 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, + /// been received, or an error has occurred. When this pollable is ready, /// the `get` method will return `some`. + @since(version = 0.2.0) subscribe: func() -> pollable; - /// Returns the contents of the trailers, or an error which occured, + /// Returns the contents of the trailers, or an error which occurred, /// once the future is ready. /// /// The outer `option` represents future readiness. Users can wait on this @@ -450,17 +541,19 @@ interface types { /// /// 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 + /// error occurred 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. + @since(version = 0.2.0) get: func() -> option, error-code>>>; } /// Represents an outgoing HTTP Response. + @since(version = 0.2.0) resource outgoing-response { /// Construct an `outgoing-response`, with a default `status-code` of `200`. @@ -468,13 +561,16 @@ interface types { /// `set-status-code` method. /// /// * `headers` is the HTTP Headers for the Response. + @since(version = 0.2.0) constructor(headers: headers); /// Get the HTTP Status Code for the Response. + @since(version = 0.2.0) 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. + @since(version = 0.2.0) set-status-code: func(status-code: status-code) -> result; /// Get the headers associated with the Request. @@ -483,8 +579,9 @@ interface types { /// `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 + /// `outgoing-request` is dropped, or its ownership is transferred to /// another component by e.g. `outgoing-handler.handle`. + @since(version = 0.2.0) headers: func() -> headers; /// Returns the resource corresponding to the outgoing Body for this Response. @@ -492,6 +589,7 @@ interface types { /// 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. + @since(version = 0.2.0) body: func() -> result; } @@ -507,10 +605,11 @@ interface types { /// /// 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 + /// and that an error has occurred. The implementation should propagate 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. + @since(version = 0.2.0) resource outgoing-body { /// Returns a stream for writing the body contents. @@ -522,6 +621,7 @@ interface types { /// 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. + @since(version = 0.2.0) write: func() -> result; /// Finalize an outgoing body, optionally providing trailers. This must be @@ -533,21 +633,24 @@ interface types { /// 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. + @since(version = 0.2.0) finish: static func( this: outgoing-body, trailers: option ) -> result<_, error-code>; } - /// Represents a future which may eventaully return an incoming HTTP + /// Represents a future which may eventually 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. + @since(version = 0.2.0) 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, + /// been received, or an error has occurred. When this pollable is ready, /// the `get` method will return `some`. + @since(version = 0.2.0) subscribe: func() -> pollable; /// Returns the incoming HTTP Response, or an error, once one is ready. @@ -560,11 +663,11 @@ interface types { /// 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, + /// status and headers have received successfully, or that an error + /// occurred. Errors may also occur while consuming the response body, /// but those will be reported by the `incoming-body` and its /// `output-stream` child. + @since(version = 0.2.0) get: func() -> option>>; - } } diff --git a/test-components/scheduled-invocation/wit-deps/io/error.wit b/test-components/scheduled-invocation/wit-deps/io/error.wit index 22e5b64894..97c6068779 100644 --- a/test-components/scheduled-invocation/wit-deps/io/error.wit +++ b/test-components/scheduled-invocation/wit-deps/io/error.wit @@ -1,6 +1,6 @@ -package wasi:io@0.2.0; - +package wasi:io@0.2.3; +@since(version = 0.2.0) interface error { /// A resource which represents some error information. /// @@ -11,16 +11,15 @@ interface error { /// `wasi:io/streams/stream-error` type. /// /// To provide more specific error information, other interfaces may - /// provide functions to further "downcast" this error into more specific - /// error information. For example, `error`s returned in streams derived - /// from filesystem types to be described using the filesystem's own - /// error-code type, using the function - /// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter - /// `borrow` and returns - /// `option`. + /// offer functions to "downcast" this error into more specific types. For example, + /// errors returned from streams derived from filesystem types can be described using + /// the filesystem's own error-code type. This is done using the function + /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow` + /// parameter and returns an `option`. /// /// The set of functions which can "downcast" an `error` into a more /// concrete type is open. + @since(version = 0.2.0) resource error { /// Returns a string that is suitable to assist humans in debugging /// this error. @@ -29,6 +28,7 @@ interface error { /// It may change across platforms, hosts, or other implementation /// details. Parsing this string is a major platform-compatibility /// hazard. + @since(version = 0.2.0) to-debug-string: func() -> string; } } diff --git a/test-components/scheduled-invocation/wit-deps/io/poll.wit b/test-components/scheduled-invocation/wit-deps/io/poll.wit index c982f1af76..9bcbe8e036 100644 --- a/test-components/scheduled-invocation/wit-deps/io/poll.wit +++ b/test-components/scheduled-invocation/wit-deps/io/poll.wit @@ -1,14 +1,17 @@ -package wasi:io@0.2.0; +package wasi:io@0.2.3; /// A poll API intended to let users wait for I/O events on multiple handles /// at once. +@since(version = 0.2.0) interface poll { - /// `pollable` epresents a single I/O event which may be ready, or not. + /// `pollable` represents a single I/O event which may be ready, or not. + @since(version = 0.2.0) resource pollable { /// Return the readiness of a pollable. This function never blocks. /// /// Returns `true` when the pollable is ready, and `false` otherwise. + @since(version = 0.2.0) ready: func() -> bool; /// `block` returns immediately if the pollable is ready, and otherwise @@ -16,6 +19,7 @@ interface poll { /// /// This function is equivalent to calling `poll.poll` on a list /// containing only this pollable. + @since(version = 0.2.0) block: func(); } @@ -27,8 +31,9 @@ interface poll { /// The result `list` contains one or more indices of handles in the /// argument list that is ready for I/O. /// - /// If the list contains more elements than can be indexed with a `u32` - /// value, this function traps. + /// This function traps if either: + /// - the list is empty, or: + /// - the list contains more elements than can be indexed with a `u32` value. /// /// A timeout can be implemented by adding a pollable from the /// wasi-clocks API to the list. @@ -36,6 +41,7 @@ interface poll { /// This function does not return a `result`; polling in itself does not /// do any I/O so it doesn't fail. If any of the I/O sources identified by /// the pollables has an error, it is indicated by marking the source as - /// being reaedy for I/O. + /// being ready for I/O. + @since(version = 0.2.0) poll: func(in: list>) -> list; } diff --git a/test-components/scheduled-invocation/wit-deps/io/streams.wit b/test-components/scheduled-invocation/wit-deps/io/streams.wit index c797e37ffb..0de0846293 100644 --- a/test-components/scheduled-invocation/wit-deps/io/streams.wit +++ b/test-components/scheduled-invocation/wit-deps/io/streams.wit @@ -1,19 +1,26 @@ -package wasi:io@0.2.0; +package wasi:io@0.2.3; /// WASI I/O is an I/O abstraction API which is currently focused on providing /// stream types. /// /// In the future, the component model is expected to add built-in stream types; /// when it does, they are expected to subsume this API. +@since(version = 0.2.0) interface streams { + @since(version = 0.2.0) use error.{error}; + @since(version = 0.2.0) use poll.{pollable}; /// An error for input-stream and output-stream operations. + @since(version = 0.2.0) variant stream-error { /// The last operation (a write or flush) failed before completion. /// /// More information is available in the `error` payload. + /// + /// After this, the stream will be closed. All future operations return + /// `stream-error::closed`. last-operation-failed(error), /// The stream is closed: no more input will be accepted by the /// stream. A closed output-stream will return this error on all @@ -29,9 +36,15 @@ interface streams { /// available, which could even be zero. To wait for data to be available, /// use the `subscribe` function to obtain a `pollable` which can be polled /// for using `wasi:io/poll`. + @since(version = 0.2.0) resource input-stream { /// Perform a non-blocking read from the stream. /// + /// When the source of a `read` is binary data, the bytes from the source + /// are returned verbatim. When the source of a `read` is known to the + /// implementation to be text, bytes containing the UTF-8 encoding of the + /// text are returned. + /// /// This function returns a list of bytes containing the read data, /// when successful. The returned list will contain up to `len` bytes; /// it may return fewer than requested, but not more. The list is @@ -51,6 +64,7 @@ interface streams { /// is not possible to allocate in wasm32, or not desirable to allocate as /// as a return value by the callee. The callee may return a list of bytes /// less than `len` in size while more bytes are available for reading. + @since(version = 0.2.0) read: func( /// The maximum number of bytes to read len: u64 @@ -58,6 +72,7 @@ interface streams { /// Read bytes from a stream, after blocking until at least one byte can /// be read. Except for blocking, behavior is identical to `read`. + @since(version = 0.2.0) blocking-read: func( /// The maximum number of bytes to read len: u64 @@ -67,6 +82,7 @@ interface streams { /// /// Behaves identical to `read`, except instead of returning a list /// of bytes, returns the number of bytes consumed from the stream. + @since(version = 0.2.0) skip: func( /// The maximum number of bytes to skip. len: u64, @@ -74,6 +90,7 @@ interface streams { /// Skip bytes from a stream, after blocking until at least one byte /// can be skipped. Except for blocking behavior, identical to `skip`. + @since(version = 0.2.0) blocking-skip: func( /// The maximum number of bytes to skip. len: u64, @@ -85,6 +102,7 @@ interface streams { /// The created `pollable` is a child resource of the `input-stream`. /// Implementations may trap if the `input-stream` is dropped before /// all derived `pollable`s created with this function are dropped. + @since(version = 0.2.0) subscribe: func() -> pollable; } @@ -97,6 +115,11 @@ interface streams { /// promptly, which could even be zero. To wait for the stream to be ready to /// accept data, the `subscribe` function to obtain a `pollable` which can be /// polled for using `wasi:io/poll`. + /// + /// Dropping an `output-stream` while there's still an active write in + /// progress may result in the data being lost. Before dropping the stream, + /// be sure to fully flush your writes. + @since(version = 0.2.0) resource output-stream { /// Check readiness for writing. This function never blocks. /// @@ -107,15 +130,23 @@ interface streams { /// When this function returns 0 bytes, the `subscribe` pollable will /// become ready when this function will report at least 1 byte, or an /// error. + @since(version = 0.2.0) check-write: func() -> result; /// Perform a write. This function never blocks. /// + /// When the destination of a `write` is binary data, the bytes from + /// `contents` are written verbatim. When the destination of a `write` is + /// known to the implementation to be text, the bytes of `contents` are + /// transcoded from UTF-8 into the encoding of the destination and then + /// written. + /// /// Precondition: check-write gave permit of Ok(n) and contents has a /// length of less than or equal to n. Otherwise, this function will trap. /// /// returns Err(closed) without writing if the stream has closed since /// the last call to check-write provided a permit. + @since(version = 0.2.0) write: func( contents: list ) -> result<_, stream-error>; @@ -131,7 +162,7 @@ interface streams { /// let pollable = this.subscribe(); /// while !contents.is_empty() { /// // Wait for the stream to become writable - /// poll-one(pollable); + /// pollable.block(); /// let Ok(n) = this.check-write(); // eliding error handling /// let len = min(n, contents.len()); /// let (chunk, rest) = contents.split_at(len); @@ -140,10 +171,11 @@ interface streams { /// } /// this.flush(); /// // Wait for completion of `flush` - /// poll-one(pollable); + /// pollable.block(); /// // Check for any errors that arose during `flush` /// let _ = this.check-write(); // eliding error handling /// ``` + @since(version = 0.2.0) blocking-write-and-flush: func( contents: list ) -> result<_, stream-error>; @@ -158,14 +190,16 @@ interface streams { /// writes (`check-write` will return `ok(0)`) until the flush has /// completed. The `subscribe` pollable will become ready when the /// flush has completed and the stream can accept more writes. + @since(version = 0.2.0) flush: func() -> result<_, stream-error>; /// Request to flush buffered output, and block until flush completes /// and stream is ready for writing again. + @since(version = 0.2.0) blocking-flush: func() -> result<_, stream-error>; /// Create a `pollable` which will resolve once the output-stream - /// is ready for more writing, or an error has occured. When this + /// is ready for more writing, or an error has occurred. When this /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an /// error. /// @@ -174,14 +208,16 @@ interface streams { /// The created `pollable` is a child resource of the `output-stream`. /// Implementations may trap if the `output-stream` is dropped before /// all derived `pollable`s created with this function are dropped. + @since(version = 0.2.0) subscribe: func() -> pollable; /// Write zeroes to a stream. /// - /// this should be used precisely like `write` with the exact same + /// This should be used precisely like `write` with the exact same /// preconditions (must use check-write first), but instead of /// passing a list of bytes, you simply pass the number of zero-bytes /// that should be written. + @since(version = 0.2.0) write-zeroes: func( /// The number of zero-bytes to write len: u64 @@ -199,7 +235,7 @@ interface streams { /// let pollable = this.subscribe(); /// while num_zeroes != 0 { /// // Wait for the stream to become writable - /// poll-one(pollable); + /// pollable.block(); /// let Ok(n) = this.check-write(); // eliding error handling /// let len = min(n, num_zeroes); /// this.write-zeroes(len); // eliding error handling @@ -207,10 +243,11 @@ interface streams { /// } /// this.flush(); /// // Wait for completion of `flush` - /// poll-one(pollable); + /// pollable.block(); /// // Check for any errors that arose during `flush` /// let _ = this.check-write(); // eliding error handling /// ``` + @since(version = 0.2.0) blocking-write-zeroes-and-flush: func( /// The number of zero-bytes to write len: u64 @@ -218,7 +255,7 @@ interface streams { /// Read from one stream and write to another. /// - /// The behavior of splice is equivelant to: + /// The behavior of splice is equivalent to: /// 1. calling `check-write` on the `output-stream` /// 2. calling `read` on the `input-stream` with the smaller of the /// `check-write` permitted length and the `len` provided to `splice` @@ -229,6 +266,7 @@ interface streams { /// /// This function returns the number of bytes transferred; it may be less /// than `len`. + @since(version = 0.2.0) splice: func( /// The stream to read from src: borrow, @@ -241,6 +279,7 @@ interface streams { /// This is similar to `splice`, except that it blocks until the /// `output-stream` is ready for writing, and the `input-stream` /// is ready for reading, before performing the `splice`. + @since(version = 0.2.0) blocking-splice: func( /// The stream to read from src: borrow, diff --git a/test-components/scheduled-invocation/wit-deps/io/world.wit b/test-components/scheduled-invocation/wit-deps/io/world.wit index 5f0b43fe50..f1d2102dca 100644 --- a/test-components/scheduled-invocation/wit-deps/io/world.wit +++ b/test-components/scheduled-invocation/wit-deps/io/world.wit @@ -1,6 +1,10 @@ -package wasi:io@0.2.0; +package wasi:io@0.2.3; +@since(version = 0.2.0) world imports { + @since(version = 0.2.0) import streams; + + @since(version = 0.2.0) import poll; } diff --git a/test-components/scheduled-invocation/wit-deps/keyvalue/caching.wit b/test-components/scheduled-invocation/wit-deps/keyvalue/caching.wit index 8235527a23..5880362a8c 100644 --- a/test-components/scheduled-invocation/wit-deps/keyvalue/caching.wit +++ b/test-components/scheduled-invocation/wit-deps/keyvalue/caching.wit @@ -11,7 +11,7 @@ // Time-to-Live values (within the usual limitations around time in a // distributed setting). interface cache { - use wasi:io/poll@0.2.0.{pollable}; + use wasi:io/poll@0.2.3.{pollable}; use types.{key, incoming-value, outgoing-value, error}; // The `get` operation returns the value passed by a previous `set` for the @@ -95,4 +95,4 @@ interface cache { // Additionally, due to weak ordering, concurrent `set` calls for the same // key may or may not get deleted. delete: func(k: key) -> future-result; -} \ No newline at end of file +} diff --git a/test-components/scheduled-invocation/wit-deps/keyvalue/types.wit b/test-components/scheduled-invocation/wit-deps/keyvalue/types.wit index ba3416b0e0..81ee803c0f 100644 --- a/test-components/scheduled-invocation/wit-deps/keyvalue/types.wit +++ b/test-components/scheduled-invocation/wit-deps/keyvalue/types.wit @@ -18,7 +18,7 @@ interface types { // Soon: switch to `resource bucket { ... }` resource bucket { /// Opens a bucket with the given name. - /// + /// /// If any error occurs, including if the bucket does not exist, it returns an `Err(error)`. open-bucket: static func(name: string) -> result; } @@ -26,7 +26,7 @@ interface types { /// retrieve the value from the bucket. type key = string; - use wasi:io/streams@0.2.0.{input-stream, output-stream}; + use wasi:io/streams@0.2.3.{input-stream, output-stream}; use wasi-keyvalue-error.{ error }; /// A value is the data stored in a key-value pair. The value can be of any type /// that can be represented in a byte array. It provides a way to write the value @@ -69,4 +69,4 @@ interface types { } type incoming-value-async-body = input-stream; type incoming-value-sync-body = list; -} \ No newline at end of file +} diff --git a/test-components/scheduled-invocation/wit-deps/random/insecure-seed.wit b/test-components/scheduled-invocation/wit-deps/random/insecure-seed.wit index 47210ac6bd..67d024d5bf 100644 --- a/test-components/scheduled-invocation/wit-deps/random/insecure-seed.wit +++ b/test-components/scheduled-invocation/wit-deps/random/insecure-seed.wit @@ -1,8 +1,9 @@ -package wasi:random@0.2.0; +package wasi:random@0.2.3; /// The insecure-seed interface for seeding hash-map DoS resistance. /// /// It is intended to be portable at least between Unix-family platforms and /// Windows. +@since(version = 0.2.0) interface insecure-seed { /// Return a 128-bit value that may contain a pseudo-random value. /// @@ -21,5 +22,6 @@ interface insecure-seed { /// This will likely be changed to a value import, to prevent it from being /// called multiple times and potentially used for purposes other than DoS /// protection. + @since(version = 0.2.0) insecure-seed: func() -> tuple; } diff --git a/test-components/scheduled-invocation/wit-deps/random/insecure.wit b/test-components/scheduled-invocation/wit-deps/random/insecure.wit index c58f4ee852..a07dfab327 100644 --- a/test-components/scheduled-invocation/wit-deps/random/insecure.wit +++ b/test-components/scheduled-invocation/wit-deps/random/insecure.wit @@ -1,8 +1,9 @@ -package wasi:random@0.2.0; +package wasi:random@0.2.3; /// The insecure interface for insecure pseudo-random numbers. /// /// It is intended to be portable at least between Unix-family platforms and /// Windows. +@since(version = 0.2.0) interface insecure { /// Return `len` insecure pseudo-random bytes. /// @@ -12,11 +13,13 @@ interface insecure { /// There are no requirements on the values of the returned bytes, however /// implementations are encouraged to return evenly distributed values with /// a long period. + @since(version = 0.2.0) get-insecure-random-bytes: func(len: u64) -> list; /// Return an insecure pseudo-random `u64` value. /// /// This function returns the same type of pseudo-random data as /// `get-insecure-random-bytes`, represented as a `u64`. + @since(version = 0.2.0) get-insecure-random-u64: func() -> u64; } diff --git a/test-components/scheduled-invocation/wit-deps/random/random.wit b/test-components/scheduled-invocation/wit-deps/random/random.wit index 0c017f0934..91957e6330 100644 --- a/test-components/scheduled-invocation/wit-deps/random/random.wit +++ b/test-components/scheduled-invocation/wit-deps/random/random.wit @@ -1,8 +1,9 @@ -package wasi:random@0.2.0; +package wasi:random@0.2.3; /// WASI Random is a random data API. /// /// It is intended to be portable at least between Unix-family platforms and /// Windows. +@since(version = 0.2.0) interface random { /// Return `len` cryptographically-secure random or pseudo-random bytes. /// @@ -16,11 +17,13 @@ interface random { /// This function must always return fresh data. Deterministic environments /// must omit this function, rather than implementing it with deterministic /// data. + @since(version = 0.2.0) get-random-bytes: func(len: u64) -> list; /// Return a cryptographically-secure random or pseudo-random `u64` value. /// /// This function returns the same type of data as `get-random-bytes`, /// represented as a `u64`. + @since(version = 0.2.0) get-random-u64: func() -> u64; } diff --git a/test-components/scheduled-invocation/wit-deps/random/world.wit b/test-components/scheduled-invocation/wit-deps/random/world.wit index 3da34914a4..0c1218f36e 100644 --- a/test-components/scheduled-invocation/wit-deps/random/world.wit +++ b/test-components/scheduled-invocation/wit-deps/random/world.wit @@ -1,7 +1,13 @@ -package wasi:random@0.2.0; +package wasi:random@0.2.3; +@since(version = 0.2.0) world imports { + @since(version = 0.2.0) import random; + + @since(version = 0.2.0) import insecure; + + @since(version = 0.2.0) import insecure-seed; } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/instance-network.wit b/test-components/scheduled-invocation/wit-deps/sockets/instance-network.wit index e455d0ff7b..5f6e6c1cc9 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/instance-network.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/instance-network.wit @@ -1,9 +1,11 @@ /// This interface provides a value-export of the default network handle.. +@since(version = 0.2.0) interface instance-network { + @since(version = 0.2.0) use network.{network}; /// Get a handle to the default network. + @since(version = 0.2.0) instance-network: func() -> network; - } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/ip-name-lookup.wit b/test-components/scheduled-invocation/wit-deps/sockets/ip-name-lookup.wit index 8e639ec596..c1d8a47c16 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/ip-name-lookup.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/ip-name-lookup.wit @@ -1,9 +1,10 @@ - +@since(version = 0.2.0) interface ip-name-lookup { - use wasi:io/poll@0.2.0.{pollable}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + @since(version = 0.2.0) use network.{network, error-code, ip-address}; - /// Resolve an internet host name to a list of IP addresses. /// /// Unicode domain names are automatically converted to ASCII using IDNA encoding. @@ -24,8 +25,10 @@ interface ip-name-lookup { /// - /// - /// - + @since(version = 0.2.0) resolve-addresses: func(network: borrow, name: string) -> result; + @since(version = 0.2.0) resource resolve-address-stream { /// Returns the next address from the resolver. /// @@ -40,12 +43,14 @@ interface ip-name-lookup { /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN) /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL) /// - `would-block`: A result is not available yet. (EWOULDBLOCK, EAGAIN) + @since(version = 0.2.0) resolve-next-address: func() -> result, error-code>; /// Create a `pollable` which will resolve once the stream is ready for I/O. /// - /// Note: this function is here for WASI Preview2 only. + /// Note: this function is here for WASI 0.2 only. /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) subscribe: func() -> pollable; } } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/network.wit b/test-components/scheduled-invocation/wit-deps/sockets/network.wit index 9cadf0650a..f3f60a3709 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/network.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/network.wit @@ -1,8 +1,12 @@ - +@since(version = 0.2.0) interface network { + @unstable(feature = network-error-code) + use wasi:io/error@0.2.3.{error}; + /// An opaque resource that represents access to (a subset of) the network. /// This enables context-based security for networking. /// There is no need for this to map 1:1 to a physical network interface. + @since(version = 0.2.0) resource network; /// Error codes. @@ -17,6 +21,7 @@ interface network { /// - `concurrency-conflict` /// /// See each individual API for what the POSIX equivalents are. They sometimes differ per API. + @since(version = 0.2.0) enum error-code { /// Unknown error unknown, @@ -103,6 +108,20 @@ interface network { permanent-resolver-failure, } + /// Attempts to extract a network-related `error-code` from the stream + /// `error` provided. + /// + /// Stream operations which return `stream-error::last-operation-failed` + /// have a payload with more information about the operation that failed. + /// This payload can be passed through to this function to see if there's + /// network-related information about the error to return. + /// + /// Note that this function is fallible because not all stream-related + /// errors are network-related errors. + @unstable(feature = network-error-code) + network-error-code: func(err: borrow) -> option; + + @since(version = 0.2.0) enum ip-address-family { /// Similar to `AF_INET` in POSIX. ipv4, @@ -111,14 +130,18 @@ interface network { ipv6, } + @since(version = 0.2.0) type ipv4-address = tuple; + @since(version = 0.2.0) type ipv6-address = tuple; + @since(version = 0.2.0) variant ip-address { ipv4(ipv4-address), ipv6(ipv6-address), } + @since(version = 0.2.0) record ipv4-socket-address { /// sin_port port: u16, @@ -126,6 +149,7 @@ interface network { address: ipv4-address, } + @since(version = 0.2.0) record ipv6-socket-address { /// sin6_port port: u16, @@ -137,9 +161,9 @@ interface network { scope-id: u32, } + @since(version = 0.2.0) variant ip-socket-address { ipv4(ipv4-socket-address), ipv6(ipv6-socket-address), } - } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/tcp-create-socket.wit b/test-components/scheduled-invocation/wit-deps/sockets/tcp-create-socket.wit index c7ddf1f228..eedbd30768 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/tcp-create-socket.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/tcp-create-socket.wit @@ -1,6 +1,8 @@ - +@since(version = 0.2.0) interface tcp-create-socket { + @since(version = 0.2.0) use network.{network, error-code, ip-address-family}; + @since(version = 0.2.0) use tcp.{tcp-socket}; /// Create a new TCP socket. @@ -23,5 +25,6 @@ interface tcp-create-socket { /// - /// - /// - + @since(version = 0.2.0) create-tcp-socket: func(address-family: ip-address-family) -> result; } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/tcp.wit b/test-components/scheduled-invocation/wit-deps/sockets/tcp.wit index fbe023b648..b4cd87fcef 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/tcp.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/tcp.wit @@ -1,10 +1,15 @@ - +@since(version = 0.2.0) 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}; + @since(version = 0.2.0) + use wasi:io/streams@0.2.3.{input-stream, output-stream}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + @since(version = 0.2.0) + use wasi:clocks/monotonic-clock@0.2.3.{duration}; + @since(version = 0.2.0) use network.{network, error-code, ip-socket-address, ip-address-family}; + @since(version = 0.2.0) enum shutdown-type { /// Similar to `SHUT_RD` in POSIX. receive, @@ -15,9 +20,29 @@ interface tcp { /// Similar to `SHUT_RDWR` in POSIX. both, } - - - /// A TCP socket handle. + + /// A TCP socket resource. + /// + /// The socket can be in one of the following states: + /// - `unbound` + /// - `bind-in-progress` + /// - `bound` (See note below) + /// - `listen-in-progress` + /// - `listening` + /// - `connect-in-progress` + /// - `connected` + /// - `closed` + /// See + /// for more information. + /// + /// Note: Except where explicitly mentioned, whenever this documentation uses + /// the term "bound" without backticks it actually means: in the `bound` state *or higher*. + /// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`) + /// + /// In addition to the general error codes documented on the + /// `network::error-code` type, TCP socket methods may always return + /// `error(invalid-state)` when in the `closed` state. + @since(version = 0.2.0) resource tcp-socket { /// Bind the socket to a specific network on the provided IP address and port. /// @@ -25,15 +50,16 @@ interface tcp { /// network interface(s) to bind to. /// If the TCP/UDP port is zero, the socket will be bound to a random free port. /// - /// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts. + /// Bind can be attempted multiple times on the same socket, even with + /// different arguments on each iteration. But never concurrently and + /// only as long as the previous bind failed. Once a bind succeeds, the + /// binding can't be changed anymore. /// - /// # Typical `start` errors + /// # Typical errors /// - `invalid-argument`: The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows) /// - `invalid-argument`: `local-address` is not a unicast address. (EINVAL) /// - `invalid-argument`: `local-address` is an IPv4-mapped IPv6 address. (EINVAL) /// - `invalid-state`: The socket is already bound. (EINVAL) - /// - /// # Typical `finish` errors /// - `address-in-use`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows) /// - `address-in-use`: Address is already in use. (EADDRINUSE) /// - `address-not-bindable`: `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL) @@ -46,80 +72,101 @@ interface tcp { /// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior /// and SO_REUSEADDR performs something different entirely. /// + /// Unlike in POSIX, in WASI the bind operation is async. This enables + /// interactive WASI hosts to inject permission prompts. Runtimes that + /// don't want to make use of this ability can simply call the native + /// `bind` as part of either `start-bind` or `finish-bind`. + /// /// # References /// - /// - /// - /// - + @since(version = 0.2.0) start-bind: func(network: borrow, local-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) finish-bind: func() -> result<_, error-code>; /// Connect to a remote endpoint. /// /// On success: - /// - the socket is transitioned into the Connection state + /// - the socket is transitioned into the `connected` state. /// - a pair of streams is returned that can be used to read & write to the connection /// - /// After a failed connection attempt, the only valid action left is to - /// `drop` the socket. A single socket can not be used to connect more than once. + /// After a failed connection attempt, the socket will be in the `closed` + /// state and the only valid action left is to `drop` the socket. A single + /// socket can not be used to connect more than once. /// - /// # Typical `start` errors + /// # Typical errors /// - `invalid-argument`: The `remote-address` has the wrong address family. (EAFNOSUPPORT) /// - `invalid-argument`: `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS) /// - `invalid-argument`: `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos) /// - `invalid-argument`: The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows) /// - `invalid-argument`: The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows) /// - `invalid-argument`: The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`. - /// - `invalid-state`: The socket is already in the Connection state. (EISCONN) - /// - `invalid-state`: The socket is already in the Listener state. (EOPNOTSUPP, EINVAL on Windows) - /// - /// # Typical `finish` errors + /// - `invalid-state`: The socket is already in the `connected` state. (EISCONN) + /// - `invalid-state`: The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows) /// - `timeout`: Connection timed out. (ETIMEDOUT) /// - `connection-refused`: The connection was forcefully rejected. (ECONNREFUSED) /// - `connection-reset`: The connection was reset. (ECONNRESET) /// - `connection-aborted`: The connection was aborted. (ECONNABORTED) /// - `remote-unreachable`: The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET) /// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD) - /// - `not-in-progress`: A `connect` operation is not in progress. + /// - `not-in-progress`: A connect operation is not in progress. /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) /// + /// # Implementors note + /// The POSIX equivalent of `start-connect` is the regular `connect` syscall. + /// Because all WASI sockets are non-blocking this is expected to return + /// EINPROGRESS, which should be translated to `ok()` in WASI. + /// + /// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT` + /// with a timeout of 0 on the socket descriptor. Followed by a check for + /// the `SO_ERROR` socket option, in case the poll signaled readiness. + /// /// # References /// - /// - /// - /// - + @since(version = 0.2.0) start-connect: func(network: borrow, remote-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) finish-connect: func() -> result, error-code>; /// Start listening for new connections. /// - /// Transitions the socket into the Listener state. + /// Transitions the socket into the `listening` state. /// - /// Unlike POSIX: - /// - this function is async. This enables interactive WASI hosts to inject permission prompts. - /// - the socket must already be explicitly bound. + /// Unlike POSIX, the socket must already be explicitly bound. /// - /// # Typical `start` errors + /// # Typical errors /// - `invalid-state`: The socket is not bound to any local address. (EDESTADDRREQ) - /// - `invalid-state`: The socket is already in the Connection state. (EISCONN, EINVAL on BSD) - /// - `invalid-state`: The socket is already in the Listener state. - /// - /// # Typical `finish` errors + /// - `invalid-state`: The socket is already in the `connected` state. (EISCONN, EINVAL on BSD) + /// - `invalid-state`: The socket is already in the `listening` state. /// - `address-in-use`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE) - /// - `not-in-progress`: A `listen` operation is not in progress. + /// - `not-in-progress`: A listen operation is not in progress. /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) /// + /// # Implementors note + /// Unlike in POSIX, in WASI the listen operation is async. This enables + /// interactive WASI hosts to inject permission prompts. Runtimes that + /// don't want to make use of this ability can simply call the native + /// `listen` as part of either `start-listen` or `finish-listen`. + /// /// # References /// - /// - /// - /// - + @since(version = 0.2.0) start-listen: func() -> result<_, error-code>; + @since(version = 0.2.0) finish-listen: func() -> result<_, error-code>; /// Accept a new client socket. /// - /// The returned socket is bound and in the Connection state. The following properties are inherited from the listener socket: + /// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket: /// - `address-family` /// - `keep-alive-enabled` /// - `keep-alive-idle-time` @@ -133,7 +180,7 @@ interface tcp { /// a pair of streams that can be used to read & write to the connection. /// /// # Typical errors - /// - `invalid-state`: Socket is not in the Listener state. (EINVAL) + /// - `invalid-state`: Socket is not in the `listening` state. (EINVAL) /// - `would-block`: No pending connections at the moment. (EWOULDBLOCK, EAGAIN) /// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED) /// - `new-socket-limit`: The new socket resource could not be created because of a system limit. (EMFILE, ENFILE) @@ -143,6 +190,7 @@ interface tcp { /// - /// - /// - + @since(version = 0.2.0) accept: func() -> result, error-code>; /// Get the bound local address. @@ -161,6 +209,7 @@ interface tcp { /// - /// - /// - + @since(version = 0.2.0) local-address: func() -> result; /// Get the remote address. @@ -173,16 +222,19 @@ interface tcp { /// - /// - /// - + @since(version = 0.2.0) remote-address: func() -> result; - /// Whether the socket is listening for new connections. + /// Whether the socket is in the `listening` state. /// /// Equivalent to the SO_ACCEPTCONN socket option. + @since(version = 0.2.0) is-listening: func() -> bool; /// Whether this is a IPv4 or IPv6 socket. /// /// Equivalent to the SO_DOMAIN socket option. + @since(version = 0.2.0) address-family: func() -> ip-address-family; /// Hints the desired listen queue size. Implementations are free to ignore this. @@ -193,7 +245,8 @@ interface tcp { /// # Typical errors /// - `not-supported`: (set) The platform does not support changing the backlog size after the initial listen. /// - `invalid-argument`: (set) The provided value was 0. - /// - `invalid-state`: (set) The socket is already in the Connection state. + /// - `invalid-state`: (set) The socket is in the `connect-in-progress` or `connected` state. + @since(version = 0.2.0) set-listen-backlog-size: func(value: u64) -> result<_, error-code>; /// Enables or disables keepalive. @@ -205,7 +258,9 @@ interface tcp { /// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true. /// /// Equivalent to the SO_KEEPALIVE socket option. + @since(version = 0.2.0) keep-alive-enabled: func() -> result; + @since(version = 0.2.0) set-keep-alive-enabled: func(value: bool) -> result<_, error-code>; /// Amount of time the connection has to be idle before TCP starts sending keepalive packets. @@ -218,7 +273,9 @@ interface tcp { /// /// # Typical errors /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) keep-alive-idle-time: func() -> result; + @since(version = 0.2.0) set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>; /// The time between keepalive packets. @@ -231,7 +288,9 @@ interface tcp { /// /// # Typical errors /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) keep-alive-interval: func() -> result; + @since(version = 0.2.0) set-keep-alive-interval: func(value: duration) -> result<_, error-code>; /// The maximum amount of keepalive packets TCP should send before aborting the connection. @@ -244,7 +303,9 @@ interface tcp { /// /// # Typical errors /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) keep-alive-count: func() -> result; + @since(version = 0.2.0) set-keep-alive-count: func(value: u32) -> result<_, error-code>; /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options. @@ -253,9 +314,9 @@ interface tcp { /// /// # Typical errors /// - `invalid-argument`: (set) The TTL value must be 1 or higher. - /// - `invalid-state`: (set) The socket is already in the Connection state. - /// - `invalid-state`: (set) The socket is already in the Listener state. + @since(version = 0.2.0) hop-limit: func() -> result; + @since(version = 0.2.0) set-hop-limit: func(value: u8) -> result<_, error-code>; /// The kernel buffer space reserved for sends/receives on this socket. @@ -268,17 +329,33 @@ interface tcp { /// /// # Typical errors /// - `invalid-argument`: (set) The provided value was 0. - /// - `invalid-state`: (set) The socket is already in the Connection state. - /// - `invalid-state`: (set) The socket is already in the Listener state. + @since(version = 0.2.0) receive-buffer-size: func() -> result; + @since(version = 0.2.0) set-receive-buffer-size: func(value: u64) -> result<_, error-code>; + @since(version = 0.2.0) send-buffer-size: func() -> result; + @since(version = 0.2.0) set-send-buffer-size: func(value: u64) -> result<_, error-code>; - /// Create a `pollable` which will resolve once the socket is ready for I/O. + /// Create a `pollable` which can be used to poll for, or block on, + /// completion of any of the asynchronous operations of this socket. + /// + /// When `finish-bind`, `finish-listen`, `finish-connect` or `accept` + /// return `error(would-block)`, this pollable can be used to wait for + /// their success or failure, after which the method can be retried. + /// + /// The pollable is not limited to the async operation that happens to be + /// in progress at the time of calling `subscribe` (if any). Theoretically, + /// `subscribe` only has to be called once per socket and can then be + /// (re)used for the remainder of the socket's lifetime. + /// + /// See + /// for more information. /// - /// Note: this function is here for WASI Preview2 only. + /// Note: this function is here for WASI 0.2 only. /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) subscribe: func() -> pollable; /// Initiate a graceful shutdown. @@ -291,19 +368,20 @@ interface tcp { /// associated with this socket will be closed and a FIN packet will be sent. /// - `both`: Same effect as `receive` & `send` combined. /// - /// This function is idempotent. Shutting a down a direction more than once + /// This function is idempotent; shutting down a direction more than once /// has no effect and returns `ok`. /// /// The shutdown function does not close (drop) the socket. /// /// # Typical errors - /// - `invalid-state`: The socket is not in the Connection state. (ENOTCONN) + /// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN) /// /// # References /// - /// - /// - /// - + @since(version = 0.2.0) shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>; } } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/udp-create-socket.wit b/test-components/scheduled-invocation/wit-deps/sockets/udp-create-socket.wit index 0482d1fe73..e8eeacbfef 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/udp-create-socket.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/udp-create-socket.wit @@ -1,6 +1,8 @@ - +@since(version = 0.2.0) interface udp-create-socket { + @since(version = 0.2.0) use network.{network, error-code, ip-address-family}; + @since(version = 0.2.0) use udp.{udp-socket}; /// Create a new UDP socket. @@ -23,5 +25,6 @@ interface udp-create-socket { /// - /// - /// - + @since(version = 0.2.0) create-udp-socket: func(address-family: ip-address-family) -> result; } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/udp.wit b/test-components/scheduled-invocation/wit-deps/sockets/udp.wit index b9826a6a54..01901ca27f 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/udp.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/udp.wit @@ -1,9 +1,12 @@ - +@since(version = 0.2.0) interface udp { - use wasi:io/poll@0.2.0.{pollable}; + @since(version = 0.2.0) + use wasi:io/poll@0.2.3.{pollable}; + @since(version = 0.2.0) use network.{network, error-code, ip-socket-address, ip-address-family}; /// A received datagram. + @since(version = 0.2.0) record incoming-datagram { /// The payload. /// @@ -19,6 +22,7 @@ interface udp { } /// A datagram to be sent out. + @since(version = 0.2.0) record outgoing-datagram { /// The payload. data: list, @@ -33,9 +37,8 @@ interface udp { remote-address: option, } - - /// A UDP socket handle. + @since(version = 0.2.0) resource udp-socket { /// Bind the socket to a specific network on the provided IP address and port. /// @@ -43,25 +46,29 @@ interface udp { /// network interface(s) to bind to. /// If the port is zero, the socket will be bound to a random free port. /// - /// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts. - /// - /// # Typical `start` errors + /// # Typical errors /// - `invalid-argument`: The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows) /// - `invalid-state`: The socket is already bound. (EINVAL) - /// - /// # Typical `finish` errors /// - `address-in-use`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows) /// - `address-in-use`: Address is already in use. (EADDRINUSE) /// - `address-not-bindable`: `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL) /// - `not-in-progress`: A `bind` operation is not in progress. /// - `would-block`: Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN) /// + /// # Implementors note + /// Unlike in POSIX, in WASI the bind operation is async. This enables + /// interactive WASI hosts to inject permission prompts. Runtimes that + /// don't want to make use of this ability can simply call the native + /// `bind` as part of either `start-bind` or `finish-bind`. + /// /// # References /// - /// - /// - /// - + @since(version = 0.2.0) start-bind: func(network: borrow, local-address: ip-socket-address) -> result<_, error-code>; + @since(version = 0.2.0) finish-bind: func() -> result<_, error-code>; /// Set up inbound & outbound communication channels, optionally to a specific peer. @@ -104,6 +111,7 @@ interface udp { /// - /// - /// - + @since(version = 0.2.0) %stream: func(remote-address: option) -> result, error-code>; /// Get the current bound address. @@ -122,6 +130,7 @@ interface udp { /// - /// - /// - + @since(version = 0.2.0) local-address: func() -> result; /// Get the address the socket is currently streaming to. @@ -134,11 +143,13 @@ interface udp { /// - /// - /// - + @since(version = 0.2.0) remote-address: func() -> result; /// Whether this is a IPv4 or IPv6 socket. /// /// Equivalent to the SO_DOMAIN socket option. + @since(version = 0.2.0) address-family: func() -> ip-address-family; /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options. @@ -147,7 +158,9 @@ interface udp { /// /// # Typical errors /// - `invalid-argument`: (set) The TTL value must be 1 or higher. + @since(version = 0.2.0) unicast-hop-limit: func() -> result; + @since(version = 0.2.0) set-unicast-hop-limit: func(value: u8) -> result<_, error-code>; /// The kernel buffer space reserved for sends/receives on this socket. @@ -160,18 +173,24 @@ interface udp { /// /// # Typical errors /// - `invalid-argument`: (set) The provided value was 0. + @since(version = 0.2.0) receive-buffer-size: func() -> result; + @since(version = 0.2.0) set-receive-buffer-size: func(value: u64) -> result<_, error-code>; + @since(version = 0.2.0) send-buffer-size: func() -> result; + @since(version = 0.2.0) set-send-buffer-size: func(value: u64) -> result<_, error-code>; /// Create a `pollable` which will resolve once the socket is ready for I/O. /// - /// Note: this function is here for WASI Preview2 only. + /// Note: this function is here for WASI 0.2 only. /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) subscribe: func() -> pollable; } + @since(version = 0.2.0) resource incoming-datagram-stream { /// Receive messages on the socket. /// @@ -196,15 +215,18 @@ interface udp { /// - /// - /// - + @since(version = 0.2.0) receive: func(max-results: u64) -> result, error-code>; /// Create a `pollable` which will resolve once the stream is ready to receive again. /// - /// Note: this function is here for WASI Preview2 only. + /// Note: this function is here for WASI 0.2 only. /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) subscribe: func() -> pollable; } + @since(version = 0.2.0) resource outgoing-datagram-stream { /// Check readiness for sending. This function never blocks. /// @@ -253,12 +275,14 @@ interface udp { /// - /// - /// - + @since(version = 0.2.0) send: func(datagrams: list) -> result; /// Create a `pollable` which will resolve once the stream is ready to send again. /// - /// Note: this function is here for WASI Preview2 only. + /// Note: this function is here for WASI 0.2 only. /// It's planned to be removed when `future` is natively supported in Preview3. + @since(version = 0.2.0) subscribe: func() -> pollable; } } diff --git a/test-components/scheduled-invocation/wit-deps/sockets/world.wit b/test-components/scheduled-invocation/wit-deps/sockets/world.wit index f8bb92ae04..2f0ad0d7c9 100644 --- a/test-components/scheduled-invocation/wit-deps/sockets/world.wit +++ b/test-components/scheduled-invocation/wit-deps/sockets/world.wit @@ -1,11 +1,19 @@ -package wasi:sockets@0.2.0; +package wasi:sockets@0.2.3; +@since(version = 0.2.0) world imports { + @since(version = 0.2.0) import instance-network; + @since(version = 0.2.0) import network; + @since(version = 0.2.0) import udp; + @since(version = 0.2.0) import udp-create-socket; + @since(version = 0.2.0) import tcp; + @since(version = 0.2.0) import tcp-create-socket; + @since(version = 0.2.0) import ip-name-lookup; } diff --git a/test-components/shopping-cart-resource.wasm b/test-components/shopping-cart-resource.wasm index eaa7f584f7..c84d9ea8f3 100755 Binary files a/test-components/shopping-cart-resource.wasm and b/test-components/shopping-cart-resource.wasm differ diff --git a/test-components/shopping-cart.wasm b/test-components/shopping-cart.wasm index e284df11f2..1f59df3421 100644 Binary files a/test-components/shopping-cart.wasm and b/test-components/shopping-cart.wasm differ diff --git a/test-components/shopping-cart/src/bindings.rs b/test-components/shopping-cart/src/bindings.rs index ab8ddcff4a..bf78d7be48 100644 --- a/test-components/shopping-cart/src/bindings.rs +++ b/test-components/shopping-cart/src/bindings.rs @@ -384,12 +384,31 @@ pub mod golem { } } #[derive(Clone)] + pub struct WorkerWasiConfigVarsFilter { + pub name: _rt::String, + pub comparator: StringFilterComparator, + pub value: _rt::String, + } + impl ::core::fmt::Debug for WorkerWasiConfigVarsFilter { + fn fmt( + &self, + f: &mut ::core::fmt::Formatter<'_>, + ) -> ::core::fmt::Result { + f.debug_struct("WorkerWasiConfigVarsFilter") + .field("name", &self.name) + .field("comparator", &self.comparator) + .field("value", &self.value) + .finish() + } + } + #[derive(Clone)] pub enum WorkerPropertyFilter { Name(WorkerNameFilter), Status(WorkerStatusFilter), Version(WorkerVersionFilter), CreatedAt(WorkerCreatedAtFilter), Env(WorkerEnvFilter), + WasiConfigVars(WorkerWasiConfigVarsFilter), } impl ::core::fmt::Debug for WorkerPropertyFilter { fn fmt( @@ -418,6 +437,11 @@ pub mod golem { WorkerPropertyFilter::Env(e) => { f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish() } + WorkerPropertyFilter::WasiConfigVars(e) => { + f.debug_tuple("WorkerPropertyFilter::WasiConfigVars") + .field(e) + .finish() + } } } } @@ -454,6 +478,7 @@ pub mod golem { pub worker_id: WorkerId, pub args: _rt::Vec<_rt::String>, pub env: _rt::Vec<(_rt::String, _rt::String)>, + pub wasi_config_vars: _rt::Vec<(_rt::String, _rt::String)>, pub status: WorkerStatus, pub component_version: u64, pub retry_count: u64, @@ -467,6 +492,7 @@ pub mod golem { .field("worker-id", &self.worker_id) .field("args", &self.args) .field("env", &self.env) + .field("wasi-config-vars", &self.wasi_config_vars) .field("status", &self.status) .field("component-version", &self.component_version) .field("retry-count", &self.retry_count) @@ -590,47 +616,47 @@ pub mod golem { high_bits: high_bits1, low_bits: low_bits1, } = uuid0; - let (result14_0, result14_1, result14_2) = match filter { + let (result17_0, result17_1, result17_2) = match filter { Some(e) => { let WorkerAnyFilter { filters: filters2 } = e; - let vec13 = filters2; - let len13 = vec13.len(); - let layout13 = _rt::alloc::Layout::from_size_align_unchecked( - vec13.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec16 = filters2; + let len16 = vec16.len(); + let layout16 = _rt::alloc::Layout::from_size_align_unchecked( + vec16.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result13 = if layout13.size() != 0 { - let ptr = _rt::alloc::alloc(layout13).cast::(); + let result16 = if layout16.size() != 0 { + let ptr = _rt::alloc::alloc(layout16).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout13); + _rt::alloc::handle_alloc_error(layout16); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec13.into_iter().enumerate() { - let base = result13 + for (i, e) in vec16.into_iter().enumerate() { + let base = result16 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { let WorkerAllFilter { filters: filters3 } = e; - let vec12 = filters3; - let len12 = vec12.len(); - let layout12 = _rt::alloc::Layout::from_size_align_unchecked( - vec12.len() + let vec15 = filters3; + let len15 = vec15.len(); + let layout15 = _rt::alloc::Layout::from_size_align_unchecked( + vec15.len() * (16 + 4 * ::core::mem::size_of::<*const u8>()), 8, ); - let result12 = if layout12.size() != 0 { - let ptr = _rt::alloc::alloc(layout12).cast::(); + let result15 = if layout15.size() != 0 { + let ptr = _rt::alloc::alloc(layout15).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout12); + _rt::alloc::handle_alloc_error(layout15); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec12.into_iter().enumerate() { - let base = result12 + for (i, e) in vec15.into_iter().enumerate() { + let base = result15 .add(i * (16 + 4 * ::core::mem::size_of::<*const u8>())); { match e { @@ -709,18 +735,45 @@ pub mod golem { .add(8 + 3 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>() = ptr11.cast_mut(); } + WorkerPropertyFilter::WasiConfigVars(e) => { + *base.add(0).cast::() = (5i32) as u8; + let WorkerWasiConfigVarsFilter { + name: name12, + comparator: comparator12, + value: value12, + } = e; + let vec13 = name12; + let ptr13 = vec13.as_ptr().cast::(); + let len13 = vec13.len(); + *base + .add(8 + 1 * ::core::mem::size_of::<*const u8>()) + .cast::() = len13; + *base.add(8).cast::<*mut u8>() = ptr13.cast_mut(); + *base + .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .cast::() = (comparator12.clone() as i32) as u8; + let vec14 = value12; + let ptr14 = vec14.as_ptr().cast::(); + let len14 = vec14.len(); + *base + .add(8 + 4 * ::core::mem::size_of::<*const u8>()) + .cast::() = len14; + *base + .add(8 + 3 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr14.cast_mut(); + } } } } *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len12; - *base.add(0).cast::<*mut u8>() = result12; - cleanup_list.extend_from_slice(&[(result12, layout12)]); + .cast::() = len15; + *base.add(0).cast::<*mut u8>() = result15; + cleanup_list.extend_from_slice(&[(result15, layout15)]); } } - cleanup_list.extend_from_slice(&[(result13, layout13)]); - (1i32, result13, len13) + cleanup_list.extend_from_slice(&[(result16, layout16)]); + (1i32, result16, len16) } None => (0i32, ::core::ptr::null_mut(), 0usize), }; @@ -728,7 +781,7 @@ pub mod golem { #[link(wasm_import_module = "golem:api/host@1.1.7")] unsafe extern "C" { #[link_name = "[constructor]get-workers"] - fn wit_import15( + fn wit_import18( _: i64, _: i64, _: i32, @@ -738,7 +791,7 @@ pub mod golem { ) -> i32; } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import15( + unsafe extern "C" fn wit_import18( _: i64, _: i64, _: i32, @@ -749,12 +802,12 @@ pub mod golem { unreachable!() } let ret = unsafe { - wit_import15( + wit_import18( _rt::as_i64(high_bits1), _rt::as_i64(low_bits1), - result14_0, - result14_1, - result14_2, + result17_0, + result17_1, + result17_2, match &precise { true => 1, false => 0, @@ -798,7 +851,7 @@ pub mod golem { } unsafe { wit_import1((self).handle() as i32, ptr0) }; let l2 = i32::from(*ptr0.add(0).cast::()); - let result29 = match l2 { + let result38 = match l2 { 0 => None, 1 => { let e = { @@ -808,13 +861,13 @@ pub mod golem { let l4 = *ptr0 .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base28 = l3; - let len28 = l4; - let mut result28 = _rt::Vec::with_capacity(len28); - for i in 0..len28 { - let base = base28 - .add(i * (40 + 6 * ::core::mem::size_of::<*const u8>())); - let e28 = { + let base37 = l3; + let len37 = l4; + let mut result37 = _rt::Vec::with_capacity(len37); + for i in 0..len37 { + let base = base37 + .add(i * (40 + 8 * ::core::mem::size_of::<*const u8>())); + let e37 = { let l5 = *base.add(0).cast::(); let l6 = *base.add(8).cast::(); let l7 = *base.add(16).cast::<*mut u8>(); @@ -903,16 +956,60 @@ pub mod golem { len24 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l25 = i32::from( + let l25 = *base + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l26 = *base + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base33 = l25; + let len33 = l26; + let mut result33 = _rt::Vec::with_capacity(len33); + for i in 0..len33 { + let base = base33 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e33 = { + let l27 = *base.add(0).cast::<*mut u8>(); + let l28 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + let l30 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l31 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len32 = l31; + let bytes32 = _rt::Vec::from_raw_parts( + l30.cast(), + len32, + len32, + ); + (_rt::string_lift(bytes29), _rt::string_lift(bytes32)) + }; + result33.push(e33); + } + _rt::cabi_dealloc( + base33, + len33 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l34 = i32::from( *base - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l26 = *base - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l35 = *base + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l27 = *base - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l36 = *base + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -926,25 +1023,26 @@ pub mod golem { }, args: result15, env: result24, - status: WorkerStatus::_lift(l25 as u8), - component_version: l26 as u64, - retry_count: l27 as u64, + wasi_config_vars: result33, + status: WorkerStatus::_lift(l34 as u8), + component_version: l35 as u64, + retry_count: l36 as u64, } }; - result28.push(e28); + result37.push(e37); } _rt::cabi_dealloc( - base28, - len28 * (40 + 6 * ::core::mem::size_of::<*const u8>()), + base37, + len37 * (40 + 8 * ::core::mem::size_of::<*const u8>()), 8, ); - result28 + result37 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result29 + result38 } } } @@ -1646,11 +1744,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 40 + 6 * ::core::mem::size_of::<*const u8>()], + >; 40 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 40 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let ptr0 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] @@ -1748,18 +1846,62 @@ pub mod golem { len21 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l22 = i32::from( + let l22 = *ptr0 + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l23 = *ptr0 + .add(16 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base30 = l22; + let len30 = l23; + let mut result30 = _rt::Vec::with_capacity(len30); + for i in 0..len30 { + let base = base30 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e30 = { + let l24 = *base.add(0).cast::<*mut u8>(); + let l25 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len26 = l25; + let bytes26 = _rt::Vec::from_raw_parts( + l24.cast(), + len26, + len26, + ); + let l27 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len29 = l28; + let bytes29 = _rt::Vec::from_raw_parts( + l27.cast(), + len29, + len29, + ); + (_rt::string_lift(bytes26), _rt::string_lift(bytes29)) + }; + result30.push(e30); + } + _rt::cabi_dealloc( + base30, + len30 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l31 = i32::from( *ptr0 - .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .add(16 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l23 = *ptr0 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + let l32 = *ptr0 + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l24 = *ptr0 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l33 = *ptr0 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let result25 = WorkerMetadata { + let result34 = WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { component_id: super::super::super::golem::rpc::types::ComponentId { uuid: super::super::super::golem::rpc::types::Uuid { @@ -1771,11 +1913,12 @@ pub mod golem { }, args: result12, env: result21, - status: WorkerStatus::_lift(l22 as u8), - component_version: l23 as u64, - retry_count: l24 as u64, + wasi_config_vars: result30, + status: WorkerStatus::_lift(l31 as u8), + component_version: l32 as u64, + retry_count: l33 as u64, }; - result25 + result34 } } #[allow(unused_unsafe, clippy::all)] @@ -1786,11 +1929,11 @@ pub mod golem { struct RetArea( [::core::mem::MaybeUninit< u8, - >; 48 + 6 * ::core::mem::size_of::<*const u8>()], + >; 48 + 8 * ::core::mem::size_of::<*const u8>()], ); let mut ret_area = RetArea( [::core::mem::MaybeUninit::uninit(); 48 - + 6 * ::core::mem::size_of::<*const u8>()], + + 8 * ::core::mem::size_of::<*const u8>()], ); let super::super::super::golem::rpc::types::WorkerId { component_id: component_id0, @@ -1833,7 +1976,7 @@ pub mod golem { ) }; let l6 = i32::from(*ptr4.add(0).cast::()); - let result30 = match l6 { + let result39 = match l6 { 0 => None, 1 => { let e = { @@ -1925,16 +2068,60 @@ pub mod golem { len26 * (4 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let l27 = i32::from( + let l27 = *ptr4 + .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l28 = *ptr4 + .add(24 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let base35 = l27; + let len35 = l28; + let mut result35 = _rt::Vec::with_capacity(len35); + for i in 0..len35 { + let base = base35 + .add(i * (4 * ::core::mem::size_of::<*const u8>())); + let e35 = { + let l29 = *base.add(0).cast::<*mut u8>(); + let l30 = *base + .add(::core::mem::size_of::<*const u8>()) + .cast::(); + let len31 = l30; + let bytes31 = _rt::Vec::from_raw_parts( + l29.cast(), + len31, + len31, + ); + let l32 = *base + .add(2 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l33 = *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len34 = l33; + let bytes34 = _rt::Vec::from_raw_parts( + l32.cast(), + len34, + len34, + ); + (_rt::string_lift(bytes31), _rt::string_lift(bytes34)) + }; + result35.push(e35); + } + _rt::cabi_dealloc( + base35, + len35 * (4 * ::core::mem::size_of::<*const u8>()), + ::core::mem::size_of::<*const u8>(), + ); + let l36 = i32::from( *ptr4 - .add(24 + 6 * ::core::mem::size_of::<*const u8>()) + .add(24 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l28 = *ptr4 - .add(32 + 6 * ::core::mem::size_of::<*const u8>()) + let l37 = *ptr4 + .add(32 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l29 = *ptr4 - .add(40 + 6 * ::core::mem::size_of::<*const u8>()) + let l38 = *ptr4 + .add(40 + 8 * ::core::mem::size_of::<*const u8>()) .cast::(); WorkerMetadata { worker_id: super::super::super::golem::rpc::types::WorkerId { @@ -1948,16 +2135,17 @@ pub mod golem { }, args: result17, env: result26, - status: WorkerStatus::_lift(l27 as u8), - component_version: l28 as u64, - retry_count: l29 as u64, + wasi_config_vars: result35, + status: WorkerStatus::_lift(l36 as u8), + component_version: l37 as u64, + retry_count: l38 as u64, } }; Some(e) } _ => _rt::invalid_enum_discriminant(), }; - result30 + result39 } } #[allow(unused_unsafe, clippy::all)] @@ -2549,6 +2737,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -2558,6 +2747,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -5785,26 +5975,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -5822,83 +6016,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -5916,245 +6131,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6163,7 +6378,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -6172,43 +6387,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -6216,89 +6431,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -6309,13 +6524,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -6327,156 +6542,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -6717,26 +6932,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -6754,83 +6973,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -6848,245 +7088,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7095,7 +7335,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -7104,106 +7344,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -7211,158 +7456,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -7370,7 +7615,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -7387,66 +7632,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, + ); + _rt::string_lift(bytes37) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes41) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -8475,8 +8742,8 @@ pub(crate) use __export_shopping_cart_impl as export; )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5715] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xcf+\x01A\x02\x01A\x12\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5871] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xeb,\x01A\x02\x01A\x13\ \x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04self\x01\0\x7f\x04\0\x16[\ method]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\0\x16[method]pollab\ le.block\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\0\x04poll\x01\x06\x03\ @@ -8501,96 +8768,99 @@ pe\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0cprim-s8 -type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0dprim\ -f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\0\x10\ prim-string-type\0\0\x0bhandle-type\x01\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01\ -ks\x01r\x02\x04name\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\ -\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05values\x04\0\x03u\ -ri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0cre\ -cord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\x0bflags-value\ -\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coption-value\x01\x12\ -\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\ -\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08p\ -rim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\ -\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\ -\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03\ -typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01s\0\x06deni\ -ed\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09rpc-error\ -\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\x04\0\x12\ -cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15[construc\ -tor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm-rpc.ephe\ -meral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffun\ -ction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\ -\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wasm-rpc.inv\ -oke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0<\x04\0'\ -[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0escheduled-time\ -\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rpc.schedule\ --invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\ -\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-invocation\x01\ -@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-invoke-resu\ -lt.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[method]future-i\ -nvoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![method]cancellat\ -ion-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\0\x0aparse\ --uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\x03vnt-\ -\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-type\x01\ -L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\0\x03\ -\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x09worker-id\x01B{\x02\x03\x02\ -\x01\x06\x04\0\x08duration\x03\0\0\x02\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\ -\0\x02\x02\x03\x02\x01\x08\x04\0\x04uuid\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x09\ -worker-id\x03\0\x06\x01w\x04\0\x0boplog-index\x03\0\x08\x01r\x02\x09worker-id\x07\ -\x09oplog-idx\x09\x04\0\x0apromise-id\x03\0\x0a\x01w\x04\0\x11component-version\x03\ -\0\x0c\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x0e\x01r\x01\x04uuid\x05\x04\ -\0\x0aproject-id\x03\0\x10\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x01\x09m\ -ax-delay\x01\x0amultiplieru\x11max-jitter-factor\x12\x04\0\x0cretry-policy\x03\0\ -\x13\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\ -\0\0\x04\0\x11persistence-level\x03\0\x15\x01m\x02\x09automatic\x0esnapshot-base\ -d\x04\0\x0bupdate-mode\x03\0\x17\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\ -\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x19\x01m\x04\x05\ -equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1b\ -\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06\ -exited\x04\0\x0dworker-status\x03\0\x1d\x01r\x02\x0acomparator\x1c\x05values\x04\ -\0\x12worker-name-filter\x03\0\x1f\x01r\x02\x0acomparator\x1a\x05value\x1e\x04\0\ -\x14worker-status-filter\x03\0!\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x15wo\ -rker-version-filter\x03\0#\x01r\x02\x0acomparator\x1a\x05valuew\x04\0\x18worker-\ -created-at-filter\x03\0%\x01r\x03\x04names\x0acomparator\x1c\x05values\x04\0\x11\ -worker-env-filter\x03\0'\x01q\x05\x04name\x01\x20\0\x06status\x01\"\0\x07version\ -\x01$\0\x0acreated-at\x01&\0\x03env\x01(\0\x04\0\x16worker-property-filter\x03\0\ -)\x01p*\x01r\x01\x07filters+\x04\0\x11worker-all-filter\x03\0,\x01p-\x01r\x01\x07\ -filters.\x04\0\x11worker-any-filter\x03\0/\x01ps\x01o\x02ss\x01p2\x01r\x06\x09wo\ -rker-id\x07\x04args1\x03env3\x06status\x1e\x11component-versionw\x0bretry-countw\ -\x04\0\x0fworker-metadata\x03\04\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert\ --to-oplog-index\x01\x09\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-work\ -er-target\x03\07\x01m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\09\x01k\ -0\x01i6\x01@\x03\x0ccomponent-id\x03\x06filter;\x07precise\x7f\0<\x04\0\x18[cons\ -tructor]get-workers\x01=\x01h6\x01p5\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[m\ -ethod]get-workers.get-next\x01A\x01@\0\0\x0b\x04\0\x0ecreate-promise\x01B\x01p}\x01\ -@\x01\x0apromise-id\x0b\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\x0a\ -promise-id\x0b\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x0b\x04\ -data\xc3\0\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x0b\x01\0\ -\x04\0\x0edelete-promise\x01H\x01@\0\0\x09\x04\0\x0fget-oplog-index\x01I\x01@\x01\ -\x09oplog-idx\x09\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\ -\x04\0\x0coplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\ -\x09\x01\0\x04\0\x12mark-end-operation\x01L\x01@\0\0\x14\x04\0\x10get-retry-poli\ -cy\x01M\x01@\x01\x10new-retry-policy\x14\x01\0\x04\0\x10set-retry-policy\x01N\x01\ -@\0\0\x16\x04\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-\ -level\x16\x01\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14\ -get-idempotence-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempote\ -nce-mode\x01R\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09wo\ -rker-id\x07\x0etarget-version\x0d\x04mode\x18\x01\0\x04\0\x0dupdate-worker\x01T\x01\ -@\0\05\x04\0\x11get-self-metadata\x01U\x01k5\x01@\x01\x09worker-id\x07\0\xd6\0\x04\ -\0\x13get-worker-metadata\x01W\x01@\x03\x10source-worker-id\x07\x10target-worker\ --id\x07\x11oplog-idx-cut-off\x09\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09wor\ -ker-id\x07\x0drevert-target8\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x03\x01@\x01\ -\x13component-references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x07\x01\ -@\x02\x13component-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\ -\x01]\x04\0\x18resolve-worker-id-strict\x01]\x01@\x01\x08new-names\0:\x04\0\x04f\ -ork\x01^\x03\0\x14golem:api/host@1.1.7\x05\x0a\x01B\x17\x01r\x04\x0aproduct-ids\x04\ -names\x05pricev\x08quantityy\x04\0\x0cproduct-item\x03\0\0\x01p\x01\x01r\x04\x08\ -order-ids\x05items\x02\x05totalv\x09timestampw\x04\0\x05order\x03\0\x03\x01r\x01\ -\x08order-ids\x04\0\x12order-confirmation\x03\0\x05\x01q\x02\x05error\x01s\0\x07\ -success\x01\x06\0\x04\0\x0fcheckout-result\x03\0\x07\x01@\x01\x07user-ids\x01\0\x04\ -\0\x0finitialize-cart\x01\x09\x01@\x01\x04item\x01\x01\0\x04\0\x08add-item\x01\x0a\ +ks\x01r\x03\x04name\x1b\x05owner\x1b\x04type\x1a\x04\0\x13named-wit-type-node\x03\ +\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-type\x03\0\x1f\x01r\x01\x05va\ +lues\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\ +\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-value\x01#\0\x0aenum-value\x01y\0\ +\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0alist-value\x01\x16\0\x0coptio\ +n-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\x01}\0\x08prim-u16\x01{\0\x08\ +prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08prim-\ +s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\x09p\ +rim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01&\0\x04\ +\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\0\x09wit-value\x03\0*\x01r\x02\ +\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\0,\x01q\x04\x0eprotocol-error\x01\ +s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-error\x01s\0\x04\0\x09\ +rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-invoke-result\x03\x01\ +\x04\0\x12cancellation-token\x03\x01\x01i0\x01@\x01\x09worker-id\x09\03\x04\0\x15\ +[constructor]wasm-rpc\x014\x01@\x01\x0ccomponent-id\x07\03\x04\0\x1a[static]wasm\ +-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01/\x01@\x03\x04self6\x0dfunction-nam\ +es\x0ffunction-params7\08\x04\0![method]wasm-rpc.invoke-and-await\x019\x01j\0\x01\ +/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\0:\x04\0\x17[method]wa\ +sm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\ +\0<\x04\0'[method]wasm-rpc.async-invoke-and-await\x01=\x01@\x04\x04self6\x0esche\ +duled-time\x01\x0dfunction-names\x0ffunction-params7\x01\0\x04\0$[method]wasm-rp\ +c.schedule-invocation\x01>\x01i2\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunc\ +tion-names\x0ffunction-params7\0?\x04\0/[method]wasm-rpc.schedule-cancelable-inv\ +ocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\0\0\xc2\0\x04\0&[method]future-\ +invoke-result.subscribe\x01C\x01k8\x01@\x01\x04self\xc1\0\0\xc4\0\x04\0\x20[meth\ +od]future-invoke-result.get\x01E\x01h2\x01@\x01\x04self\xc6\0\x01\0\x04\0![metho\ +d]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01@\x01\x04uuids\0\xc8\0\x04\ +\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0euuid-to-string\x01J\x01@\x01\ +\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03vnt-\0\x20\x04\0\x0cextract-\ +type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x05\x02\x03\0\x01\x08duration\x02\x03\ +\0\x03\x0ccomponent-id\x02\x03\0\x03\x04uuid\x02\x03\0\x03\x0evalue-and-type\x02\ +\x03\0\x03\x09worker-id\x01B\x7f\x02\x03\x02\x01\x06\x04\0\x08duration\x03\0\0\x02\ +\x03\x02\x01\x07\x04\0\x0ccomponent-id\x03\0\x02\x02\x03\x02\x01\x08\x04\0\x04uu\ +id\x03\0\x04\x02\x03\x02\x01\x09\x04\0\x0evalue-and-type\x03\0\x06\x02\x03\x02\x01\ +\x0a\x04\0\x09worker-id\x03\0\x08\x01w\x04\0\x0boplog-index\x03\0\x0a\x01r\x02\x09\ +worker-id\x09\x09oplog-idx\x0b\x04\0\x0apromise-id\x03\0\x0c\x01w\x04\0\x11compo\ +nent-version\x03\0\x0e\x01r\x01\x05values\x04\0\x0aaccount-id\x03\0\x10\x01r\x01\ +\x04uuid\x05\x04\0\x0aproject-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09mi\ +n-delay\x01\x09max-delay\x01\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cre\ +try-policy\x03\0\x15\x01q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effe\ +cts\0\0\x05smart\0\0\x04\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0e\ +snapshot-based\x04\0\x0bupdate-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0d\ +greater-equal\x07greater\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\ +\x01m\x04\x05equal\x09not-equal\x04like\x08not-like\x04\0\x18string-filter-compa\ +rator\x03\0\x1d\x01m\x07\x07running\x04idle\x09suspended\x0binterrupted\x08retry\ +ing\x06failed\x06exited\x04\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\ +\x05values\x04\0\x12worker-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05valu\ +e\x20\x04\0\x14worker-status-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\ +\0\x15worker-version-filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18\ +worker-created-at-filter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x11worker-env-filter\x03\0)\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\ +\0\x1eworker-wasi-config-vars-filter\x03\0+\x01q\x06\x04name\x01\"\0\x06status\x01\ +$\0\x07version\x01&\0\x0acreated-at\x01(\0\x03env\x01*\0\x10wasi-config-vars\x01\ +,\0\x04\0\x16worker-property-filter\x03\0-\x01p.\x01r\x01\x07filters/\x04\0\x11w\ +orker-all-filter\x03\00\x01p1\x01r\x01\x07filters2\x04\0\x11worker-any-filter\x03\ +\03\x01ps\x01o\x02ss\x01p6\x01r\x07\x09worker-id\x09\x04args5\x03env7\x10wasi-co\ +nfig-vars7\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\ +etadata\x03\08\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\ +\x0b\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\0;\x01\ +m\x02\x08original\x06forked\x04\0\x0bfork-result\x03\0=\x01k4\x01i:\x01@\x03\x0c\ +component-id\x03\x06filter?\x07precise\x7f\0\xc0\0\x04\0\x18[constructor]get-wor\ +kers\x01A\x01h:\x01p9\x01k\xc3\0\x01@\x01\x04self\xc2\0\0\xc4\0\x04\0\x1c[method\ +]get-workers.get-next\x01E\x01@\0\0\x0d\x04\0\x0ecreate-promise\x01F\x01p}\x01@\x01\ +\x0apromise-id\x0d\0\xc7\0\x04\0\x0dawait-promise\x01H\x01k\xc7\0\x01@\x01\x0apr\ +omise-id\x0d\0\xc9\0\x04\0\x0cpoll-promise\x01J\x01@\x02\x0apromise-id\x0d\x04da\ +ta\xc7\0\0\x7f\x04\0\x10complete-promise\x01K\x01@\x01\x0apromise-id\x0d\x01\0\x04\ +\0\x0edelete-promise\x01L\x01@\0\0\x0b\x04\0\x0fget-oplog-index\x01M\x01@\x01\x09\ +oplog-idx\x0b\x01\0\x04\0\x0fset-oplog-index\x01N\x01@\x01\x08replicas}\x01\0\x04\ +\0\x0coplog-commit\x01O\x04\0\x14mark-begin-operation\x01M\x01@\x01\x05begin\x0b\ +\x01\0\x04\0\x12mark-end-operation\x01P\x01@\0\0\x16\x04\0\x10get-retry-policy\x01\ +Q\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01R\x01@\0\0\ +\x18\x04\0\x1bget-oplog-persistence-level\x01S\x01@\x01\x15new-persistence-level\ +\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01T\x01@\0\0\x7f\x04\0\x14get-i\ +dempotence-mode\x01U\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempotence-m\ +ode\x01V\x01@\0\0\x05\x04\0\x18generate-idempotency-key\x01W\x01@\x03\x09worker-\ +id\x09\x0etarget-version\x0f\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01X\x01@\0\ +\09\x04\0\x11get-self-metadata\x01Y\x01k9\x01@\x01\x09worker-id\x09\0\xda\0\x04\0\ +\x13get-worker-metadata\x01[\x01@\x03\x10source-worker-id\x09\x10target-worker-i\ +d\x09\x11oplog-idx-cut-off\x0b\x01\0\x04\0\x0bfork-worker\x01\\\x01@\x02\x09work\ +er-id\x09\x0drevert-target<\x01\0\x04\0\x0drevert-worker\x01]\x01k\x03\x01@\x01\x13\ +component-references\0\xde\0\x04\0\x14resolve-component-id\x01_\x01k\x09\x01@\x02\ +\x13component-references\x0bworker-names\0\xe0\0\x04\0\x11resolve-worker-id\x01a\ +\x04\0\x18resolve-worker-id-strict\x01a\x01@\x01\x08new-names\0>\x04\0\x04fork\x01\ +b\x03\0\x14golem:api/host@1.1.7\x05\x0b\x01B\x17\x01r\x04\x0aproduct-ids\x04name\ +s\x05pricev\x08quantityy\x04\0\x0cproduct-item\x03\0\0\x01p\x01\x01r\x04\x08orde\ +r-ids\x05items\x02\x05totalv\x09timestampw\x04\0\x05order\x03\0\x03\x01r\x01\x08\ +order-ids\x04\0\x12order-confirmation\x03\0\x05\x01q\x02\x05error\x01s\0\x07succ\ +ess\x01\x06\0\x04\0\x0fcheckout-result\x03\0\x07\x01@\x01\x07user-ids\x01\0\x04\0\ +\x0finitialize-cart\x01\x09\x01@\x01\x04item\x01\x01\0\x04\0\x08add-item\x01\x0a\ \x01@\x01\x0aproduct-ids\x01\0\x04\0\x0bremove-item\x01\x0b\x01@\x02\x0aproduct-\ ids\x08quantityy\x01\0\x04\0\x14update-item-quantity\x01\x0c\x01@\0\0\x08\x04\0\x08\ checkout\x01\x0d\x01@\0\0\x02\x04\0\x11get-cart-contents\x01\x0e\x01@\x01\x05cou\ -nt}\x01\0\x04\0\x0cforce-commit\x01\x0f\x04\0\x0cgolem:it/api\x05\x0b\x04\0\x16g\ +nt}\x01\0\x04\0\x0cforce-commit\x01\x0f\x04\0\x0cgolem:it/api\x05\x0c\x04\0\x16g\ olem:it/shopping-cart\x04\0\x0b\x13\x01\0\x0dshopping-cart\x03\0\0\0G\x09produce\ rs\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.\ 41.0"; diff --git a/test-components/shopping-cart/wit/deps.lock b/test-components/shopping-cart/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/shopping-cart/wit/deps.lock +++ b/test-components/shopping-cart/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/shopping-cart/wit/deps.toml b/test-components/shopping-cart/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/shopping-cart/wit/deps.toml +++ b/test-components/shopping-cart/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/shopping-cart/wit/deps/golem-1.x/golem-host.wit b/test-components/shopping-cart/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/shopping-cart/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/shopping-cart/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/shopping-cart/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/shopping-cart/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/shopping-cart/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/shopping-cart/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/tinygo-wasi-http/wit/deps.toml b/test-components/tinygo-wasi-http/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/tinygo-wasi-http/wit/deps.toml +++ b/test-components/tinygo-wasi-http/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/tinygo-wasi/wit/deps.toml b/test-components/tinygo-wasi/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/tinygo-wasi/wit/deps.toml +++ b/test-components/tinygo-wasi/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/ts-rpc/components-ts/caller/src/main.ts b/test-components/ts-rpc/components-ts/caller/src/main.ts index 97b4e15eb3..0ad98915e0 100644 --- a/test-components/ts-rpc/components-ts/caller/src/main.ts +++ b/test-components/ts-rpc/components-ts/caller/src/main.ts @@ -35,21 +35,21 @@ function createGlobalCounter(workerName: string): Counter { return counter; } -async function test1(): Promise { +function test1(): bigint { const counter = globalCounter ?? createGlobalCounter("counters_test2"); counter.blockingIncBy(BigInt(1)); const value = counter.blockingGetValue(); return value; } -async function test2(): Promise { +function test2(): bigint { const counter = globalCounter ?? createGlobalCounter("counters_test3"); counter.blockingIncBy(BigInt(1)); const value = counter.blockingGetValue(); return value; } -async function test3(): Promise<[string[], [string, string][]]> { +function test3(): [string[], [string, string][]] { const counter = globalCounter ?? createGlobalCounter("counters_test4"); const args = counter.blockingGetArgs(); const env = counter.blockingGetEnv(); diff --git a/test-components/ts-rpc/components-ts/counter/src/main.ts b/test-components/ts-rpc/components-ts/counter/src/main.ts index 58dc3b78d3..28bab05f0b 100644 --- a/test-components/ts-rpc/components-ts/counter/src/main.ts +++ b/test-components/ts-rpc/components-ts/counter/src/main.ts @@ -8,16 +8,16 @@ class CounterResource implements World.api.Counter { this.value = BigInt(0) } - async incBy(value: bigint): Promise { + incBy(value: bigint) { this.value += value } - async getValue(): Promise { + getValue(): bigint { return this.value } - async getArgs(): Promise { + getArgs(): string[] { return getArguments() } - async getEnv(): Promise<[string, string][]> { + getEnv(): [string, string][] { return getEnvironment() } @@ -28,10 +28,10 @@ let globalValue: bigint = BigInt(0) const api: typeof World.api = { Counter: CounterResource, - async incGlobalBy(value: bigint) { + incGlobalBy(value: bigint) { globalValue += value }, - async getGlobalValue() { + getGlobalValue() { return globalValue }, } diff --git a/test-components/ts-rpc/wit/deps.lock b/test-components/ts-rpc/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/ts-rpc/wit/deps.lock +++ b/test-components/ts-rpc/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/ts-rpc/wit/deps.toml b/test-components/ts-rpc/wit/deps.toml index 5dacfebe4b..6c10af03a6 100644 --- a/test-components/ts-rpc/wit/deps.toml +++ b/test-components/ts-rpc/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" diff --git a/test-components/update-test-env-var/Cargo.lock b/test-components/update-test-env-var/Cargo.lock index 987b6d6f14..2907a72704 100644 --- a/test-components/update-test-env-var/Cargo.lock +++ b/test-components/update-test-env-var/Cargo.lock @@ -4,9 +4,9 @@ version = 4 [[package]] name = "adler2" -version = "2.0.0" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" [[package]] name = "android-tzdata" @@ -25,9 +25,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.97" +version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f" +checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100" [[package]] name = "auditable-serde" @@ -43,33 +43,33 @@ dependencies = [ [[package]] name = "autocfg" -version = "1.4.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967" [[package]] name = "bumpalo" -version = "3.17.0" +version = "3.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" [[package]] name = "bytes" -version = "1.6.0" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" +checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a" [[package]] name = "camino" -version = "1.1.9" +version = "1.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3" +checksum = "5d07aa9a93b00c76f71bc35d598bed923f6d4f3a9ca5c24b7737ae1a292841c0" dependencies = [ "serde", ] @@ -99,24 +99,24 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.18" +version = "1.2.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525046617d8376e3db1deffb079e91cef90a89fc3ca5c185bbf8c9ecdd15cd5c" +checksum = "2352e5597e9c544d5e6d9c95190d5d27738ade584fa8db0a16e130e5c2b5296e" dependencies = [ "shlex", ] [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" [[package]] name = "chrono" -version = "0.4.40" +version = "0.4.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a7964611d71df112cb1730f2ee67324fcf4d0fc6606acbbe9bfe06df124637c" +checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d" dependencies = [ "android-tzdata", "iana-time-zone", @@ -135,9 +135,9 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "crc32fast" -version = "1.4.2" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" dependencies = [ "cfg-if", ] @@ -161,9 +161,9 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" [[package]] name = "flate2" -version = "1.1.1" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece" +checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d" dependencies = [ "crc32fast", "miniz_oxide", @@ -275,9 +275,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "libc", @@ -307,9 +307,8 @@ dependencies = [ [[package]] name = "golem-rust" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46aaf34adda9057718d79e808fb323b3247cb34ec9c38ff88e74824d703980dd" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#3f188145088e43cababe90f9ffbf0d3cba6d5669" dependencies = [ "golem-rust-macro", "golem-wasm-rpc", @@ -321,9 +320,8 @@ dependencies = [ [[package]] name = "golem-rust-macro" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ab4174ebe45b8a1961eedeebc215bbc475aea4bdf4f2baa80cc6222fb0058da" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem-rust?branch=type-owner#3f188145088e43cababe90f9ffbf0d3cba6d5669" dependencies = [ "heck", "proc-macro2", @@ -333,9 +331,8 @@ dependencies = [ [[package]] name = "golem-wasm-rpc" -version = "1.3.0-dev.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e80ad91fcaed123f283edb451862fb960f5f7a390c22a37186ca24770597d8ec" +version = "0.0.0" +source = "git+https://github.com/golemcloud/golem?branch=resource-improvements#783f103dd9a45fbbf43d2c5eb1ed6ef8dfa62ef3" dependencies = [ "cargo_metadata", "chrono", @@ -346,9 +343,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" dependencies = [ "foldhash", ] @@ -385,21 +382,22 @@ dependencies = [ [[package]] name = "icu_collections" -version = "1.5.0" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" dependencies = [ "displaydoc", + "potential_utf", "yoke", "zerofrom", "zerovec", ] [[package]] -name = "icu_locid" -version = "1.5.0" +name = "icu_locale_core" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" dependencies = [ "displaydoc", "litemap", @@ -408,31 +406,11 @@ dependencies = [ "zerovec", ] -[[package]] -name = "icu_locid_transform" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e" -dependencies = [ - "displaydoc", - "icu_locid", - "icu_locid_transform_data", - "icu_provider", - "tinystr", - "zerovec", -] - -[[package]] -name = "icu_locid_transform_data" -version = "1.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7515e6d781098bf9f7205ab3fc7e9709d34554ae0b21ddbcb5febfa4bc7df11d" - [[package]] name = "icu_normalizer" -version = "1.5.0" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" dependencies = [ "displaydoc", "icu_collections", @@ -440,67 +418,54 @@ dependencies = [ "icu_properties", "icu_provider", "smallvec", - "utf16_iter", - "utf8_iter", - "write16", "zerovec", ] [[package]] name = "icu_normalizer_data" -version = "1.5.1" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5e8338228bdc8ab83303f16b797e177953730f601a96c25d10cb3ab0daa0cb7" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" [[package]] name = "icu_properties" -version = "1.5.1" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" dependencies = [ "displaydoc", "icu_collections", - "icu_locid_transform", + "icu_locale_core", "icu_properties_data", "icu_provider", - "tinystr", + "potential_utf", + "zerotrie", "zerovec", ] [[package]] name = "icu_properties_data" -version = "1.5.1" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85fb8799753b75aee8d2a21d7c14d9f38921b54b3dbda10f5a3c7a7b82dba5e2" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" [[package]] name = "icu_provider" -version = "1.5.0" +version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" dependencies = [ "displaydoc", - "icu_locid", - "icu_provider_macros", + "icu_locale_core", "stable_deref_trait", "tinystr", "writeable", "yoke", "zerofrom", + "zerotrie", "zerovec", ] -[[package]] -name = "icu_provider_macros" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - [[package]] name = "id-arena" version = "2.2.1" @@ -520,9 +485,9 @@ dependencies = [ [[package]] name = "idna_adapter" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" dependencies = [ "icu_normalizer", "icu_properties", @@ -530,9 +495,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.9.0" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e" +checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" dependencies = [ "equivalent", "hashbrown", @@ -563,15 +528,15 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" [[package]] name = "libc" -version = "0.2.171" +version = "0.2.175" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6" +checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" [[package]] name = "litemap" -version = "0.7.5" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23fb14cb19457329c82206317a5663005a4d404783dc74f4252769b0d5f42856" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" [[package]] name = "log" @@ -581,15 +546,15 @@ checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" [[package]] name = "memchr" -version = "2.7.4" +version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" [[package]] name = "miniz_oxide" -version = "0.8.8" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" dependencies = [ "adler2", ] @@ -627,11 +592,20 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "potential_utf" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" +dependencies = [ + "zerovec", +] + [[package]] name = "prettyplease" -version = "0.2.32" +version = "0.2.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6" +checksum = "ff24dfcda44452b9816fff4cd4227e1bb73ff5a2f1bc1105aa92fb8565ce44d2" dependencies = [ "proc-macro2", "syn", @@ -639,9 +613,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.94" +version = "1.0.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84" +checksum = "d61789d7719defeb74ea5fe81f2fdfdbd28a803847077cecce2ff14e1472f6f1" dependencies = [ "unicode-ident", ] @@ -657,15 +631,15 @@ dependencies = [ [[package]] name = "r-efi" -version = "5.2.0" +version = "5.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" [[package]] name = "rustversion" -version = "1.0.20" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" @@ -704,9 +678,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.140" +version = "1.0.142" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" dependencies = [ "itoa", "memchr", @@ -728,24 +702,21 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "slab" -version = "0.4.9" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" [[package]] name = "smallvec" -version = "1.15.0" +version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" [[package]] name = "spdx" -version = "0.10.8" +version = "0.10.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58b69356da67e2fc1f542c71ea7e654a361a79c938e4424392ecf4fa065d2193" +checksum = "c3e17e880bafaeb362a7b751ec46bdc5b61445a188f80e0606e68167cd540fa3" dependencies = [ "smallvec", ] @@ -758,9 +729,9 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "syn" -version = "2.0.100" +version = "2.0.105" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0" +checksum = "7bc3fcb250e53458e712715cf74285c1f889686520d79294a9ef3bd7aa1fc619" dependencies = [ "proc-macro2", "quote", @@ -769,9 +740,9 @@ dependencies = [ [[package]] name = "synstructure" -version = "0.13.1" +version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ "proc-macro2", "quote", @@ -780,18 +751,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708" +checksum = "0b0949c3a6c842cbde3f1686d6eea5a010516deb7085f79db747562d4102f41e" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" +checksum = "cc5b44b4ab9c2fdd0e0512e6bece8388e214c0749f5862b114cc5b7a25daf227" dependencies = [ "proc-macro2", "quote", @@ -800,9 +771,9 @@ dependencies = [ [[package]] name = "tinystr" -version = "0.7.6" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" dependencies = [ "displaydoc", "zerovec", @@ -846,12 +817,6 @@ dependencies = [ "percent-encoding", ] -[[package]] -name = "utf16_iter" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246" - [[package]] name = "utf8_iter" version = "1.0.4" @@ -860,13 +825,15 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" [[package]] name = "uuid" -version = "1.16.0" +version = "1.18.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9" +checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be" dependencies = [ "getrandom", + "js-sys", "serde", "sha1_smol", + "wasm-bindgen", ] [[package]] @@ -979,9 +946,9 @@ dependencies = [ [[package]] name = "windows-core" -version = "0.61.0" +version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980" +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3" dependencies = [ "windows-implement", "windows-interface", @@ -1014,24 +981,24 @@ dependencies = [ [[package]] name = "windows-link" -version = "0.1.1" +version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" [[package]] name = "windows-result" -version = "0.3.2" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252" +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6" dependencies = [ "windows-link", ] [[package]] name = "windows-strings" -version = "0.4.0" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97" +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57" dependencies = [ "windows-link", ] @@ -1145,23 +1112,17 @@ dependencies = [ "wasmparser", ] -[[package]] -name = "write16" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936" - [[package]] name = "writeable" -version = "0.5.5" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" [[package]] name = "yoke" -version = "0.7.5" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" dependencies = [ "serde", "stable_deref_trait", @@ -1171,9 +1132,9 @@ dependencies = [ [[package]] name = "yoke-derive" -version = "0.7.5" +version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" dependencies = [ "proc-macro2", "quote", @@ -1202,11 +1163,22 @@ dependencies = [ "synstructure", ] +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + [[package]] name = "zerovec" -version = "0.10.4" +version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" dependencies = [ "yoke", "zerofrom", @@ -1215,9 +1187,9 @@ dependencies = [ [[package]] name = "zerovec-derive" -version = "0.10.3" +version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" dependencies = [ "proc-macro2", "quote", diff --git a/test-components/update-test-env-var/Cargo.toml b/test-components/update-test-env-var/Cargo.toml index f23dcfaba7..d3afbd9342 100644 --- a/test-components/update-test-env-var/Cargo.toml +++ b/test-components/update-test-env-var/Cargo.toml @@ -14,7 +14,7 @@ strip = true [dependencies] bytes = "1.6.0" -golem-rust = { version = "1.6.0", features = ["default", "export_load_snapshot", "export_save_snapshot"] } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["default", "export_load_snapshot", "export_save_snapshot"] } wit-bindgen-rt = { version = "0.40.0", features = ["bitflags"] } [package.metadata.component.target] diff --git a/test-components/update-test-env-var/wit/deps.toml b/test-components/update-test-env-var/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/update-test-env-var/wit/deps.toml +++ b/test-components/update-test-env-var/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/update-test-v1.wasm b/test-components/update-test-v1.wasm index d2bc9951a8..97d1787971 100755 Binary files a/test-components/update-test-v1.wasm and b/test-components/update-test-v1.wasm differ diff --git a/test-components/update-test-v2-11.wasm b/test-components/update-test-v2-11.wasm index a2981440f4..589ee20463 100644 Binary files a/test-components/update-test-v2-11.wasm and b/test-components/update-test-v2-11.wasm differ diff --git a/test-components/update-test-v2-11/wit/deps.lock b/test-components/update-test-v2-11/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/update-test-v2-11/wit/deps.lock +++ b/test-components/update-test-v2-11/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/update-test-v2-11/wit/deps.toml b/test-components/update-test-v2-11/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/update-test-v2-11/wit/deps.toml +++ b/test-components/update-test-v2-11/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/update-test-v2-11/wit/deps/golem-1.x/golem-host.wit b/test-components/update-test-v2-11/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/update-test-v2-11/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/update-test-v2-11/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/update-test-v2-11/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/update-test-v2-11/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/update-test-v2-11/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/update-test-v2-11/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/update-test-v3-11.wasm b/test-components/update-test-v3-11.wasm index 6725dc0f1c..e2846f2ee7 100644 Binary files a/test-components/update-test-v3-11.wasm and b/test-components/update-test-v3-11.wasm differ diff --git a/test-components/update-test-v3-11/wit/deps.lock b/test-components/update-test-v3-11/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/update-test-v3-11/wit/deps.lock +++ b/test-components/update-test-v3-11/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/update-test-v3-11/wit/deps.toml b/test-components/update-test-v3-11/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/update-test-v3-11/wit/deps.toml +++ b/test-components/update-test-v3-11/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/update-test-v3-11/wit/deps/golem-1.x/golem-host.wit b/test-components/update-test-v3-11/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/update-test-v3-11/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/update-test-v3-11/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/update-test-v3-11/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/update-test-v3-11/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/update-test-v3-11/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/update-test-v3-11/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/update-test-v3-sdk/Cargo.toml b/test-components/update-test-v3-sdk/Cargo.toml index 86f3951caf..e635e94910 100644 --- a/test-components/update-test-v3-sdk/Cargo.toml +++ b/test-components/update-test-v3-sdk/Cargo.toml @@ -14,7 +14,7 @@ strip = true [dependencies] bytes = "1.6.0" -golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "wit-bindgen", features = ["default", "export_load_snapshot", "export_save_snapshot"] } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["default", "export_load_snapshot", "export_save_snapshot"] } wit-bindgen-rt = { version = "0.40.0", features = ["bitflags"] } [package.metadata.component.target] diff --git a/test-components/update-test-v3-sdk/wit/deps.toml b/test-components/update-test-v3-sdk/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/update-test-v3-sdk/wit/deps.toml +++ b/test-components/update-test-v3-sdk/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/update-test-v4/wit/deps.lock b/test-components/update-test-v4/wit/deps.lock index f94692f73c..3933395b22 100644 --- a/test-components/update-test-v4/wit/deps.lock +++ b/test-components/update-test-v4/wit/deps.lock @@ -1,5 +1,5 @@ [all] -url = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -25,16 +25,16 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/test-components/update-test-v4/wit/deps.toml b/test-components/update-test-v4/wit/deps.toml index 68788c36d6..b97a604d56 100644 --- a/test-components/update-test-v4/wit/deps.toml +++ b/test-components/update-test-v4/wit/deps.toml @@ -1 +1 @@ -all = "https://github.com/golemcloud/golem-wit/archive/type-names.tar.gz" \ No newline at end of file +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" \ No newline at end of file diff --git a/test-components/update-test-v4/wit/deps/golem-1.x/golem-host.wit b/test-components/update-test-v4/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/test-components/update-test-v4/wit/deps/golem-1.x/golem-host.wit +++ b/test-components/update-test-v4/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/test-components/update-test-v4/wit/deps/golem-rpc/wasm-rpc.wit b/test-components/update-test-v4/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/test-components/update-test-v4/wit/deps/golem-rpc/wasm-rpc.wit +++ b/test-components/update-test-v4/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/test-components/wasi-config/Cargo.toml b/test-components/wasi-config/Cargo.toml index 2e964c2b14..5c9c7c4dfd 100644 --- a/test-components/wasi-config/Cargo.toml +++ b/test-components/wasi-config/Cargo.toml @@ -7,7 +7,7 @@ opt-level = "s" lto = true [workspace.dependencies] -golem-rust = { version = "1.6.0", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } +golem-rust = { git = "https://github.com/golemcloud/golem-rust", branch = "type-owner", features = ["export_load_snapshot", "export_save_snapshot", "export_oplog_processor"] } reqwest = { git = "https://github.com/zivergetech/reqwest", branch = "update-may-2025", features = ["json"] } serde = { version = "1", features = ["derive"] } serde_json = "1" diff --git a/wasm-ast/proto/wasm/ast/type.proto b/wasm-ast/proto/wasm/ast/type.proto index a9d8050c31..32f3b33c56 100644 --- a/wasm-ast/proto/wasm/ast/type.proto +++ b/wasm-ast/proto/wasm/ast/type.proto @@ -24,48 +24,57 @@ message TypePrimitive { message TypeList { Type elem = 1; optional string name = 2; + optional string owner = 3; } message TypeTuple { repeated Type elems = 1; optional string name = 2; + optional string owner = 3; } message TypeRecord { repeated NameTypePair fields = 1; optional string name = 2; + optional string owner = 3; } message TypeFlags { repeated string names = 1; optional string name = 2; + optional string owner = 3; } message TypeEnum { repeated string names = 1; optional string name = 2; + optional string owner = 3; } message TypeOption { Type elem = 1; optional string name = 2; + optional string owner = 3; } message TypeResult { optional Type ok = 1; optional Type err = 2; optional string name = 3; + optional string owner = 4; } message TypeVariant { repeated NameOptionTypePair cases = 1; optional string name = 2; + optional string owner = 3; } message TypeHandle { uint64 resource_id = 1; ResourceMode mode = 2; optional string name = 3; + optional string owner = 4; } message NameTypePair { diff --git a/wasm-ast/src/analysis/model.rs b/wasm-ast/src/analysis/model.rs index 559cd30643..35b02dca26 100644 --- a/wasm-ast/src/analysis/model.rs +++ b/wasm-ast/src/analysis/model.rs @@ -89,6 +89,8 @@ pub struct AnalysedInstance { pub struct TypeResult { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub ok: Option>, pub err: Option>, } @@ -118,6 +120,8 @@ pub struct NameOptionTypePair { pub struct TypeVariant { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub cases: Vec, } @@ -128,6 +132,8 @@ pub struct TypeVariant { pub struct TypeOption { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub inner: Box, } @@ -138,6 +144,8 @@ pub struct TypeOption { pub struct TypeEnum { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub cases: Vec, } @@ -148,6 +156,8 @@ pub struct TypeEnum { pub struct TypeFlags { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub names: Vec, } @@ -158,6 +168,8 @@ pub struct TypeFlags { pub struct TypeRecord { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub fields: Vec, } @@ -168,6 +180,8 @@ pub struct TypeRecord { pub struct TypeTuple { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub items: Vec, } @@ -178,6 +192,8 @@ pub struct TypeTuple { pub struct TypeList { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub inner: Box, } @@ -266,6 +282,8 @@ pub struct TypeBool; pub struct TypeHandle { #[serde(skip_serializing_if = "Option::is_none")] pub name: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub owner: Option, pub resource_id: AnalysedResourceId, pub mode: AnalysedResourceMode, } @@ -316,19 +334,7 @@ impl AnalysedType { AnalysedType::Tuple(typ) => typ.name.as_deref(), AnalysedType::List(typ) => typ.name.as_deref(), AnalysedType::Handle(typ) => typ.name.as_deref(), - AnalysedType::Str(_) => None, - AnalysedType::Chr(_) => None, - AnalysedType::F64(_) => None, - AnalysedType::F32(_) => None, - AnalysedType::U64(_) => None, - AnalysedType::S64(_) => None, - AnalysedType::U32(_) => None, - AnalysedType::S32(_) => None, - AnalysedType::U16(_) => None, - AnalysedType::S16(_) => None, - AnalysedType::U8(_) => None, - AnalysedType::S8(_) => None, - AnalysedType::Bool(_) => None, + _ => None, } } @@ -377,6 +383,86 @@ impl AnalysedType { pub fn named(self, name: impl AsRef) -> Self { self.with_optional_name(Some(name.as_ref().to_string())) } + + pub fn owner(&self) -> Option<&str> { + match self { + AnalysedType::Variant(typ) => typ.owner.as_deref(), + AnalysedType::Result(typ) => typ.owner.as_deref(), + AnalysedType::Option(typ) => typ.owner.as_deref(), + AnalysedType::Enum(typ) => typ.owner.as_deref(), + AnalysedType::Flags(typ) => typ.owner.as_deref(), + AnalysedType::Record(typ) => typ.owner.as_deref(), + AnalysedType::Tuple(typ) => typ.owner.as_deref(), + AnalysedType::List(typ) => typ.owner.as_deref(), + AnalysedType::Handle(typ) => typ.owner.as_deref(), + _ => None, + } + } + + pub fn with_optional_owner(self, owner: Option) -> Self { + match self { + AnalysedType::Variant(mut typ) => { + typ.owner = owner; + AnalysedType::Variant(typ) + } + AnalysedType::Result(mut typ) => { + typ.owner = owner; + AnalysedType::Result(typ) + } + AnalysedType::Option(mut typ) => { + typ.owner = owner; + AnalysedType::Option(typ) + } + AnalysedType::Enum(mut typ) => { + typ.owner = owner; + AnalysedType::Enum(typ) + } + AnalysedType::Flags(mut typ) => { + typ.owner = owner; + AnalysedType::Flags(typ) + } + AnalysedType::Record(mut typ) => { + typ.owner = owner; + AnalysedType::Record(typ) + } + AnalysedType::Tuple(mut typ) => { + typ.owner = owner; + AnalysedType::Tuple(typ) + } + AnalysedType::List(mut typ) => { + typ.owner = owner; + AnalysedType::List(typ) + } + AnalysedType::Handle(mut typ) => { + typ.owner = owner; + AnalysedType::Handle(typ) + } + _ => self, + } + } + + pub fn owned(self, owner: impl AsRef) -> Self { + self.with_optional_owner(Some(owner.as_ref().to_string())) + } + + pub fn contains_handle(&self) -> bool { + match self { + AnalysedType::Handle(_) => true, + AnalysedType::Variant(typ) => typ + .cases + .iter() + .any(|case| case.typ.as_ref().is_some_and(|t| t.contains_handle())), + AnalysedType::Result(typ) => { + typ.ok.as_ref().is_some_and(|t| t.contains_handle()) + || typ.err.as_ref().is_some_and(|t| t.contains_handle()) + } + AnalysedType::Option(typ) => typ.inner.contains_handle(), + AnalysedType::Record(typ) => typ.fields.iter().any(|f| f.typ.contains_handle()), + AnalysedType::Tuple(typ) => typ.items.iter().any(|t| t.contains_handle()), + AnalysedType::List(typ) => typ.inner.contains_handle(), + _ => false, + } + } } pub mod analysed_type { @@ -465,6 +551,7 @@ pub mod analysed_type { pub fn list(inner: AnalysedType) -> AnalysedType { AnalysedType::List(TypeList { name: None, + owner: None, inner: Box::new(inner), }) } @@ -472,6 +559,7 @@ pub mod analysed_type { pub fn option(inner: AnalysedType) -> AnalysedType { AnalysedType::Option(TypeOption { name: None, + owner: None, inner: Box::new(inner), }) } @@ -479,6 +567,7 @@ pub mod analysed_type { pub fn flags(names: &[&str]) -> AnalysedType { AnalysedType::Flags(TypeFlags { name: None, + owner: None, names: names.iter().map(|n| n.to_string()).collect(), }) } @@ -486,17 +575,23 @@ pub mod analysed_type { pub fn r#enum(cases: &[&str]) -> AnalysedType { AnalysedType::Enum(TypeEnum { name: None, + owner: None, cases: cases.iter().map(|n| n.to_string()).collect(), }) } pub fn tuple(items: Vec) -> AnalysedType { - AnalysedType::Tuple(TypeTuple { name: None, items }) + AnalysedType::Tuple(TypeTuple { + name: None, + owner: None, + items, + }) } pub fn result(ok: AnalysedType, err: AnalysedType) -> AnalysedType { AnalysedType::Result(TypeResult { name: None, + owner: None, ok: Some(Box::new(ok)), err: Some(Box::new(err)), }) @@ -505,6 +600,7 @@ pub mod analysed_type { pub fn result_ok(ok: AnalysedType) -> AnalysedType { AnalysedType::Result(TypeResult { name: None, + owner: None, ok: Some(Box::new(ok)), err: None, }) @@ -513,22 +609,32 @@ pub mod analysed_type { pub fn result_err(err: AnalysedType) -> AnalysedType { AnalysedType::Result(TypeResult { name: None, + owner: None, ok: None, err: Some(Box::new(err)), }) } pub fn record(fields: Vec) -> AnalysedType { - AnalysedType::Record(TypeRecord { name: None, fields }) + AnalysedType::Record(TypeRecord { + name: None, + owner: None, + fields, + }) } pub fn variant(cases: Vec) -> AnalysedType { - AnalysedType::Variant(TypeVariant { name: None, cases }) + AnalysedType::Variant(TypeVariant { + name: None, + owner: None, + cases, + }) } pub fn handle(resource_id: AnalysedResourceId, mode: AnalysedResourceMode) -> AnalysedType { AnalysedType::Handle(TypeHandle { name: None, + owner: None, resource_id, mode, }) @@ -544,7 +650,7 @@ pub enum AnalysedResourceMode { Borrowed, } -#[derive(Debug, Clone, PartialEq, Hash, Eq)] +#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq)] #[cfg_attr(feature = "json", derive(serde::Serialize, serde::Deserialize))] #[cfg_attr(feature = "bincode", derive(bincode::Encode, bincode::Decode))] #[cfg_attr(feature = "poem_openapi", derive(poem_openapi::NewType))] diff --git a/wasm-ast/src/analysis/protobuf.rs b/wasm-ast/src/analysis/protobuf.rs index 1696009c87..17be630cee 100644 --- a/wasm-ast/src/analysis/protobuf.rs +++ b/wasm-ast/src/analysis/protobuf.rs @@ -50,7 +50,9 @@ impl TryFrom<&Type> for AnalysedType { .as_ref() .ok_or_else(|| "List element type is None".to_string())?; let analysed_type = AnalysedType::try_from(elem_type.as_ref())?; - Ok(list(analysed_type).with_optional_name(inner.name.clone())) + Ok(list(analysed_type) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } Some(r#type::Type::Tuple(inner)) => { let elems = inner @@ -58,7 +60,9 @@ impl TryFrom<&Type> for AnalysedType { .iter() .map(AnalysedType::try_from) .collect::, String>>()?; - Ok(tuple(elems).with_optional_name(inner.name.clone())) + Ok(tuple(elems) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } Some(r#type::Type::Record(inner)) => { let fields = inner @@ -72,7 +76,9 @@ impl TryFrom<&Type> for AnalysedType { Ok(field(&proto_field.name, analysed_type)) }) .collect::, String>>()?; - Ok(record(fields).with_optional_name(inner.name.clone())) + Ok(record(fields) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } Some(r#type::Type::Flags(inner)) => Ok(flags( &inner @@ -81,7 +87,8 @@ impl TryFrom<&Type> for AnalysedType { .map(|s| s.as_str()) .collect::>(), ) - .with_optional_name(inner.name.clone())), + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())), Some(r#type::Type::Enum(inner)) => Ok(r#enum( &inner .names @@ -89,14 +96,17 @@ impl TryFrom<&Type> for AnalysedType { .map(|s| s.as_str()) .collect::>(), ) - .with_optional_name(inner.name.clone())), + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())), Some(r#type::Type::Option(inner)) => { let elem_type = inner .elem .as_ref() .ok_or_else(|| "Option element type is None".to_string())?; let analysed_type = AnalysedType::try_from(elem_type.as_ref())?; - Ok(option(analysed_type).with_optional_name(inner.name.clone())) + Ok(option(analysed_type) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } Some(r#type::Type::Result(inner)) => { let ok_type = inner @@ -113,8 +123,10 @@ impl TryFrom<&Type> for AnalysedType { ok: ok_type.map(Box::new), err: err_type.map(Box::new), name: inner.name.clone(), + owner: inner.owner.clone(), }) - .with_optional_name(inner.name.clone())) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } Some(r#type::Type::Variant(inner)) => { let cases = inner @@ -129,7 +141,9 @@ impl TryFrom<&Type> for AnalysedType { }) }) .collect::, String>>()?; - Ok(variant(cases).with_optional_name(inner.name.clone())) + Ok(variant(cases) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } Some(r#type::Type::Handle(inner)) => { let resource_mode = match inner.mode { @@ -138,7 +152,8 @@ impl TryFrom<&Type> for AnalysedType { _ => Err("Invalid resource mode".to_string()), }?; Ok(handle(AnalysedResourceId(inner.resource_id), resource_mode) - .with_optional_name(inner.name.clone())) + .with_optional_name(inner.name.clone()) + .with_optional_owner(inner.owner.clone())) } None => Err("Type is None".to_string()), } @@ -187,63 +202,75 @@ impl From<&AnalysedType> for Type { AnalysedType::Str(_) => Some(r#type::Type::Primitive(TypePrimitive { primitive: PrimitiveType::Str as i32, })), - AnalysedType::List(crate::analysis::TypeList { inner, name }) => { + AnalysedType::List(crate::analysis::TypeList { inner, name, owner }) => { Some(r#type::Type::List(Box::new(TypeList { elem: Some(Box::new(Type::from(inner.deref()))), name: name.clone(), + owner: owner.clone(), }))) } - AnalysedType::Tuple(crate::analysis::TypeTuple { items, name }) => { + AnalysedType::Tuple(crate::analysis::TypeTuple { items, name, owner }) => { Some(r#type::Type::Tuple(TypeTuple { elems: items .iter() .map(|analysed_type| analysed_type.into()) .collect(), name: name.clone(), + owner: owner.clone(), })) } - AnalysedType::Record(crate::analysis::TypeRecord { fields, name }) => { - Some(r#type::Type::Record(TypeRecord { - fields: fields - .iter() - .map(|pair| NameTypePair { - name: pair.name.clone(), - typ: Some((&pair.typ).into()), - }) - .collect(), - name: name.clone(), - })) - } - AnalysedType::Flags(crate::analysis::TypeFlags { names, name }) => { + AnalysedType::Record(crate::analysis::TypeRecord { + fields, + name, + owner, + }) => Some(r#type::Type::Record(TypeRecord { + fields: fields + .iter() + .map(|pair| NameTypePair { + name: pair.name.clone(), + typ: Some((&pair.typ).into()), + }) + .collect(), + name: name.clone(), + owner: owner.clone(), + })), + AnalysedType::Flags(crate::analysis::TypeFlags { names, name, owner }) => { Some(r#type::Type::Flags(TypeFlags { names: names.clone(), name: name.clone(), + owner: owner.clone(), })) } - AnalysedType::Enum(crate::analysis::TypeEnum { cases, name }) => { + AnalysedType::Enum(crate::analysis::TypeEnum { cases, name, owner }) => { Some(r#type::Type::Enum(TypeEnum { names: cases.clone(), name: name.clone(), + owner: owner.clone(), })) } - AnalysedType::Option(crate::analysis::TypeOption { inner, name }) => { + AnalysedType::Option(crate::analysis::TypeOption { inner, name, owner }) => { Some(r#type::Type::Option(Box::new(TypeOption { elem: Some(Box::new(Type::from(inner.deref()))), name: name.clone(), + owner: owner.clone(), }))) } - AnalysedType::Result(crate::analysis::TypeResult { ok, err, name }) => { - Some(r#type::Type::Result(Box::new(TypeResult { - ok: ok - .clone() - .map(|ok_type| Box::new(Type::from(ok_type.as_ref()))), - err: err - .clone() - .map(|err_type| Box::new(Type::from(err_type.as_ref()))), - name: name.clone(), - }))) - } - AnalysedType::Variant(crate::analysis::TypeVariant { cases, name }) => { + AnalysedType::Result(crate::analysis::TypeResult { + ok, + err, + name, + owner, + }) => Some(r#type::Type::Result(Box::new(TypeResult { + ok: ok + .clone() + .map(|ok_type| Box::new(Type::from(ok_type.as_ref()))), + err: err + .clone() + .map(|err_type| Box::new(Type::from(err_type.as_ref()))), + name: name.clone(), + owner: owner.clone(), + }))), + AnalysedType::Variant(crate::analysis::TypeVariant { cases, name, owner }) => { Some(r#type::Type::Variant(TypeVariant { cases: cases .iter() @@ -253,12 +280,14 @@ impl From<&AnalysedType> for Type { }) .collect(), name: name.clone(), + owner: owner.clone(), })) } AnalysedType::Handle(crate::analysis::TypeHandle { resource_id, mode, name, + owner, }) => Some(r#type::Type::Handle(TypeHandle { resource_id: resource_id.0, mode: match mode { @@ -266,6 +295,7 @@ impl From<&AnalysedType> for Type { AnalysedResourceMode::Borrowed => 1, }, name: name.clone(), + owner: owner.clone(), })), }; diff --git a/wasm-ast/src/analysis/wit_parser.rs b/wasm-ast/src/analysis/wit_parser.rs index e4db0ece33..0551255f88 100644 --- a/wasm-ast/src/analysis/wit_parser.rs +++ b/wasm-ast/src/analysis/wit_parser.rs @@ -209,10 +209,9 @@ impl GetResourceId for WitAnalysisContext { let mut resource_ids = self.resource_ids.borrow_mut(); Some( - resource_ids + *resource_ids .entry(type_id) - .or_insert_with(|| AnalysedResourceId(new_unique_id)) - .clone(), + .or_insert_with(|| AnalysedResourceId(new_unique_id)), ) } } @@ -266,7 +265,8 @@ impl ToAnalysedType for TypeDef { }) .collect::>()?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Resource => { Err("to_analysed_type not implemented for resource type".to_string()) } @@ -277,7 +277,10 @@ impl ToAnalysedType for TypeDef { resource_id, mode: AnalysedResourceMode::Owned, name: self.name.clone(), - })), + owner: None, + }) + .with_optional_name(get_type_name(resolve, type_id)) + .with_optional_owner(get_type_owner(resolve, type_id))), None => Err("to_analysed_type not implemented for handle type".to_string()), }, Handle::Borrow(type_id) => match resource_map.get_resource_id(*type_id) { @@ -285,7 +288,10 @@ impl ToAnalysedType for TypeDef { resource_id, mode: AnalysedResourceMode::Borrowed, name: self.name.clone(), - })), + owner: None, + }) + .with_optional_name(get_type_name(resolve, type_id)) + .with_optional_owner(get_type_owner(resolve, type_id))), None => Err("to_analysed_type not implemented for handle type".to_string()), }, }, @@ -296,7 +302,8 @@ impl ToAnalysedType for TypeDef { .map(|flag| flag.name.as_str()) .collect::>(), ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Tuple(tuple) => Ok(analysed_type::tuple( tuple .types @@ -304,7 +311,8 @@ impl ToAnalysedType for TypeDef { .map(|typ| typ.to_analysed_type(resolve, resource_map)) .collect::>()?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Variant(variant) => Ok(analysed_type::variant( variant .cases @@ -320,7 +328,8 @@ impl ToAnalysedType for TypeDef { }) .collect::>()?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Enum(enum_) => Ok(analysed_type::r#enum( &enum_ .cases @@ -328,31 +337,42 @@ impl ToAnalysedType for TypeDef { .map(|case| case.name.as_str()) .collect::>(), ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Option(inner) => Ok(analysed_type::option( inner.to_analysed_type(resolve, resource_map)?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Result(result) => match (result.ok, result.err) { (Some(ok), Some(err)) => Ok(analysed_type::result( ok.to_analysed_type(resolve, resource_map)?, err.to_analysed_type(resolve, resource_map)?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), (Some(ok), None) => Ok(analysed_type::result_ok( ok.to_analysed_type(resolve, resource_map)?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), (None, Some(err)) => Ok(analysed_type::result_err( err.to_analysed_type(resolve, resource_map)?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), (None, None) => Err("result type with no ok or err case".to_string()), }, TypeDefKind::List(ty) => Ok(analysed_type::list( ty.to_analysed_type(resolve, resource_map)?, ) - .with_optional_name(self.name.clone())), + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), + TypeDefKind::FixedSizeList(ty, _) => Ok(analysed_type::list( + ty.to_analysed_type(resolve, resource_map)?, + ) + .with_optional_name(self.name.clone()) + .with_optional_owner(get_owner_name(resolve, &self.owner))), TypeDefKind::Future(_) => { Err("to_analysed_type not implemented for future type".to_string()) } @@ -395,6 +415,56 @@ impl ToAnalysedType for Type { } } +fn follow_aliases(resolve: &Resolve, type_id: &TypeId) -> TypeId { + let mut current_id = *type_id; + while let Some(type_def) = resolve.types.get(current_id) { + if let TypeDefKind::Type(Type::Id(alias_type_id)) = &type_def.kind { + current_id = *alias_type_id; + } else { + break; + } + } + current_id +} + +fn get_type_name(resolve: &Resolve, type_id: &TypeId) -> Option { + resolve + .types + .get(follow_aliases(resolve, type_id)) + .and_then(|type_def| type_def.name.clone()) +} + +fn get_type_owner(resolve: &Resolve, type_id: &TypeId) -> Option { + resolve + .types + .get(follow_aliases(resolve, type_id)) + .and_then(|type_def| get_owner_name(resolve, &type_def.owner)) +} + +fn get_owner_name(resolve: &Resolve, owner: &wit_parser::TypeOwner) -> Option { + match owner { + wit_parser::TypeOwner::World(world_id) => resolve + .worlds + .get(*world_id) + .map(|world| world.name.clone()), + wit_parser::TypeOwner::Interface(iface_id) => resolve + .interfaces + .get(*iface_id) + .and_then(|iface| iface.name.clone().map(|name| (iface.package, name))) + .and_then(|(package_id, name)| { + if let Some(package_id) = package_id { + resolve + .packages + .get(package_id) + .map(|package| format!("{}/{}", package.name, name)) + } else { + Some(name) + } + }), + wit_parser::TypeOwner::None => None, + } +} + #[derive(Debug, Hash, PartialEq, Eq)] pub enum TypeOwner { World(String), diff --git a/wasm-ast/tests/exports.rs b/wasm-ast/tests/exports.rs index 42e6d98048..0b360f24c3 100644 --- a/wasm-ast/tests/exports.rs +++ b/wasm-ast/tests/exports.rs @@ -41,7 +41,8 @@ fn exports_shopping_cart_component() { field("price", f32()), field("quantity", u32()), ]) - .named("product-item"), + .named("product-item") + .owned("golem:it/api"), }], result: None, }, @@ -75,10 +76,13 @@ fn exports_shopping_cart_component() { case("error", str()), case( "success", - record(vec![field("order-id", str())]).named("order-confirmation"), + record(vec![field("order-id", str())]) + .named("order-confirmation") + .owned("golem:it/api"), ), ]) - .named("checkout-result"), + .named("checkout-result") + .owned("golem:it/api"), }), }, AnalysedFunction { @@ -92,7 +96,8 @@ fn exports_shopping_cart_component() { field("price", f32()), field("quantity", u32()), ]) - .named("product-item"), + .named("product-item") + .owned("golem:it/api"), ), }), }, @@ -178,15 +183,18 @@ fn exports_file_service_component() { field( "last-modified", record(vec![field("seconds", u64()), field("nanoseconds", u32())]) - .named("datetime"), + .named("datetime") + .owned("wasi:clocks@0.2.0/wall-clock"), ), field( "last-accessed", record(vec![field("seconds", u64()), field("nanoseconds", u32())]) - .named("datetime"), + .named("datetime") + .owned("wasi:clocks@0.2.0/wall-clock"), ), ]) - .named("file-info"), + .named("file-info") + .owned("golem:it/api"), str(), ), }), @@ -203,15 +211,18 @@ fn exports_file_service_component() { field( "last-modified", record(vec![field("seconds", u64()), field("nanoseconds", u32())]) - .named("datetime"), + .named("datetime") + .owned("wasi:clocks@0.2.0/wall-clock"), ), field( "last-accessed", record(vec![field("seconds", u64()), field("nanoseconds", u32())]) - .named("datetime"), + .named("datetime") + .owned("wasi:clocks@0.2.0/wall-clock"), ), ]) - .named("file-info"), + .named("file-info") + .owned("golem:it/api"), str(), ), }), @@ -303,7 +314,8 @@ fn exports_file_service_component() { result: Some(AnalysedFunctionResult { typ: result( record(vec![field("lower", u64()), field("upper", u64())]) - .named("metadata-hash-value"), + .named("metadata-hash-value") + .owned("wasi:filesystem@0.2.0/types"), str(), ), }), @@ -339,7 +351,9 @@ fn exports_auction_registry_composed_component() { }, ], result: Some(AnalysedFunctionResult { - typ: record(vec![field("bidder-id", str())]).named("bidder-id"), + typ: record(vec![field("bidder-id", str())]) + .named("bidder-id") + .owned("auction:auction/api"), }), }, AnalysedFunction { @@ -363,7 +377,9 @@ fn exports_auction_registry_composed_component() { }, ], result: Some(AnalysedFunctionResult { - typ: record(vec![field("auction-id", str())]).named("auction-id"), + typ: record(vec![field("auction-id", str())]) + .named("auction-id") + .owned("auction:auction/api"), }), }, AnalysedFunction { @@ -374,14 +390,17 @@ fn exports_auction_registry_composed_component() { record(vec![ field( "auction-id", - record(vec![field("auction-id", str())]).named("auction-id"), + record(vec![field("auction-id", str())]) + .named("auction-id") + .owned("auction:auction/api"), ), field("name", str()), field("description", str()), field("limit-price", f32()), field("expiration", u64()), ]) - .named("auction"), + .named("auction") + .owned("auction:auction/api"), ), }), }, @@ -409,7 +428,9 @@ fn exports_shopping_cart_resource_component() { typ: str(), }], result: Some(AnalysedFunctionResult { - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Owned), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Owned) + .named("cart") + .owned("golem:it/api"), }), }, AnalysedFunction { @@ -417,7 +438,9 @@ fn exports_shopping_cart_resource_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }, AnalysedFunctionParameter { name: "item".to_string(), @@ -427,7 +450,8 @@ fn exports_shopping_cart_resource_component() { field("price", f32()), field("quantity", u32()), ]) - .named("product-item"), + .named("product-item") + .owned("golem:it/api"), }, ], result: None, @@ -437,7 +461,9 @@ fn exports_shopping_cart_resource_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }, AnalysedFunctionParameter { name: "product-id".to_string(), @@ -451,7 +477,9 @@ fn exports_shopping_cart_resource_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }, AnalysedFunctionParameter { name: "product-id".to_string(), @@ -468,24 +496,31 @@ fn exports_shopping_cart_resource_component() { name: "[method]cart.checkout".to_string(), parameters: vec![AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }], result: Some(AnalysedFunctionResult { typ: variant(vec![ case("error", str()), case( "success", - record(vec![field("order-id", str())]).named("order-confirmation"), + record(vec![field("order-id", str())]) + .named("order-confirmation") + .owned("golem:it/api"), ), ]) - .named("checkout-result"), + .named("checkout-result") + .owned("golem:it/api"), }), }, AnalysedFunction { name: "[method]cart.get-cart-contents".to_string(), parameters: vec![AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }], result: Some(AnalysedFunctionResult { typ: list( @@ -495,7 +530,8 @@ fn exports_shopping_cart_resource_component() { field("price", f32()), field("quantity", u32()), ]) - .named("product-item"), + .named("product-item") + .owned("golem:it/api"), ), }), }, @@ -504,11 +540,15 @@ fn exports_shopping_cart_resource_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }, AnalysedFunctionParameter { name: "other-cart".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it/api"), }, ], result: None, @@ -537,7 +577,9 @@ fn exports_shopping_cart_resource_versioned_component() { typ: str(), }], result: Some(AnalysedFunctionResult { - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Owned), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Owned) + .named("cart") + .owned("golem:it@1.2.3/api"), }), }, AnalysedFunction { @@ -545,7 +587,9 @@ fn exports_shopping_cart_resource_versioned_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }, AnalysedFunctionParameter { name: "item".to_string(), @@ -555,7 +599,8 @@ fn exports_shopping_cart_resource_versioned_component() { field("price", f32()), field("quantity", u32()), ]) - .named("product-item"), + .named("product-item") + .owned("golem:it@1.2.3/api"), }, ], result: None, @@ -565,7 +610,9 @@ fn exports_shopping_cart_resource_versioned_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }, AnalysedFunctionParameter { name: "product-id".to_string(), @@ -579,7 +626,9 @@ fn exports_shopping_cart_resource_versioned_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }, AnalysedFunctionParameter { name: "product-id".to_string(), @@ -596,24 +645,31 @@ fn exports_shopping_cart_resource_versioned_component() { name: "[method]cart.checkout".to_string(), parameters: vec![AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }], result: Some(AnalysedFunctionResult { typ: variant(vec![ case("error", str()), case( "success", - record(vec![field("order-id", str())]).named("order-confirmation"), + record(vec![field("order-id", str())]) + .named("order-confirmation") + .owned("golem:it@1.2.3/api"), ), ]) - .named("checkout-result"), + .named("checkout-result") + .owned("golem:it@1.2.3/api"), }), }, AnalysedFunction { name: "[method]cart.get-cart-contents".to_string(), parameters: vec![AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }], result: Some(AnalysedFunctionResult { typ: list( @@ -623,7 +679,8 @@ fn exports_shopping_cart_resource_versioned_component() { field("price", f32()), field("quantity", u32()), ]) - .named("product-item"), + .named("product-item") + .owned("golem:it@1.2.3/api"), ), }), }, @@ -632,11 +689,15 @@ fn exports_shopping_cart_resource_versioned_component() { parameters: vec![ AnalysedFunctionParameter { name: "self".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }, AnalysedFunctionParameter { name: "other-cart".to_string(), - typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed), + typ: handle(AnalysedResourceId(0), AnalysedResourceMode::Borrowed) + .named("cart") + .owned("golem:it@1.2.3/api"), }, ], result: None, @@ -689,10 +750,14 @@ fn exports_caller_composed_component() { name: "bug-wasm-rpc-i32".to_string(), parameters: vec![AnalysedFunctionParameter { name: "in".to_string(), - typ: variant(vec![unit_case("leaf")]).named("timeline-node"), + typ: variant(vec![unit_case("leaf")]) + .named("timeline-node") + .owned("root"), }], result: Some(AnalysedFunctionResult { - typ: variant(vec![unit_case("leaf")]).named("timeline-node"), + typ: variant(vec![unit_case("leaf")]) + .named("timeline-node") + .owned("root"), }), }), ]; @@ -743,10 +808,14 @@ fn exports_caller_component() { name: "bug-wasm-rpc-i32".to_string(), parameters: vec![AnalysedFunctionParameter { name: "in".to_string(), - typ: variant(vec![unit_case("leaf")]).named("timeline-node"), + typ: variant(vec![unit_case("leaf")]) + .named("timeline-node") + .owned("rpc:counters/api"), }], result: Some(AnalysedFunctionResult { - typ: variant(vec![unit_case("leaf")]).named("timeline-node"), + typ: variant(vec![unit_case("leaf")]) + .named("timeline-node") + .owned("rpc:counters/api"), }), }), AnalysedExport::Function(AnalysedFunction { diff --git a/wasm-rpc-derive/Cargo.toml b/wasm-rpc-derive/Cargo.toml index d33fa998e4..014bf97615 100644 --- a/wasm-rpc-derive/Cargo.toml +++ b/wasm-rpc-derive/Cargo.toml @@ -13,7 +13,7 @@ license-file = "../LICENSE" proc-macro = true [dependencies] -heck = "0.5.0" +heck = { workspace = true } proc-macro2 = "1" quote = "1" syn = { version = "2", features = ["full"] } diff --git a/wasm-rpc/src/bincode.rs b/wasm-rpc/src/bincode.rs index ab9928788d..5cceaf0a3d 100644 --- a/wasm-rpc/src/bincode.rs +++ b/wasm-rpc/src/bincode.rs @@ -420,6 +420,7 @@ impl<'de, Context> BorrowDecode<'de, Context> for ResourceMode { impl Encode for NamedWitTypeNode { fn encode(&self, encoder: &mut E) -> Result<(), EncodeError> { self.name.encode(encoder)?; + self.owner.encode(encoder)?; self.type_.encode(encoder) } } @@ -427,8 +428,9 @@ impl Encode for NamedWitTypeNode { impl Decode for NamedWitTypeNode { fn decode>(decoder: &mut D) -> Result { let name = Option::::decode(decoder)?; + let owner = Option::::decode(decoder)?; let type_ = WitTypeNode::decode(decoder)?; - Ok(NamedWitTypeNode { name, type_ }) + Ok(NamedWitTypeNode { name, owner, type_ }) } } @@ -437,8 +439,9 @@ impl<'de, Context> BorrowDecode<'de, Context> for NamedWitTypeNode { decoder: &mut D, ) -> Result { let name = Option::::borrow_decode(decoder)?; + let owner = Option::::borrow_decode(decoder)?; let type_ = WitTypeNode::borrow_decode(decoder)?; - Ok(NamedWitTypeNode { name, type_ }) + Ok(NamedWitTypeNode { name, owner, type_ }) } } diff --git a/wasm-rpc/src/bindings.rs b/wasm-rpc/src/bindings.rs index e3e1e80e8c..8d58f13c9d 100644 --- a/wasm-rpc/src/bindings.rs +++ b/wasm-rpc/src/bindings.rs @@ -201,6 +201,7 @@ pub mod golem { #[derive(Clone)] pub struct NamedWitTypeNode { pub name: Option<_rt::String>, + pub owner: Option<_rt::String>, pub type_: WitTypeNode, } impl ::core::fmt::Debug for NamedWitTypeNode { @@ -210,6 +211,7 @@ pub mod golem { ) -> ::core::fmt::Result { f.debug_struct("NamedWitTypeNode") .field("name", &self.name) + .field("owner", &self.owner) .field("type", &self.type_) .finish() } @@ -3437,26 +3439,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -3474,83 +3480,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -3568,245 +3595,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-value"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -3815,7 +3842,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -3824,43 +3851,43 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base78 = l31; - let len78 = l32; - let mut result78 = _rt::Vec::with_capacity(len78); - for i in 0..len78 { - let base = base78 + let base79 = l32; + let len79 = l33; + let mut result79 = _rt::Vec::with_capacity(len79); + for i in 0..len79 { + let base = base79 .add(i * (16 + 2 * ::core::mem::size_of::<*const u8>())); - let e78 = { - let l33 = i32::from(*base.add(0).cast::()); - let v77 = match l33 { + let e79 = { + let l34 = i32::from(*base.add(0).cast::()); + let v78 = match l34 { 0 => { - let e77 = { - let l34 = *base.add(8).cast::<*mut u8>(); - let l35 = *base + let e78 = { + let l35 = *base.add(8).cast::<*mut u8>(); + let l36 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - _rt::Vec::from_raw_parts(l34.cast(), len36, len36) + let len37 = l36; + _rt::Vec::from_raw_parts(l35.cast(), len37, len37) }; - WitNode::RecordValue(e77) + WitNode::RecordValue(e78) } 1 => { - let e77 = { - let l37 = *base.add(8).cast::(); - let l38 = i32::from(*base.add(12).cast::()); + let e78 = { + let l38 = *base.add(8).cast::(); + let l39 = i32::from(*base.add(12).cast::()); ( - l37 as u32, - match l38 { + l38 as u32, + match l39 { 0 => None, 1 => { let e = { - let l39 = *base.add(16).cast::(); - l39 + let l40 = *base.add(16).cast::(); + l40 }; Some(e) } @@ -3868,89 +3895,89 @@ pub mod golem { }, ) }; - WitNode::VariantValue(e77) + WitNode::VariantValue(e78) } 2 => { - let e77 = { - let l40 = *base.add(8).cast::(); - l40 as u32 + let e78 = { + let l41 = *base.add(8).cast::(); + l41 as u32 }; - WitNode::EnumValue(e77) + WitNode::EnumValue(e78) } 3 => { - let e77 = { - let l41 = *base.add(8).cast::<*mut u8>(); - let l42 = *base + let e78 = { + let l42 = *base.add(8).cast::<*mut u8>(); + let l43 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l41; - let len44 = l42; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44.add(i * 1); - let e44 = { - let l43 = i32::from(*base.add(0).cast::()); - _rt::bool_lift(l43 as u8) + let base45 = l42; + let len45 = l43; + let mut result45 = _rt::Vec::with_capacity(len45); + for i in 0..len45 { + let base = base45.add(i * 1); + let e45 = { + let l44 = i32::from(*base.add(0).cast::()); + _rt::bool_lift(l44 as u8) }; - result44.push(e44); + result45.push(e45); } - _rt::cabi_dealloc(base44, len44 * 1, 1); - result44 + _rt::cabi_dealloc(base45, len45 * 1, 1); + result45 }; - WitNode::FlagsValue(e77) + WitNode::FlagsValue(e78) } 4 => { - let e77 = { - let l45 = *base.add(8).cast::<*mut u8>(); - let l46 = *base + let e78 = { + let l46 = *base.add(8).cast::<*mut u8>(); + let l47 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len47 = l46; - _rt::Vec::from_raw_parts(l45.cast(), len47, len47) + let len48 = l47; + _rt::Vec::from_raw_parts(l46.cast(), len48, len48) }; - WitNode::TupleValue(e77) + WitNode::TupleValue(e78) } 5 => { - let e77 = { - let l48 = *base.add(8).cast::<*mut u8>(); - let l49 = *base + let e78 = { + let l49 = *base.add(8).cast::<*mut u8>(); + let l50 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len50 = l49; - _rt::Vec::from_raw_parts(l48.cast(), len50, len50) + let len51 = l50; + _rt::Vec::from_raw_parts(l49.cast(), len51, len51) }; - WitNode::ListValue(e77) + WitNode::ListValue(e78) } 6 => { - let e77 = { - let l51 = i32::from(*base.add(8).cast::()); - match l51 { + let e78 = { + let l52 = i32::from(*base.add(8).cast::()); + match l52 { 0 => None, 1 => { let e = { - let l52 = *base.add(12).cast::(); - l52 + let l53 = *base.add(12).cast::(); + l53 }; Some(e) } _ => _rt::invalid_enum_discriminant(), } }; - WitNode::OptionValue(e77) + WitNode::OptionValue(e78) } 7 => { - let e77 = { - let l53 = i32::from(*base.add(8).cast::()); - match l53 { + let e78 = { + let l54 = i32::from(*base.add(8).cast::()); + match l54 { 0 => { let e = { - let l54 = i32::from(*base.add(12).cast::()); - match l54 { + let l55 = i32::from(*base.add(12).cast::()); + match l55 { 0 => None, 1 => { let e = { - let l55 = *base.add(16).cast::(); - l55 + let l56 = *base.add(16).cast::(); + l56 }; Some(e) } @@ -3961,13 +3988,13 @@ pub mod golem { } 1 => { let e = { - let l56 = i32::from(*base.add(12).cast::()); - match l56 { + let l57 = i32::from(*base.add(12).cast::()); + match l57 { 0 => None, 1 => { let e = { - let l57 = *base.add(16).cast::(); - l57 + let l58 = *base.add(16).cast::(); + l58 }; Some(e) } @@ -3979,156 +4006,156 @@ pub mod golem { _ => _rt::invalid_enum_discriminant(), } }; - WitNode::ResultValue(e77) + WitNode::ResultValue(e78) } 8 => { - let e77 = { - let l58 = i32::from(*base.add(8).cast::()); - l58 as u8 + let e78 = { + let l59 = i32::from(*base.add(8).cast::()); + l59 as u8 }; - WitNode::PrimU8(e77) + WitNode::PrimU8(e78) } 9 => { - let e77 = { - let l59 = i32::from(*base.add(8).cast::()); - l59 as u16 + let e78 = { + let l60 = i32::from(*base.add(8).cast::()); + l60 as u16 }; - WitNode::PrimU16(e77) + WitNode::PrimU16(e78) } 10 => { - let e77 = { - let l60 = *base.add(8).cast::(); - l60 as u32 + let e78 = { + let l61 = *base.add(8).cast::(); + l61 as u32 }; - WitNode::PrimU32(e77) + WitNode::PrimU32(e78) } 11 => { - let e77 = { - let l61 = *base.add(8).cast::(); - l61 as u64 + let e78 = { + let l62 = *base.add(8).cast::(); + l62 as u64 }; - WitNode::PrimU64(e77) + WitNode::PrimU64(e78) } 12 => { - let e77 = { - let l62 = i32::from(*base.add(8).cast::()); - l62 as i8 + let e78 = { + let l63 = i32::from(*base.add(8).cast::()); + l63 as i8 }; - WitNode::PrimS8(e77) + WitNode::PrimS8(e78) } 13 => { - let e77 = { - let l63 = i32::from(*base.add(8).cast::()); - l63 as i16 + let e78 = { + let l64 = i32::from(*base.add(8).cast::()); + l64 as i16 }; - WitNode::PrimS16(e77) + WitNode::PrimS16(e78) } 14 => { - let e77 = { - let l64 = *base.add(8).cast::(); - l64 + let e78 = { + let l65 = *base.add(8).cast::(); + l65 }; - WitNode::PrimS32(e77) + WitNode::PrimS32(e78) } 15 => { - let e77 = { - let l65 = *base.add(8).cast::(); - l65 + let e78 = { + let l66 = *base.add(8).cast::(); + l66 }; - WitNode::PrimS64(e77) + WitNode::PrimS64(e78) } 16 => { - let e77 = { - let l66 = *base.add(8).cast::(); - l66 + let e78 = { + let l67 = *base.add(8).cast::(); + l67 }; - WitNode::PrimFloat32(e77) + WitNode::PrimFloat32(e78) } 17 => { - let e77 = { - let l67 = *base.add(8).cast::(); - l67 + let e78 = { + let l68 = *base.add(8).cast::(); + l68 }; - WitNode::PrimFloat64(e77) + WitNode::PrimFloat64(e78) } 18 => { - let e77 = { - let l68 = *base.add(8).cast::(); - _rt::char_lift(l68 as u32) + let e78 = { + let l69 = *base.add(8).cast::(); + _rt::char_lift(l69 as u32) }; - WitNode::PrimChar(e77) + WitNode::PrimChar(e78) } 19 => { - let e77 = { - let l69 = i32::from(*base.add(8).cast::()); - _rt::bool_lift(l69 as u8) + let e78 = { + let l70 = i32::from(*base.add(8).cast::()); + _rt::bool_lift(l70 as u8) }; - WitNode::PrimBool(e77) + WitNode::PrimBool(e78) } 20 => { - let e77 = { - let l70 = *base.add(8).cast::<*mut u8>(); - let l71 = *base + let e78 = { + let l71 = *base.add(8).cast::<*mut u8>(); + let l72 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len72 = l71; - let bytes72 = _rt::Vec::from_raw_parts( - l70.cast(), - len72, - len72, + let len73 = l72; + let bytes73 = _rt::Vec::from_raw_parts( + l71.cast(), + len73, + len73, ); - _rt::string_lift(bytes72) + _rt::string_lift(bytes73) }; - WitNode::PrimString(e77) + WitNode::PrimString(e78) } n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e77 = { - let l73 = *base.add(8).cast::<*mut u8>(); - let l74 = *base + let e78 = { + let l74 = *base.add(8).cast::<*mut u8>(); + let l75 = *base .add(8 + 1 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len75 = l74; - let bytes75 = _rt::Vec::from_raw_parts( - l73.cast(), - len75, - len75, + let len76 = l75; + let bytes76 = _rt::Vec::from_raw_parts( + l74.cast(), + len76, + len76, ); - let l76 = *base + let l77 = *base .add(8 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); ( Uri { - value: _rt::string_lift(bytes75), + value: _rt::string_lift(bytes76), }, - l76 as u64, + l77 as u64, ) }; - WitNode::Handle(e77) + WitNode::Handle(e78) } }; - v77 + v78 }; - result78.push(e78); + result79.push(e79); } _rt::cabi_dealloc( - base78, - len78 * (16 + 2 * ::core::mem::size_of::<*const u8>()), + base79, + len79 * (16 + 2 * ::core::mem::size_of::<*const u8>()), 8, ); - let result79 = WitValue { nodes: result78 }; + let result80 = WitValue { nodes: result79 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result79 + result80 } } #[allow(unused_unsafe, clippy::all)] @@ -4369,26 +4396,30 @@ pub mod golem { } } let WitType { nodes: nodes12 } = typ0; - let vec28 = nodes12; - let len28 = vec28.len(); - let layout28 = _rt::alloc::Layout::from_size_align_unchecked( - vec28.len() * (32 + 2 * ::core::mem::size_of::<*const u8>()), + let vec29 = nodes12; + let len29 = vec29.len(); + let layout29 = _rt::alloc::Layout::from_size_align_unchecked( + vec29.len() * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result28 = if layout28.size() != 0 { - let ptr = _rt::alloc::alloc(layout28).cast::(); + let result29 = if layout29.size() != 0 { + let ptr = _rt::alloc::alloc(layout29).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout28); + _rt::alloc::handle_alloc_error(layout29); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec28.into_iter().enumerate() { - let base = result28 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); + for (i, e) in vec29.into_iter().enumerate() { + let base = result29 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); { - let NamedWitTypeNode { name: name13, type_: type_13 } = e; + let NamedWitTypeNode { + name: name13, + owner: owner13, + type_: type_13, + } = e; match name13 { Some(e) => { *base.add(0).cast::() = (1i32) as u8; @@ -4406,83 +4437,104 @@ pub mod golem { *base.add(0).cast::() = (0i32) as u8; } }; + match owner13 { + Some(e) => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (1i32) as u8; + let vec15 = e; + let ptr15 = vec15.as_ptr().cast::(); + let len15 = vec15.len(); + *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::() = len15; + *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr15.cast_mut(); + } + None => { + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::() = (0i32) as u8; + } + }; match type_13 { WitTypeNode::RecordType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; - let vec17 = e; - let len17 = vec17.len(); - let layout17 = _rt::alloc::Layout::from_size_align_unchecked( - vec17.len() * (3 * ::core::mem::size_of::<*const u8>()), + let vec18 = e; + let len18 = vec18.len(); + let layout18 = _rt::alloc::Layout::from_size_align_unchecked( + vec18.len() * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result17 = if layout17.size() != 0 { - let ptr = _rt::alloc::alloc(layout17).cast::(); + let result18 = if layout18.size() != 0 { + let ptr = _rt::alloc::alloc(layout18).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout17); + _rt::alloc::handle_alloc_error(layout18); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec17.into_iter().enumerate() { - let base = result17 + for (i, e) in vec18.into_iter().enumerate() { + let base = result18 .add(i * (3 * ::core::mem::size_of::<*const u8>())); { - let (t15_0, t15_1) = e; - let vec16 = t15_0; - let ptr16 = vec16.as_ptr().cast::(); - let len16 = vec16.len(); + let (t16_0, t16_1) = e; + let vec17 = t16_0; + let ptr17 = vec17.as_ptr().cast::(); + let len17 = vec17.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len16; - *base.add(0).cast::<*mut u8>() = ptr16.cast_mut(); + .cast::() = len17; + *base.add(0).cast::<*mut u8>() = ptr17.cast_mut(); *base .add(2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i32(t15_1); + .cast::() = _rt::as_i32(t16_1); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len17; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len18; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result17; - cleanup_list.extend_from_slice(&[(result17, layout17)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result18; + cleanup_list.extend_from_slice(&[(result18, layout18)]); } WitTypeNode::VariantType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; - let vec20 = e; - let len20 = vec20.len(); - let layout20 = _rt::alloc::Layout::from_size_align_unchecked( - vec20.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), + let vec21 = e; + let len21 = vec21.len(); + let layout21 = _rt::alloc::Layout::from_size_align_unchecked( + vec21.len() * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result20 = if layout20.size() != 0 { - let ptr = _rt::alloc::alloc(layout20).cast::(); + let result21 = if layout21.size() != 0 { + let ptr = _rt::alloc::alloc(layout21).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout20); + _rt::alloc::handle_alloc_error(layout21); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec20.into_iter().enumerate() { - let base = result20 + for (i, e) in vec21.into_iter().enumerate() { + let base = result21 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); { - let (t18_0, t18_1) = e; - let vec19 = t18_0; - let ptr19 = vec19.as_ptr().cast::(); - let len19 = vec19.len(); + let (t19_0, t19_1) = e; + let vec20 = t19_0; + let ptr20 = vec20.as_ptr().cast::(); + let len20 = vec20.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len19; - *base.add(0).cast::<*mut u8>() = ptr19.cast_mut(); - match t18_1 { + .cast::() = len20; + *base.add(0).cast::<*mut u8>() = ptr20.cast_mut(); + match t19_1 { Some(e) => { *base .add(2 * ::core::mem::size_of::<*const u8>()) @@ -4500,245 +4552,245 @@ pub mod golem { } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len20; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len21; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result20; - cleanup_list.extend_from_slice(&[(result20, layout20)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result21; + cleanup_list.extend_from_slice(&[(result21, layout21)]); } WitTypeNode::EnumType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (2i32) as u8; - let vec22 = e; - let len22 = vec22.len(); - let layout22 = _rt::alloc::Layout::from_size_align_unchecked( - vec22.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec23 = e; + let len23 = vec23.len(); + let layout23 = _rt::alloc::Layout::from_size_align_unchecked( + vec23.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result22 = if layout22.size() != 0 { - let ptr = _rt::alloc::alloc(layout22).cast::(); + let result23 = if layout23.size() != 0 { + let ptr = _rt::alloc::alloc(layout23).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout22); + _rt::alloc::handle_alloc_error(layout23); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec22.into_iter().enumerate() { - let base = result22 + for (i, e) in vec23.into_iter().enumerate() { + let base = result23 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec21 = e; - let ptr21 = vec21.as_ptr().cast::(); - let len21 = vec21.len(); + let vec22 = e; + let ptr22 = vec22.as_ptr().cast::(); + let len22 = vec22.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len21; - *base.add(0).cast::<*mut u8>() = ptr21.cast_mut(); + .cast::() = len22; + *base.add(0).cast::<*mut u8>() = ptr22.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len22; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len23; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result22; - cleanup_list.extend_from_slice(&[(result22, layout22)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result23; + cleanup_list.extend_from_slice(&[(result23, layout23)]); } WitTypeNode::FlagsType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (3i32) as u8; - let vec24 = e; - let len24 = vec24.len(); - let layout24 = _rt::alloc::Layout::from_size_align_unchecked( - vec24.len() * (2 * ::core::mem::size_of::<*const u8>()), + let vec25 = e; + let len25 = vec25.len(); + let layout25 = _rt::alloc::Layout::from_size_align_unchecked( + vec25.len() * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - let result24 = if layout24.size() != 0 { - let ptr = _rt::alloc::alloc(layout24).cast::(); + let result25 = if layout25.size() != 0 { + let ptr = _rt::alloc::alloc(layout25).cast::(); if ptr.is_null() { - _rt::alloc::handle_alloc_error(layout24); + _rt::alloc::handle_alloc_error(layout25); } ptr } else { ::core::ptr::null_mut() }; - for (i, e) in vec24.into_iter().enumerate() { - let base = result24 + for (i, e) in vec25.into_iter().enumerate() { + let base = result25 .add(i * (2 * ::core::mem::size_of::<*const u8>())); { - let vec23 = e; - let ptr23 = vec23.as_ptr().cast::(); - let len23 = vec23.len(); + let vec24 = e; + let ptr24 = vec24.as_ptr().cast::(); + let len24 = vec24.len(); *base .add(::core::mem::size_of::<*const u8>()) - .cast::() = len23; - *base.add(0).cast::<*mut u8>() = ptr23.cast_mut(); + .cast::() = len24; + *base.add(0).cast::<*mut u8>() = ptr24.cast_mut(); } } *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len24; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len25; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = result24; - cleanup_list.extend_from_slice(&[(result24, layout24)]); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = result25; + cleanup_list.extend_from_slice(&[(result25, layout25)]); } WitTypeNode::TupleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (4i32) as u8; - let vec25 = e; - let ptr25 = vec25.as_ptr().cast::(); - let len25 = vec25.len(); + let vec26 = e; + let ptr26 = vec26.as_ptr().cast::(); + let len26 = vec26.len(); *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) - .cast::() = len25; + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) + .cast::() = len26; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::<*mut u8>() = ptr25.cast_mut(); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>() = ptr26.cast_mut(); } WitTypeNode::ListType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (5i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::OptionType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (6i32) as u8; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } WitTypeNode::ResultType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (7i32) as u8; - let (t26_0, t26_1) = e; - match t26_0 { + let (t27_0, t27_1) = e; + match t27_0 { Some(e) => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; - match t26_1 { + match t27_1 { Some(e) => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (1i32) as u8; *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = _rt::as_i32(e); } None => { *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::() = (0i32) as u8; } }; } WitTypeNode::PrimU8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (8i32) as u8; } WitTypeNode::PrimU16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (9i32) as u8; } WitTypeNode::PrimU32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (10i32) as u8; } WitTypeNode::PrimU64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (11i32) as u8; } WitTypeNode::PrimS8Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (12i32) as u8; } WitTypeNode::PrimS16Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (13i32) as u8; } WitTypeNode::PrimS32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (14i32) as u8; } WitTypeNode::PrimS64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (15i32) as u8; } WitTypeNode::PrimF32Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (16i32) as u8; } WitTypeNode::PrimF64Type => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (17i32) as u8; } WitTypeNode::PrimCharType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (18i32) as u8; } WitTypeNode::PrimBoolType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (19i32) as u8; } WitTypeNode::PrimStringType => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (20i32) as u8; } WitTypeNode::HandleType(e) => { *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::() = (21i32) as u8; - let (t27_0, t27_1) = e; + let (t28_0, t28_1) = e; *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = _rt::as_i64(t27_0); + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = _rt::as_i64(t28_0); *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) - .cast::() = (t27_1.clone() as i32) as u8; + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) + .cast::() = (t28_1.clone() as i32) as u8; } } } } - let ptr29 = ret_area.0.as_mut_ptr().cast::(); + let ptr30 = ret_area.0.as_mut_ptr().cast::(); #[cfg(target_arch = "wasm32")] #[link(wasm_import_module = "golem:rpc/types@0.2.2")] unsafe extern "C" { #[link_name = "extract-type"] - fn wit_import30( + fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -4747,7 +4799,7 @@ pub mod golem { ); } #[cfg(not(target_arch = "wasm32"))] - unsafe extern "C" fn wit_import30( + unsafe extern "C" fn wit_import31( _: *mut u8, _: usize, _: *mut u8, @@ -4756,106 +4808,111 @@ pub mod golem { ) { unreachable!() } - unsafe { wit_import30(result11, len11, result28, len28, ptr29) }; - let l31 = *ptr29.add(0).cast::<*mut u8>(); - let l32 = *ptr29 + unsafe { wit_import31(result11, len11, result29, len29, ptr30) }; + let l32 = *ptr30.add(0).cast::<*mut u8>(); + let l33 = *ptr30 .add(::core::mem::size_of::<*const u8>()) .cast::(); - let base77 = l31; - let len77 = l32; - let mut result77 = _rt::Vec::with_capacity(len77); - for i in 0..len77 { - let base = base77 - .add(i * (32 + 2 * ::core::mem::size_of::<*const u8>())); - let e77 = { - let l33 = i32::from(*base.add(0).cast::()); - let l37 = i32::from( + let base82 = l32; + let len82 = l33; + let mut result82 = _rt::Vec::with_capacity(len82); + for i in 0..len82 { + let base = base82 + .add(i * (24 + 6 * ::core::mem::size_of::<*const u8>())); + let e82 = { + let l34 = i32::from(*base.add(0).cast::()); + let l38 = i32::from( + *base + .add(3 * ::core::mem::size_of::<*const u8>()) + .cast::(), + ); + let l42 = i32::from( *base - .add(8 + 2 * ::core::mem::size_of::<*const u8>()) + .add(6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let v76 = match l37 { + let v81 = match l42 { 0 => { - let e76 = { - let l38 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l43 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l39 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l44 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base44 = l38; - let len44 = l39; - let mut result44 = _rt::Vec::with_capacity(len44); - for i in 0..len44 { - let base = base44 + let base49 = l43; + let len49 = l44; + let mut result49 = _rt::Vec::with_capacity(len49); + for i in 0..len49 { + let base = base49 .add(i * (3 * ::core::mem::size_of::<*const u8>())); - let e44 = { - let l40 = *base.add(0).cast::<*mut u8>(); - let l41 = *base + let e49 = { + let l45 = *base.add(0).cast::<*mut u8>(); + let l46 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len42 = l41; - let bytes42 = _rt::Vec::from_raw_parts( - l40.cast(), - len42, - len42, + let len47 = l46; + let bytes47 = _rt::Vec::from_raw_parts( + l45.cast(), + len47, + len47, ); - let l43 = *base + let l48 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - (_rt::string_lift(bytes42), l43) + (_rt::string_lift(bytes47), l48) }; - result44.push(e44); + result49.push(e49); } _rt::cabi_dealloc( - base44, - len44 * (3 * ::core::mem::size_of::<*const u8>()), + base49, + len49 * (3 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result44 + result49 }; - WitTypeNode::RecordType(e76) + WitTypeNode::RecordType(e81) } 1 => { - let e76 = { - let l45 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l50 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l46 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l51 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base52 = l45; - let len52 = l46; - let mut result52 = _rt::Vec::with_capacity(len52); - for i in 0..len52 { - let base = base52 + let base57 = l50; + let len57 = l51; + let mut result57 = _rt::Vec::with_capacity(len57); + for i in 0..len57 { + let base = base57 .add(i * (8 + 2 * ::core::mem::size_of::<*const u8>())); - let e52 = { - let l47 = *base.add(0).cast::<*mut u8>(); - let l48 = *base + let e57 = { + let l52 = *base.add(0).cast::<*mut u8>(); + let l53 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len49 = l48; - let bytes49 = _rt::Vec::from_raw_parts( - l47.cast(), - len49, - len49, + let len54 = l53; + let bytes54 = _rt::Vec::from_raw_parts( + l52.cast(), + len54, + len54, ); - let l50 = i32::from( + let l55 = i32::from( *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - _rt::string_lift(bytes49), - match l50 { + _rt::string_lift(bytes54), + match l55 { 0 => None, 1 => { let e = { - let l51 = *base + let l56 = *base .add(4 + 2 * ::core::mem::size_of::<*const u8>()) .cast::(); - l51 + l56 }; Some(e) } @@ -4863,158 +4920,158 @@ pub mod golem { }, ) }; - result52.push(e52); + result57.push(e57); } _rt::cabi_dealloc( - base52, - len52 * (8 + 2 * ::core::mem::size_of::<*const u8>()), + base57, + len57 * (8 + 2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result52 + result57 }; - WitTypeNode::VariantType(e76) + WitTypeNode::VariantType(e81) } 2 => { - let e76 = { - let l53 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l58 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l54 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l59 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base58 = l53; - let len58 = l54; - let mut result58 = _rt::Vec::with_capacity(len58); - for i in 0..len58 { - let base = base58 + let base63 = l58; + let len63 = l59; + let mut result63 = _rt::Vec::with_capacity(len63); + for i in 0..len63 { + let base = base63 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e58 = { - let l55 = *base.add(0).cast::<*mut u8>(); - let l56 = *base + let e63 = { + let l60 = *base.add(0).cast::<*mut u8>(); + let l61 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len57 = l56; - let bytes57 = _rt::Vec::from_raw_parts( - l55.cast(), - len57, - len57, + let len62 = l61; + let bytes62 = _rt::Vec::from_raw_parts( + l60.cast(), + len62, + len62, ); - _rt::string_lift(bytes57) + _rt::string_lift(bytes62) }; - result58.push(e58); + result63.push(e63); } _rt::cabi_dealloc( - base58, - len58 * (2 * ::core::mem::size_of::<*const u8>()), + base63, + len63 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result58 + result63 }; - WitTypeNode::EnumType(e76) + WitTypeNode::EnumType(e81) } 3 => { - let e76 = { - let l59 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l64 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l60 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l65 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let base64 = l59; - let len64 = l60; - let mut result64 = _rt::Vec::with_capacity(len64); - for i in 0..len64 { - let base = base64 + let base69 = l64; + let len69 = l65; + let mut result69 = _rt::Vec::with_capacity(len69); + for i in 0..len69 { + let base = base69 .add(i * (2 * ::core::mem::size_of::<*const u8>())); - let e64 = { - let l61 = *base.add(0).cast::<*mut u8>(); - let l62 = *base + let e69 = { + let l66 = *base.add(0).cast::<*mut u8>(); + let l67 = *base .add(::core::mem::size_of::<*const u8>()) .cast::(); - let len63 = l62; - let bytes63 = _rt::Vec::from_raw_parts( - l61.cast(), - len63, - len63, + let len68 = l67; + let bytes68 = _rt::Vec::from_raw_parts( + l66.cast(), + len68, + len68, ); - _rt::string_lift(bytes63) + _rt::string_lift(bytes68) }; - result64.push(e64); + result69.push(e69); } _rt::cabi_dealloc( - base64, - len64 * (2 * ::core::mem::size_of::<*const u8>()), + base69, + len69 * (2 * ::core::mem::size_of::<*const u8>()), ::core::mem::size_of::<*const u8>(), ); - result64 + result69 }; - WitTypeNode::FlagsType(e76) + WitTypeNode::FlagsType(e81) } 4 => { - let e76 = { - let l65 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l70 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l66 = *base - .add(16 + 3 * ::core::mem::size_of::<*const u8>()) + let l71 = *base + .add(8 + 7 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len67 = l66; - _rt::Vec::from_raw_parts(l65.cast(), len67, len67) + let len72 = l71; + _rt::Vec::from_raw_parts(l70.cast(), len72, len72) }; - WitTypeNode::TupleType(e76) + WitTypeNode::TupleType(e81) } 5 => { - let e76 = { - let l68 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l73 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l68 + l73 }; - WitTypeNode::ListType(e76) + WitTypeNode::ListType(e81) } 6 => { - let e76 = { - let l69 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l74 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l69 + l74 }; - WitTypeNode::OptionType(e76) + WitTypeNode::OptionType(e81) } 7 => { - let e76 = { - let l70 = i32::from( + let e81 = { + let l75 = i32::from( *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - let l72 = i32::from( + let l77 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); ( - match l70 { + match l75 { 0 => None, 1 => { let e = { - let l71 = *base - .add(20 + 2 * ::core::mem::size_of::<*const u8>()) + let l76 = *base + .add(12 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l71 + l76 }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - match l72 { + match l77 { 0 => None, 1 => { let e = { - let l73 = *base - .add(28 + 2 * ::core::mem::size_of::<*const u8>()) + let l78 = *base + .add(20 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - l73 + l78 }; Some(e) } @@ -5022,7 +5079,7 @@ pub mod golem { }, ) }; - WitTypeNode::ResultType(e76) + WitTypeNode::ResultType(e81) } 8 => WitTypeNode::PrimU8Type, 9 => WitTypeNode::PrimU16Type, @@ -5039,66 +5096,88 @@ pub mod golem { 20 => WitTypeNode::PrimStringType, n => { debug_assert_eq!(n, 21, "invalid enum discriminant"); - let e76 = { - let l74 = *base - .add(16 + 2 * ::core::mem::size_of::<*const u8>()) + let e81 = { + let l79 = *base + .add(8 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(); - let l75 = i32::from( + let l80 = i32::from( *base - .add(24 + 2 * ::core::mem::size_of::<*const u8>()) + .add(16 + 6 * ::core::mem::size_of::<*const u8>()) .cast::(), ); - (l74 as u64, ResourceMode::_lift(l75 as u8)) + (l79 as u64, ResourceMode::_lift(l80 as u8)) }; - WitTypeNode::HandleType(e76) + WitTypeNode::HandleType(e81) } }; NamedWitTypeNode { - name: match l33 { + name: match l34 { 0 => None, 1 => { let e = { - let l34 = *base + let l35 = *base .add(::core::mem::size_of::<*const u8>()) .cast::<*mut u8>(); - let l35 = *base + let l36 = *base .add(2 * ::core::mem::size_of::<*const u8>()) .cast::(); - let len36 = l35; - let bytes36 = _rt::Vec::from_raw_parts( - l34.cast(), - len36, - len36, + let len37 = l36; + let bytes37 = _rt::Vec::from_raw_parts( + l35.cast(), + len37, + len37, + ); + _rt::string_lift(bytes37) + }; + Some(e) + } + _ => _rt::invalid_enum_discriminant(), + }, + owner: match l38 { + 0 => None, + 1 => { + let e = { + let l39 = *base + .add(4 * ::core::mem::size_of::<*const u8>()) + .cast::<*mut u8>(); + let l40 = *base + .add(5 * ::core::mem::size_of::<*const u8>()) + .cast::(); + let len41 = l40; + let bytes41 = _rt::Vec::from_raw_parts( + l39.cast(), + len41, + len41, ); - _rt::string_lift(bytes36) + _rt::string_lift(bytes41) }; Some(e) } _ => _rt::invalid_enum_discriminant(), }, - type_: v76, + type_: v81, } }; - result77.push(e77); + result82.push(e82); } _rt::cabi_dealloc( - base77, - len77 * (32 + 2 * ::core::mem::size_of::<*const u8>()), + base82, + len82 * (24 + 6 * ::core::mem::size_of::<*const u8>()), 8, ); - let result78 = WitType { nodes: result77 }; + let result83 = WitType { nodes: result82 }; if layout11.size() != 0 { _rt::alloc::dealloc(result11.cast(), layout11); } - if layout28.size() != 0 { - _rt::alloc::dealloc(result28.cast(), layout28); + if layout29.size() != 0 { + _rt::alloc::dealloc(result29.cast(), layout29); } for (ptr, layout) in cleanup_list { if layout.size() != 0 { _rt::alloc::dealloc(ptr.cast(), layout); } } - result78 + result83 } } } @@ -5633,8 +5712,8 @@ mod _rt { )] #[doc(hidden)] #[allow(clippy::octal_escapes)] -pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 2559] = *b"\ -\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\x80\x13\x01A\x02\x01\ +pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 2566] = *b"\ +\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\x87\x13\x01A\x02\x01\ A\x08\x01B\x05\x01r\x02\x07secondsw\x0bnanosecondsy\x04\0\x08datetime\x03\0\0\x01\ @\0\0\x01\x04\0\x03now\x01\x02\x04\0\x0aresolution\x01\x02\x03\0\x1cwasi:clocks/\ wall-clock@0.2.3\x05\0\x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04sel\ @@ -5654,39 +5733,39 @@ rd-type\x01\x11\0\x0cvariant-type\x01\x14\0\x09enum-type\x01\x15\0\x0aflags-type -type\0\0\x0dprim-u64-type\0\0\x0cprim-s8-type\0\0\x0dprim-s16-type\0\0\x0dprim-\ s32-type\0\0\x0dprim-s64-type\0\0\x0dprim-f32-type\0\0\x0dprim-f64-type\0\0\x0ep\ rim-char-type\0\0\x0eprim-bool-type\0\0\x10prim-string-type\0\0\x0bhandle-type\x01\ -\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01ks\x01r\x02\x04name\x1b\x04type\x1a\x04\ -\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\0\x08wit-\ -type\x03\0\x1f\x01r\x01\x05values\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01p\x7f\x01\ -j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0crecord-value\x01\x16\0\x0dvariant-valu\ -e\x01#\0\x0aenum-value\x01y\0\x0bflags-value\x01$\0\x0btuple-value\x01\x16\0\x0a\ -list-value\x01\x16\0\x0coption-value\x01\x12\0\x0cresult-value\x01%\0\x07prim-u8\ -\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\ -\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\ -\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-str\ -ing\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nodes)\x04\ -\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03typ\x20\x04\0\x0evalue-and-type\x03\ -\0,\x01q\x04\x0eprotocol-error\x01s\0\x06denied\x01s\0\x09not-found\x01s\0\x15re\ -mote-internal-error\x01s\0\x04\0\x09rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\x01\x04\ -\0\x14future-invoke-result\x03\x01\x04\0\x12cancellation-token\x03\x01\x01i0\x01\ -@\x01\x09worker-id\x09\03\x04\0\x15[constructor]wasm-rpc\x014\x01@\x01\x0ccompon\ -ent-id\x07\03\x04\0\x1a[static]wasm-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01+\x01\ -/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\08\x04\0![method]wasm-\ -rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffun\ -ction-params7\0:\x04\0\x17[method]wasm-rpc.invoke\x01;\x01i1\x01@\x03\x04self6\x0d\ -function-names\x0ffunction-params7\0<\x04\0'[method]wasm-rpc.async-invoke-and-aw\ -ait\x01=\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\x0ffunction-p\ -arams7\x01\0\x04\0$[method]wasm-rpc.schedule-invocation\x01>\x01i2\x01@\x04\x04s\ -elf6\x0escheduled-time\x01\x0dfunction-names\x0ffunction-params7\0?\x04\0/[metho\ -d]wasm-rpc.schedule-cancelable-invocation\x01@\x01h1\x01i\x03\x01@\x01\x04self\xc1\ -\0\0\xc2\0\x04\0&[method]future-invoke-result.subscribe\x01C\x01k8\x01@\x01\x04s\ -elf\xc1\0\0\xc4\0\x04\0\x20[method]future-invoke-result.get\x01E\x01h2\x01@\x01\x04\ -self\xc6\0\x01\0\x04\0![method]cancellation-token.cancel\x01G\x01j\x01\x05\x01s\x01\ -@\x01\x04uuids\0\xc8\0\x04\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\x04\0\x0e\ -uuid-to-string\x01J\x01@\x01\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01@\x01\x03\ -vnt-\0\x20\x04\0\x0cextract-type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\x04\x04\ -\0\x12golem:rpc/wasm-rpc\x04\0\x0b\x0e\x01\0\x08wasm-rpc\x03\0\0\0G\x09producers\ -\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.41\ -.0"; +\x18\0\x04\0\x0dwit-type-node\x03\0\x19\x01ks\x01r\x03\x04name\x1b\x05owner\x1b\x04\ +type\x1a\x04\0\x13named-wit-type-node\x03\0\x1c\x01p\x1d\x01r\x01\x05nodes\x1e\x04\ +\0\x08wit-type\x03\0\x1f\x01r\x01\x05values\x04\0\x03uri\x03\0!\x01o\x02y\x12\x01\ +p\x7f\x01j\x01\x12\x01\x12\x01o\x02\"w\x01q\x16\x0crecord-value\x01\x16\0\x0dvar\ +iant-value\x01#\0\x0aenum-value\x01y\0\x0bflags-value\x01$\0\x0btuple-value\x01\x16\ +\0\x0alist-value\x01\x16\0\x0coption-value\x01\x12\0\x0cresult-value\x01%\0\x07p\ +rim-u8\x01}\0\x08prim-u16\x01{\0\x08prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s\ +8\x01~\0\x08prim-s16\x01|\0\x08prim-s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float3\ +2\x01v\0\x0cprim-float64\x01u\0\x09prim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bpr\ +im-string\x01s\0\x06handle\x01&\0\x04\0\x08wit-node\x03\0'\x01p(\x01r\x01\x05nod\ +es)\x04\0\x09wit-value\x03\0*\x01r\x02\x05value+\x03typ\x20\x04\0\x0evalue-and-t\ +ype\x03\0,\x01q\x04\x0eprotocol-error\x01s\0\x06denied\x01s\0\x09not-found\x01s\0\ +\x15remote-internal-error\x01s\0\x04\0\x09rpc-error\x03\0.\x04\0\x08wasm-rpc\x03\ +\x01\x04\0\x14future-invoke-result\x03\x01\x04\0\x12cancellation-token\x03\x01\x01\ +i0\x01@\x01\x09worker-id\x09\03\x04\0\x15[constructor]wasm-rpc\x014\x01@\x01\x0c\ +component-id\x07\03\x04\0\x1a[static]wasm-rpc.ephemeral\x015\x01h0\x01p+\x01j\x01\ ++\x01/\x01@\x03\x04self6\x0dfunction-names\x0ffunction-params7\08\x04\0![method]\ +wasm-rpc.invoke-and-await\x019\x01j\0\x01/\x01@\x03\x04self6\x0dfunction-names\x0f\ +function-params7\0:\x04\0\x17[method]wasm-rpc.invoke\x01;\x01i1\x01@\x03\x04self\ +6\x0dfunction-names\x0ffunction-params7\0<\x04\0'[method]wasm-rpc.async-invoke-a\ +nd-await\x01=\x01@\x04\x04self6\x0escheduled-time\x01\x0dfunction-names\x0ffunct\ +ion-params7\x01\0\x04\0$[method]wasm-rpc.schedule-invocation\x01>\x01i2\x01@\x04\ +\x04self6\x0escheduled-time\x01\x0dfunction-names\x0ffunction-params7\0?\x04\0/[\ +method]wasm-rpc.schedule-cancelable-invocation\x01@\x01h1\x01i\x03\x01@\x01\x04s\ +elf\xc1\0\0\xc2\0\x04\0&[method]future-invoke-result.subscribe\x01C\x01k8\x01@\x01\ +\x04self\xc1\0\0\xc4\0\x04\0\x20[method]future-invoke-result.get\x01E\x01h2\x01@\ +\x01\x04self\xc6\0\x01\0\x04\0![method]cancellation-token.cancel\x01G\x01j\x01\x05\ +\x01s\x01@\x01\x04uuids\0\xc8\0\x04\0\x0aparse-uuid\x01I\x01@\x01\x04uuid\x05\0s\ +\x04\0\x0euuid-to-string\x01J\x01@\x01\x03vnt-\0+\x04\0\x0dextract-value\x01K\x01\ +@\x01\x03vnt-\0\x20\x04\0\x0cextract-type\x01L\x03\0\x15golem:rpc/types@0.2.2\x05\ +\x04\x04\0\x12golem:rpc/wasm-rpc\x04\0\x0b\x0e\x01\0\x08wasm-rpc\x03\0\0\0G\x09p\ +roducers\x01\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\ +\x060.41.0"; #[inline(never)] #[doc(hidden)] pub fn __link_custom_section_describing_imports() { diff --git a/wasm-rpc/src/json/impl.rs b/wasm-rpc/src/json/impl.rs index d9ffdef70e..ca4204bc48 100644 --- a/wasm-rpc/src/json/impl.rs +++ b/wasm-rpc/src/json/impl.rs @@ -51,7 +51,7 @@ impl ValueAndTypeJsonExtensions for ValueAndType { AnalysedType::Tuple(TypeTuple { items, .. }) => get_tuple(json_val, items), AnalysedType::Handle(TypeHandle { resource_id, mode, .. - }) => get_handle(json_val, resource_id.clone(), mode.clone()), + }) => get_handle(json_val, *resource_id, mode.clone()), } } @@ -478,6 +478,7 @@ fn get_enum(input_json: &JsonValue, names: &[String]) -> Result Result Result { - to_string(value).map_err(|err| err.to_string()) + println!("[print_value_and_type] value: {value:?}"); + if value.typ.contains_handle() { + Err("Cannot print handle type".to_string()) + } else { + to_string(value).map_err(|err| err.to_string()) + } } impl WasmValue for ValueAndType { diff --git a/wasm-rpc/src/value_and_type.rs b/wasm-rpc/src/value_and_type.rs index 445bcdb660..9dd23859b3 100644 --- a/wasm-rpc/src/value_and_type.rs +++ b/wasm-rpc/src/value_and_type.rs @@ -130,7 +130,7 @@ impl IntoValue for u32 { } fn get_type() -> AnalysedType { - analysed_type::u32() + u32() } } @@ -230,7 +230,7 @@ impl IntoValue for String { } fn get_type() -> AnalysedType { - analysed_type::str() + str() } } @@ -240,7 +240,7 @@ impl IntoValue for &str { } fn get_type() -> AnalysedType { - analysed_type::str() + str() } } @@ -326,9 +326,9 @@ impl IntoValue for Bound { fn get_type() -> AnalysedType { variant(vec![ - analysed_type::case("included", T::get_type()), - analysed_type::case("excluded", T::get_type()), - analysed_type::unit_case("unbounded"), + case("included", T::get_type()), + case("excluded", T::get_type()), + unit_case("unbounded"), ]) } } @@ -909,10 +909,12 @@ fn build_tree(node: &NamedWitTypeNode, nodes: &[NamedWitTypeNode]) -> AnalysedTy WitTypeNode::EnumType(names) => AnalysedType::Enum(TypeEnum { cases: names.clone(), name: node.name.clone(), + owner: node.owner.clone(), }), WitTypeNode::FlagsType(names) => AnalysedType::Flags(TypeFlags { names: names.clone(), name: node.name.clone(), + owner: node.owner.clone(), }), WitTypeNode::TupleType(types) => { let types = types @@ -997,9 +999,11 @@ impl WitTypeBuilder { let idx = self.nodes.len(); self.nodes.push(NamedWitTypeNode { name: None, + owner: None, type_: WitTypeNode::PrimBoolType, }); // placeholder, to be replaced let name = typ.name().map(|n| n.to_string()); + let owner = typ.owner().map(|o| o.to_string()); let node: WitTypeNode = match typ { AnalysedType::Variant(variant) => { let mut cases = Vec::new(); @@ -1054,12 +1058,16 @@ impl WitTypeBuilder { AnalysedType::Handle(handle) => WitTypeNode::HandleType(( handle.resource_id.0, match handle.mode { - AnalysedResourceMode::Owned => crate::ResourceMode::Owned, - AnalysedResourceMode::Borrowed => crate::ResourceMode::Borrowed, + AnalysedResourceMode::Owned => ResourceMode::Owned, + AnalysedResourceMode::Borrowed => ResourceMode::Borrowed, }, )), }; - self.nodes[idx] = NamedWitTypeNode { name, type_: node }; + self.nodes[idx] = NamedWitTypeNode { + name, + owner, + type_: node, + }; idx } } diff --git a/wasm-rpc/src/wasmtime.rs b/wasm-rpc/src/wasmtime.rs index bd34977f77..5dbd9345dd 100644 --- a/wasm-rpc/src/wasmtime.rs +++ b/wasm-rpc/src/wasmtime.rs @@ -43,12 +43,21 @@ impl Display for EncodingError { } } +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +#[cfg_attr(feature = "bincode", derive(bincode::Encode, bincode::Decode))] +pub struct ResourceTypeId { + /// Name of the WIT resource + pub name: String, + /// Owner of the resource, either an interface in a WIT package or a name of a world + pub owner: String, +} + #[async_trait] pub trait ResourceStore { fn self_uri(&self) -> Uri; - async fn add(&mut self, resource: ResourceAny) -> u64; - async fn get(&mut self, resource_id: u64) -> Option; - async fn borrow(&self, resource_id: u64) -> Option; + async fn add(&mut self, resource: ResourceAny, name: ResourceTypeId) -> u64; + async fn get(&mut self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)>; + async fn borrow(&self, resource_id: u64) -> Option<(ResourceTypeId, ResourceAny)>; } pub struct DecodeParamResult { @@ -436,7 +445,7 @@ async fn decode_param_impl( let uri = Uri { value: uri.clone() }; if resource_store.self_uri() == uri { match resource_store.get(*resource_id).await { - Some(resource) => Ok(DecodeParamResult { + Some((_, resource)) => Ok(DecodeParamResult { val: Val::Resource(resource), resources_to_drop: vec![resource], }), @@ -446,8 +455,8 @@ async fn decode_param_impl( } } else { Err(EncodingError::ValueMismatch { - details: format!("in {context} cannot resolve handle belonging to a different worker"), - }) + details: format!("in {context} cannot resolve handle belonging to a different worker"), + }) } } _ => Err(EncodingError::ParamTypeMismatch { @@ -463,7 +472,9 @@ async fn decode_param_impl( let uri = Uri { value: uri.clone() }; if resource_store.self_uri() == uri { match resource_store.borrow(*resource_id).await { - Some(resource) => Ok(DecodeParamResult::simple(Val::Resource(resource))), + Some((_, resource)) => { + Ok(DecodeParamResult::simple(Val::Resource(resource))) + } None => Err(EncodingError::ValueMismatch { details: format!("in {context} resource not found"), }), @@ -491,6 +502,7 @@ async fn decode_param_impl( pub async fn encode_output( value: &Val, typ: &Type, + analysed_typ: &AnalysedType, resource_store: &mut (impl ResourceStore + Send), ) -> Result { match value { @@ -510,9 +522,19 @@ pub async fn encode_output( Val::List(list) => { if let Type::List(list_type) = typ { let mut encoded_values = Vec::new(); + let inner_analysed_typ = if let AnalysedType::List(inner) = analysed_typ { + Ok(&*inner.inner) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected a List type for list value".to_string(), + }) + }?; + for value in (*list).iter() { - encoded_values - .push(encode_output(value, &list_type.ty(), resource_store).await?); + encoded_values.push( + encode_output(value, &list_type.ty(), inner_analysed_typ, resource_store) + .await?, + ); } Ok(Value::List(encoded_values)) } else { @@ -524,8 +546,20 @@ pub async fn encode_output( Val::Record(record) => { if let Type::Record(record_type) = typ { let mut encoded_values = Vec::new(); - for ((_name, value), field) in record.iter().zip(record_type.fields()) { - let field = encode_output(value, &field.ty, resource_store).await?; + for (idx, ((_name, value), field)) in + record.iter().zip(record_type.fields()).enumerate() + { + let field_analysed_type = if let AnalysedType::Record(inner) = analysed_typ { + Ok(&inner.fields[idx].typ) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected a Record type for record value".to_string(), + }) + }?; + + let field = + encode_output(value, &field.ty, field_analysed_type, resource_store) + .await?; encoded_values.push(field); } Ok(Value::Record(encoded_values)) @@ -538,8 +572,16 @@ pub async fn encode_output( Val::Tuple(tuple) => { if let Type::Tuple(tuple_type) = typ { let mut encoded_values = Vec::new(); - for (v, t) in tuple.iter().zip(tuple_type.types()) { - let value = encode_output(v, &t, resource_store).await?; + for (idx, (v, t)) in tuple.iter().zip(tuple_type.types()).enumerate() { + let item_analysed_type = if let AnalysedType::Tuple(inner) = analysed_typ { + Ok(&inner.items[idx]) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected a Tuple type for tuple value".to_string(), + }) + }?; + + let value = encode_output(v, &t, item_analysed_type, resource_store).await?; encoded_values.push(value); } Ok(Value::Tuple(encoded_values)) @@ -551,10 +593,20 @@ pub async fn encode_output( } Val::Variant(name, value) => { if let Type::Variant(variant_type) = typ { - let (discriminant, case) = variant_type + let (discriminant, case, analysed_case_type) = variant_type .cases() .enumerate() .find(|(_idx, case)| case.name == *name) + .map(|(idx, case)| { + if let AnalysedType::Variant(inner) = analysed_typ { + Ok((idx, case, &inner.cases[idx].typ)) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected a Variant type for variant value".to_string(), + }) + } + }) + .transpose()? .ok_or(EncodingError::ValueMismatch { details: format!("Could not find case for variant {name}"), })?; @@ -566,6 +618,11 @@ pub async fn encode_output( &case.ty.ok_or(EncodingError::ValueMismatch { details: "Could not get type information for case".to_string(), })?, + analysed_case_type + .as_ref() + .ok_or(EncodingError::ValueMismatch { + details: "Could not get type information for case".to_string(), + })?, resource_store, ) .await?, @@ -602,8 +659,21 @@ pub async fn encode_output( Val::Option(option) => match option { Some(value) => { if let Type::Option(option_type) = typ { - let encoded_output = - encode_output(value, &option_type.ty(), resource_store).await?; + let analysed_inner_type = if let AnalysedType::Option(inner) = analysed_typ { + Ok(&*inner.inner) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected an Option type for option value".to_string(), + }) + }?; + + let encoded_output = encode_output( + value, + &option_type.ty(), + analysed_inner_type, + resource_store, + ) + .await?; Ok(Value::Option(Some(Box::new(encoded_output)))) } else { Err(EncodingError::ValueMismatch { @@ -623,7 +693,22 @@ pub async fn encode_output( details: "Could not get ok type for result".to_string(), })?; - Some(encode_output(v, &t, resource_store).await?) + let analysed_ok_type = + if let AnalysedType::Result(inner) = analysed_typ { + Ok(inner.ok.as_ref().ok_or_else(|| { + EncodingError::ValueMismatch { + details: "Expected a Result type for result value" + .to_string(), + } + })?) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected a Result type for result value" + .to_string(), + }) + }?; + + Some(encode_output(v, &t, analysed_ok_type, resource_store).await?) } None => None, }; @@ -635,7 +720,23 @@ pub async fn encode_output( let t = result_type.err().ok_or(EncodingError::ValueMismatch { details: "Could not get error type for result".to_string(), })?; - Some(encode_output(v, &t, resource_store).await?) + + let analysed_err_type = + if let AnalysedType::Result(inner) = analysed_typ { + Ok(inner.err.as_ref().ok_or_else(|| { + EncodingError::ValueMismatch { + details: "Expected a Result type for result value" + .to_string(), + } + })?) + } else { + Err(EncodingError::ValueMismatch { + details: "Expected a Result type for result value" + .to_string(), + }) + }?; + + Some(encode_output(v, &t, analysed_err_type, resource_store).await?) } None => None, }; @@ -666,7 +767,19 @@ pub async fn encode_output( } } Val::Resource(resource) => { - let id = resource_store.add(*resource).await; + let type_id = analysed_typ + .name() + .and_then(|name| { + analysed_typ.owner().map(|owner| ResourceTypeId { + name: name.to_string(), + owner: owner.to_string(), + }) + }) + .ok_or_else(|| EncodingError::ValueMismatch { + details: "Resource type information is missing for resource value".to_string(), + })?; + + let id = resource_store.add(*resource, type_id).await; Ok(Value::Handle { uri: resource_store.self_uri().value, resource_id: id, @@ -736,6 +849,7 @@ pub fn type_to_analysed_type(typ: &Type) -> Result { ok, err, name: None, + owner: None, })) } Type::Flags(wflags) => Ok(flags(&wflags.names().collect::>())), diff --git a/wasm-rpc/wit/deps/golem-1.x/golem-host.wit b/wasm-rpc/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/wasm-rpc/wit/deps/golem-1.x/golem-host.wit +++ b/wasm-rpc/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/wasm-rpc/wit/deps/golem-rpc/wasm-rpc.wit b/wasm-rpc/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/wasm-rpc/wit/deps/golem-rpc/wasm-rpc.wit +++ b/wasm-rpc/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node } diff --git a/wit/deps.done b/wit/deps.done deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/wit/deps.lock b/wit/deps.lock index 6f09a309f3..7bc0515bd8 100644 --- a/wit/deps.lock +++ b/wit/deps.lock @@ -5,7 +5,7 @@ sha512 = "b37e4979adfe4f35c44786a1b79db9455ab56a02f28dfc6ae1cfb8d658bd92793d87e6 deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-agent", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] [all] -url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.5.tar.gz" +url = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" sha256 = "6ac4f1553003474229bb40a885b48d1eaa4bea2f9d679a115da9afede30b5ad4" sha512 = "ced8c18a35dc04123386465d98d2aeba54c486e4e22a30e7efac0548974e176528fcba36c64942d67fa35d9135806ff0fcde259eb4af051c4a29fcb397e9af1c" deps = ["blobstore", "cli", "clocks", "config", "filesystem", "golem-1.x", "golem-durability", "golem-rpc", "http", "io", "keyvalue", "logging", "random", "sockets"] @@ -31,20 +31,20 @@ sha256 = "69d42fb10a04a33545b17e055f13db9b1e10e82ba0ed5bdb52334e40dc07c679" sha512 = "612effbac6f4804fe0c29dae20b78bbba59e52cb754c15402f5fe229c3153a221e0fbdff1d9d00ceaa3fe049c6a95523a5b99f772f1c16d972eade2c88326a30" ["golem-1.x"] -sha256 = "d707888500487684ea753aa86547665221803d64445fcb1ef23470ded04eaab7" -sha512 = "7558b6110b7f8b43b8b9858e9236eba2569babf9a23204d186785e6693172c94856e271406b7753ed75c8e1fefb2558e7038b10f3dead448a4ea23975f3d10df" +sha256 = "cc4244f268f1a4a49c11085639798520b5f7a24ea8de052f326ccb97979ec0a8" +sha512 = "f6b26f65f31f02d0f7afaa518dd6dcae14a693577ffc6aa95e2a3d255d0a3728a7434227c51a2296f85cdef6a36231fb21badeef0a378c6e74695cf852bc77bf" [golem-agent] -sha256 = "7a7bab29059c195c95878c1ad3cacdb2e82ba7a89e309684eedfe02cbe2c5bcf" -sha512 = "71c638d2f5c75627423f31ce4e8b518831636ebb32b1948384df3a47595a408e8b3a4a415f20ec571135ca2a5e1fc5684bb9c91f0b7f00fcb79bef3f00e11d8f" +sha256 = "5b4b7a7f7f6fca429cf241139e0ec56ef393559e355a3eee2f0a3ff66a0c516b" +sha512 = "27151b72ee8b0c68316198d89306de39f831d9ea7786e9d47676eee533de33a2116e6dcf0ff65ef07d24b85b1689bb83e5e7dbaf40a49fef29c0419e766fd40a" [golem-durability] sha256 = "c5f8b9b4bda5a8d5d1d008978abed617c18da7d9c24167bf20a81a379d10d688" sha512 = "40e09d412fd6faee904ce6f8abdcf3f83a604eca3628bf5605b7667540874ea53f9e29392059dac327ca96a0f1298372cb0626abcf66a1df4f4180731c13646a" [golem-rpc] -sha256 = "a73f66a61e81b237057117b14aecc6c4c20eb004a4244ae10a51a876f71cf626" -sha512 = "396a1738320f7dc34a9a066755397b132b976e81c7cd28a8f45ff32aa5ea3226eb91d1e26d73995104b397fbd063ff83090550718f805773ceb78eb4f2155acf" +sha256 = "5ba11ce01c333b3e9ef877431c8d447c9617711cf40cb2f41c1261ea7b883f14" +sha512 = "fafc17bdc2bdc4eb84510272e4ddec587ad0d835d764124b20cd67cb8d91551d4b603e63cb8d04721b43843de56249c0420e4cdfd788367fd746c3196c1d46c6" [http] sha256 = "72d3a00dbf39eed40a134e8b1dee85834961153f9d205ee4dd56657270c084ce" diff --git a/wit/deps.toml b/wit/deps.toml index 85cded924c..b974aacb78 100644 --- a/wit/deps.toml +++ b/wit/deps.toml @@ -1,3 +1,3 @@ -all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.5.tar.gz" +all = "https://github.com/golemcloud/golem-wit/archive/v1.3.0-dev.6.tar.gz" agent = "https://github.com/golemcloud/golem-agentic/archive/main.tar.gz" rdbms = "https://github.com/golemcloud/wasi-rdbms/archive/golem-rdbms.tar.gz" diff --git a/wit/deps/golem-1.x/golem-host.wit b/wit/deps/golem-1.x/golem-host.wit index bb932f7675..80cbe329a0 100644 --- a/wit/deps/golem-1.x/golem-host.wit +++ b/wit/deps/golem-1.x/golem-host.wit @@ -4,7 +4,7 @@ package golem:api@1.1.7; /// the durability and transactional guarantees the executor provides. interface host { use wasi:clocks/monotonic-clock@0.2.3.{duration}; - use golem:rpc/types@0.2.2.{component-id, uuid, worker-id}; + use golem:rpc/types@0.2.2.{component-id, uuid, value-and-type, worker-id}; /// An index into the persistent log storing all performed operations of a worker type oplog-index = u64; @@ -121,12 +121,19 @@ interface host { value: string } + record worker-wasi-config-vars-filter { + name: string, + comparator: string-filter-comparator, + value: string + } + variant worker-property-filter { name(worker-name-filter), status(worker-status-filter), version(worker-version-filter), created-at(worker-created-at-filter), - env(worker-env-filter) + env(worker-env-filter), + wasi-config-vars(worker-wasi-config-vars-filter) } record worker-all-filter { @@ -141,6 +148,7 @@ interface host { worker-id: worker-id, args: list, env: list>, + wasi-config-vars: list>, status: worker-status, component-version: u64, retry-count: u64 diff --git a/wit/deps/golem-agent/common.wit b/wit/deps/golem-agent/common.wit index c725c768d2..4282355cb3 100644 --- a/wit/deps/golem-agent/common.wit +++ b/wit/deps/golem-agent/common.wit @@ -1,7 +1,7 @@ package golem:agent; interface common { - use golem:rpc/types@0.2.2.{wit-type, wit-value}; + use golem:rpc/types@0.2.2.{value-and-type, wit-type, wit-value}; type url = string; @@ -103,6 +103,6 @@ interface common { invalid-method(string), invalid-type(string), invalid-agent-id(string), - custom-error(data-value), + custom-error(value-and-type), } } diff --git a/wit/deps/golem-agent/guest.wit b/wit/deps/golem-agent/guest.wit index e71b8c8e7c..4fe6473eea 100644 --- a/wit/deps/golem-agent/guest.wit +++ b/wit/deps/golem-agent/guest.wit @@ -15,6 +15,10 @@ interface guest { get-agent: func(agent-type: string, agent-id: string) -> agent; + /// Invokes an agent method on an agent of a given type and ID. + /// Equivalent of getting an agent with `get-agent` and calling `invoke` on that. + invoke-agent: func(agent-type: string, agent-id: string, method-name: string, input: data-value) -> result; + discover-agents: func() -> list; discover-agent-types: func() -> list; @@ -25,3 +29,7 @@ world agent-guest { import golem:rpc/types@0.2.2; export guest; } + +world agent-host { + export host; +} diff --git a/wit/deps/golem-agent/host.wit b/wit/deps/golem-agent/host.wit new file mode 100644 index 0000000000..0428b5cc86 --- /dev/null +++ b/wit/deps/golem-agent/host.wit @@ -0,0 +1,8 @@ +package golem:agent; + +interface host { + use common.{data-value}; + + register-agent: func(agent-type: string, agent-id: string, constructor-parameters: data-value); + unregister-agent: func(agent-type: string, agent-id: string, constructor-parameters: data-value); +} diff --git a/wit/deps/golem-rpc/wasm-rpc.wit b/wit/deps/golem-rpc/wasm-rpc.wit index c4ed84cc35..372919b05c 100644 --- a/wit/deps/golem-rpc/wasm-rpc.wit +++ b/wit/deps/golem-rpc/wasm-rpc.wit @@ -71,6 +71,7 @@ interface types { record named-wit-type-node { name: option, + owner: option, %type: wit-type-node }