/** * Return the id of the procedure which holds the exclusive lock, if exists. Or a negative value * which means no one holds the exclusive lock. * <p/> * Notice that, in HBase, we assume that the procedure id is positive, or at least non-negative. */ default long getExclusiveLockProcIdOwner() { Procedure<?> proc = getExclusiveLockOwnerProcedure(); return proc != null ? proc.getProcId() : -1L; }
public boolean isRunnable(final long procId) { for (Procedure proc: runnable) { if (proc.getProcId() == procId) { return true; } } return false; }
private void submitChildrenProcedures(Procedure<TEnvironment>[] subprocs) { for (int i = 0; i < subprocs.length; ++i) { Procedure<TEnvironment> subproc = subprocs[i]; subproc.updateMetricsOnSubmit(getEnvironment()); assert !procedures.containsKey(subproc.getProcId()); procedures.put(subproc.getProcId(), subproc); scheduler.addFront(subproc); } }
/** * Helper to lookup the root Procedure ID given a specified procedure. */ protected static <T> Long getRootProcedureId(Map<Long, Procedure<T>> procedures, Procedure<T> proc) { while (proc.hasParent()) { proc = procedures.get(proc.getParentProcId()); if (proc == null) { return null; } } return proc.getProcId(); }
private void restoreLock(Procedure<TEnvironment> proc, Set<Long> restored) { proc.restoreLock(getEnvironment()); restored.add(proc.getProcId()); }
private long pushProcedure(Procedure<TEnvironment> proc) { final long currentProcId = proc.getProcId(); // Update metrics on start of a procedure proc.updateMetricsOnSubmit(getEnvironment()); // Create the rollback stack for the procedure RootProcedureState<TEnvironment> stack = new RootProcedureState<>(); rollbackStack.put(currentProcId, stack); // Submit the new subprocedures assert !procedures.containsKey(currentProcId); procedures.put(currentProcId, proc); sendProcedureAddedNotification(currentProcId); scheduler.addBack(proc); return proc.getProcId(); }
public static String describe(Procedure<?> proc) { Map<String, Object> description = new LinkedHashMap<>(); description.put("ID", proc.getProcId()); description.put("PARENT_ID", proc.getParentProcId()); description.put("STATE", proc.getState()); description.put("OWNER", proc.getOwner()); description.put("TYPE", proc.getProcName()); description.put("START_TIME", new Date(proc.getSubmittedTime())); description.put("LAST_UPDATE", new Date(proc.getLastUpdate())); if (proc.isFailed()) { description.put("ERRORS", MasterProcedureUtil.unwrapRemoteIOException(proc).getMessage()); } description.put("PARAMETERS", parametersToObject(proc)); return JRubyFormat.print(description); }
/** * Get lock info for a resource of specified type and name and log details */ private void logLockedResource(LockedResourceType resourceType, String resourceName) { if (!LOG.isDebugEnabled()) { return; } LockedResource lockedResource = getLockResource(resourceType, resourceName); if (lockedResource != null) { String msg = resourceType.toString() + " '" + resourceName + "', shared lock count=" + lockedResource.getSharedLockCount(); Procedure<?> proc = lockedResource.getExclusiveLockOwnerProcedure(); if (proc != null) { msg += ", exclusively locked by procId=" + proc.getProcId(); } LOG.debug(msg); } }
@Override public Boolean evaluate() throws IOException { if (!procExec.isRunning()) { return true; } ProcedureState state = proc.getState(); if (state == ProcedureState.INITIALIZING || state == ProcedureState.RUNNABLE) { // under these states the procedure may have not been added to procExec yet, so do not // use isFinished to test whether it is finished, as this method will just check if the // procedure is in the running procedure list return false; } return procExec.isFinished(proc.getProcId()); } });
@Override public void handleCorrupted(ProcedureIterator procIter) throws IOException { while (procIter.hasNext()) { Procedure proc = procIter.next(); LOG.debug("corrupted procId=" + proc.getProcId() + ": " + proc); corrupted.add(proc); } } }
private boolean shouldSubmitSCP(ServerName serverName) { // check if there is already a SCP of this server running List<Procedure<MasterProcedureEnv>> procedures = master.getMasterProcedureExecutor().getProcedures(); for (Procedure<MasterProcedureEnv> procedure : procedures) { if (procedure instanceof ServerCrashProcedure) { if (serverName.compareTo(((ServerCrashProcedure) procedure).getServerName()) == 0 && !procedure.isFinished()) { LOG.info("there is already a SCP of this server {} running, pid {}", serverName, procedure.getProcId()); return false; } } } return true; } }
private static void assertUpdated(final ProcedureStoreTracker tracker, final Procedure<?>[] procs, final int[] updatedProcs, final int[] nonUpdatedProcs) { for (int index : updatedProcs) { long procId = procs[index].getProcId(); assertTrue("Procedure id : " + procId, tracker.isModified(procId)); } for (int index : nonUpdatedProcs) { long procId = procs[index].getProcId(); assertFalse("Procedure id : " + procId, tracker.isModified(procId)); } }
private static void assertDeleted(final ProcedureStoreTracker tracker, final Procedure<?>[] procs, final int[] deletedProcs, final int[] nonDeletedProcs) { for (int index : deletedProcs) { long procId = procs[index].getProcId(); assertEquals("Procedure id : " + procId, ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(procId)); } for (int index : nonDeletedProcs) { long procId = procs[index].getProcId(); assertEquals("Procedure id : " + procId, ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(procId)); } }
public static <TEnv> void waitProcedure(ProcedureExecutor<TEnv> procExecutor, Procedure proc) { while (proc.getState() == ProcedureState.INITIALIZING) { Threads.sleepWithoutInterrupt(250); } waitProcedure(procExecutor, proc.getProcId()); }
public static Throwable assertProcFailed(final Procedure<?> result) { assertEquals(true, result.isFailed()); LOG.info("procId=" + result.getProcId() + " exception: " + result.getException().getMessage()); return getExceptionCause(result); }
public static void writeDelete(ByteSlot slot, Procedure<?> proc, long[] subprocs) throws IOException { final ProcedureWALEntry.Builder builder = ProcedureWALEntry.newBuilder(); builder.setType(ProcedureWALEntry.Type.PROCEDURE_WAL_DELETE); builder.setProcId(proc.getProcId()); if (subprocs != null) { builder.addProcedure(ProcedureUtil.convertToProtoProcedure(proc)); for (int i = 0; i < subprocs.length; ++i) { builder.addChildId(subprocs[i]); } } builder.build().writeDelimitedTo(slot); } }
@Test public void testSubmitBatch() throws Exception { Procedure[] procs = new Procedure[5]; for (int i = 0; i < procs.length; ++i) { procs[i] = new NoopProcedure<TestProcEnv>(); } // submit procedures createNewExecutor(htu.getConfiguration(), 3); procExecutor.submitProcedures(procs); // wait for procs to be completed for (int i = 0; i < procs.length; ++i) { final long procId = procs[i].getProcId(); ProcedureTestingUtility.waitProcedure(procExecutor, procId); ProcedureTestingUtility.assertProcNotFailed(procExecutor, procId); } }
@After public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); // Kill all running procedures. for (Procedure<?> proc : procExec.getProcedures()) { procExec.abort(proc.getProcId()); ProcedureTestingUtility.waitProcedure(procExec, proc); } assertEquals(0, procExec.getEnvironment().getProcedureScheduler().size()); }