More changes

Dockerfile.box

@@ -21,9 +21,6 @@ RUN go mod download -x
 
 COPY . /src/
 
-# Build runner template
-RUN just build-kt-runtime
-
 # Build runner
 RUN just errtrace
 # Reset timestamps so that the build state is reset

Dockerfile.runner

@@ -22,9 +22,6 @@ RUN go mod download -x
 
 COPY . /src/
 
-# Build runner template
-RUN just build-kt-runtime
-
 # Build runner
 RUN just errtrace
 # Reset timestamps so that the build state is reset

backend/controller/dal/dal.go

@@ -731,27 +731,6 @@ func (d *DAL) deploymentWillDeactivate(ctx context.Context, key model.Deployment
 	return d.removeSubscriptionsAndSubscribers(ctx, key)
 }
 
-// GetDeploymentsNeedingReconciliation returns deployments that have a
-// mismatch between the number of assigned and required replicas.
-func (d *DAL) GetDeploymentsNeedingReconciliation(ctx context.Context) ([]Reconciliation, error) {
-	counts, err := d.db.GetDeploymentsNeedingReconciliation(ctx)
-	if err != nil {
-		if libdal.IsNotFound(err) {
-			return nil, nil
-		}
-		return nil, libdal.TranslatePGError(err)
-	}
-	return slices.Map(counts, func(t dalsql.GetDeploymentsNeedingReconciliationRow) Reconciliation {
-		return Reconciliation{
-			Deployment:       t.DeploymentKey,
-			Module:           t.ModuleName,
-			Language:         t.Language,
-			AssignedReplicas: int(t.AssignedRunnersCount),
-			RequiredReplicas: int(t.RequiredRunnersCount),
-		}
-	}), nil
-}
-
 // GetActiveDeployments returns all active deployments.
 func (d *DAL) GetActiveDeployments(ctx context.Context) ([]Deployment, error) {
 	rows, err := d.db.GetActiveDeployments(ctx)

backend/controller/dal/dal_test.go

@@ -105,20 +105,22 @@ func TestDAL(t *testing.T) {
 
 	t.Run("RegisterRunner", func(t *testing.T) {
 		err = dal.UpsertRunner(ctx, Runner{
-			Key:      runnerID,
-			Labels:   labels,
-			Endpoint: "http://localhost:8080",
-			State:    RunnerStateNew,
+			Key:        runnerID,
+			Labels:     labels,
+			Endpoint:   "http://localhost:8080",
+			State:      RunnerStateNew,
+			Deployment: deploymentKey,
 		})
 		assert.NoError(t, err)
 	})
 
 	t.Run("RegisterRunnerFailsOnDuplicate", func(t *testing.T) {
 		err = dal.UpsertRunner(ctx, Runner{
-			Key:      model.NewRunnerKey("localhost", "8080"),
-			Labels:   labels,
-			Endpoint: "http://localhost:8080",
-			State:    RunnerStateNew,
+			Key:        model.NewRunnerKey("localhost", "8080"),
+			Labels:     labels,
+			Endpoint:   "http://localhost:8080",
+			State:      RunnerStateNew,
+			Deployment: deploymentKey,
 		})
 		assert.Error(t, err)
 		assert.IsError(t, err, libdal.ErrConflict)
@@ -132,29 +134,11 @@ func TestDAL(t *testing.T) {
 		Deployment: deploymentKey,
 	}
 
-	t.Run("GetDeploymentsNeedingReconciliation", func(t *testing.T) {
-		reconcile, err := dal.GetDeploymentsNeedingReconciliation(ctx)
-		assert.NoError(t, err)
-		assert.Equal(t, []Reconciliation{}, reconcile)
-	})
-
 	t.Run("SetDeploymentReplicas", func(t *testing.T) {
 		err := dal.SetDeploymentReplicas(ctx, deploymentKey, 1)
 		assert.NoError(t, err)
 	})
 
-	t.Run("GetDeploymentsNeedingReconciliation", func(t *testing.T) {
-		reconcile, err := dal.GetDeploymentsNeedingReconciliation(ctx)
-		assert.NoError(t, err)
-		assert.Equal(t, []Reconciliation{{
-			Deployment:       deploymentKey,
-			Module:           deployment.Module,
-			Language:         deployment.Language,
-			AssignedReplicas: 0,
-			RequiredReplicas: 1,
-		}}, reconcile)
-	})
-
 	t.Run("UpdateRunnerAssigned", func(t *testing.T) {
 		err := dal.UpsertRunner(ctx, Runner{
 			Key:        runnerID,
@@ -166,12 +150,6 @@ func TestDAL(t *testing.T) {
 		assert.NoError(t, err)
 	})
 
-	t.Run("GetDeploymentsNeedingReconciliation", func(t *testing.T) {
-		reconcile, err := dal.GetDeploymentsNeedingReconciliation(ctx)
-		assert.NoError(t, err)
-		assert.Equal(t, []Reconciliation{}, reconcile)
-	})
-
 	t.Run("GetRunnersForDeployment", func(t *testing.T) {
 		runners, err := dal.GetRunnersForDeployment(ctx, deploymentKey)
 		assert.NoError(t, err)
@@ -279,11 +257,11 @@ func TestDAL(t *testing.T) {
 			Deployment: model.NewDeploymentKey("test"),
 		})
 		assert.Error(t, err)
-		assert.IsError(t, err, libdal.ErrNotFound)
+		assert.IsError(t, err, libdal.ErrConstraint)
 	})
 
 	t.Run("GetRoutingTable", func(t *testing.T) {
-		_, err := dal.GetRoutingTable(ctx, []string{deployment.Module})
+		_, err := dal.GetRoutingTable(ctx, []string{"non-existent"})
 		assert.IsError(t, err, libdal.ErrNotFound)
 	})
 

backend/controller/dal/internal/sql/queries.sql

@@ -105,8 +105,7 @@ FROM matches;
 -- name: DeregisterRunner :one
 WITH matches AS (
     UPDATE runners
-        SET state = 'dead',
-            deployment_id = NULL
+        SET state = 'dead'
         WHERE key = sqlc.arg('key')::runner_key
         RETURNING 1)
 SELECT COUNT(*)
@@ -173,19 +172,6 @@ WHERE m.name = $1
   AND min_replicas > 0
 LIMIT 1;
 
--- name: GetDeploymentsNeedingReconciliation :many
--- Get deployments that have a mismatch between the number of assigned and required replicas.
-SELECT d.key                 AS deployment_key,
-       m.name                 AS module_name,
-       m.language             AS language,
-       COUNT(r.id)            AS assigned_runners_count,
-       d.min_replicas::BIGINT AS required_runners_count
-FROM deployments d
-         LEFT JOIN runners r ON d.id = r.deployment_id AND r.state <> 'dead'
-         JOIN modules m ON d.module_id = m.id
-GROUP BY d.key, d.min_replicas, m.name, m.language
-HAVING COUNT(r.id) <> d.min_replicas;
-
 -- name: GetRunnerState :one
 SELECT state
 FROM runners