public override void CoordinatorIsElected(InstanceId coordinatorId)
{
lock (this)
{
try
{
HighAvailabilityMemberState oldState = outerInstance.state;
InstanceId previousElected = outerInstance.context.ElectedMasterId;
outerInstance.context.AvailableHaMasterId = null;
if (!AcceptNewState(outerInstance.state.masterIsElected(outerInstance.context, coordinatorId)))
{
return;
}
outerInstance.context.ElectedMasterId = coordinatorId;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent(oldState, state, coordinatorId, null);
HighAvailabilityMemberChangeEvent @event = new HighAvailabilityMemberChangeEvent(oldState, outerInstance.state, coordinatorId, null);
outerInstance.memberListeners.Notify(listener => listener.masterIsElected(@event));
if (oldState.AccessAllowed && oldState != outerInstance.state)
{
outerInstance.databaseAvailabilityGuard.Require(AvailabilityRequirement);
}
outerInstance.log.Debug("Got masterIsElected(" + coordinatorId + "), moved to " + outerInstance.state + " from " + oldState + ". Previous elected master is " + previousElected);
}
catch (Exception t)
{
throw new Exception(t);
}
}
}
public override void InstanceDetached(HighAvailabilityMemberChangeEvent @event)
{
MasterIsElectedConflict = false;
MasterIsAvailableConflict = false;
SlaveIsAvailableConflict = false;
InstanceStopsConflict = false;
InstanceDetachedConflict = true;
LastEvent = @event;
}
public override void MasterIsAvailable(HighAvailabilityMemberChangeEvent @event)
{
if (@event.NewState == @event.OldState && @event.OldState == HighAvailabilityMemberState.SLAVE)
{
_clusterMemberAvailability.memberIsAvailable(SLAVE, _slaveHaURI, _storeIdSupplier.get());
}
else
{
StateChanged(@event);
}
}
public override void MasterIsElected(HighAvailabilityMemberChangeEvent @event)
{
if (@event.NewState == @event.OldState && @event.OldState == HighAvailabilityMemberState.MASTER)
{
_clusterMemberAvailability.memberIsAvailable(MASTER, _masterHaURI, _storeIdSupplier.get());
}
else
{
StateChanged(@event);
}
}
internal virtual void ChangeStateToDetached()
{
outerInstance.state = HighAvailabilityMemberState.Pending;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent(state, HighAvailabilityMemberState.PENDING, null, null);
HighAvailabilityMemberChangeEvent @event = new HighAvailabilityMemberChangeEvent(outerInstance.state, HighAvailabilityMemberState.Pending, null, null);
outerInstance.memberListeners.Notify(listener => listener.instanceDetached(@event));
outerInstance.context.AvailableHaMasterId = null;
outerInstance.context.ElectedMasterId = null;
}
public override void MemberIsAvailable(string role, InstanceId instanceId, URI roleUri, StoreId storeId)
{
lock (this)
{
try
{
/*
* Do different things depending on whether the cluster member is in master or slave state
*/
if (role.Equals(HighAvailabilityModeSwitcher.MASTER))
{
HighAvailabilityMemberState oldState = outerInstance.state;
outerInstance.context.AvailableHaMasterId = roleUri;
if (!AcceptNewState(outerInstance.state.masterIsAvailable(outerInstance.context, instanceId, roleUri)))
{
return;
}
outerInstance.log.Debug("Got masterIsAvailable(" + instanceId + "), moved to " + outerInstance.state + " from " + oldState);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent(oldState, state, instanceId, roleUri);
HighAvailabilityMemberChangeEvent @event = new HighAvailabilityMemberChangeEvent(oldState, outerInstance.state, instanceId, roleUri);
outerInstance.memberListeners.Notify(listener => listener.masterIsAvailable(@event));
if (oldState == HighAvailabilityMemberState.ToMaster && outerInstance.state == HighAvailabilityMemberState.Master)
{
outerInstance.databaseAvailabilityGuard.Fulfill(AvailabilityRequirement);
}
}
else if (role.Equals(HighAvailabilityModeSwitcher.SLAVE))
{
HighAvailabilityMemberState oldState = outerInstance.state;
if (!AcceptNewState(outerInstance.state.slaveIsAvailable(outerInstance.context, instanceId, roleUri)))
{
return;
}
outerInstance.log.Debug("Got slaveIsAvailable(" + instanceId + "), " + "moved to " + outerInstance.state + " from " + oldState);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent(oldState, state, instanceId, roleUri);
HighAvailabilityMemberChangeEvent @event = new HighAvailabilityMemberChangeEvent(oldState, outerInstance.state, instanceId, roleUri);
outerInstance.memberListeners.Notify(listener => listener.slaveIsAvailable(@event));
if (oldState == HighAvailabilityMemberState.ToSlave && outerInstance.state == HighAvailabilityMemberState.Slave)
{
outerInstance.databaseAvailabilityGuard.Fulfill(AvailabilityRequirement);
}
}
}
catch (Exception throwable)
{
outerInstance.log.Warn("Exception while receiving member availability notification", throwable);
}
}
}
internal virtual void ChangeStateToPending()
{
if (outerInstance.state.AccessAllowed)
{
outerInstance.databaseAvailabilityGuard.Require(AvailabilityRequirement);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent(state, HighAvailabilityMemberState.PENDING, null, null);
HighAvailabilityMemberChangeEvent @event = new HighAvailabilityMemberChangeEvent(outerInstance.state, HighAvailabilityMemberState.Pending, null, null);
outerInstance.state = HighAvailabilityMemberState.Pending;
outerInstance.memberListeners.Notify(listener => listener.instanceStops(@event));
outerInstance.context.AvailableHaMasterId = null;
outerInstance.context.ElectedMasterId = null;
}
public override void Stop()
{
_events.removeClusterMemberListener(_eventsListener);
HighAvailabilityMemberState oldState = _state;
_state = HighAvailabilityMemberState.Pending;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final HighAvailabilityMemberChangeEvent event = new HighAvailabilityMemberChangeEvent(oldState, state, null, null);
HighAvailabilityMemberChangeEvent @event = new HighAvailabilityMemberChangeEvent(oldState, _state, null, null);
_memberListeners.notify(listener => listener.instanceStops(@event));
// If we were previously in a state that allowed access, we must now deny access
if (oldState.AccessAllowed)
{
_databaseAvailabilityGuard.require(AvailabilityRequirement);
}
_context.AvailableHaMasterId = null;
}
public override void InstanceDetached(HighAvailabilityMemberChangeEvent @event)
{
}
public override void InstanceStops(HighAvailabilityMemberChangeEvent @event)
{
}
public override void SlaveIsAvailable(HighAvailabilityMemberChangeEvent @event)
{
}
public override void MasterIsElected(HighAvailabilityMemberChangeEvent @event)
{
}
public override void instanceDetached(HighAvailabilityMemberChangeEvent @event)
{
_latch.Signal();
}
private void StateChanged(HighAvailabilityMemberChangeEvent @event)
{
/*
* First of all, check if the state change is internal or external. In this context, internal means
* that the old and new state are different, so we definitely need to do something.
* Both cases may require a switcher to be activated, but external needs to check if the same as previously
* should be the one used (because the last attempt failed, for example) or maybe we simply need to update
* a field. Internal will probably require a new switcher to be used.
*/
if (@event.NewState == @event.OldState)
{
/*
* This is the external change case. We need to check our internals and perhaps retry a transition
*/
if (@event.NewState != HighAvailabilityMemberState.TO_MASTER)
{
/*
* We get here if for example a new master becomes available while we are already switching. In that
* case we don't change state but we must update with the new availableMasterId,
* but only if it is not null.
*/
if (@event.ServerHaUri != null)
{
_availableMasterId = @event.ServerHaUri;
}
return;
}
/*
* The other case is that the new state is TO_MASTER
*/
else if (_currentTargetState == HighAvailabilityMemberState.TO_MASTER)
{
/*
* We are still switching from before. If a failure had happened, then currentTargetState would
* be PENDING.
*/
return;
}
}
_availableMasterId = @event.ServerHaUri;
_currentTargetState = @event.NewState;
switch (@event.NewState)
{
case TO_MASTER:
if (@event.OldState.Equals(HighAvailabilityMemberState.SLAVE))
{
_clusterMemberAvailability.memberIsUnavailable(SLAVE);
}
SwitchToMaster();
break;
case TO_SLAVE:
SwitchToSlave();
break;
case PENDING:
SwitchToPending(@event.OldState);
break;
default:
// do nothing
break;
}
}
public override void SlaveIsAvailable(HighAvailabilityMemberChangeEvent @event)
{
// ignored, we don't do any mode switching in slave available events
}
