Method Validate

common/validation.go:264–310

()

}

func (s *SharedStateConfig) Validate() error {
	if s.Connector != nil {
		if err := s.Connector.Validate(); err != nil {
			return err
		}
	} else {
		return fmt.Errorf("sharedState.connector is required")
	}
	if s.FallbackTimeout == 0 {
		return fmt.Errorf("sharedState.fallbackTimeout is required")
	}
	if s.FallbackTimeout.Duration() < 100*time.Millisecond {
		return fmt.Errorf("sharedState.fallbackTimeout should be at least 100ms")
	}
	if s.LockTtl == 0 {
		return fmt.Errorf("sharedState.lockTtl is required")
	}
	if s.LockTtl.Duration() < 1*time.Second {
		return fmt.Errorf("sharedState.lockTtl should be at least 1s")
	}

	// Validate timeout relationships for the best-effort design
	fallbackTimeout := s.FallbackTimeout.Duration()
	lockTtl := s.LockTtl.Duration()
	lockMaxWait := s.LockMaxWait.Duration()
	updateMaxWait := s.UpdateMaxWait.Duration()

	// LockTtl should be long enough to complete remote operations (get + set)
	// It should be at least as long as FallbackTimeout to allow one remote operation
	if lockTtl < fallbackTimeout {
		return fmt.Errorf("sharedState.lockTtl (%v) should be at least as long as fallbackTimeout (%v) to complete remote operations",
			lockTtl, fallbackTimeout)
	}

	// LockMaxWait and UpdateMaxWait are foreground budgets and should be much smaller than network timeouts
	if lockMaxWait >= fallbackTimeout {
		return fmt.Errorf("sharedState.lockMaxWait (%v) should be less than fallbackTimeout (%v) as it's a foreground latency budget",
			lockMaxWait, fallbackTimeout)
	}

	if updateMaxWait >= fallbackTimeout {
		return fmt.Errorf("sharedState.updateMaxWait (%v) should be less than fallbackTimeout (%v) as it's a foreground latency budget",
			updateMaxWait, fallbackTimeout)
	}

	return nil
}

func (c *CacheConfig) Validate() error {
	existingIds := make(map[string]bool)