func (f *FlowTraversalStep) Nodes(s ...interface{}) *traversal.GraphTraversalV {
var nodes []*graph.Node
if f.Error() != nil {
return traversal.NewGraphTraversalV(f.GraphTraversal, nodes, f.Error())
}
m, err := traversal.SliceToMetadata(s...)
if err != nil {
logging.GetLogger().Critical(err)
return traversal.NewGraphTraversalV(f.GraphTraversal, nodes, err)
}
for _, flow := range f.flowset.Flows {
if flow.NodeUUID != "" && flow.NodeUUID != "*" {
if node := f.GraphTraversal.Graph.GetNode(graph.Identifier(flow.NodeUUID)); node != nil && node.MatchMetadata(m) {
nodes = append(nodes, node)
}
}
if flow.ANodeUUID != "" && flow.ANodeUUID != "*" {
if node := f.GraphTraversal.Graph.GetNode(graph.Identifier(flow.ANodeUUID)); node != nil && node.MatchMetadata(m) {
nodes = append(nodes, node)
}
}
if flow.BNodeUUID != "" && flow.BNodeUUID != "*" {
if node := f.GraphTraversal.Graph.GetNode(graph.Identifier(flow.BNodeUUID)); node != nil && node.MatchMetadata(m) {
nodes = append(nodes, node)
}
}
}
return traversal.NewGraphTraversalV(f.GraphTraversal, nodes)
}
func (s *HopsGremlinTraversalStep) Exec(last traversal.GraphTraversalStep) (traversal.GraphTraversalStep, error) {
var nodes []*graph.Node
switch last.(type) {
case *FlowTraversalStep:
fs := last.(*FlowTraversalStep)
graphTraversal := fs.GraphTraversal
m, err := traversal.SliceToMetadata(s.context.Params...)
if err != nil {
return nil, traversal.ExecutionError
}
for _, f := range fs.flowset.Flows {
if node := graphTraversal.Graph.GetNode(graph.Identifier(f.NodeUUID)); node != nil && node.MatchMetadata(m) {
nodes = append(nodes, node)
}
}
graphTraversalV := traversal.NewGraphTraversalV(graphTraversal, nodes)
return graphTraversalV, nil
}
return nil, traversal.ExecutionError
}
func (f *FlowTraversalStep) MarshalJSON() ([]byte, error) {
a := make([]interface{}, len(f.flowset.Flows))
for i, flow := range f.flowset.Flows {
b, err := json.Marshal(flow)
if err != nil {
logging.GetLogger().Errorf("Error while converting flow to JSON: %v", flow)
continue
}
d := json.NewDecoder(bytes.NewReader(b))
d.UseNumber()
var x map[string]interface{}
err = d.Decode(&x)
if err != nil {
logging.GetLogger().Errorf("Error while converting flow to JSON: %v", flow)
continue
}
// substitute UUID by the node
if flow.ANodeUUID != "" && flow.ANodeUUID != "*" {
node := f.GraphTraversal.Graph.GetNode(graph.Identifier(flow.ANodeUUID))
if node != nil {
x["ANode"] = node
}
}
if flow.BNodeUUID != "" && flow.BNodeUUID != "*" {
node := f.GraphTraversal.Graph.GetNode(graph.Identifier(flow.BNodeUUID))
if node != nil {
x["BNode"] = node
}
}
node := f.GraphTraversal.Graph.GetNode(graph.Identifier(flow.NodeUUID))
if node != nil {
x["Node"] = node
}
a[i] = x
}
return json.Marshal(a)
}
func NewGraph(t *testing.T) *graph.Graph {
var backend graph.GraphBackend
var err error
switch graphBackend {
case "gremlin-ws":
backend, err = graph.NewGremlinBackend("ws://127.0.0.1:8182")
case "gremlin-rest":
backend, err = graph.NewGremlinBackend("http://127.0.0.1:8182?gremlin=")
case "elasticsearch":
backend, err = graph.NewElasticSearchBackend("127.0.0.1", "9200", 10, 60, 1)
if err == nil {
backend, err = graph.NewShadowedBackend(backend)
}
case "orientdb":
password := os.Getenv("ORIENTDB_ROOT_PASSWORD")
if password == "" {
password = "******"
}
backend, err = graph.NewOrientDBBackend("http://127.0.0.1:2480", "TestSkydive", "root", password)
default:
backend, err = graph.NewMemoryBackend()
}
if err != nil {
t.Fatal(err.Error())
}
t.Logf("Using %s as backend", graphBackend)
g, err := graph.NewGraphFromConfig(backend)
if err != nil {
t.Fatal(err.Error())
}
hostname, err := os.Hostname()
if err != nil {
t.Fatal(err.Error())
}
root := g.LookupFirstNode(graph.Metadata{"Name": hostname, "Type": "host"})
if root == nil {
root = g.NewNode(graph.Identifier(hostname), graph.Metadata{"Name": hostname, "Type": "host"})
if root == nil {
t.Fatal("fail while adding root node")
}
}
return g
}
func (fb *FabricProbe) addFabricNodeFromDef(nodeDef string) (*graph.Node, error) {
nodeName, metadata, err := nodeDefToMetadata(nodeDef)
if err != nil {
return nil, err
}
u, _ := uuid.NewV5(uuid.NamespaceOID, []byte("fabric"+nodeName))
id := graph.Identifier(u.String())
if node := fb.Graph.GetNode(id); node != nil {
return node, nil
}
metadata["Probe"] = "fabric"
return fb.Graph.NewNode(id, metadata), nil
}
func CreateRootNode(g *graph.Graph) *graph.Node {
hostID := config.GetConfig().GetString("host_id")
m := graph.Metadata{"Name": hostID, "Type": "host"}
if config.GetConfig().IsSet("agent.metadata") {
subtree := config.GetConfig().Sub("agent.metadata")
for key, value := range subtree.AllSettings() {
m[key] = value
}
}
buffer, err := ioutil.ReadFile("/var/lib/cloud/data/instance-id")
if err == nil {
m["InstanceID"] = strings.TrimSpace(string(buffer))
}
u, _ := uuid.NewV5(uuid.NamespaceOID, []byte(hostID))
return g.NewNode(graph.Identifier(u.String()), m)
}
func (o *OnDemandProbeServer) OnMessage(msg shttp.WSMessage) {
if msg.Namespace != ondemand.Namespace {
return
}
var query ondemand.CaptureQuery
if err := json.Unmarshal([]byte(*msg.Obj), &query); err != nil {
logging.GetLogger().Errorf("Unable to decode capture %v", msg)
return
}
o.Graph.Lock()
defer o.Graph.Unlock()
status := http.StatusOK
n := o.Graph.GetNode(graph.Identifier(query.NodeID))
if n == nil {
logging.GetLogger().Errorf("Unknown node %s for new capture", query.NodeID)
status = http.StatusNotFound
} else {
var ok bool
switch msg.Type {
case "CaptureStart":
if ok = o.registerProbe(n, &query.Capture); ok {
t := o.Graph.StartMetadataTransaction(n)
t.AddMetadata("State/FlowCapture", "ON")
t.AddMetadata("CaptureID", query.Capture.UUID)
t.Commit()
}
case "CaptureStop":
if ok = o.unregisterProbe(n); ok {
metadata := n.Metadata()
metadata["State/FlowCapture"] = "OFF"
delete(metadata, "CaptureID")
o.Graph.SetMetadata(n, metadata)
}
}
if !ok {
status = http.StatusBadRequest
}
}
reply := msg.Reply(&ondemand.CaptureQuery{}, "CaptureStopReply", status)
o.wsClient.SendWSMessage(reply)
}
func (t *GraphTraversal) V(s ...interface{}) *GraphTraversalV {
var nodes []*graph.Node
var metadata graph.Metadata
var err error
if t.error != nil {
return &GraphTraversalV{error: t.error}
}
switch len(s) {
case 1:
id, ok := s[0].(string)
if !ok {
return &GraphTraversalV{error: fmt.Errorf("V accepts only a string when there is only one argument")}
}
node := t.Graph.GetNode(graph.Identifier(id))
if node == nil {
return &GraphTraversalV{error: fmt.Errorf("Node '%s' does not exist", id)}
}
nodes = []*graph.Node{node}
default:
if metadata, err = SliceToMetadata(s...); err != nil {
return &GraphTraversalV{error: err}
}
fallthrough
case 0:
nodes = t.Graph.GetNodes(metadata)
}
if t.currentStepContext.PaginationRange != nil {
var nodeRange []*graph.Node
it := t.currentStepContext.PaginationRange.Iterator()
for _, node := range nodes {
if it.Done() {
break
} else if it.Next() {
nodeRange = append(nodeRange, node)
}
}
nodes = nodeRange
}
return &GraphTraversalV{GraphTraversal: t, nodes: nodes}
}
func (s *GremlinTraversalStepV) Exec(last GraphTraversalStep) (GraphTraversalStep, error) {
g, ok := last.(*GraphTraversal)
if !ok {
return nil, ExecutionError
}
g.currentStepContext = s.StepContext
switch len(s.Params) {
case 1:
if k, ok := s.Params[0].(string); ok {
return g.V(graph.Identifier(k)), nil
}
return nil, ExecutionError
case 0:
return g.V(), nil
default:
return nil, ExecutionError
}
}
