package idle

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

Dependency Relation
	imports 4 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 ClientConn (interface)
		ClientConn is the functionality provided by grpc.ClientConn to enter and exit
		from idle mode.

		Methods (total 2, both are exported)
			( ClientConn) EnterIdleMode()
			( ClientConn) ExitIdleMode()
		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(cc ClientConn, timeout time.Duration) *Manager

	 type Manager (struct)
		Manager implements idleness detection and calls the ClientConn 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
			cc ClientConn
				Can be accessed without atomics or mutex since these are set at creation
				time and read-only after that.
				// Functionality provided by grpc.ClientConn.

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

			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 11, in which 6 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()
				ExitIdleMode instructs m to call the ClientConn's ExitIdleMode and update its
				internal state.

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

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

			(*Manager) UnsafeSetNotIdle()
				UnsafeSetNotIdle instructs the Manager to update its internal state to
				reflect the reality that the channel is no longer in IDLE mode.
				
				N.B. This method is intended only for internal use by the gRPC client
				when it exits IDLE mode **manually** from `Dial`. The callsite must ensure:
				  - The channel was **actually in IDLE mode** immediately prior to the call.
				  - There is **no concurrent activity** that could cause the channel to exit
				    IDLE mode *naturally* at the same time.

			/* 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(checkActivity bool) bool
				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(cc ClientConn, timeout time.Duration) *Manager


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

	 func NewManager(cc ClientConn, 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.8.4. (GOOS=linux GOARCH=amd64)