@Override public void onResume(ClientContext context) throws InsertException, ResumeFailedException { synchronized(this) { if(resumed) return; resumed = true; } if(sfi != null) sfi.onResume(context); if(metadataPutter != null) metadataPutter.onResume(context); if(sfi != null) sfi.schedule(context); if(metadataPutter != null) { if(ctx.earlyEncode || sfi == null || metaInsertStarted) metadataPutter.schedule(context); } }
@Override public void onShutdown(ClientContext context) { ClientPutState s; synchronized(this) { s = currentState; } if(s != null) s.onShutdown(context); }
@Override public void cancel(ClientContext context) { ClientPutState[] states = new ClientPutState[waitingFor.size()]; synchronized(this) { states = waitingFor.toArray(states); } boolean logDEBUG = Logger.shouldLog(LogLevel.DEBUG, this); for(int i=0;i<states.length;i++) { if(logDEBUG) Logger.minor(this, "Cancelling state "+i+" of "+states.length+" : "+states[i]); states[i].cancel(context); } }
@Override public void schedule(ClientContext context) throws InsertException { sfi.schedule(context); }
@Override public void innerOnResume(ClientContext context) throws ResumeFailedException { super.innerOnResume(context); try { if(currentState != null) currentState.onResume(context); if(origSFI != null) origSFI.onResume(context); } catch (InsertException e) { Logger.error(this, "Failed to start insert on resume: "+e, e); throw new ResumeFailedException("Insert error: "+e); } }
@Override public void cancel(ClientContext context) { if(logMINOR) Logger.minor(this, "Cancelling "+this); ClientPutState oldSFI = null; ClientPutState oldMetadataPutter = null; synchronized(this) { oldSFI = sfi; oldMetadataPutter = metadataPutter; } if(oldSFI != null) oldSFI.cancel(context); if(oldMetadataPutter != null) oldMetadataPutter.cancel(context); // FIXME in the other cases, fail() and onSuccess(), we only free when // we set finished. But we haven't set finished here. Can we rely on // the callback and not do anything here? Note that it is in fact safe // to double-free, it's not safe to not free. if(freeData) { block.free(); } else { block.nullData(); } }
origSFI = null; sfi.schedule(context);
@Override public void onResume(ClientContext context) throws InsertException, ResumeFailedException { synchronized(this) { if(resumed) return; resumed = true; } for(ClientPutState s : getWaitingFor()) s.onResume(context); if(cb != parent) cb.onResume(context); }
private void fail(InsertException e, ClientContext context) { if(logMINOR) Logger.minor(this, "Failing: "+e, e); ClientPutState oldSFI = null; ClientPutState oldMetadataPutter = null; synchronized(this) { if(finished){ return; } finished = true; oldSFI = sfi; oldMetadataPutter = metadataPutter; } if(oldSFI != null) oldSFI.cancel(context); if(oldMetadataPutter != null) oldMetadataPutter.cancel(context); synchronized(this) { if(freeData) block.free(); else { block.nullData(); } } cb.onFailure(e, this, context); }
putter.schedule(context); if(logMINOR) Logger.minor(this, "Started metadata inserter: "+putter+" for "+this); return true;
@Override public void onShutdown(ClientContext context) { ClientPutState state; synchronized(this) { state = currentState; } if(state != null) state.onShutdown(context); } }
@Override public void innerOnResume(ClientContext context) throws ResumeFailedException { super.innerOnResume(context); if(currentState != null) { try { currentState.onResume(context); } catch (InsertException e) { this.onFailure(e, null, context); return; } } if(data != null) data.onResume(context); notifyClients(context); }
@Override public void cancel(ClientContext context) { if(logMINOR) Logger.minor(this, "Cancelling "+this, new Exception("debug")); ClientPutState oldState = null; synchronized(this) { if(cancelled) return; super.cancel(); oldState = currentState; } if(oldState != null) oldState.cancel(context); onFailure(new InsertException(InsertExceptionMode.CANCELLED), oldState, context); }
if(ctx.earlyEncode && bi instanceof SingleBlockInserter && isCHK) ((SingleBlockInserter)bi).getBlock(context, true); bi.schedule(context); if(!isUSK) cb.onBlockSetFinished(this, context); if(ctx.earlyEncode && metaPutter instanceof SingleBlockInserter) ((SingleBlockInserter)metaPutter).getBlock(context, true); metaPutter.schedule(context); if(!isUSK) cb.onBlockSetFinished(this, context);
@Override public void onShutdown(ClientContext context) { ClientPutState splitfileInserter; ClientPutState metadataInserter; synchronized(this) { splitfileInserter = sfi; metadataInserter = metadataPutter; } if(splitfileInserter != null) splitfileInserter.onShutdown(context); if(metadataInserter != null) metadataInserter.onShutdown(context); }
/** Cancel the insert. Will call onFailure() if it is not already cancelled, so the callback will * normally be called. */ @Override public void cancel(ClientContext context) { if(logMINOR) Logger.minor(this, "Cancelling "+this, new Exception("debug")); ClientPutState oldState = null; synchronized(this) { if(cancelled) return; if(finished) return; super.cancel(); oldState = currentState; } if(oldState != null) oldState.cancel(context); onFailure(new InsertException(InsertExceptionMode.CANCELLED), null, context); }
((SingleFileInserter)currentState).start(context); else currentState.schedule(context); synchronized(this) { cancel = cancelled;
@Override public void onShutdown(ClientContext context) { for(ClientPutState state : getWaitingFor()) { state.onShutdown(context); } }