Merge pull request golang#21 from sdboyer/tracelog

Implement tracelog

Author: sdboyer

errors.go

@@ -22,6 +22,10 @@ type SolveError interface {
 	Children() []error
 }
 
+type traceError interface {
+	traceString() string
+}
+
 type solveError struct {
 	lvl errorLevel
 	msg string
@@ -54,6 +58,24 @@ func (e *noVersionError) Error() string {
 	return buf.String()
 }
 
+func (e *noVersionError) traceString() string {
+	if len(e.fails) == 0 {
+		return fmt.Sprintf("No versions found")
+	}
+
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "No versions of %s met constraints:", e.pn.LocalName)
+	for _, f := range e.fails {
+		if te, ok := f.f.(traceError); ok {
+			fmt.Fprintf(&buf, "\n  %s: %s", f.v, te.traceString())
+		} else {
+			fmt.Fprintf(&buf, "\n  %s: %s", f.v, f.f.Error())
+		}
+	}
+
+	return buf.String()
+}
+
 type disjointConstraintFailure struct {
 	goal      Dependency
 	failsib   []Dependency
@@ -64,7 +86,7 @@ type disjointConstraintFailure struct {
 func (e *disjointConstraintFailure) Error() string {
 	if len(e.failsib) == 1 {
 		str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which has no overlap with existing constraint %s from %s at %s"
-		return fmt.Sprintf(str, e.goal.Depender.Ident, e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String(), e.failsib[0].Dep.Constraint.String(), e.failsib[0].Depender.Ident, e.failsib[0].Depender.Version)
+		return fmt.Sprintf(str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String(), e.failsib[0].Dep.Constraint.String(), e.failsib[0].Depender.Ident.errString(), e.failsib[0].Depender.Version)
 	}
 
 	var buf bytes.Buffer
@@ -74,16 +96,29 @@ func (e *disjointConstraintFailure) Error() string {
 		sibs = e.failsib
 
 		str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which has no overlap with the following existing constraints:\n"
-		fmt.Fprintf(&buf, str, e.goal.Depender.Ident, e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String())
+		fmt.Fprintf(&buf, str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String())
 	} else {
 		sibs = e.nofailsib
 
 		str := "Could not introduce %s at %s, as it has a dependency on %s with constraint %s, which does not overlap with the intersection of existing constraints from other currently selected packages:\n"
-		fmt.Fprintf(&buf, str, e.goal.Depender.Ident, e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String())
+		fmt.Fprintf(&buf, str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint.String())
 	}
 
 	for _, c := range sibs {
-		fmt.Fprintf(&buf, "\t%s at %s with constraint %s\n", c.Depender.Ident, c.Depender.Version, c.Dep.Constraint.String())
+		fmt.Fprintf(&buf, "\t%s from %s at %s\n", c.Dep.Constraint.String(), c.Depender.Ident.errString(), c.Depender.Version)
+	}
+
+	return buf.String()
+}
+
+func (e *disjointConstraintFailure) traceString() string {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "constraint %s on %s disjoint with other dependers:\n", e.goal.Dep.Constraint.String(), e.goal.Dep.Ident.errString())
+	for _, f := range e.failsib {
+		fmt.Fprintf(&buf, "%s from %s at %s (no overlap)\n", f.Dep.Constraint.String(), f.Depender.Ident.LocalName, f.Depender.Version)
+	}
+	for _, f := range e.nofailsib {
+		fmt.Fprintf(&buf, "%s from %s at %s (some overlap)\n", f.Dep.Constraint.String(), f.Depender.Ident.LocalName, f.Depender.Version)
 	}
 
 	return buf.String()
@@ -102,6 +137,11 @@ func (e *constraintNotAllowedFailure) Error() string {
 	return fmt.Sprintf(str, e.goal.Depender.Ident.errString(), e.goal.Depender.Version, e.goal.Dep.Ident.errString(), e.goal.Dep.Constraint, e.v)
 }
 
+func (e *constraintNotAllowedFailure) traceString() string {
+	str := "%s at %s depends on %s with %s, but that's already selected at %s"
+	return fmt.Sprintf(str, e.goal.Depender.Ident.LocalName, e.goal.Depender.Version, e.goal.Dep.Ident.LocalName, e.goal.Dep.Constraint, e.v)
+}
+
 type versionNotAllowedFailure struct {
 	goal       ProjectAtom
 	failparent []Dependency
@@ -111,16 +151,27 @@ type versionNotAllowedFailure struct {
 func (e *versionNotAllowedFailure) Error() string {
 	if len(e.failparent) == 1 {
 		str := "Could not introduce %s at %s, as it is not allowed by constraint %s from project %s."
-		return fmt.Sprintf(str, e.goal.Ident, e.goal.Version, e.failparent[0].Dep.Constraint.String(), e.failparent[0].Depender.Ident)
+		return fmt.Sprintf(str, e.goal.Ident.errString(), e.goal.Version, e.failparent[0].Dep.Constraint.String(), e.failparent[0].Depender.Ident.errString())
 	}
 
 	var buf bytes.Buffer
 
 	str := "Could not introduce %s at %s, as it is not allowed by constraints from the following projects:\n"
-	fmt.Fprintf(&buf, str, e.goal.Ident, e.goal.Version)
+	fmt.Fprintf(&buf, str, e.goal.Ident.errString(), e.goal.Version)
+
+	for _, f := range e.failparent {
+		fmt.Fprintf(&buf, "\t%s from %s at %s\n", f.Dep.Constraint.String(), f.Depender.Ident.errString(), f.Depender.Version)
+	}
+
+	return buf.String()
+}
 
+func (e *versionNotAllowedFailure) traceString() string {
+	var buf bytes.Buffer
+
+	fmt.Fprintf(&buf, "%s at %s not allowed by constraint %s:\n", e.goal.Ident.LocalName, e.goal.Version, e.c.String())
 	for _, f := range e.failparent {
-		fmt.Fprintf(&buf, "\t%s at %s with constraint %s\n", f.Depender.Ident, f.Depender.Version, f.Dep.Constraint.String())
+		fmt.Fprintf(&buf, "  %s from %s at %s\n", f.Dep.Constraint.String(), f.Depender.Ident.LocalName, f.Depender.Version)
 	}
 
 	return buf.String()
@@ -157,3 +208,15 @@ func (e *sourceMismatchFailure) Error() string {
 	str := "Could not introduce %s at %s, as it depends on %s from %s, but %s is already marked as coming from %s by %s"
 	return fmt.Sprintf(str, e.prob.Ident.errString(), e.prob.Version, e.shared, e.mismatch, e.shared, e.current, strings.Join(cur, ", "))
 }
+
+func (e *sourceMismatchFailure) traceString() string {
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "disagreement on network addr for %s:\n", e.shared)
+
+	fmt.Fprintf(&buf, "  %s from %s\n", e.mismatch, e.prob.Ident.errString())
+	for _, dep := range e.sel {
+		fmt.Fprintf(&buf, "  %s from %s\n", e.current, dep.Depender.Ident.errString())
+	}
+
+	return buf.String()
+}

glide.lock

@@ -4,10 +4,6 @@ import:
   version: 2.x
   vtype: branch
   vcs: git
-- package: github.com/Sirupsen/logrus
-  version: 0.10.0
-  vtype: semver
-  vcs: git
 - package: github.com/Masterminds/vcs
   vcs: git
 - package: github.com/termie/go-shutil

glide.yaml

@@ -1,7 +1,5 @@
 package vsolver
 
-import "github.com/Sirupsen/logrus"
-
 // satisfiable is the main checking method. It determines if introducing a new
 // project atom would result in a state where all solver requirements are still
 // satisfied.
@@ -12,13 +10,6 @@ func (s *solver) satisfiable(pa ProjectAtom) error {
 		panic("canary - checking version of empty ProjectAtom")
 	}
 
-	if s.l.Level >= logrus.DebugLevel {
-		s.l.WithFields(logrus.Fields{
-			"name":    pa.Ident,
-			"version": pa.Version,
-		}).Debug("Checking satisfiability of project atom against current constraints")
-	}
-
 	if err := s.checkAtomAllowable(pa); err != nil {
 		return err
 	}
@@ -33,7 +24,6 @@ func (s *solver) satisfiable(pa ProjectAtom) error {
 		if err := s.checkIdentMatches(pa, dep); err != nil {
 			return err
 		}
-		// TODO dart skips "magic" deps here; do we need that?
 		if err := s.checkDepsConstraintsAllowable(pa, dep); err != nil {
 			return err
 		}
@@ -44,13 +34,6 @@ func (s *solver) satisfiable(pa ProjectAtom) error {
 		// TODO add check that fails if adding this atom would create a loop
 	}
 
-	if s.l.Level >= logrus.DebugLevel {
-		s.l.WithFields(logrus.Fields{
-			"name":    pa.Ident,
-			"version": pa.Version,
-		}).Debug("Project atom passed satisfiability test against current state")
-	}
-
 	return nil
 }
 
@@ -63,35 +46,23 @@ func (s *solver) checkAtomAllowable(pa ProjectAtom) error {
 	}
 	// TODO collect constraint failure reason
 
-	if s.l.Level >= logrus.InfoLevel {
-		s.l.WithFields(logrus.Fields{
-			"name":          pa.Ident,
-			"version":       pa.Version,
-			"curconstraint": constraint.String(),
-		}).Info("Current constraints do not allow version")
-	}
-
 	deps := s.sel.getDependenciesOn(pa.Ident)
 	var failparent []Dependency
 	for _, dep := range deps {
 		if !dep.Dep.Constraint.Matches(pa.Version) {
-			if s.l.Level >= logrus.DebugLevel {
-				s.l.WithFields(logrus.Fields{
-					"name":       pa.Ident,
-					"othername":  dep.Depender.Ident,
-					"constraint": dep.Dep.Constraint.String(),
-				}).Debug("Marking other, selected project with conflicting constraint as failed")
-			}
 			s.fail(dep.Depender.Ident)
 			failparent = append(failparent, dep)
 		}
 	}
 
-	return &versionNotAllowedFailure{
+	err := &versionNotAllowedFailure{
 		goal:       pa,
 		failparent: failparent,
 		c:          constraint,
 	}
+
+	s.logSolve(err)
+	return err
 }
 
 // checkDepsConstraintsAllowable checks that the constraints of an atom on a
@@ -104,44 +75,27 @@ func (s *solver) checkDepsConstraintsAllowable(pa ProjectAtom, dep ProjectDep) e
 		return nil
 	}
 
-	if s.l.Level >= logrus.DebugLevel {
-		s.l.WithFields(logrus.Fields{
-			"name":          pa.Ident,
-			"version":       pa.Version,
-			"depname":       dep.Ident,
-			"curconstraint": constraint.String(),
-			"newconstraint": dep.Constraint.String(),
-		}).Debug("Project atom cannot be added; its constraints are disjoint with existing constraints")
-	}
-
 	siblings := s.sel.getDependenciesOn(dep.Ident)
 	// No admissible versions - visit all siblings and identify the disagreement(s)
 	var failsib []Dependency
 	var nofailsib []Dependency
 	for _, sibling := range siblings {
 		if !sibling.Dep.Constraint.MatchesAny(dep.Constraint) {
-			if s.l.Level >= logrus.DebugLevel {
-				s.l.WithFields(logrus.Fields{
-					"name":          pa.Ident,
-					"version":       pa.Version,
-					"depname":       sibling.Depender.Ident,
-					"sibconstraint": sibling.Dep.Constraint.String(),
-					"newconstraint": dep.Constraint.String(),
-				}).Debug("Marking other, selected project as failed because its constraint is disjoint with our testee")
-			}
 			s.fail(sibling.Depender.Ident)
 			failsib = append(failsib, sibling)
 		} else {
 			nofailsib = append(nofailsib, sibling)
 		}
 	}
 
-	return &disjointConstraintFailure{
+	err := &disjointConstraintFailure{
 		goal:      Dependency{Depender: pa, Dep: dep},
 		failsib:   failsib,
 		nofailsib: nofailsib,
 		c:         constraint,
 	}
+	s.logSolve(err)
+	return err
 }
 
 // checkDepsDisallowsSelected ensures that an atom's constraints on a particular
@@ -150,21 +104,14 @@ func (s *solver) checkDepsConstraintsAllowable(pa ProjectAtom, dep ProjectDep) e
 func (s *solver) checkDepsDisallowsSelected(pa ProjectAtom, dep ProjectDep) error {
 	selected, exists := s.sel.selected(dep.Ident)
 	if exists && !dep.Constraint.Matches(selected.Version) {
-		if s.l.Level >= logrus.DebugLevel {
-			s.l.WithFields(logrus.Fields{
-				"name":          pa.Ident,
-				"version":       pa.Version,
-				"depname":       dep.Ident,
-				"curversion":    selected.Version,
-				"newconstraint": dep.Constraint.String(),
-			}).Debug("Project atom cannot be added; a constraint it introduces does not allow a currently selected version")
-		}
 		s.fail(dep.Ident)
 
-		return &constraintNotAllowedFailure{
+		err := &constraintNotAllowedFailure{
 			goal: Dependency{Depender: pa, Dep: dep},
 			v:    selected.Version,
 		}
+		s.logSolve(err)
+		return err
 	}
 	return nil
 }
@@ -174,18 +121,27 @@ func (s *solver) checkDepsDisallowsSelected(pa ProjectAtom, dep ProjectDep) erro
 // been selected).
 //
 // In other words, this ensures that the solver never simultaneously selects two
-// identifiers that disagree about where their upstream source is.
+// identifiers with the same local name, but that disagree about where their
+// network source is.
 func (s *solver) checkIdentMatches(pa ProjectAtom, dep ProjectDep) error {
 	if cur, exists := s.names[dep.Ident.LocalName]; exists {
 		if cur != dep.Ident.netName() {
 			deps := s.sel.getDependenciesOn(pa.Ident)
-			return &sourceMismatchFailure{
+			// Fail all the other deps, as there's no way atom can ever be
+			// compatible with them
+			for _, d := range deps {
+				s.fail(d.Depender.Ident)
+			}
+
+			err := &sourceMismatchFailure{
 				shared:   dep.Ident.LocalName,
 				sel:      deps,
 				current:  cur,
 				mismatch: dep.Ident.netName(),
 				prob:     pa,
 			}
+			s.logSolve(err)
+			return err
 		}
 	}