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

package lifecycle

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

var ErrWaitInterrupted = errors.New("wait interrupted")

func WaitFn(fn func() error, interrupter chan struct{}) error {
	waiter := make(chan error, 1)
	go func() { waiter <- fn() }()
	select {
	case err := <-waiter:
		return err
	case <-interrupter:
		return ErrWaitInterrupted
	}
}

type Waitable interface {
	Future(FutureType, Future) Future
}

func Wait[W Waitable](typ FutureType, interrupter chan struct{}, waitable W) (err error) {
	waiter := make(future.ChanFuture[error], 1)
	if waitable.Future(typ, waiter) == nil {
		return nil
	}
	select {
	case err = <-waiter:
		return err
	case <-interrupter:
		return ErrWaitInterrupted
	}
}

func WaitAll[W Waitable](typ FutureType, interrupter chan struct{}, waitable ...W) (err error) {
	if len(waitable) == 0 {
		return nil
	}
	count := len(waitable)
	waiter := make(future.ChanFuture[error], count)
	for _, w := range waitable {
		if w.Future(typ, waiter) == nil {
			count--
		}
	}
	for i := 0; i < count; i++ {
		select {
		case err = <-waiter:
			if err != nil {
				return err
			}
		case <-interrupter:
			return ErrWaitInterrupted
		}
	}
	return nil
}

func WaitAny[W Waitable](typ FutureType, interrupter chan struct{}, waitable ...W) (err error) {
	if len(waitable) == 0 {
		return nil
	}
	count := len(waitable)
	waiter := make(future.ChanFuture[error], len(waitable))
	for _, w := range waitable {
		if w.Future(typ, waiter) == nil {
			count--
		}
	}
	if count == 0 {
		return nil
	}
	select {
	case err = <-waiter:
		return err
	case <-interrupter:
		return ErrWaitInterrupted
	}
}

type Starter interface {
	Background() error

	Start() error

	Future(FutureType, Future) Future
}

func Start[S Starter](interrupter chan struct{}, starter S) (err error) {
	if err = starter.Background(); err != nil {
		return err
	}
	return Wait(FutureTypeStarted, interrupter, starter)
}

func SequenceStarter[S Starter](starters ...S) Starter {
	return NewWithFunc(func(Lifecycle) error {
		for _, starter := range starters {
			if err := starter.Start(); err != nil {
				return err
			}
		}
		return nil
	}, nil, nil)
}

func ParallelStarter[S Starter](lifecycles ...S) Starter {
	return NewWithFunc(func(Lifecycle) error {
		for _, lifecycle := range lifecycles {
			if err := lifecycle.Background(); err != nil {
				return err
			}
		}
		return WaitAll(FutureTypeStarted, nil, lifecycles...)
	}, nil, nil)
}

func ParallelStart[S Starter](interrupter chan struct{}, starters ...S) (err error) {
	for _, starter := range starters {
		if err = starter.Background(); err != nil {
			return err
		}
	}
	return WaitAll(FutureTypeStarted, interrupter, starters...)
}

func SequenceStart[S Starter](interrupter chan struct{}, starters ...S) (err error) {
	for _, starter := range starters {
		if err = Start(interrupter, starter); err != nil {
			return
		}
	}
	return nil
}

type Closer interface {
	Close() error

	Future(FutureType, Future) Future
}

func SequenceCloser[C Closer](closers ...C) Closer {
	closer := NewInterruptedWithFunc(nil, func(_ Lifecycle, interrupter chan struct{}) error {
		defer SequenceClose(closers...)
		<-interrupter
		return nil
	})
	closer.Start()
	return closer
}

func ParallelCloser[C Closer](closers ...C) Closer {
	closer := NewInterruptedWithFunc(nil, func(_ Lifecycle, interrupter chan struct{}) error {
		defer ParallelClose(closers...)
		<-interrupter
		return nil
	})
	closer.Start()
	return closer
}

func SequenceClose[C Closer](closers ...C) {
	waiter := make(future.ChanFuture[error], 1)
	for _, closer := range closers {
		if err := closer.Close(); err == nil {
			if closer.Future(FutureTypeClosed, waiter) != nil {
				<-waiter
			}
		}
	}
}

func ParallelClose[C Closer](closers ...C) {
	var count int
	waiter := make(future.ChanFuture[error], len(closers))
	for _, closer := range closers {
		if err := closer.Close(); err == nil {
			if closer.Future(FutureTypeClosed, waiter) != nil {
				count++
			}
		}
	}
	for i := 0; i < count; i++ {
		<-waiter
	}
}

type RelationStarter struct {
	Lifecycle Lifecycle
	Depends   []*RelationStarter
	Nowait    bool
	before    []*RelationStarter

	initializer sync.Once
	started     atomic.Bool
	ref         atomic.Int64
	waiter      *sync.WaitGroup

	err error
}

func NewRelationStarter(lifecycle Lifecycle, nowait bool, depends ...*RelationStarter) *RelationStarter {
	s := &RelationStarter{
		Lifecycle: lifecycle,
		Depends:   depends,
		Nowait:    nowait,
	}
	return s
}

func (s *RelationStarter) init() {
	for _, depend := range s.Depends {
		depend.before = append(depend.before, s)
	}
	if s.waiter == nil {
		s.waiter = new(sync.WaitGroup)
	}
	s.waiter.Add(1)
	for _, depend := range s.Depends {
		s.ref.Add(1)
		depend.waiter = s.waiter
		depend.initializer.Do(depend.init)
	}
}

func (s *RelationStarter) startComplete(err error) {
	defer s.waiter.Done()
	s.err = err
	if err != nil {
		for _, before := range s.before {
			if before.started.CompareAndSwap(false, true) {
				before.startComplete(err)
			}
		}
		return
	}
	for _, before := range s.before {
		if before.ref.Add(-1) == 0 {
			before.background()
		}
	}
}

func (s *RelationStarter) background() (err error) {
	if s.started.CompareAndSwap(false, true) {
		if s.Lifecycle == nil {
			s.startComplete(nil)
		} else {
			err = s.Lifecycle.Background()
			if s.Nowait {
				s.startComplete(nil)
			} else {
				if s.Lifecycle.Future(FutureTypeStarted, future.CallbackFuture[error](s.startComplete)) == nil {
					s.startComplete(nil)
				}
			}
		}
	}
	return
}

func (s *RelationStarter) Background() error {
	s.initializer.Do(s.init)
	for _, depend := range s.Depends {
		depend.Background()
	}
	if len(s.Depends) == 0 {
		return s.background()
	}
	return nil
}

func (s *RelationStarter) Wait() error {
	s.initializer.Do(s.init)
	s.waiter.Wait()
	return s.err
}

func (s *RelationStarter) Start() error {
	s.Background()
	return s.Wait()
}

type RelationCloser struct {
	Lifecycle Lifecycle
	Depends   []*RelationCloser

	initializer sync.Once
	ref         atomic.Int64
	waiter      *sync.WaitGroup

	err error
}

func NewRelationCloser(lifecycle Lifecycle, depends ...*RelationCloser) *RelationCloser {
	c := &RelationCloser{
		Lifecycle: lifecycle,
		Depends:   depends,
	}
	return c
}

func (c *RelationCloser) init() {
	if c.waiter == nil {
		c.waiter = new(sync.WaitGroup)
	}
	c.waiter.Add(1)
	for _, depend := range c.Depends {
		depend.ref.Add(1)
		depend.waiter = c.waiter
		depend.initializer.Do(depend.init)
	}
}

func (c *RelationCloser) closed(err error) {
	defer c.waiter.Done()
	c.err = err
	for _, depend := range c.Depends {
		if depend.ref.Add(-1) == 0 {
			depend.Close()
		}
	}
}

func (c *RelationCloser) close() (err error) {
	if c.Lifecycle == nil {
		c.closed(nil)
	} else {
		err = c.Lifecycle.Close()
		if c.Lifecycle.Future(FutureTypeClosed, future.CallbackFuture[error](c.closed)) == nil {
			c.closed(nil)
		}
	}
	return
}

func (c *RelationCloser) Close() error {
	c.initializer.Do(c.init)
	return c.close()
}

func (c *RelationCloser) Wait() error {
	c.initializer.Do(c.init)
	c.waiter.Wait()
	return c.err
}

func (c *RelationCloser) Shutdown() error {
	c.Close()
	return c.Wait()
}