// Will create a new queue, all fields are optional. // Queue type cannot be changed. func ConfigCreateQueue(queueInfo QueueInfo, settings *config.Settings) (QueueInfo, error) { if queueInfo.Name == "" { return QueueInfo{}, errors.New("Name of queue is empty") } url := api.Action(config.ManualConfig("iron_mq", settings), "queues", queueInfo.Name) in := struct { Queue QueueInfo `json:"queue"` }{ Queue: queueInfo, } var out struct { Queue QueueInfo `json:"queue"` } err := url.Req("PUT", in, &out) return out.Queue, err }
// ConfigNew uses the specified settings over configuration specified in an iron.json file or // environment variables to return a Queue object capable of acquiring information about or // modifying the queue specified by queueName. func ConfigNew(queueName string, settings *config.Settings) Queue { return Queue{Settings: config.ManualConfig("iron_mq", settings), Name: queueName} }
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) }