func init() {
// Parse the flags
flag.Parse()
cnf = config.Config{
Broker: *broker,
ResultBackend: *resultBackend,
Exchange: *exchange,
ExchangeType: *exchangeType,
DefaultQueue: *defaultQueue,
BindingKey: *bindingKey,
}
// Parse the config
// NOTE: If a config file is present, it has priority over flags
data, err := config.ReadFromFile(*configPath)
if err == nil {
err = config.ParseYAMLConfig(&data, &cnf)
errors.Fail(err, "Could not parse config file")
}
server, err := machinery.NewServer(&cnf)
errors.Fail(err, "Could not initialize server")
// Register tasks
tasks := map[string]interface{}{
"add": exampletasks.Add,
"multiply": exampletasks.Multiply,
}
server.RegisterTasks(tasks)
// The second argument is a consumer tag
// Ideally, each worker should have a unique tag (worker1, worker2 etc)
worker = server.NewWorker("machinery_worker")
}
func _setup(brokerURL, backend string) *machinery.Server {
cnf := config.Config{
Broker: brokerURL,
ResultBackend: backend,
Exchange: "test_exchange",
ExchangeType: "direct",
DefaultQueue: "test_queue",
BindingKey: "test_task",
}
server, err := machinery.NewServer(&cnf)
errors.Fail(err, "Could not initialize server")
tasks := map[string]interface{}{
"add": func(args ...int64) (int64, error) {
sum := int64(0)
for _, arg := range args {
sum += arg
}
return sum, nil
},
"multiply": func(args ...int64) (int64, error) {
sum := int64(1)
for _, arg := range args {
sum *= arg
}
return sum, nil
},
}
server.RegisterTasks(tasks)
return server
}
func init() {
// Parse the flags
flag.Parse()
cnf = config.Config{
Broker: *broker,
ResultBackend: *resultBackend,
Exchange: *exchange,
ExchangeType: *exchangeType,
DefaultQueue: *defaultQueue,
BindingKey: *bindingKey,
}
// Parse the config
// NOTE: If a config file is present, it has priority over flags
data, err := config.ReadFromFile(*configPath)
if err == nil {
err = config.ParseYAMLConfig(&data, &cnf)
errors.Fail(err, "Could not parse config file")
}
server, err = machinery.NewServer(&cnf)
errors.Fail(err, "Could not initialize server")
}
func main() {
/*
* First, let's try sending a single task
*/
initTasks()
fmt.Println("Single task:")
asyncResult, err := server.SendTask(&task0)
errors.Fail(err, "Could not send task")
result, err := asyncResult.Get()
errors.Fail(err, "Getting task state failed with error")
fmt.Printf("1 + 1 = %v\n", result.Interface())
/*
* Now let's explore ways of sending multiple tasks
*/
// Now let's try a parallel execution
initTasks()
fmt.Println("Group of tasks (parallel execution):")
group := machinery.NewGroup(&task0, &task1, &task2)
asyncResults, err := server.SendGroup(group)
errors.Fail(err, "Could not send group")
for _, asyncResult := range asyncResults {
result, err = asyncResult.Get()
errors.Fail(err, "Getting task state failed with error")
fmt.Printf(
"%v + %v = %v\n",
asyncResult.Signature.Args[0].Value,
asyncResult.Signature.Args[1].Value,
result.Interface(),
)
}
// Now let's try a group with a chord
initTasks()
fmt.Println("Group of tasks with a callback (chord):")
group = machinery.NewGroup(&task0, &task1, &task2)
chord := machinery.NewChord(group, &task4)
chordAsyncResult, err := server.SendChord(chord)
errors.Fail(err, "Could not send chord")
result, err = chordAsyncResult.Get()
errors.Fail(err, "Getting task state failed with error")
fmt.Printf("(1 + 1) * (2 + 2) * (5 + 6) = %v\n", result.Interface())
// Now let's try chaining task results
initTasks()
fmt.Println("Chain of tasks:")
chain := machinery.NewChain(&task0, &task1, &task2, &task3)
chainAsyncResult, err := server.SendChain(chain)
errors.Fail(err, "Could not send chain")
result, err = chainAsyncResult.Get()
errors.Fail(err, "Getting chain result failed with error")
fmt.Printf("(((1 + 1) + (2 + 2)) + (5 + 6)) * 4 = %v\n", result.Interface())
}
func main() {
err := worker.Launch()
errors.Fail(err, "Could not launch worker")
}