Goblero

Pure Go, Simple, Embedded, Persistent Job Queue, backed by BadgerDB

DO NOT USE IN PRODUCTION This library is still in Alpha / Work In Progress

About Goblero

Intro article: Introducing Goblero: a Go Embedded Job Queue

Pure Go library, no cgo
Simple, embedded, persistent job queue
Provides in-process job processing to any Go app
The jobs/status changes are persisted to disk after each operation and pending jobs can continue processing after an app restart or a crash
Allows multiple “processors”, each processor/worker processes one job at a time then is assigned a new job, etc
The storage engine used is [BadgerDB]

P.S: Why is the library named Goblero ? Go for the Go programming language obviously, and Badger in french is “Blaireau”, but blero is easier to pronounce :)

Usage

The full API is documented on godoc.org. There is also a demo repo goblero-demo

Get package

go get -u github.com/didil/goblero/pkg/blero

API

// Create a new Blero backend
bl := blero.New("db/")

// Start Blero
bl.Start()

// defer Stopping Blero
defer bl.Stop()

// register a processor
bl.RegisterProcessorFunc(func(j *blero.Job) error {
  // Do some processing, access job name with j.Name, job data with j.Data
})

// enqueue a job
bl.EnqueueJob("MyJob", []byte("My Job Data"))

Demo

package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/didil/goblero/pkg/blero"
)

func main() {
	// Parse flags
	n := flag.Int("n", 1, "number of processors")
	flag.Parse()

	// Create a new Blero backend
	bl := blero.New("db/")
	// Start Blero
	err := bl.Start()
	if err != nil {
		log.Fatal(err)
	}

	// Register processor(s)
	for i := 1; i <= *n; i++ {
		pI := i
		fmt.Printf("Registering Processor %v ...\n", pI)
		bl.RegisterProcessorFunc(func(j *blero.Job) error {
			fmt.Printf("[Processor %v] Processing job: %v - data: %v\n", pI, j.Name, string(j.Data))
			// Simulate processing
			time.Sleep(2 * time.Second)
			fmt.Printf("[Processor %v] Done Processing job: %v\n", pI, j.Name)

			return nil
		})
	}

	// Enqueue jobs
	if len(os.Args) > 1 && os.Args[1] == "enqueue" {
		fmt.Println("Enqueuing jobs ...")
		for i := 1; i <= 50; i++ {
			jobName := fmt.Sprintf("Job #%v", i)
			jobData := []byte(fmt.Sprintf("Job Data #%v", i))
			_, err := bl.EnqueueJob(jobName, jobData)
			if err != nil {
				log.Fatal(err)
			}
		}
	}

	// Wait for SIGTERM or SIGINT to stop Blero and exit
	var exitCh = make(chan os.Signal)
	signal.Notify(exitCh, syscall.SIGINT)
	signal.Notify(exitCh, syscall.SIGTERM)
	s := <-exitCh
	fmt.Printf("Caught signal %v. Exiting ...\n", s)

	// Stop Blero
	bl.Stop()
	os.Exit(0)
}

Benchmarks

# Core i5 laptop / 8GB Ram / SSD 
make bench
BenchmarkEnqueue/EnqueueJob-4          50000            159942 ns/op (~ 6250 ops/s)
BenchmarkEnqueue/dequeueJob-4           5000           2767260 ns/op (~  361 ops/s)

Todo:

Restart interrupted jobs after app restart/crashes
Sweep completed jobs from the “complete” queue
Failed Jobs retry options
Allow batch enqueuing
Add support for Go contexts
Test in real conditions under high load
Expose Prometheus Metrics in an Http handler
Optimize performance / Locking

Goblero 介绍

参考文档: https://blog.csdn.net/gitblog_00002/article/details/139540185

Goblero：一个简单、嵌入式的Go持久化任务队列

项目介绍

Goblero 是一个用纯Go语言编写的简单、嵌入式、持久化的任务队列库。它基于 BadgerDB 作为存储引擎，能够在应用程序重启或崩溃后继续处理未完成的任务。Goblero的设计目标是提供一个轻量级、易于集成的任务队列解决方案，适用于需要本地持久化任务处理的应用场景。

项目技术分析

技术栈

Go语言：Goblero完全使用Go语言编写，不依赖CGO，确保了跨平台的兼容性和编译的便捷性。
BadgerDB：作为底层存储引擎，BadgerDB提供了高性能的键值存储，适合用于任务队列的持久化需求。
嵌入式设计：Goblero的设计理念是嵌入式，这意味着它可以轻松集成到任何Go应用程序中，无需额外的服务依赖。

核心功能

持久化任务处理：任务的状态变化会在每次操作后持久化到磁盘，确保在应用程序重启或崩溃后能够继续处理未完成的任务。
多处理器支持：支持多个处理器（worker）同时工作，每个处理器一次处理一个任务，处理完成后继续获取新任务。
简单API：Goblero提供了简洁的API，易于上手和集成。

项目及技术应用场景

Goblero适用于以下场景：

后台任务处理：适用于需要异步处理任务的应用程序，如邮件发送、数据处理、定时任务等。
嵌入式系统：由于其嵌入式设计和轻量级特性，Goblero非常适合嵌入式系统中的任务队列需求。
本地持久化任务队列：对于需要在本地持久化任务状态的应用程序，Goblero提供了一个简单且可靠的解决方案。

项目特点

纯Go实现：完全使用Go语言编写，不依赖CGO，确保了跨平台的兼容性和编译的便捷性。
简单易用：Goblero提供了简洁的API，易于集成和使用。
持久化支持：任务状态持久化到磁盘，确保在应用程序重启或崩溃后能够继续处理未完成的任务。
高性能：基于BadgerDB的高性能存储引擎，Goblero能够在高负载下保持良好的性能。
开源社区支持：Goblero是一个开源项目，欢迎社区贡献和反馈，共同推动项目的发展。

总结

Goblero是一个简单、嵌入式的Go持久化任务队列库，适用于需要本地持久化任务处理的应用场景。其纯Go实现、简单易用的API、持久化支持和高性能特性，使其成为一个值得尝试的任务队列解决方案。虽然目前仍处于Alpha阶段，但Goblero已经展示了其潜力和价值，未来有望成为Go开发者处理任务队列的首选工具之一。

如果你正在寻找一个轻量级、易于集成的任务队列解决方案，不妨试试Goblero，它可能会成为你项目中的得力助手。