func main() {
filename := flag.String("conf", "/etc/skydive/skydive.ini",
"Config file with all the skydive parameter.")
flag.Parse()
err := config.InitConfig(*filename)
if err != nil {
panic(err)
}
quit = make(chan bool)
sflowAgent := agents.NewSFlowAgent("127.0.0.1", 6345)
ovsSFlowAgent := ovsdb.SFlowAgent{
ID: "SkydiveSFlowAgent",
Interface: "eth0",
Target: sflowAgent.GetTarget(),
HeaderSize: 256,
Sampling: 1,
Polling: 0,
}
sflowHandler := ovsdb.NewOvsSFlowAgentsHandler([]ovsdb.SFlowAgent{ovsSFlowAgent})
ovsmon := ovsdb.NewOvsMonitor("127.0.0.1", 6400)
ovsmon.AddMonitorHandler(sflowHandler)
topo := topology.NewTopology()
root := topo.NewContainer("root", topology.Root)
ns := topology.NewNetNSTopoUpdater(topo)
ns.Start()
nl := topology.NewNetLinkTopoUpdater(root)
nl.Start()
ovs := topology.NewOvsTopoUpdater(topo, ovsmon)
ovs.Start()
mapper := mappings.NewFlowMapper()
drivers, err := getInterfaceMappingDrivers(topo)
if err != nil {
panic(err)
}
mapper.SetInterfaceMappingDrivers(drivers)
sflowAgent.SetFlowMapper(mapper)
analyzer, err := analyzer.NewClient("127.0.0.1", 8888)
if err != nil {
panic(err)
}
sflowAgent.SetAnalyzerClient(analyzer)
sflowAgent.Start()
ovsmon.StartMonitoring()
fmt.Println("Skydive Agent started !")
<-quit
}
func NewFlowProbeBundleFromConfig(tb *probes.TopologyProbeBundle, g *graph.Graph) *FlowProbeBundle {
list := config.GetConfig().GetStringSlice("agent.flow.probes")
logging.GetLogger().Infof("Flow probes: %v", list)
gfe := mappings.NewGraphFlowEnhancer(g)
var aclient *analyzer.Client
addr, port, err := config.GetAnalyzerClientAddr()
if err != nil {
logging.GetLogger().Errorf("Unable to parse analyzer client: %s", err.Error())
return nil
}
if addr != "" {
aclient, err = analyzer.NewClient(addr, port)
if err != nil {
logging.GetLogger().Errorf("Analyzer client error %s:%d : %s", addr, port, err.Error())
return nil
}
}
probes := make(map[string]probe.Probe)
for _, t := range list {
if _, ok := probes[t]; ok {
continue
}
switch t {
case "ovssflow":
ofe := mappings.NewOvsFlowEnhancer(g)
pipeline := mappings.NewFlowMappingPipeline(gfe, ofe)
o := NewOvsSFlowProbesHandler(tb, g, pipeline, aclient)
if o != nil {
probes[t] = o
}
case "pcap":
pipeline := mappings.NewFlowMappingPipeline(gfe)
o := NewPcapProbesHandler(tb, g, pipeline, aclient)
if o != nil {
probes[t] = o
}
default:
logging.GetLogger().Errorf("unknown probe type %s", t)
}
}
p := probe.NewProbeBundle(probes)
return &FlowProbeBundle{
ProbeBundle: *p,
Graph: g,
}
}
func (a *Agent) Start() {
var err error
// send a first reset event to the analyzers
a.Graph.DelSubGraph(a.Root)
a.SFlowProbe, err = fprobes.NewSFlowProbeFromConfig(a.Graph)
if err != nil {
panic(err)
}
ovsSFlowProbe := ovsdb.SFlowProbe{
ID: "SkydiveSFlowProbe",
Interface: "eth0",
Target: a.SFlowProbe.GetTarget(),
HeaderSize: 256,
Sampling: 1,
Polling: 0,
}
sflowHandler := ovsdb.NewOvsSFlowProbesHandler([]ovsdb.SFlowProbe{ovsSFlowProbe})
a.OvsMon.AddMonitorHandler(sflowHandler)
analyzers := config.GetConfig().Section("agent").Key("analyzers").Strings(",")
// TODO(safchain) HA Connection ???
if len(analyzers) > 0 {
analyzerAddr := strings.Split(analyzers[0], ":")[0]
analyzerPort, err := strconv.Atoi(strings.Split(analyzers[0], ":")[1])
if err != nil {
panic(err)
}
analyzer, err := analyzer.NewClient(analyzerAddr, analyzerPort)
if err != nil {
panic(err)
}
a.SFlowProbe.SetAnalyzerClient(analyzer)
a.Gclient = graph.NewAsyncClient(analyzerAddr, analyzerPort, "/ws/graph")
graph.NewForwarder(a.Gclient, a.Graph)
a.Gclient.Connect()
}
gfe, err := mappings.NewGraphFlowEnhancer(a.Graph)
if err != nil {
panic(err)
}
pipeline := mappings.NewFlowMappingPipeline([]mappings.FlowEnhancer{gfe})
a.SFlowProbe.SetMappingPipeline(pipeline)
// start probes that will update the graph
a.NsProbe.Start()
a.NlProbe.Start()
a.OvsProbe.Start()
go a.SFlowProbe.Start()
if err := a.OvsMon.StartMonitoring(); err != nil {
panic(err)
}
go a.TopoServer.ListenAndServe()
go a.GraphServer.ListenAndServe()
}