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 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)
}
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 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)
}
root := g.NewNode(graph.Identifier(hostname), graph.Metadata{"Name": hostname, "Type": "host"})
api.RegisterTopologyApi("agent", g, hserver)
gserver, err := graph.NewServerFromConfig(g, hserver)
if err != nil {
panic(err)
}
return &Agent{
Graph: g,
GraphServer: gserver,
Root: root,
HTTPServer: hserver,
}
}
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
}
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
}
alertManager := alert.NewAlertManager(g, apiServer.GetHandler("alert"))
if err != nil {
return nil, err
}
aserver, err := alert.NewServerFromConfig(alertManager, httpServer)
if err != nil {
return nil, err
}
gserver, err := graph.NewServerFromConfig(g, httpServer)
if err != nil {
return nil, err
}
gfe := mappings.NewGraphFlowEnhancer(g)
ofe := mappings.NewOvsFlowEnhancer(g)
pipeline := mappings.NewFlowMappingPipeline(gfe, ofe)
flowtable := flow.NewFlowTable()
server := &Server{
HTTPServer: httpServer,
GraphServer: gserver,
AlertServer: aserver,
FlowMappingPipeline: pipeline,
FlowTable: flowtable,
EmbeddedEtcd: etcdServer,
}
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
}