func (pc *PacketInjectorClient) injectPacket(host string, pp *PacketParams, status chan *string) { msg := shttp.NewWSMessage(Namespace, "InjectPacket", pp) ch := make(chan *json.RawMessage) defer close(ch) pc.replyChanMutex.Lock() pc.replyChan[msg.UUID] = ch pc.replyChanMutex.Unlock() defer func() { pc.replyChanMutex.Lock() delete(pc.replyChan, msg.UUID) pc.replyChanMutex.Unlock() }() if !pc.WSServer.SendWSMessageTo(msg, host) { e := fmt.Sprintf("Unable to send message to agent: %s", host) logging.GetLogger().Errorf(e) status <- &e return } data := <-ch var reply string if err := json.Unmarshal([]byte(*data), &reply); err != nil { e := fmt.Sprintf("Error while reading reply from: %s", host) logging.GetLogger().Errorf(e) status <- &e return } status <- &reply }
func (f *TableClient) lookupFlows(flowset chan *FlowSet, host string, flowSearchQuery *FlowSearchQuery) { obj, _ := proto.Marshal(flowSearchQuery) tq := TableQuery{ Type: "FlowSearchQuery", Obj: obj, } msg := shttp.NewWSMessage(Namespace, "TableQuery", tq) ch := make(chan *json.RawMessage) defer close(ch) f.replyChanMutex.Lock() f.replyChan[msg.UUID] = ch f.replyChanMutex.Unlock() defer func() { f.replyChanMutex.Lock() delete(f.replyChan, msg.UUID) f.replyChanMutex.Unlock() }() if !f.WSServer.SendWSMessageTo(msg, host) { logging.GetLogger().Errorf("Unable to send message to agent: %s", host) flowset <- NewFlowSet() return } select { case raw := <-ch: var reply TableReply if err := json.Unmarshal([]byte(*raw), &reply); err != nil { logging.GetLogger().Errorf("Error returned while reading TableReply from: %s", host) break } if reply.Status != http.StatusOK { logging.GetLogger().Errorf("Error %d TableReply from: %s", reply.Status, host) break } fs := NewFlowSet() context := MergeContext{Sorted: flowSearchQuery.Sort, Dedup: flowSearchQuery.Dedup} for _, b := range reply.Obj { var fsr FlowSearchReply if err := proto.Unmarshal(b, &fsr); err != nil { logging.GetLogger().Errorf("Unable to decode flow search reply from: %s", host) continue } fs.Merge(fsr.FlowSet, context) } flowset <- fs return case <-time.After(time.Second * 10): logging.GetLogger().Errorf("Timeout while reading TableReply from: %s", host) } flowset <- NewFlowSet() }
func (o *OnDemandProbeClient) unregisterProbe(node *graph.Node) bool { msg := shttp.NewWSMessage(ondemand.Namespace, "CaptureStop", ondemand.CaptureQuery{NodeID: string(node.ID)}) if !o.wsServer.SendWSMessageTo(msg, node.Host()) { logging.GetLogger().Errorf("Unable to send message to agent: %s", node.Host()) return false } return true }
func (s *GraphServer) OnMessage(c *shttp.WSClient, msg shttp.WSMessage) { if msg.Namespace != Namespace { return } s.Graph.Lock() defer s.Graph.Unlock() msgType, obj, err := UnmarshalWSMessage(msg) if err != nil { logging.GetLogger().Errorf("Graph: Unable to parse the event %v: %s", msg, err.Error()) return } switch msgType { case "SyncRequest": reply := shttp.NewWSMessage(Namespace, "SyncReply", s.Graph.WithContext(obj.(GraphContext))) c.SendWSMessage(reply) case "SubGraphDeleted": n := obj.(*Node) logging.GetLogger().Debugf("Got SubGraphDeleted event from the node %s", n.ID) node := s.Graph.GetNode(n.ID) if node != nil { s.Graph.DelSubGraph(node) } case "NodeUpdated": n := obj.(*Node) node := s.Graph.GetNode(n.ID) if node != nil { s.Graph.SetMetadata(node, n.metadata) } case "NodeDeleted": s.Graph.DelNode(obj.(*Node)) case "NodeAdded": n := obj.(*Node) if s.Graph.GetNode(n.ID) == nil { s.Graph.AddNode(n) } case "EdgeUpdated": e := obj.(*Edge) edge := s.Graph.GetEdge(e.ID) if edge != nil { s.Graph.SetMetadata(edge, e.metadata) } case "EdgeDeleted": s.Graph.DelEdge(obj.(*Edge)) case "EdgeAdded": e := obj.(*Edge) if s.Graph.GetEdge(e.ID) == nil { s.Graph.AddEdge(e) } } }
func (c *Forwarder) triggerResync() { logging.GetLogger().Infof("Start a resync of the graph") c.Graph.RLock() defer c.Graph.RUnlock() // request for deletion of everything belonging to Root node c.Client.SendWSMessage(shttp.NewWSMessage(Namespace, "HostGraphDeleted", c.Host)) // re-added all the nodes and edges nodes := c.Graph.GetNodes(Metadata{}) for _, n := range nodes { c.Client.SendWSMessage(shttp.NewWSMessage(Namespace, "NodeAdded", n)) } edges := c.Graph.GetEdges(Metadata{}) for _, e := range edges { c.Client.SendWSMessage(shttp.NewWSMessage(Namespace, "EdgeAdded", e)) } }
func (mapper *NeutronMapper) updateNode(node *graph.Node, attrs *Attributes) { mapper.graph.Lock() tr := mapper.graph.StartMetadataTransaction(node) tr.AddMetadata("Manager", "neutron") if attrs.PortID != "" { tr.AddMetadata("Neutron/PortID", attrs.PortID) } if attrs.TenantID != "" { tr.AddMetadata("Neutron/TenantID", attrs.TenantID) } if attrs.NetworkID != "" { tr.AddMetadata("Neutron/NetworkID", attrs.NetworkID) } if attrs.NetworkName != "" { tr.AddMetadata("Neutron/NetworkName", attrs.NetworkName) } if segID, err := strconv.Atoi(attrs.VNI); err != nil && segID > 0 { tr.AddMetadata("Neutron/VNI", uint64(segID)) } var registerLink *FabricRegisterLinkWSMessage if vm, ok := node.Metadata()["ExtID/vm-uuid"]; ok { if mac, ok := node.Metadata()["ExtID/attached-mac"]; ok { if path := mapper.graph.LookupShortestPath(node, graph.Metadata{"Type": "tun"}, graph.Metadata{"RelationType": "layer2"}); len(path) > 0 { registerLink = &FabricRegisterLinkWSMessage{ ParentNodeID: path[len(path)-1].ID, ParentMetadata: graph.Metadata{"Type": "host", "InstanceID": vm}, ChildMetadata: graph.Metadata{"Type": "device", "MAC": mac}, } } } } tr.Commit() mapper.graph.Unlock() if registerLink != nil { msg := shttp.NewWSMessage(FabricNamespace, "RegisterLink", registerLink) mapper.wsClient.SendWSMessage(msg) } }
/* Called by alert.EvalNodes() */ func (c *alertClient) OnAlert(amsg *AlertMessage) { msg := shttp.NewWSMessage(Namespace, "Alert", amsg) c.wsClient.SendWSMessage(msg) }
func (c *Forwarder) OnEdgeDeleted(e *Edge) { c.Client.SendWSMessage(shttp.NewWSMessage(Namespace, "EdgeDeleted", e)) }
func (c *Forwarder) OnNodeDeleted(n *Node) { c.Client.SendWSMessage(shttp.NewWSMessage(Namespace, "NodeDeleted", n)) }
func (s *GraphServer) OnEdgeDeleted(e *Edge) { s.WSServer.BroadcastWSMessage(shttp.NewWSMessage(Namespace, "EdgeDeleted", e)) }
func (s *GraphServer) OnNodeDeleted(n *Node) { s.WSServer.BroadcastWSMessage(shttp.NewWSMessage(Namespace, "NodeDeleted", n)) }