func NewServer(addr string, port int, router *mux.Router) (*Server, error) {
backend, err := graph.BackendFromConfig()
if err != nil {
return nil, err
}
g, err := graph.NewGraph(backend)
if err != nil {
return nil, err
}
tserver := topology.NewServer(g, addr, port, router)
tserver.RegisterStaticEndpoints()
tserver.RegisterRpcEndpoints()
alertmgr := graph.NewAlert(g, router)
alertmgr.RegisterRpcEndpoints()
gserver, err := graph.NewServerFromConfig(g, alertmgr, router)
if err != nil {
return nil, err
}
gfe, err := mappings.NewGraphFlowEnhancer(g)
if err != nil {
return nil, err
}
pipeline := mappings.NewFlowMappingPipeline([]mappings.FlowEnhancer{gfe})
flowtable := flow.NewFlowTable()
server := &Server{
Addr: addr,
Port: port,
Router: router,
TopoServer: tserver,
GraphServer: gserver,
FlowMappingPipeline: pipeline,
FlowTable: flowtable,
}
server.RegisterStaticEndpoints()
server.RegisterRpcEndpoints()
cfgFlowtable_expire, err := config.GetConfig().Section("analyzer").Key("flowtable_expire").Int()
if err != nil || cfgFlowtable_expire < 1 {
logging.GetLogger().Error("Config flowTable_expire invalid value ", cfgFlowtable_expire, err.Error())
return nil, err
}
go flowtable.AsyncExpire(server.flowExpire, time.Duration(cfgFlowtable_expire)*time.Minute)
return server, nil
}
func newGraph(t *testing.T) *graph.Graph {
backend, err := graph.NewMemoryBackend()
if err != nil {
t.Fatal(err.Error())
}
g, err := graph.NewGraph(backend)
if err != nil {
t.Fatal(err.Error())
}
return g
}
func NewAgent() *Agent {
backend, err := graph.NewMemoryBackend()
if err != nil {
panic(err)
}
g, err := graph.NewGraph(backend)
if err != nil {
panic(err)
}
hostname, err := os.Hostname()
if err != nil {
panic(err)
}
ovsmon := ovsdb.NewOvsMonitorFromConfig()
root := g.NewNode(graph.Identifier(hostname), graph.Metadatas{"Name": hostname, "Type": "host"})
ns := tprobes.NewNetNSProbe(g, root)
nl := tprobes.NewNetLinkProbe(g, root)
ovs := tprobes.NewOvsdbProbe(g, root, ovsmon)
router := mux.NewRouter().StrictSlash(true)
server, err := topology.NewServerFromConfig("agent", g, router)
if err != nil {
panic(err)
}
server.RegisterStaticEndpoints()
server.RegisterRpcEndpoints()
gserver, err := graph.NewServerFromConfig(g, nil, router)
if err != nil {
panic(err)
}
return &Agent{
Graph: g,
NsProbe: ns,
NlProbe: nl,
OvsMon: ovsmon,
OvsProbe: ovs,
TopoServer: server,
GraphServer: gserver,
Root: root,
}
}
func NewAgent() *Agent {
backend, err := graph.NewMemoryBackend()
if err != nil {
panic(err)
}
g, err := graph.NewGraph(backend)
if err != nil {
panic(err)
}
hostname, err := os.Hostname()
if err != nil {
panic(err)
}
hserver, err := shttp.NewServerFromConfig("agent")
if err != nil {
panic(err)
}
_, err = api.NewApi(hserver, nil)
if err != nil {
panic(err)
}
wsServer := shttp.NewWSServerFromConfig(hserver, "/ws")
root := g.NewNode(graph.Identifier(hostname), graph.Metadata{"Name": hostname, "Type": "host"})
api.RegisterTopologyApi("agent", g, hserver)
gserver := graph.NewServer(g, wsServer)
return &Agent{
Graph: g,
WSServer: wsServer,
GraphServer: gserver,
Root: root,
HTTPServer: hserver,
}
}
func NewAgent() *Agent {
backend, err := graph.NewMemoryBackend()
if err != nil {
panic(err)
}
g, err := graph.NewGraph(backend)
if err != nil {
panic(err)
}
hostname, err := os.Hostname()
if err != nil {
panic(err)
}
root := g.NewNode(graph.Identifier(hostname), graph.Metadata{"Name": hostname, "Type": "host"})
router := mux.NewRouter().StrictSlash(true)
server, err := topology.NewServerFromConfig("agent", g, router)
if err != nil {
panic(err)
}
server.RegisterStaticEndpoints()
server.RegisterRPCEndpoints()
gserver, err := graph.NewServerFromConfig(g, nil, router)
if err != nil {
panic(err)
}
return &Agent{
Graph: g,
TopologyServer: server,
GraphServer: gserver,
Root: root,
}
}
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=")
default:
backend, err = graph.NewMemoryBackend()
}
if err != nil {
t.Fatal(err.Error())
}
t.Logf("Using %s as backend", graphBackend)
g, err := graph.NewGraph(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 NewServer(addr string, port int, router *mux.Router, embedEtcd bool) (*Server, error) {
backend, err := graph.BackendFromConfig()
if err != nil {
return nil, err
}
g, err := graph.NewGraph(backend)
if err != nil {
return nil, err
}
tserver := topology.NewServer("analyzer", g, addr, port, router)
tserver.RegisterStaticEndpoints()
tserver.RegisterRPCEndpoints()
var etcd *storage.EmbeddedEtcd
if embedEtcd {
if etcd, err = storage.NewEmbeddedEtcdFromConfig(); err != nil {
return nil, err
}
}
alertmgr, err := graph.NewAlertFromConfig(g, router)
if err != nil {
return nil, err
}
alertmgr.RegisterRPCEndpoints()
gserver, err := graph.NewServerFromConfig(g, alertmgr, router)
if err != nil {
return nil, err
}
gfe, err := mappings.NewGraphFlowEnhancer(g)
if err != nil {
return nil, err
}
pipeline := mappings.NewFlowMappingPipeline(gfe)
flowtable := flow.NewFlowTable()
server := &Server{
Addr: addr,
Port: port,
Router: router,
TopoServer: tserver,
GraphServer: gserver,
FlowMappingPipeline: pipeline,
FlowTable: flowtable,
EmbeddedEtcd: etcd,
}
server.RegisterRPCEndpoints()
cfgFlowtable_expire := config.GetConfig().GetInt("analyzer.flowtable_expire")
if cfgFlowtable_expire < 1 {
logging.GetLogger().Errorf("Config flowTable_expire invalid value %d : %s", cfgFlowtable_expire, err.Error())
return nil, err
}
go flowtable.AsyncExpire(server.flowExpire, time.Duration(cfgFlowtable_expire)*time.Minute)
return server, nil
}
func NewServerFromConfig() (*Server, error) {
embedEtcd := config.GetConfig().GetBool("etcd.embedded")
backend, err := graph.BackendFromConfig()
if err != nil {
return nil, err
}
g, err := graph.NewGraph(backend)
if err != nil {
return nil, err
}
httpServer, err := shttp.NewServerFromConfig("analyzer")
if err != nil {
return nil, err
}
wsServer := shttp.NewWSServerFromConfig(httpServer, "/ws")
api.RegisterTopologyApi("analyzer", g, httpServer)
var etcdServer *etcd.EmbeddedEtcd
if embedEtcd {
if etcdServer, err = etcd.NewEmbeddedEtcdFromConfig(); err != nil {
return nil, err
}
}
etcdClient, err := etcd.NewEtcdClientFromConfig()
if err != nil {
return nil, err
}
apiServer, err := api.NewApi(httpServer, etcdClient.KeysApi)
if err != nil {
return nil, err
}
captureHandler := &api.BasicApiHandler{
ResourceHandler: &api.CaptureHandler{},
EtcdKeyAPI: etcdClient.KeysApi,
}
err = apiServer.RegisterApiHandler(captureHandler)
if err != nil {
return nil, err
}
alertHandler := &api.BasicApiHandler{
ResourceHandler: &api.AlertHandler{},
EtcdKeyAPI: etcdClient.KeysApi,
}
err = apiServer.RegisterApiHandler(alertHandler)
if err != nil {
return nil, err
}
alertManager := alert.NewAlertManager(g, alertHandler)
aserver := alert.NewServer(alertManager, wsServer)
gserver := graph.NewServer(g, wsServer)
gfe := mappings.NewGraphFlowEnhancer(g)
ofe := mappings.NewOvsFlowEnhancer(g)
pipeline := mappings.NewFlowMappingPipeline(gfe, ofe)
flowtable := flow.NewTable()
server := &Server{
HTTPServer: httpServer,
WSServer: wsServer,
GraphServer: gserver,
AlertServer: aserver,
FlowMappingPipeline: pipeline,
FlowTable: flowtable,
EmbeddedEtcd: etcdServer,
EtcdClient: etcdClient,
}
server.SetStorageFromConfig()
api.RegisterFlowApi("analyzer", flowtable, server.Storage, httpServer)
cfgFlowtable_expire := config.GetConfig().GetInt("analyzer.flowtable_expire")
flowtable.RegisterExpire(server.flowExpireUpdate, time.Duration(cfgFlowtable_expire)*time.Second)
cfgFlowtable_update := config.GetConfig().GetInt("analyzer.flowtable_update")
flowtable.RegisterUpdated(server.flowExpireUpdate, time.Duration(cfgFlowtable_update)*time.Second)
return server, nil
}
