public StateMachineController(LifeCycleState lifeCycleState, SchedulerState schedulerState,
ConnectivityState connectivityState)
{
_lifeCycleState = lifeCycleState;
_schedulerState = schedulerState;
_connectivityState = connectivityState;
}
public void UpdateState(BalancerState state)
{
_controller.UpdateState(state);
_state = state.ConnectivityState;
NotifySubscribers();
}
internal Task WaitForStateChangedAsync(ConnectivityState lastObservedState, ConnectivityState?waitForState, CancellationToken cancellationToken)
{
StateWatcher?watcher;
lock (_lock)
{
if (State != lastObservedState)
{
return(Task.CompletedTask);
}
else
{
// Minor optimization to check if we're already waiting for state change
// using the specified cancellation token.
foreach (var stateWatcher in _stateWatchers)
{
if (stateWatcher.CancellationToken == cancellationToken &&
stateWatcher.WaitForState == waitForState)
{
return(stateWatcher.Tcs.Task);
}
}
watcher = new StateWatcher(
cancellationToken,
waitForState,
new TaskCompletionSource <object?>(TaskCreationOptions.RunContinuationsAsynchronously));
_stateWatchers.Add(watcher);
}
}
return(WaitForStateChangedAsyncCore(watcher));
}
//=============================================================================
public void SetCorrStatus(ConnectivityState status)
{
if (status == ConnectivityState.Online)
{
MakeStatusOnline();
EnableSyncButton();
}
else if (status == ConnectivityState.Offline)
{
MakeStatusOffline();
DisableSyncButton();
}
}
internal void RaiseStateChanged(ConnectivityState state, Status status)
{
SubchannelLog.SubchannelStateChanged(_logger, Id, state, status);
if (_stateChangedRegistrations.Count > 0)
{
var subchannelState = new SubchannelState(state, status);
foreach (var registration in _stateChangedRegistrations)
{
registration.Invoke(subchannelState);
}
}
}
private static async Task WaitForStateAsync(GrpcChannel channel, ConnectivityState state)
{
while (true)
{
var currentState = channel.State;
if (currentState == state)
{
return;
}
await channel.WaitForStateChangedAsync(currentState);
}
}
internal void OnSubchannelStateChange(Subchannel subchannel, ConnectivityState state, Status status)
{
if (state == ConnectivityState.Shutdown)
{
lock (_subchannels)
{
var removed = _subchannels.Remove(subchannel);
Debug.Assert(removed);
}
}
lock (_lock)
{
subchannel.RaiseStateChanged(state, status);
}
}
internal bool UpdateConnectivityState(ConnectivityState state, Status status)
{
lock (Lock)
{
// Don't update subchannel state if the state is the same or the subchannel has been shutdown.
//
// This could happen when:
// 1. Start trying to connect with a subchannel.
// 2. Address resolver updates and subchannel address is no longer there and subchannel is shutdown.
// 3. Connection attempt fails and tries to update subchannel state.
if (_state == state || _state == ConnectivityState.Shutdown)
{
return(false);
}
_state = state;
}
// Notify channel outside of lock to avoid deadlocks.
_manager.OnSubchannelStateChange(this, state, status);
return(true);
}
public static void ChannelStateUpdated(ILogger logger, ConnectivityState connectivityState)
{
_channelStateUpdated(logger, connectivityState, null);
}
public BalancerState(ConnectivityState connectivityState, SubchannelPicker picker)
{
ConnectivityState = connectivityState;
Picker = picker;
}
public void UpdateState(ConnectivityState state, Status?status = null)
{
_state = state;
Subchannel.UpdateConnectivityState(_state, status ?? Status.DefaultSuccess);
}
public static void SetMessagebusConnectivity(ConnectivityState state)
{
__messagebusConnectivity.SetState(state);
if (state == ConnectivityState.Broken)
{
Thread.MemoryBarrier();
__messagebusConnectivityRetryTime = DateTime.Now.Add(TimeSpan.FromMinutes(5));
Thread.MemoryBarrier();
}
}
public void UpdateKnownState(ConnectivityState knownState)
{
_lastKnownState = knownState;
}
public static void RefreshingResolverForSubchannel(ILogger logger, int subchannelId, ConnectivityState state)
{
_refreshingResolverForSubchannel(logger, subchannelId, state, null);
}
private void UpdateChannelState(ConnectivityState state, SubchannelPicker subchannelPicker)
{
State = state;
Controller.UpdateState(new BalancerState(state, subchannelPicker));
}
internal bool UpdateConnectivityState(ConnectivityState state, string successDetail)
{
return(UpdateConnectivityState(state, new Status(StatusCode.OK, successDetail)));
}
internal SubchannelState(ConnectivityState state, Status status)
{
State = state;
Status = status;
}
public static void ProcessingSubchannelStateChanged(ILogger logger, int subchannelId, ConnectivityState state, Status status)
{
_processingSubchannelStateChanged(logger, subchannelId, state, status.Detail, status.DebugException);
}
public static void ConnectionRequestedInNonIdleState(ILogger logger, int subchannelId, ConnectivityState state)
{
_connectionRequestedInNonIdleState(logger, subchannelId, state, null);
}
public static void RequestingConnectionForSubchannel(ILogger logger, int subchannelId, ConnectivityState state)
{
_requestingConnectionForSubchannel(logger, subchannelId, state, null);
}
public AddressSubchannel(Subchannel subchannel, BalancerAddress address)
{
Subchannel = subchannel;
Address = address;
_lastKnownState = ConnectivityState.Idle;
}
