From d9078c714d67f484b1c034431444e4465e06cb9b Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Mon, 18 Mar 2024 18:42:21 +0100 Subject: [PATCH 01/20] Add bindings for the pinned metrics --- go.mod | 2 ++ go.sum | 4 +++ internal/api/bindings.h | 2 ++ internal/api/lib.go | 16 ++++++++++ libwasmvm/Cargo.lock | 29 ++++++++++++++++-- libwasmvm/Cargo.toml | 2 ++ libwasmvm/bindings.h | 2 ++ libwasmvm/src/cache.rs | 59 +++++++++++++++++++++++++++++++++++++ libwasmvm/src/error/rust.rs | 20 +++++++++++++ types/types.go | 9 ++++++ 10 files changed, 142 insertions(+), 3 deletions(-) diff --git a/go.mod b/go.mod index 133700f6a..9b3f0722d 100644 --- a/go.mod +++ b/go.mod @@ -12,6 +12,8 @@ require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/kr/pretty v0.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect + github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index ad7a24b92..04639096c 100644 --- a/go.sum +++ b/go.sum @@ -17,6 +17,10 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8= +github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok= +github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g= +github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/internal/api/bindings.h b/internal/api/bindings.h index 6e778a96f..88c04e117 100644 --- a/internal/api/bindings.h +++ b/internal/api/bindings.h @@ -441,6 +441,8 @@ struct AnalysisReport analyze_code(struct cache_t *cache, struct Metrics get_metrics(struct cache_t *cache, struct UnmanagedVector *error_msg); +struct UnmanagedVector get_pinned_metrics(struct cache_t *cache, struct UnmanagedVector *error_msg); + /** * frees a cache reference * diff --git a/internal/api/lib.go b/internal/api/lib.go index 56924437e..a6e9cb62c 100644 --- a/internal/api/lib.go +++ b/internal/api/lib.go @@ -14,6 +14,7 @@ import ( "golang.org/x/sys/unix" "github.com/CosmWasm/wasmvm/v2/types" + "github.com/vmihailenco/msgpack/v5" ) // Value types @@ -190,6 +191,21 @@ func GetMetrics(cache Cache) (*types.Metrics, error) { }, nil } +func GetPinnedMetrics(cache Cache) (*types.PinnedMetrics, error) { + errmsg := uninitializedUnmanagedVector() + metrics, err := C.get_pinned_metrics(cache.ptr, &errmsg) + if err != nil { + return nil, errorWithMessage(err, errmsg) + } + + var pinnedMetrics types.PinnedMetrics + if err := msgpack.Unmarshal(copyAndDestroyUnmanagedVector(metrics), &pinnedMetrics); err != nil { + return nil, err + } + + return &pinnedMetrics, nil +} + func Instantiate( cache Cache, checksum []byte, diff --git a/libwasmvm/Cargo.lock b/libwasmvm/Cargo.lock index a3525a2a1..b7f53a18e 100644 --- a/libwasmvm/Cargo.lock +++ b/libwasmvm/Cargo.lock @@ -19,9 +19,9 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" [[package]] name = "ahash" -version = "0.7.7" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd" +checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" dependencies = [ "getrandom", "once_cell", @@ -1059,7 +1059,7 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" dependencies = [ - "ahash 0.7.7", + "ahash 0.7.8", ] [[package]] @@ -1594,6 +1594,28 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "rmp" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f9860a6cc38ed1da53456442089b4dfa35e7cedaa326df63017af88385e6b20" +dependencies = [ + "byteorder", + "num-traits", + "paste", +] + +[[package]] +name = "rmp-serde" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bffea85eea980d8a74453e5d02a8d93028f3c34725de143085a844ebe953258a" +dependencies = [ + "byteorder", + "rmp", + "serde", +] + [[package]] name = "rustc-demangle" version = "0.1.23" @@ -2430,6 +2452,7 @@ dependencies = [ "cosmwasm-vm", "errno", "hex", + "rmp-serde", "serde", "serde_json", "tempfile", diff --git a/libwasmvm/Cargo.toml b/libwasmvm/Cargo.toml index b3f136761..f289d323b 100644 --- a/libwasmvm/Cargo.toml +++ b/libwasmvm/Cargo.toml @@ -29,6 +29,8 @@ backtraces = [] cosmwasm-std = { git = "https://github.com/CosmWasm/cosmwasm.git", rev = "v2.1.0-rc.1", features = ["staking", "stargate", "iterator"] } cosmwasm-vm = { git = "https://github.com/CosmWasm/cosmwasm.git", rev = "v2.1.0-rc.1", features = ["staking", "stargate", "iterator"] } errno = "0.3.8" +rmp-serde = "1.1.2" +serde = { version = "1.0.103", features = ["derive"] } serde_json = "1.0.91" thiserror = "1.0.38" hex = "0.4.3" diff --git a/libwasmvm/bindings.h b/libwasmvm/bindings.h index 6e778a96f..88c04e117 100644 --- a/libwasmvm/bindings.h +++ b/libwasmvm/bindings.h @@ -441,6 +441,8 @@ struct AnalysisReport analyze_code(struct cache_t *cache, struct Metrics get_metrics(struct cache_t *cache, struct UnmanagedVector *error_msg); +struct UnmanagedVector get_pinned_metrics(struct cache_t *cache, struct UnmanagedVector *error_msg); + /** * frees a cache reference * diff --git a/libwasmvm/src/cache.rs b/libwasmvm/src/cache.rs index 1fd20f3ee..83086d23f 100644 --- a/libwasmvm/src/cache.rs +++ b/libwasmvm/src/cache.rs @@ -5,6 +5,7 @@ use std::str::from_utf8; use cosmwasm_std::Checksum; use cosmwasm_vm::{capabilities_from_csv, Cache, CacheOptions, Size}; +use serde::Serialize; use crate::api::GoApi; use crate::args::{AVAILABLE_CAPABILITIES_ARG, CACHE_ARG, CHECKSUM_ARG, DATA_DIR_ARG, WASM_ARG}; @@ -415,6 +416,64 @@ fn do_get_metrics(cache: &mut Cache) -> Result for PerModuleMetrics { + fn from(value: cosmwasm_vm::PerModuleMetrics) -> Self { + Self { + hits: value.hits, + size: value.size, + } + } +} + +#[derive(Serialize)] +struct PinnedMetrics { + per_module: Vec<(Checksum, PerModuleMetrics)>, +} + +impl From for PinnedMetrics { + fn from(value: cosmwasm_vm::PinnedMetrics) -> Self { + Self { + per_module: value + .per_module + .iter() + .cloned() + .map(|(checksum, metrics)| (checksum, metrics.into())) + .collect(), + } + } +} + +#[no_mangle] +pub extern "C" fn get_pinned_metrics( + cache: *mut cache_t, + error_msg: Option<&mut UnmanagedVector>, +) -> UnmanagedVector { + let r = match to_cache(cache) { + Some(c) => { + catch_unwind(AssertUnwindSafe(move || do_get_pinned_metrics(c))).unwrap_or_else(|err| { + eprintln!("Panic in do_get_pinned_metrics: {err:?}"); + Err(Error::panic()) + }) + } + None => Err(Error::unset_arg(CACHE_ARG)), + }; + handle_c_error_default(r, error_msg) +} + +fn do_get_pinned_metrics( + cache: &mut Cache, +) -> Result { + let pinned_metrics = PinnedMetrics::from(cache.pinned_metrics()); + let edgerunner = rmp_serde::to_vec_named(&pinned_metrics)?; + Ok(UnmanagedVector::new(Some(edgerunner))) +} + /// frees a cache reference /// /// # Safety diff --git a/libwasmvm/src/error/rust.rs b/libwasmvm/src/error/rust.rs index cb0656dcc..a6682d667 100644 --- a/libwasmvm/src/error/rust.rs +++ b/libwasmvm/src/error/rust.rs @@ -22,6 +22,12 @@ pub enum RustError { #[cfg(feature = "backtraces")] backtrace: Backtrace, }, + #[error("Cannot serialize to MessagePack: {msg}")] + MessagePack { + msg: String, + #[cfg(feature = "backtraces")] + backtrace: Backtrace, + }, #[error("Ran out of gas")] OutOfGas { #[cfg(feature = "backtraces")] @@ -68,6 +74,14 @@ impl RustError { } } + pub fn message_pack(msg: S) -> Self { + RustError::MessagePack { + msg: msg.to_string(), + #[cfg(feature = "backtraces")] + backtrace: Backtrace::capture(), + } + } + pub fn panic() -> Self { RustError::Panic { #[cfg(feature = "backtraces")] @@ -121,6 +135,12 @@ impl From for RustError { } } +impl From for RustError { + fn from(source: rmp_serde::encode::Error) -> Self { + RustError::message_pack(source) + } +} + impl From for RustError { fn from(source: std::str::Utf8Error) -> Self { RustError::invalid_utf8(source) diff --git a/types/types.go b/types/types.go index b9cbe7ebb..d3e501838 100644 --- a/types/types.go +++ b/types/types.go @@ -189,6 +189,15 @@ type Metrics struct { SizeMemoryCache uint64 } +type PerModuleMetrics struct { + Hits uint32 + Size uint64 +} + +type PinnedMetrics struct { + PerModule PerModuleMetrics `json:"per_module"` +} + // Array is a wrapper around a slice that ensures that we get "[]" JSON for nil values. // When unmarshaling, we get an empty slice for "[]" and "null". // From b55dc36251e8134932b173e51c603ea887f8e118 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Mon, 18 Mar 2024 18:52:49 +0100 Subject: [PATCH 02/20] Update go.mod --- go.mod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 9b3f0722d..b662b3c7f 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,7 @@ go 1.21 require ( github.com/google/btree v1.0.0 github.com/stretchr/testify v1.8.1 + github.com/vmihailenco/msgpack/v5 v5.4.1 golang.org/x/sys v0.16.0 ) @@ -12,7 +13,6 @@ require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/kr/pretty v0.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect From 06deb1ec099ee17822bee3ef83f7332215067d61 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Mon, 18 Mar 2024 18:56:48 +0100 Subject: [PATCH 03/20] Fix lints --- internal/api/lib.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/internal/api/lib.go b/internal/api/lib.go index a6e9cb62c..1133111b8 100644 --- a/internal/api/lib.go +++ b/internal/api/lib.go @@ -13,8 +13,9 @@ import ( "golang.org/x/sys/unix" - "github.com/CosmWasm/wasmvm/v2/types" "github.com/vmihailenco/msgpack/v5" + + "github.com/CosmWasm/wasmvm/v2/types" ) // Value types From 47f26747a91138ee9b214c6061935d9e01271742 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 11:23:06 +0100 Subject: [PATCH 04/20] Make unmarshal function associated --- internal/api/lib.go | 4 +--- types/types.go | 6 ++++++ 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/internal/api/lib.go b/internal/api/lib.go index 1133111b8..35f5b877f 100644 --- a/internal/api/lib.go +++ b/internal/api/lib.go @@ -13,8 +13,6 @@ import ( "golang.org/x/sys/unix" - "github.com/vmihailenco/msgpack/v5" - "github.com/CosmWasm/wasmvm/v2/types" ) @@ -200,7 +198,7 @@ func GetPinnedMetrics(cache Cache) (*types.PinnedMetrics, error) { } var pinnedMetrics types.PinnedMetrics - if err := msgpack.Unmarshal(copyAndDestroyUnmanagedVector(metrics), &pinnedMetrics); err != nil { + if err := pinnedMetrics.UnmarshalMessagePack(copyAndDestroyUnmanagedVector(metrics)); err != nil { return nil, err } diff --git a/types/types.go b/types/types.go index d3e501838..3bdaa4eaa 100644 --- a/types/types.go +++ b/types/types.go @@ -4,6 +4,8 @@ import ( "encoding/json" "fmt" "strconv" + + "github.com/vmihailenco/msgpack/v5" ) // Uint64 is a wrapper for uint64, but it is marshalled to and from JSON as a string @@ -198,6 +200,10 @@ type PinnedMetrics struct { PerModule PerModuleMetrics `json:"per_module"` } +func (pm *PinnedMetrics) UnmarshalMessagePack(data []byte) error { + return msgpack.Unmarshal(data, pm) +} + // Array is a wrapper around a slice that ensures that we get "[]" JSON for nil values. // When unmarshaling, we get an empty slice for "[]" and "null". // From 94cb09d349611aad80669641d52529984c2f5322 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 11:24:31 +0100 Subject: [PATCH 05/20] Add Nix flake with dev shell --- flake.lock | 85 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ flake.nix | 36 +++++++++++++++++++++++ 2 files changed, 121 insertions(+) create mode 100644 flake.lock create mode 100644 flake.nix diff --git a/flake.lock b/flake.lock new file mode 100644 index 000000000..f0a466b0a --- /dev/null +++ b/flake.lock @@ -0,0 +1,85 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1710146030, + "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1710631334, + "narHash": "sha256-rL5LSYd85kplL5othxK5lmAtjyMOBg390sGBTb3LRMM=", + "owner": "nixos", + "repo": "nixpkgs", + "rev": "c75037bbf9093a2acb617804ee46320d6d1fea5a", + "type": "github" + }, + "original": { + "owner": "nixos", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs", + "rust-overlay": "rust-overlay" + } + }, + "rust-overlay": { + "inputs": { + "flake-utils": [ + "flake-utils" + ], + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1710814282, + "narHash": "sha256-nWaKhMQackiO0M8504HSx/E7I76C2r0/g4wqZf4hp24=", + "owner": "oxalica", + "repo": "rust-overlay", + "rev": "8c72f33c23c8e537dd59088c4560222c43eedaca", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "rust-overlay", + "type": "github" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 000000000..aafab5efc --- /dev/null +++ b/flake.nix @@ -0,0 +1,36 @@ +{ + description = "Devshell flake"; + + inputs = { + flake-utils.url = "github:numtide/flake-utils"; + nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable"; + rust-overlay = { + inputs = { + flake-utils.follows = "flake-utils"; + nixpkgs.follows = "nixpkgs"; + }; + url = "github:oxalica/rust-overlay"; + }; + }; + + outputs = { self, nixpkgs, flake-utils, rust-overlay } @ inputs: + flake-utils.lib.eachDefaultSystem (system: + let + overlays = [ (import rust-overlay) ]; + pkgs = import nixpkgs { + inherit overlays system; + }; + in + { + formatter = pkgs.nixpkgs-fmt; + + devShells.default = pkgs.mkShell { + buildInputs = with pkgs; [ + go + gofumpt + golangci-lint + ]; + }; + } + ); +} From 260e8e11eef105dc94c8ae7567e2c54f510bff5f Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 11:37:28 +0100 Subject: [PATCH 06/20] Add Go test for pinned metrics --- internal/api/lib_test.go | 57 ++++++++++++++++++++++++++++++++++++++++ types/checksum.go | 4 +++ types/types.go | 2 +- 3 files changed, 62 insertions(+), 1 deletion(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index e0d29debc..9242b449d 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -382,6 +382,63 @@ func TestGetMetrics(t *testing.T) { require.InEpsilon(t, 3700000, metrics.SizeMemoryCache, 0.25) } +func TestGetPinnedMetrics(t *testing.T) { + cache, cleanup := withCache(t) + defer cleanup() + + // GetMetrics 1 + metrics, err := GetPinnedMetrics(cache) + require.NoError(t, err) + assert.Equal(t, &types.PinnedMetrics{PerModule: make(map[string]types.PerModuleMetrics, 0)}, metrics) + + // Store contract 1 + wasm, err := os.ReadFile("../../testdata/hackatom.wasm") + require.NoError(t, err) + checksum, err := StoreCode(cache, wasm) + require.NoError(t, err) + + err = Pin(cache, checksum) + require.NoError(t, err) + + // Store contract 2 + cyberpunkWasm, err := os.ReadFile("../../testdata/cyberpunk.wasm") + require.NoError(t, err) + cyberpunkChecksum, err := StoreCode(cache, cyberpunkWasm) + require.NoError(t, err) + + err = Pin(cache, cyberpunkChecksum) + require.NoError(t, err) + + checksumStr := types.Checksum(checksum).EncodeHex() + cyberpunkChecksumStr := types.Checksum(cyberpunkChecksum).EncodeHex() + + // GetMetrics 2 + metrics, err = GetPinnedMetrics(cache) + require.NoError(t, err) + assert.Equal(t, len(metrics.PerModule), 2) + assert.Equal(t, metrics.PerModule[checksumStr].Hits, 0) + assert.Equal(t, metrics.PerModule[cyberpunkChecksumStr].Hits, 0) + + // Instantiate 1 + gasMeter := NewMockGasMeter(TESTING_GAS_LIMIT) + igasMeter := types.GasMeter(gasMeter) + store := NewLookup(gasMeter) + api := NewMockAPI() + querier := DefaultQuerier(MOCK_CONTRACT_ADDR, types.Array[types.Coin]{types.NewCoin(100, "ATOM")}) + env := MockEnvBin(t) + info := MockInfoBin(t, "creator") + msg1 := []byte(`{"verifier": "fred", "beneficiary": "bob"}`) + _, _, err = Instantiate(cache, checksum, env, info, msg1, &igasMeter, store, api, &querier, TESTING_GAS_LIMIT, TESTING_PRINT_DEBUG) + require.NoError(t, err) + + // GetMetrics 3 + metrics, err = GetPinnedMetrics(cache) + require.NoError(t, err) + assert.Equal(t, len(metrics.PerModule), 1) + assert.Equal(t, metrics.PerModule[checksumStr].Hits, 1) + assert.Equal(t, metrics.PerModule[cyberpunkChecksumStr].Hits, 0) +} + func TestInstantiate(t *testing.T) { cache, cleanup := withCache(t) defer cleanup() diff --git a/types/checksum.go b/types/checksum.go index 03d664021..bb472e317 100644 --- a/types/checksum.go +++ b/types/checksum.go @@ -10,6 +10,10 @@ import ( // The length of a checksum must always be ChecksumLen. type Checksum []byte +func (cs Checksum) EncodeHex() string { + return hex.EncodeToString(cs) +} + func (cs Checksum) MarshalJSON() ([]byte, error) { return json.Marshal(hex.EncodeToString(cs)) } diff --git a/types/types.go b/types/types.go index 3bdaa4eaa..4c1aa5264 100644 --- a/types/types.go +++ b/types/types.go @@ -197,7 +197,7 @@ type PerModuleMetrics struct { } type PinnedMetrics struct { - PerModule PerModuleMetrics `json:"per_module"` + PerModule map[string]PerModuleMetrics `json:"per_module"` } func (pm *PinnedMetrics) UnmarshalMessagePack(data []byte) error { From ac2947108a659dda1dc3206f5bc645cd8a731e0d Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 11:51:55 +0100 Subject: [PATCH 07/20] Fix test expectation --- internal/api/lib_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index 9242b449d..11d2c9245 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -389,7 +389,7 @@ func TestGetPinnedMetrics(t *testing.T) { // GetMetrics 1 metrics, err := GetPinnedMetrics(cache) require.NoError(t, err) - assert.Equal(t, &types.PinnedMetrics{PerModule: make(map[string]types.PerModuleMetrics, 0)}, metrics) + assert.Equal(t, &types.PinnedMetrics{PerModule: nil}, metrics) // Store contract 1 wasm, err := os.ReadFile("../../testdata/hackatom.wasm") From e1dbd4e522c954c90d00b6389478064b26939d7f Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 12:00:41 +0100 Subject: [PATCH 08/20] Swap around assert order --- internal/api/lib_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index 11d2c9245..98b8561fa 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -415,9 +415,9 @@ func TestGetPinnedMetrics(t *testing.T) { // GetMetrics 2 metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) - assert.Equal(t, len(metrics.PerModule), 2) - assert.Equal(t, metrics.PerModule[checksumStr].Hits, 0) - assert.Equal(t, metrics.PerModule[cyberpunkChecksumStr].Hits, 0) + assert.Equal(t, 2, len(metrics.PerModule)) + assert.Equal(t, 0, metrics.PerModule[checksumStr].Hits) + assert.Equal(t, 0, metrics.PerModule[cyberpunkChecksumStr].Hits) // Instantiate 1 gasMeter := NewMockGasMeter(TESTING_GAS_LIMIT) @@ -434,9 +434,9 @@ func TestGetPinnedMetrics(t *testing.T) { // GetMetrics 3 metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) - assert.Equal(t, len(metrics.PerModule), 1) - assert.Equal(t, metrics.PerModule[checksumStr].Hits, 1) - assert.Equal(t, metrics.PerModule[cyberpunkChecksumStr].Hits, 0) + assert.Equal(t, 1, len(metrics.PerModule)) + assert.Equal(t, 1, metrics.PerModule[checksumStr].Hits) + assert.Equal(t, 0, metrics.PerModule[cyberpunkChecksumStr].Hits) } func TestInstantiate(t *testing.T) { From 88cb2d7bc5b44705311f708f69f97ee3d22be278 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 12:14:56 +0100 Subject: [PATCH 09/20] Tag map as array --- internal/api/lib_test.go | 8 ++++---- types/types.go | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index 98b8561fa..57aa0b6fc 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -416,8 +416,8 @@ func TestGetPinnedMetrics(t *testing.T) { metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) assert.Equal(t, 2, len(metrics.PerModule)) - assert.Equal(t, 0, metrics.PerModule[checksumStr].Hits) - assert.Equal(t, 0, metrics.PerModule[cyberpunkChecksumStr].Hits) + assert.Equal(t, uint32(0), metrics.PerModule[checksumStr].Hits) + assert.Equal(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Hits) // Instantiate 1 gasMeter := NewMockGasMeter(TESTING_GAS_LIMIT) @@ -435,8 +435,8 @@ func TestGetPinnedMetrics(t *testing.T) { metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) assert.Equal(t, 1, len(metrics.PerModule)) - assert.Equal(t, 1, metrics.PerModule[checksumStr].Hits) - assert.Equal(t, 0, metrics.PerModule[cyberpunkChecksumStr].Hits) + assert.Equal(t, uint32(1), metrics.PerModule[checksumStr].Hits) + assert.Equal(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Hits) } func TestInstantiate(t *testing.T) { diff --git a/types/types.go b/types/types.go index 4c1aa5264..b723a4842 100644 --- a/types/types.go +++ b/types/types.go @@ -197,7 +197,7 @@ type PerModuleMetrics struct { } type PinnedMetrics struct { - PerModule map[string]PerModuleMetrics `json:"per_module"` + PerModule map[string]PerModuleMetrics `json:"per_module" msgpack:",asarray"` } func (pm *PinnedMetrics) UnmarshalMessagePack(data []byte) error { From 37b95b07b6346afef76cfc499ab07d28da9a1904 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 12:19:50 +0100 Subject: [PATCH 10/20] Use `HashMap` in Rust --- libwasmvm/src/cache.rs | 4 ++-- types/types.go | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libwasmvm/src/cache.rs b/libwasmvm/src/cache.rs index 83086d23f..7f84662b3 100644 --- a/libwasmvm/src/cache.rs +++ b/libwasmvm/src/cache.rs @@ -1,4 +1,4 @@ -use std::collections::BTreeSet; +use std::collections::{BTreeSet, HashMap}; use std::convert::TryInto; use std::panic::{catch_unwind, AssertUnwindSafe}; use std::str::from_utf8; @@ -433,7 +433,7 @@ impl From for PerModuleMetrics { #[derive(Serialize)] struct PinnedMetrics { - per_module: Vec<(Checksum, PerModuleMetrics)>, + per_module: HashMap, } impl From for PinnedMetrics { diff --git a/types/types.go b/types/types.go index b723a4842..de754e9b6 100644 --- a/types/types.go +++ b/types/types.go @@ -197,7 +197,7 @@ type PerModuleMetrics struct { } type PinnedMetrics struct { - PerModule map[string]PerModuleMetrics `json:"per_module" msgpack:",asarray"` + PerModule map[string]PerModuleMetrics `msgpack:"per_module"` } func (pm *PinnedMetrics) UnmarshalMessagePack(data []byte) error { From 99cb47cdfee3bd83c33af54aa1bc340966a30234 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 12:38:57 +0100 Subject: [PATCH 11/20] Fix test expectations --- internal/api/lib_test.go | 8 ++++++-- types/types.go | 4 ++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index 57aa0b6fc..27a7406e4 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -389,7 +389,7 @@ func TestGetPinnedMetrics(t *testing.T) { // GetMetrics 1 metrics, err := GetPinnedMetrics(cache) require.NoError(t, err) - assert.Equal(t, &types.PinnedMetrics{PerModule: nil}, metrics) + assert.Equal(t, &types.PinnedMetrics{PerModule: make(map[string]types.PerModuleMetrics, 0)}, metrics) // Store contract 1 wasm, err := os.ReadFile("../../testdata/hackatom.wasm") @@ -417,7 +417,9 @@ func TestGetPinnedMetrics(t *testing.T) { require.NoError(t, err) assert.Equal(t, 2, len(metrics.PerModule)) assert.Equal(t, uint32(0), metrics.PerModule[checksumStr].Hits) + assert.NotEqual(t, uint32(0), metrics.PerModule[checksumStr].Size) assert.Equal(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Hits) + assert.NotEqual(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Size) // Instantiate 1 gasMeter := NewMockGasMeter(TESTING_GAS_LIMIT) @@ -434,9 +436,11 @@ func TestGetPinnedMetrics(t *testing.T) { // GetMetrics 3 metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) - assert.Equal(t, 1, len(metrics.PerModule)) + assert.Equal(t, 2, len(metrics.PerModule)) assert.Equal(t, uint32(1), metrics.PerModule[checksumStr].Hits) + assert.NotEqual(t, uint32(0), metrics.PerModule[checksumStr].Size) assert.Equal(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Hits) + assert.NotEqual(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Size) } func TestInstantiate(t *testing.T) { diff --git a/types/types.go b/types/types.go index de754e9b6..4113f2313 100644 --- a/types/types.go +++ b/types/types.go @@ -192,8 +192,8 @@ type Metrics struct { } type PerModuleMetrics struct { - Hits uint32 - Size uint64 + Hits uint32 `msgpack:"hits"` + Size uint64 `msgpack:"size"` } type PinnedMetrics struct { From f4d0a9230de40a3710d06e941dc0e7e9645f8d7b Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 15:10:21 +0100 Subject: [PATCH 12/20] Implement `Stringer` interface, skip `HashMap` on Rust side --- internal/api/lib_test.go | 43 ++++++++++++++++++++++++++++++---------- libwasmvm/src/cache.rs | 7 +++---- types/checksum.go | 2 +- types/types.go | 7 ++++++- 4 files changed, 42 insertions(+), 17 deletions(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index 27a7406e4..d039f60f8 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -389,7 +389,7 @@ func TestGetPinnedMetrics(t *testing.T) { // GetMetrics 1 metrics, err := GetPinnedMetrics(cache) require.NoError(t, err) - assert.Equal(t, &types.PinnedMetrics{PerModule: make(map[string]types.PerModuleMetrics, 0)}, metrics) + assert.Equal(t, &types.PinnedMetrics{PerModule: make([]types.PerModuleEntry, 0)}, metrics) // Store contract 1 wasm, err := os.ReadFile("../../testdata/hackatom.wasm") @@ -409,17 +409,34 @@ func TestGetPinnedMetrics(t *testing.T) { err = Pin(cache, cyberpunkChecksum) require.NoError(t, err) - checksumStr := types.Checksum(checksum).EncodeHex() - cyberpunkChecksumStr := types.Checksum(cyberpunkChecksum).EncodeHex() + checksumStr := types.Checksum(checksum).String() + cyberpunkChecksumStr := types.Checksum(cyberpunkChecksum).String() + + findMetrics := func(list []types.PerModuleEntry, checksum string) *types.PerModuleMetrics { + found := (*types.PerModuleMetrics)(nil) + + for _, structure := range list { + if structure.Name == checksum { + found = &structure.Metrics + break + } + } + + return found + } // GetMetrics 2 metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) assert.Equal(t, 2, len(metrics.PerModule)) - assert.Equal(t, uint32(0), metrics.PerModule[checksumStr].Hits) - assert.NotEqual(t, uint32(0), metrics.PerModule[checksumStr].Size) - assert.Equal(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Hits) - assert.NotEqual(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Size) + + hackatomMetrics := findMetrics(metrics.PerModule, checksumStr) + cyberpunkMetrics := findMetrics(metrics.PerModule, cyberpunkChecksumStr) + + assert.Equal(t, uint32(0), hackatomMetrics.Hits) + assert.NotEqual(t, uint32(0), hackatomMetrics.Size) + assert.Equal(t, uint32(0), cyberpunkMetrics.Hits) + assert.NotEqual(t, uint32(0), cyberpunkMetrics.Size) // Instantiate 1 gasMeter := NewMockGasMeter(TESTING_GAS_LIMIT) @@ -437,10 +454,14 @@ func TestGetPinnedMetrics(t *testing.T) { metrics, err = GetPinnedMetrics(cache) require.NoError(t, err) assert.Equal(t, 2, len(metrics.PerModule)) - assert.Equal(t, uint32(1), metrics.PerModule[checksumStr].Hits) - assert.NotEqual(t, uint32(0), metrics.PerModule[checksumStr].Size) - assert.Equal(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Hits) - assert.NotEqual(t, uint32(0), metrics.PerModule[cyberpunkChecksumStr].Size) + + hackatomMetrics = findMetrics(metrics.PerModule, checksumStr) + cyberpunkMetrics = findMetrics(metrics.PerModule, cyberpunkChecksumStr) + + assert.Equal(t, uint32(1), hackatomMetrics.Hits) + assert.NotEqual(t, uint32(0), hackatomMetrics.Size) + assert.Equal(t, uint32(0), cyberpunkMetrics.Hits) + assert.NotEqual(t, uint32(0), cyberpunkMetrics.Size) } func TestInstantiate(t *testing.T) { diff --git a/libwasmvm/src/cache.rs b/libwasmvm/src/cache.rs index 7f84662b3..5f38affd2 100644 --- a/libwasmvm/src/cache.rs +++ b/libwasmvm/src/cache.rs @@ -1,4 +1,4 @@ -use std::collections::{BTreeSet, HashMap}; +use std::collections::BTreeSet; use std::convert::TryInto; use std::panic::{catch_unwind, AssertUnwindSafe}; use std::str::from_utf8; @@ -433,7 +433,7 @@ impl From for PerModuleMetrics { #[derive(Serialize)] struct PinnedMetrics { - per_module: HashMap, + per_module: Vec<(Checksum, PerModuleMetrics)>, } impl From for PinnedMetrics { @@ -441,8 +441,7 @@ impl From for PinnedMetrics { Self { per_module: value .per_module - .iter() - .cloned() + .into_iter() .map(|(checksum, metrics)| (checksum, metrics.into())) .collect(), } diff --git a/types/checksum.go b/types/checksum.go index bb472e317..2f74224d9 100644 --- a/types/checksum.go +++ b/types/checksum.go @@ -10,7 +10,7 @@ import ( // The length of a checksum must always be ChecksumLen. type Checksum []byte -func (cs Checksum) EncodeHex() string { +func (cs Checksum) String() string { return hex.EncodeToString(cs) } diff --git a/types/types.go b/types/types.go index 4113f2313..904e67b3e 100644 --- a/types/types.go +++ b/types/types.go @@ -196,8 +196,13 @@ type PerModuleMetrics struct { Size uint64 `msgpack:"size"` } +type PerModuleEntry struct { + Name string + Metrics PerModuleMetrics +} + type PinnedMetrics struct { - PerModule map[string]PerModuleMetrics `msgpack:"per_module"` + PerModule []PerModuleEntry `msgpack:"per_module,as_array"` } func (pm *PinnedMetrics) UnmarshalMessagePack(data []byte) error { From cfd0f1680c2c553ff883ecd6e443b3bc67c6ebb2 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Tue, 19 Mar 2024 15:58:20 +0100 Subject: [PATCH 13/20] Add `Stringer` test --- types/types_test.go | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/types/types_test.go b/types/types_test.go index 172a3ca9c..2a3fa9c90 100644 --- a/types/types_test.go +++ b/types/types_test.go @@ -5,9 +5,20 @@ import ( "math" "testing" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) +func TestChecksumString(t *testing.T) { + // SHA-256 hash of "lucyna kushinada" + + hexRepr := "cd6ff9ff3faea9b3d0224a7e0d1133e6eae1b7800e8392441200056986c358a9" + rawBytes := []byte{0xCD, 0x6F, 0xF9, 0xFF, 0x3F, 0xAE, 0xA9, 0xB3, 0xD0, 0x22, 0x4A, 0x7E, 0x0D, 0x11, 0x33, 0xE6, 0xEA, 0xE1, 0xB7, 0x80, 0x0E, 0x83, 0x92, 0x44, 0x12, 0x00, 0x05, 0x69, 0x86, 0xC3, 0x58, 0xA9} + checksumRepr := Checksum(rawBytes).String() + + assert.Equal(t, hexRepr, checksumRepr) +} + func TestUint64JSON(t *testing.T) { var u Uint64 From b6a20d556d9fccac6f4e48b79b25a24519cbf9f7 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 12:33:01 +0200 Subject: [PATCH 14/20] Change field name and type --- types/types.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/types/types.go b/types/types.go index 904e67b3e..bf9a54d0d 100644 --- a/types/types.go +++ b/types/types.go @@ -197,7 +197,7 @@ type PerModuleMetrics struct { } type PerModuleEntry struct { - Name string + Checksum Checksum Metrics PerModuleMetrics } From 34c853f6efb293a7ab4a8151afcb6619e458b05e Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 12:33:11 +0200 Subject: [PATCH 15/20] Serialize as byte array --- libwasmvm/src/cache.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/libwasmvm/src/cache.rs b/libwasmvm/src/cache.rs index 5f38affd2..0ec20afa1 100644 --- a/libwasmvm/src/cache.rs +++ b/libwasmvm/src/cache.rs @@ -433,7 +433,8 @@ impl From for PerModuleMetrics { #[derive(Serialize)] struct PinnedMetrics { - per_module: Vec<(Checksum, PerModuleMetrics)>, + // TODO: Remove the array usage as soon as the metrics have a stable wire format + per_module: Vec<([u8; 32], PerModuleMetrics)>, } impl From for PinnedMetrics { @@ -442,7 +443,7 @@ impl From for PinnedMetrics { per_module: value .per_module .into_iter() - .map(|(checksum, metrics)| (checksum, metrics.into())) + .map(|(checksum, metrics)| (*checksum.as_ref(), metrics.into())) .collect(), } } From 61b6bcd7371d75a61625f4746e00b4a56f502065 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 12:34:39 +0200 Subject: [PATCH 16/20] Fix name --- internal/api/lib_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index d039f60f8..d30509431 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -416,7 +416,7 @@ func TestGetPinnedMetrics(t *testing.T) { found := (*types.PerModuleMetrics)(nil) for _, structure := range list { - if structure.Name == checksum { + if structure.Checksum == checksum { found = &structure.Metrics break } From b12bab6a5f7176a18e83f9d952d7b199537138bb Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 12:39:51 +0200 Subject: [PATCH 17/20] Fix tests --- internal/api/lib_test.go | 16 +++++++--------- types/types.go | 4 ++-- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/internal/api/lib_test.go b/internal/api/lib_test.go index d30509431..d259e8220 100644 --- a/internal/api/lib_test.go +++ b/internal/api/lib_test.go @@ -1,6 +1,7 @@ package api import ( + "bytes" "crypto/sha256" "encoding/hex" "encoding/json" @@ -409,14 +410,11 @@ func TestGetPinnedMetrics(t *testing.T) { err = Pin(cache, cyberpunkChecksum) require.NoError(t, err) - checksumStr := types.Checksum(checksum).String() - cyberpunkChecksumStr := types.Checksum(cyberpunkChecksum).String() - - findMetrics := func(list []types.PerModuleEntry, checksum string) *types.PerModuleMetrics { + findMetrics := func(list []types.PerModuleEntry, checksum types.Checksum) *types.PerModuleMetrics { found := (*types.PerModuleMetrics)(nil) for _, structure := range list { - if structure.Checksum == checksum { + if bytes.Equal(structure.Checksum, checksum) { found = &structure.Metrics break } @@ -430,8 +428,8 @@ func TestGetPinnedMetrics(t *testing.T) { require.NoError(t, err) assert.Equal(t, 2, len(metrics.PerModule)) - hackatomMetrics := findMetrics(metrics.PerModule, checksumStr) - cyberpunkMetrics := findMetrics(metrics.PerModule, cyberpunkChecksumStr) + hackatomMetrics := findMetrics(metrics.PerModule, checksum) + cyberpunkMetrics := findMetrics(metrics.PerModule, cyberpunkChecksum) assert.Equal(t, uint32(0), hackatomMetrics.Hits) assert.NotEqual(t, uint32(0), hackatomMetrics.Size) @@ -455,8 +453,8 @@ func TestGetPinnedMetrics(t *testing.T) { require.NoError(t, err) assert.Equal(t, 2, len(metrics.PerModule)) - hackatomMetrics = findMetrics(metrics.PerModule, checksumStr) - cyberpunkMetrics = findMetrics(metrics.PerModule, cyberpunkChecksumStr) + hackatomMetrics = findMetrics(metrics.PerModule, checksum) + cyberpunkMetrics = findMetrics(metrics.PerModule, cyberpunkChecksum) assert.Equal(t, uint32(1), hackatomMetrics.Hits) assert.NotEqual(t, uint32(0), hackatomMetrics.Size) diff --git a/types/types.go b/types/types.go index bf9a54d0d..e33acc1f5 100644 --- a/types/types.go +++ b/types/types.go @@ -197,8 +197,8 @@ type PerModuleMetrics struct { } type PerModuleEntry struct { - Checksum Checksum - Metrics PerModuleMetrics + Checksum Checksum + Metrics PerModuleMetrics } type PinnedMetrics struct { From 5144d94ac4e20e7e9d0f3df7e28881ec1aeec485 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 13:28:59 +0200 Subject: [PATCH 18/20] Update libwasmvm/src/cache.rs Co-authored-by: Simon Warta <2603011+webmaster128@users.noreply.github.com> --- libwasmvm/src/cache.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libwasmvm/src/cache.rs b/libwasmvm/src/cache.rs index 0ec20afa1..cd4bc203b 100644 --- a/libwasmvm/src/cache.rs +++ b/libwasmvm/src/cache.rs @@ -433,7 +433,7 @@ impl From for PerModuleMetrics { #[derive(Serialize)] struct PinnedMetrics { - // TODO: Remove the array usage as soon as the metrics have a stable wire format + // TODO: Remove the array usage as soon as `Checksum` has a stable wire format in msgpack per_module: Vec<([u8; 32], PerModuleMetrics)>, } From 98ab98989f61ef8e84e9ba2362ebb1ac475832f3 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 13:59:38 +0200 Subject: [PATCH 19/20] Switch how fields are encoded --- go.mod | 5 ++--- go.sum | 19 ++++++++++--------- libwasmvm/src/cache.rs | 2 +- types/types.go | 6 +++--- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/go.mod b/go.mod index b662b3c7f..b8a003356 100644 --- a/go.mod +++ b/go.mod @@ -4,16 +4,15 @@ go 1.21 require ( github.com/google/btree v1.0.0 + github.com/shamaton/msgpack/v2 v2.2.0 github.com/stretchr/testify v1.8.1 - github.com/vmihailenco/msgpack/v5 v5.4.1 golang.org/x/sys v0.16.0 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect - github.com/kr/pretty v0.1.0 // indirect + github.com/kr/pretty v0.3.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 04639096c..0e767c24f 100644 --- a/go.sum +++ b/go.sum @@ -1,15 +1,20 @@ +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/shamaton/msgpack/v2 v2.2.0 h1:IP1m01pHwCrMa6ZccP9B3bqxEMKMSmMVAVKk54g3L/Y= +github.com/shamaton/msgpack/v2 v2.2.0/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= @@ -17,10 +22,6 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8= -github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok= -github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g= -github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/libwasmvm/src/cache.rs b/libwasmvm/src/cache.rs index cd4bc203b..6927d1a68 100644 --- a/libwasmvm/src/cache.rs +++ b/libwasmvm/src/cache.rs @@ -470,7 +470,7 @@ fn do_get_pinned_metrics( cache: &mut Cache, ) -> Result { let pinned_metrics = PinnedMetrics::from(cache.pinned_metrics()); - let edgerunner = rmp_serde::to_vec_named(&pinned_metrics)?; + let edgerunner = rmp_serde::to_vec(&pinned_metrics)?; Ok(UnmanagedVector::new(Some(edgerunner))) } diff --git a/types/types.go b/types/types.go index e33acc1f5..717625c0c 100644 --- a/types/types.go +++ b/types/types.go @@ -5,7 +5,7 @@ import ( "fmt" "strconv" - "github.com/vmihailenco/msgpack/v5" + "github.com/shamaton/msgpack/v2" ) // Uint64 is a wrapper for uint64, but it is marshalled to and from JSON as a string @@ -202,11 +202,11 @@ type PerModuleEntry struct { } type PinnedMetrics struct { - PerModule []PerModuleEntry `msgpack:"per_module,as_array"` + PerModule []PerModuleEntry `msgpack:"per_module"` } func (pm *PinnedMetrics) UnmarshalMessagePack(data []byte) error { - return msgpack.Unmarshal(data, pm) + return msgpack.UnmarshalAsArray(data, pm) } // Array is a wrapper around a slice that ensures that we get "[]" JSON for nil values. From 1ecdacba00a86f16293bd9971b0b8892cc4d8a45 Mon Sep 17 00:00:00 2001 From: Aumetra Weisman Date: Wed, 26 Jun 2024 17:38:44 +0200 Subject: [PATCH 20/20] Update flake.nix --- flake.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/flake.nix b/flake.nix index aafab5efc..9dd40ce49 100644 --- a/flake.nix +++ b/flake.nix @@ -29,6 +29,7 @@ go gofumpt golangci-lint + rust-bin.stable.latest.default ]; }; }