From f678d1db35064a2eefa9d3e9bfca88a8c5c71dcc Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Thu, 5 Sep 2024 18:17:53 -0700 Subject: [PATCH 1/9] chore: make server flags with default value optional --- server/flags.go | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-) diff --git a/server/flags.go b/server/flags.go index 2b02984..32736f3 100644 --- a/server/flags.go +++ b/server/flags.go @@ -1,8 +1,6 @@ package server import ( - "fmt" - "github.com/Layr-Labs/eigenda-proxy/store" "github.com/urfave/cli/v2" @@ -26,7 +24,7 @@ var ( ListenAddrFlag = &cli.StringFlag{ Name: ListenAddrFlagName, Usage: "server listening address", - Value: "127.0.0.1", + Value: "0.0.0.0", EnvVars: prefixEnvVars("ADDR"), } PortFlag = &cli.IntFlag{ @@ -37,13 +35,13 @@ var ( } ) -var requiredFlags = []cli.Flag{ +var requiredFlags = []cli.Flag{} + +var optionalFlags = []cli.Flag{ ListenAddrFlag, PortFlag, } -var optionalFlags = []cli.Flag{} - func init() { optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...) optionalFlags = append(optionalFlags, CLIFlags()...) @@ -76,12 +74,3 @@ func (c CLIConfig) Check() error { } return nil } - -func CheckRequired(ctx *cli.Context) error { - for _, f := range requiredFlags { - if !ctx.IsSet(f.Names()[0]) { - return fmt.Errorf("flag %s is required", f.Names()[0]) - } - } - return nil -} From 40448dbbff1ffa1f80cbfca3b4546b3ddc468c9e Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Thu, 5 Sep 2024 18:18:16 -0700 Subject: [PATCH 2/9] chore: fix run-server command (renamed to run-memstore-server) --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 50d0e8a..c5d889e 100644 --- a/Makefile +++ b/Makefile @@ -31,8 +31,8 @@ stop-minio: docker stop minio && docker rm minio; \ fi -run-server: - ./bin/eigenda-proxy +run-memstore-server: + ./bin/eigenda-proxy --memstore.enabled clean: rm bin/eigenda-proxy From 701c4b6895ac20fdbdb98a581290dc5ff8f4b8f4 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Thu, 5 Sep 2024 18:18:29 -0700 Subject: [PATCH 3/9] feat: put/get artificial latency for memstore backend --- cmd/server/entrypoint.go | 3 --- server/config.go | 18 +++++++++++++ server/load_store.go | 2 +- store/memory.go | 20 ++++++++++----- store/memory_test.go | 55 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 88 insertions(+), 10 deletions(-) diff --git a/cmd/server/entrypoint.go b/cmd/server/entrypoint.go index 2959ec9..77cad47 100644 --- a/cmd/server/entrypoint.go +++ b/cmd/server/entrypoint.go @@ -13,9 +13,6 @@ import ( ) func StartProxySvr(cliCtx *cli.Context) error { - if err := server.CheckRequired(cliCtx); err != nil { - return err - } cfg := server.ReadCLIConfig(cliCtx) if err := cfg.Check(); err != nil { return err diff --git a/server/config.go b/server/config.go index ff1d084..f407301 100644 --- a/server/config.go +++ b/server/config.go @@ -38,6 +38,8 @@ const ( // memstore flags MemstoreFlagName = "memstore.enabled" MemstoreExpirationFlagName = "memstore.expiration" + MemstorePutLatencyFlagName = "memstore.put-latency" + MemstoreGetLatencyFlagName = "memstore.get-latency" // S3 client flags S3CredentialTypeFlagName = "s3.credential-type" // #nosec G101 @@ -90,6 +92,8 @@ type Config struct { // Memstore MemstoreEnabled bool MemstoreBlobExpiration time.Duration + MemstoreGetLatency time.Duration + MemstorePutLatency time.Duration // routing FallbackTargets []string @@ -179,6 +183,8 @@ func ReadConfig(ctx *cli.Context) Config { EthConfirmationDepth: ctx.Int64(EthConfirmationDepthFlagName), MemstoreEnabled: ctx.Bool(MemstoreFlagName), MemstoreBlobExpiration: ctx.Duration(MemstoreExpirationFlagName), + MemstoreGetLatency: ctx.Duration(MemstoreGetLatencyFlagName), + MemstorePutLatency: ctx.Duration(MemstorePutLatencyFlagName), FallbackTargets: ctx.StringSlice(FallbackTargets), CacheTargets: ctx.StringSlice(CacheTargets), } @@ -419,6 +425,18 @@ func CLIFlags() []cli.Flag { Value: 25 * time.Minute, EnvVars: []string{"MEMSTORE_EXPIRATION"}, }, + &cli.DurationFlag{ + Name: MemstorePutLatencyFlagName, + Usage: "Artificial latency added for memstore backend to mimic EigenDA's dispersal latency.", + Value: 0, + EnvVars: []string{"MEMSTORE_PUT_LATENCY"}, + }, + &cli.DurationFlag{ + Name: MemstoreGetLatencyFlagName, + Usage: "Artificial latency added for memstore backend to mimic EigenDA's retrieval latency.", + Value: 0, + EnvVars: []string{"MEMSTORE_GET_LATENCY"}, + }, &cli.StringSliceFlag{ Name: FallbackTargets, Usage: "List of read fallback targets to rollover to if cert can't be read from EigenDA.", diff --git a/server/load_store.go b/server/load_store.go index bc144f1..f2af62c 100644 --- a/server/load_store.go +++ b/server/load_store.go @@ -47,7 +47,7 @@ func LoadStoreRouter(ctx context.Context, cfg CLIConfig, log log.Logger) (store. var eigenda store.KeyGeneratedStore if cfg.EigenDAConfig.MemstoreEnabled { log.Info("Using mem-store backend for EigenDA") - eigenda, err = store.NewMemStore(ctx, verifier, log, maxBlobLength, cfg.EigenDAConfig.MemstoreBlobExpiration) + eigenda, err = store.NewMemStore(ctx, verifier, log, maxBlobLength, cfg.EigenDAConfig.MemstoreBlobExpiration, cfg.EigenDAConfig.MemstorePutLatency, cfg.EigenDAConfig.MemstoreGetLatency) } else { var client *clients.EigenDAClient log.Info("Using EigenDA backend") diff --git a/store/memory.go b/store/memory.go index 19d63c6..1f7e5e6 100644 --- a/store/memory.go +++ b/store/memory.go @@ -30,11 +30,13 @@ EigenDA operators. type MemStore struct { sync.RWMutex - l log.Logger - keyStarts map[string]time.Time - store map[string][]byte - verifier *verify.Verifier - codec codecs.BlobCodec + l log.Logger + keyStarts map[string]time.Time + store map[string][]byte + verifier *verify.Verifier + codec codecs.BlobCodec + putLatency time.Duration + getLatency time.Duration maxBlobSizeBytes uint64 blobExpiration time.Duration @@ -45,7 +47,8 @@ var _ KeyGeneratedStore = (*MemStore)(nil) // NewMemStore ... constructor func NewMemStore(ctx context.Context, verifier *verify.Verifier, l log.Logger, - maxBlobSizeBytes uint64, blobExpiration time.Duration) (*MemStore, error) { + maxBlobSizeBytes uint64, blobExpiration time.Duration, + putLatency, getLatency time.Duration) (*MemStore, error) { store := &MemStore{ l: l, keyStarts: make(map[string]time.Time), @@ -54,6 +57,9 @@ func NewMemStore(ctx context.Context, verifier *verify.Verifier, l log.Logger, codec: codecs.NewIFFTCodec(codecs.NewDefaultBlobCodec()), maxBlobSizeBytes: maxBlobSizeBytes, blobExpiration: blobExpiration, + // artificial latency added for memstore backend to mimic eigenda's latency + putLatency: putLatency, + getLatency: getLatency, } if store.blobExpiration != 0 { @@ -97,6 +103,7 @@ func (e *MemStore) pruneExpired() { // Get fetches a value from the store. func (e *MemStore) Get(_ context.Context, commit []byte) ([]byte, error) { + time.Sleep(e.getLatency) e.reads++ e.RLock() defer e.RUnlock() @@ -124,6 +131,7 @@ func (e *MemStore) Get(_ context.Context, commit []byte) ([]byte, error) { // Put inserts a value into the store. func (e *MemStore) Put(_ context.Context, value []byte) ([]byte, error) { + time.Sleep(e.putLatency) if uint64(len(value)) > e.maxBlobSizeBytes { return nil, fmt.Errorf("blob is larger than max blob size: blob length %d, max blob size %d", len(value), e.maxBlobSizeBytes) } diff --git a/store/memory_test.go b/store/memory_test.go index cbecc01..85e7ffd 100644 --- a/store/memory_test.go +++ b/store/memory_test.go @@ -43,6 +43,7 @@ func TestGetSet(t *testing.T) { log.New(), 1024*1024*2, time.Hour*1000, + 0, 0, ) require.NoError(t, err) @@ -85,6 +86,7 @@ func TestExpiration(t *testing.T) { log.New(), 1024*1024*2, time.Millisecond*10, + 0, 0, ) require.NoError(t, err) @@ -100,3 +102,56 @@ func TestExpiration(t *testing.T) { require.Error(t, err) } + +func TestLatency(t *testing.T) { + t.Parallel() + + putLatency := 1 * time.Second + getLatency := 1 * time.Second + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + kzgConfig := &kzg.KzgConfig{ + G1Path: "../resources/g1.point", + G2PowerOf2Path: "../resources/g2.point.powerOf2", + CacheDir: "../resources/SRSTables", + SRSOrder: 3000, + SRSNumberToLoad: 3000, + NumWorker: uint64(runtime.GOMAXPROCS(0)), + } + + cfg := &verify.Config{ + Verify: false, + KzgConfig: kzgConfig, + } + + verifier, err := verify.NewVerifier(cfg, nil) + require.NoError(t, err) + + ms, err := NewMemStore( + ctx, + verifier, + log.New(), + 1024*1024*2, + time.Millisecond*10, + putLatency, getLatency, + ) + + require.NoError(t, err) + + preimage := []byte(testPreimage) + timeBeforePut := time.Now() + key, err := ms.Put(ctx, preimage) + require.NoError(t, err) + require.GreaterOrEqual(t, time.Since(timeBeforePut), putLatency) + + // sleep 1 second and verify that older blob entries are removed + time.Sleep(time.Second * 1) + + timeBeforeGet := time.Now() + _, err = ms.Get(ctx, key) + require.Error(t, err) + require.GreaterOrEqual(t, time.Since(timeBeforeGet), getLatency) + +} From 72668f265dd667410e5b3a184318c65f8d085226 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 6 Sep 2024 10:49:43 -0700 Subject: [PATCH 4/9] doc: add memstore put/get latency flags into README options table --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 75f6757..846cfc1 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,8 @@ In order to disperse to the EigenDA network in production, or at high throughput | `--log.pid` | `false` | `$EIGENDA_PROXY_LOG_PID` | Show pid in the log. | | `--memstore.enabled` | `false` | `$MEMSTORE_ENABLED` | Whether to use mem-store for DA logic. | | `--memstore.expiration` | `25m0s` | `$MEMSTORE_EXPIRATION` | Duration that a mem-store blob/commitment pair are allowed to live. | +| `--memstore.put-latency` | `0` | `$MEMSTORE_PUT_LATENCY` | Artificial latency added for memstore backend to mimic EigenDA's dispersal latency. | +| `--memstore.get-latency` | `0` | `$MEMSTORE_GET_LATENCY` | Artificial latency added for memstore backend to mimic EigenDA's retrieval latency. | | `--metrics.addr` | `"0.0.0.0"` | `$EIGENDA_PROXY_METRICS_ADDR` | Metrics listening address. | | `--metrics.enabled` | `false` | `$EIGENDA_PROXY_METRICS_ENABLED` | Enable the metrics server. | | `--metrics.port` | `7300` | `$EIGENDA_PROXY_METRICS_PORT` | Metrics listening port. | From 516ee3d0cde385118b08b7f250d4d97ab24829d2 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 6 Sep 2024 10:56:45 -0700 Subject: [PATCH 5/9] chore: clean flags --- server/flags.go | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/server/flags.go b/server/flags.go index 32736f3..3e4b528 100644 --- a/server/flags.go +++ b/server/flags.go @@ -20,38 +20,28 @@ func prefixEnvVars(name string) []string { return opservice.PrefixEnvVar(EnvVarPrefix, name) } -var ( - ListenAddrFlag = &cli.StringFlag{ +// Flags contains the list of configuration options available to the binary. +var Flags = []cli.Flag{ + &cli.StringFlag{ Name: ListenAddrFlagName, Usage: "server listening address", Value: "0.0.0.0", EnvVars: prefixEnvVars("ADDR"), - } - PortFlag = &cli.IntFlag{ + }, + &cli.IntFlag{ Name: PortFlagName, Usage: "server listening port", Value: 3100, EnvVars: prefixEnvVars("PORT"), - } -) - -var requiredFlags = []cli.Flag{} - -var optionalFlags = []cli.Flag{ - ListenAddrFlag, - PortFlag, + }, } func init() { - optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...) - optionalFlags = append(optionalFlags, CLIFlags()...) - optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...) - Flags = append(requiredFlags, optionalFlags...) //nolint:gocritic // this is a global variable + Flags = append(Flags, oplog.CLIFlags(EnvVarPrefix)...) + Flags = append(Flags, CLIFlags()...) + Flags = append(Flags, opmetrics.CLIFlags(EnvVarPrefix)...) } -// Flags contains the list of configuration options available to the binary. -var Flags []cli.Flag - type CLIConfig struct { S3Config store.S3Config EigenDAConfig Config From 77a31ee2ba60582212a3f064da90623806873796 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 6 Sep 2024 11:30:47 -0700 Subject: [PATCH 6/9] refactor: use config for memstore --- server/load_store.go | 7 ++++- store/memory.go | 67 ++++++++++++++++++++++++-------------------- store/memory_test.go | 21 ++++++++------ 3 files changed, 54 insertions(+), 41 deletions(-) diff --git a/server/load_store.go b/server/load_store.go index f2af62c..a323973 100644 --- a/server/load_store.go +++ b/server/load_store.go @@ -47,7 +47,12 @@ func LoadStoreRouter(ctx context.Context, cfg CLIConfig, log log.Logger) (store. var eigenda store.KeyGeneratedStore if cfg.EigenDAConfig.MemstoreEnabled { log.Info("Using mem-store backend for EigenDA") - eigenda, err = store.NewMemStore(ctx, verifier, log, maxBlobLength, cfg.EigenDAConfig.MemstoreBlobExpiration, cfg.EigenDAConfig.MemstorePutLatency, cfg.EigenDAConfig.MemstoreGetLatency) + eigenda, err = store.NewMemStore(ctx, verifier, log, store.MemStoreConfig{ + MaxBlobSizeBytes: maxBlobLength, + BlobExpiration: cfg.EigenDAConfig.MemstoreBlobExpiration, + PutLatency: cfg.EigenDAConfig.MemstorePutLatency, + GetLatency: cfg.EigenDAConfig.MemstoreGetLatency, + }) } else { var client *clients.EigenDAClient log.Info("Using EigenDA backend") diff --git a/store/memory.go b/store/memory.go index 1f7e5e6..8d8ad12 100644 --- a/store/memory.go +++ b/store/memory.go @@ -22,6 +22,18 @@ const ( DefaultPruneInterval = 500 * time.Millisecond ) +type MemStoreConfig struct { + MaxBlobSizeBytes uint64 + BlobExpiration time.Duration + // artificial latency added for memstore backend to mimic eigenda's latency + PutLatency time.Duration + GetLatency time.Duration +} + +var memStoreConfigDefaults = MemStoreConfig{ + MaxBlobSizeBytes: 1024 * 1024, +} + /* MemStore is a simple in-memory store for blobs which uses an expiration time to evict blobs to best emulate the ephemeral nature of blobs dispersed to @@ -30,40 +42,33 @@ EigenDA operators. type MemStore struct { sync.RWMutex - l log.Logger - keyStarts map[string]time.Time - store map[string][]byte - verifier *verify.Verifier - codec codecs.BlobCodec - putLatency time.Duration - getLatency time.Duration - - maxBlobSizeBytes uint64 - blobExpiration time.Duration - reads int + config MemStoreConfig + l log.Logger + keyStarts map[string]time.Time + store map[string][]byte + verifier *verify.Verifier + codec codecs.BlobCodec + + reads int } var _ KeyGeneratedStore = (*MemStore)(nil) // NewMemStore ... constructor -func NewMemStore(ctx context.Context, verifier *verify.Verifier, l log.Logger, - maxBlobSizeBytes uint64, blobExpiration time.Duration, - putLatency, getLatency time.Duration) (*MemStore, error) { +func NewMemStore( + ctx context.Context, verifier *verify.Verifier, l log.Logger, config MemStoreConfig, +) (*MemStore, error) { store := &MemStore{ - l: l, - keyStarts: make(map[string]time.Time), - store: make(map[string][]byte), - verifier: verifier, - codec: codecs.NewIFFTCodec(codecs.NewDefaultBlobCodec()), - maxBlobSizeBytes: maxBlobSizeBytes, - blobExpiration: blobExpiration, - // artificial latency added for memstore backend to mimic eigenda's latency - putLatency: putLatency, - getLatency: getLatency, + l: l, + config: config, + keyStarts: make(map[string]time.Time), + store: make(map[string][]byte), + verifier: verifier, + codec: codecs.NewIFFTCodec(codecs.NewDefaultBlobCodec()), } - if store.blobExpiration != 0 { - l.Info("memstore expiration enabled", "time", store.blobExpiration) + if store.config.BlobExpiration != 0 { + l.Info("memstore expiration enabled", "time", store.config.BlobExpiration) go store.EventLoop(ctx) } @@ -92,7 +97,7 @@ func (e *MemStore) pruneExpired() { defer e.Unlock() for commit, dur := range e.keyStarts { - if time.Since(dur) >= e.blobExpiration { + if time.Since(dur) >= e.config.BlobExpiration { delete(e.keyStarts, commit) delete(e.store, commit) @@ -103,7 +108,7 @@ func (e *MemStore) pruneExpired() { // Get fetches a value from the store. func (e *MemStore) Get(_ context.Context, commit []byte) ([]byte, error) { - time.Sleep(e.getLatency) + time.Sleep(e.config.GetLatency) e.reads++ e.RLock() defer e.RUnlock() @@ -131,9 +136,9 @@ func (e *MemStore) Get(_ context.Context, commit []byte) ([]byte, error) { // Put inserts a value into the store. func (e *MemStore) Put(_ context.Context, value []byte) ([]byte, error) { - time.Sleep(e.putLatency) - if uint64(len(value)) > e.maxBlobSizeBytes { - return nil, fmt.Errorf("blob is larger than max blob size: blob length %d, max blob size %d", len(value), e.maxBlobSizeBytes) + time.Sleep(e.config.PutLatency) + if uint64(len(value)) > e.config.MaxBlobSizeBytes { + return nil, fmt.Errorf("blob is larger than max blob size: blob length %d, max blob size %d", len(value), e.config.MaxBlobSizeBytes) } e.Lock() diff --git a/store/memory_test.go b/store/memory_test.go index 85e7ffd..0724a11 100644 --- a/store/memory_test.go +++ b/store/memory_test.go @@ -16,6 +16,15 @@ const ( testPreimage = "Four score and seven years ago" ) +func getDefaultTestConfig() MemStoreConfig { + return MemStoreConfig{ + MaxBlobSizeBytes: 1024 * 1024, + BlobExpiration: time.Hour * 1000, + PutLatency: 0, + GetLatency: 0, + } +} + func TestGetSet(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() @@ -41,9 +50,7 @@ func TestGetSet(t *testing.T) { ctx, verifier, log.New(), - 1024*1024*2, - time.Hour*1000, - 0, 0, + getDefaultTestConfig(), ) require.NoError(t, err) @@ -84,9 +91,7 @@ func TestExpiration(t *testing.T) { ctx, verifier, log.New(), - 1024*1024*2, - time.Millisecond*10, - 0, 0, + getDefaultTestConfig(), ) require.NoError(t, err) @@ -133,9 +138,7 @@ func TestLatency(t *testing.T) { ctx, verifier, log.New(), - 1024*1024*2, - time.Millisecond*10, - putLatency, getLatency, + getDefaultTestConfig(), ) require.NoError(t, err) From edcf800dd62a49d6f2c8dd6a11fa4ab6ebb9efb0 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 6 Sep 2024 11:37:29 -0700 Subject: [PATCH 7/9] fix: memstore tests --- store/memory_test.go | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/store/memory_test.go b/store/memory_test.go index 0724a11..d524460 100644 --- a/store/memory_test.go +++ b/store/memory_test.go @@ -19,7 +19,7 @@ const ( func getDefaultTestConfig() MemStoreConfig { return MemStoreConfig{ MaxBlobSizeBytes: 1024 * 1024, - BlobExpiration: time.Hour * 1000, + BlobExpiration: 0, PutLatency: 0, GetLatency: 0, } @@ -87,11 +87,13 @@ func TestExpiration(t *testing.T) { verifier, err := verify.NewVerifier(cfg, nil) require.NoError(t, err) + memstoreConfig := getDefaultTestConfig() + memstoreConfig.BlobExpiration = 10 * time.Millisecond ms, err := NewMemStore( ctx, verifier, log.New(), - getDefaultTestConfig(), + memstoreConfig, ) require.NoError(t, err) @@ -134,12 +136,10 @@ func TestLatency(t *testing.T) { verifier, err := verify.NewVerifier(cfg, nil) require.NoError(t, err) - ms, err := NewMemStore( - ctx, - verifier, - log.New(), - getDefaultTestConfig(), - ) + config := getDefaultTestConfig() + config.PutLatency = putLatency + config.GetLatency = getLatency + ms, err := NewMemStore(ctx, verifier, log.New(), config) require.NoError(t, err) @@ -149,12 +149,9 @@ func TestLatency(t *testing.T) { require.NoError(t, err) require.GreaterOrEqual(t, time.Since(timeBeforePut), putLatency) - // sleep 1 second and verify that older blob entries are removed - time.Sleep(time.Second * 1) - timeBeforeGet := time.Now() _, err = ms.Get(ctx, key) - require.Error(t, err) + require.NoError(t, err) require.GreaterOrEqual(t, time.Since(timeBeforeGet), getLatency) } From 90008016a4d452809557b6dd8698c25d83543b1b Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 6 Sep 2024 11:41:41 -0700 Subject: [PATCH 8/9] refactor: add default verifier config creation function for memstore tests --- store/memory_test.go | 70 +++++++++++++------------------------------- 1 file changed, 21 insertions(+), 49 deletions(-) diff --git a/store/memory_test.go b/store/memory_test.go index d524460..52965a0 100644 --- a/store/memory_test.go +++ b/store/memory_test.go @@ -16,7 +16,7 @@ const ( testPreimage = "Four score and seven years ago" ) -func getDefaultTestConfig() MemStoreConfig { +func getDefaultMemStoreTestConfig() MemStoreConfig { return MemStoreConfig{ MaxBlobSizeBytes: 1024 * 1024, BlobExpiration: 0, @@ -25,32 +25,32 @@ func getDefaultTestConfig() MemStoreConfig { } } +func getDefaultVerifierTestConfig() *verify.Config { + return &verify.Config{ + Verify: false, + KzgConfig: &kzg.KzgConfig{ + G1Path: "../resources/g1.point", + G2PowerOf2Path: "../resources/g2.point.powerOf2", + CacheDir: "../resources/SRSTables", + SRSOrder: 3000, + SRSNumberToLoad: 3000, + NumWorker: uint64(runtime.GOMAXPROCS(0)), + }, + } +} + func TestGetSet(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - kzgConfig := &kzg.KzgConfig{ - G1Path: "../resources/g1.point", - G2PowerOf2Path: "../resources/g2.point.powerOf2", - CacheDir: "../resources/SRSTables", - SRSOrder: 3000, - SRSNumberToLoad: 3000, - NumWorker: uint64(runtime.GOMAXPROCS(0)), - } - - cfg := &verify.Config{ - Verify: false, - KzgConfig: kzgConfig, - } - - verifier, err := verify.NewVerifier(cfg, nil) + verifier, err := verify.NewVerifier(getDefaultVerifierTestConfig(), nil) require.NoError(t, err) ms, err := NewMemStore( ctx, verifier, log.New(), - getDefaultTestConfig(), + getDefaultMemStoreTestConfig(), ) require.NoError(t, err) @@ -70,24 +70,10 @@ func TestExpiration(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - kzgConfig := &kzg.KzgConfig{ - G1Path: "../resources/g1.point", - G2PowerOf2Path: "../resources/g2.point.powerOf2", - CacheDir: "../resources/SRSTables", - SRSOrder: 3000, - SRSNumberToLoad: 3000, - NumWorker: uint64(runtime.GOMAXPROCS(0)), - } - - cfg := &verify.Config{ - Verify: false, - KzgConfig: kzgConfig, - } - - verifier, err := verify.NewVerifier(cfg, nil) + verifier, err := verify.NewVerifier(getDefaultVerifierTestConfig(), nil) require.NoError(t, err) - memstoreConfig := getDefaultTestConfig() + memstoreConfig := getDefaultMemStoreTestConfig() memstoreConfig.BlobExpiration = 10 * time.Millisecond ms, err := NewMemStore( ctx, @@ -119,24 +105,10 @@ func TestLatency(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - kzgConfig := &kzg.KzgConfig{ - G1Path: "../resources/g1.point", - G2PowerOf2Path: "../resources/g2.point.powerOf2", - CacheDir: "../resources/SRSTables", - SRSOrder: 3000, - SRSNumberToLoad: 3000, - NumWorker: uint64(runtime.GOMAXPROCS(0)), - } - - cfg := &verify.Config{ - Verify: false, - KzgConfig: kzgConfig, - } - - verifier, err := verify.NewVerifier(cfg, nil) + verifier, err := verify.NewVerifier(getDefaultVerifierTestConfig(), nil) require.NoError(t, err) - config := getDefaultTestConfig() + config := getDefaultMemStoreTestConfig() config.PutLatency = putLatency config.GetLatency = getLatency ms, err := NewMemStore(ctx, verifier, log.New(), config) From 399dbfbd47fc645cf15abffcbf6851473e681214 Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 6 Sep 2024 11:42:24 -0700 Subject: [PATCH 9/9] fix(lint): remove unused var --- store/memory.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/store/memory.go b/store/memory.go index 8d8ad12..85d134c 100644 --- a/store/memory.go +++ b/store/memory.go @@ -30,10 +30,6 @@ type MemStoreConfig struct { GetLatency time.Duration } -var memStoreConfigDefaults = MemStoreConfig{ - MaxBlobSizeBytes: 1024 * 1024, -} - /* MemStore is a simple in-memory store for blobs which uses an expiration time to evict blobs to best emulate the ephemeral nature of blobs dispersed to