uwe

uwe

United Workers Environment

WARN: current state is unsatable and not work. Use routines from Armory upstream

Worker

Worker is an interface for async workers which launches and manages by the Chief.

The main ideas of the Worker:

• this is simple and lightweight worker;
• it can communicate with surroundings through channels, message queues, etc;
• worker must do one or few small jobs;
• should be able to run the worker as one independent process;

For example microservice for the image storing can have three workers:

1. Rest API - receives and gives out images from user;
2. Image resizer - compresses and resize the image for the thumbnails;
3. Uploader - uploads files to the S3 storage.

All this workers are part of one microservice, in one binary and able to run them as a one process or as a three different.

Method list:

• Init(context.Context) Worker - initializes new instance of the Worker implementation.
• Run() - starts the Worker instance execution. This should be a blocking call, which in normal mode will be executed in goroutine.

Chief

Chief is a head of workers, it must be used to register, initialize and correctly start and stop asynchronous executors of the type Worker.

Method list:

• AddWorker(name string, worker Worker - register a new Worker to the Chief worker pool.
• EnableWorkers(names ...string) - enables all worker from the names list. By default, all added workers are enabled.
• EnableWorker(name string) - enables the worker with the specified name. By default, all added workers are enabled.
• IsEnabled(name string) bool - checks is enable worker with passed name.
• InitWorkers(logger *logrus.Entry) - initializes all registered workers.
• Start(parentCtx context.Context) - runs all registered workers, locks until the parentCtx closes, and then gracefully stops all workers.

In InitWorkers Chief insert in the context his logger (*logrus.Entry), so at the worker you can took by key routines.CtxKeyLog and use it.

// .....
func (w *MyWorker) Init(parentCtx context.Context) routines.Worker {
    logger, ok := parentCtx.Value(routines.CtxKeyLog).(*logrus.Entry)
    if !ok {
        // process error
    }
    // add field with worker name.
    w.Logger = logger.WithField("worker", "my-cool-worker")
    
    // ... do other stuff ... //
    
    return w
}
// .....

Usage

Just define the routines.Chief variable, register your worker using the AddWorker method. Before starting, you must initialize registered workers using the InitWorkers(*logrus.Entry) method.

A very simple example:

package main

import (
    "github.com/lancer-kit/armory/routines"
    "context"
)

var WorkersChief routines.Chief

func init()  {
    WorkersChief = routines.Chief{}
    WorkersChief.AddWorker("my-awesome-worker", &MyWorker{})
    // `MyWorker` is a type which implement `Worker` interface.
}

func main () {
    WorkersChief.InitWorkers(nil)
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        WorkersChief.Start(ctx)
    }()
    
    defer func() {
        cancel()
    }()
}