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 }