Esempio n. 1
0
func setupSourceTest(app, proc, rev, env string) (*visor.Instance, error) {
	store, err := visor.DialURI(visor.DefaultURI, visor.DefaultRoot)
	if err != nil {
		return nil, err
	}
	ins, err := store.RegisterInstance(app, rev, proc, env)
	if err != nil {
		return nil, err
	}
	ins, err = ins.Claim("1.2.3.4")
	if err != nil {
		return nil, err
	}
	ins, err = ins.Started("1.2.3.4", "lolcathost", 2221, 2222)
	if err != nil {
		return nil, err
	}
	return ins, nil
}
Esempio n. 2
0
func main() {
	var (
		addr          = flag.String("addr", "127.0.0.1:9999", "addr to accept client connections")
		clientBuffer  = flag.Int("client.buffer", 64, "line buffer size for client connections")
		clientTimeout = flag.Duration("client.timeout", time.Second, "read/write timeout for client connections")
		doozerURI     = flag.String("doozer.uri", visor.DefaultURI, "URI for doozer connection")
		doozerRoot    = flag.String("doozer.root", "/bazooka", "root for data in doozer tree")
		historyBuffer = flag.Int("history.buffer", 1000, "number of lines of history to keep per topic")
		logDir        = flag.String("log.dir", "/var/log", "location for log directories")
		telemetryAddr = flag.String("telemetry.addr", "127.0.0.1:9998", "addr to expose telemetry")
		version       = flag.Bool("version", false, "show bazooka-log version")

		pubc   = make(chan Line)
		subc   = make(chan Subscription)
		unsubc = make(chan Subscription)
		histc  = make(chan HistoryRequest)
		errc   = make(chan error)
		sigc   = make(chan os.Signal, 1)
	)

	flag.Parse()
	log.SetOutput(os.Stdout)

	if *version {
		fmt.Fprintf(os.Stdout, "bazooka-log@%s(%s)", Version, CommitID)
		os.Exit(0)
	}

	logf("main: bazooka-log@%s(%s) started", Version, CommitID)

	signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM)

	expvar.NewString("commitID").Set(CommitID)
	expvar.NewString("version").Set(Version)

	host, _, err := net.SplitHostPort(*addr)
	if err != nil {
		log.Fatalf("main: %s", err)
	}
	store, err := visor.DialURI(*doozerURI, *doozerRoot)
	if err != nil {
		log.Fatalf("main: %s", err)
	}
	store, err = store.RegisterLogger(*addr, Version)
	if err != nil {
		log.Fatalf("main: %s", err)
	}

	collector := &collector{
		store:  store,
		host:   host,
		logDir: *logDir,
		pubc:   pubc,
		errc:   errc,
		lookup: NewLookup(),
	}

	server := &server{
		buffer:  *clientBuffer,
		timeout: *clientTimeout,
		subc:    subc,
		unsubc:  unsubc,
		errc:    errc,
		histc:   histc,
		lookup:  NewLookup(),
	}

	expvar.Publish("collector", collector)
	expvar.Publish("server", server)

	go fanout(pubc, subc, unsubc, histc, *historyBuffer)
	go collector.WatchAndSource()
	go server.ListenAndServe(*addr)
	go telemetry(*telemetryAddr, errc)

	for {
		select {
		case err := <-errc:
			log.Fatal(err)
		case <-sigc:
			logf("main: bazooka-log@%s(%s) shutdown", Version, CommitID)
			signal.Stop(sigc)
			err := store.UnregisterLogger(*addr)
			if err != nil {
				log.Fatalf("main: %s", err)
			}
			return
		}
	}
}