spindle: more verbose error messages

Signed-off-by: Seongmin Lee <[e-mail]>

spindle/db/events.go

···
 	EventJson string `json:"event"`
 }
 
-func (d *DB) InsertEvent(event Event, notifier *notifier.Notifier) error {
+func (d *DB) insertEvent(event Event, notifier *notifier.Notifier) error {
 	_, err := d.Exec(
 		`insert into events (rkey, nsid, event, created) values (?, ?, ?, ?)`,
 		event.Rkey,
···
 	return evts, nil
 }
 
-func (d *DB) CreateStatusEvent(rkey string, s tangled.PipelineStatus, n *notifier.Notifier) error {
-	eventJson, err := json.Marshal(s)
-	if err != nil {
-		return err
-	}
-
-	event := Event{
-		Rkey:      rkey,
-		Nsid:      tangled.PipelineStatusNSID,
-		Created:   time.Now().UnixNano(),
-		EventJson: string(eventJson),
-	}
-
-	return d.InsertEvent(event, n)
-}
-
 func (d *DB) createStatusEvent(
 	workflowId models.WorkflowId,
 	statusKind models.StatusKind,
···
 		EventJson: string(eventJson),
 	}
 
-	return d.InsertEvent(event, n)
+	return d.insertEvent(event, n)
 
 }
 

spindle/engines/nixery/engine.go

···
 		return err
 	}
 	e.registerCleanup(wid, func(ctx context.Context) error {
-		return e.docker.NetworkRemove(ctx, networkName(wid))
+		err := e.docker.NetworkRemove(ctx, networkName(wid))
+		if err != nil {
+			return fmt.Errorf("removing network: %w", err)
+		}
+		return nil
 	})
 
 	addl := wf.Data.(addlFields)
···
 		return fmt.Errorf("creating container: %w", err)
 	}
 	e.registerCleanup(wid, func(ctx context.Context) error {
-		err = e.docker.ContainerStop(ctx, resp.ID, container.StopOptions{})
+		err := e.docker.ContainerStop(ctx, resp.ID, container.StopOptions{})
 		if err != nil {
-			return err
+			return fmt.Errorf("stopping container: %w", err)
 		}
 
-		return e.docker.ContainerRemove(ctx, resp.ID, container.RemoveOptions{
+		err = e.docker.ContainerRemove(ctx, resp.ID, container.RemoveOptions{
 			RemoveVolumes: true,
 			RemoveLinks:   false,
 			Force:         false,
 		})
+		if err != nil {
+			return fmt.Errorf("removing container: %w", err)
+		}
+		return nil
 	})
 
 	err = e.docker.ContainerStart(ctx, resp.ID, container.StartOptions{})
···
 }
 
 func (e *Engine) DestroyWorkflow(ctx context.Context, wid models.WorkflowId) error {
-	e.cleanupMu.Lock()
-	key := wid.String()
-
-	fns := e.cleanup[key]
-	delete(e.cleanup, key)
-	e.cleanupMu.Unlock()
+	fns := e.drainCleanups(wid)
 
 	for _, fn := range fns {
 		if err := fn(ctx); err != nil {
···
 
 	key := wid.String()
 	e.cleanup[key] = append(e.cleanup[key], fn)
+}
+
+func (e *Engine) drainCleanups(wid models.WorkflowId) []cleanupFunc {
+	e.cleanupMu.Lock()
+	key := wid.String()
+
+	fns := e.cleanup[key]
+	delete(e.cleanup, key)
+	e.cleanupMu.Unlock()
+
+	return fns
 }
 
 func networkName(wid models.WorkflowId) string {

spindle/server.go

···
 			tpl.TriggerMetadata.Repo.Repo,
 		)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to get repo: %w", err)
 		}
 
 		pipelineId := models.PipelineId{
···
 						Name:       w.Name,
 					}, fmt.Sprintf("unknown engine %#v", w.Engine), -1, s.n)
 					if err != nil {
-						return err
+						return fmt.Errorf("db.StatusFailed: %w", err)
 					}
 
 					continue
···
 
 				ewf, err := s.engs[w.Engine].InitWorkflow(*w, tpl)
 				if err != nil {
-					return err
+					return fmt.Errorf("init workflow: %w", err)
 				}
 
 				// inject TANGLED_* env vars after InitWorkflow
···
 					Name:       w.Name,
 				}, s.n)
 				if err != nil {
-					return err
+					return fmt.Errorf("db.StatusPending: %w", err)
 				}
 			}
 		}