public void wake(MasterProcedureScheduler scheduler) { if (!event.isReady()) { event.wake(scheduler); } }
while (size-- > 0) { ProcedureEvent ev = waitQueue.pollFirst().getEvent(); ev.wake(procSched); LOG.debug("WAKE " + ev + " total=" + wakeCount.get()); wakeCount.incrementAndGet();
public void wake(MasterProcedureScheduler scheduler) { if (!event.isReady()) { event.wake(scheduler); } } }
private void complete(MasterProcedureEnv env, Throwable error) { if (error != null) { LOG.warn("Failed to switch rpc throttle to {} on server {}", rpcThrottleEnabled, targetServer, error); this.succ = false; } else { this.succ = true; } event.wake(env.getProcedureScheduler()); event = null; }
public void setEventReady(ProcedureEvent<?> event, boolean isReady) { if (isReady) { event.wake(procSched); } else { event.suspend(); } }
private void complete(MasterProcedureEnv env, Throwable error) { if (event == null) { LOG.warn("procedure event for {} is null, maybe the procedure is created when recovery", getProcId()); return; } if (error != null) { LOG.warn("Refresh peer {} for {} on {} failed", peerId, type, targetServer, error); this.succ = false; } else { LOG.info("Refresh peer {} for {} on {} suceeded", peerId, type, targetServer); this.succ = true; } event.wake(env.getProcedureScheduler()); event = null; }
public void unlock(final MasterProcedureEnv env) { unlock.set(true); locked.set(false); // Maybe timeout already awakened the event and the procedure has finished. synchronized (event) { if (!event.isReady()) { setState(ProcedureProtos.ProcedureState.RUNNABLE); event.wake(env.getProcedureScheduler()); } } }
/** * Re run the procedure after every timeout to write new WAL entries so we don't hold back old * WALs. * @return false, so procedure framework doesn't mark this procedure as failure. */ @Override protected synchronized boolean setTimeoutFailure(final MasterProcedureEnv env) { synchronized (event) { if (LOG.isDebugEnabled()) LOG.debug("Timeout failure " + this.event); if (!event.isReady()) { // Maybe unlock() awakened the event. setState(ProcedureProtos.ProcedureState.RUNNABLE); if (LOG.isDebugEnabled()) LOG.debug("Calling wake on " + this.event); event.wake(env.getProcedureScheduler()); } } return false; // false: do not mark the procedure as failed. }
private void complete(MasterProcedureEnv env, Throwable error) { if (event == null) { LOG.warn("procedure event for {} is null, maybe the procedure is created when recovery", getProcId()); return; } if (error != null) { LOG.warn("Replay wals {} on {} failed for peer id={}", wals, targetServer, peerId, error); this.succ = false; } else { truncateWALs(env); LOG.info("Replay wals {} on {} succeed for peer id={}", wals, targetServer, peerId); this.succ = true; } event.wake(env.getProcedureScheduler()); event = null; }
@VisibleForTesting void wakeMetaLoadedEvent() { metaLoadEvent.wake(getProcedureScheduler()); assert isMetaLoaded() : "expected meta to be loaded"; }
private void complete(MasterProcedureEnv env, Throwable error) { if (event == null) { LOG.warn("procedure event for {} is null, maybe the procedure is created when recovery", getProcId()); return; } if (error == null) { LOG.info("split WAL {} on {} succeeded", walPath, worker); try { env.getMasterServices().getSplitWALManager().deleteSplitWAL(walPath); } catch (IOException e){ LOG.warn("remove WAL {} failed, ignore...", walPath, e); } success = true; } else { if (error instanceof DoNotRetryIOException) { LOG.warn("WAL split task of {} send to a wrong server {}, will retry on another server", walPath, worker, error); success = true; } else { LOG.warn("split WAL {} failed, retry...", walPath, error); success = false; } } event.wake(env.getProcedureScheduler()); event = null; }
@Override protected synchronized boolean setTimeoutFailure(final TestProcEnv env) { int n = ntimeouts.incrementAndGet(); LOG.info("HANDLE TIMEOUT " + this + " ntimeouts=" + n); setState(ProcedureState.RUNNABLE); event.wake((AbstractProcedureScheduler) env.getProcedureScheduler()); return false; }
private void setMetaAssigned(RegionInfo metaRegionInfo, boolean assigned) { assert isMetaRegion(metaRegionInfo) : "unexpected non-meta region " + metaRegionInfo; ProcedureEvent<?> metaAssignEvent = getMetaAssignEvent(metaRegionInfo); if (assigned) { metaAssignEvent.wake(getProcedureScheduler()); } else { metaAssignEvent.suspend(); } }
@Override public void remoteCallFailed(MasterProcedureEnv env, ServerName remote, IOException exception) { RegionStateNode regionNode = getRegionNode(env); regionNode.lock(); try { ProcedureEvent<?> event = regionNode.getProcedureEvent(); if (event.isReady()) { LOG.warn( "The procedure event of procedure {} for region {} to server {} is not suspended, " + "usually this should not happen, but anyway let's skip the following wake up code, ", this, region, targetServer); return; } LOG.warn("The remote operation {} for region {} to server {} failed", this, region, targetServer, exception); event.wake(env.getProcedureScheduler()); } finally { regionNode.unlock(); } }
public void serverCrashed(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName) throws IOException { // Notice that, in this method, we do not change the procedure state, instead, we update the // region state in hbase:meta. This is because that, the procedure state change will not be // persisted until the region is woken up and finish one step, if we crash before that then the // information will be lost. So here we will update the region state in hbase:meta, and when the // procedure is woken up, it will process the error and jump to the correct procedure state. RegionStateTransitionState currentState = getCurrentState(); switch (currentState) { case REGION_STATE_TRANSITION_CLOSE: case REGION_STATE_TRANSITION_CONFIRM_CLOSED: case REGION_STATE_TRANSITION_CONFIRM_OPENED: // for these 3 states, the region may still be online on the crashed server env.getAssignmentManager().regionClosed(regionNode, false); if (currentState != RegionStateTransitionState.REGION_STATE_TRANSITION_CLOSE) { regionNode.getProcedureEvent().wake(env.getProcedureScheduler()); } break; default: // If the procedure is in other 2 states, then actually we should not arrive here, as we // know that the region is not online on any server, so we need to do nothing... But anyway // let's add a log here LOG.warn("{} received unexpected server crash call for region {} from {}", this, regionNode, serverName); } }
private void reportTransitionFailedOpen(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName) { if (!isOpening(regionNode, serverName, TransitionCode.FAILED_OPEN)) { return; } // there is no openSeqNum for FAILED_OPEN, so we will check the target server instead if (!regionNode.getRegionLocation().equals(serverName)) { LOG.warn( "Received report {} transition from {} for {}, pid={}," + " but the region is not on it, should be a retry, ignore", TransitionCode.FAILED_OPEN, regionNode, serverName, getProcId()); return; } // just wake up the procedure and see if we can retry // Notice that, even if we arrive here, this call could still be a retry, as we may retry // opening on the same server again. And the assumption here is that, once the region state is // OPENING, and the TRSP state is REGION_STATE_TRANSITION_CONFIRM_OPENED, the TRSP must have // been suspended on the procedure event, so after the waking operation here, the TRSP will be // executed and try to schedule new OpenRegionProcedure again. Once there is a successful open // then we are done, so the TRSP will not be stuck. // TODO: maybe we could send the procedure id of the OpenRegionProcedure to the region server // and let the region server send it back when done, so it will be easy to detect whether this // is a retry. regionNode.getProcedureEvent().wake(env.getProcedureScheduler()); }
regionNode.getProcedureEvent().wake(env.getProcedureScheduler());
regionNode.getProcedureEvent().wake(env.getProcedureScheduler());
event.wake(procSched); assertEquals(true, event.isReady());
@Test public void testSuspendedProcedure() throws Exception { final TableName tableName = TableName.valueOf(name.getMethodName()); queue.addBack( new TestTableProcedure(1, tableName, TableProcedureInterface.TableOperationType.READ)); queue.addBack( new TestTableProcedure(2, tableName, TableProcedureInterface.TableOperationType.READ)); Procedure<?> proc = queue.poll(); assertEquals(1, proc.getProcId()); // suspend ProcedureEvent<?> event = new ProcedureEvent<>("testSuspendedProcedureEvent"); assertEquals(true, event.suspendIfNotReady(proc)); proc = queue.poll(); assertEquals(2, proc.getProcId()); assertEquals(null, queue.poll(0)); // resume event.wake(queue); proc = queue.poll(); assertEquals(1, proc.getProcId()); assertEquals(null, queue.poll(0)); }