Basic lockfile support

gxutil/lckfile.go

@@ -0,0 +1,28 @@
+package gxutil
+
+import (
+	"encoding/json"
+	"io/ioutil"
+)
+
+type LockDep struct {
+	// full ipfs path /ipfs/<hash>/foo
+	Ref string
+
+	// Mapping of dvcs import paths to LockData
+	Deps map[string]LockDep
+}
+
+type LockFile struct {
+	Language string
+	Deps     map[string]LockDep
+}
+
+func LoadLockFile(lck *LockFile, fname string) error {
+	data, err := ioutil.ReadFile(fname)
+	if err != nil {
+		return err
+	}
+
+	return json.Unmarshal(data, lck)
+}

gxutil/pm.go

@@ -22,6 +22,7 @@ import (
 const GxVersion = "0.12.1"
 
 const PkgFileName = "package.json"
+const LckFileName = "gx-lock.json"
 
 var installPathsCache map[string]string
 var binarySuffix string
@@ -155,6 +156,73 @@ func (pm *PM) InstallDeps(pkg *Package, location string) error {
 	return pm.installDeps(pkg, location, make(map[string]bool))
 }
 
+// InstallDeps recursively installs all dependencies for the given package
+func (pm *PM) InstallLock(lck *LockFile, location string) error {
+	return pm.installLock(lck, location, make(map[string]bool))
+}
+
+func (pm *PM) installLock(lck *LockFile, location string, complete map[string]bool) error {
+	done := make(chan LockDep)
+	errs := make(chan error)
+	ratelim := make(chan struct{}, 2)
+	var count int
+	pm.ProgMeter.AddTodos(len(lck.Deps))
+	for dvcsPath, dep := range lck.Deps {
+		if complete[dvcsPath] {
+			pm.ProgMeter.MarkDone()
+			continue
+		}
+
+		count++
+
+		go func(i int, dep LockDep, dvcsPath string) {
+			ratelim <- struct{}{}
+			VLog("installing %s", dvcsPath)
+			defer func() { <-ratelim }()
+			pm.ProgMeter.AddEntry(dep.Ref, dvcsPath, "[fetch]   <ELAPSED>"+dep.Ref)
+
+			var final error
+			for i := 0; i < 4; i++ {
+				_, final = pm.GetPackageTo(dep.Ref, fmt.Sprintf("%s/%s", location, dvcsPath))
+				if final == nil {
+					break
+				}
+
+				if !isTempError(final) {
+					break
+				}
+
+				time.Sleep(time.Millisecond * 200 * time.Duration(i+1))
+			}
+			if final != nil {
+				pm.ProgMeter.Error(dep.Ref, final.Error())
+				errs <- fmt.Errorf("failed to fetch package: %s: %s", dep.Ref, final)
+				return
+			}
+
+			pm.ProgMeter.Finish(dep.Ref)
+
+			done <- dep
+		}(count, dep, dvcsPath)
+	}
+
+	var failed bool
+	for i := 0; i < count; i++ {
+		select {
+		case <-done:
+		case err := <-errs:
+			Error("[%d / %d ] parallel fetch: %s", i+1, len(lck.Deps), err)
+			failed = true
+		}
+	}
+
+	if failed {
+		return errors.New("failed to fetch dependencies")
+	}
+
+	return nil
+}
+
 func (pm *PM) SetProgMeter(meter *prog.ProgMeter) {
 	pm.ProgMeter = meter
 }

main.go

@@ -27,6 +27,26 @@ var (
 )
 
 const PkgFileName = gx.PkgFileName
+const LckFileName = gx.LckFileName
+
+func LoadLockFile(path string) (*gx.LockFile, error) {
+	if path == LckFileName {
+		root, err := gx.GetPackageRoot()
+		if err != nil {
+			return nil, err
+		}
+
+		path = filepath.Join(root, LckFileName)
+	}
+
+	var lck gx.LockFile
+	err := gx.LoadLockFile(&lck, path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &lck, nil
+}
 
 func LoadPackageFile(path string) (*gx.Package, error) {
 	if path == PkgFileName {
@@ -111,6 +131,7 @@ func main() {
 		DiffCommand,
 		InitCommand,
 		InstallCommand,
+		LockInstallCommand,
 		PublishCommand,
 		ReleaseCommand,
 		RepoCommand,
@@ -822,6 +843,35 @@ var depCheckCommand = cli.Command{
 	},
 }
 
+var LockInstallCommand = cli.Command{
+	Name:  "lock-install",
+	Usage: "Install deps from lockfile into vendor",
+	Action: func(c *cli.Context) error {
+		lck, err := LoadLockFile(LckFileName)
+		if err != nil {
+			return err
+		}
+
+		pm.ProgMeter = progmeter.NewProgMeter(c.Bool("nofancy"))
+
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+
+		ipath, err := gx.InstallPath(lck.Language, cwd, false)
+		if err != nil {
+			return err
+		}
+
+		if err := pm.InstallLock(lck, ipath); err != nil {
+			return fmt.Errorf("install deps: %s", err)
+		}
+
+		return nil
+	},
+}
+
 var CleanCommand = cli.Command{
 	Name:  "clean",
 	Usage: "cleanup unused packages in vendor directory",