diff --git a/.changeset/swift-fireants-compare.md b/.changeset/swift-fireants-compare.md new file mode 100644 index 00000000000..b11c516e7c3 --- /dev/null +++ b/.changeset/swift-fireants-compare.md @@ -0,0 +1,5 @@ +--- +"chainlink": minor +--- + +Add CSA authentication support to Beholder #added diff --git a/.github/workflows/ci-core.yml b/.github/workflows/ci-core.yml index 3d7050197a6..3a32d7e12c7 100644 --- a/.github/workflows/ci-core.yml +++ b/.github/workflows/ci-core.yml @@ -166,7 +166,7 @@ jobs: uses: ./.github/actions/setup-go with: # race/fuzz tests don't benefit repeated caching, so restore from develop's build cache - restore-build-cache-only: ${{ matrix.type.cmd == 'go_core_race_tests' || matrix.type.cmd == 'go_core_fuzz' }} + restore-build-cache-only: ${{ matrix.type.cmd == 'go_core_fuzz' }} build-cache-version: ${{ matrix.type.cmd }} - name: Replace chainlink-evm deps @@ -220,12 +220,13 @@ jobs: go install ./pkg/chainlink/cmd/chainlink-starknet popd - - name: Increase Race Timeout - # Increase race timeout for scheduled runs only + - name: Increase Timeouts for Fuzz/Race + # Increase timeouts for scheduled runs only if: ${{ github.event.schedule != '' && needs.filter.outputs.should-run-ci-core == 'true' }} run: | echo "TIMEOUT=10m" >> $GITHUB_ENV echo "COUNT=50" >> $GITHUB_ENV + echo "FUZZ_TIMEOUT_MINUTES=10">> $GITHUB_ENV - name: Install gotestloghelper if: ${{ needs.filter.outputs.should-run-ci-core == 'true' }} diff --git a/core/cmd/key_store_authenticator.go b/core/cmd/key_store_authenticator.go index 6ad4b0ef2ba..7833566fcdc 100644 --- a/core/cmd/key_store_authenticator.go +++ b/core/cmd/key_store_authenticator.go @@ -17,11 +17,11 @@ type TerminalKeyStoreAuthenticator struct { Prompter Prompter } -type keystorePassword interface { +type KeystorePassword interface { Keystore() string } -func (auth TerminalKeyStoreAuthenticator) authenticate(ctx context.Context, keyStore keystore.Master, password keystorePassword) error { +func (auth TerminalKeyStoreAuthenticator) Authenticate(ctx context.Context, keyStore keystore.Master, password KeystorePassword) error { isEmpty, err := keyStore.IsEmpty(ctx) if err != nil { return errors.Wrap(err, "error determining if keystore is empty") diff --git a/core/cmd/shell.go b/core/cmd/shell.go index fb2b262821a..966fa1a0ff8 100644 --- a/core/cmd/shell.go +++ b/core/cmd/shell.go @@ -66,7 +66,7 @@ var ( grpcOpts loop.GRPCOpts ) -func initGlobals(cfgProm config.Prometheus, cfgTracing config.Tracing, cfgTelemetry config.Telemetry, lggr logger.Logger) error { +func initGlobals(cfgProm config.Prometheus, cfgTracing config.Tracing, cfgTelemetry config.Telemetry, lggr logger.Logger, csaPubKeyHex string, beholderAuthHeaders map[string]string) error { // Avoid double initializations, but does not prevent relay methods from being called multiple times. var err error initGlobalsOnce.Do(func() { @@ -97,6 +97,7 @@ func initGlobals(cfgProm config.Prometheus, cfgTracing config.Tracing, cfgTeleme for k, v := range cfgTelemetry.ResourceAttributes() { attributes = append(attributes, attribute.String(k, v)) } + clientCfg := beholder.Config{ InsecureConnection: cfgTelemetry.InsecureConnection(), CACertFile: cfgTelemetry.CACertFile(), @@ -105,6 +106,8 @@ func initGlobals(cfgProm config.Prometheus, cfgTracing config.Tracing, cfgTeleme TraceSampleRatio: cfgTelemetry.TraceSampleRatio(), EmitterBatchProcessor: cfgTelemetry.EmitterBatchProcessor(), EmitterExportTimeout: cfgTelemetry.EmitterExportTimeout(), + AuthPublicKeyHex: csaPubKeyHex, + AuthHeaders: beholderAuthHeaders, } if tracingCfg.Enabled { clientCfg.TraceSpanExporter, err = tracingCfg.NewSpanExporter() @@ -175,19 +178,14 @@ func (s *Shell) configExitErr(validateFn func() error) cli.ExitCoder { // AppFactory implements the NewApplication method. type AppFactory interface { - NewApplication(ctx context.Context, cfg chainlink.GeneralConfig, appLggr logger.Logger, db *sqlx.DB) (chainlink.Application, error) + NewApplication(ctx context.Context, cfg chainlink.GeneralConfig, appLggr logger.Logger, db *sqlx.DB, keyStoreAuthenticator TerminalKeyStoreAuthenticator) (chainlink.Application, error) } // ChainlinkAppFactory is used to create a new Application. type ChainlinkAppFactory struct{} // NewApplication returns a new instance of the node with the given config. -func (n ChainlinkAppFactory) NewApplication(ctx context.Context, cfg chainlink.GeneralConfig, appLggr logger.Logger, db *sqlx.DB) (app chainlink.Application, err error) { - err = initGlobals(cfg.Prometheus(), cfg.Tracing(), cfg.Telemetry(), appLggr) - if err != nil { - appLggr.Errorf("Failed to initialize globals: %v", err) - } - +func (n ChainlinkAppFactory) NewApplication(ctx context.Context, cfg chainlink.GeneralConfig, appLggr logger.Logger, db *sqlx.DB, keyStoreAuthenticator TerminalKeyStoreAuthenticator) (app chainlink.Application, err error) { err = migrate.SetMigrationENVVars(cfg) if err != nil { return nil, err @@ -199,11 +197,31 @@ func (n ChainlinkAppFactory) NewApplication(ctx context.Context, cfg chainlink.G } ds := sqlutil.WrapDataSource(db, appLggr, sqlutil.TimeoutHook(cfg.Database().DefaultQueryTimeout), sqlutil.MonitorHook(cfg.Database().LogSQL)) - keyStore := keystore.New(ds, utils.GetScryptParams(cfg), appLggr) + + err = keyStoreAuthenticator.Authenticate(ctx, keyStore, cfg.Password()) + if err != nil { + return nil, errors.Wrap(err, "error authenticating keystore") + } + + err = keyStore.CSA().EnsureKey(ctx) + if err != nil { + return nil, errors.Wrap(err, "failed to ensure CSA key") + } + + beholderAuthHeaders, csaPubKeyHex, err := keystore.BuildBeholderAuth(keyStore) + if err != nil { + return nil, errors.Wrap(err, "failed to build Beholder auth") + } + + err = initGlobals(cfg.Prometheus(), cfg.Tracing(), cfg.Telemetry(), appLggr, csaPubKeyHex, beholderAuthHeaders) + if err != nil { + appLggr.Errorf("Failed to initialize globals: %v", err) + } + mailMon := mailbox.NewMonitor(cfg.AppID().String(), appLggr.Named("Mailbox")) - loopRegistry := plugins.NewLoopRegistry(appLggr, cfg.Tracing(), cfg.Telemetry()) + loopRegistry := plugins.NewLoopRegistry(appLggr, cfg.Tracing(), cfg.Telemetry(), beholderAuthHeaders, csaPubKeyHex) mercuryPool := wsrpc.NewPool(appLggr, cache.Config{ LatestReportTTL: cfg.Mercury().Cache().LatestReportTTL(), diff --git a/core/cmd/shell_local.go b/core/cmd/shell_local.go index 689e7d27d26..50411e10d42 100644 --- a/core/cmd/shell_local.go +++ b/core/cmd/shell_local.go @@ -382,18 +382,13 @@ func (s *Shell) runNode(c *cli.Context) error { // From now on, DB locks and DB connection will be released on every return. // Keep watching on logger.Fatal* calls and os.Exit(), because defer will not be executed. - app, err := s.AppFactory.NewApplication(rootCtx, s.Config, s.Logger, ldb.DB()) + app, err := s.AppFactory.NewApplication(rootCtx, s.Config, s.Logger, ldb.DB(), s.KeyStoreAuthenticator) if err != nil { return s.errorOut(errors.Wrap(err, "fatal error instantiating application")) } // Local shell initialization always uses local auth users table for admin auth authProviderORM := app.BasicAdminUsersORM() - keyStore := app.GetKeyStore() - err = s.KeyStoreAuthenticator.authenticate(rootCtx, keyStore, s.Config.Password()) - if err != nil { - return errors.Wrap(err, "error authenticating keystore") - } legacyEVMChains := app.GetRelayers().LegacyEVMChains() @@ -634,7 +629,7 @@ func (s *Shell) RebroadcastTransactions(c *cli.Context) (err error) { } defer lggr.ErrorIfFn(db.Close, "Error closing db") - app, err := s.AppFactory.NewApplication(ctx, s.Config, lggr, db) + app, err := s.AppFactory.NewApplication(ctx, s.Config, lggr, db, s.KeyStoreAuthenticator) if err != nil { return s.errorOut(errors.Wrap(err, "fatal error instantiating application")) } @@ -1281,7 +1276,7 @@ func (s *Shell) RemoveBlocks(c *cli.Context) error { // From now on, DB locks and DB connection will be released on every return. // Keep watching on logger.Fatal* calls and os.Exit(), because defer will not be executed. - app, err := s.AppFactory.NewApplication(ctx, s.Config, s.Logger, ldb.DB()) + app, err := s.AppFactory.NewApplication(ctx, s.Config, s.Logger, ldb.DB(), s.KeyStoreAuthenticator) if err != nil { return s.errorOut(errors.Wrap(err, "fatal error instantiating application")) } diff --git a/core/cmd/shell_local_test.go b/core/cmd/shell_local_test.go index 79d2b9f07a6..78254c0279e 100644 --- a/core/cmd/shell_local_test.go +++ b/core/cmd/shell_local_test.go @@ -46,7 +46,7 @@ import ( func genTestEVMRelayers(t *testing.T, opts legacyevm.ChainRelayOpts, ks evmrelayer.CSAETHKeystore) *chainlink.CoreRelayerChainInteroperators { f := chainlink.RelayerFactory{ Logger: opts.Logger, - LoopRegistry: plugins.NewLoopRegistry(opts.Logger, opts.AppConfig.Tracing(), opts.AppConfig.Telemetry()), + LoopRegistry: plugins.NewLoopRegistry(opts.Logger, opts.AppConfig.Tracing(), opts.AppConfig.Telemetry(), nil, ""), CapabilitiesRegistry: capabilities.NewRegistry(opts.Logger), } @@ -122,7 +122,7 @@ func TestShell_RunNodeWithPasswords(t *testing.T) { Config: cfg, FallbackAPIInitializer: apiPrompt, Runner: cltest.EmptyRunner{}, - AppFactory: cltest.InstanceAppFactory{App: app}, + AppFactory: cltest.InstanceAppFactoryWithKeystoreMock{App: app}, Logger: lggr, } diff --git a/core/cmd/shell_test.go b/core/cmd/shell_test.go index a93be2fb9ea..13b914ba1c7 100644 --- a/core/cmd/shell_test.go +++ b/core/cmd/shell_test.go @@ -351,7 +351,7 @@ func TestNewUserCache(t *testing.T) { func TestSetupSolanaRelayer(t *testing.T) { lggr := logger.TestLogger(t) - reg := plugins.NewLoopRegistry(lggr, nil, nil) + reg := plugins.NewLoopRegistry(lggr, nil, nil, nil, "") ks := mocks.NewSolana(t) // config 3 chains but only enable 2 => should only be 2 relayer @@ -466,7 +466,7 @@ func TestSetupSolanaRelayer(t *testing.T) { func TestSetupStarkNetRelayer(t *testing.T) { lggr := logger.TestLogger(t) - reg := plugins.NewLoopRegistry(lggr, nil, nil) + reg := plugins.NewLoopRegistry(lggr, nil, nil, nil, "") ks := mocks.NewStarkNet(t) // config 3 chains but only enable 2 => should only be 2 relayer nEnabledChains := 2 diff --git a/core/internal/cltest/cltest.go b/core/internal/cltest/cltest.go index a858fc1d508..5ff48549490 100644 --- a/core/internal/cltest/cltest.go +++ b/core/internal/cltest/cltest.go @@ -394,7 +394,7 @@ func NewApplicationWithConfig(t testing.TB, cfg chainlink.GeneralConfig, flagsAn keyStore := keystore.NewInMemory(ds, utils.FastScryptParams, lggr) mailMon := mailbox.NewMonitor(cfg.AppID().String(), lggr.Named("Mailbox")) - loopRegistry := plugins.NewLoopRegistry(lggr, nil, nil) + loopRegistry := plugins.NewLoopRegistry(lggr, nil, nil, nil, "") mercuryPool := wsrpc.NewPool(lggr, cache.Config{ LatestReportTTL: cfg.Mercury().Cache().LatestReportTTL(), @@ -487,7 +487,7 @@ func NewApplicationWithConfig(t testing.TB, cfg chainlink.GeneralConfig, flagsAn RestrictedHTTPClient: c, UnrestrictedHTTPClient: c, SecretGenerator: MockSecretGenerator{}, - LoopRegistry: plugins.NewLoopRegistry(lggr, nil, nil), + LoopRegistry: plugins.NewLoopRegistry(lggr, nil, nil, nil, ""), MercuryPool: mercuryPool, CapabilitiesRegistry: capabilitiesRegistry, CapabilitiesDispatcher: dispatcher, diff --git a/core/internal/cltest/mocks.go b/core/internal/cltest/mocks.go index fd01f72c131..b8bb4657056 100644 --- a/core/internal/cltest/mocks.go +++ b/core/internal/cltest/mocks.go @@ -10,11 +10,11 @@ import ( "testing" "time" + "github.com/jmoiron/sqlx" + "github.com/smartcontractkit/chainlink/v2/core/chains/evm/txmgr" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils" - "github.com/jmoiron/sqlx" - evmclient "github.com/smartcontractkit/chainlink/v2/core/chains/evm/client" evmtypes "github.com/smartcontractkit/chainlink/v2/core/chains/evm/types" "github.com/smartcontractkit/chainlink/v2/core/chains/legacyevm" @@ -82,13 +82,27 @@ func (rm *RendererMock) Render(v interface{}, headers ...string) error { return nil } +type InstanceAppFactoryWithKeystoreMock struct { + App chainlink.Application +} + +// NewApplication creates a new application with specified config and calls the authenticate function of the keystore +func (f InstanceAppFactoryWithKeystoreMock) NewApplication(ctx context.Context, cfg chainlink.GeneralConfig, lggr logger.Logger, db *sqlx.DB, ks cmd.TerminalKeyStoreAuthenticator) (chainlink.Application, error) { + keyStore := f.App.GetKeyStore() + err := ks.Authenticate(ctx, keyStore, cfg.Password()) + if err != nil { + return nil, fmt.Errorf("error authenticating keystore: %w", err) + } + return f.App, nil +} + // InstanceAppFactory is an InstanceAppFactory type InstanceAppFactory struct { App chainlink.Application } // NewApplication creates a new application with specified config -func (f InstanceAppFactory) NewApplication(context.Context, chainlink.GeneralConfig, logger.Logger, *sqlx.DB) (chainlink.Application, error) { +func (f InstanceAppFactory) NewApplication(context.Context, chainlink.GeneralConfig, logger.Logger, *sqlx.DB, cmd.TerminalKeyStoreAuthenticator) (chainlink.Application, error) { return f.App, nil } @@ -96,7 +110,7 @@ type seededAppFactory struct { Application chainlink.Application } -func (s seededAppFactory) NewApplication(context.Context, chainlink.GeneralConfig, logger.Logger, *sqlx.DB) (chainlink.Application, error) { +func (s seededAppFactory) NewApplication(context.Context, chainlink.GeneralConfig, logger.Logger, *sqlx.DB, cmd.TerminalKeyStoreAuthenticator) (chainlink.Application, error) { return noopStopApplication{s.Application}, nil } diff --git a/core/scripts/go.mod b/core/scripts/go.mod index 9f0f60cb931..314e88a9b7f 100644 --- a/core/scripts/go.mod +++ b/core/scripts/go.mod @@ -24,9 +24,9 @@ require ( github.com/prometheus/client_golang v1.20.5 github.com/shopspring/decimal v1.4.0 github.com/smartcontractkit/chainlink-automation v0.8.1 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 github.com/smartcontractkit/chainlink/deployment v0.0.0-00010101000000-000000000000 - github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a + github.com/smartcontractkit/chainlink/v2 v2.0.0-00010101000000-000000000000 github.com/smartcontractkit/libocr v0.0.0-20241007185508-adbe57025f12 github.com/spf13/cobra v1.8.1 github.com/spf13/viper v1.19.0 diff --git a/core/scripts/go.sum b/core/scripts/go.sum index cae3853c13c..5a30edb6c83 100644 --- a/core/scripts/go.sum +++ b/core/scripts/go.sum @@ -1092,8 +1092,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 h1:VfH/AW5NtTmroY9zz6OYCPFbFTqpMyJ2ubgT9ahYf3U= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff h1:Dduou3xzY4bVJPE9yIFW+Zfqrw7QG7ePPfauO+KY508= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 h1:e+uFsxQ21tMQKRu4oBXKycNzoR30vO/7STBtqtDvQJQ= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241018134907-a00ba3729b5e h1:JiETqdNM0bktAUGMc62COwXIaw3rR3M77Me6bBLG0Fg= diff --git a/core/services/chainlink/application.go b/core/services/chainlink/application.go index 2c918b3a8d8..0b2352f67d4 100644 --- a/core/services/chainlink/application.go +++ b/core/services/chainlink/application.go @@ -294,7 +294,11 @@ func NewApplication(opts ApplicationOpts) (Application, error) { // we need to initialize in case we serve OCR2 LOOPs loopRegistry := opts.LoopRegistry if loopRegistry == nil { - loopRegistry = plugins.NewLoopRegistry(globalLogger, opts.Config.Tracing(), opts.Config.Telemetry()) + beholderAuthHeaders, csaPubKeyHex, err := keystore.BuildBeholderAuth(keyStore) + if err != nil { + return nil, fmt.Errorf("could not build Beholder auth: %w", err) + } + loopRegistry = plugins.NewLoopRegistry(globalLogger, opts.Config.Tracing(), opts.Config.Telemetry(), beholderAuthHeaders, csaPubKeyHex) } // If the audit logger is enabled diff --git a/core/services/chainlink/config_telemetry.go b/core/services/chainlink/config_telemetry.go index 94caa9570d6..125eeed64e5 100644 --- a/core/services/chainlink/config_telemetry.go +++ b/core/services/chainlink/config_telemetry.go @@ -4,6 +4,7 @@ import ( "time" "github.com/smartcontractkit/chainlink/v2/core/config/toml" + "github.com/smartcontractkit/chainlink/v2/core/static" ) type telemetryConfig struct { @@ -33,8 +34,24 @@ func (b *telemetryConfig) OtelExporterGRPCEndpoint() string { return *b.s.Endpoint } +// ResourceAttributes returns the resource attributes set in the TOML config +// by the user, but first sets OTEL required attributes: +// +// service.name +// service.version +// +// These can be overridden by the TOML if the user so chooses func (b *telemetryConfig) ResourceAttributes() map[string]string { - return b.s.ResourceAttributes + defaults := map[string]string{ + "service.name": "chainlink", + "service.version": static.Version, + } + + for k, v := range b.s.ResourceAttributes { + defaults[k] = v + } + + return defaults } func (b *telemetryConfig) TraceSampleRatio() float64 { diff --git a/core/services/chainlink/config_telemetry_test.go b/core/services/chainlink/config_telemetry_test.go new file mode 100644 index 00000000000..d0963129994 --- /dev/null +++ b/core/services/chainlink/config_telemetry_test.go @@ -0,0 +1,142 @@ +package chainlink + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/smartcontractkit/chainlink/v2/core/config/toml" + "github.com/smartcontractkit/chainlink/v2/core/static" +) + +func TestTelemetryConfig_Enabled(t *testing.T) { + trueVal := true + falseVal := false + + tests := []struct { + name string + telemetry toml.Telemetry + expected bool + }{ + {"EnabledTrue", toml.Telemetry{Enabled: &trueVal}, true}, + {"EnabledFalse", toml.Telemetry{Enabled: &falseVal}, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tc := telemetryConfig{s: tt.telemetry} + assert.Equal(t, tt.expected, tc.Enabled()) + }) + } +} + +func TestTelemetryConfig_InsecureConnection(t *testing.T) { + trueVal := true + falseVal := false + + tests := []struct { + name string + telemetry toml.Telemetry + expected bool + }{ + {"InsecureConnectionTrue", toml.Telemetry{InsecureConnection: &trueVal}, true}, + {"InsecureConnectionFalse", toml.Telemetry{InsecureConnection: &falseVal}, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tc := telemetryConfig{s: tt.telemetry} + assert.Equal(t, tt.expected, tc.InsecureConnection()) + }) + } +} + +func TestTelemetryConfig_CACertFile(t *testing.T) { + tests := []struct { + name string + telemetry toml.Telemetry + expected string + }{ + {"CACertFileSet", toml.Telemetry{CACertFile: ptr("test.pem")}, "test.pem"}, + {"CACertFileNil", toml.Telemetry{CACertFile: nil}, ""}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tc := telemetryConfig{s: tt.telemetry} + assert.Equal(t, tt.expected, tc.CACertFile()) + }) + } +} + +func TestTelemetryConfig_OtelExporterGRPCEndpoint(t *testing.T) { + tests := []struct { + name string + telemetry toml.Telemetry + expected string + }{ + {"EndpointSet", toml.Telemetry{Endpoint: ptr("localhost:4317")}, "localhost:4317"}, + {"EndpointNil", toml.Telemetry{Endpoint: nil}, ""}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tc := telemetryConfig{s: tt.telemetry} + assert.Equal(t, tt.expected, tc.OtelExporterGRPCEndpoint()) + }) + } +} + +func TestTelemetryConfig_ResourceAttributes(t *testing.T) { + tests := []struct { + name string + telemetry toml.Telemetry + expected map[string]string + }{ + { + "DefaultAttributes", + toml.Telemetry{ResourceAttributes: nil}, + map[string]string{ + "service.name": "chainlink", + "service.version": static.Version, + }, + }, + { + "CustomAttributes", + toml.Telemetry{ResourceAttributes: map[string]string{"custom.key": "custom.value"}}, + map[string]string{ + "service.name": "chainlink", + "service.version": static.Version, + "custom.key": "custom.value", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tc := telemetryConfig{s: tt.telemetry} + assert.Equal(t, tt.expected, tc.ResourceAttributes()) + }) + } +} + +func TestTelemetryConfig_TraceSampleRatio(t *testing.T) { + tests := []struct { + name string + telemetry toml.Telemetry + expected float64 + }{ + {"TraceSampleRatioSet", toml.Telemetry{TraceSampleRatio: ptrFloat(0.5)}, 0.5}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tc := telemetryConfig{s: tt.telemetry} + assert.InEpsilon(t, tt.expected, tc.TraceSampleRatio(), 0.0001) + }) + } +} + +func ptrFloat(f float64) *float64 { + return &f +} diff --git a/core/services/chainlink/relayer_chain_interoperators_test.go b/core/services/chainlink/relayer_chain_interoperators_test.go index e83c2881c93..a4bd8c168ba 100644 --- a/core/services/chainlink/relayer_chain_interoperators_test.go +++ b/core/services/chainlink/relayer_chain_interoperators_test.go @@ -176,7 +176,7 @@ func TestCoreRelayerChainInteroperators(t *testing.T) { factory := chainlink.RelayerFactory{ Logger: lggr, - LoopRegistry: plugins.NewLoopRegistry(lggr, nil, nil), + LoopRegistry: plugins.NewLoopRegistry(lggr, nil, nil, nil, ""), GRPCOpts: loop.GRPCOpts{}, CapabilitiesRegistry: capabilities.NewRegistry(lggr), } diff --git a/core/services/keystore/beholder.go b/core/services/keystore/beholder.go new file mode 100644 index 00000000000..40655cf0e82 --- /dev/null +++ b/core/services/keystore/beholder.go @@ -0,0 +1,19 @@ +package keystore + +import ( + "encoding/hex" + + "github.com/smartcontractkit/chainlink-common/pkg/beholder" +) + +func BuildBeholderAuth(keyStore Master) (authHeaders map[string]string, pubKeyHex string, err error) { + csaKeys, err := keyStore.CSA().GetAll() + if err != nil { + return nil, "", err + } + csaKey := csaKeys[0] + csaPrivKey := csaKey.Raw().Bytes() + authHeaders = beholder.BuildAuthHeaders(csaPrivKey) + pubKeyHex = hex.EncodeToString(csaKey.PublicKey) + return +} diff --git a/core/services/ocr2/plugins/ccip/testhelpers/integration/chainlink.go b/core/services/ocr2/plugins/ccip/testhelpers/integration/chainlink.go index 0b7f0de4d25..b34aab8decd 100644 --- a/core/services/ocr2/plugins/ccip/testhelpers/integration/chainlink.go +++ b/core/services/ocr2/plugins/ccip/testhelpers/integration/chainlink.go @@ -460,7 +460,10 @@ func setupNodeCCIP( }, CSAETHKeystore: simEthKeyStore, } - loopRegistry := plugins.NewLoopRegistry(lggr.Named("LoopRegistry"), config.Tracing(), config.Telemetry()) + beholderAuthHeaders, csaPubKeyHex, err := keystore.BuildBeholderAuth(keyStore) + require.NoError(t, err) + + loopRegistry := plugins.NewLoopRegistry(lggr.Named("LoopRegistry"), config.Tracing(), config.Telemetry(), beholderAuthHeaders, csaPubKeyHex) relayerFactory := chainlink.RelayerFactory{ Logger: lggr, LoopRegistry: loopRegistry, @@ -490,7 +493,7 @@ func setupNodeCCIP( RestrictedHTTPClient: &http.Client{}, AuditLogger: audit.NoopLogger, MailMon: mailMon, - LoopRegistry: plugins.NewLoopRegistry(lggr, config.Tracing(), config.Telemetry()), + LoopRegistry: plugins.NewLoopRegistry(lggr, config.Tracing(), config.Telemetry(), beholderAuthHeaders, csaPubKeyHex), }) require.NoError(t, err) require.NoError(t, app.GetKeyStore().Unlock(ctx, "password")) diff --git a/core/services/ocr2/plugins/ccip/testhelpers/testhelpers_1_4_0/chainlink.go b/core/services/ocr2/plugins/ccip/testhelpers/testhelpers_1_4_0/chainlink.go index b897d565bae..4118f158210 100644 --- a/core/services/ocr2/plugins/ccip/testhelpers/testhelpers_1_4_0/chainlink.go +++ b/core/services/ocr2/plugins/ccip/testhelpers/testhelpers_1_4_0/chainlink.go @@ -455,7 +455,11 @@ func setupNodeCCIP( }, CSAETHKeystore: simEthKeyStore, } - loopRegistry := plugins.NewLoopRegistry(lggr.Named("LoopRegistry"), config.Tracing(), config.Telemetry()) + + beholderAuthHeaders, csaPubKeyHex, err := keystore.BuildBeholderAuth(keyStore) + require.NoError(t, err) + + loopRegistry := plugins.NewLoopRegistry(lggr.Named("LoopRegistry"), config.Tracing(), config.Telemetry(), beholderAuthHeaders, csaPubKeyHex) relayerFactory := chainlink.RelayerFactory{ Logger: lggr, LoopRegistry: loopRegistry, @@ -485,7 +489,7 @@ func setupNodeCCIP( RestrictedHTTPClient: &http.Client{}, AuditLogger: audit.NoopLogger, MailMon: mailMon, - LoopRegistry: plugins.NewLoopRegistry(lggr, config.Tracing(), config.Telemetry()), + LoopRegistry: plugins.NewLoopRegistry(lggr, config.Tracing(), config.Telemetry(), beholderAuthHeaders, csaPubKeyHex), }) ctx := testutils.Context(t) require.NoError(t, err) diff --git a/core/web/loop_registry_internal_test.go b/core/web/loop_registry_internal_test.go index a02fa20802a..d1235cd09b4 100644 --- a/core/web/loop_registry_internal_test.go +++ b/core/web/loop_registry_internal_test.go @@ -38,7 +38,7 @@ func TestLoopRegistryServer_CantWriteToResponse(t *testing.T) { l, o := logger.TestLoggerObserved(t, zap.ErrorLevel) s := &LoopRegistryServer{ exposedPromPort: 1, - registry: plugins.NewLoopRegistry(l, nil, nil), + registry: plugins.NewLoopRegistry(l, nil, nil, nil, ""), logger: l.(logger.SugaredLogger), jsonMarshalFn: json.Marshal, } @@ -53,7 +53,7 @@ func TestLoopRegistryServer_CantMarshal(t *testing.T) { l, o := logger.TestLoggerObserved(t, zap.ErrorLevel) s := &LoopRegistryServer{ exposedPromPort: 1, - registry: plugins.NewLoopRegistry(l, nil, nil), + registry: plugins.NewLoopRegistry(l, nil, nil, nil, ""), logger: l.(logger.SugaredLogger), jsonMarshalFn: func(any) ([]byte, error) { return []byte(""), errors.New("can't unmarshal") diff --git a/deployment/ccip/changeset/cap_reg.go b/deployment/ccip/changeset/cap_reg.go deleted file mode 100644 index 1eded730a7c..00000000000 --- a/deployment/ccip/changeset/cap_reg.go +++ /dev/null @@ -1,30 +0,0 @@ -package changeset - -import ( - "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/timelock" - - "github.com/smartcontractkit/chainlink/deployment" - ccipdeployment "github.com/smartcontractkit/chainlink/deployment/ccip" -) - -var _ deployment.ChangeSet = DeployCapReg - -// DeployCapReg is a separate changeset because cap reg is an env var for CL nodes. -func DeployCapReg(env deployment.Environment, config interface{}) (deployment.ChangesetOutput, error) { - homeChainSel, ok := config.(uint64) - if !ok { - return deployment.ChangesetOutput{}, deployment.ErrInvalidConfig - } - // Note we also deploy the cap reg. - ab := deployment.NewMemoryAddressBook() - _, err := ccipdeployment.DeployCapReg(env.Logger, ab, env.Chains[homeChainSel]) - if err != nil { - env.Logger.Errorw("Failed to deploy cap reg", "err", err, "addresses", ab) - return deployment.ChangesetOutput{}, err - } - return deployment.ChangesetOutput{ - Proposals: []timelock.MCMSWithTimelockProposal{}, - AddressBook: ab, - JobSpecs: nil, - }, nil -} diff --git a/deployment/ccip/changeset/home_chain.go b/deployment/ccip/changeset/home_chain.go new file mode 100644 index 00000000000..5fa5cab5b21 --- /dev/null +++ b/deployment/ccip/changeset/home_chain.go @@ -0,0 +1,77 @@ +package changeset + +import ( + "fmt" + + "github.com/ethereum/go-ethereum/common" + "github.com/pkg/errors" + "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/timelock" + + "github.com/smartcontractkit/chainlink/deployment" + ccipdeployment "github.com/smartcontractkit/chainlink/deployment/ccip" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/keystone/generated/capabilities_registry" +) + +var _ deployment.ChangeSet = DeployHomeChain + +// DeployHomeChain is a separate changeset because it is a standalone deployment performed once in home chain for the entire CCIP deployment. +func DeployHomeChain(env deployment.Environment, config interface{}) (deployment.ChangesetOutput, error) { + cfg, ok := config.(DeployHomeChainConfig) + if !ok { + return deployment.ChangesetOutput{}, deployment.ErrInvalidConfig + } + err := cfg.Validate() + if err != nil { + return deployment.ChangesetOutput{}, errors.Wrapf(deployment.ErrInvalidConfig, "%v", err) + } + ab := deployment.NewMemoryAddressBook() + // Note we also deploy the cap reg. + _, err = ccipdeployment.DeployHomeChain(env.Logger, env, ab, env.Chains[cfg.HomeChainSel], cfg.RMNStaticConfig, cfg.RMNDynamicConfig, cfg.NodeOperators, cfg.NodeP2PIDsPerNodeOpAdmin) + if err != nil { + env.Logger.Errorw("Failed to deploy cap reg", "err", err, "addresses", env.ExistingAddresses) + return deployment.ChangesetOutput{}, err + } + + return deployment.ChangesetOutput{ + Proposals: []timelock.MCMSWithTimelockProposal{}, + AddressBook: ab, + JobSpecs: nil, + }, nil +} + +type DeployHomeChainConfig struct { + HomeChainSel uint64 + RMNStaticConfig rmn_home.RMNHomeStaticConfig + RMNDynamicConfig rmn_home.RMNHomeDynamicConfig + NodeOperators []capabilities_registry.CapabilitiesRegistryNodeOperator + NodeP2PIDsPerNodeOpAdmin map[string][][32]byte +} + +func (c DeployHomeChainConfig) Validate() error { + if c.HomeChainSel == 0 { + return fmt.Errorf("home chain selector must be set") + } + if c.RMNDynamicConfig.OffchainConfig == nil { + return fmt.Errorf("offchain config for RMNHomeDynamicConfig must be set") + } + if c.RMNStaticConfig.OffchainConfig == nil { + return fmt.Errorf("offchain config for RMNHomeStaticConfig must be set") + } + if len(c.NodeOperators) == 0 { + return fmt.Errorf("node operators must be set") + } + for _, nop := range c.NodeOperators { + if nop.Admin == (common.Address{}) { + return fmt.Errorf("node operator admin address must be set") + } + if nop.Name == "" { + return fmt.Errorf("node operator name must be set") + } + if len(c.NodeP2PIDsPerNodeOpAdmin[nop.Name]) == 0 { + return fmt.Errorf("node operator %s must have node p2p ids provided", nop.Name) + } + } + + return nil +} diff --git a/deployment/ccip/changeset/home_chain_test.go b/deployment/ccip/changeset/home_chain_test.go new file mode 100644 index 00000000000..f0abdc64437 --- /dev/null +++ b/deployment/ccip/changeset/home_chain_test.go @@ -0,0 +1,63 @@ +package changeset + +import ( + "testing" + + chainsel "github.com/smartcontractkit/chain-selectors" + "github.com/stretchr/testify/require" + "go.uber.org/zap/zapcore" + + "github.com/smartcontractkit/chainlink/deployment" + ccdeploy "github.com/smartcontractkit/chainlink/deployment/ccip" + "github.com/smartcontractkit/chainlink/deployment/common/view/v1_0" + "github.com/smartcontractkit/chainlink/deployment/environment/memory" + "github.com/smartcontractkit/chainlink/v2/core/logger" +) + +func TestDeployHomeChain(t *testing.T) { + lggr := logger.TestLogger(t) + e := memory.NewMemoryEnvironment(t, lggr, zapcore.InfoLevel, memory.MemoryEnvironmentConfig{ + Bootstraps: 1, + Chains: 2, + Nodes: 4, + }) + homeChainSel := e.AllChainSelectors()[0] + nodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) + require.NoError(t, err) + p2pIds := nodes.NonBootstraps().PeerIDs() + homeChainCfg := DeployHomeChainConfig{ + HomeChainSel: homeChainSel, + RMNStaticConfig: ccdeploy.NewTestRMNStaticConfig(), + RMNDynamicConfig: ccdeploy.NewTestRMNDynamicConfig(), + NodeOperators: ccdeploy.NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), + NodeP2PIDsPerNodeOpAdmin: map[string][][32]byte{ + "NodeOperator": p2pIds, + }, + } + output, err := DeployHomeChain(e, homeChainCfg) + require.NoError(t, err) + require.NoError(t, e.ExistingAddresses.Merge(output.AddressBook)) + state, err := ccdeploy.LoadOnchainState(e) + require.NoError(t, err) + require.NotNil(t, state.Chains[homeChainSel].CapabilityRegistry) + require.NotNil(t, state.Chains[homeChainSel].CCIPHome) + require.NotNil(t, state.Chains[homeChainSel].RMNHome) + snap, err := state.View([]uint64{homeChainSel}) + require.NoError(t, err) + chainid, err := chainsel.ChainIdFromSelector(homeChainSel) + require.NoError(t, err) + chainName, err := chainsel.NameFromChainId(chainid) + require.NoError(t, err) + _, ok := snap[chainName] + require.True(t, ok) + capRegSnap, ok := snap[chainName].CapabilityRegistry[state.Chains[homeChainSel].CapabilityRegistry.Address().String()] + require.True(t, ok) + require.NotNil(t, capRegSnap) + require.Equal(t, capRegSnap.Nops, []v1_0.NopView{ + { + Admin: e.Chains[homeChainSel].DeployerKey.From, + Name: "NodeOperator", + }, + }) + require.Len(t, capRegSnap.Nodes, len(p2pIds)) +} diff --git a/deployment/ccip/deploy.go b/deployment/ccip/deploy.go index 4d90422c843..f407b9856c4 100644 --- a/deployment/ccip/deploy.go +++ b/deployment/ccip/deploy.go @@ -12,6 +12,7 @@ import ( owner_helpers "github.com/smartcontractkit/ccip-owner-contracts/pkg/gethwrappers" "github.com/smartcontractkit/chainlink-common/pkg/logger" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/fee_quoter" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/registry_module_owner_custom" "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home" @@ -187,15 +188,6 @@ func DeployCCIPContracts(e deployment.Environment, ab deployment.AddressBook, c return fmt.Errorf("ccip home address mismatch") } - // Signal to CR that our nodes support CCIP capability. - if err := AddNodes( - e.Logger, - capReg, - e.Chains[c.HomeChainSel], - nodes.NonBootstraps().PeerIDs(), - ); err != nil { - return err - } rmnHome := existingState.Chains[c.HomeChainSel].RMNHome if rmnHome == nil { e.Logger.Errorw("Failed to get rmn home", "err", err) diff --git a/deployment/ccip/deploy_home_chain.go b/deployment/ccip/deploy_home_chain.go index 3f614b8510f..341f53a0438 100644 --- a/deployment/ccip/deploy_home_chain.go +++ b/deployment/ccip/deploy_home_chain.go @@ -15,6 +15,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/pkg/errors" "github.com/smartcontractkit/ccip-owner-contracts/pkg/proposal/mcms" + "golang.org/x/exp/maps" "github.com/smartcontractkit/chainlink-ccip/chainconfig" "github.com/smartcontractkit/chainlink-ccip/pkg/types/ccipocr3" @@ -85,7 +86,24 @@ func MustABIEncode(abiString string, args ...interface{}) []byte { return encoded } -func DeployCapReg(lggr logger.Logger, ab deployment.AddressBook, chain deployment.Chain) (*ContractDeploy[*capabilities_registry.CapabilitiesRegistry], error) { +// DeployCapReg deploys the CapabilitiesRegistry contract if it is not already deployed +// and returns a ContractDeploy struct with the address and contract instance. +func DeployCapReg( + lggr logger.Logger, + state CCIPOnChainState, + ab deployment.AddressBook, + chain deployment.Chain, +) (*ContractDeploy[*capabilities_registry.CapabilitiesRegistry], error) { + homeChainState, exists := state.Chains[chain.Selector] + if exists { + cr := homeChainState.CapabilityRegistry + if cr != nil { + lggr.Infow("Found CapabilitiesRegistry in chain state", "address", cr.Address().String()) + return &ContractDeploy[*capabilities_registry.CapabilitiesRegistry]{ + Address: cr.Address(), Contract: cr, Tv: deployment.NewTypeAndVersion(CapabilitiesRegistry, deployment.Version1_0_0), + }, nil + } + } capReg, err := deployContract(lggr, chain, ab, func(chain deployment.Chain) ContractDeploy[*capabilities_registry.CapabilitiesRegistry] { crAddr, tx, cr, err2 := capabilities_registry.DeployCapabilitiesRegistry( @@ -100,8 +118,31 @@ func DeployCapReg(lggr logger.Logger, ab deployment.AddressBook, chain deploymen lggr.Errorw("Failed to deploy capreg", "err", err) return nil, err } + return capReg, nil +} - lggr.Infow("deployed capreg", "addr", capReg.Address) +func DeployHomeChain( + lggr logger.Logger, + e deployment.Environment, + ab deployment.AddressBook, + chain deployment.Chain, + rmnHomeStatic rmn_home.RMNHomeStaticConfig, + rmnHomeDynamic rmn_home.RMNHomeDynamicConfig, + nodeOps []capabilities_registry.CapabilitiesRegistryNodeOperator, + nodeP2PIDsPerNodeOpAdmin map[string][][32]byte, +) (*ContractDeploy[*capabilities_registry.CapabilitiesRegistry], error) { + // load existing state + state, err := LoadOnchainState(e) + if err != nil { + return nil, fmt.Errorf("failed to load onchain state: %w", err) + } + // Deploy CapabilitiesRegistry, CCIPHome, RMNHome + capReg, err := DeployCapReg(lggr, state, ab, chain) + if err != nil { + return nil, err + } + + lggr.Infow("deployed/connected to capreg", "addr", capReg.Address) ccipHome, err := deployContract( lggr, chain, ab, func(chain deployment.Chain) ContractDeploy[*ccip_home.CCIPHome] { @@ -138,14 +179,8 @@ func DeployCapReg(lggr logger.Logger, ab deployment.AddressBook, chain deploymen } lggr.Infow("deployed RMNHome", "addr", rmnHome.Address) - // TODO: properly configure RMNHome - tx, err := rmnHome.Contract.SetCandidate(chain.DeployerKey, rmn_home.RMNHomeStaticConfig{ - Nodes: []rmn_home.RMNHomeNode{}, - OffchainConfig: []byte("static config"), - }, rmn_home.RMNHomeDynamicConfig{ - SourceChains: []rmn_home.RMNHomeSourceChain{}, - OffchainConfig: []byte("dynamic config"), - }, [32]byte{}) + // considering the RMNHome is recently deployed, there is no digest to overwrite + tx, err := rmnHome.Contract.SetCandidate(chain.DeployerKey, rmnHomeStatic, rmnHomeDynamic, [32]byte{}) if _, err := deployment.ConfirmIfNoError(chain, tx, err); err != nil { lggr.Errorw("Failed to set candidate on RMNHome", "err", err) return nil, err @@ -189,20 +224,63 @@ func DeployCapReg(lggr logger.Logger, ab deployment.AddressBook, chain deploymen lggr.Errorw("Failed to add capabilities", "err", err) return nil, err } - // TODO: Just one for testing. - tx, err = capReg.Contract.AddNodeOperators(chain.DeployerKey, []capabilities_registry.CapabilitiesRegistryNodeOperator{ - { - Admin: chain.DeployerKey.From, - Name: "NodeOperator", - }, - }) - if _, err := deployment.ConfirmIfNoError(chain, tx, err); err != nil { + + tx, err = capReg.Contract.AddNodeOperators(chain.DeployerKey, nodeOps) + txBlockNum, err := deployment.ConfirmIfNoError(chain, tx, err) + if err != nil { lggr.Errorw("Failed to add node operators", "err", err) return nil, err } + addedEvent, err := capReg.Contract.FilterNodeOperatorAdded(&bind.FilterOpts{ + Start: txBlockNum, + Context: context.Background(), + }, nil, nil) + if err != nil { + lggr.Errorw("Failed to filter NodeOperatorAdded event", "err", err) + return capReg, err + } + // Need to fetch nodeoperators ids to be able to add nodes for corresponding node operators + p2pIDsByNodeOpId := make(map[uint32][][32]byte) + for addedEvent.Next() { + for nopName, p2pId := range nodeP2PIDsPerNodeOpAdmin { + if addedEvent.Event.Name == nopName { + lggr.Infow("Added node operator", "admin", addedEvent.Event.Admin, "name", addedEvent.Event.Name) + p2pIDsByNodeOpId[addedEvent.Event.NodeOperatorId] = p2pId + } + } + } + if len(p2pIDsByNodeOpId) != len(nodeP2PIDsPerNodeOpAdmin) { + lggr.Errorw("Failed to add all node operators", "added", maps.Keys(p2pIDsByNodeOpId), "expected", maps.Keys(nodeP2PIDsPerNodeOpAdmin)) + return capReg, errors.New("failed to add all node operators") + } + // Adds initial set of nodes to CR, who all have the CCIP capability + if err := AddNodes(lggr, capReg.Contract, chain, p2pIDsByNodeOpId); err != nil { + return capReg, err + } return capReg, nil } +// getNodeOperatorIDMap returns a map of node operator names to their IDs +// If maxNops is greater than the number of node operators, it will return all node operators +func getNodeOperatorIDMap(capReg *capabilities_registry.CapabilitiesRegistry, maxNops uint32) (map[string]uint32, error) { + nopIdByName := make(map[string]uint32) + operators, err := capReg.GetNodeOperators(nil) + if err != nil { + return nil, err + } + if len(operators) < int(maxNops) { + maxNops = uint32(len(operators)) + } + for i := uint32(1); i <= maxNops; i++ { + operator, err := capReg.GetNodeOperator(nil, i) + if err != nil { + return nil, err + } + nopIdByName[operator.Name] = i + } + return nopIdByName, nil +} + func isEqualCapabilitiesRegistryNodeParams(a, b capabilities_registry.CapabilitiesRegistryNodeParams) (bool, error) { aBytes, err := json.Marshal(a) if err != nil { @@ -219,7 +297,7 @@ func AddNodes( lggr logger.Logger, capReg *capabilities_registry.CapabilitiesRegistry, chain deployment.Chain, - p2pIDs [][32]byte, + p2pIDsByNodeOpId map[uint32][][32]byte, ) error { var nodeParams []capabilities_registry.CapabilitiesRegistryNodeParams nodes, err := capReg.GetNodes(nil) @@ -235,26 +313,28 @@ func AddNodes( HashedCapabilityIds: node.HashedCapabilityIds, } } - for _, p2pID := range p2pIDs { - // if any p2pIDs are empty throw error - if bytes.Equal(p2pID[:], make([]byte, 32)) { - return errors.Wrapf(errors.New("empty p2pID"), "p2pID: %x selector: %d", p2pID, chain.Selector) - } - nodeParam := capabilities_registry.CapabilitiesRegistryNodeParams{ - NodeOperatorId: NodeOperatorID, - Signer: p2pID, // Not used in tests - P2pId: p2pID, - EncryptionPublicKey: p2pID, // Not used in tests - HashedCapabilityIds: [][32]byte{CCIPCapabilityID}, - } - if existing, ok := existingNodeParams[p2pID]; ok { - if isEqual, err := isEqualCapabilitiesRegistryNodeParams(existing, nodeParam); err != nil && isEqual { - lggr.Infow("Node already exists", "p2pID", p2pID) - continue + for nopID, p2pIDs := range p2pIDsByNodeOpId { + for _, p2pID := range p2pIDs { + // if any p2pIDs are empty throw error + if bytes.Equal(p2pID[:], make([]byte, 32)) { + return errors.Wrapf(errors.New("empty p2pID"), "p2pID: %x selector: %d", p2pID, chain.Selector) + } + nodeParam := capabilities_registry.CapabilitiesRegistryNodeParams{ + NodeOperatorId: nopID, + Signer: p2pID, // Not used in tests + P2pId: p2pID, + EncryptionPublicKey: p2pID, // Not used in tests + HashedCapabilityIds: [][32]byte{CCIPCapabilityID}, + } + if existing, ok := existingNodeParams[p2pID]; ok { + if isEqual, err := isEqualCapabilitiesRegistryNodeParams(existing, nodeParam); err != nil && isEqual { + lggr.Infow("Node already exists", "p2pID", p2pID) + continue + } } - } - nodeParams = append(nodeParams, nodeParam) + nodeParams = append(nodeParams, nodeParam) + } } if len(nodeParams) == 0 { lggr.Infow("No new nodes to add") diff --git a/deployment/ccip/deploy_test.go b/deployment/ccip/deploy_test.go index ecb17017193..63aeacb4bdf 100644 --- a/deployment/ccip/deploy_test.go +++ b/deployment/ccip/deploy_test.go @@ -25,6 +25,18 @@ func TestDeployCCIPContracts(t *testing.T) { homeChainSel, feedChainSel := allocateCCIPChainSelectors(e.Chains) _ = DeployTestContracts(t, lggr, e.ExistingAddresses, homeChainSel, feedChainSel, e.Chains) + nodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) + require.NoError(t, err) + + _, err = DeployHomeChain(lggr, e, e.ExistingAddresses, e.Chains[homeChainSel], + NewTestRMNStaticConfig(), + NewTestRMNDynamicConfig(), + NewTestNodeOperator(e.Chains[homeChainSel].DeployerKey.From), + map[string][][32]byte{ + "NodeOperator": nodes.NonBootstraps().PeerIDs(), + }, + ) + require.NoError(t, err) // Load the state after deploying the cap reg and feeds. s, err := LoadOnchainState(e) require.NoError(t, err) diff --git a/deployment/ccip/test_helpers.go b/deployment/ccip/test_helpers.go index de1ebd7e675..74cf98cab9f 100644 --- a/deployment/ccip/test_helpers.go +++ b/deployment/ccip/test_helpers.go @@ -3,12 +3,13 @@ package ccipdeployment import ( "context" "fmt" - mapset "github.com/deckarep/golang-set/v2" "math/big" "sort" "testing" "time" + mapset "github.com/deckarep/golang-set/v2" + "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/core/types" @@ -111,7 +112,11 @@ func DeployTestContracts(t *testing.T, feedChainSel uint64, chains map[uint64]deployment.Chain, ) deployment.CapabilityRegistryConfig { - capReg, err := DeployCapReg(lggr, ab, chains[homeChainSel]) + capReg, err := DeployCapReg(lggr, + // deploying cap reg for the first time on a blank chain state + CCIPOnChainState{ + Chains: make(map[uint64]CCIPChainState), + }, ab, chains[homeChainSel]) require.NoError(t, err) _, err = DeployFeeds(lggr, ab, chains[feedChainSel]) require.NoError(t, err) @@ -172,9 +177,20 @@ func NewMemoryEnvironment(t *testing.T, lggr logger.Logger, numChains int, numNo require.NoError(t, node.App.Stop()) }) } - e := memory.NewMemoryEnvironmentFromChainsNodes(t, lggr, chains, nodes) + envNodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) + require.NoError(t, err) e.ExistingAddresses = ab + _, err = DeployHomeChain(lggr, e, e.ExistingAddresses, chains[homeChainSel], + NewTestRMNStaticConfig(), + NewTestRMNDynamicConfig(), + NewTestNodeOperator(chains[homeChainSel].DeployerKey.From), + map[string][][32]byte{ + "NodeOperator": envNodes.NonBootstraps().PeerIDs(), + }, + ) + require.NoError(t, err) + return DeployedEnv{ Env: e, HomeChainSel: homeChainSel, diff --git a/deployment/ccip/test_params.go b/deployment/ccip/test_params.go new file mode 100644 index 00000000000..531c48532f1 --- /dev/null +++ b/deployment/ccip/test_params.go @@ -0,0 +1,31 @@ +package ccipdeployment + +import ( + "github.com/ethereum/go-ethereum/common" + + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/ccip/generated/rmn_home" + "github.com/smartcontractkit/chainlink/v2/core/gethwrappers/keystone/generated/capabilities_registry" +) + +func NewTestRMNStaticConfig() rmn_home.RMNHomeStaticConfig { + return rmn_home.RMNHomeStaticConfig{ + Nodes: []rmn_home.RMNHomeNode{}, + OffchainConfig: []byte("static config"), + } +} + +func NewTestRMNDynamicConfig() rmn_home.RMNHomeDynamicConfig { + return rmn_home.RMNHomeDynamicConfig{ + SourceChains: []rmn_home.RMNHomeSourceChain{}, + OffchainConfig: []byte("dynamic config"), + } +} + +func NewTestNodeOperator(admin common.Address) []capabilities_registry.CapabilitiesRegistryNodeOperator { + return []capabilities_registry.CapabilitiesRegistryNodeOperator{ + { + Admin: admin, + Name: "NodeOperator", + }, + } +} diff --git a/deployment/changeset.go b/deployment/changeset.go index 687d772bf73..e6c0988e67e 100644 --- a/deployment/changeset.go +++ b/deployment/changeset.go @@ -8,7 +8,7 @@ import ( ) var ( - ErrInvalidConfig = errors.New("invalid config") + ErrInvalidConfig = errors.New("invalid changeset config") ) // ChangeSet represents a set of changes to be made to an environment. diff --git a/deployment/environment/memory/node.go b/deployment/environment/memory/node.go index a2a690cbae5..90ad264faa9 100644 --- a/deployment/environment/memory/node.go +++ b/deployment/environment/memory/node.go @@ -145,10 +145,17 @@ func NewNode( CSAETHKeystore: kStore, } + // Build Beholder auth + ctx := tests.Context(t) + require.NoError(t, master.Unlock(ctx, "password")) + require.NoError(t, master.CSA().EnsureKey(ctx)) + beholderAuthHeaders, csaPubKeyHex, err := keystore.BuildBeholderAuth(master) + require.NoError(t, err) + // Build relayer factory with EVM. relayerFactory := chainlink.RelayerFactory{ Logger: lggr, - LoopRegistry: plugins.NewLoopRegistry(lggr.Named("LoopRegistry"), cfg.Tracing(), cfg.Telemetry()), + LoopRegistry: plugins.NewLoopRegistry(lggr.Named("LoopRegistry"), cfg.Tracing(), cfg.Telemetry(), beholderAuthHeaders, csaPubKeyHex), GRPCOpts: loop.GRPCOpts{}, CapabilitiesRegistry: capabilities.NewRegistry(lggr), } @@ -168,7 +175,7 @@ func NewNode( RestrictedHTTPClient: &http.Client{}, AuditLogger: audit.NoopLogger, MailMon: mailMon, - LoopRegistry: plugins.NewLoopRegistry(lggr, cfg.Tracing(), cfg.Telemetry()), + LoopRegistry: plugins.NewLoopRegistry(lggr, cfg.Tracing(), cfg.Telemetry(), beholderAuthHeaders, csaPubKeyHex), }) require.NoError(t, err) t.Cleanup(func() { @@ -193,7 +200,6 @@ type Keys struct { func CreateKeys(t *testing.T, app chainlink.Application, chains map[uint64]EVMChain) Keys { ctx := tests.Context(t) - require.NoError(t, app.GetKeyStore().Unlock(ctx, "password")) _, err := app.GetKeyStore().P2P().Create(ctx) require.NoError(t, err) diff --git a/deployment/go.mod b/deployment/go.mod index 26342d19ca2..cde3a01968c 100644 --- a/deployment/go.mod +++ b/deployment/go.mod @@ -2,6 +2,9 @@ module github.com/smartcontractkit/chainlink/deployment go 1.22.8 +// Make sure we're working with the latest chainlink libs +replace github.com/smartcontractkit/chainlink/v2 => ../ + require ( github.com/AlekSi/pointer v1.1.0 github.com/Khan/genqlient v0.7.0 @@ -21,16 +24,17 @@ require ( github.com/smartcontractkit/ccip-owner-contracts v0.0.0-20240926212305-a6deabdfce86 github.com/smartcontractkit/chain-selectors v1.0.27 github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241106142051-c7bded1c08ae + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 github.com/smartcontractkit/chainlink-protos/job-distributor v0.4.0 github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.13 - github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a + github.com/smartcontractkit/chainlink/v2 v2.0.0-00010101000000-000000000000 github.com/smartcontractkit/libocr v0.0.0-20241007185508-adbe57025f12 github.com/stretchr/testify v1.9.0 github.com/test-go/testify v1.1.4 github.com/testcontainers/testcontainers-go v0.34.0 go.uber.org/multierr v1.11.0 go.uber.org/zap v1.27.0 + golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c golang.org/x/sync v0.8.0 google.golang.org/grpc v1.67.1 google.golang.org/protobuf v1.35.1 @@ -263,7 +267,7 @@ require ( github.com/hashicorp/go-hclog v1.6.3 // indirect github.com/hashicorp/go-immutable-radix v1.3.1 // indirect github.com/hashicorp/go-msgpack v0.5.5 // indirect - github.com/hashicorp/go-plugin v1.6.2-0.20240829161738-06afb6d7ae99 // indirect + github.com/hashicorp/go-plugin v1.6.2 // indirect github.com/hashicorp/go-retryablehttp v0.7.7 // indirect github.com/hashicorp/go-rootcerts v1.0.2 // indirect github.com/hashicorp/go-sockaddr v1.0.6 // indirect @@ -475,7 +479,6 @@ require ( go4.org/netipx v0.0.0-20230125063823-8449b0a6169f // indirect golang.org/x/arch v0.11.0 // indirect golang.org/x/crypto v0.28.0 // indirect - golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c // indirect golang.org/x/mod v0.21.0 // indirect golang.org/x/net v0.30.0 // indirect golang.org/x/oauth2 v0.23.0 // indirect diff --git a/deployment/go.sum b/deployment/go.sum index 31f0f69e8e4..32d78868a01 100644 --- a/deployment/go.sum +++ b/deployment/go.sum @@ -850,8 +850,8 @@ github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHh github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= -github.com/hashicorp/go-plugin v1.6.2-0.20240829161738-06afb6d7ae99 h1:OSQYEsRT3tRttZkk6zyC3aAaliwd7Loi/KgXgXxGtwA= -github.com/hashicorp/go-plugin v1.6.2-0.20240829161738-06afb6d7ae99/go.mod h1:CkgLQ5CZqNmdL9U9JzM532t8ZiYQ35+pj3b1FD37R0Q= +github.com/hashicorp/go-plugin v1.6.2 h1:zdGAEd0V1lCaU0u+MxWQhtSDQmahpkwOun8U8EiRVog= +github.com/hashicorp/go-plugin v1.6.2/go.mod h1:CkgLQ5CZqNmdL9U9JzM532t8ZiYQ35+pj3b1FD37R0Q= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU= github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk= @@ -1384,8 +1384,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 h1:VfH/AW5NtTmroY9zz6OYCPFbFTqpMyJ2ubgT9ahYf3U= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241106142051-c7bded1c08ae h1:uqce0bjNVYzFrrVLafXgyn8SVNdfOtZekLfAwQihHiA= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241106142051-c7bded1c08ae/go.mod h1:TQ9/KKXZ9vr8QAlUquqGpSvDCpR+DtABKPXZY4CiRns= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 h1:e+uFsxQ21tMQKRu4oBXKycNzoR30vO/7STBtqtDvQJQ= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241018134907-a00ba3729b5e h1:JiETqdNM0bktAUGMc62COwXIaw3rR3M77Me6bBLG0Fg= @@ -1408,8 +1408,6 @@ github.com/smartcontractkit/chainlink-testing-framework/seth v1.50.5 h1:BxN9wddN github.com/smartcontractkit/chainlink-testing-framework/seth v1.50.5/go.mod h1:lJk0atEJ5Zyo3Tqrmf1Pl9jUEe79EgDb9bD3K5OTUBI= github.com/smartcontractkit/chainlink-testing-framework/wasp v1.50.2 h1:7bCdbTUWzyczQg+kwHCxlx6y07zE8HNB8+ntTne6qd8= github.com/smartcontractkit/chainlink-testing-framework/wasp v1.50.2/go.mod h1:MltlNu3jcXm/DyLN98I5TFNtu/o1NNAcaPAFKMXWk70= -github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a h1:JYuj6yaHF8uWh+/JY6v4Hpr5lPFERxHTQfHcwaw3IX8= -github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a/go.mod h1:6TEYffdCBW3R9psqrVWsjBVlAB4o4jhA8LuiRwW/8dU= github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7 h1:12ijqMM9tvYVEm+nR826WsrNi6zCKpwBhuApq127wHs= github.com/smartcontractkit/grpc-proxy v0.0.0-20240830132753-a7e17fec5ab7/go.mod h1:FX7/bVdoep147QQhsOPkYsPEXhGZjeYx6lBSaSXtZOA= github.com/smartcontractkit/libocr v0.0.0-20241007185508-adbe57025f12 h1:NzZGjaqez21I3DU7objl3xExTH4fxYvzTqar8DC6360= diff --git a/deployment/keystone/changeset/internal/test/utils.go b/deployment/keystone/changeset/internal/test/utils.go index f7ff6845254..cea20fd327d 100644 --- a/deployment/keystone/changeset/internal/test/utils.go +++ b/deployment/keystone/changeset/internal/test/utils.go @@ -109,7 +109,7 @@ func deployCapReg(t *testing.T, lggr logger.Logger, chain deployment.Chain) *kcr } func addNops(t *testing.T, lggr logger.Logger, chain deployment.Chain, registry *kcr.CapabilitiesRegistry, nops []kcr.CapabilitiesRegistryNodeOperator) *kslib.RegisterNOPSResponse { - resp, err := kslib.RegisterNOPS(context.TODO(), kslib.RegisterNOPSRequest{ + resp, err := kslib.RegisterNOPS(context.TODO(), lggr, kslib.RegisterNOPSRequest{ Chain: chain, Registry: registry, Nops: nops, diff --git a/deployment/keystone/deploy.go b/deployment/keystone/deploy.go index 8838312121a..9be1d3c21dd 100644 --- a/deployment/keystone/deploy.go +++ b/deployment/keystone/deploy.go @@ -196,7 +196,7 @@ func ConfigureRegistry(ctx context.Context, lggr logger.Logger, req ConfigureCon for _, nop := range nodeIdToNop { nops = append(nops, nop) } - nopsResp, err := RegisterNOPS(ctx, RegisterNOPSRequest{ + nopsResp, err := RegisterNOPS(ctx, lggr, RegisterNOPSRequest{ Chain: registryChain, Registry: registry, Nops: nops, @@ -231,7 +231,7 @@ func ConfigureRegistry(ctx context.Context, lggr logger.Logger, req ConfigureCon if err != nil { return nil, fmt.Errorf("failed to register DONS: %w", err) } - lggr.Infow("registered DONS", "dons", len(donsResp.donInfos)) + lggr.Infow("registered DONs", "dons", len(donsResp.donInfos)) return &ConfigureContractsResponse{ Changeset: &deployment.ChangesetOutput{ @@ -371,6 +371,7 @@ func registerCapabilities(lggr logger.Logger, req registerCapabilitiesRequest) ( if len(req.donToCapabilities) == 0 { return nil, fmt.Errorf("no capabilities to register") } + lggr.Infow("registering capabilities...", "len", len(req.donToCapabilities)) resp := ®isterCapabilitiesResponse{ donToCapabilities: make(map[string][]RegisteredCapability), } @@ -421,8 +422,37 @@ type RegisterNOPSResponse struct { Nops []*kcr.CapabilitiesRegistryNodeOperatorAdded } -func RegisterNOPS(ctx context.Context, req RegisterNOPSRequest) (*RegisterNOPSResponse, error) { - nops := req.Nops +func RegisterNOPS(ctx context.Context, lggr logger.Logger, req RegisterNOPSRequest) (*RegisterNOPSResponse, error) { + lggr.Infow("registering node operators...", "len", len(req.Nops)) + existingNops, err := req.Registry.GetNodeOperators(&bind.CallOpts{}) + if err != nil { + return nil, err + } + existingNopsAddrToID := make(map[capabilities_registry.CapabilitiesRegistryNodeOperator]uint32) + for id, nop := range existingNops { + existingNopsAddrToID[nop] = uint32(id) + } + lggr.Infow("fetched existing node operators", "len", len(existingNopsAddrToID)) + resp := &RegisterNOPSResponse{ + Nops: []*kcr.CapabilitiesRegistryNodeOperatorAdded{}, + } + nops := []kcr.CapabilitiesRegistryNodeOperator{} + for _, nop := range req.Nops { + if id, ok := existingNopsAddrToID[nop]; !ok { + nops = append(nops, nop) + } else { + lggr.Debugw("node operator already exists", "name", nop.Name, "admin", nop.Admin.String(), "id", id) + resp.Nops = append(resp.Nops, &kcr.CapabilitiesRegistryNodeOperatorAdded{ + NodeOperatorId: id, + Name: nop.Name, + Admin: nop.Admin, + }) + } + } + if len(nops) == 0 { + lggr.Debug("no new node operators to register") + return resp, nil + } tx, err := req.Registry.AddNodeOperators(req.Chain.DeployerKey, nops) if err != nil { err = DecodeErr(kcr.CapabilitiesRegistryABI, err) @@ -442,15 +472,12 @@ func RegisterNOPS(ctx context.Context, req RegisterNOPSRequest) (*RegisterNOPSRe if len(receipt.Logs) != len(nops) { return nil, fmt.Errorf("expected %d log entries for AddNodeOperators, got %d", len(nops), len(receipt.Logs)) } - resp := &RegisterNOPSResponse{ - Nops: make([]*kcr.CapabilitiesRegistryNodeOperatorAdded, len(receipt.Logs)), - } for i, log := range receipt.Logs { o, err := req.Registry.ParseNodeOperatorAdded(*log) if err != nil { return nil, fmt.Errorf("failed to parse log %d for operator added: %w", i, err) } - resp.Nops[i] = o + resp.Nops = append(resp.Nops, o) } return resp, nil @@ -531,6 +558,7 @@ type registerNodesResponse struct { // can sign the transactions update the contract state // TODO: 467 refactor to support MCMS. Specifically need to separate the call data generation from the actual contract call func registerNodes(lggr logger.Logger, req *registerNodesRequest) (*registerNodesResponse, error) { + lggr.Infow("registering nodes...", "len", len(req.nodeIdToNop)) nopToNodeIDs := make(map[kcr.CapabilitiesRegistryNodeOperator][]string) for nodeID, nop := range req.nodeIdToNop { if _, ok := nopToNodeIDs[nop]; !ok { @@ -623,7 +651,7 @@ func registerNodes(lggr logger.Logger, req *registerNodesRequest) (*registerNode if err != nil { err = DecodeErr(kcr.CapabilitiesRegistryABI, err) if strings.Contains(err.Error(), "NodeAlreadyExists") { - lggr.Warnw("node already exists, skipping", "p2pid", singleNodeParams.P2pId) + lggr.Warnw("node already exists, skipping", "p2pid", hex.EncodeToString(singleNodeParams.P2pId[:])) continue } return nil, fmt.Errorf("failed to call AddNode for node with p2pid %v: %w", singleNodeParams.P2pId, err) @@ -672,13 +700,22 @@ func sortedHash(p2pids [][32]byte) string { } func registerDons(lggr logger.Logger, req registerDonsRequest) (*registerDonsResponse, error) { - resp := registerDonsResponse{ - donInfos: make(map[string]kcr.CapabilitiesRegistryDONInfo), - } + lggr.Infow("registering DONs...", "len", len(req.donToOcr2Nodes)) // track hash of sorted p2pids to don name because the registry return value does not include the don name // and we need to map it back to the don name to access the other mapping data such as the don's capabilities & nodes p2pIdsToDon := make(map[string]string) - var registeredDons = 0 + var addedDons = 0 + + donInfos, err := req.registry.GetDONs(&bind.CallOpts{}) + if err != nil { + err = DecodeErr(kcr.CapabilitiesRegistryABI, err) + return nil, fmt.Errorf("failed to call GetDONs: %w", err) + } + existingDONs := make(map[string]struct{}) + for _, donInfo := range donInfos { + existingDONs[sortedHash(donInfo.NodeP2PIds)] = struct{}{} + } + lggr.Infow("fetched existing DONs...", "len", len(donInfos), "lenByNodesHash", len(existingDONs)) for don, ocr2nodes := range req.donToOcr2Nodes { var p2pIds [][32]byte @@ -695,6 +732,12 @@ func registerDons(lggr logger.Logger, req registerDonsRequest) (*registerDonsRes p2pSortedHash := sortedHash(p2pIds) p2pIdsToDon[p2pSortedHash] = don + + if _, ok := existingDONs[p2pSortedHash]; ok { + lggr.Debugw("don already exists, ignoring", "don", don, "p2p sorted hash", p2pSortedHash) + continue + } + caps, ok := req.donToCapabilities[don] if !ok { return nil, fmt.Errorf("capabilities not found for node operator %s", don) @@ -728,21 +771,21 @@ func registerDons(lggr logger.Logger, req registerDonsRequest) (*registerDonsRes return nil, fmt.Errorf("failed to confirm AddDON transaction %s for don %s: %w", tx.Hash().String(), don, err) } lggr.Debugw("registered DON", "don", don, "p2p sorted hash", p2pSortedHash, "cgs", cfgs, "wfSupported", wfSupported, "f", f) - registeredDons++ + addedDons++ } - lggr.Debugf("Registered all DONS %d, waiting for registry to update", registeredDons) + lggr.Debugf("Registered all DONs (new=%d), waiting for registry to update", addedDons) // occasionally the registry does not return the expected number of DONS immediately after the txns above // so we retry a few times. while crude, it is effective - var donInfos []capabilities_registry.CapabilitiesRegistryDONInfo - var err error + foundAll := false for i := 0; i < 10; i++ { - lggr.Debug("attempting to get DONS from registry", i) + lggr.Debugw("attempting to get DONs from registry", "attempt#", i) donInfos, err = req.registry.GetDONs(&bind.CallOpts{}) - if len(donInfos) != registeredDons { - lggr.Debugw("expected dons not registered", "expected", registeredDons, "got", len(donInfos)) + if !containsAllDONs(donInfos, p2pIdsToDon) { + lggr.Debugw("some expected dons not registered yet, re-checking after a delay ...") time.Sleep(2 * time.Second) } else { + foundAll = true break } } @@ -750,22 +793,37 @@ func registerDons(lggr logger.Logger, req registerDonsRequest) (*registerDonsRes err = DecodeErr(kcr.CapabilitiesRegistryABI, err) return nil, fmt.Errorf("failed to call GetDONs: %w", err) } + if !foundAll { + return nil, fmt.Errorf("did not find all desired DONS") + } + resp := registerDonsResponse{ + donInfos: make(map[string]kcr.CapabilitiesRegistryDONInfo), + } for i, donInfo := range donInfos { donName, ok := p2pIdsToDon[sortedHash(donInfo.NodeP2PIds)] if !ok { - return nil, fmt.Errorf("don not found for p2pids %s in %v", sortedHash(donInfo.NodeP2PIds), p2pIdsToDon) + lggr.Debugw("irrelevant DON found in the registry, ignoring", "p2p sorted hash", sortedHash(donInfo.NodeP2PIds)) + continue } - lggr.Debugw("adding don info", "don", donName, "cnt", i) + lggr.Debugw("adding don info to the reponse (keyed by DON name)", "don", donName) resp.donInfos[donName] = donInfos[i] } - lggr.Debugw("found registered DONs", "count", len(resp.donInfos)) - if len(resp.donInfos) != registeredDons { - return nil, fmt.Errorf("expected %d dons, got %d", registeredDons, len(resp.donInfos)) - } return &resp, nil } +// are all DONs from p2pIdsToDon in donInfos +func containsAllDONs(donInfos []kcr.CapabilitiesRegistryDONInfo, p2pIdsToDon map[string]string) bool { + found := make(map[string]struct{}) + for _, donInfo := range donInfos { + hash := sortedHash(donInfo.NodeP2PIds) + if _, ok := p2pIdsToDon[hash]; ok { + found[hash] = struct{}{} + } + } + return len(found) == len(p2pIdsToDon) +} + // configureForwarder sets the config for the forwarder contract on the chain for all Dons that accept workflows // dons that don't accept workflows are not registered with the forwarder func configureForwarder(lggr logger.Logger, chain deployment.Chain, fwdr *kf.KeystoneForwarder, dons []RegisteredDon) error { diff --git a/deployment/keystone/types.go b/deployment/keystone/types.go index 18967ccf445..e01ec6d0d55 100644 --- a/deployment/keystone/types.go +++ b/deployment/keystone/types.go @@ -210,15 +210,15 @@ type DonCapabilities struct { } // map the node id to the NOP -func (dc DonCapabilities) nodeIdToNop(cs uint64) (map[string]capabilities_registry.CapabilitiesRegistryNodeOperator, error) { +func (dc DonCapabilities) nopsByNodeID(chainSelector uint64) (map[string]capabilities_registry.CapabilitiesRegistryNodeOperator, error) { out := make(map[string]capabilities_registry.CapabilitiesRegistryNodeOperator) for _, nop := range dc.Nops { for _, node := range nop.Nodes { - a, err := AdminAddress(node, cs) + a, err := AdminAddress(node, chainSelector) if err != nil { return nil, fmt.Errorf("failed to get admin address for node %s: %w", node.ID, err) } - out[node.ID] = NodeOperator(dc.Name, a) + out[node.ID] = NodeOperator(nop.Name, a) } } @@ -251,7 +251,7 @@ func AdminAddress(n *models.Node, chainSel uint64) (string, error) { func nodesToNops(dons []DonCapabilities, chainSel uint64) (map[string]capabilities_registry.CapabilitiesRegistryNodeOperator, error) { out := make(map[string]capabilities_registry.CapabilitiesRegistryNodeOperator) for _, don := range dons { - nops, err := don.nodeIdToNop(chainSel) + nops, err := don.nopsByNodeID(chainSel) if err != nil { return nil, fmt.Errorf("failed to get registry NOPs for don %s: %w", don.Name, err) } diff --git a/fuzz/fuzz_all_native.py b/fuzz/fuzz_all_native.py index aa191fc5e8d..2d1cc4ccb29 100755 --- a/fuzz/fuzz_all_native.py +++ b/fuzz/fuzz_all_native.py @@ -6,6 +6,7 @@ import re import subprocess import sys +import time def main(): parser = argparse.ArgumentParser( @@ -22,35 +23,51 @@ def main(): # use float for remaining_seconds so we can represent infinity if args.seconds: - remaining_seconds = float(args.seconds) + total_time = float(args.seconds) else: - remaining_seconds = float("inf") + total_time = float("inf") + + start_time = time.time() + remaining_seconds = total_time fuzzers = discover_fuzzers(args.go_module_root) - print(f"🐝 Discovered fuzzers:", file=sys.stderr) + num_fuzzers = len(fuzzers) + print(f"🐝 Discovered {num_fuzzers} fuzzers:", file=sys.stderr) for fuzzfn, path in fuzzers.items(): print(f"{fuzzfn} in {path}", file=sys.stderr) + if num_fuzzers == 0: + print(f"No fuzzers found, this is likely an error. Exiting.") + exit(1) + + # run forever or until --seconds, with increasingly longer durations per fuzz run + durations_seconds = itertools.chain([5, 10, 30, 90, 270], itertools.repeat(600)) if args.ci: - # only run each fuzzer once for 60 seconds in CI - durations_seconds = [60] - else: - # run forever or until --seconds, with increasingly longer durations per fuzz run - durations_seconds = itertools.chain([5, 10, 30, 90, 270], itertools.repeat(600)) + # In CI - default to 60s fuzzes for scheduled runs, and 45 seconds for everything else + durations_seconds = [60] if os.getenv('GITHUB_EVENT_NAME') == 'scheduled' else [45] + if args.seconds: + # However, if seconds was specified, evenly divide total time among all fuzzers + # leaving a 10 second buffer for processing/building time between fuzz runs + actual_fuzz_time = total_time - (num_fuzzers * 10) + if actual_fuzz_time <= 5 * num_fuzzers: + print(f"Seconds (--seconds {arg.seconds}) is too low to properly run fuzzers for 5sec each. Exiting.") + exit(1) + durations_seconds = [ actual_fuzz_time / num_fuzzers ] for duration_seconds in durations_seconds: print(f"🐝 Running each fuzzer for {duration_seconds}s before switching to next fuzzer", file=sys.stderr) for fuzzfn, path in fuzzers.items(): + elapsed_time = time.time() - start_time + remaining_seconds = total_time - elapsed_time + if remaining_seconds <= 0: print(f"🐝 Time budget of {args.seconds}s is exhausted. Exiting.", file=sys.stderr) return next_duration_seconds = min(remaining_seconds, duration_seconds) - remaining_seconds -= next_duration_seconds - - print(f"🐝 Running {fuzzfn} in {path} for {next_duration_seconds}s before switching to next fuzzer", file=sys.stderr) + print(f"🐝 Running {fuzzfn} in {path} for {next_duration_seconds}s (Elapsed: {elapsed_time:.2f}s, Remaining: {remaining_seconds:.2f}s)", file=sys.stderr) run_fuzzer(fuzzfn, path, next_duration_seconds, args.go_module_root) - print(f"🐝 Completed running {fuzzfn} in {path} for {next_duration_seconds}s. Total remaining time is {remaining_seconds}s", file=sys.stderr) + print(f"🐝 Completed running {fuzzfn} in {path} for {next_duration_seconds}s.", file=sys.stderr) def discover_fuzzers(go_module_root): fuzzers = {} diff --git a/go.mod b/go.mod index c1d12475461..ca0250d2917 100644 --- a/go.mod +++ b/go.mod @@ -77,7 +77,7 @@ require ( github.com/smartcontractkit/chain-selectors v1.0.27 github.com/smartcontractkit/chainlink-automation v0.8.1 github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241018134907-a00ba3729b5e github.com/smartcontractkit/chainlink-feeds v0.1.1 diff --git a/go.sum b/go.sum index ad233fa5104..db766c87c1a 100644 --- a/go.sum +++ b/go.sum @@ -1077,8 +1077,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 h1:VfH/AW5NtTmroY9zz6OYCPFbFTqpMyJ2ubgT9ahYf3U= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff h1:Dduou3xzY4bVJPE9yIFW+Zfqrw7QG7ePPfauO+KY508= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 h1:e+uFsxQ21tMQKRu4oBXKycNzoR30vO/7STBtqtDvQJQ= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241018134907-a00ba3729b5e h1:JiETqdNM0bktAUGMc62COwXIaw3rR3M77Me6bBLG0Fg= diff --git a/integration-tests/ccip-tests/testsetups/test_helpers.go b/integration-tests/ccip-tests/testsetups/test_helpers.go index 4a63d109992..4de5d0988a2 100644 --- a/integration-tests/ccip-tests/testsetups/test_helpers.go +++ b/integration-tests/ccip-tests/testsetups/test_helpers.go @@ -95,11 +95,22 @@ func NewLocalDevEnvironment(t *testing.T, lggr logger.Logger) (ccipdeployment.De crConfig, testEnv, cfg) require.NoError(t, err) - e, don, err := devenv.NewEnvironment(ctx, lggr, *envConfig) require.NoError(t, err) require.NotNil(t, e) e.ExistingAddresses = ab + + envNodes, err := deployment.NodeInfo(e.NodeIDs, e.Offchain) + require.NoError(t, err) + _, err = ccipdeployment.DeployHomeChain(lggr, *e, e.ExistingAddresses, chains[homeChainSel], + ccipdeployment.NewTestRMNStaticConfig(), + ccipdeployment.NewTestRMNDynamicConfig(), + ccipdeployment.NewTestNodeOperator(chains[homeChainSel].DeployerKey.From), + map[string][][32]byte{ + "NodeOperator": envNodes.NonBootstraps().PeerIDs(), + }, + ) + require.NoError(t, err) zeroLogLggr := logging.GetTestLogger(t) // fund the nodes FundNodes(t, zeroLogLggr, testEnv, cfg, don.PluginNodes()) diff --git a/integration-tests/go.mod b/integration-tests/go.mod index 0e0c8e850d0..7bf5a0e1c36 100644 --- a/integration-tests/go.mod +++ b/integration-tests/go.mod @@ -37,7 +37,7 @@ require ( github.com/smartcontractkit/chain-selectors v1.0.27 github.com/smartcontractkit/chainlink-automation v0.8.1 github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 github.com/smartcontractkit/chainlink-protos/job-distributor v0.4.0 github.com/smartcontractkit/chainlink-testing-framework/havoc v1.50.2 github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.13 @@ -45,7 +45,7 @@ require ( github.com/smartcontractkit/chainlink-testing-framework/seth v1.50.5 github.com/smartcontractkit/chainlink-testing-framework/wasp v1.50.2 github.com/smartcontractkit/chainlink/deployment v0.0.0-00010101000000-000000000000 - github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a + github.com/smartcontractkit/chainlink/v2 v2.0.0-00010101000000-000000000000 github.com/smartcontractkit/libocr v0.0.0-20241007185508-adbe57025f12 github.com/spf13/cobra v1.8.1 github.com/stretchr/testify v1.9.0 diff --git a/integration-tests/go.sum b/integration-tests/go.sum index f4d528be2dd..a1f42b16aea 100644 --- a/integration-tests/go.sum +++ b/integration-tests/go.sum @@ -1405,8 +1405,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 h1:VfH/AW5NtTmroY9zz6OYCPFbFTqpMyJ2ubgT9ahYf3U= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff h1:Dduou3xzY4bVJPE9yIFW+Zfqrw7QG7ePPfauO+KY508= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 h1:e+uFsxQ21tMQKRu4oBXKycNzoR30vO/7STBtqtDvQJQ= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241018134907-a00ba3729b5e h1:JiETqdNM0bktAUGMc62COwXIaw3rR3M77Me6bBLG0Fg= diff --git a/integration-tests/load/go.mod b/integration-tests/load/go.mod index c3066aee602..441c6eaa4e1 100644 --- a/integration-tests/load/go.mod +++ b/integration-tests/load/go.mod @@ -17,13 +17,13 @@ require ( github.com/pkg/errors v0.9.1 github.com/rs/zerolog v1.33.0 github.com/slack-go/slack v0.15.0 - github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff + github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 github.com/smartcontractkit/chainlink-testing-framework/lib v1.50.13 github.com/smartcontractkit/chainlink-testing-framework/seth v1.50.5 github.com/smartcontractkit/chainlink-testing-framework/wasp v1.50.2 github.com/smartcontractkit/chainlink/deployment v0.0.0-00010101000000-000000000000 github.com/smartcontractkit/chainlink/integration-tests v0.0.0-20241030133659-9ec788e78b4f - github.com/smartcontractkit/chainlink/v2 v2.14.0-mercury-20240807.0.20241106193309-5560cd76211a + github.com/smartcontractkit/chainlink/v2 v2.9.0-beta0.0.20240216210048-da02459ddad8 github.com/smartcontractkit/tdh2/go/tdh2 v0.0.0-20241009055228-33d0c0bf38de github.com/stretchr/testify v1.9.0 github.com/wiremock/go-wiremock v1.9.0 diff --git a/integration-tests/load/go.sum b/integration-tests/load/go.sum index 5cdd3f0c7b9..a2c8cc52ba4 100644 --- a/integration-tests/load/go.sum +++ b/integration-tests/load/go.sum @@ -1394,8 +1394,8 @@ github.com/smartcontractkit/chainlink-automation v0.8.1 h1:sTc9LKpBvcKPc1JDYAmgB github.com/smartcontractkit/chainlink-automation v0.8.1/go.mod h1:Iij36PvWZ6blrdC5A/nrQUBuf3MH3JvsBB9sSyc9W08= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422 h1:VfH/AW5NtTmroY9zz6OYCPFbFTqpMyJ2ubgT9ahYf3U= github.com/smartcontractkit/chainlink-ccip v0.0.0-20241106140121-4c9ee21ab422/go.mod h1:4adKaHNaxFsRvV/lYfqtbsWyyvIPUMLR0FdOJN/ljis= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff h1:Dduou3xzY4bVJPE9yIFW+Zfqrw7QG7ePPfauO+KY508= -github.com/smartcontractkit/chainlink-common v0.3.1-0.20241108143808-44ef01dbdeff/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4 h1:e+uFsxQ21tMQKRu4oBXKycNzoR30vO/7STBtqtDvQJQ= +github.com/smartcontractkit/chainlink-common v0.3.1-0.20241109002240-af894848b3b4/go.mod h1:ny87uTW6hLjCTLiBqBRNFEhETSXhHWevYlPclT5lSco= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f h1:BwrIaQIx5Iy6eT+DfLhFfK2XqjxRm74mVdlX8gbu4dw= github.com/smartcontractkit/chainlink-cosmos v0.5.2-0.20241017133723-5277829bd53f/go.mod h1:wHtwSR3F1CQSJJZDQKuqaqFYnvkT+kMyget7dl8Clvo= github.com/smartcontractkit/chainlink-data-streams v0.1.1-0.20241018134907-a00ba3729b5e h1:JiETqdNM0bktAUGMc62COwXIaw3rR3M77Me6bBLG0Fg= diff --git a/plugins/loop_registry.go b/plugins/loop_registry.go index 732e2bfe372..82ef219566a 100644 --- a/plugins/loop_registry.go +++ b/plugins/loop_registry.go @@ -27,17 +27,21 @@ type LoopRegistry struct { mu sync.Mutex registry map[string]*RegisteredLoop - lggr logger.Logger - cfgTracing config.Tracing - cfgTelemetry config.Telemetry + lggr logger.Logger + cfgTracing config.Tracing + cfgTelemetry config.Telemetry + telemetryAuthHeaders map[string]string + telemetryAuthPubKeyHex string } -func NewLoopRegistry(lggr logger.Logger, tracing config.Tracing, telemetry config.Telemetry) *LoopRegistry { +func NewLoopRegistry(lggr logger.Logger, tracing config.Tracing, telemetry config.Telemetry, telemetryAuthHeaders map[string]string, telemetryAuthPubKeyHex string) *LoopRegistry { return &LoopRegistry{ - registry: map[string]*RegisteredLoop{}, - lggr: logger.Named(lggr, "LoopRegistry"), - cfgTracing: tracing, - cfgTelemetry: telemetry, + registry: map[string]*RegisteredLoop{}, + lggr: logger.Named(lggr, "LoopRegistry"), + cfgTracing: tracing, + cfgTelemetry: telemetry, + telemetryAuthHeaders: telemetryAuthHeaders, + telemetryAuthPubKeyHex: telemetryAuthPubKeyHex, } } @@ -74,13 +78,18 @@ func (m *LoopRegistry) Register(id string) (*RegisteredLoop, error) { envCfg.TelemetryCACertFile = m.cfgTelemetry.CACertFile() envCfg.TelemetryAttributes = m.cfgTelemetry.ResourceAttributes() envCfg.TelemetryTraceSampleRatio = m.cfgTelemetry.TraceSampleRatio() - // TODO: Implement these - // envCfg.TelemetryBatchProcessor = m.cfgTelemetry.EmitterBatchProcessor() - // envCfg.TelemetryExportTimeout = m.cfgTelemetry.EmitterExportTimeout() + envCfg.TelemetryEmitterBatchProcessor = m.cfgTelemetry.EmitterBatchProcessor() + envCfg.TelemetryEmitterExportTimeout = m.cfgTelemetry.EmitterExportTimeout() + envCfg.TelemetryAuthPubKeyHex = m.telemetryAuthPubKeyHex + } + m.lggr.Debugf("Registered loopp %q with config %v, port %d", id, envCfg, envCfg.PrometheusPort) + + // Add auth header after logging config + if m.cfgTelemetry != nil { + envCfg.TelemetryAuthHeaders = m.telemetryAuthHeaders } m.registry[id] = &RegisteredLoop{Name: id, EnvCfg: envCfg} - m.lggr.Debugf("Registered loopp %q with config %v, port %d", id, envCfg, envCfg.PrometheusPort) return m.registry[id], nil } diff --git a/plugins/loop_registry_test.go b/plugins/loop_registry_test.go index 643e4005418..e9d7b752147 100644 --- a/plugins/loop_registry_test.go +++ b/plugins/loop_registry_test.go @@ -12,7 +12,7 @@ import ( func TestPluginPortManager(t *testing.T) { // register one - m := NewLoopRegistry(logger.TestLogger(t), nil, nil) + m := NewLoopRegistry(logger.TestLogger(t), nil, nil, nil, "") pFoo, err := m.Register("foo") require.NoError(t, err) require.Equal(t, "foo", pFoo.Name) @@ -56,9 +56,9 @@ func (m mockCfgTelemetry) ResourceAttributes() map[string]string { func (m mockCfgTelemetry) TraceSampleRatio() float64 { return 0.42 } -func (m mockCfgTelemetry) EmitterBatchProcessor() bool { return false } +func (m mockCfgTelemetry) EmitterBatchProcessor() bool { return true } -func (m mockCfgTelemetry) EmitterExportTimeout() time.Duration { return 0 } +func (m mockCfgTelemetry) EmitterExportTimeout() time.Duration { return 1 * time.Second } func TestLoopRegistry_Register(t *testing.T) { mockCfgTracing := &mockCfgTracing{} @@ -91,7 +91,6 @@ func TestLoopRegistry_Register(t *testing.T) { require.Equal(t, "http://localhost:9001", envCfg.TelemetryEndpoint) require.Equal(t, loop.OtelAttributes{"foo": "bar"}, envCfg.TelemetryAttributes) require.Equal(t, 0.42, envCfg.TelemetryTraceSampleRatio) - // TODO: EmitterBatchProcessor and EmitterExportTimeout to envCfg - // require.False(t, true, envCfg.EmitterBatchProcessor) - // require.Equal(t, 1*time.Second, envCfg.EmitterExportTimeout) + require.Equal(t, true, envCfg.TelemetryEmitterBatchProcessor) + require.Equal(t, 1*time.Second, envCfg.TelemetryEmitterExportTimeout) } diff --git a/tools/bin/go_core_fuzz b/tools/bin/go_core_fuzz index eb0334fe7ca..49aaf33b65e 100755 --- a/tools/bin/go_core_fuzz +++ b/tools/bin/go_core_fuzz @@ -4,14 +4,22 @@ set +e SCRIPT_PATH=`dirname "$0"`; SCRIPT_PATH=`eval "cd \"$SCRIPT_PATH\" && pwd"` OUTPUT_FILE=${OUTPUT_FILE:-"./output.txt"} -FUZZ_TIMEOUT=${FUZZ_TIMEOUT:-10m} +FUZZ_TIMEOUT_MINUTES=${FUZZ_TIMEOUT_MINUTES:-"3"} +TOTAL_SECONDS=$((FUZZ_TIMEOUT_MINUTES * 60)) +if (( TOTAL_SECONDS >= 120 )); then + # Allow for a 30 second buffer between the timeout, and fuzz test runtime + FUZZ_SECONDS=$((TOTAL_SECONDS - 30)) +else + echo "Increase FUZZ_TIMEOUT_MINUTES to >=2, received $FUZZ_TIMEOUT_MINUTES" + exit 1 +fi + +echo "timeout minutes: $FUZZ_TIMEOUT_MINUTES" +echo "fuzz seconds: $FUZZ_SECONDS" echo "Failed fuzz tests and panics: ---------------------" echo "" -# the amount of --seconds here is subject to change based on how long the CI job takes in the future -# as we add more fuzz tests, we should take into consideration increasing this timelapse, so we can have enough coverage. -# We are timing out after ~10mins in case the tests hang. (Current CI duration is ~8m, modify if needed) -timeout "${FUZZ_TIMEOUT}" ./fuzz/fuzz_all_native.py --ci --seconds 420 --go_module_root ./ | tee $OUTPUT_FILE +timeout "${FUZZ_TIMEOUT_MINUTES}"m ./fuzz/fuzz_all_native.py --ci --seconds "$FUZZ_SECONDS" --go_module_root ./ | tee $OUTPUT_FILE EXITCODE=${PIPESTATUS[0]} # Assert no known sensitive strings present in test logger output diff --git a/tools/bin/go_core_race_tests b/tools/bin/go_core_race_tests index d09a8d903e4..2c4071bc20f 100755 --- a/tools/bin/go_core_race_tests +++ b/tools/bin/go_core_race_tests @@ -1,8 +1,8 @@ #!/usr/bin/env bash set -ex OUTPUT_FILE=${OUTPUT_FILE:-"./output.txt"} -TIMEOUT="${TIMEOUT:-30s}" -COUNT="${COUNT:-10}" +TIMEOUT="${TIMEOUT:-10s}" +COUNT="${COUNT:-5}" echo "Failed tests and panics: ---------------------" echo "" @@ -10,13 +10,13 @@ if [[ $GITHUB_EVENT_NAME == "schedule" ]]; then if [[ $DEBUG == "true" ]]; then GORACE="log_path=$PWD/race" go test -json -vet=off -race -shuffle on -timeout "$TIMEOUT" -count "$COUNT" $1 | tee $OUTPUT_FILE else - GORACE="log_path=$PWD/race" go test -json -vet=off -race -shuffle on -timeout "$TIMEOUT" -count "$COUNT" $1 | cat > $OUTPUT_FILE + GORACE="log_path=$PWD/race" go test -vet=off -race -shuffle on -timeout "$TIMEOUT" -count "$COUNT" $1 | cat > $OUTPUT_FILE fi else if [[ $DEBUG == "true" ]]; then GORACE="log_path=$PWD/race" go test -json -vet=off -race -shuffle on -timeout "$TIMEOUT" -count "$COUNT" $1 | tee $OUTPUT_FILE else - GORACE="log_path=$PWD/race" go test -json -vet=off -race -shuffle on -timeout "$TIMEOUT" -count "$COUNT" $1 | cat > $OUTPUT_FILE + GORACE="log_path=$PWD/race" go test -vet=off -race -shuffle on -timeout "$TIMEOUT" -count "$COUNT" $1 | cat > $OUTPUT_FILE fi fi EXITCODE=${PIPESTATUS[0]}