gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/lifecycle.v2/lifecycle.go

package lifecycle

import (
	"gitee.com/sy_183/go-common/lifecycle.v2/future"
	"sync/atomic"
	"unsafe"
)

type FutureType uint

const (
	FutureTypeStarted = FutureType(iota)
	FutureTypeClosed  = FutureType(iota)
	futureTypes
)

type Future future.Future[error]

type BeforeCallbackType uint

const (
	BeforeStart = BeforeCallbackType(iota)
	BeforeClose
	beforeCallbackTypes
)

type AfterCallbackType uint

const (
	AfterStart = AfterCallbackType(iota)
	AfterClose
	AfterRun
	afterCallbackTypes
)

type PanicCallbackType uint

const (
	PanicOnStarting = PanicCallbackType(iota)
	PanicOnRunning
	panicCallbackTypes
)

type (
	BeforeCallback = func(Lifecycle) error
	AfterCallback  = func(Lifecycle, error)
	PanicCallback  = func(Lifecycle, any) error
)

type atomicEntry[V any] struct {
	value V
	next  atomic.Pointer[atomicEntry[V]]
}

type atomicList[V any] struct {
	head *atomicEntry[V]
	tail atomic.Pointer[atomicEntry[V]]
}

func (l *atomicList[V]) init() {
	l.head = new(atomicEntry[V])
	l.tail.Store(l.head)
}

func (l *atomicList[V]) append(v V) *atomicEntry[V] {
	e := &atomicEntry[V]{value: v}
	for {
		tail := l.tail.Load()
		if tail.next.CompareAndSwap(nil, e) {
			l.tail.Store(e)
			return e
		}
	}
}

type onceFuture struct {
	future.Future[error]
	once atomic.Bool
	next atomic.Pointer[onceFuture]
}

func (f *onceFuture) Complete(err error) {
	if f.once.CompareAndSwap(false, true) {
		f.Future.Complete(err)
	}
}

type onceFutures struct {
	head *onceFuture
	tail atomic.Pointer[onceFuture]
}

func (fs *onceFutures) init() {
	fs.head = new(onceFuture)
	fs.tail.Store(fs.head)
}

func (fs *onceFutures) append(f future.Future[error]) *onceFuture {
	of := &onceFuture{Future: f}
	for {
		tail := fs.tail.Load()
		if tail.next.CompareAndSwap(nil, of) {
			fs.tail.Store(of)
			return of
		}
	}
}

func (fs *onceFutures) Complete(err error) {
	for of := fs.head.next.Load(); of != nil; of = of.next.Load() {
		of.Complete(err)
	}
}

type Lifecycle interface {
	// Run 在当前协程运行生命周期的整体流程，包括启动的过程和运行的过程。当启动失败或运行退出包含
	// 错误信息时，此函数返回此错误。
	Run() error

	// Start 在当前协程执行生命周期的启动流程，当启动成功后会在新的协程运行此生命周期。当启动失败
	// 时返回错误。
	Start() error

	// Background 在确定可以启动此生命周期后，使用新的协程运行生命周期的整体流程。返回错误则说明
	// 不能启动。
	Background() error

	// Close 通知生命周期进行关闭流程，执行此流程返回成功后，生命周期将在清理资源后关闭。
	Close() error

	// Shutdown 关闭生命周期，如果返回错误，则说明通知生命周期进行关闭失败。否则将等待生命周期完
	// 全关闭
	Shutdown() error

	// State 返回生命周期的当前状态，详见 State 类型。
	State() State

	// Future 向生命周期中添加指定类型(详见 FutureType)的 future，用于跟踪生命周期状态的变
	// 化。若生命周期状态已切换到触发状态及以后，则会在此函数中完成指定的 future。
	Future(FutureType, Future) Future

	// Waiter 获取生命周期状态变化的通知通道。
	Waiter(FutureType) <-chan error

	//Wait(typ FutureType, interrupter chan struct{}) error

	Before(BeforeCallbackType, BeforeCallback)

	After(AfterCallbackType, AfterCallback)

	OnPanic(PanicCallbackType, PanicCallback)
}

type DefaultLifecycle struct {
	runner          Runner
	futures         [futureTypes]onceFutures
	beforeCallbacks [beforeCallbackTypes]atomicList[BeforeCallback]
	afterCallbacks  [afterCallbackTypes]atomicList[AfterCallback]
	panicCallback   [panicCallbackTypes]PanicCallback
	state           atomic.Uint32
	startErr        error
	exitErr         error
}

func New(runner Runner) *DefaultLifecycle {
	if runner == nil {
		runner = NopRunner()
	}
	l := &DefaultLifecycle{runner: runner}
	for i := range l.futures {
		l.futures[i].init()
	}
	for i := range l.beforeCallbacks {
		l.beforeCallbacks[i].init()
	}
	for i := range l.afterCallbacks {
		l.afterCallbacks[i].init()
	}
	return l
}

func NewWithFunc(startFn StartFunc, runFn RunFunc, closeFn CloseFunc) *DefaultLifecycle {
	return New(FuncRunner(startFn, runFn, closeFn))
}

func NewInterrupted(runner InterruptedRunner) *DefaultLifecycle {
	return New(WrapInterruptedRunner(runner))
}

func NewInterruptedWithFunc(startFn InterruptedStartFunc, runFn InterruptedRunFunc) *DefaultLifecycle {
	return New(WrapInterruptedRunner(FuncInterruptedRunner(startFn, runFn)))
}

func NewInterruptedWithStarter(starter InterruptedStarter) *DefaultLifecycle {
	return New(InterruptedStarterRunner(starter))
}

func NewInterruptedWithStarterFunc(starterFn InterruptedStarterFunc) *DefaultLifecycle {
	return New(InterruptedStarterRunner(FuncInterruptedStarter(starterFn)))
}

func (l *DefaultLifecycle) addFuture(typ FutureType, f Future) (*onceFuture, State) {
	return l.futures[typ].append(f), State(l.state.Load())
}

func (l *DefaultLifecycle) completeFutures(typ FutureType, err error) {
	l.futures[typ].Complete(err)
}

func (l *DefaultLifecycle) addBeforeCallback(typ BeforeCallbackType, callback BeforeCallback) {
	l.beforeCallbacks[typ].append(callback)
}

func (l *DefaultLifecycle) executeBeforeCallbacks(typ BeforeCallbackType) error {
	for e := l.beforeCallbacks[typ].head.next.Load(); e != nil; e = e.next.Load() {
		if err := e.value(l); err != nil {
			return err
		}
	}
	return nil
}

func (l *DefaultLifecycle) addAfterCallback(typ AfterCallbackType, callback AfterCallback) {
	l.afterCallbacks[typ].append(callback)
}

func (l *DefaultLifecycle) executeAfterCallbacks(typ AfterCallbackType, err error) {
	for e := l.afterCallbacks[typ].head.next.Load(); e != nil; e = e.next.Load() {
		e.value(l, err)
	}
}

func (l *DefaultLifecycle) loadPanicCallback(typ PanicCallbackType) PanicCallback {
	up := atomic.LoadUintptr((*uintptr)(unsafe.Pointer(&l.panicCallback[typ])))
	return *(*PanicCallback)(unsafe.Pointer(&up))
}

func (l *DefaultLifecycle) storePanicCallback(typ PanicCallbackType, callback PanicCallback) {
	up := *(*uintptr)(unsafe.Pointer(&callback))
	atomic.StoreUintptr((*uintptr)(unsafe.Pointer(&l.panicCallback[typ])), up)
}

func (l *DefaultLifecycle) handlePanic(typ PanicCallbackType, ep *error) {
	if callback := l.loadPanicCallback(typ); callback != nil {
		if e := recover(); e != nil {
			*ep = callback(l, e)
		}
	}
	return
}

func (l *DefaultLifecycle) doStart() (err error) {
	defer l.handlePanic(PanicOnStarting, &err)
	return l.runner.DoStart(l)
}

func (l *DefaultLifecycle) start() error {
	if l.startErr = l.executeBeforeCallbacks(BeforeStart); l.startErr != nil {
		return l.startErr
	}
	l.startErr = l.doStart()
	l.executeAfterCallbacks(AfterStart, l.startErr)
	if l.startErr != nil {
		l.exitErr = l.startErr
		l.state.Store(uint32(StateClosed))
		l.completeFutures(FutureTypeStarted, l.startErr)
		l.completeFutures(FutureTypeClosed, l.exitErr)
	} else {
		l.state.Store(uint32(StateRunning))
		l.completeFutures(FutureTypeStarted, nil)
	}
	return l.startErr
}

func (l *DefaultLifecycle) doRun() (err error) {
	defer l.handlePanic(PanicOnRunning, &err)
	return l.runner.DoRun(l)
}

func (l *DefaultLifecycle) run() error {
	l.exitErr = l.runner.DoRun(l)
	l.executeAfterCallbacks(AfterRun, l.exitErr)
	l.state.Store(uint32(StateClosed))
	l.completeFutures(FutureTypeClosed, nil)
	return l.exitErr
}

func (l *DefaultLifecycle) Runner() Runner {
	return l.runner
}

func (l *DefaultLifecycle) Run() error {
	if !l.state.CompareAndSwap(uint32(StateReady), uint32(StateStarting)) {
		return l.waitClosed()
	}
	if err := l.start(); err != nil {
		return err
	}
	return l.run()
}

func (l *DefaultLifecycle) Start() error {
	if !l.state.CompareAndSwap(uint32(StateReady), uint32(StateStarting)) {
		return l.waitStarted()
	}
	if err := l.start(); err != nil {
		return err
	}
	go l.run()
	return nil
}

func (l *DefaultLifecycle) Background() error {
	if !l.state.CompareAndSwap(uint32(StateReady), uint32(StateStarting)) {
		return nil
	}
	go func() {
		if err := l.start(); err == nil {
			l.run()
		}
	}()
	return nil
}

func (l *DefaultLifecycle) Close() error {
	if l.state.CompareAndSwap(uint32(StateReady), uint32(StateClosed)) {
		// 状态为 Ready 则直接转变状态为 Closed，并触发 future
		l.completeFutures(FutureTypeStarted, nil)
		l.completeFutures(FutureTypeClosed, nil)
		return nil
	}
	if state := State(l.state.Load()); state < StateClosed {
		// 状态为 Starting 或 Running，执行 runner 的 DoClose 方法通知生命周期进行关闭
		if err := l.executeBeforeCallbacks(BeforeClose); err != nil {
			return err
		}
		err := l.runner.DoClose(l)
		l.executeAfterCallbacks(AfterClose, err)
		return err
	}
	return nil
}

func (l *DefaultLifecycle) Shutdown() error {
	if err := l.Close(); err != nil {
		return err
	}
	l.waitClosed()
	return nil
}

func (l *DefaultLifecycle) State() State {
	return State(l.state.Load())
}

func (l *DefaultLifecycle) waitStarted() error {
	state := l.State()
	if state > StateStarting {
		return l.startErr
	}
	f := make(future.ChanFuture[error], 1)
	if _, ns := l.addFuture(FutureTypeStarted, f); ns > StateStarting {
		return l.startErr
	} else {
		return <-f
	}
}

func (l *DefaultLifecycle) waitClosed() error {
	state := l.State()
	if state > StateRunning {
		return l.exitErr
	}
	f := make(future.ChanFuture[error], 1)
	if _, ns := l.addFuture(FutureTypeClosed, f); ns > StateRunning {
		return l.exitErr
	} else {
		return <-f
	}
}

func (l *DefaultLifecycle) StartedFuture(f Future) Future {
	state := l.State()
	if state > StateStarting {
		// 状态已经高于触发 future 的阈值，不添加到生命周期中，并且立即完成此 future
		f.Complete(l.startErr)
	} else if of, ns := l.addFuture(FutureTypeStarted, f); ns > StateStarting {
		// 在添加 future 时状态发生切换，由于不确定运行协程是否完成此 future，此处需要手
		// 动完成，由 onceFuture 来保证 future 只会被完成一次
		of.Complete(l.startErr)
	} else {
		// 将 future 添加到了生命周期中，并且状态没有切换到高于触发 future 的阈值，由生
		// 命周期运行协程完成此 future
	}
	return f
}

func (l *DefaultLifecycle) ClosedFuture(f Future) Future {
	state := l.State()
	if state > StateRunning {
		// 状态已经高于触发 future 的阈值，不添加到生命周期中，并且立即完成此 future
		f.Complete(l.exitErr)
	} else if of, ns := l.addFuture(FutureTypeClosed, f); ns > StateRunning {
		// 在添加 future 时状态发生切换，由于不确定运行协程是否完成此 future，此处需要手
		// 动完成，由 onceFuture 来保证 future 只会被完成一次
		of.Complete(l.exitErr)
	} else {
		// 将 future 添加到了生命周期中，并且状态没有切换到高于触发 future 的阈值，由生
		// 命周期运行协程完成此 future
	}
	return f
}

func (l *DefaultLifecycle) Future(typ FutureType, f Future) Future {
	switch typ {
	case FutureTypeStarted:
		return l.StartedFuture(f)
	case FutureTypeClosed:
		return l.ClosedFuture(f)
	}
	return nil
}

func (l *DefaultLifecycle) Waiter(typ FutureType) <-chan error {
	if typ < futureTypes {
		waiter := make(future.ChanFuture[error], 1)
		l.Future(typ, waiter)
		return waiter
	}
	return nil
}

func (l *DefaultLifecycle) Before(typ BeforeCallbackType, callback BeforeCallback) {
	if typ < beforeCallbackTypes {
		l.addBeforeCallback(typ, callback)
	}
}

func (l *DefaultLifecycle) After(typ AfterCallbackType, callback AfterCallback) {
	if typ < afterCallbackTypes {
		l.addAfterCallback(typ, callback)
	}
}

func (l *DefaultLifecycle) OnPanic(typ PanicCallbackType, callback PanicCallback) {
	if typ < panicCallbackTypes {
		l.storePanicCallback(typ, callback)
	}
}