notify/session_owner_state.go

package notify

import "sync/atomic"

const (
	ownerSessionStateIdle int32 = iota
	ownerSessionStateStarting
	ownerSessionStateRunning
	ownerSessionStateStopping
	ownerSessionStateFinalizing
	ownerSessionStateStopped
)

func beginOwnerSessionStart(state *atomic.Int32) bool {
	if state == nil {
		return false
	}
	for {
		current := state.Load()
		switch current {
		case ownerSessionStateIdle, ownerSessionStateStopped:
			if state.CompareAndSwap(current, ownerSessionStateStarting) {
				return true
			}
		default:
			return false
		}
	}
}

func rollbackOwnerSessionStart(state *atomic.Int32) {
	if state == nil {
		return
	}
	state.CompareAndSwap(ownerSessionStateStarting, ownerSessionStateIdle)
}

func markOwnerSessionStarted(state *atomic.Int32) {
	if state == nil {
		return
	}
	for {
		current := state.Load()
		switch current {
		case ownerSessionStateRunning:
			return
		case ownerSessionStateStopping, ownerSessionStateFinalizing:
			return
		case ownerSessionStateStarting, ownerSessionStateIdle, ownerSessionStateStopped:
			if state.CompareAndSwap(current, ownerSessionStateRunning) {
				return
			}
		default:
			return
		}
	}
}

func markOwnerSessionStopping(state *atomic.Int32) bool {
	if state == nil {
		return false
	}
	for {
		current := state.Load()
		switch current {
		case ownerSessionStateStopping, ownerSessionStateFinalizing, ownerSessionStateStopped:
			return false
		case ownerSessionStateRunning, ownerSessionStateStarting:
			if state.CompareAndSwap(current, ownerSessionStateStopping) {
				return true
			}
		case ownerSessionStateIdle:
			if state.CompareAndSwap(current, ownerSessionStateStopped) {
				return true
			}
		default:
			return false
		}
	}
}

// claimOwnerSessionStop elects exactly one caller to run session cleanup.
// finalizing remains externally visible as "stopping" while preventing a
// concurrent Stop/read-error path from entering cleanup a second time.
func claimOwnerSessionStop(state *atomic.Int32) bool {
	if state == nil {
		return false
	}
	for {
		current := state.Load()
		switch current {
		case ownerSessionStateFinalizing, ownerSessionStateStopped:
			return false
		case ownerSessionStateIdle, ownerSessionStateStarting, ownerSessionStateRunning, ownerSessionStateStopping:
			if state.CompareAndSwap(current, ownerSessionStateFinalizing) {
				return true
			}
		default:
			return false
		}
	}
}

func markOwnerSessionStopped(state *atomic.Int32) {
	if state == nil {
		return
	}
	for {
		current := state.Load()
		if current == ownerSessionStateStopped {
			return
		}
		if state.CompareAndSwap(current, ownerSessionStateStopped) {
			return
		}
	}
}

func ownerSessionStateName(state int32) string {
	switch state {
	case ownerSessionStateIdle:
		return "idle"
	case ownerSessionStateStarting:
		return "starting"
	case ownerSessionStateRunning:
		return "running"
	case ownerSessionStateStopping, ownerSessionStateFinalizing:
		return "stopping"
	case ownerSessionStateStopped:
		return "stopped"
	default:
		return "unknown"
	}
}

func ownerSessionStateValue(state *atomic.Int32) int32 {
	if state == nil {
		return ownerSessionStateIdle
	}
	return state.Load()
}

func (c *ClientCommon) beginClientSessionStart() bool {
	if c == nil {
		return false
	}
	return beginOwnerSessionStart(&c.sessionOwnerState)
}

func (c *ClientCommon) rollbackClientSessionStart() {
	if c == nil {
		return
	}
	rollbackOwnerSessionStart(&c.sessionOwnerState)
}

func (c *ClientCommon) markClientSessionStarted() {
	if c == nil {
		return
	}
	markOwnerSessionStarted(&c.sessionOwnerState)
}

func (c *ClientCommon) markClientSessionStopped() {
	if c == nil {
		return
	}
	markOwnerSessionStopped(&c.sessionOwnerState)
}

func (c *ClientCommon) markClientSessionStopping() bool {
	if c == nil {
		return false
	}
	return markOwnerSessionStopping(&c.sessionOwnerState)
}

func (c *ClientCommon) claimClientSessionStop() bool {
	if c == nil {
		return false
	}
	return claimOwnerSessionStop(&c.sessionOwnerState)
}

func (c *ClientCommon) ownerSessionState() int32 {
	if c == nil {
		return ownerSessionStateIdle
	}
	return ownerSessionStateValue(&c.sessionOwnerState)
}

func (c *ClientCommon) ownerSessionStateName() string {
	return ownerSessionStateName(c.ownerSessionState())
}

func (s *ServerCommon) beginServerSessionStart() bool {
	if s == nil {
		return false
	}
	return beginOwnerSessionStart(&s.sessionOwnerState)
}

func (s *ServerCommon) rollbackServerSessionStart() {
	if s == nil {
		return
	}
	rollbackOwnerSessionStart(&s.sessionOwnerState)
}

func (s *ServerCommon) markServerSessionStarted() {
	if s == nil {
		return
	}
	markOwnerSessionStarted(&s.sessionOwnerState)
}

func (s *ServerCommon) markServerSessionStopped() {
	if s == nil {
		return
	}
	markOwnerSessionStopped(&s.sessionOwnerState)
}

func (s *ServerCommon) markServerSessionStopping() bool {
	if s == nil {
		return false
	}
	return markOwnerSessionStopping(&s.sessionOwnerState)
}

func (s *ServerCommon) claimServerSessionStop() bool {
	if s == nil {
		return false
	}
	return claimOwnerSessionStop(&s.sessionOwnerState)
}

func (s *ServerCommon) ownerSessionState() int32 {
	if s == nil {
		return ownerSessionStateIdle
	}
	return ownerSessionStateValue(&s.sessionOwnerState)
}

func (s *ServerCommon) ownerSessionStateName() string {
	return ownerSessionStateName(s.ownerSessionState())
}