Function checkpointAllNoteboxes

lib/notebox.go:395–454

checkpointAllNoteboxes ensures that what's on-disk is up to date

(ctx context.Context, purge bool)

// checkpointAllNoteboxes ensures that what's on-disk is up to date
func checkpointAllNoteboxes(ctx context.Context, purge bool) error {
	var firstError error

	// Collect all instances to checkpoint while holding the lock
	// This prevents instances from being deleted while we're working
	var toCheckpoint []struct {
		storage  interface{}
		instance *NoteboxInstance
	}

	// First pass: collect instances under lock
	boxLock.RLock()
	openboxes.Range(func(boxStorage, boxi interface{}) bool {
		instance, ok := boxi.(*NoteboxInstance)
		if ok && instance != nil {
			toCheckpoint = append(toCheckpoint, struct {
				storage  interface{}
				instance *NoteboxInstance
			}{boxStorage, instance})
		}
		return true
	})
	boxLock.RUnlock()

	// Second pass: checkpoint each instance
	for _, item := range toCheckpoint {
		// Re-verify the instance is still in the map
		currentInstance, stillExists := openboxes.Load(item.storage)
		if !stillExists || currentInstance != item.instance {
			// Instance was replaced or deleted, skip it
			continue
		}

		box := &Notebox{}
		box.instance = item.instance

		emptyBox, err := box.checkpoint(ctx, true, purge, false, false)
		if firstError == nil && err != nil && err.Error() != "notebox instance is nil" {
			firstError = err
		}

		// If we're purging, get rid of the notefile if it wasn't in use
		if purge && emptyBox && err == nil {
			// Use boxLock to ensure atomic purge
			boxLock.Lock()
			// Double-check it still exists and is the same instance
			currentInstance, stillExists := openboxes.Load(item.storage)
			if stillExists && currentInstance == item.instance {
				openboxes.Delete(item.storage)
				if debugBox {
					logDebug(ctx, "Notebox %s purged", item.storage)
				}
			}
			boxLock.Unlock()
		}
	}

	// Done