Beispiel #1
0
func (p *Prospector) startHarvesterWithOffset(info *prospectorInfo, fileconfig *core.FileConfig, offset int64) {
	// TODO - hook in a shutdown channel
	info.harvester = harvester.NewHarvester(info, p.config, &fileconfig.StreamConfig, offset)
	info.running = true
	info.status = Status_Ok
	info.harvester.Start(p.output)
}
Beispiel #2
0
func (lc *LogCourier) Run() {
	var admin_listener *admin.Listener
	var on_command <-chan string
	var harvester_wait <-chan *harvester.HarvesterFinish
	var registrar_imp registrar.Registrator

	lc.startUp()

	log.Info("Log Courier version %s pipeline starting", core.Log_Courier_Version)

	// If reading from stdin, skip admin, and set up a null registrar
	if lc.stdin {
		registrar_imp = newStdinRegistrar(lc.pipeline)
	} else {
		if lc.config.General.AdminEnabled {
			var err error

			admin_listener, err = admin.NewListener(lc.pipeline, &lc.config.General)
			if err != nil {
				log.Fatalf("Failed to initialise: %s", err)
			}

			on_command = admin_listener.OnCommand()
		}

		registrar_imp = registrar.NewRegistrar(lc.pipeline, lc.config.General.PersistDir)
	}

	publisher_imp, err := publisher.NewPublisher(lc.pipeline, &lc.config.Network, registrar_imp)
	if err != nil {
		log.Fatalf("Failed to initialise: %s", err)
	}

	spooler_imp := spooler.NewSpooler(lc.pipeline, &lc.config.General, publisher_imp)

	// If reading from stdin, don't start prospector, directly start a harvester
	if lc.stdin {
		lc.harvester = harvester.NewHarvester(nil, lc.config, &lc.config.Stdin, 0)
		lc.harvester.Start(spooler_imp.Connect())
		harvester_wait = lc.harvester.OnFinish()
	} else {
		if _, err := prospector.NewProspector(lc.pipeline, lc.config, lc.from_beginning, registrar_imp, spooler_imp); err != nil {
			log.Fatalf("Failed to initialise: %s", err)
		}
	}

	// Start the pipeline
	lc.pipeline.Start()

	log.Notice("Pipeline ready")

	lc.shutdown_chan = make(chan os.Signal, 1)
	lc.reload_chan = make(chan os.Signal, 1)
	lc.registerSignals()

SignalLoop:
	for {
		select {
		case <-lc.shutdown_chan:
			lc.cleanShutdown()
			break SignalLoop
		case <-lc.reload_chan:
			lc.reloadConfig()
		case command := <-on_command:
			admin_listener.Respond(lc.processCommand(command))
		case finished := <-harvester_wait:
			if finished.Error != nil {
				log.Notice("An error occurred reading from stdin at offset %d: %s", finished.Last_Read_Offset, finished.Error)
			} else {
				log.Notice("Finished reading from stdin at offset %d", finished.Last_Read_Offset)
			}
			lc.harvester = nil

			// Flush the spooler
			spooler_imp.Flush()

			// Wait for StdinRegistrar to receive ACK for the last event we sent
			registrar_imp.(*StdinRegistrar).Wait(finished.Last_Event_Offset)

			lc.cleanShutdown()
			break SignalLoop
		}
	}

	log.Notice("Exiting")

	if lc.log_file != nil {
		lc.log_file.Close()
	}
}