Beispiel #1
0
func NewFlowProbeBundleFromConfig(tb *probes.TopologyProbeBundle, g *graph.Graph, fta *flow.TableAllocator) *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":
			o := NewOvsSFlowProbesHandler(tb, g)
			if o != nil {
				ofe := mappings.NewOvsFlowEnhancer(g)
				pipeline := mappings.NewFlowMappingPipeline(gfe, ofe)
				probes[t] = FlowProbe{fpi: o, pipeline: pipeline, client: aclient}
			}
		case "gopacket":
			o := NewGoPacketProbesHandler(g)
			if o != nil {
				pipeline := mappings.NewFlowMappingPipeline(gfe)
				gopacket := FlowProbe{fpi: o, pipeline: pipeline, client: aclient}

				probes["afpacket"] = gopacket
				probes["pcap"] = gopacket
			}
		default:
			logging.GetLogger().Errorf("unknown probe type %s", t)
		}
	}

	p := probe.NewProbeBundle(probes)

	return &FlowProbeBundle{
		ProbeBundle:        *p,
		Graph:              g,
		FlowTableAllocator: fta,
	}
}
Beispiel #2
0
func NewRestClientFromConfig(authOptions *AuthenticationOpts) (*RestClient, error) {
	addr, port, err := config.GetAnalyzerClientAddr()
	if err != nil {
		logging.GetLogger().Errorf("Unable to parse analyzer client %s", err.Error())
		return nil, err
	}

	return NewRestClient(addr, port, authOptions), nil
}
Beispiel #3
0
func (a *Agent) Start() {
	var err error

	go a.WSServer.ListenAndServe()

	addr, port, err := config.GetAnalyzerClientAddr()
	if err != nil {
		logging.GetLogger().Errorf("Unable to parse analyzer client %s", err.Error())
		os.Exit(1)
	}

	if addr != "" {
		authOptions := &shttp.AuthenticationOpts{
			Username: config.GetConfig().GetString("agent.analyzer_username"),
			Password: config.GetConfig().GetString("agent.analyzer_password"),
		}
		authClient := waitAnalyzer(addr, port, authOptions)
		a.WSClient, err = shttp.NewWSAsyncClientFromConfig("skydive-agent", addr, port, "/ws", authClient)
		if err != nil {
			logging.GetLogger().Errorf("Unable to instantiate analyzer client %s", err.Error())
			os.Exit(1)
		}

		graph.NewForwarder(a.WSClient, a.Graph, config.GetConfig().GetString("host_id"))
		a.WSClient.Connect()
	}

	a.TopologyProbeBundle, err = NewTopologyProbeBundleFromConfig(a.Graph, a.Root, a.WSClient)
	if err != nil {
		logging.GetLogger().Errorf("Unable to instantiate topology probes: %s", err.Error())
		os.Exit(1)
	}
	a.TopologyProbeBundle.Start()

	go a.HTTPServer.ListenAndServe()

	if addr != "" {
		a.EtcdClient, err = etcd.NewEtcdClientFromConfig()
		if err != nil {
			logging.GetLogger().Errorf("Unable to start etcd client %s", err.Error())
			os.Exit(1)
		}

		for {
			flowtableUpdate, err := a.EtcdClient.GetInt64("/agent/config/flowtable_update")
			if err != nil {
				time.Sleep(time.Second)
				continue
			}
			flowtableExpire, err := a.EtcdClient.GetInt64("/agent/config/flowtable_expire")
			if err != nil {
				time.Sleep(time.Second)
				continue
			}

			updateTime := time.Duration(flowtableUpdate) * time.Second
			expireTime := time.Duration(flowtableExpire) * time.Second
			a.FlowTableAllocator = flow.NewTableAllocator(updateTime, expireTime)

			// expose a flow server through the client connection
			flow.NewServer(a.FlowTableAllocator, a.WSClient)

			packet_injector.NewServer(a.WSClient, a.Graph)

			a.FlowProbeBundle = fprobes.NewFlowProbeBundleFromConfig(a.TopologyProbeBundle, a.Graph, a.FlowTableAllocator)
			a.FlowProbeBundle.Start()

			l, err := ondemand.NewOnDemandProbeServer(a.FlowProbeBundle, a.Graph, a.WSClient)
			if err != nil {
				logging.GetLogger().Errorf("Unable to start on-demand flow probe %s", err.Error())
				os.Exit(1)
			}
			a.OnDemandProbeServer = l
			a.OnDemandProbeServer.Start()

			break
		}
	}
}
Beispiel #4
0
func (a *Agent) Start() {
	var err error

	go a.WSServer.ListenAndServe()

	addr, port, err := config.GetAnalyzerClientAddr()
	if err != nil {
		logging.GetLogger().Errorf("Unable to parse analyzer client %s", err.Error())
		os.Exit(1)
	}

	if addr != "" {
		authOptions := &shttp.AuthenticationOpts{
			Username: config.GetConfig().GetString("agent.analyzer_username"),
			Password: config.GetConfig().GetString("agent.analyzer_password"),
		}
		authClient := waitAnalyzer(addr, port, authOptions)
		a.WSClient, err = shttp.NewWSAsyncClientFromConfig("skydive-agent", addr, port, "/ws", authClient)
		if err != nil {
			logging.GetLogger().Errorf("Unable to instantiate analyzer client %s", err.Error())
			os.Exit(1)
		}

		graph.NewForwarder(a.WSClient, a.Graph, a.Root)
		a.WSClient.Connect()

		// send a first reset event to the analyzers
		a.Graph.DelSubGraph(a.Root)
	}

	a.TopologyProbeBundle = tprobes.NewTopologyProbeBundleFromConfig(a.Graph, a.Root)
	a.TopologyProbeBundle.Start()

	go a.HTTPServer.ListenAndServe()

	if addr != "" {
		a.EtcdClient, err = etcd.NewEtcdClientFromConfig()
		if err != nil {
			logging.GetLogger().Errorf("Unable to start etcd client %s", err.Error())
			os.Exit(1)
		}

		captureApiHandler := &api.CaptureApiHandler{
			BasicApiHandler: api.BasicApiHandler{
				ResourceHandler: &api.CaptureResourceHandler{},
				EtcdKeyAPI:      a.EtcdClient.KeysApi,
			},
			Graph: a.Graph,
		}

		for {
			flowtableUpdate, err := a.EtcdClient.GetInt64("/agent/config/flowtable_update")
			if err != nil {
				time.Sleep(time.Second)
				continue
			}
			flowtableExpire, err := a.EtcdClient.GetInt64("/agent/config/flowtable_expire")
			if err != nil {
				time.Sleep(time.Second)
				continue
			}

			updateTime := time.Duration(flowtableUpdate) * time.Second
			expireTime := time.Duration(flowtableExpire) * time.Second
			a.FlowTableAllocator = flow.NewTableAllocator(updateTime, expireTime)

			// expose a flow server through the client connection
			flow.NewServer(a.FlowTableAllocator, a.WSClient)

			a.FlowProbeBundle = fprobes.NewFlowProbeBundleFromConfig(a.TopologyProbeBundle, a.Graph, a.FlowTableAllocator)
			a.FlowProbeBundle.Start()

			l, err := fprobes.NewOnDemandProbeListener(a.FlowProbeBundle, a.Graph, captureApiHandler)
			if err != nil {
				logging.GetLogger().Errorf("Unable to start on-demand flow probe %s", err.Error())
				os.Exit(1)
			}
			a.OnDemandProbeListener = l
			a.OnDemandProbeListener.Start()

			break
		}
	}
}