Call resolve from Package FromPath getter; use nix.Package in template

Author: savil

internal/lock/interfaces.go

@@ -18,5 +18,4 @@ type Locker interface {
 	resolver
 	LegacyNixpkgsPath(string) string
 	ProjectDir() string
-	SystemInfo(pkg string) (*SystemInfo, error)
 }

internal/lock/lockfile.go

@@ -129,33 +129,6 @@ func (l *File) Resolve(pkg string) (*Package, error) {
 	return l.Packages[pkg], nil
 }
 
-func (l *File) SystemInfo(pkgVersionedName string) (*SystemInfo, error) {
-	if !featureflag.RemoveNixpkgs.Enabled() {
-		return nil, nil
-	}
-
-	pkg, ok := l.Packages[pkgVersionedName]
-	if !ok {
-		return nil, errors.Errorf("package %s not found in lockfile", pkgVersionedName)
-	}
-
-	if sysInfo, ok := pkg.Systems[l.system]; ok {
-		// Found it! We are done.
-		return sysInfo, nil
-	}
-
-	// If the systemInfo is missing, then resolve the package to get it from the search api.
-	var err error
-	pkg, err = l.Resolve(pkgVersionedName)
-	if err != nil {
-		return nil, err
-	}
-	if sysInfo, ok := pkg.Systems[l.system]; ok {
-		return sysInfo, nil
-	}
-	return nil, errors.Errorf("Unable to get system %s info for package %s", l.system, pkgVersionedName)
-}
-
 func (l *File) ForceResolve(pkg string) (*Package, error) {
 	delete(l.Packages, pkg)
 	return l.Resolve(pkg)

internal/nix/input.go

@@ -13,10 +13,10 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/pkg/errors"
 	"github.com/samber/lo"
 	"go.jetpack.io/devbox/internal/boxcli/usererr"
 	"go.jetpack.io/devbox/internal/cuecfg"
-	"go.jetpack.io/devbox/internal/debug"
 	"go.jetpack.io/devbox/internal/lock"
 )
 
@@ -42,9 +42,6 @@ type Package struct {
 	Raw string
 
 	normalizedPackageAttributePathCache string // memoized value from normalizedPackageAttributePath()
-
-	// sysInfo contains system-specific information about this package in the nix store
-	sysInfo *lock.SystemInfo
 }
 
 // PackageFromStrings constructs Package from the list of package names provided.
@@ -82,17 +79,6 @@ func PackageFromString(raw string, locker lock.Locker) *Package {
 		lockfile:                            locker,
 		Raw:                                 raw,
 		normalizedPackageAttributePathCache: "",
-		sysInfo:                             nil,
-	}
-
-	if pkg.isVersioned() {
-		sysInfo, err := locker.SystemInfo(raw)
-		if err != nil {
-			// ignoring for coding convenience. TODO savil. handle error
-			debug.Log("ERROR: failed to get locker.SystemInfo for pkg %s. Error is %s", raw, err)
-		} else if sysInfo != nil {
-			pkg.sysInfo = sysInfo
-		}
 	}
 
 	return pkg
@@ -421,16 +407,51 @@ func (p *Package) version() string {
 	return version
 }
 
+// TODO savil. In next PR, change all callers to IsVersioned. Not doing it in
+// this PR to keep the diff scoped.
 func (p *Package) isVersioned() bool {
 	return p.isDevboxPackage() && strings.Contains(p.Path, "@")
 }
 
+func (p *Package) IsVersioned() bool {
+	return p.isVersioned()
+}
+
 func (p *Package) hashFromNixPkgsURL() string {
 	return HashFromNixPkgsURL(p.URLForFlakeInput())
 }
 
-func (p *Package) SystemInfo() *lock.SystemInfo {
-	return p.sysInfo
+// BinaryCacheStore is the store from which to fetch this package's binaries.
+// It is used as FromStore in builts.fetchClosure.
+const BinaryCacheStore = "https://cache.nixos.org"
+
+func (p *Package) IsInFromBinaryStore() bool {
+	return p.isVersioned()
+}
+
+// PathInBinaryStore is the key in the BinaryCacheStore for this package
+func (p *Package) PathInBinaryStore() (string, error) {
+	if !p.IsInFromBinaryStore() {
+		return "", errors.Errorf("Package %q cannot be fetched from binary cache store", p.Raw)
+	}
+
+	entry, err := p.lockfile.Resolve(p.Raw)
+	if err != nil {
+		return "", err
+	}
+
+	userSystem, err := System()
+	if err != nil {
+		return "", err
+	}
+
+	sysInfo := entry.Systems[userSystem]
+	storeDirParts := []string{sysInfo.FromHash, sysInfo.StoreName}
+	if sysInfo.StoreVersion != "" {
+		storeDirParts = append(storeDirParts, sysInfo.StoreVersion)
+	}
+	storeDir := strings.Join(storeDirParts, "-")
+	return filepath.Join("/nix/store", storeDir), nil
 }
 
 // IsGithubNixpkgsURL returns true if the package is a flake of the form:

internal/nix/input_test.go

@@ -131,10 +131,6 @@ func (l *lockfile) Resolve(pkg string) (*lock.Package, error) {
 	}
 }
 
-func (l *lockfile) SystemInfo(pkg string) (*lock.SystemInfo, error) {
-	return nil, nil
-}
-
 func testInputFromString(s, projectDir string) *testInput {
 	return lo.ToPtr(testInput{Package: *PackageFromString(s, &lockfile{projectDir})})
 }

internal/shellgen/flake_input.go

@@ -65,31 +65,21 @@ func (f *flakeInput) BuildInputs() []string {
 // i.e. have a commit hash and always resolve to the same package/version.
 // Note: inputs returned by this function include plugin packages. (php only for now)
 // It's not entirely clear we always want to add plugin packages to the top level
-func flakeInputs(ctx context.Context, devbox devboxer) ([]*flakeInput, error) {
+func flakeInputs(ctx context.Context, packages []*nix.Package) ([]*flakeInput, error) {
 	defer trace.StartRegion(ctx, "flakeInputs").End()
 
 	// Use the verbose name flakeInputs to distinguish from `inputs`
 	// which refer to `nix.Input` in most of the codebase.
 	flakeInputs := map[string]*flakeInput{}
 
-	userInputs := devbox.PackagesAsInputs()
-	pluginInputs, err := devbox.PluginManager().PluginInputs(userInputs)
-	if err != nil {
-		return nil, err
-	}
-
-	// We prioritize plugin packages so that the php plugin works. Not sure
-	// if this is behavior we want for user plugins. We may need to add an optional
-	// priority field to the config.
-	allInputs := append(pluginInputs, userInputs...)
-	allInputs = lo.Filter(allInputs, func(item *nix.Package, _ int) bool {
-		// This is temporary, so that we can support the existing flake.nix.tmpl
-		// as well as the new flake_remove_nixpkgs.nix.tmpl.
-		return !featureflag.RemoveNixpkgs.Enabled() || item.SystemInfo() == nil
+	packages = lo.Filter(packages, func(item *nix.Package, _ int) bool {
+		// Include packages (like local or remote flakes) that cannot be
+		// fetched from a Binary Cache Store.
+		return !featureflag.RemoveNixpkgs.Enabled() || !item.IsInFromBinaryStore()
 	})
 
 	order := []string{}
-	for _, input := range allInputs {
+	for _, input := range packages {
 		AttributePath, err := input.FullPackageAttributePath()
 		if err != nil {
 			return nil, err

internal/shellgen/flake_package.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"runtime/trace"
 
+	"github.com/samber/lo"
 	"go.jetpack.io/devbox/internal/nix"
 )
 
@@ -12,7 +13,7 @@ import (
 type flakePlan struct {
 	NixpkgsInfo *NixpkgsInfo
 	FlakeInputs []*flakeInput
-	Packages    []*flakePackage
+	Packages    []*nix.Package
 	System      string
 }
 
@@ -39,17 +40,25 @@ func newFlakePlan(ctx context.Context, devbox devboxer) (*flakePlan, error) {
 		}
 	}
 
-	var err error
-	flakeInputs, err := flakeInputs(ctx, devbox)
+	userPackages := devbox.PackagesAsInputs()
+	pluginPackages, err := devbox.PluginManager().PluginInputs(userPackages)
 	if err != nil {
 		return nil, err
 	}
+	// We prioritize plugin packages so that the php plugin works. Not sure
+	// if this is behavior we want for user plugins. We may need to add an optional
+	// priority field to the config.
+	packages := append(pluginPackages, userPackages...)
 
-	flakePackages, err := flakePackages(devbox)
+	flakeInputs, err := flakeInputs(ctx, packages)
 	if err != nil {
 		return nil, err
 	}
 
+	versionedPackages := lo.Filter(packages, func(pkg *nix.Package, _ int) bool {
+		return pkg.IsInFromBinaryStore()
+	})
+
 	nixpkgsInfo := getNixpkgsInfo(devbox.Config().NixPkgsCommitHash())
 
 	// This is an optimization. Try to reuse the nixpkgs info from the flake
@@ -69,7 +78,7 @@ func newFlakePlan(ctx context.Context, devbox devboxer) (*flakePlan, error) {
 	return &flakePlan{
 		FlakeInputs: flakeInputs,
 		NixpkgsInfo: nixpkgsInfo,
-		Packages:    flakePackages,
+		Packages:    versionedPackages,
 		System:      system,
 	}, nil
 }

internal/shellgen/flake_plan.go

@@ -19,17 +19,17 @@
        let
           pkgs = nixpkgs.legacyPackages.{{ .System }};
           {{- range $_, $pkg := .Packages }}
-          {{ $pkg.Name }}.{{ $.System }} = builtins.fetchClosure{
-             fromStore = "{{ $pkg.FromStore }}";
-             fromPath = "{{ $pkg.FromPath }}";
+          {{ $pkg.PackageAttributePath }}.{{ $.System }} = builtins.fetchClosure{
+             fromStore = "{{ $pkg.BinaryCacheStore }}";
+             fromPath = "{{ $pkg.PathInBinaryStore }}";
           };
           {{- end }}
        in
        {
          devShells.{{ .System }}.default = pkgs.mkShell {
            buildInputs = [
              {{- range $_, $pkg := .Packages }}
-             {{ $pkg.Name }}.{{ $.System }}
+             {{ $pkg.PackageAttributePath }}.{{ $.System }}
              {{- end }}
              {{- range $_, $flake := .FlakeInputs }}
              {{- range $flake.BuildInputs }}