예제 #1
0
파일: gotch.go 프로젝트: chuck7000/gotch
func (m *Manager) canRunChangeFunc() bool {
	// the ChangeFunc can run if we are not in a quite period, an dif we are not currently running
	if m.Quiet() {
		log.Debug("ChangeFunc can't run due to quiet period...")
	}
	if m.Running() {
		log.Debug("ChangeFunc is already running")
	}
	return !m.Quiet() && !m.Running()
}
예제 #2
0
파일: gotch.go 프로젝트: chuck7000/gotch
// runChangeFunc will manage the state of the manager and enforce PreRunDelay and QuietPeriod
func (m *Manager) runChangeFunc(skipQuiet bool) {
	// mark that the manger is currently running to block re-fireing the run based on
	// changes that come in during a run.
	m.SetRunning(true)
	log.Debug("Setting running status to true")

	// if we have a PreRunDelay, sleep for that period of time before firing the ChangeFunc
	if m.PreRunDelay {
		log.Debugf("pre-run flag is set to true, pausing for %v seconds to wait for more changes",
			m.PreRunDelay)
		time.Sleep(time.Duration(m.PreRunDelayTime) * time.Second)
	}

	// run the change func and log the result if there is an error
	err := m.ChangeFunc()
	if err != nil {
		log.Infof("Running change func resulted in error: %v", err)
	}

	// clear the runnign flag
	m.SetRunning(false)
	log.Debug("Clearing running state")

	// if we need to have a quiet period, and the skipQuiet period override is not set
	// run the quiet period
	if m.QuietPeriod && !skipQuiet {
		// set that we are in a quiet period
		m.SetQuiet(true)
		log.Debugf("entering quiet period of %v", m.QuietPeriodTime)
		// sleep for the amount of time in QuietPeriodTime
		time.Sleep(time.Duration(m.QuietPeriodTime) * time.Second)
		// clear the quiet state
		m.SetQuiet(false)
		log.Debug("exiting quiet period")

		// check to see if more changes happened while we were sleeping
		if m.ChangeHappened() {
			log.Info("More changes happened during process run, so running again")
			// if so, run the change func with the quiet period delayed.
			m.runChangeFunc(true)
		}
	}
}
예제 #3
0
파일: gotch.go 프로젝트: chuck7000/gotch
// initAndListen will start a go func to listen on the Manager.Change channel and update the
// ChangeHappened state anytime a chance occurs.  It will then check to see if the ChangeFunc
// can be ran, and if so - will run it.
func (m *Manager) initAndListen() {
	go func() {
		log.Info("starting listener...")
		for {
			// listen to the change channel
			<-m.Change
			log.Debug("recieved message from change channel")

			// set changed happened when a message is recieved
			log.Debug("setting change happend to true")
			m.SetChangeHappened(true)

			// check to see if we can run a cycle of the ChangeFunc
			if m.canRunChangeFunc() {
				log.Debug("can run change func, so calling as go routine")
				// if so, launch it in a goroutine.
				go m.runChangeFunc(false)
			}
		}
	}()
}