// 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 (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
}
func ParseTasks(topologyDot []byte) *TaskGraphStructure {
parsed, err := gographviz.Parse(topologyDot)
if err != nil {
panic(err)
}
// Display the graph
var topology *TaskGraphStructure
topology = NewTaskGraphStructure()
gographviz.Analyse(parsed, topology)
return topology
}
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)
}
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)
}
}
}
