| // Copyright 2016 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package dep |
| |
| import ( |
| "bytes" |
| "io" |
| "sort" |
| |
| "github.com/golang/dep/gps" |
| "github.com/golang/dep/gps/verify" |
| "github.com/pelletier/go-toml" |
| "github.com/pkg/errors" |
| ) |
| |
| // LockName is the lock file name used by dep. |
| const LockName = "Gopkg.lock" |
| |
| // Lock holds lock file data and implements gps.Lock. |
| type Lock struct { |
| SolveMeta SolveMeta |
| P []gps.LockedProject |
| } |
| |
| // SolveMeta holds metadata about the solving process that created the lock that |
| // is not specific to any individual project. |
| type SolveMeta struct { |
| AnalyzerName string |
| AnalyzerVersion int |
| SolverName string |
| SolverVersion int |
| InputImports []string |
| } |
| |
| type rawLock struct { |
| SolveMeta solveMeta `toml:"solve-meta"` |
| Projects []rawLockedProject `toml:"projects"` |
| } |
| |
| type solveMeta struct { |
| AnalyzerName string `toml:"analyzer-name"` |
| AnalyzerVersion int `toml:"analyzer-version"` |
| SolverName string `toml:"solver-name"` |
| SolverVersion int `toml:"solver-version"` |
| InputImports []string `toml:"input-imports"` |
| } |
| |
| type rawLockedProject struct { |
| Name string `toml:"name"` |
| Branch string `toml:"branch,omitempty"` |
| Revision string `toml:"revision"` |
| Version string `toml:"version,omitempty"` |
| Source string `toml:"source,omitempty"` |
| Packages []string `toml:"packages"` |
| PruneOpts string `toml:"pruneopts"` |
| Digest string `toml:"digest"` |
| } |
| |
| func readLock(r io.Reader) (*Lock, error) { |
| buf := &bytes.Buffer{} |
| _, err := buf.ReadFrom(r) |
| if err != nil { |
| return nil, errors.Wrap(err, "Unable to read byte stream") |
| } |
| |
| raw := rawLock{} |
| err = toml.Unmarshal(buf.Bytes(), &raw) |
| if err != nil { |
| return nil, errors.Wrap(err, "Unable to parse the lock as TOML") |
| } |
| |
| return fromRawLock(raw) |
| } |
| |
| func fromRawLock(raw rawLock) (*Lock, error) { |
| l := &Lock{ |
| P: make([]gps.LockedProject, 0, len(raw.Projects)), |
| } |
| |
| l.SolveMeta.AnalyzerName = raw.SolveMeta.AnalyzerName |
| l.SolveMeta.AnalyzerVersion = raw.SolveMeta.AnalyzerVersion |
| l.SolveMeta.SolverName = raw.SolveMeta.SolverName |
| l.SolveMeta.SolverVersion = raw.SolveMeta.SolverVersion |
| l.SolveMeta.InputImports = raw.SolveMeta.InputImports |
| |
| for _, ld := range raw.Projects { |
| r := gps.Revision(ld.Revision) |
| |
| var v gps.Version = r |
| if ld.Version != "" { |
| if ld.Branch != "" { |
| return nil, errors.Errorf("lock file specified both a branch (%s) and version (%s) for %s", ld.Branch, ld.Version, ld.Name) |
| } |
| v = gps.NewVersion(ld.Version).Pair(r) |
| } else if ld.Branch != "" { |
| v = gps.NewBranch(ld.Branch).Pair(r) |
| } else if r == "" { |
| return nil, errors.Errorf("lock file has entry for %s, but specifies no branch or version", ld.Name) |
| } |
| |
| id := gps.ProjectIdentifier{ |
| ProjectRoot: gps.ProjectRoot(ld.Name), |
| Source: ld.Source, |
| } |
| |
| var err error |
| vp := verify.VerifiableProject{ |
| LockedProject: gps.NewLockedProject(id, v, ld.Packages), |
| } |
| if ld.Digest != "" { |
| vp.Digest, err = verify.ParseVersionedDigest(ld.Digest) |
| if err != nil { |
| return nil, err |
| } |
| } |
| |
| po, err := gps.ParsePruneOptions(ld.PruneOpts) |
| if err != nil { |
| return nil, errors.Errorf("%s in prune options for %s", err.Error(), ld.Name) |
| } |
| // Add the vendor pruning bit so that gps doesn't get confused |
| vp.PruneOpts = po | gps.PruneNestedVendorDirs |
| |
| l.P = append(l.P, vp) |
| } |
| |
| return l, nil |
| } |
| |
| // Projects returns the list of LockedProjects contained in the lock data. |
| func (l *Lock) Projects() []gps.LockedProject { |
| if l == nil || l == (*Lock)(nil) { |
| return nil |
| } |
| return l.P |
| } |
| |
| // InputImports reports the list of input imports that were used in generating |
| // this Lock. |
| func (l *Lock) InputImports() []string { |
| if l == nil || l == (*Lock)(nil) { |
| return nil |
| } |
| return l.SolveMeta.InputImports |
| } |
| |
| // HasProjectWithRoot checks if the lock contains a project with the provided |
| // ProjectRoot. |
| // |
| // This check is O(n) in the number of projects. |
| func (l *Lock) HasProjectWithRoot(root gps.ProjectRoot) bool { |
| for _, p := range l.P { |
| if p.Ident().ProjectRoot == root { |
| return true |
| } |
| } |
| |
| return false |
| } |
| |
| func (l *Lock) dup() *Lock { |
| l2 := &Lock{ |
| SolveMeta: l.SolveMeta, |
| P: make([]gps.LockedProject, len(l.P)), |
| } |
| |
| l2.SolveMeta.InputImports = make([]string, len(l.SolveMeta.InputImports)) |
| copy(l2.SolveMeta.InputImports, l.SolveMeta.InputImports) |
| copy(l2.P, l.P) |
| |
| return l2 |
| } |
| |
| // toRaw converts the manifest into a representation suitable to write to the lock file |
| func (l *Lock) toRaw() rawLock { |
| raw := rawLock{ |
| SolveMeta: solveMeta{ |
| AnalyzerName: l.SolveMeta.AnalyzerName, |
| AnalyzerVersion: l.SolveMeta.AnalyzerVersion, |
| InputImports: l.SolveMeta.InputImports, |
| SolverName: l.SolveMeta.SolverName, |
| SolverVersion: l.SolveMeta.SolverVersion, |
| }, |
| Projects: make([]rawLockedProject, 0, len(l.P)), |
| } |
| |
| sort.Slice(l.P, func(i, j int) bool { |
| return l.P[i].Ident().Less(l.P[j].Ident()) |
| }) |
| |
| for _, lp := range l.P { |
| id := lp.Ident() |
| ld := rawLockedProject{ |
| Name: string(id.ProjectRoot), |
| Source: id.Source, |
| Packages: lp.Packages(), |
| } |
| |
| v := lp.Version() |
| ld.Revision, ld.Branch, ld.Version = gps.VersionComponentStrings(v) |
| |
| // This will panic if the lock isn't the expected dynamic type. We can |
| // relax this later if it turns out to create real problems, but there's |
| // no intended case in which this is untrue, so it's preferable to start |
| // by failing hard if those expectations aren't met. |
| vp := lp.(verify.VerifiableProject) |
| ld.Digest = vp.Digest.String() |
| ld.PruneOpts = (vp.PruneOpts & ^gps.PruneNestedVendorDirs).String() |
| |
| raw.Projects = append(raw.Projects, ld) |
| } |
| |
| return raw |
| } |
| |
| // MarshalTOML serializes this lock into TOML via an intermediate raw form. |
| func (l *Lock) MarshalTOML() ([]byte, error) { |
| raw := l.toRaw() |
| var buf bytes.Buffer |
| enc := toml.NewEncoder(&buf).ArraysWithOneElementPerLine(true) |
| err := enc.Encode(raw) |
| return buf.Bytes(), errors.Wrap(err, "Unable to marshal lock to TOML string") |
| } |
| |
| // LockFromSolution converts a gps.Solution to dep's representation of a lock. |
| // It makes sure that that the provided prune options are set correctly, as the |
| // solver does not use VerifiableProjects for new selections it makes. |
| // |
| // Data is defensively copied wherever necessary to ensure the resulting *Lock |
| // shares no memory with the input solution. |
| func LockFromSolution(in gps.Solution, prune gps.CascadingPruneOptions) *Lock { |
| p := in.Projects() |
| |
| l := &Lock{ |
| SolveMeta: SolveMeta{ |
| AnalyzerName: in.AnalyzerName(), |
| AnalyzerVersion: in.AnalyzerVersion(), |
| InputImports: in.InputImports(), |
| SolverName: in.SolverName(), |
| SolverVersion: in.SolverVersion(), |
| }, |
| P: make([]gps.LockedProject, 0, len(p)), |
| } |
| |
| for _, lp := range p { |
| if vp, ok := lp.(verify.VerifiableProject); ok { |
| l.P = append(l.P, vp) |
| } else { |
| l.P = append(l.P, verify.VerifiableProject{ |
| LockedProject: lp, |
| PruneOpts: prune.PruneOptionsFor(lp.Ident().ProjectRoot), |
| }) |
| } |
| } |
| |
| return l |
| } |
