Function buildLockSystemInfos

internal/lock/resolve.go:168–212

(pkg *searcher.PackageVersion)

}

func buildLockSystemInfos(pkg *searcher.PackageVersion) (map[string]*SystemInfo, error) {
	// guard against missing search data
	systems := lo.PickBy(pkg.Systems, func(sysName string, sysInfo searcher.PackageInfo) bool {
		return sysInfo.StoreHash != "" && sysInfo.StoreName != ""
	})

	group, ctx := errgroup.WithContext(context.Background())

	var storePathLock sync.RWMutex
	sysStorePaths := map[string]string{}
	for _sysName, _sysInfo := range systems {
		sysName := _sysName // capture range variable
		sysInfo := _sysInfo // capture range variable

		group.Go(func() error {
			// We should use devpkg.BinaryCache here, but it'll cause a circular reference
			// Just hardcoding for now. Maybe we should move that to nix.DefaultBinaryCache?
			path, err := nix.StorePathFromHashPart(ctx, sysInfo.StoreHash, "https://cache.nixos.org")
			if err != nil {
				// Should we report this to sentry to collect data?
				slog.Error("failed to resolve store path", "system", sysName, "store_hash", sysInfo.StoreHash, "err", err)
				// Instead of erroring, we can just skip this package. It can install via the slow path.
				return nil
			}
			storePathLock.Lock()
			sysStorePaths[sysName] = path
			storePathLock.Unlock()
			return nil
		})
	}
	err := group.Wait()
	if err != nil {
		return nil, err
	}

	sysInfos := map[string]*SystemInfo{}
	for sysName, storePath := range sysStorePaths {
		sysInfo := &SystemInfo{
			StorePath: storePath,
		}
		sysInfo.addOutputFromLegacyStorePath()
		sysInfos[sysName] = sysInfo
	}
	return sysInfos, nil
}

func lockFlake(ctx context.Context, ref flake.Ref, refresh bool) (flake.Ref, error) {
	if ref.Locked() {