func main() { var t toscalib.ServiceTemplateDefinition err := t.Parse(os.Stdin) if err != nil { log.Fatal(err) } // Creates a new graph g := gographviz.NewGraph() g.AddAttr("", "rankdir", "LR") g.SetName("G") g.SetDir(true) e := toscaexec.GeneratePlaybook(t) for i, p := range e.Index { g.AddNode("G", fmt.Sprintf("%v", i), map[string]string{ "id": fmt.Sprintf("\"%v\"", i), "label": fmt.Sprintf("\"%v|%v\"", p.NodeTemplate.Name, p.OperationName), "shape": "\"record\"", }) } l := e.AdjacencyMatrix.Dim() for r := 0; r < l; r++ { for c := 0; c < l; c++ { if e.AdjacencyMatrix.At(r, c) == 1 { g.AddEdge(fmt.Sprintf("%v", r), fmt.Sprintf("%v", c), true, nil) } } } log.Println("here") s := g.String() fmt.Println(s) /* d, _ := yaml.Marshal(e) fmt.Println(string(d)) */ /* for i, n := range e.Index { log.Printf("[%v] %v:%v -> %v %v", i, n.NodeTemplate.Name, n.OperationName, n.NodeTemplate.Interfaces[n.InterfaceName].Operations[n.OperationName].Implementation, n.NodeTemplate.Interfaces[n.InterfaceName].Operations[n.OperationName].Inputs, ) } */ }
func DotTrie(name string, json bool) (string, error) { var err error Zk = datamodel.Zk.Conn ZC := zCfg{map[string]Pool{}, map[string]Rule{}, map[string]Trie{}} Edges := Edges{map[string]bool{}, map[string]bool{}, map[string]bool{}} graph := ggv.NewGraph() graph.SetName(graphName) graph.SetDir(true) result := zkGraph{graph, &ZC, &Edges} if name == "all" { err = ZC.ParseAllTrie() } else { err = ZC.ParseWholeTrie(name) } if err != nil { return "{}", err } str, err := ZC.ToJSON() if err != nil { return "{}", err } if json { return str, nil } str = result.JSONtoDot(str) return str, nil }
func (nn NeuralNetwork) CreateGraph() string { graph := graphviz.NewGraph() graph.SetDir(true) graph.SetName("NeuralNetwork") for layerIndex, layer := range nn.layers { for i, neuron := range layer.neurons { name := nodeName(layerIndex, i) attrs := make(map[string]string) if neuron.bias != 0.0 { attrs["label"] = label(name, neuron.bias) } graph.AddNode(name, name, attrs) } for b, neuron := range layer.neurons { for a, weight := range neuron.weights { if weight != 0.0 { attrs := make(map[string]string) attrs["label"] = fmt.Sprintf("%v", weight) aLabel := nodeName(layerIndex-1, a) bLabel := nodeName(layerIndex, b) graph.AddEdge(aLabel, bLabel, true, attrs) } } } } return graph.String() }
func TestDFSAlmostEmptyGraph(t *testing.T) { g := ggv.NewGraph() g.SetName("G") g.AddNode("G", "N1", nil) g.SetDir(true) nodeToOutEdges := map[string][]*ggv.Edge{} buffer := new(bytes.Buffer) mockPathStringer := new(mockPathStringer) anythingType := mock.AnythingOfType("map[string]*gographviz.Node") mockPathStringer.On("pathAsString", []ggv.Edge{}, anythingType).Return("").Once() searcherWithTestStringer := &defaultSearcher{ pathStringer: mockPathStringer, } searcherWithTestStringer.dfs(searchArgs{ root: "N1", path: []ggv.Edge{}, nodeToOutEdges: nodeToOutEdges, nameToNodes: g.Nodes.Lookup, buffer: buffer, statusMap: make(map[string]discoveryStatus), }) correctOutput := "" actualOutput := buffer.String() assert.Equal(t, correctOutput, actualOutput) mockPathStringer.AssertExpectations(t) }
// GraphAsText is the standard implementation of Grapher func (g *defaultGrapher) GraphAsText(dotText []byte) (string, error) { graphAst, err := parser.ParseBytes(dotText) if err != nil { return "", err } dag := ggv.NewGraph() // A directed acyclic graph ggv.Analyse(graphAst, dag) if len(dag.Edges.Edges) == 0 { return "", errNoActivity } nodeToOutEdges := g.collectionGetter.generateNodeToOutEdges(dag) inDegreeZeroNodes := g.collectionGetter.getInDegreeZeroNodes(dag) nameToNodes := dag.Nodes.Lookup buffer := new(bytes.Buffer) statusMap := make(map[string]discoveryStatus) for _, root := range inDegreeZeroNodes { g.searcher.dfs(searchArgs{ root: root, path: nil, nodeToOutEdges: nodeToOutEdges, nameToNodes: nameToNodes, buffer: buffer, statusMap: statusMap, }) } return buffer.String(), nil }
func (this *DotSerializer) Deserialize(data []byte) (*DAG, error) { ast, err := dotparser.ParseBytes(data) if err != nil { return nil, err } graph := dot.NewGraph() dot.Analyse(ast, graph) p := NewDAG(graph.Name) for src, dests := range graph.Edges.SrcToDsts { for dest, _ := range dests { if orig, ok := p.Jobs[src]; !ok { n := dotNameToDAGJob(graph, src) n.Post = append(n.Post, dest) p.Jobs[src] = n } else { orig.Post = append(orig.Post, dest) } if orig, ok := p.Jobs[dest]; !ok { n := dotNameToDAGJob(graph, dest) n.Prev = append(n.Prev, src) p.Jobs[dest] = n } else { orig.Prev = append(orig.Prev, src) } if _, ok := p.InDegrees[src]; !ok { p.InDegrees[src] = 0 } if orig, ok := p.InDegrees[dest]; !ok { p.InDegrees[dest] = 1 } else { p.InDegrees[dest] = orig + 1 } } } for _, edge := range graph.Edges.Edges { if v, ok := edge.Attrs["nonstrict"]; ok { nonstrict, err := util.StringToBool(strings.Trim(v, "\"")) if err != nil { log.Error(err) return nil, err } if len(edge.Src) != 0 && len(edge.Dst) != 0 { r := NewRelation() r.NonStrict = nonstrict if _, ok := p.Relations[edge.Src]; !ok { p.Relations[edge.Src] = make(map[string]*Relation) } p.Relations[edge.Src][edge.Dst] = r } } } return p, nil }
func newGraph(name string) *gographviz.Graph { g := gographviz.NewGraph() g.SetName(name) g.SetDir(true) g.AddAttr(name, "rankdir", "BT") // g.AddAttr(name, "ordering", "in") return g }
func printDotGraph(functions []uint16) { brAttr1 := make(map[string]string) //brAttr1["label"] = "T" brAttr1["color"] = "green" brAttr2 := make(map[string]string) brAttr2["color"] = "red" //brAttr2["label"] = "F" for _, addr := range functions { b := blockMap[addr] fn := gographviz.NewGraph() //fname := "\""+b.fnString()+"\"" fname := b.fnString() fn.SetName(fname) fn.SetDir(true) fn.SetStrict(true) // DFS visited := make(map[uint16]bool) var s stack s.Put(addr) for !s.Empty() { a := s.Pop() if !visited[a] { visited[a] = true fn.AddNode(fname, blockMap[a].addrString(), blockMap[a].getAttributes()) if len(blockMap[a].branches) == 1 { if blockMap[blockMap[a].branches[0]] != nil { fn.AddEdge(blockMap[a].addrString(), blockMap[blockMap[a].branches[0]].addrString(), true, nil) if !visited[blockMap[a].branches[0]] { s.Put(blockMap[a].branches[0]) } } } if len(blockMap[a].branches) == 2 { if blockMap[blockMap[a].branches[1]] != nil { fn.AddEdge(blockMap[a].addrString(), blockMap[blockMap[a].branches[1]].addrString(), true, brAttr2) if !visited[blockMap[a].branches[1]] { s.Put(blockMap[a].branches[1]) } } if blockMap[blockMap[a].branches[0]] != nil { fn.AddEdge(blockMap[a].addrString(), blockMap[blockMap[a].branches[0]].addrString(), true, brAttr1) if !visited[blockMap[a].branches[0]] { s.Put(blockMap[a].branches[0]) } } } } } saveGraph(fn) } }
func TestGetInDegreeZeroNodesEmptyGraph(t *testing.T) { g := ggv.NewGraph() g.SetName("G") g.SetDir(true) var correctInDegreeZeroNodes []string actualInDegreeZeroNodes := new(defaultCollectionGetter).getInDegreeZeroNodes(g) assert.Equal(t, correctInDegreeZeroNodes, actualInDegreeZeroNodes) }
func TestGenerateNodeToOutEdgesEmptyGraph(t *testing.T) { g := ggv.NewGraph() g.SetName("G") g.SetDir(true) correctNodeToOutEdges := make(map[string][]*ggv.Edge) actualNodeToOutEdges := new(defaultCollectionGetter).generateNodeToOutEdges(g) assert.Equal(t, correctNodeToOutEdges, actualNodeToOutEdges) }
func GenerateDotString(res []struct { ANAME string BNAME string AID int BID int RELKIND string RELID int URLS []string }, attrs url.Values) string { attrs.Del("url") attrs.Del("r") // split our slice in a slice with only nodes and a slice with only rels var splitAt int for index, row := range res { if row.BNAME != "" { splitAt = index break } } graphName := "nodes" g := gographviz.NewGraph() g.SetName(graphName) g.SetDir(true) g.AddAttr(graphName, "size", "\"15,1000\"") g.AddAttr(graphName, "ratio", "compress") for k := range attrs { g.AddAttr(graphName, k, attrs.Get(k)) } // add nodes for _, row := range res[:splitAt] { g.AddNode(graphName, strconv.Itoa(row.AID), map[string]string{ "id": strconv.Itoa(row.AID), "label": nodeTable(row.ANAME, row.URLS), "shape": "box", "fontname": "Verdana", "fontsize": "9", }) } // add edges for _, row := range res[splitAt:] { g.AddEdge(strconv.Itoa(row.AID), strconv.Itoa(row.BID), true, map[string]string{ "id": strconv.Itoa(row.RELID), "label": row.RELKIND, "dir": relationshipDir(row.RELKIND), "tooltip": row.RELKIND, "fontname": "Verdana", "fontsize": "9", }) } return g.String() }
func (n *Node) Graph() string { g := gographviz.NewGraph() g.SetName("Tree") g.SetDir(true) g.AddNode("Tree", "root", nil) n.addToGraph(g, "root") return g.String() }
func (n *Node) ToGraphViz() string { graphAst, _ := parser.ParseString(`digraph NestedSet {}`) graph := gographviz.NewGraph() gographviz.Analyse(graphAst, graph) n.addToGraphViz(graph, "NestedSet", "") output := graph.String() return output }
// The returned graph, represented in ascii: // +----------+ // | Ignoreme | // +----------+ // +----+ +----------+ // | N2 | <-- | N1 | // +----+ +----------+ // | // | // v // +----------+ // | N3 | // +----------+ func testGraphWithClusterNodes() *ggv.Graph { g := ggv.NewGraph() g.SetName("G") g.SetDir(true) g.AddNode("G", "N1", nil) g.AddNode("G", "N2", nil) g.AddNode("G", "N3", nil) g.AddNode("G", "Ignore me!", nil) g.AddEdge("N1", "N2", true, nil) g.AddEdge("N1", "N3", true, nil) return g }
// The returned graph, represented in ascii: // +----+ // | N1 | -+ // +----+ | // | | // | | // v | // +----+ | // | N2 | | // +----+ | // | | // | | // v | // +----+ | // | N3 | | // +----+ | // | | // | | // v | // +----+ | // | N4 | <+ // +----+ func testGraphWithTooltip() *ggv.Graph { g := ggv.NewGraph() g.SetName("G") g.SetDir(true) g.AddNode("G", "N1", map[string]string{"tooltip": "function1"}) g.AddNode("G", "N2", map[string]string{"tooltip": "function2"}) g.AddNode("G", "N3", map[string]string{"tooltip": "function3"}) g.AddNode("G", "N4", map[string]string{"tooltip": "function4"}) g.AddEdge("N1", "N2", true, nil) g.AddEdge("N2", "N3", true, nil) g.AddEdge("N3", "N4", true, nil) g.AddEdge("N1", "N4", true, nil) return g }
// The returned graph, represented in ascii: // +----+ +----+ // | N4 | <-- | N1 | -+ // +----+ +----+ | // | | | // | | | // | v | // | +----+ | // | | N2 | | // | +----+ | // | | | // | | | // | v | // | +----+ | // +------> | N3 | <+ // +----+ func testSingleRootGraph() *ggv.Graph { g := ggv.NewGraph() g.SetName("G") g.SetDir(true) g.AddNode("G", "N1", nil) g.AddNode("G", "N2", nil) g.AddNode("G", "N3", nil) g.AddNode("G", "N4", nil) g.AddEdge("N1", "N2", true, nil) g.AddEdge("N2", "N3", true, nil) g.AddEdge("N4", "N3", true, nil) g.AddEdge("N1", "N4", true, nil) g.AddEdge("N1", "N3", true, nil) return g }
func visualize(data *Data) { graphAst, _ := parser.ParseString(`digraph G {}`) g := gographviz.NewGraph() gographviz.Analyse(graphAst, g) // step1 : add nodes for node := range data.NodeMap { g.AddNode("G", node.ID, nil) } // step2 : make edge from source node to target node for _, edge := range data.GetEdges() { g.AddEdge(edge.Src.ID, edge.Dst.ID, true, nil) } output := g.String() fmt.Println(output) }
// The returned graph, represented in ascii: // +----+ +----+ // +> | N4 | <-- | N1 | // | +----+ +----+ // | ^ | // | | | // | | v // | | +----+ // | +------- | N2 | <+ // | +----+ | // | | | // | | | // | v | // | +----+ | // +------------ | N3 | | // +----+ | // | | // | | // v | // +----+ | // | N5 | -+ // +----+ func testGraphWithCycles() *ggv.Graph { g := ggv.NewGraph() g.SetName("G") g.SetDir(true) g.AddNode("G", "N1", nil) g.AddNode("G", "N2", nil) g.AddNode("G", "N3", nil) g.AddNode("G", "N4", nil) g.AddNode("G", "N5", nil) g.AddEdge("N1", "N2", true, nil) g.AddEdge("N1", "N4", true, nil) g.AddEdge("N2", "N3", true, nil) g.AddEdge("N2", "N4", true, nil) g.AddEdge("N3", "N4", true, nil) g.AddEdge("N3", "N5", true, nil) g.AddEdge("N5", "N2", true, nil) return g }
func printFunctionGraph(fgraph map[uint16]map[uint16]bool) { fn := gographviz.NewGraph() fname := "Functions" fn.SetName(fname) fn.SetDir(true) fn.SetStrict(true) for fnaddr := range fgraph { fn.AddNode(fname, f(fnaddr), nil) //TODO for calledfn := range fgraph[fnaddr] { fn.AddEdge(f(fnaddr), f(calledfn), true, nil) } } saveGraph(fn) }
func main() { // Creates a new graph g := gographviz.NewGraph() g.AddAttr("", "rankdir", "LR") // Now read the json input var v orchestrator.Graph dec := json.NewDecoder(os.Stdin) if err := dec.Decode(&v); err != nil { panic(err) } // Now for each node, create a node g.SetName(v.Name) g.SetDir(true) m := make(map[int]string) // Now add every node for i, _ := range v.Nodes { v.Nodes[i].Name = strings.Replace(v.Nodes[i].Name, "-", "_", -1) v.Nodes[i].Name = strings.Replace(v.Nodes[i].Name, ":", "_Method", -1) g.AddNode("G", v.Nodes[i].Name, map[string]string{ "id": fmt.Sprintf("\"%v\"", strconv.Itoa(v.Nodes[i].ID)), "label": fmt.Sprintf("\"%v|%v|%v|%v\"", v.Nodes[i].Name, v.Nodes[i].Engine, v.Nodes[i].Artifact, v.Nodes[i].Args), "shape": "\"record\"", }) m[v.Nodes[i].ID] = v.Nodes[i].Name } l := v.Digraph.Dim() for r := 0; r < l; r++ { for c := 0; c < l; c++ { if v.Digraph.At(r, c) == 1 { g.AddEdge(m[r], m[c], true, nil) } } } // Now add the edges //g.AddEdge("Hello", "World", true, nil) s := g.String() fmt.Println(s) }
func main() { var ( bytes []byte data map[string]service err error graph *gographviz.Graph project string ) logger = stdlog.GetFromFlags() project = "" // Load docker-compose.yml bytes, err = ioutil.ReadFile("docker-compose.yml") if err != nil { abort(err.Error()) } // Parse it as YML data = make(map[string]service, 5) yaml.Unmarshal(bytes, &data) if err != nil { abort(err.Error()) } // Create directed graph graph = gographviz.NewGraph() graph.SetName(project) graph.SetDir(true) // Add legend graph.AddSubGraph(project, "cluster_legend", map[string]string{"label": "Legend"}) graph.AddNode("cluster_legend", "legend_service", map[string]string{"label": "service"}) graph.AddNode("cluster_legend", "legend_service_with_ports", map[string]string{ "label": "\"service with exposed ports\\n80:80 443:443\\n--volume1[:host_dir1]\\n--volume2[:host_dir2]\"", "shape": "box"}) graph.AddEdge("legend_service", "legend_service_with_ports", true, map[string]string{"label": "links"}) graph.AddEdge("legend_service_with_ports", "legend_service", true, map[string]string{"label": "volumes_from", "style": "dashed"}) // Round one: populate nodes for name, service := range data { var attrs = map[string]string{"label": name} if service.Ports != nil { attrs["label"] += "\\n" + strings.Join(service.Ports, " ") attrs["shape"] = "box" } if service.Volumes != nil { attrs["label"] += "\\n--" + strings.Join(service.Volumes, "\\n--") } attrs["label"] = fmt.Sprintf("\"%s\"", attrs["label"]) graph.AddNode(project, name, attrs) } // Round two: populate connections for name, service := range data { // links if service.Links != nil { for _, linkTo := range service.Links { if strings.Contains(linkTo, ":") { linkTo = strings.Split(linkTo, ":")[0] } graph.AddEdge(name, linkTo, true, nil) } } // volumes_from if service.VolumesFrom != nil { for _, linkTo := range service.VolumesFrom { graph.AddEdge(name, linkTo, true, map[string]string{"style": "dotted"}) } } } fmt.Print(graph) }
func generateSvg(id string) ([]byte, error) { template, err := template.New("node").Parse(`{{define "NODE"}}<<table border="0" cellspacing="0"> <tr ><td colspan="2" port="port1" border="1" bgcolor="lightblue">{{.Name}}</td></tr> <tr ><td colspan="2" port="port2" border="1">{{.Target}}</td></tr> <tr> <td port="port2" border="1">{{.Engine}}</td> <td port="port8" border="1">{{.Artifact}}</td> </tr> {{range .Args}} <tr ><td colspan="2" port="port2" border="1">{{.}}</td></tr> {{end}} <tr ><td colspan="2" port="port2" border="1">{{.Outputs}}</td></tr> </table>>{{end}}`) // Creates a new graph g := gographviz.NewGraph() //g.AddAttr("", "rankdir", "LR") // Now read the json input var v orchestrator.Graph resp, err := http.Get(fmt.Sprintf("%v/%v", OrchestratorUrl, id)) if err != nil { return nil, err } defer resp.Body.Close() //body, err := ioutil.ReadAll(resp.Body) dec := json.NewDecoder(resp.Body) if err := dec.Decode(&v); err != nil { return nil, err } // Now for each node, create a node g.SetName("Execution") g.SetDir(true) m := make(map[int]string) // Now add every node // Hack: If node has no Engine and no Artiface, and if sum(row)=sum(col)=0, skip it for i, _ := range v.Nodes { sumr := int64(0) sumc := int64(0) for r := 0; r < v.Digraph.Dim(); r++ { sumr = sumr + v.Digraph.At(v.Nodes[i].ID, r) sumc = sumc + v.Digraph.At(r, v.Nodes[i].ID) } if v.Nodes[i].Artifact == "" && sumr == 0 && sumc == 0 { continue } tmp := make([]string, 2) v.Nodes[i].Name = strings.Replace(v.Nodes[i].Name, "-", "_", -1) tmp = strings.SplitAfter(v.Nodes[i].Name, ":") v.Nodes[i].Name = strings.Replace(v.Nodes[i].Name, ":", "_", -1) if len(tmp) != 2 { tmp[0] = v.Nodes[i].Name tmp = append(tmp, "") } var out bytes.Buffer err = template.ExecuteTemplate(&out, "NODE", v.Nodes[i]) g.AddNode("G", v.Nodes[i].Name, map[string]string{ "id": fmt.Sprintf("\"%v\"", strconv.Itoa(v.Nodes[i].ID)), //"label": fmt.Sprintf("\"%v|%v\"", tmp[0], tmp[1]), "label": out.String(), //"label": fmt.Sprintf("\"%v|%v|%v|%v|%v\"", tmp[0], tmp[1], v.Nodes[i].Engine, v.Nodes[i].Artifact, v.Nodes[i].Args[:]), "shape": "\"record\"", "style": "\"rounded\"", }) m[v.Nodes[i].ID] = v.Nodes[i].Name } for r := 0; r < v.Digraph.Dim(); r++ { for c := 0; c < v.Digraph.Dim(); c++ { if v.Digraph.At(r, c) != 0 { //g.AddEdge(fmt.Sprintf("%v:%v", m[r], r), fmt.Sprintf("%v:%v", m[c], c), true, nil) g.AddEdge(m[r], m[c], true, nil) } } } // Now add the edges s := g.String() d := exec.Command("dot", "-Tsvg") // Set the stdin stdout and stderr of the dot subprocess stdinOfDotProcess, err := d.StdinPipe() if err != nil { return nil, err } defer stdinOfDotProcess.Close() // the doc says subProcess.Wait will close it, but I'm not sure, so I kept this line readCloser, err := d.StdoutPipe() if err != nil { return nil, err } d.Stderr = os.Stderr // Actually run the dot subprocess if err = d.Start(); err != nil { //Use start, not run fmt.Println("An error occured: ", err) //replace with logger, or anything you want } fmt.Fprintf(stdinOfDotProcess, s) stdinOfDotProcess.Close() // Read from stdout and store it in the correct structure var buf bytes.Buffer buf.ReadFrom(readCloser) err = d.Wait() if err != nil { fmt.Println(s) } return buf.Bytes(), nil }
// RunBuildChain contains all the necessary functionality for the OpenShift // experimental build-chain command func RunBuildChain(f *clientcmd.Factory, cmd *cobra.Command, args []string) error { all := cmdutil.GetFlagBool(cmd, "all") allTags := cmdutil.GetFlagBool(cmd, "all-tags") if len(args) > 1 || (len(args) == 1 && all) || (len(args) == 0 && allTags) || (all && allTags) { return cmdutil.UsageError(cmd, "Must pass nothing, an ImageStream name:tag combination, or specify the --all flag") } oc, _, err := f.Clients() if err != nil { return err } // Retrieve namespace(s) namespace := cmdutil.GetFlagString(cmd, "namespace") if len(namespace) == 0 { namespace, err = f.DefaultNamespace() if err != nil { return err } } namespaces := make([]string, 0) if all { projectList, err := oc.Projects().List(labels.Everything(), fields.Everything()) if err != nil { return err } for _, project := range projectList.Items { glog.V(4).Infof("Found namespace %s", project.Name) namespaces = append(namespaces, project.Name) } } if len(namespaces) == 0 { namespaces = append(namespaces, namespace) } // Get all build configurations buildConfigList := make([]buildapi.BuildConfig, 0) for _, namespace := range namespaces { cfgList, err := oc.BuildConfigs(namespace).List(labels.Everything(), fields.Everything()) if err != nil { return err } buildConfigList = append(buildConfigList, cfgList.Items...) } // Parse user input and validate specified image stream streams := make(map[string][]string) if !all && len(args) != 0 { name, specifiedTag, err := parseTag(args[0]) if err != nil { return err } // Validate the specified image stream is, err := oc.ImageStreams(namespace).Get(name) if err != nil { return err } stream := join(namespace, name) // Validate specified tag tags := make([]string, 0) exists := false for tag := range is.Status.Tags { tags = append(tags, tag) if specifiedTag == tag { exists = true } } if !exists && !allTags { // The specified tag isn't a part of our image stream return fmt.Errorf("no tag %s exists in %s", specifiedTag, stream) } else if !allTags { // Use only the specified tag tags = []string{specifiedTag} } // Set the specified stream as the only one to output dependencies for streams[stream] = tags } else { streams = getStreams(buildConfigList) } if len(streams) == 0 { return fmt.Errorf("no ImageStream available for building its dependency tree") } output := cmdutil.GetFlagString(cmd, "output") for stream, tags := range streams { for _, tag := range tags { glog.V(4).Infof("Checking dependencies of stream %s tag %s", stream, tag) root, err := findStreamDeps(stream, tag, buildConfigList) if err != nil { return err } // Check if the given image stream doesn't have any dependencies if treeSize(root) < 2 { glog.Infof("%s:%s has no dependencies\n", root.FullName, tag) continue } switch output { case "json": jsonDump, err := json.MarshalIndent(root, "", "\t") if err != nil { return err } fmt.Println(string(jsonDump)) case "dot": g := dot.NewGraph() _, name, err := split(stream) if err != nil { return err } graphName := validDOT(name) g.SetName(graphName) // Directed graph since we illustrate dependencies g.SetDir(true) // Explicitly allow multiple pairs of edges between // the same pair of nodes g.SetStrict(false) out, err := dotDump(root, g, graphName) if err != nil { return err } fmt.Println(out) case "ast": fmt.Println(root) default: return cmdutil.UsageError(cmd, "Wrong output format specified: %s", output) } } } return nil }
func main() { pDoGame := flag.Bool("game", false, "start the game") flag.Parse() rcsv("data/neurons.csv", func(records []string) { newEmptyNeuron(records[0], records, 5, BODY) }) rcsv("data/connectome.csv", func(records []string) { weight, err := strconv.ParseInt(records[3], 10, 32) if err != nil { log.Fatal(err) } ID_TO_NEURON[records[0]].connect(ID_TO_NEURON[records[1]], int32(weight)) }) rcsv("data/fake_motor.csv", func(records []string) { weight, err := strconv.ParseInt(records[3], 10, 32) if err != nil { log.Fatal(err) } if records[1] == "LEFT" { ID_TO_NEURON[records[0]].connect(BODY.left, int32(weight)) } else if records[1] == "RIGHT" { ID_TO_NEURON[records[0]].connect(BODY.right, int32(weight)) } }) for _, v := range ID_TO_NEURON { v.ticker() } http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) { q := r.URL.RawQuery if n, ok := ID_TO_NEURON[r.URL.RawQuery]; ok { n.ping(30) fmt.Fprintf(w, "nReceived: %d", n.nReceived) } else { http.Error(w, fmt.Sprintf("missing neuron: %s", q), 404) } }) http.HandleFunc("/debug", func(w http.ResponseWriter, r *http.Request) { DEBUG = !DEBUG fmt.Fprintf(w, "current: %#v", DEBUG) }) http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { graphAst, _ := parser.ParseString(`digraph G {}`) graph := gv.NewGraph() graph.SetDir(true) for _, v := range ID_TO_NEURON { if v.activity() > 0 { graph.AddNode("G", v.id(), nil) for _, c := range v.connections { graph.AddNode("G", c.to.id(), nil) graph.AddEdge(v.id(), c.to.id(), true, nil) } } } gv.Analyse(graphAst, graph) output := graph.String() fmt.Fprintf(w, output) }) go func() { log.Fatal(http.ListenAndServe(":8080", nil)) }() if *pDoGame { world() } else { BODY.ticker() for { time.Sleep(1 * time.Second) } } }
func lbpkr_run_cmd_dep_graph(cmd *commander.Command, args []string) error { var err error siteroot := cmd.Flag.Lookup("siteroot").Value.Get().(string) debug := cmd.Flag.Lookup("v").Value.Get().(bool) dotfname := cmd.Flag.Lookup("o").Value.Get().(string) dmax := cmd.Flag.Lookup("maxdepth").Value.Get().(int) name := "" vers := "" release := "" switch len(args) { case 0: name = "" case 1: name = args[0] case 2: name = args[0] vers = args[1] case 3: name = args[0] vers = args[1] release = args[2] default: cmd.Usage() return fmt.Errorf("lbpkr: invalid number of arguments. expected n=0|1|2|3. got=%d (%v)", len(args), args, ) } cfg := NewConfig(siteroot) ctx, err := New(cfg, Debug(debug)) if err != nil { return err } defer ctx.Close() g := graph.NewGraph() g.SetName("rpms") g.SetDir(true) decorate := func(pkg yum.RPM) map[string]string { return map[string]string{ "name": strconv.Quote(pkg.Name()), "version": strconv.Quote(pkg.Version()), "release": strconv.Quote(pkg.Release()), "epoch": strconv.Quote(pkg.Epoch()), } } pkgs, err := ctx.ListInstalledPackages(name, vers, release) if err != nil { return err } str_in_slice := func(str string, slice []string) bool { for _, v := range slice { if str == v { return true } } return false } var process func(pkg *yum.Package, lvl int) error process = func(pkg *yum.Package, lvl int) error { var err error root := strconv.Quote(pkg.ID()) g.AddNode("rpms", root, decorate(pkg)) reqs := pkg.Requires() for _, req := range reqs { if str_in_slice(req.Name(), yum.IGNORED_PACKAGES) { continue } dep, err := ctx.Client().FindLatestMatchingRequire(req) if err != nil { ctx.msg.Infof("no package providing name=%q version=%q release=%q\n", req.Name(), req.Version(), req.Release(), ) continue } g.AddNode("rpms", strconv.Quote(dep.ID()), decorate(dep)) g.AddEdge(root, strconv.Quote(dep.ID()), true, nil) if lvl < dmax || dmax < 0 { err = process(dep, lvl+1) if err != nil { return err } } } return err } for _, pkg := range pkgs { err = process(pkg, 1) if err != nil { return err } } err = ioutil.WriteFile(dotfname, []byte(g.String()), 0644) if err != nil { return err } return err }