protected synchronized void addSubProcedure(Procedure<TEnvironment> proc) { if (!proc.hasParent()) { return; } if (subprocs == null) { subprocs = new HashSet<>(); } subprocs.add(proc); }
/** * @param a the first procedure to be compared. * @param b the second procedure to be compared. * @return true if the two procedures have the same parent */ public static boolean haveSameParent(Procedure<?> a, Procedure<?> b) { return a.hasParent() && b.hasParent() && (a.getParentProcId() == b.getParentProcId()); } }
/** * 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 restoreLocks() { Set<Long> restored = new HashSet<>(); Deque<Procedure<TEnvironment>> stack = new ArrayDeque<>(); procedures.values().forEach(proc -> { for (;;) { if (restored.contains(proc.getProcId())) { restoreLocks(stack, restored); return; } if (!proc.hasParent()) { restoreLock(proc, restored); restoreLocks(stack, restored); return; } stack.push(proc); proc = procedures.get(proc.getParentProcId()); } }); }
@Override public void insert(Procedure<?>[] procs) { if (LOG.isTraceEnabled()) { LOG.trace("Insert " + Arrays.toString(procs)); } ByteSlot slot = acquireSlot(); try { // Serialize the insert long[] procIds = new long[procs.length]; for (int i = 0; i < procs.length; ++i) { assert !procs[i].hasParent(); procIds[i] = procs[i].getProcId(); ProcedureWALFormat.writeInsert(slot, procs[i]); } // Push the transaction data and wait until it is persisted pushData(PushType.INSERT, slot, Procedure.NO_PROC_ID, procIds); } catch (IOException e) { // We are not able to serialize the procedure. // this is a code error, and we are not able to go on. LOG.error(HBaseMarkers.FATAL, "Unable to serialize one of the procedure: " + Arrays.toString(procs), e); throw new RuntimeException(e); } finally { releaseSlot(slot); } }
sb.append(getProcId()); if (hasParent()) { sb.append(", ppid="); sb.append(getParentProcId());
@Override public boolean hasLockAccess(Procedure<?> proc) { if (exclusiveLockOwnerProcedure == null) { return false; } long lockOwnerId = exclusiveLockOwnerProcedure.getProcId(); if (proc.getProcId() == lockOwnerId) { return true; } if (!proc.hasParent()) { return false; } // fast path to check root procedure if (proc.getRootProcId() == lockOwnerId) { return true; } // check ancestors for (Procedure<?> p = proc;;) { if (p.getParentProcId() == lockOwnerId) { return true; } p = procedureRetriever.apply(p.getParentProcId()); if (p == null || !p.hasParent()) { return false; } } }
Procedure<TEnvironment> proc = procedures.get(procId); if (proc != null) { if (proc.isFinished() && proc.hasParent() && isRootFinished(proc)) { LOG.debug("Procedure {} has already been finished and parent is succeeded," + " skip force updating", proc);
assert !proc.hasParent(); ProcedureWALFormat.writeInsert(slot, proc);
private void updateStoreOnExec(RootProcedureState<TEnvironment> procStack, Procedure<TEnvironment> procedure, Procedure<TEnvironment>[] subprocs) { if (subprocs != null && !procedure.isFailed()) { if (LOG.isTraceEnabled()) { LOG.trace("Stored " + procedure + ", children " + Arrays.toString(subprocs)); } store.insert(procedure, subprocs); } else { LOG.trace("Store update {}", procedure); if (procedure.isFinished() && !procedure.hasParent()) { // remove child procedures final long[] childProcIds = procStack.getSubprocedureIds(); if (childProcIds != null) { store.delete(procedure, childProcIds); for (int i = 0; i < childProcIds.length; ++i) { procedures.remove(childProcIds[i]); } } else { store.update(procedure); } } else { store.update(procedure); } } }
private Procedure<TEnvironment> prepareProcedure(Procedure<TEnvironment> proc) { Preconditions.checkArgument(proc.getState() == ProcedureState.INITIALIZING); Preconditions.checkArgument(!proc.hasParent(), "unexpected parent", proc); if (this.checkOwnerSet) { Preconditions.checkArgument(proc.hasOwner(), "missing owner"); } return proc; }
LOG.debug("Completed {}", proc); } else { if (!proc.hasParent()) { assert !proc.isFinished() : "unexpected finished procedure"; rollbackStack.put(proc.getProcId(), new RootProcedureState<>()); assert !(proc.isFinished() && !proc.hasParent()) : "unexpected completed proc=" + proc; if (proc.hasParent()) { Procedure<TEnvironment> parent = procedures.get(proc.getParentProcId()); if (parent != null && !proc.isFinished()) { runnableList.forEach(p -> { p.afterReplay(getEnvironment()); if (!p.hasParent()) { sendProcedureLoadedNotification(p.getProcId());
if (procedure.hasParent() && procedure.getState() != ProcedureState.RUNNABLE && procedure.getState() != ProcedureState.WAITING && procedure.getState() != ProcedureState.WAITING_TIMEOUT) {
private void cleanupAfterRollbackOneStep(Procedure<TEnvironment> proc) { if (proc.removeStackIndex()) { if (!proc.isSuccess()) { proc.setState(ProcedureState.ROLLEDBACK); } // update metrics on finishing the procedure (fail) proc.updateMetricsOnFinish(getEnvironment(), proc.elapsedTime(), false); if (proc.hasParent()) { store.delete(proc.getProcId()); procedures.remove(proc.getProcId()); } else { final long[] childProcIds = rollbackStack.get(proc.getProcId()).getSubprocedureIds(); if (childProcIds != null) { store.delete(proc, childProcIds); } else { store.update(proc); } } } else { store.update(proc); } }
out.print( proc.getProcId() ); out.write("</td>\n <td>"); out.print( proc.hasParent() ? proc.getParentProcId() : "" ); out.write("</td>\n <td>"); out.print( escapeXml(proc.getState().toString() + (proc.isBypass() ? "(Bypass)" : "")) );
.setLastUpdate(proc.getLastUpdate()); if (proc.hasParent()) { builder.setParentId(proc.getParentProcId());
@InterfaceAudience.Private protected static Long getRootProcedureId(final Map<Long, Procedure> procedures, Procedure proc) { while (proc.hasParent()) { proc = procedures.get(proc.getParentProcId()); if (proc == null) return null; } return proc.getProcId(); }
private Procedure<TEnvironment> prepareProcedure(Procedure<TEnvironment> proc) { Preconditions.checkArgument(proc.getState() == ProcedureState.INITIALIZING); Preconditions.checkArgument(!proc.hasParent(), "unexpected parent", proc); if (this.checkOwnerSet) { Preconditions.checkArgument(proc.hasOwner(), "missing owner"); } return proc; }
private Procedure prepareProcedure(final Procedure proc) { Preconditions.checkArgument(proc.getState() == ProcedureState.INITIALIZING); Preconditions.checkArgument(isRunning(), "executor not running"); Preconditions.checkArgument(!proc.hasParent(), "unexpected parent", proc); if (this.checkOwnerSet) { Preconditions.checkArgument(proc.hasOwner(), "missing owner"); } return proc; }