package idle

Import Path
	google.golang.org/grpc/internal/idle (on go.dev)

Dependency Relation
	imports 5 packages, and imported by one package

Involved Source Files

	  d idle.go
		Package idle contains a component for managing idleness (entering and exiting)
		based on RPC activity.
Package-Level Type Names (total 2, both are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Enforcer (interface)
		Enforcer is the functionality provided by grpc.ClientConn to enter
		and exit from idle mode.

		Methods (total 2, both are exported)
			( Enforcer) EnterIdleMode()
			( Enforcer) ExitIdleMode() error
		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*google.golang.org/grpc.idler
		As Inputs Of (at least one exported)
			func NewManager(enforcer Enforcer, timeout time.Duration) *Manager

	 type Manager (struct)
		Manager implements idleness detection and calls the configured Enforcer to
		enter/exit idle mode when appropriate.  Must be created by NewManager.

		Fields (total 9, none are exported)
			/* 9 unexporteds ... *//* 9 unexporteds: */
			activeCallsCount int32
				// Count of active RPCs; -math.MaxInt32 means channel is idle or is trying to get there.

			activeSinceLastTimerCheck int32
				// Boolean; True if there was an RPC since the last timer callback.

			actuallyIdle bool
			closed int32
				// Boolean; True when the manager is closed.

			enforcer Enforcer
				Can be accessed without atomics or mutex since these are set at creation
				time and read-only after that.
				// Functionality provided by grpc.ClientConn.

			idleMu sync.RWMutex
				idleMu is used to guarantee mutual exclusion in two scenarios:
				- Opposing intentions:
				  - a: Idle timeout has fired and handleIdleTimeout() is trying to put
				    the channel in idle mode because the channel has been inactive.
				  - b: At the same time an RPC is made on the channel, and OnCallBegin()
				    is trying to prevent the channel from going idle.
				- Competing intentions:
				  - The channel is in idle mode and there are multiple RPCs starting at
				    the same time, all trying to move the channel out of idle. Only one
				    of them should succeed in doing so, while the other RPCs should
				    piggyback on the first one and be successfully handled.

			lastCallEndTime int64
				State accessed atomically.
				// Unix timestamp in nanos; time when the most recent RPC completed.

			timeout time.Duration
			timer *time.Timer
		Methods (total 10, in which 5 are exported)
			(*Manager) Close()
				Close stops the timer associated with the Manager, if it exists.

			(*Manager) EnterIdleModeForTesting()
				EnterIdleModeForTesting instructs the channel to enter idle mode.

			(*Manager) ExitIdleMode() error
				ExitIdleMode instructs m to call the enforcer's ExitIdleMode and update m's
				internal state.

			(*Manager) OnCallBegin() error
				OnCallBegin is invoked at the start of every RPC.

			(*Manager) OnCallEnd()
				OnCallEnd is invoked at the end of every RPC.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*Manager) handleIdleTimeout()
				handleIdleTimeout is the timer callback that is invoked upon expiry of the
				configured idle timeout. The channel is considered inactive if there are no
				ongoing calls and no RPC activity since the last time the timer fired.

			(*Manager) isClosed() bool
			(*Manager) resetIdleTimer(d time.Duration)
			(*Manager) resetIdleTimerLocked(d time.Duration)
				resetIdleTimerLocked resets the idle timer to the given duration.  Called
				when exiting idle mode or when the timer fires and we need to reset it.

			(*Manager) tryEnterIdleMode() bool
				tryEnterIdleMode instructs the channel to enter idle mode. But before
				that, it performs a last minute check to ensure that no new RPC has come in,
				making the channel active.
				
				Return value indicates whether or not the channel moved to idle mode.
				
				Holds idleMu which ensures mutual exclusion with exitIdleMode.

		As Outputs Of (at least one exported)
			func NewManager(enforcer Enforcer, timeout time.Duration) *Manager


Package-Level Functions (only one, which is exported)

	 func NewManager(enforcer Enforcer, timeout time.Duration) *Manager
		NewManager creates a new idleness manager implementation for the
		given idle timeout.  It begins in idle mode.


Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var timeAfterFunc func(d time.Duration, f func()) *time.Timer
		For overriding in unit tests.

The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64)