Esempio n. 1
0
// This process will unmarshal the task payload containing the trigger that
// caused this task to be created.
func main() {
	worker.ParseFlags()

	t := &trigger{}
	err := worker.PayloadFromJSON(t)
	if err != nil {
		fmt.Println(err)
	}

	fmt.Println("Trigger type is", t.Typ)

	switch t.Typ {
	case "min":
		// Be a long duration worker
		time.Sleep(30 * time.Second)
	default:
	}
}
Esempio n. 2
0
func main() {
	worker.ParseFlags()

	var err error
	c, err = getConfig(configFile)
	if err != nil {
		log.Fatalln(err)
	}

	// Setup cache settings
	cacheEnv, exists := c.getSettings("cache", c.CacheEnv)
	if !exists {
		log.Fatalln("No cache environment set")
		return
	}
	qCache = &cache.Cache{Settings: *cacheEnv, Name: "autoscale-prevs"}

	// Determine runtime
	runtime := defaultRuntime
	if c.Runtime != nil {
		runtime = time.Duration(*c.Runtime) * time.Second
	}

	// Start watchers
	wg := &sync.WaitGroup{}
	stop := make(chan struct{})
	for _, alert := range c.Alerts {
		if len(alert.Triggers) == 0 {
			continue
		}

		wg.Add(1)
		go watchTriggers(alert, wg, stop)
	}

	// Main goroutine sleeps, stops, then exits
	time.Sleep(runtime)
	close(stop)
	wg.Wait()
}
Esempio n. 3
0
func main() {
	start := time.Now()

	// Parse config json and validate
	worker.ParseFlags()
	c := DefaultConfig()
	worker.ConfigFromJSON(c)
	if err := c.Valid(); err != nil {
		log.Fatal(err)
	}

	// Copy config, obfuscate token, and print for record
	copy := *c
	copy.Env.Token = obfuscate(copy.Env.Token)
	j, err := json.MarshalIndent(copy, "", "    ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(j))

	// Retrieve queue info
	s := config.ManualConfig("iron_mq", &c.Env)
	t := time.Now()
	q := mq.ConfigNew(c.QueueName, &s)
	info, err := q.Info()
	if err != nil {
		log.Fatal("Could not access queue info", err)
	}
	fmt.Printf("Queue has %d messages. (request took %v)\n", info.Size, time.Since(t))

	// Loop for multiple iterations of dequeuing & processing messages
	emptyResultCount := 0
	totalProcessedCount := 0
batchLoop:
	for x := 0; c.MaxIterations == nil || x < *c.MaxIterations; x++ {
		// Determine if we have time for another set of processing
		if time.Since(start) > c.MaxDuration {
			break
		}

		// If configured, sleep between iterations
		if x != 0 {
			fmt.Println("Sleeping", c.IterationSleep)
			time.Sleep(c.IterationSleep)
		}

		// Create a timeout that can accommodate the duration of the entire batch
		timeout := float64(c.BatchSize) * c.MsgDuration.Seconds() * 1.1 // give it an extra 10% time for safety

		// Reserve messages with given batch size, timeout, and longpoll time
		t = time.Now()
		msgs, err := q.LongPoll(c.BatchSize, int(timeout), c.DequeueWait, false)
		if err != nil {
			// Ideally, continue the loop and try again later. After a certain amount of time, do panic/Fatal
			log.Fatal(err)
		}
		fmt.Printf("Iteration %d: Requested %d, got %d (request took %v with a max wait of %ds)\n", x, c.BatchSize, len(msgs), time.Since(t), c.DequeueWait)

		// Handle case of zero messages
		if len(msgs) == 0 && c.MaxEmptyResults != nil {
			emptyResultCount++
			if emptyResultCount >= *c.MaxEmptyResults {
				fmt.Println("Queue is empty - breaking work loop")
				break
			}
		} else {
			// Reset count if queue isn't empty
			emptyResultCount = 0
		}

		// Process each message
		for i, msg := range msgs {
			// Determine if we have time to process another message
			if time.Since(start) > c.MaxDuration+c.MsgDuration {
				fmt.Println("Not enough time to process message - breaking work loop")
				break batchLoop
			}

			// Simulate Message Processing
			time.Sleep(c.MsgDuration)
			fmt.Printf(" %d: %q\n", i, msg.Body)

			// Example case for error processing
			var processingError error
			if processingError != nil {
				// Move error to error queue
				// errorQueue.Push(msg)
			}

			totalProcessedCount++

			// Delete processed message from queue
			err = msg.Delete()
			if err != nil {
				fmt.Println("Could not delete msg:", msg.Body, err)
			}
		}
	}

	fmt.Printf("Worker ending after %s and processing %d messages", time.Since(start), totalProcessedCount)
}