func (c *win_wmi_collector) connect() (err error) { // use COINIT_MULTITHREADED model ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED) unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator") if err != nil { logging.Critical("oleutil.CreateObject Failed: ", err) return err } defer unknown.Release() wmi, err := unknown.QueryInterface(ole.IID_IDispatch) if err != nil { logging.Critical("QueryInterface Failed: ", err) return err } defer wmi.Release() serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer") if err != nil { logging.Critical("Connect to Server Failed", err) return err } c.service = serviceRaw.ToIDispatch() return nil }
func NewSinglePingCollector(name, prefix string, conf config.Config_single_pinger) *ping_collector { if conf.Target == "" { logging.Critical("CRITICAL: we cannot ping empty target.") } tags := conf.Tags.Copy() tags["target"] = conf.Target if conf.Packets <= 0 { conf.Packets = 1 } c := &ping_collector{ name: name, enabled: true, config: conf, prefix: prefix, interval: conf.Interval.MustDuration(time.Second), timeout: conf.Timeout.MustDuration(time.Millisecond * 500), tags: tags, } return c }
// this is the entry point of long running daemon func run(isDebug bool, daemon bool) { if !config.IsCoreConfigLoaded() { err := config.LoadCoreConfig() if err != nil { logging.Critical("Failed to load core config: ", err) return } } go func() { loop: rss_mb := float64(gs.GetCurrentRSS()) / 1024 / 1024 // Mb logging.Tracef("current rss: %f", rss_mb) if rss_mb > float64(config.CoreConf.Rss_limit_mb) { logging.Criticalf("Suicide. CurrentRSS above limit: %f >= %d Mb", rss_mb, config.CoreConf.Rss_limit_mb) os.Exit(1) } next := time.After(time.Second) <-next goto loop }() if daemon { runService(isDebug) } else { runWithoutService() } }
func MustNewWinWmiCollector(name, prefix string, opts config.Config_win_wmi) *win_wmi_collector { c := &win_wmi_collector{ name: name, enabled: true, prefix: prefix, interval: opts.Interval.MustDuration(time.Second * 15), config: opts, } err := c.connect() if err != nil { logging.Critical("CRITICAL: win_wmi_collector cannot connect: ", err) } return c }
func (b *kafkaBackend) loop() { var ( startConsuming <-chan newcore.MultiDataPoint try_connect_first chan bool try_connect_tick <-chan time.Time ) startConsuming = b.updates logging.Info("kafkaBackend.loop started") for { if b.producer == nil && try_connect_first == nil && try_connect_tick == nil { startConsuming = nil // disable consuming try_connect_first = make(chan bool) logging.Debug("trying to connect to kafka first time.") // trying to connect to kafka first time go func() { err := b.connect() if b.producer != nil && err == nil { logging.Debugf("connect kafka first time OK: %v", b.producer) try_connect_first <- true } else { logging.Criticalf("connect to kafka failed %s", err) try_connect_first <- false } }() } if startConsuming != nil { logging.Trace("kafkaBackend consuming started") } select { case md := <-startConsuming: for idx, p := range md { b.producer.Input() <- &sarama.ProducerMessage{ Topic: b.conf.Topic_id, Key: sarama.StringEncoder(p.Metric), Value: p, } _d, _ := p.Encode() logging.Tracef("kafka producer ---> %d, %s", idx, _d) } logging.Debugf("kafkaBackend consuming finished: count: %d", len(md)) case connected := <-try_connect_first: try_connect_first = nil // disable this branch if !connected { // failed open it the first time, // then we try to open file with time interval, until connected successfully. logging.Critical("connect first time failed, try to connect with interval of 1s") try_connect_tick = time.Tick(time.Second * 1) } else { logging.Debug("kafka connected the first time.") startConsuming = b.updates } case <-try_connect_tick: // try to connect with interval err := b.connect() if b.producer != nil && err == nil { // finally connected. try_connect_tick = nil startConsuming = b.updates } else { logging.Criticalf("kafka backend trying to connect but failed: %s", err) } case errc := <-b.closing: logging.Info("kafaBackend.loop closing") startConsuming = nil // stop comsuming errc <- nil close(b.updates) logging.Info("kafaBackend.loop closed") return } } }
func (b *influxdbBackend) loop() { var ( startConsuming <-chan newcore.MultiDataPoint try_create_client_once chan bool try_create_client_tick <-chan time.Time ) startConsuming = b.updates logging.Debug("influxdb backend loop started ") for { if b.output == nil && try_create_client_once == nil && try_create_client_tick == nil { startConsuming = nil // disable consuming try_create_client_once = make(chan bool) // try to create influxdb client the first time async. go func() { err := b.newInfluxdbClientFromConf() if err == nil { try_create_client_once <- true } else { try_create_client_once <- false } }() } //TODO: Flush_interval and Max_batch_size select { case md := <-startConsuming: if b.output != nil { points := []client.Point{} for _, p := range md { // logging.Debug(p.Metric.Clean()) // logging.Debug(utils.Convert(p.Value)) points = append(points, client.Point{ Measurement: p.Metric.Clean(), Time: p.Timestamp, Fields: map[string]interface{}{ "value": utils.Convert(p.Value), }, Tags: p.Tags, //TODO: Tags }) } write := client.BatchPoints{ Database: b.conf.Database, RetentionPolicy: b.conf.RetentionPolicy, Points: points, } // logging.Debugf("write: count: %d", len(md)) //FIXME: connection timeout? resp, err := b.output.Write(write) if err != nil { logging.Errorf("failed to write into influxdb: %v, %+v", err, resp) } } case opened := <-try_create_client_once: try_create_client_once = nil // disable this branch if !opened { // failed open it the first time, // then we try to open file with time interval, until opened successfully. logging.Debug("open the first time failed, try to open with interval of 1s") try_create_client_tick = time.Tick(time.Second * 1) } else { startConsuming = b.updates } case <-try_create_client_tick: // try to open with interval err := b.newInfluxdbClientFromConf() if b.output != nil && err == nil { // finally opened. try_create_client_tick = nil startConsuming = b.updates } else { logging.Critical("influxdb backend trying to open file but failed: %s", err) } case errc := <-b.closing: // fmt.Println("errc <- b.closing") logging.Debug("influxdb backend .loop closing") startConsuming = nil // stop comsuming errc <- nil close(b.updates) logging.Debug("influxdb backend .loop stopped") return } } }
func runAsPrimaryService(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) { logging.Debug("runAsPrimaryService started") defer utils.Recover_and_log() const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown changes <- svc.Status{State: svc.StartPending} changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted} //http://localhost:6060/debug/pprof/ // utils.HttpPprofServe(6060) // after := time.After(time.Duration(8) * time.Minute) // f, _ := os.Create("d:\\cpu-" + strconv.Itoa(pid) + ".pprof") // pprof.StartCPUProfile(f) // defer pprof.StopCPUProfile() // cfg := profile.Config{ // MemProfile: true, // ProfilePath: "./pprofs/", // store profiles in current directory // NoShutdownHook: true, // do not hook SIGINT // } // p := profile.Start(&cfg) // // defer p.Stop() // utils.StartCPUProfile() // defer utils.StopCPUProfile() // go func() { // for { // <-time.After(time.Second * time.Duration(15)) // debug.FreeOSMemory() // } // }() err := hickwall.Start() if err != nil { logging.Critical("Failed To Start hickwall: %v", err) return } else { defer hickwall.Stop() } logging.Debug("service event handling loop started ") // major loop for signal processing. loop: for { select { case c := <-r: switch c.Cmd { case svc.Interrogate: changes <- c.CurrentStatus // testing deadlock from https://code.google.com/p/winsvc/issues/detail?id=4 time.Sleep(100 * time.Millisecond) changes <- c.CurrentStatus case svc.Stop, svc.Shutdown: break loop default: logging.Errorf("unexpected control request #%d", c) } } } changes <- svc.Status{State: svc.StopPending} logging.Debug("runAsPrimaryService stopped") return }