func NewPcapProbesHandler(tb *probes.TopologyProbeBundle, g *graph.Graph, p *mappings.FlowMappingPipeline, a *analyzer.Client) *PcapProbesHandler {
handler := &PcapProbesHandler{
graph: g,
analyzerClient: a,
flowMappingPipeline: p,
flowTable: flow.NewTable(),
probes: make(map[string]*PcapProbe),
}
return handler
}
func (sfa *SFlowAgent) start() error {
addr := net.UDPAddr{
Port: sfa.Port,
IP: net.ParseIP(sfa.Addr),
}
conn, err := net.ListenUDP("udp", &addr)
if err != nil {
logging.GetLogger().Errorf("Unable to listen on port %d: %s", sfa.Port, err.Error())
return err
}
defer conn.Close()
conn.SetDeadline(time.Now().Add(1 * time.Second))
sfa.wg.Add(1)
defer sfa.wg.Done()
sfa.running.Store(true)
sfa.flowTable = flow.NewTable()
defer sfa.flowTable.UnregisterAll()
cfgFlowtable_expire := config.GetConfig().GetInt("agent.flowtable_expire")
sfa.flowTable.RegisterExpire(sfa.asyncFlowPipeline, time.Duration(cfgFlowtable_expire)*time.Second)
cfgFlowtable_update := config.GetConfig().GetInt("agent.flowtable_update")
sfa.flowTable.RegisterUpdated(sfa.asyncFlowPipeline, time.Duration(cfgFlowtable_update)*time.Second)
for sfa.running.Load() == true {
select {
case now := <-sfa.flowTable.GetExpireTicker():
sfa.flowTable.Expire(now)
case now := <-sfa.flowTable.GetUpdatedTicker():
sfa.flowTable.Updated(now)
case <-sfa.flush:
sfa.flowTable.ExpireNow()
sfa.flushDone <- true
default:
sfa.feedFlowTable(conn)
}
}
return 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
}