From 96676e18afa9cc8b8c5e7c6884f5f32e7e37ada4 Mon Sep 17 00:00:00 2001 From: Geoff Franks Date: Fri, 17 Oct 2025 20:35:07 +0000 Subject: [PATCH] Suppresses heartbeat related start-actual-lrp log messages to save log volume Adds configuration to allow this feature to be enabled/disabled --- cmd/bbs/config/config.go | 1 + cmd/bbs/config/config_test.go | 2 + cmd/bbs/lrp_convergence_test.go | 2 + cmd/bbs/main.go | 1 + .../actual_lrp_lifecycle_controller.go | 4 +- .../actual_lrp_lifecycle_controller_test.go | 24 +++- db/actual_lrp_db.go | 1 + db/dbfakes/fake_actual_lrpdb.go | 54 +++---- db/dbfakes/fake_db.go | 54 +++---- db/dbfakes/fake_lrpdb.go | 54 +++---- db/sqldb/actual_lrp_db.go | 10 +- db/sqldb/actual_lrp_db_test.go | 132 ++++++++++++++---- db/sqldb/encryption_db_test.go | 8 +- db/sqldb/evacuation_db_test.go | 2 +- db/sqldb/fakesqldriver/deadlocks_test.go | 2 +- .../fakesqldriver/fakesqldriver_suite_test.go | 2 +- db/sqldb/lrp_convergence_test.go | 40 +++--- db/sqldb/sqldb.go | 47 ++++--- db/sqldb/sqldb_suite_test.go | 4 +- db/sqldb/suspect_db_test.go | 6 +- db/sqldb/version_db_test.go | 2 +- handlers/context_test.go | 1 + 22 files changed, 287 insertions(+), 166 deletions(-) diff --git a/cmd/bbs/config/config.go b/cmd/bbs/config/config.go index aeecf342..7a7447d6 100644 --- a/cmd/bbs/config/config.go +++ b/cmd/bbs/config/config.go @@ -38,6 +38,7 @@ type BBSConfig struct { ConvergenceWorkers int `json:"convergence_workers,omitempty"` DatabaseConnectionString string `json:"database_connection_string"` DatabaseDriver string `json:"database_driver,omitempty"` + DebugLRPStartHeartbeats bool `json:"debug_lrp_start_heartbeats,omitempty"` DesiredLRPCreationTimeout durationjson.Duration `json:"desired_lrp_creation_timeout,omitempty"` ExpireCompletedTaskDuration durationjson.Duration `json:"expire_completed_task_duration,omitempty"` ExpirePendingTaskDuration durationjson.Duration `json:"expire_pending_task_duration,omitempty"` diff --git a/cmd/bbs/config/config_test.go b/cmd/bbs/config/config_test.go index 2daec09b..ae9dedf6 100644 --- a/cmd/bbs/config/config_test.go +++ b/cmd/bbs/config/config_test.go @@ -40,6 +40,7 @@ var _ = Describe("BBSConfig", func() { "database_connection_string": "", "database_driver": "postgres", "debug_address": "127.0.0.1:17017", + "debug_lrp_start_heartbeats":true, "desired_lrp_creation_timeout": "1m0s", "encryption_keys": {"label": "key"}, "expire_completed_task_duration": "2m0s", @@ -137,6 +138,7 @@ var _ = Describe("BBSConfig", func() { DebugServerConfig: debugserver.DebugServerConfig{ DebugAddress: "127.0.0.1:17017", }, + DebugLRPStartHeartbeats: true, DesiredLRPCreationTimeout: durationjson.Duration(1 * time.Minute), EncryptionConfig: encryption.EncryptionConfig{ ActiveKeyLabel: "label", diff --git a/cmd/bbs/lrp_convergence_test.go b/cmd/bbs/lrp_convergence_test.go index e4f87dbf..523f9ece 100644 --- a/cmd/bbs/lrp_convergence_test.go +++ b/cmd/bbs/lrp_convergence_test.go @@ -111,6 +111,7 @@ var _ = Describe("Convergence API", func() { clock.NewClock(), sqlRunner.DriverName(), metronClient, + false, ) Eventually(func() models.ActualLRP_Presence { @@ -176,6 +177,7 @@ var _ = Describe("Convergence API", func() { map[string]string{}, false, "", + false, ) Expect(err).NotTo(HaveOccurred()) }) diff --git a/cmd/bbs/main.go b/cmd/bbs/main.go index f11d7277..f88a57ea 100644 --- a/cmd/bbs/main.go +++ b/cmd/bbs/main.go @@ -137,6 +137,7 @@ func main() { clock, bbsConfig.DatabaseDriver, metronClient, + bbsConfig.DebugLRPStartHeartbeats, ) err = sqlDB.CreateConfigurationsTable(context.Background(), logger) if err != nil { diff --git a/controllers/actual_lrp_lifecycle_controller.go b/controllers/actual_lrp_lifecycle_controller.go index a5d4e059..731a2a71 100644 --- a/controllers/actual_lrp_lifecycle_controller.go +++ b/controllers/actual_lrp_lifecycle_controller.go @@ -132,9 +132,11 @@ func (h *ActualLRPLifecycleController) StartActualLRP(ctx context.Context, return nil } + isCurrentlyRunning := lrp != nil && lrp.State == models.ActualLRPStateRunning + // creates ordinary running actual LRP if it doesn't exist, otherwise updates // the existing ordinary actual LRP to running state - before, after, err := h.db.StartActualLRP(ctx, logger, actualLRPKey, actualLRPInstanceKey, actualLRPNetInfo, actualLRPInternalRoutes, actualLRPMetricTags, routable, availabilityZone) + before, after, err := h.db.StartActualLRP(ctx, logger, actualLRPKey, actualLRPInstanceKey, actualLRPNetInfo, actualLRPInternalRoutes, actualLRPMetricTags, routable, availabilityZone, isCurrentlyRunning) if err != nil { return err } diff --git a/controllers/actual_lrp_lifecycle_controller_test.go b/controllers/actual_lrp_lifecycle_controller_test.go index 4b592a5c..b49e2dde 100644 --- a/controllers/actual_lrp_lifecycle_controller_test.go +++ b/controllers/actual_lrp_lifecycle_controller_test.go @@ -421,7 +421,7 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() { Expect(fakeActualLRPDB.StartActualLRPCallCount()).To(Equal(1)) Expect(fakeActualLRPDB.ActualLRPsCallCount()).To(Equal(1)) - _, _, _, _, _, internalRoutesArgument, metricTagsArgument, routableArgument, availabilityZoneArgument := fakeActualLRPDB.StartActualLRPArgsForCall(0) + _, _, _, _, _, internalRoutesArgument, metricTagsArgument, routableArgument, availabilityZoneArgument, _ := fakeActualLRPDB.StartActualLRPArgsForCall(0) Expect(err).NotTo(HaveOccurred()) Expect(internalRoutesArgument).To(Equal(internalRoutes)) @@ -532,11 +532,23 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() { createdEvent := event.(*models.ActualLRPInstanceCreatedEvent) Expect(createdEvent.ActualLrp).To(Equal(afterActualLRP)) }) + It("tells the db that a previous instance didn't exist", func() { + err = controller.StartActualLRP(ctx, logger, &actualLRPKey, &afterInstanceKey, &netInfo, internalRoutes, metricTags, routable, availabilityZone) + Expect(err).NotTo(HaveOccurred()) + + Expect(fakeActualLRPDB.StartActualLRPCallCount()).To(Equal(1)) + _, _, _, _, _, _, _, _, _, isRunning := fakeActualLRPDB.StartActualLRPArgsForCall(0) + Expect(isRunning).To(BeFalse()) + }) }) Context("when the actual lrp was updated", func() { + JustBeforeEach(func() { + actualLRP.State = models.ActualLRPStateRunning + fakeActualLRPDB.ActualLRPsReturns([]*models.ActualLRP{actualLRP}, nil) + }) It("emits a change event to the hub", func() { - err = controller.StartActualLRP(ctx, logger, &actualLRPKey, &afterInstanceKey, &netInfo, internalRoutes, metricTags, routable, availabilityZone) + err = controller.StartActualLRP(ctx, logger, &actualLRPKey, &beforeInstanceKey, &netInfo, internalRoutes, metricTags, routable, availabilityZone) Eventually(actualHub.EmitCallCount).Should(Equal(1)) event := actualHub.EmitArgsForCall(0) //lint:ignore SA1019 - calling deprecated model while unit testing deprecated method @@ -547,6 +559,14 @@ var _ = Describe("ActualLRP Lifecycle Controller", func() { //lint:ignore SA1019 - still need to emit these events until the ActaulLRPGroup api is deleted Expect(changedEvent.After).To(Equal(afterActualLRP.ToActualLRPGroup())) }) + It("tells the db that a previous instance exists", func() { + err = controller.StartActualLRP(ctx, logger, &actualLRPKey, &afterInstanceKey, &netInfo, internalRoutes, metricTags, routable, availabilityZone) + Expect(err).NotTo(HaveOccurred()) + + Expect(fakeActualLRPDB.StartActualLRPCallCount()).To(Equal(1)) + _, _, _, _, _, _, _, _, _, isRunning := fakeActualLRPDB.StartActualLRPArgsForCall(0) + Expect(isRunning).To(BeTrue()) + }) }) Context("when Routable was updated", func() { diff --git a/db/actual_lrp_db.go b/db/actual_lrp_db.go index f2ef593c..60ecd51a 100644 --- a/db/actual_lrp_db.go +++ b/db/actual_lrp_db.go @@ -24,6 +24,7 @@ type ActualLRPDB interface { metricTags map[string]string, routable bool, availabilityZone string, + isCurrentlyRunning bool, ) (before *models.ActualLRP, after *models.ActualLRP, err error) CrashActualLRP(ctx context.Context, logger lager.Logger, key *models.ActualLRPKey, instanceKey *models.ActualLRPInstanceKey, crashReason string) (before *models.ActualLRP, after *models.ActualLRP, shouldRestart bool, err error) FailActualLRP(ctx context.Context, logger lager.Logger, key *models.ActualLRPKey, placementError string) (before *models.ActualLRP, after *models.ActualLRP, err error) diff --git a/db/dbfakes/fake_actual_lrpdb.go b/db/dbfakes/fake_actual_lrpdb.go index 915f8434..a0b8e7e0 100644 --- a/db/dbfakes/fake_actual_lrpdb.go +++ b/db/dbfakes/fake_actual_lrpdb.go @@ -180,18 +180,19 @@ type FakeActualLRPDB struct { removeActualLRPReturnsOnCall map[int]struct { result1 error } - StartActualLRPStub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) (*models.ActualLRP, *models.ActualLRP, error) + StartActualLRPStub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) (*models.ActualLRP, *models.ActualLRP, error) startActualLRPMutex sync.RWMutex startActualLRPArgsForCall []struct { - arg1 context.Context - arg2 lager.Logger - arg3 *models.ActualLRPKey - arg4 *models.ActualLRPInstanceKey - arg5 *models.ActualLRPNetInfo - arg6 []*models.ActualLRPInternalRoute - arg7 map[string]string - arg8 bool - arg9 string + arg1 context.Context + arg2 lager.Logger + arg3 *models.ActualLRPKey + arg4 *models.ActualLRPInstanceKey + arg5 *models.ActualLRPNetInfo + arg6 []*models.ActualLRPInternalRoute + arg7 map[string]string + arg8 bool + arg9 string + arg10 bool } startActualLRPReturns struct { result1 *models.ActualLRP @@ -909,7 +910,7 @@ func (fake *FakeActualLRPDB) RemoveActualLRPReturnsOnCall(i int, result1 error) }{result1} } -func (fake *FakeActualLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute, arg7 map[string]string, arg8 bool, arg9 string) (*models.ActualLRP, *models.ActualLRP, error) { +func (fake *FakeActualLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute, arg7 map[string]string, arg8 bool, arg9 string, arg10 bool) (*models.ActualLRP, *models.ActualLRP, error) { var arg6Copy []*models.ActualLRPInternalRoute if arg6 != nil { arg6Copy = make([]*models.ActualLRPInternalRoute, len(arg6)) @@ -918,22 +919,23 @@ func (fake *FakeActualLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Log fake.startActualLRPMutex.Lock() ret, specificReturn := fake.startActualLRPReturnsOnCall[len(fake.startActualLRPArgsForCall)] fake.startActualLRPArgsForCall = append(fake.startActualLRPArgsForCall, struct { - arg1 context.Context - arg2 lager.Logger - arg3 *models.ActualLRPKey - arg4 *models.ActualLRPInstanceKey - arg5 *models.ActualLRPNetInfo - arg6 []*models.ActualLRPInternalRoute - arg7 map[string]string - arg8 bool - arg9 string - }{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9}) + arg1 context.Context + arg2 lager.Logger + arg3 *models.ActualLRPKey + arg4 *models.ActualLRPInstanceKey + arg5 *models.ActualLRPNetInfo + arg6 []*models.ActualLRPInternalRoute + arg7 map[string]string + arg8 bool + arg9 string + arg10 bool + }{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9, arg10}) stub := fake.StartActualLRPStub fakeReturns := fake.startActualLRPReturns - fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9}) + fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9, arg10}) fake.startActualLRPMutex.Unlock() if stub != nil { - return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) } if specificReturn { return ret.result1, ret.result2, ret.result3 @@ -947,17 +949,17 @@ func (fake *FakeActualLRPDB) StartActualLRPCallCount() int { return len(fake.startActualLRPArgsForCall) } -func (fake *FakeActualLRPDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) (*models.ActualLRP, *models.ActualLRP, error)) { +func (fake *FakeActualLRPDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) (*models.ActualLRP, *models.ActualLRP, error)) { fake.startActualLRPMutex.Lock() defer fake.startActualLRPMutex.Unlock() fake.StartActualLRPStub = stub } -func (fake *FakeActualLRPDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) { +func (fake *FakeActualLRPDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) { fake.startActualLRPMutex.RLock() defer fake.startActualLRPMutex.RUnlock() argsForCall := fake.startActualLRPArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9, argsForCall.arg10 } func (fake *FakeActualLRPDB) StartActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) { diff --git a/db/dbfakes/fake_db.go b/db/dbfakes/fake_db.go index 8119b469..1e626f2a 100644 --- a/db/dbfakes/fake_db.go +++ b/db/dbfakes/fake_db.go @@ -574,18 +574,19 @@ type FakeDB struct { setVersionReturnsOnCall map[int]struct { result1 error } - StartActualLRPStub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) (*models.ActualLRP, *models.ActualLRP, error) + StartActualLRPStub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) (*models.ActualLRP, *models.ActualLRP, error) startActualLRPMutex sync.RWMutex startActualLRPArgsForCall []struct { - arg1 context.Context - arg2 lager.Logger - arg3 *models.ActualLRPKey - arg4 *models.ActualLRPInstanceKey - arg5 *models.ActualLRPNetInfo - arg6 []*models.ActualLRPInternalRoute - arg7 map[string]string - arg8 bool - arg9 string + arg1 context.Context + arg2 lager.Logger + arg3 *models.ActualLRPKey + arg4 *models.ActualLRPInstanceKey + arg5 *models.ActualLRPNetInfo + arg6 []*models.ActualLRPInternalRoute + arg7 map[string]string + arg8 bool + arg9 string + arg10 bool } startActualLRPReturns struct { result1 *models.ActualLRP @@ -3070,7 +3071,7 @@ func (fake *FakeDB) SetVersionReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute, arg7 map[string]string, arg8 bool, arg9 string) (*models.ActualLRP, *models.ActualLRP, error) { +func (fake *FakeDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute, arg7 map[string]string, arg8 bool, arg9 string, arg10 bool) (*models.ActualLRP, *models.ActualLRP, error) { var arg6Copy []*models.ActualLRPInternalRoute if arg6 != nil { arg6Copy = make([]*models.ActualLRPInternalRoute, len(arg6)) @@ -3079,22 +3080,23 @@ func (fake *FakeDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 fake.startActualLRPMutex.Lock() ret, specificReturn := fake.startActualLRPReturnsOnCall[len(fake.startActualLRPArgsForCall)] fake.startActualLRPArgsForCall = append(fake.startActualLRPArgsForCall, struct { - arg1 context.Context - arg2 lager.Logger - arg3 *models.ActualLRPKey - arg4 *models.ActualLRPInstanceKey - arg5 *models.ActualLRPNetInfo - arg6 []*models.ActualLRPInternalRoute - arg7 map[string]string - arg8 bool - arg9 string - }{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9}) + arg1 context.Context + arg2 lager.Logger + arg3 *models.ActualLRPKey + arg4 *models.ActualLRPInstanceKey + arg5 *models.ActualLRPNetInfo + arg6 []*models.ActualLRPInternalRoute + arg7 map[string]string + arg8 bool + arg9 string + arg10 bool + }{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9, arg10}) stub := fake.StartActualLRPStub fakeReturns := fake.startActualLRPReturns - fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9}) + fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9, arg10}) fake.startActualLRPMutex.Unlock() if stub != nil { - return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) } if specificReturn { return ret.result1, ret.result2, ret.result3 @@ -3108,17 +3110,17 @@ func (fake *FakeDB) StartActualLRPCallCount() int { return len(fake.startActualLRPArgsForCall) } -func (fake *FakeDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) (*models.ActualLRP, *models.ActualLRP, error)) { +func (fake *FakeDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) (*models.ActualLRP, *models.ActualLRP, error)) { fake.startActualLRPMutex.Lock() defer fake.startActualLRPMutex.Unlock() fake.StartActualLRPStub = stub } -func (fake *FakeDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) { +func (fake *FakeDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) { fake.startActualLRPMutex.RLock() defer fake.startActualLRPMutex.RUnlock() argsForCall := fake.startActualLRPArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9, argsForCall.arg10 } func (fake *FakeDB) StartActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) { diff --git a/db/dbfakes/fake_lrpdb.go b/db/dbfakes/fake_lrpdb.go index 15a2a714..71aa3c23 100644 --- a/db/dbfakes/fake_lrpdb.go +++ b/db/dbfakes/fake_lrpdb.go @@ -294,18 +294,19 @@ type FakeLRPDB struct { removeDesiredLRPReturnsOnCall map[int]struct { result1 error } - StartActualLRPStub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) (*models.ActualLRP, *models.ActualLRP, error) + StartActualLRPStub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) (*models.ActualLRP, *models.ActualLRP, error) startActualLRPMutex sync.RWMutex startActualLRPArgsForCall []struct { - arg1 context.Context - arg2 lager.Logger - arg3 *models.ActualLRPKey - arg4 *models.ActualLRPInstanceKey - arg5 *models.ActualLRPNetInfo - arg6 []*models.ActualLRPInternalRoute - arg7 map[string]string - arg8 bool - arg9 string + arg1 context.Context + arg2 lager.Logger + arg3 *models.ActualLRPKey + arg4 *models.ActualLRPInstanceKey + arg5 *models.ActualLRPNetInfo + arg6 []*models.ActualLRPInternalRoute + arg7 map[string]string + arg8 bool + arg9 string + arg10 bool } startActualLRPReturns struct { result1 *models.ActualLRP @@ -1558,7 +1559,7 @@ func (fake *FakeLRPDB) RemoveDesiredLRPReturnsOnCall(i int, result1 error) { }{result1} } -func (fake *FakeLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute, arg7 map[string]string, arg8 bool, arg9 string) (*models.ActualLRP, *models.ActualLRP, error) { +func (fake *FakeLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 *models.ActualLRPKey, arg4 *models.ActualLRPInstanceKey, arg5 *models.ActualLRPNetInfo, arg6 []*models.ActualLRPInternalRoute, arg7 map[string]string, arg8 bool, arg9 string, arg10 bool) (*models.ActualLRP, *models.ActualLRP, error) { var arg6Copy []*models.ActualLRPInternalRoute if arg6 != nil { arg6Copy = make([]*models.ActualLRPInternalRoute, len(arg6)) @@ -1567,22 +1568,23 @@ func (fake *FakeLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, a fake.startActualLRPMutex.Lock() ret, specificReturn := fake.startActualLRPReturnsOnCall[len(fake.startActualLRPArgsForCall)] fake.startActualLRPArgsForCall = append(fake.startActualLRPArgsForCall, struct { - arg1 context.Context - arg2 lager.Logger - arg3 *models.ActualLRPKey - arg4 *models.ActualLRPInstanceKey - arg5 *models.ActualLRPNetInfo - arg6 []*models.ActualLRPInternalRoute - arg7 map[string]string - arg8 bool - arg9 string - }{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9}) + arg1 context.Context + arg2 lager.Logger + arg3 *models.ActualLRPKey + arg4 *models.ActualLRPInstanceKey + arg5 *models.ActualLRPNetInfo + arg6 []*models.ActualLRPInternalRoute + arg7 map[string]string + arg8 bool + arg9 string + arg10 bool + }{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9, arg10}) stub := fake.StartActualLRPStub fakeReturns := fake.startActualLRPReturns - fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9}) + fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6Copy, arg7, arg8, arg9, arg10}) fake.startActualLRPMutex.Unlock() if stub != nil { - return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) } if specificReturn { return ret.result1, ret.result2, ret.result3 @@ -1596,17 +1598,17 @@ func (fake *FakeLRPDB) StartActualLRPCallCount() int { return len(fake.startActualLRPArgsForCall) } -func (fake *FakeLRPDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) (*models.ActualLRP, *models.ActualLRP, error)) { +func (fake *FakeLRPDB) StartActualLRPCalls(stub func(context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) (*models.ActualLRP, *models.ActualLRP, error)) { fake.startActualLRPMutex.Lock() defer fake.startActualLRPMutex.Unlock() fake.StartActualLRPStub = stub } -func (fake *FakeLRPDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string) { +func (fake *FakeLRPDB) StartActualLRPArgsForCall(i int) (context.Context, lager.Logger, *models.ActualLRPKey, *models.ActualLRPInstanceKey, *models.ActualLRPNetInfo, []*models.ActualLRPInternalRoute, map[string]string, bool, string, bool) { fake.startActualLRPMutex.RLock() defer fake.startActualLRPMutex.RUnlock() argsForCall := fake.startActualLRPArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8, argsForCall.arg9, argsForCall.arg10 } func (fake *FakeLRPDB) StartActualLRPReturns(result1 *models.ActualLRP, result2 *models.ActualLRP, result3 error) { diff --git a/db/sqldb/actual_lrp_db.go b/db/sqldb/actual_lrp_db.go index f46e77da..92f50d58 100644 --- a/db/sqldb/actual_lrp_db.go +++ b/db/sqldb/actual_lrp_db.go @@ -324,10 +324,16 @@ func (db *SQLDB) StartActualLRP( metricTags map[string]string, routable bool, availabilityZone string, + isCurrentlyRunning bool, ) (*models.ActualLRP, *models.ActualLRP, error) { logger = logger.Session("db-start-actual-lrp", lager.Data{"actual_lrp_key": key, "actual_lrp_instance_key": instanceKey, "net_info": netInfo, "routable": routable}) - logger.Info("starting") - defer logger.Info("complete") + if db.debugStartActualLRPHeartbeats && isCurrentlyRunning { + logger.Debug("heartbeating-lrp") + defer logger.Debug("heartbeat-complete") + } else { + logger.Info("starting") + defer logger.Info("complete") + } var beforeActualLRP models.ActualLRP var actualLRP *models.ActualLRP diff --git a/db/sqldb/actual_lrp_db_test.go b/db/sqldb/actual_lrp_db_test.go index 7c5ae67c..e34318e3 100644 --- a/db/sqldb/actual_lrp_db_test.go +++ b/db/sqldb/actual_lrp_db_test.go @@ -5,11 +5,13 @@ import ( "strings" "time" + "code.cloudfoundry.org/bbs/db/sqldb" "code.cloudfoundry.org/bbs/models" "code.cloudfoundry.org/bbs/models/test/model_helpers" "code.cloudfoundry.org/bbs/test_helpers" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" + "github.com/onsi/gomega/gbytes" ) var _ = Describe("ActualLRPDB", func() { @@ -46,7 +48,7 @@ var _ = Describe("ActualLRPDB", func() { BeforeEach(func() { _, err := sqlDB.CreateUnclaimedActualLRP(ctx, logger, key) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, key, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, key, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) @@ -64,7 +66,7 @@ var _ = Describe("ActualLRPDB", func() { Expect(err).NotTo(HaveOccurred()) _, err = sqlDB.CreateUnclaimedActualLRP(ctx, logger, key) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, key, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, key, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) @@ -323,7 +325,7 @@ var _ = Describe("ActualLRPDB", func() { internalRoutes := model_helpers.NewActualLRPInternalRoutes() metricTags := model_helpers.NewActualLRPMetricTags() availabilityZone6 := "some-zone-6" - _, _, err = sqlDB.StartActualLRP(ctx, logger, actualLRPKey6, instanceKey6, &netInfo, internalRoutes, metricTags, false, availabilityZone6) + _, _, err = sqlDB.StartActualLRP(ctx, logger, actualLRPKey6, instanceKey6, &netInfo, internalRoutes, metricTags, false, availabilityZone6, false) Expect(err).NotTo(HaveOccurred()) queryStr = "UPDATE actual_lrps SET presence = ? WHERE process_guid = ? AND instance_index = ? AND presence = ?" if test_helpers.UsePostgres() { @@ -420,7 +422,7 @@ var _ = Describe("ActualLRPDB", func() { internalRoutes := model_helpers.NewActualLRPInternalRoutes() metricTags := model_helpers.NewActualLRPMetricTags() _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRPWithInvalidData.ActualLRPKey, - &actualLRPWithInvalidData.ActualLRPInstanceKey, &actualLRPWithInvalidData.ActualLRPNetInfo, internalRoutes, metricTags, false, "some-zone") + &actualLRPWithInvalidData.ActualLRPInstanceKey, &actualLRPWithInvalidData.ActualLRPNetInfo, internalRoutes, metricTags, false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) queryStr := `UPDATE actual_lrps SET net_info = 'garbage' WHERE process_guid = 'invalid'` if test_helpers.UsePostgres() { @@ -446,7 +448,7 @@ var _ = Describe("ActualLRPDB", func() { internalRoutes := model_helpers.NewActualLRPInternalRoutes() metricTags := model_helpers.NewActualLRPMetricTags() _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRPWithInvalidData.ActualLRPKey, - &actualLRPWithInvalidData.ActualLRPInstanceKey, &actualLRPWithInvalidData.ActualLRPNetInfo, internalRoutes, metricTags, false, "some-zone") + &actualLRPWithInvalidData.ActualLRPInstanceKey, &actualLRPWithInvalidData.ActualLRPNetInfo, internalRoutes, metricTags, false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) queryStr := `UPDATE actual_lrps SET internal_routes = 'garbage' WHERE process_guid = 'invalid'` if test_helpers.UsePostgres() { @@ -471,7 +473,7 @@ var _ = Describe("ActualLRPDB", func() { internalRoutes := model_helpers.NewActualLRPInternalRoutes() metricTags := model_helpers.NewActualLRPMetricTags() _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRPWithInvalidData.ActualLRPKey, - &actualLRPWithInvalidData.ActualLRPInstanceKey, &actualLRPWithInvalidData.ActualLRPNetInfo, internalRoutes, metricTags, false, "some-zone") + &actualLRPWithInvalidData.ActualLRPInstanceKey, &actualLRPWithInvalidData.ActualLRPNetInfo, internalRoutes, metricTags, false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) queryStr := `UPDATE actual_lrps SET metric_tags = 'garbage' WHERE process_guid = 'invalid'` if test_helpers.UsePostgres() { @@ -829,7 +831,7 @@ var _ = Describe("ActualLRPDB", func() { InstanceGuid: instanceKey.InstanceGuid, CellId: instanceKey.CellId, }, - &netInfo, internalRoutes, metricTags, false, availabilityZone) + &netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) @@ -1020,7 +1022,7 @@ var _ = Describe("ActualLRPDB", func() { Context("and the actual lrp is UNCLAIMED", func() { It("transitions the state to RUNNING", func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) actualLRPs, err := sqlDB.ActualLRPs(ctx, logger, models.ActualLRPFilter{ProcessGuid: actualLRP.ProcessGuid, Index: &actualLRP.Index}) @@ -1044,7 +1046,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("returns the existing actual lrp", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) expectedActualLRP := *actualLRP expectedActualLRP.State = models.ActualLRPStateUnclaimed @@ -1073,7 +1075,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("transitions the state to RUNNING", func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) actualLRPs, err := sqlDB.ActualLRPs(ctx, logger, models.ActualLRPFilter{ProcessGuid: actualLRP.ProcessGuid, Index: &actualLRP.Index}) @@ -1097,7 +1099,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("returns the existing actual lrp", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) expectedActualLRP := *actualLRP @@ -1124,7 +1126,7 @@ var _ = Describe("ActualLRPDB", func() { Context("and the instance key is different", func() { It("transitions the state to RUNNING, updating the instance key", func() { otherInstanceKey := &models.ActualLRPInstanceKey{CellId: "some-other-cell", InstanceGuid: "some-other-instance-guid"} - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, otherInstanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, otherInstanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) actualLRPs, err := sqlDB.ActualLRPs(ctx, logger, models.ActualLRPFilter{ProcessGuid: actualLRP.ProcessGuid, Index: &actualLRP.Index}) @@ -1150,7 +1152,7 @@ var _ = Describe("ActualLRPDB", func() { Context("and the actual lrp is RUNNING", func() { BeforeEach(func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) @@ -1160,7 +1162,7 @@ var _ = Describe("ActualLRPDB", func() { beforeActualLRPs, err := sqlDB.ActualLRPs(ctx, logger, models.ActualLRPFilter{ProcessGuid: actualLRP.ProcessGuid, Index: &actualLRP.Index}) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) afterActualLRPs, err := sqlDB.ActualLRPs(ctx, logger, models.ActualLRPFilter{ProcessGuid: actualLRP.ProcessGuid, Index: &actualLRP.Index}) @@ -1170,7 +1172,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("returns the same actual lrp group for before and after", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(beforeActualLRP).To(Equal(afterActualLRP)) }) @@ -1190,7 +1192,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("updates the net info", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, newNetInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, newNetInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(expectedActualLRPs).To(ConsistOf(beforeActualLRP)) @@ -1221,7 +1223,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("updates the internal routes", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, newInternalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, newInternalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(expectedActualLRPs).To(ConsistOf(beforeActualLRP)) @@ -1254,7 +1256,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("updates the metric tags", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, newMetricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, newMetricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(expectedActualLRPs).To(ConsistOf(beforeActualLRP)) @@ -1281,7 +1283,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("updates the routable", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, true, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(expectedActualLRPs).To(ConsistOf(beforeActualLRP)) @@ -1308,7 +1310,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("updates the availability_zone", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, "some-other-zone") + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, "some-other-zone", false) Expect(err).NotTo(HaveOccurred()) Expect(expectedActualLRPs).To(ConsistOf(beforeActualLRP)) @@ -1328,7 +1330,7 @@ var _ = Describe("ActualLRPDB", func() { Context("and the instance key is not the same", func() { It("returns an ErrActualLRPCannotBeStarted", func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, &models.ActualLRPInstanceKey{CellId: "some-other-cell", InstanceGuid: "some-other-instance-guid"}, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, &models.ActualLRPInstanceKey{CellId: "some-other-cell", InstanceGuid: "some-other-instance-guid"}, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).To(Equal(models.ErrActualLRPCannotBeStarted)) }) }) @@ -1351,7 +1353,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("transitions the state to RUNNING", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred()) @@ -1429,7 +1431,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("creates the actual lrp", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(beforeActualLRP).To(Equal(&models.ActualLRP{})) @@ -1468,7 +1470,7 @@ var _ = Describe("ActualLRPDB", func() { }) It("creates a new actual LRP", func() { - beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + beforeActualLRP, afterActualLRP, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) Expect(beforeActualLRP).To(Equal(&models.ActualLRP{})) @@ -1490,6 +1492,80 @@ var _ = Describe("ActualLRPDB", func() { }) }) }) + Context("logging events", func() { + var ( + instanceKey *models.ActualLRPInstanceKey + netInfo *models.ActualLRPNetInfo + actualLRP *models.ActualLRP + internalRoutes []*models.ActualLRPInternalRoute + metricTags map[string]string + ) + + BeforeEach(func() { + instanceKey = &models.ActualLRPInstanceKey{ + InstanceGuid: "the-instance-guid", + CellId: "the-cell-id", + } + + netInfo = &models.ActualLRPNetInfo{ + Address: "1.2.1.2", + Ports: []*models.PortMapping{{ContainerPort: 8080, HostPort: 9090}}, + InstanceAddress: "2.2.2.2", + } + + internalRoutes = model_helpers.NewActualLRPInternalRoutes() + metricTags = model_helpers.NewActualLRPMetricTags() + actualLRP = &models.ActualLRP{ + ActualLRPKey: models.ActualLRPKey{ + ProcessGuid: "the-guid", + Index: 1, + Domain: "the-domain", + }, + } + fakeClock.Increment(time.Hour) + }) + Context("when db.debugStartActualLRPHeartbeat is enabled", func() { + BeforeEach(func() { + sqlDB = sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, true) + }) + Context("and the StartActualLRP call is called with a container already running", func() { + It("logs a special debug message for heartbeat StartActualLRP calls", func() { + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, true) + Expect(err).ToNot(HaveOccurred()) + Eventually(logger).Should(gbytes.Say(`db.start-actual-lrp.heartbeating-lrp","log_level":0`)) + Eventually(logger).Should(gbytes.Say(`db.start-actual-lrp.heartbeat-complete","log_level":0`)) + }) + }) + + Context("and the StartActualLRP call is called without a container already running", func() { + It("logs the normal info log message for StartActualLRP calls", func() { + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) + Expect(err).ToNot(HaveOccurred()) + Eventually(logger).Should(gbytes.Say(`db-start-actual-lrp.starting","log_level":1`)) + Eventually(logger).Should(gbytes.Say(`db.start-actual-lrp.complete","log_level":1`)) + }) + }) + }) + Context("when db.debugStartActualLRPHeartbeat is disabled", func() { + Context("and the StartActualLRP call is called with a container already running", func() { + It("logs the normal info log message for StartActualLRP calls", func() { + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, true) + Expect(err).ToNot(HaveOccurred()) + Eventually(logger).Should(gbytes.Say(`db-start-actual-lrp.starting","log_level":1`)) + Eventually(logger).Should(gbytes.Say(`db.start-actual-lrp.complete","log_level":1`)) + }) + }) + + Context("and the StartActualLRP call is called without a container already running", func() { + It("logs the normal info log message for StartActualLRP calls", func() { + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) + Expect(err).ToNot(HaveOccurred()) + Eventually(logger).Should(gbytes.Say(`db-start-actual-lrp.starting","log_level":1`)) + Eventually(logger).Should(gbytes.Say(`db.start-actual-lrp.complete","log_level":1`)) + }) + }) + }) + }) }) Describe("CrashActualLRP", func() { @@ -1531,7 +1607,7 @@ var _ = Describe("ActualLRPDB", func() { Context("and it is RUNNING", func() { BeforeEach(func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) actualLRP.ModificationTag.Increment() }) @@ -1781,7 +1857,7 @@ var _ = Describe("ActualLRPDB", func() { Context("and it's already CRASHED", func() { BeforeEach(func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err := sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) actualLRP.ModificationTag.Increment() @@ -1856,7 +1932,7 @@ var _ = Describe("ActualLRPDB", func() { _, err := sqlDB.CreateUnclaimedActualLRP(ctx, logger, &evacuatingLRP.ActualLRPKey) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &evacuatingLRP.ActualLRPKey, evacuatingInstanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &evacuatingLRP.ActualLRPKey, evacuatingInstanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) queryStr := ` UPDATE actual_lrps SET presence = ? @@ -1885,7 +1961,7 @@ var _ = Describe("ActualLRPDB", func() { _, err = sqlDB.CreateUnclaimedActualLRP(ctx, logger, &actualLRP.ActualLRPKey) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, instanceKey, netInfo, internalRoutes, metricTags, false, availabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) diff --git a/db/sqldb/encryption_db_test.go b/db/sqldb/encryption_db_test.go index 1bfadfaf..e3c142e8 100644 --- a/db/sqldb/encryption_db_test.go +++ b/db/sqldb/encryption_db_test.go @@ -178,7 +178,7 @@ var _ = Describe("Encryption", func() { Expect(err).NotTo(HaveOccurred()) cryptor = makeCryptor("new", "old") - sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) err = sqlDB.PerformEncryption(ctx, logger) Expect(err).NotTo(HaveOccurred()) @@ -240,7 +240,7 @@ var _ = Describe("Encryption", func() { JustBeforeEach(func() { cryptor = makeCryptor("new", "old") - sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) err := sqlDB.PerformEncryption(ctx, logger) Expect(err).NotTo(HaveOccurred()) }) @@ -423,7 +423,7 @@ var _ = Describe("Encryption", func() { cryptor = makeCryptor("new", "old") - sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) err = sqlDB.PerformEncryption(ctx, logger) Expect(err).NotTo(HaveOccurred()) }) @@ -515,7 +515,7 @@ var _ = Describe("Encryption", func() { } cryptor = makeCryptor("new", "old") - sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB := sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) err = sqlDB.PerformEncryption(ctx, logger) Expect(err).NotTo(HaveOccurred()) diff --git a/db/sqldb/evacuation_db_test.go b/db/sqldb/evacuation_db_test.go index 8d614dd5..c60e7f82 100644 --- a/db/sqldb/evacuation_db_test.go +++ b/db/sqldb/evacuation_db_test.go @@ -32,7 +32,7 @@ var _ = Describe("Evacuation", func() { Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ClaimActualLRP(ctx, logger, guid, index, &actualLRP.ActualLRPInstanceKey) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), actualLRP.GetRoutable(), actualLRP.AvailabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), actualLRP.GetRoutable(), actualLRP.AvailabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) diff --git a/db/sqldb/fakesqldriver/deadlocks_test.go b/db/sqldb/fakesqldriver/deadlocks_test.go index 6c905f1d..e1c3583b 100644 --- a/db/sqldb/fakesqldriver/deadlocks_test.go +++ b/db/sqldb/fakesqldriver/deadlocks_test.go @@ -241,7 +241,7 @@ var _ = Describe("Deadlocks", func() { Context("StartActualLRP", func() { It("retries on deadlocks", func() { - _, _, err := sqlDB.StartActualLRP(ctx, logger, &models.ActualLRPKey{}, &models.ActualLRPInstanceKey{}, &models.ActualLRPNetInfo{}, []*models.ActualLRPInternalRoute{}, map[string]string{}, false, "") + _, _, err := sqlDB.StartActualLRP(ctx, logger, &models.ActualLRPKey{}, &models.ActualLRPInstanceKey{}, &models.ActualLRPNetInfo{}, []*models.ActualLRPInternalRoute{}, map[string]string{}, false, "", false) Expect(err).To(HaveOccurred()) Expect(fakeConn.BeginCallCount()).To(Equal(3)) }) diff --git a/db/sqldb/fakesqldriver/fakesqldriver_suite_test.go b/db/sqldb/fakesqldriver/fakesqldriver_suite_test.go index a2106360..41b62f58 100644 --- a/db/sqldb/fakesqldriver/fakesqldriver_suite_test.go +++ b/db/sqldb/fakesqldriver/fakesqldriver_suite_test.go @@ -81,7 +81,7 @@ var _ = BeforeEach(func() { serializer = format.NewSerializer(cryptor) helperDB := helpers.NewMonitoredDB(db, monitor.New()) - sqlDB = sqldb.NewSQLDB(helperDB, 5, 5, cryptor, fakeGUIDProvider, fakeClock, helpers.MySQL, fakeMetronClient) + sqlDB = sqldb.NewSQLDB(helperDB, 5, 5, cryptor, fakeGUIDProvider, fakeClock, helpers.MySQL, fakeMetronClient, false) ctx = context.Background() }) diff --git a/db/sqldb/lrp_convergence_test.go b/db/sqldb/lrp_convergence_test.go index 31f48fff..4d3a16e7 100644 --- a/db/sqldb/lrp_convergence_test.go +++ b/db/sqldb/lrp_convergence_test.go @@ -247,7 +247,7 @@ var _ = Describe("LRPConvergence", func() { // create the suspect lrp actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) lrpKey = models.NewActualLRPKey(processGuid, 0, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ChangeActualLRPPresence(ctx, logger, &lrpKey, models.ActualLRP_Ordinary, models.ActualLRP_Suspect) Expect(err).NotTo(HaveOccurred()) @@ -291,14 +291,14 @@ var _ = Describe("LRPConvergence", func() { // create the suspect lrp actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) lrpKey = models.NewActualLRPKey(processGuid, 0, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ChangeActualLRPPresence(ctx, logger, &lrpKey, models.ActualLRP_Ordinary, models.ActualLRP_Suspect) Expect(err).NotTo(HaveOccurred()) // create the second suspect lrp lrpKey2 = models.NewActualLRPKey(processGuid, 1, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ChangeActualLRPPresence(ctx, logger, &lrpKey2, models.ActualLRP_Ordinary, models.ActualLRP_Suspect) Expect(err).NotTo(HaveOccurred()) @@ -338,13 +338,13 @@ var _ = Describe("LRPConvergence", func() { // create the suspect lrp actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) lrpKey = models.NewActualLRPKey(processGuid, 0, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, err = db.ExecContext(ctx, fmt.Sprintf(`UPDATE actual_lrps SET presence = %d`, models.ActualLRP_Suspect)) Expect(err).NotTo(HaveOccurred()) // create the ordinary lrp - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) // create the unrelated suspect lrp @@ -354,7 +354,7 @@ var _ = Describe("LRPConvergence", func() { err = sqlDB.DesireLRP(ctx, logger, desiredLRP2) Expect(err).NotTo(HaveOccurred()) lrpKey2 = models.NewActualLRPKey(processGuid2, 1, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ChangeActualLRPPresence(ctx, logger, &lrpKey2, models.ActualLRP_Ordinary, models.ActualLRP_Suspect) Expect(err).NotTo(HaveOccurred()) @@ -412,12 +412,12 @@ var _ = Describe("LRPConvergence", func() { actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) processGuid := "orphaned-suspect-lrp-1" lrpKey = models.NewActualLRPKey(processGuid, 0, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey, &models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) otherProcessGuid := "orphaned-suspect-lrp-2" lrpKey2 = models.NewActualLRPKey(otherProcessGuid, 0, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, err = db.ExecContext(ctx, fmt.Sprintf(`UPDATE actual_lrps SET presence = %d`, models.ActualLRP_Suspect)) @@ -429,7 +429,7 @@ var _ = Describe("LRPConvergence", func() { err = sqlDB.DesireLRP(ctx, logger, desiredLRP2) Expect(err).NotTo(HaveOccurred()) lrpKey3 = models.NewActualLRPKey(notOrphanedProcessGuid, 0, domain) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey3, &models.ActualLRPInstanceKey{InstanceGuid: "ig-3", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey3, &models.ActualLRPInstanceKey{InstanceGuid: "ig-3", CellId: "suspect-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ChangeActualLRPPresence(ctx, logger, &lrpKey3, models.ActualLRP_Ordinary, models.ActualLRP_Suspect) Expect(err).NotTo(HaveOccurred()) @@ -1042,7 +1042,7 @@ var _ = Describe("LRPConvergence", func() { _, _, err = sqlDB.ClaimActualLRP(ctx, logger, processGuid, i, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}) Expect(err).NotTo(HaveOccurred()) actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) _, _, _, err = sqlDB.CrashActualLRP(ctx, logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, "whatever") Expect(err).NotTo(HaveOccurred()) @@ -1209,7 +1209,7 @@ var _ = Describe("LRPConvergence", func() { _, _, err = sqlDB.ClaimActualLRP(ctx, logger, processGuid, i, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}) Expect(err).NotTo(HaveOccurred()) actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &crashedActualLRPKey, &models.ActualLRPInstanceKey{InstanceGuid: instanceGuid, CellId: "existing-cell"}, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) } @@ -1414,17 +1414,17 @@ var _ = Describe("LRPConvergence", func() { actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) lrpKey1 = models.NewActualLRPKey(processGuid, 0, domain) lrpInstanceKey1 = models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "existing-cell"} - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey1, &lrpInstanceKey1, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey1, &lrpInstanceKey1, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) lrpKey2 = models.NewActualLRPKey(processGuid, 1, domain) lrpInstanceKey2 = models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "existing-cell"} - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &lrpInstanceKey2, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &lrpInstanceKey2, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) lrpKey3 = models.NewActualLRPKey(processGuid, 2, domain) lrpInstanceKey3 = models.ActualLRPInstanceKey{InstanceGuid: "ig-3", CellId: "existing-cell"} - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey3, &lrpInstanceKey3, &actualLRPNetInfo, nil, nil, false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey3, &lrpInstanceKey3, &actualLRPNetInfo, nil, nil, false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) queryStr := "UPDATE actual_lrps SET internal_routes = ? WHERE process_guid = ? AND instance_index = ?;" @@ -1440,7 +1440,7 @@ var _ = Describe("LRPConvergence", func() { {Hostname: "some-internal-route.apps.internal"}, {Hostname: "some-other-internal-route.apps.internal"}, } - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey4, &lrpInstanceKey4, &actualLRPNetInfo, sameInternalRoutes, model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey4, &lrpInstanceKey4, &actualLRPNetInfo, sameInternalRoutes, model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) lrpKey5 := models.NewActualLRPKey(processGuid, 4, domain) @@ -1449,7 +1449,7 @@ var _ = Describe("LRPConvergence", func() { {Hostname: "some-other-internal-route.apps.internal"}, {Hostname: "some-internal-route.apps.internal"}, } - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey5, &lrpInstanceKey5, &actualLRPNetInfo, internalRoutesInDifferentOrder, model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey5, &lrpInstanceKey5, &actualLRPNetInfo, internalRoutesInDifferentOrder, model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) rawInternalRoutes := json.RawMessage(`[{"hostname":"some-internal-route.apps.internal"},{"hostname":"some-other-internal-route.apps.internal"}]`) @@ -1493,17 +1493,17 @@ var _ = Describe("LRPConvergence", func() { actualLRPNetInfo := models.NewActualLRPNetInfo("some-address", "container-address", models.ActualLRPNetInfo_PreferredAddressUnknown, models.NewPortMapping(2222, 4444)) lrpKey1 = models.NewActualLRPKey(processGuid, 0, domain) lrpInstanceKey1 = models.ActualLRPInstanceKey{InstanceGuid: "ig-1", CellId: "existing-cell"} - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey1, &lrpInstanceKey1, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey1, &lrpInstanceKey1, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) lrpKey2 = models.NewActualLRPKey(processGuid, 1, domain) lrpInstanceKey2 = models.ActualLRPInstanceKey{InstanceGuid: "ig-2", CellId: "existing-cell"} - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &lrpInstanceKey2, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey2, &lrpInstanceKey2, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), model_helpers.NewActualLRPMetricTags(), false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) lrpKey3 = models.NewActualLRPKey(processGuid, 2, domain) lrpInstanceKey3 = models.ActualLRPInstanceKey{InstanceGuid: "ig-3", CellId: "existing-cell"} - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey3, &lrpInstanceKey3, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey3, &lrpInstanceKey3, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) lrpKey4 := models.NewActualLRPKey(processGuid, 3, domain) @@ -1512,7 +1512,7 @@ var _ = Describe("LRPConvergence", func() { "app_name": "some-app-renamed", } - _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey4, &lrpInstanceKey4, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), sameMetricTags, false, "some-zone") + _, _, err = sqlDB.StartActualLRP(ctx, logger, &lrpKey4, &lrpInstanceKey4, &actualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), sameMetricTags, false, "some-zone", false) Expect(err).NotTo(HaveOccurred()) update := models.DesiredLRPUpdate{ diff --git a/db/sqldb/sqldb.go b/db/sqldb/sqldb.go index 6b8ce15d..f5f828a6 100644 --- a/db/sqldb/sqldb.go +++ b/db/sqldb/sqldb.go @@ -14,17 +14,18 @@ import ( ) type SQLDB struct { - db helpers.QueryableDB - convergenceWorkersSize int - updateWorkersSize int - clock clock.Clock - guidProvider guidprovider.GUIDProvider - serializer format.Serializer - cryptor encryption.Cryptor - encoder format.Encoder - flavor string - helper helpers.SQLHelper - metronClient loggingclient.IngressClient + db helpers.QueryableDB + convergenceWorkersSize int + updateWorkersSize int + clock clock.Clock + guidProvider guidprovider.GUIDProvider + serializer format.Serializer + cryptor encryption.Cryptor + encoder format.Encoder + flavor string + helper helpers.SQLHelper + metronClient loggingclient.IngressClient + debugStartActualLRPHeartbeats bool } func NewSQLDB( @@ -36,20 +37,22 @@ func NewSQLDB( clock clock.Clock, flavor string, metronClient loggingclient.IngressClient, + debugStartActualLRPHeartbeats bool, ) *SQLDB { helper := helpers.NewSQLHelper(flavor) return &SQLDB{ - db: db, - convergenceWorkersSize: convergenceWorkersSize, - updateWorkersSize: updateWorkersSize, - clock: clock, - guidProvider: guidProvider, - serializer: format.NewSerializer(cryptor), - cryptor: cryptor, - encoder: format.NewEncoder(cryptor), - flavor: flavor, - helper: helper, - metronClient: metronClient, + db: db, + convergenceWorkersSize: convergenceWorkersSize, + updateWorkersSize: updateWorkersSize, + clock: clock, + guidProvider: guidProvider, + serializer: format.NewSerializer(cryptor), + cryptor: cryptor, + encoder: format.NewEncoder(cryptor), + flavor: flavor, + helper: helper, + metronClient: metronClient, + debugStartActualLRPHeartbeats: debugStartActualLRPHeartbeats, } } diff --git a/db/sqldb/sqldb_suite_test.go b/db/sqldb/sqldb_suite_test.go index 112bb629..63731988 100644 --- a/db/sqldb/sqldb_suite_test.go +++ b/db/sqldb/sqldb_suite_test.go @@ -124,7 +124,7 @@ var _ = BeforeSuite(func() { db = helpers.NewMonitoredDB(rawDB, monitor.New()) ctx = context.Background() - sqlDB = sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB = sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) err = sqlDB.CreateConfigurationsTable(ctx, logger) if err != nil { logger.Fatal("sql-failed-create-configurations-table", err) @@ -139,7 +139,7 @@ var _ = BeforeEach(func() { fakeMetronClient = new(mfakes.FakeIngressClient) migrationMetronClient := new(mfakes.FakeIngressClient) - sqlDB = sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB = sqldb.NewSQLDB(db, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) migrationsDone := make(chan struct{}) diff --git a/db/sqldb/suspect_db_test.go b/db/sqldb/suspect_db_test.go index a9c6abd2..7d99c07e 100644 --- a/db/sqldb/suspect_db_test.go +++ b/db/sqldb/suspect_db_test.go @@ -30,7 +30,7 @@ var _ = Describe("Suspect ActualLRPs", func() { Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ClaimActualLRP(ctx, logger, guid, index, &actualLRP.ActualLRPInstanceKey) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, false, actualLRP.AvailabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &actualLRP.ActualLRPKey, &actualLRP.ActualLRPInstanceKey, &actualLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, false, actualLRP.AvailabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) @@ -65,7 +65,7 @@ var _ = Describe("Suspect ActualLRPs", func() { Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ClaimActualLRP(ctx, logger, replacementGuid, replacementIndex, &replacementLRP.ActualLRPInstanceKey) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &replacementLRP.ActualLRPKey, &replacementLRP.ActualLRPInstanceKey, &replacementLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, replacementLRP.GetRoutable(), replacementLRP.AvailabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &replacementLRP.ActualLRPKey, &replacementLRP.ActualLRPInstanceKey, &replacementLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, replacementLRP.GetRoutable(), replacementLRP.AvailabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) @@ -102,7 +102,7 @@ var _ = Describe("Suspect ActualLRPs", func() { Expect(err).NotTo(HaveOccurred()) _, _, err = sqlDB.ClaimActualLRP(ctx, logger, guid, index, &replacementLRP.ActualLRPInstanceKey) Expect(err).NotTo(HaveOccurred()) - _, _, err = sqlDB.StartActualLRP(ctx, logger, &replacementLRP.ActualLRPKey, &replacementLRP.ActualLRPInstanceKey, &replacementLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, false, replacementLRP.AvailabilityZone) + _, _, err = sqlDB.StartActualLRP(ctx, logger, &replacementLRP.ActualLRPKey, &replacementLRP.ActualLRPInstanceKey, &replacementLRP.ActualLRPNetInfo, model_helpers.NewActualLRPInternalRoutes(), nil, false, replacementLRP.AvailabilityZone, false) Expect(err).NotTo(HaveOccurred()) }) diff --git a/db/sqldb/version_db_test.go b/db/sqldb/version_db_test.go index d14dde84..eafc99bb 100644 --- a/db/sqldb/version_db_test.go +++ b/db/sqldb/version_db_test.go @@ -133,7 +133,7 @@ var _ = Describe("Version", func() { db, err = helpers.Connect(logger, dbParams) Expect(err).NotTo(HaveOccurred()) helperDB = helpers.NewMonitoredDB(db, monitor.New()) - sqlDB = sqldb.NewSQLDB(helperDB, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient) + sqlDB = sqldb.NewSQLDB(helperDB, 5, 5, cryptor, fakeGUIDProvider, fakeClock, dbFlavor, fakeMetronClient, false) }) AfterEach(func() { diff --git a/handlers/context_test.go b/handlers/context_test.go index 12faa7be..deea6c0d 100644 --- a/handlers/context_test.go +++ b/handlers/context_test.go @@ -74,6 +74,7 @@ var _ = Describe("Context", func() { fakeClock, sqlRunner.DriverName(), fakeMetronClient, + false, ) err = sqlDB.CreateConfigurationsTable(context.Background(), logger) Expect(err).NotTo(HaveOccurred())