Merge pull request #3936 from hashicorp/f-remove-depgraph
Remove unused depgraph package
This commit is contained in:
Radek Simko
commit
48e1e96078
|
|
@ -1,46 +0,0 @@
|
||||||
package depgraph
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
|
|
||||||
"github.com/hashicorp/terraform/digraph"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Dependency is used to create a directed edge between two nouns.
|
|
||||||
// One noun may depend on another and provide version constraints
|
|
||||||
// that cannot be violated
|
|
||||||
type Dependency struct {
|
|
||||||
Name string
|
|
||||||
Meta interface{}
|
|
||||||
Constraints []Constraint
|
|
||||||
Source *Noun
|
|
||||||
Target *Noun
|
|
||||||
}
|
|
||||||
|
|
||||||
// Constraint is used by dependencies to allow arbitrary constraints
|
|
||||||
// between nouns
|
|
||||||
type Constraint interface {
|
|
||||||
Satisfied(head, tail *Noun) (bool, error)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Head returns the source, or dependent noun
|
|
||||||
func (d *Dependency) Head() digraph.Node {
|
|
||||||
return d.Source
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tail returns the target, or depended upon noun
|
|
||||||
func (d *Dependency) Tail() digraph.Node {
|
|
||||||
return d.Target
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Dependency) GoString() string {
|
|
||||||
return fmt.Sprintf(
|
|
||||||
"*Dependency{Name: %s, Source: %s, Target: %s}",
|
|
||||||
d.Name,
|
|
||||||
d.Source.Name,
|
|
||||||
d.Target.Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *Dependency) String() string {
|
|
||||||
return d.Name
|
|
||||||
}
|
|
||||||
|
|
@ -1,379 +0,0 @@
|
||||||
// The depgraph package is used to create and model a dependency graph
|
|
||||||
// of nouns. Each noun can represent a service, server, application,
|
|
||||||
// network switch, etc. Nouns can depend on other nouns, and provide
|
|
||||||
// versioning constraints. Nouns can also have various meta data that
|
|
||||||
// may be relevant to their construction or configuration.
|
|
||||||
package depgraph
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"fmt"
|
|
||||||
"sort"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"github.com/hashicorp/terraform/digraph"
|
|
||||||
)
|
|
||||||
|
|
||||||
// WalkFunc is the type used for the callback for Walk.
|
|
||||||
type WalkFunc func(*Noun) error
|
|
||||||
|
|
||||||
// Graph is used to represent a dependency graph.
|
|
||||||
type Graph struct {
|
|
||||||
Name string
|
|
||||||
Meta interface{}
|
|
||||||
Nouns []*Noun
|
|
||||||
Root *Noun
|
|
||||||
}
|
|
||||||
|
|
||||||
// ValidateError implements the Error interface but provides
|
|
||||||
// additional information on a validation error.
|
|
||||||
type ValidateError struct {
|
|
||||||
// If set, then the graph is missing a single root, on which
|
|
||||||
// there are no depdendencies
|
|
||||||
MissingRoot bool
|
|
||||||
|
|
||||||
// Unreachable are nodes that could not be reached from
|
|
||||||
// the root noun.
|
|
||||||
Unreachable []*Noun
|
|
||||||
|
|
||||||
// Cycles are groups of strongly connected nodes, which
|
|
||||||
// form a cycle. This is disallowed.
|
|
||||||
Cycles [][]*Noun
|
|
||||||
}
|
|
||||||
|
|
||||||
func (v *ValidateError) Error() string {
|
|
||||||
var msgs []string
|
|
||||||
|
|
||||||
if v.MissingRoot {
|
|
||||||
msgs = append(msgs, "The graph has no single root")
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, n := range v.Unreachable {
|
|
||||||
msgs = append(msgs, fmt.Sprintf(
|
|
||||||
"Unreachable node: %s", n.Name))
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, c := range v.Cycles {
|
|
||||||
cycleNodes := make([]string, len(c))
|
|
||||||
for i, n := range c {
|
|
||||||
cycleNodes[i] = n.Name
|
|
||||||
}
|
|
||||||
|
|
||||||
msgs = append(msgs, fmt.Sprintf(
|
|
||||||
"Cycle: %s", strings.Join(cycleNodes, " -> ")))
|
|
||||||
}
|
|
||||||
|
|
||||||
for i, m := range msgs {
|
|
||||||
msgs[i] = fmt.Sprintf("* %s", m)
|
|
||||||
}
|
|
||||||
|
|
||||||
return fmt.Sprintf(
|
|
||||||
"The dependency graph is not valid:\n\n%s",
|
|
||||||
strings.Join(msgs, "\n"))
|
|
||||||
}
|
|
||||||
|
|
||||||
// ConstraintError is used to return detailed violation
|
|
||||||
// information from CheckConstraints
|
|
||||||
type ConstraintError struct {
|
|
||||||
Violations []*Violation
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *ConstraintError) Error() string {
|
|
||||||
return fmt.Sprintf("%d constraint violations", len(c.Violations))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Violation is used to pass along information about
|
|
||||||
// a constraint violation
|
|
||||||
type Violation struct {
|
|
||||||
Source *Noun
|
|
||||||
Target *Noun
|
|
||||||
Dependency *Dependency
|
|
||||||
Constraint Constraint
|
|
||||||
Err error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (v *Violation) Error() string {
|
|
||||||
return fmt.Sprintf("Constraint %v between %v and %v violated: %v",
|
|
||||||
v.Constraint, v.Source, v.Target, v.Err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// CheckConstraints walks the graph and ensures that all
|
|
||||||
// user imposed constraints are satisfied.
|
|
||||||
func (g *Graph) CheckConstraints() error {
|
|
||||||
// Ensure we have a root
|
|
||||||
if g.Root == nil {
|
|
||||||
return fmt.Errorf("Graph must be validated before checking constraint violations")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a constraint error
|
|
||||||
cErr := &ConstraintError{}
|
|
||||||
|
|
||||||
// Walk from the root
|
|
||||||
digraph.DepthFirstWalk(g.Root, func(n digraph.Node) bool {
|
|
||||||
noun := n.(*Noun)
|
|
||||||
for _, dep := range noun.Deps {
|
|
||||||
target := dep.Target
|
|
||||||
for _, constraint := range dep.Constraints {
|
|
||||||
ok, err := constraint.Satisfied(noun, target)
|
|
||||||
if ok {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
violation := &Violation{
|
|
||||||
Source: noun,
|
|
||||||
Target: target,
|
|
||||||
Dependency: dep,
|
|
||||||
Constraint: constraint,
|
|
||||||
Err: err,
|
|
||||||
}
|
|
||||||
cErr.Violations = append(cErr.Violations, violation)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
})
|
|
||||||
|
|
||||||
if cErr.Violations != nil {
|
|
||||||
return cErr
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Noun returns the noun with the given name, or nil if it cannot be found.
|
|
||||||
func (g *Graph) Noun(name string) *Noun {
|
|
||||||
for _, n := range g.Nouns {
|
|
||||||
if n.Name == name {
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// String generates a little ASCII string of the graph, useful in
|
|
||||||
// debugging output.
|
|
||||||
func (g *Graph) String() string {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
|
|
||||||
// Alphabetize the output based on the noun name
|
|
||||||
keys := make([]string, 0, len(g.Nouns))
|
|
||||||
mapping := make(map[string]*Noun)
|
|
||||||
for _, n := range g.Nouns {
|
|
||||||
mapping[n.Name] = n
|
|
||||||
keys = append(keys, n.Name)
|
|
||||||
}
|
|
||||||
sort.Strings(keys)
|
|
||||||
|
|
||||||
if g.Root != nil {
|
|
||||||
buf.WriteString(fmt.Sprintf("root: %s\n", g.Root.Name))
|
|
||||||
} else {
|
|
||||||
buf.WriteString("root: <unknown>\n")
|
|
||||||
}
|
|
||||||
for _, k := range keys {
|
|
||||||
n := mapping[k]
|
|
||||||
buf.WriteString(fmt.Sprintf("%s\n", n.Name))
|
|
||||||
|
|
||||||
// Alphabetize the dependency names
|
|
||||||
depKeys := make([]string, 0, len(n.Deps))
|
|
||||||
depMapping := make(map[string]*Dependency)
|
|
||||||
for _, d := range n.Deps {
|
|
||||||
depMapping[d.Target.Name] = d
|
|
||||||
depKeys = append(depKeys, d.Target.Name)
|
|
||||||
}
|
|
||||||
sort.Strings(depKeys)
|
|
||||||
|
|
||||||
for _, k := range depKeys {
|
|
||||||
dep := depMapping[k]
|
|
||||||
buf.WriteString(fmt.Sprintf(
|
|
||||||
" %s -> %s\n",
|
|
||||||
dep.Source,
|
|
||||||
dep.Target))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return buf.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Validate is used to ensure that a few properties of the graph are not violated:
|
|
||||||
// 1) There must be a single "root", or source on which nothing depends.
|
|
||||||
// 2) All nouns in the graph must be reachable from the root
|
|
||||||
// 3) The graph must be cycle free, meaning there are no cicular dependencies
|
|
||||||
func (g *Graph) Validate() error {
|
|
||||||
// Convert to node list
|
|
||||||
nodes := make([]digraph.Node, len(g.Nouns))
|
|
||||||
for i, n := range g.Nouns {
|
|
||||||
nodes[i] = n
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a validate erro
|
|
||||||
vErr := &ValidateError{}
|
|
||||||
|
|
||||||
// Search for all the sources, if we have only 1, it must be the root
|
|
||||||
if sources := digraph.Sources(nodes); len(sources) != 1 {
|
|
||||||
vErr.MissingRoot = true
|
|
||||||
goto CHECK_CYCLES
|
|
||||||
} else {
|
|
||||||
g.Root = sources[0].(*Noun)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check reachability
|
|
||||||
if unreached := digraph.Unreachable(g.Root, nodes); len(unreached) > 0 {
|
|
||||||
vErr.Unreachable = make([]*Noun, len(unreached))
|
|
||||||
for i, u := range unreached {
|
|
||||||
vErr.Unreachable[i] = u.(*Noun)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
CHECK_CYCLES:
|
|
||||||
// Check for cycles
|
|
||||||
if cycles := digraph.StronglyConnectedComponents(nodes, true); len(cycles) > 0 {
|
|
||||||
vErr.Cycles = make([][]*Noun, len(cycles))
|
|
||||||
for i, cycle := range cycles {
|
|
||||||
group := make([]*Noun, len(cycle))
|
|
||||||
for j, n := range cycle {
|
|
||||||
group[j] = n.(*Noun)
|
|
||||||
}
|
|
||||||
vErr.Cycles[i] = group
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check for loops to yourself
|
|
||||||
for _, n := range g.Nouns {
|
|
||||||
for _, d := range n.Deps {
|
|
||||||
if d.Source == d.Target {
|
|
||||||
vErr.Cycles = append(vErr.Cycles, []*Noun{n})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return the detailed error
|
|
||||||
if vErr.MissingRoot || vErr.Unreachable != nil || vErr.Cycles != nil {
|
|
||||||
return vErr
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Walk will walk the tree depth-first (dependency first) and call
|
|
||||||
// the callback.
|
|
||||||
//
|
|
||||||
// The callbacks will be called in parallel, so if you need non-parallelism,
|
|
||||||
// then introduce a lock in your callback.
|
|
||||||
func (g *Graph) Walk(fn WalkFunc) error {
|
|
||||||
// Set so we don't callback for a single noun multiple times
|
|
||||||
var seenMapL sync.RWMutex
|
|
||||||
seenMap := make(map[*Noun]chan struct{})
|
|
||||||
seenMap[g.Root] = make(chan struct{})
|
|
||||||
|
|
||||||
// Keep track of what nodes errored.
|
|
||||||
var errMapL sync.RWMutex
|
|
||||||
errMap := make(map[*Noun]struct{})
|
|
||||||
|
|
||||||
// Build the list of things to visit
|
|
||||||
tovisit := make([]*Noun, 1, len(g.Nouns))
|
|
||||||
tovisit[0] = g.Root
|
|
||||||
|
|
||||||
// Spawn off all our goroutines to walk the tree
|
|
||||||
errCh := make(chan error)
|
|
||||||
for len(tovisit) > 0 {
|
|
||||||
// Grab the current thing to use
|
|
||||||
n := len(tovisit)
|
|
||||||
current := tovisit[n-1]
|
|
||||||
tovisit = tovisit[:n-1]
|
|
||||||
|
|
||||||
// Go through each dependency and run that first
|
|
||||||
for _, dep := range current.Deps {
|
|
||||||
if _, ok := seenMap[dep.Target]; !ok {
|
|
||||||
seenMapL.Lock()
|
|
||||||
seenMap[dep.Target] = make(chan struct{})
|
|
||||||
seenMapL.Unlock()
|
|
||||||
tovisit = append(tovisit, dep.Target)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Spawn off a goroutine to execute our callback once
|
|
||||||
// all our dependencies are satisfied.
|
|
||||||
go func(current *Noun) {
|
|
||||||
seenMapL.RLock()
|
|
||||||
closeCh := seenMap[current]
|
|
||||||
seenMapL.RUnlock()
|
|
||||||
|
|
||||||
defer close(closeCh)
|
|
||||||
|
|
||||||
// Wait for all our dependencies
|
|
||||||
for _, dep := range current.Deps {
|
|
||||||
seenMapL.RLock()
|
|
||||||
ch := seenMap[dep.Target]
|
|
||||||
seenMapL.RUnlock()
|
|
||||||
|
|
||||||
// Wait for the dep to be run
|
|
||||||
<-ch
|
|
||||||
|
|
||||||
// Check if any dependencies errored. If so,
|
|
||||||
// then return right away, we won't walk it.
|
|
||||||
errMapL.RLock()
|
|
||||||
_, errOk := errMap[dep.Target]
|
|
||||||
errMapL.RUnlock()
|
|
||||||
if errOk {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Call our callback!
|
|
||||||
if err := fn(current); err != nil {
|
|
||||||
errMapL.Lock()
|
|
||||||
errMap[current] = struct{}{}
|
|
||||||
errMapL.Unlock()
|
|
||||||
|
|
||||||
errCh <- err
|
|
||||||
}
|
|
||||||
}(current)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Aggregate channel that is closed when all goroutines finish
|
|
||||||
doneCh := make(chan struct{})
|
|
||||||
go func() {
|
|
||||||
defer close(doneCh)
|
|
||||||
|
|
||||||
for _, ch := range seenMap {
|
|
||||||
<-ch
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
// Wait for finish OR an error
|
|
||||||
select {
|
|
||||||
case <-doneCh:
|
|
||||||
return nil
|
|
||||||
case err := <-errCh:
|
|
||||||
// Drain the error channel
|
|
||||||
go func() {
|
|
||||||
for _ = range errCh {
|
|
||||||
// Nothing
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
// Wait for the goroutines to end
|
|
||||||
<-doneCh
|
|
||||||
close(errCh)
|
|
||||||
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// DependsOn returns the set of nouns that have a
|
|
||||||
// dependency on a given noun. This can be used to find
|
|
||||||
// the incoming edges to a noun.
|
|
||||||
func (g *Graph) DependsOn(n *Noun) []*Noun {
|
|
||||||
var incoming []*Noun
|
|
||||||
OUTER:
|
|
||||||
for _, other := range g.Nouns {
|
|
||||||
if other == n {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for _, d := range other.Deps {
|
|
||||||
if d.Target == n {
|
|
||||||
incoming = append(incoming, other)
|
|
||||||
continue OUTER
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return incoming
|
|
||||||
}
|
|
||||||
|
|
@ -1,467 +0,0 @@
|
||||||
package depgraph
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"reflect"
|
|
||||||
"sort"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
// ParseNouns is used to parse a string in the format of:
|
|
||||||
// a -> b ; edge name
|
|
||||||
// b -> c
|
|
||||||
// Into a series of nouns and dependencies
|
|
||||||
func ParseNouns(s string) map[string]*Noun {
|
|
||||||
lines := strings.Split(s, "\n")
|
|
||||||
nodes := make(map[string]*Noun)
|
|
||||||
for _, line := range lines {
|
|
||||||
var edgeName string
|
|
||||||
if idx := strings.Index(line, ";"); idx >= 0 {
|
|
||||||
edgeName = strings.Trim(line[idx+1:], " \t\r\n")
|
|
||||||
line = line[:idx]
|
|
||||||
}
|
|
||||||
parts := strings.SplitN(line, "->", 2)
|
|
||||||
if len(parts) != 2 {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
head_name := strings.Trim(parts[0], " \t\r\n")
|
|
||||||
tail_name := strings.Trim(parts[1], " \t\r\n")
|
|
||||||
head := nodes[head_name]
|
|
||||||
if head == nil {
|
|
||||||
head = &Noun{Name: head_name}
|
|
||||||
nodes[head_name] = head
|
|
||||||
}
|
|
||||||
tail := nodes[tail_name]
|
|
||||||
if tail == nil {
|
|
||||||
tail = &Noun{Name: tail_name}
|
|
||||||
nodes[tail_name] = tail
|
|
||||||
}
|
|
||||||
edge := &Dependency{
|
|
||||||
Name: edgeName,
|
|
||||||
Source: head,
|
|
||||||
Target: tail,
|
|
||||||
}
|
|
||||||
head.Deps = append(head.Deps, edge)
|
|
||||||
}
|
|
||||||
return nodes
|
|
||||||
}
|
|
||||||
|
|
||||||
func NounMapToList(m map[string]*Noun) []*Noun {
|
|
||||||
list := make([]*Noun, 0, len(m))
|
|
||||||
for _, n := range m {
|
|
||||||
list = append(list, n)
|
|
||||||
}
|
|
||||||
return list
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Noun(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
|
|
||||||
g := &Graph{
|
|
||||||
Name: "Test",
|
|
||||||
Nouns: NounMapToList(nodes),
|
|
||||||
}
|
|
||||||
|
|
||||||
n := g.Noun("a")
|
|
||||||
if n == nil {
|
|
||||||
t.Fatal("should not be nil")
|
|
||||||
}
|
|
||||||
if n.Name != "a" {
|
|
||||||
t.Fatalf("bad: %#v", n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_String(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
|
|
||||||
g := &Graph{
|
|
||||||
Name: "Test",
|
|
||||||
Nouns: NounMapToList(nodes),
|
|
||||||
Root: nodes["a"],
|
|
||||||
}
|
|
||||||
actual := g.String()
|
|
||||||
|
|
||||||
expected := `
|
|
||||||
root: a
|
|
||||||
a
|
|
||||||
a -> b
|
|
||||||
a -> c
|
|
||||||
b
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c
|
|
||||||
c -> d
|
|
||||||
c -> e
|
|
||||||
d
|
|
||||||
e
|
|
||||||
`
|
|
||||||
|
|
||||||
actual = strings.TrimSpace(actual)
|
|
||||||
expected = strings.TrimSpace(expected)
|
|
||||||
if actual != expected {
|
|
||||||
t.Fatalf("bad:\n%s\n!=\n%s", actual, expected)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Validate(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
if err := g.Validate(); err != nil {
|
|
||||||
t.Fatalf("err: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Validate_Cycle(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
d -> b`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
err := g.Validate()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("expected err")
|
|
||||||
}
|
|
||||||
|
|
||||||
vErr, ok := err.(*ValidateError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("expected validate error")
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(vErr.Cycles) != 1 {
|
|
||||||
t.Fatalf("expected cycles")
|
|
||||||
}
|
|
||||||
|
|
||||||
cycle := vErr.Cycles[0]
|
|
||||||
cycleNodes := make([]string, len(cycle))
|
|
||||||
for i, c := range cycle {
|
|
||||||
cycleNodes[i] = c.Name
|
|
||||||
}
|
|
||||||
sort.Strings(cycleNodes)
|
|
||||||
|
|
||||||
if cycleNodes[0] != "b" {
|
|
||||||
t.Fatalf("bad: %v", cycle)
|
|
||||||
}
|
|
||||||
if cycleNodes[1] != "d" {
|
|
||||||
t.Fatalf("bad: %v", cycle)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Validate_MultiRoot(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
c -> d`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
err := g.Validate()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("expected err")
|
|
||||||
}
|
|
||||||
|
|
||||||
vErr, ok := err.(*ValidateError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("expected validate error")
|
|
||||||
}
|
|
||||||
|
|
||||||
if !vErr.MissingRoot {
|
|
||||||
t.Fatalf("expected missing root")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Validate_NoRoot(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
b -> a`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
err := g.Validate()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("expected err")
|
|
||||||
}
|
|
||||||
|
|
||||||
vErr, ok := err.(*ValidateError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("expected validate error")
|
|
||||||
}
|
|
||||||
|
|
||||||
if !vErr.MissingRoot {
|
|
||||||
t.Fatalf("expected missing root")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Validate_Unreachable(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
x -> x`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
err := g.Validate()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("expected err")
|
|
||||||
}
|
|
||||||
|
|
||||||
vErr, ok := err.(*ValidateError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("expected validate error")
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(vErr.Unreachable) != 1 {
|
|
||||||
t.Fatalf("expected unreachable")
|
|
||||||
}
|
|
||||||
|
|
||||||
if vErr.Unreachable[0].Name != "x" {
|
|
||||||
t.Fatalf("bad: %v", vErr.Unreachable[0])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type VersionMeta int
|
|
||||||
type VersionConstraint struct {
|
|
||||||
Min int
|
|
||||||
Max int
|
|
||||||
}
|
|
||||||
|
|
||||||
func (v *VersionConstraint) Satisfied(head, tail *Noun) (bool, error) {
|
|
||||||
vers := int(tail.Meta.(VersionMeta))
|
|
||||||
if vers < v.Min {
|
|
||||||
return false, fmt.Errorf("version %d below minimum %d",
|
|
||||||
vers, v.Min)
|
|
||||||
} else if vers > v.Max {
|
|
||||||
return false, fmt.Errorf("version %d above maximum %d",
|
|
||||||
vers, v.Max)
|
|
||||||
}
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (v *VersionConstraint) String() string {
|
|
||||||
return "version"
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_ConstraintViolation(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
// Add a version constraint
|
|
||||||
vers := &VersionConstraint{1, 3}
|
|
||||||
|
|
||||||
// Introduce some constraints
|
|
||||||
depB := nodes["a"].Deps[0]
|
|
||||||
depB.Constraints = []Constraint{vers}
|
|
||||||
depC := nodes["a"].Deps[1]
|
|
||||||
depC.Constraints = []Constraint{vers}
|
|
||||||
|
|
||||||
// Add some versions
|
|
||||||
nodes["b"].Meta = VersionMeta(0)
|
|
||||||
nodes["c"].Meta = VersionMeta(4)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
err := g.Validate()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("err: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
err = g.CheckConstraints()
|
|
||||||
if err == nil {
|
|
||||||
t.Fatalf("Expected err")
|
|
||||||
}
|
|
||||||
|
|
||||||
cErr, ok := err.(*ConstraintError)
|
|
||||||
if !ok {
|
|
||||||
t.Fatalf("expected constraint error")
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(cErr.Violations) != 2 {
|
|
||||||
t.Fatalf("expected 2 violations: %v", cErr)
|
|
||||||
}
|
|
||||||
|
|
||||||
if cErr.Violations[0].Error() != "Constraint version between a and b violated: version 0 below minimum 1" {
|
|
||||||
t.Fatalf("err: %v", cErr.Violations[0])
|
|
||||||
}
|
|
||||||
|
|
||||||
if cErr.Violations[1].Error() != "Constraint version between a and c violated: version 4 above maximum 3" {
|
|
||||||
t.Fatalf("err: %v", cErr.Violations[1])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_Constraint_NoViolation(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
|
|
||||||
// Add a version constraint
|
|
||||||
vers := &VersionConstraint{1, 3}
|
|
||||||
|
|
||||||
// Introduce some constraints
|
|
||||||
depB := nodes["a"].Deps[0]
|
|
||||||
depB.Constraints = []Constraint{vers}
|
|
||||||
depC := nodes["a"].Deps[1]
|
|
||||||
depC.Constraints = []Constraint{vers}
|
|
||||||
|
|
||||||
// Add some versions
|
|
||||||
nodes["b"].Meta = VersionMeta(2)
|
|
||||||
nodes["c"].Meta = VersionMeta(3)
|
|
||||||
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
err := g.Validate()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("err: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
err = g.CheckConstraints()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("err: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraphWalk(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
if err := g.Validate(); err != nil {
|
|
||||||
t.Fatalf("err: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
var namesLock sync.Mutex
|
|
||||||
names := make([]string, 0, 0)
|
|
||||||
err := g.Walk(func(n *Noun) error {
|
|
||||||
namesLock.Lock()
|
|
||||||
defer namesLock.Unlock()
|
|
||||||
names = append(names, n.Name)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("err: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
expected := [][]string{
|
|
||||||
{"e", "d", "c", "b", "a"},
|
|
||||||
{"e", "d", "b", "c", "a"},
|
|
||||||
{"d", "e", "c", "b", "a"},
|
|
||||||
{"d", "e", "b", "c", "a"},
|
|
||||||
}
|
|
||||||
found := false
|
|
||||||
for _, expect := range expected {
|
|
||||||
if reflect.DeepEqual(expect, names) {
|
|
||||||
found = true
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if !found {
|
|
||||||
t.Fatalf("bad: %#v", names)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraphWalk_error(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
b -> c
|
|
||||||
a -> d
|
|
||||||
a -> e
|
|
||||||
e -> f
|
|
||||||
f -> g
|
|
||||||
g -> h`)
|
|
||||||
list := NounMapToList(nodes)
|
|
||||||
g := &Graph{Name: "Test", Nouns: list}
|
|
||||||
if err := g.Validate(); err != nil {
|
|
||||||
t.Fatalf("err: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// We repeat this a lot because sometimes timing causes
|
|
||||||
// a false positive.
|
|
||||||
for i := 0; i < 100; i++ {
|
|
||||||
var lock sync.Mutex
|
|
||||||
var walked []string
|
|
||||||
err := g.Walk(func(n *Noun) error {
|
|
||||||
lock.Lock()
|
|
||||||
defer lock.Unlock()
|
|
||||||
|
|
||||||
walked = append(walked, n.Name)
|
|
||||||
|
|
||||||
if n.Name == "b" {
|
|
||||||
return fmt.Errorf("foo")
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err == nil {
|
|
||||||
t.Fatal("should error")
|
|
||||||
}
|
|
||||||
|
|
||||||
sort.Strings(walked)
|
|
||||||
|
|
||||||
expected := []string{"b", "c", "d", "e", "f", "g", "h"}
|
|
||||||
if !reflect.DeepEqual(walked, expected) {
|
|
||||||
t.Fatalf("bad: %#v", walked)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraph_DependsOn(t *testing.T) {
|
|
||||||
nodes := ParseNouns(`a -> b
|
|
||||||
a -> c
|
|
||||||
b -> d
|
|
||||||
b -> e
|
|
||||||
c -> d
|
|
||||||
c -> e`)
|
|
||||||
|
|
||||||
g := &Graph{
|
|
||||||
Name: "Test",
|
|
||||||
Nouns: NounMapToList(nodes),
|
|
||||||
}
|
|
||||||
|
|
||||||
dNoun := g.Noun("d")
|
|
||||||
incoming := g.DependsOn(dNoun)
|
|
||||||
|
|
||||||
if len(incoming) != 2 {
|
|
||||||
t.Fatalf("bad: %#v", incoming)
|
|
||||||
}
|
|
||||||
|
|
||||||
var hasB, hasC bool
|
|
||||||
for _, in := range incoming {
|
|
||||||
switch in.Name {
|
|
||||||
case "b":
|
|
||||||
hasB = true
|
|
||||||
case "c":
|
|
||||||
hasC = true
|
|
||||||
default:
|
|
||||||
t.Fatalf("Bad: %#v", in)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if !hasB || !hasC {
|
|
||||||
t.Fatalf("missing incoming edge")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
package depgraph
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
|
|
||||||
"github.com/hashicorp/terraform/digraph"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Nouns are the key structure of the dependency graph. They can
|
|
||||||
// be used to represent all objects in the graph. They are linked
|
|
||||||
// by depedencies.
|
|
||||||
type Noun struct {
|
|
||||||
Name string // Opaque name
|
|
||||||
Meta interface{}
|
|
||||||
Deps []*Dependency
|
|
||||||
}
|
|
||||||
|
|
||||||
// Edges returns the out-going edges of a Noun
|
|
||||||
func (n *Noun) Edges() []digraph.Edge {
|
|
||||||
edges := make([]digraph.Edge, len(n.Deps))
|
|
||||||
for idx, dep := range n.Deps {
|
|
||||||
edges[idx] = dep
|
|
||||||
}
|
|
||||||
return edges
|
|
||||||
}
|
|
||||||
|
|
||||||
func (n *Noun) GoString() string {
|
|
||||||
return fmt.Sprintf("*%#v", *n)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (n *Noun) String() string {
|
|
||||||
return n.Name
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue