Method Unmarshal

modules/backendscheduler/work/work.go:403–472

Unmarshal deserializes JSON to all shards with proper locking

(data []byte)

// Unmarshal deserializes JSON to all shards with proper locking
func (w *Work) Unmarshal(data []byte) error {
	w.mtx.Lock()
	defer w.mtx.Unlock()

	// Lock all shards in order to prevent race conditions during unmarshaling
	for i := range ShardCount {
		w.Shards[i].mtx.Lock()
	}
	defer func() {
		// Unlock all shards
		for i := range ShardCount {
			w.Shards[i].mtx.Unlock()
		}
	}()

	err := json.Unmarshal(data, w)
	if err != nil {
		return err
	}

	// Ensure all shards are properly initialized (in case any were nil after unmarshaling)
	for i := range ShardCount {
		if w.Shards[i] == nil {
			w.Shards[i] = &Shard{
				Jobs:    make(map[string]*Job),
				Pending: make(map[string]*Job),
			}
		} else {
			if w.Shards[i].Jobs == nil {
				w.Shards[i].Jobs = make(map[string]*Job)
			}
			if w.Shards[i].Pending == nil {
				w.Shards[i].Pending = make(map[string]*Job)
			}
		}
	}

	// Rebuild indexes; Unmarshal holds all shard locks so we only take pendingMtx here.
	w.pendingMtx.Lock()
	defer w.pendingMtx.Unlock()
	w.pendingBlocks = make(map[string]string)
	w.pendingByTenant = make(map[string]map[tempopb.JobType][]string)
	for i := range ShardCount {
		for _, j := range w.Shards[i].Pending {
			if key := j.PendingBlockKey(); key != "" {
				w.pendingBlocks[key] = j.ID
			}
			tenant := j.JobDetail.Tenant
			if w.pendingByTenant[tenant] == nil {
				w.pendingByTenant[tenant] = make(map[tempopb.JobType][]string)
			}
			w.pendingByTenant[tenant][j.Type] = append(w.pendingByTenant[tenant][j.Type], j.ID)
		}
	}

	w.runningBlocks = make(map[string]*Job)
	for i := range ShardCount {
		for _, j := range w.Shards[i].Jobs {