Complete rewrite is planned. Waiting on good time allotment to work on it

[maietta]

After careful review of the code, I have decided to begin my journey into rewriting Chadburn with the following goals:

• Use as few dependencies as possible.
• Use only official Docker Events API.
• Maintain backwards compatibility with Ofelia and the Chadburn fork.

The fsouza/go-dockerclient dependency is being used in order to track docker events for updated service labels. The way this library works requires pulling and is not capable of real-time monitoring of docker events. I am removing this dependency in favor of the following core prototype listener as seen below:

package main

import (
	"context"
	"fmt"
	"io"
	"strings"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
)

/*
	{
	Status:destroy
	ID:f1a09c48aa893fb68388f1ebeda0ea12dc4df7bcba9a98abab3abb9cee06e9e5
	From:nginx
	Type:container
	Action:destroy
	Actor: {
		ID:f1a09c48aa893fb68388f1ebeda0ea12dc4df7bcba9a98abab3abb9cee06e9e5
		Attributes:map[
			chadburn.enabled:true
			chadburn.job-exec.test-exec-job.command:uname -a
			chadburn.job-exec.test-exec-job.schedule:@every 5s
			image:nginx maintainer:NGINX Docker Maintainers <docker-maint@nginx.com>
			name:festive_tharp
		]
		}
	Scope:local
	Time:1641000210
	TimeNano:1641000210626965000
*/

func main() {

	cli, err := client.NewEnvClient()
	if err != nil {
		panic(err)
	}

	messages, errs := cli.Events(context.Background(), types.EventsOptions{})

EventLoop:
	for {
		select {
		case err := <-errs:
			if err != nil && err != io.EOF {
				panic(err)
			}
			if err != nil && err == io.EOF {
				fmt.Printf("lost connection with Docker. exiting\n")
				break EventLoop
			}
		case message := <-messages:

			if message.Action == "start" || message.Action == "die" {

				container_name := message.Actor.Attributes["name"]
				fmt.Println("Registered:", container_name)

				//	fmt.Printf("%+v\n\n", message)

				// Get service labels from the event
				enabled := message.Actor.Attributes["chadburn.enabled"]

				if enabled == "true" {

					exec_type := ""
					exec_cmd := ""

					// Get attributes that start with chadburn.job-*
					for k, v := range message.Actor.Attributes {
						if strings.HasPrefix(k, "chadburn.job-") {
							exec_type = k
							exec_cmd = v
							fmt.Println(exec_type, "", exec_cmd)
						}
					}

					fmt.Printf("%+v\n\n", message)

					if message.Actor.Attributes["chadburn.job-exec"] == "true" {
						// This job is executed inside of a running container.
					} else if message.Actor.Attributes["chadburn.job-run"] == "true" {
						// Runs a command inside of a new container, using a specific image.
					} else if message.Actor.Attributes["chadburn.job-local"] == "true" {
						// Runs the command inside of the host running Chadburn.
					} else if message.Actor.Attributes["chadburn.job-service-run"] == "true" {
						// Runs the command inside a new "run-once" service, for running inside a swarm
					}

				}

			}

			if message.Action == "stop" || message.Action == "die" || message.Action == "destroy" {
				// Dereigster the service

			}

		}
	}

}

[maietta]

Note for those following:

I would like to inform you that I have plans to commence work on rewriting Chadburn before the end of this month, April 2022. The rebuild will focus on achieving the following objectives:

For the users:

• Providing easily understandable documentation, which includes real-world usage examples.
• Creating a user-friendly guide on Docker Service labels, offering a concise overview of how Chadburn utilizes them.
• Developing a website-based Chadburn configuration generator that encompasses all configuration methods, along with instructions for implementation in Caprover and other systems.
• Designing a flowchart using MermaidJS to illustrate how Chadburn fits into the ecosystem.

Features:

• Ensuring compatibility with both Docker and Kubernetes (although the approach is yet to be finalized).
• Supporting multi-host environments, such as Docker Swarm.
• Incorporating built-in methods for sending alerts, such as webhooks and push notifications, without disrupting the scheduler.
• Considering the possibility of adding a web API extension for managing service containers and webhooks (subject to further consideration).

Tooling:

• Providing an Ansible example to facilitate the creation or teardown of a 3-node Docker Swarm cluster for testing Chadburn.
• Enhancing Github Actions for streamlined building, testing, and publishing of releases across various architectures.
• Offering Bash scripts for quickly demonstrating label adjustments (with the potential assistance of Ansible).

[maietta]

Update late Oct:

I don't make money working for free, so bear with me here, plz.

I'm working on projects to keep money coming in but I will be spending time sometime before the year is out to try and get an experimental release available with the goal of being before this year is out.

I apologize for the really long delay on this. There's a lot of improvements I want to make including ability to easily review and remove labels on any container/service.