Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
3.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

package engine

import (
	"context"
	"slices"
	"time"

	"github.com/fluxerapp/fluxer/fluxer_rexctl/internal/stack"
)

const (
	readyInterval  = 5 * time.Second
	crashRestarts  = 5
	freshContainer = 15 * time.Minute
)

func (p *Project) WaitReady(ctx context.Context, timeout time.Duration, onTick func(Readiness), skip ...string) error {
	if timeout <= 0 {
		timeout = DefaultReadyTimeout
	}
	deadline := time.Now().Add(timeout)
	first := map[string]int{}
	ticker := time.NewTicker(readyInterval)
	defer ticker.Stop()
	for {
		containers, err := p.PS(ctx)
		if err != nil {
			return err
		}
		containers = slices.DeleteFunc(containers, func(c Container) bool { return slices.Contains(skip, c.Service) })
		services := p.Services()
		if services == nil {
			services = servicesOf(containers)
		}
		services = slices.DeleteFunc(services, func(s string) bool { return slices.Contains(skip, s) })
		r, fatal := Assess(services, containers)
		if onTick != nil {
			onTick(r)
		}
		if len(r.NotReady) == 0 && len(r.Failed) == 0 {
			return nil
		}
		crashing := crashLooping(r, containers, first)
		if fatal || len(crashing) > 0 || time.Now().After(deadline) {
			return &NotReadyError{Readiness: r, Fatal: fatal, Crashing: crashing}
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-ticker.C:
		}
	}
}

func (p *Project) Crashing(ctx context.Context) error {
	containers, err := p.PS(ctx)
	if err != nil {
		return err
	}
	services := p.Services()
	if services == nil {
		services = servicesOf(containers)
	}
	r, fatal := Assess(services, containers)
	if crashing := crashLooping(r, containers, map[string]int{}); len(crashing) > 0 {
		return &NotReadyError{Readiness: r, Fatal: fatal, Crashing: crashing}
	}
	return nil
}

func servicesOf(containers []Container) []string {
	var out []string
	for _, c := range containers {
		if !slices.Contains(out, c.Service) {
			out = append(out, c.Service)
		}
	}
	return out
}

func Assess(services []string, containers []Container) (Readiness, bool) {
	r := Readiness{Ready: []string{}, NotReady: []string{}, Failed: []string{}}
	fatal := false
	byService := map[string][]Container{}
	for _, c := range containers {
		byService[c.Service] = append(byService[c.Service], c)
	}
	for _, svc := range services {
		cs := byService[svc]
		if len(cs) == 0 {
			r.NotReady = append(r.NotReady, svc)
			continue
		}
		state := "ready"
		for _, c := range cs {
			switch s := containerState(svc, c); {
			case s == "failed":
				state = "failed"
				if stack.OneShot[svc] {
					fatal = true
				}
			case s == "waiting" && state == "ready":
				state = "waiting"
			}
		}
		switch state {
		case "ready":
			r.Ready = append(r.Ready, svc)
		case "failed":
			r.Failed = append(r.Failed, svc)
		default:
			r.NotReady = append(r.NotReady, svc)
		}
	}
	slices.Sort(r.Ready)
	slices.Sort(r.NotReady)
	slices.Sort(r.Failed)
	return r, fatal
}

func crashLooping(r Readiness, containers []Container, first map[string]int) []string {
	var out []string
	for _, c := range containers {
		if stack.OneShot[c.Service] || slices.Contains(r.Ready, c.Service) {
			continue
		}
		base, ok := first[c.ID]
		if !ok {
			base = c.RestartCount
			if time.Since(c.Created) < freshContainer {
				base = 0
			}
			first[c.ID] = base
		}
		if c.RestartCount-base >= crashRestarts && !slices.Contains(out, c.Service) {
			out = append(out, c.Service)
		}
	}
	slices.Sort(out)
	return out
}

func containerState(service string, c Container) string {
	if stack.OneShot[service] {
		switch c.State {
		case "exited":
			if c.ExitCode == 0 {
				return "ready"
			}
			return "failed"
		case "dead":
			return "failed"
		}
		return "waiting"
	}
	switch c.State {
	case "running":
		switch c.Health {
		case "", "healthy":
			return "ready"
		case "unhealthy":
			return "failed"
		}
		return "waiting"
	case "exited", "dead":
		return "failed"
	}
	return "waiting"
}