public void removeFrom(ObjectContainer container) { container.activate(data, 1); data.removeFrom(container); container.activate(targetURI, 5); targetURI.removeFrom(container); container.delete(this); }
public void realRemoveFrom(ObjectContainer container) { synchronized (this) { if (reallyRemoved) Logger.error(this, "Calling realRemoveFrom() twice on " + this); reallyRemoved = true; } bucket.removeFrom(container); container.delete(this); }
public void freeData(ObjectContainer container, boolean persistForever) { if (data != null) { if (persistForever) container.activate(data, 1); data.free(); if (persistForever) data.removeFrom(container); data = null; } if (persistForever) container.delete(this); }
@Override protected void freeData(ObjectContainer container) { Bucket data; synchronized (this) { data = returnBucket; returnBucket = null; } if (data != null) { if (persistenceType == PERSIST_FOREVER) container.activate(data, 5); data.free(); if (persistenceType == PERSIST_FOREVER) data.removeFrom(container); if (persistenceType == PERSIST_FOREVER) container.store(this); } }
@Override public void onSuccess(Object keyNum, ObjectContainer container, ClientContext context) { if (logMINOR) Logger.minor(this, "Succeeded (" + this + "): " + token); if (persistent) container.activate(parent, 1); if (parent.isCancelled()) { fail(new InsertException(InsertException.CANCELLED), container, context); return; } synchronized (this) { if (extraInserts > 0) { if (++completedInserts <= extraInserts) { if (logMINOR) Logger.minor( this, "Completed inserts " + completedInserts + " of extra inserts " + extraInserts + " on " + this); if (persistent) container.store(this); return; // Let it repeat until we've done enough inserts. It hasn't been unregistered yet. } } if (finished) { // Normal with persistence. Logger.normal(this, "Block already completed: " + this); return; } finished = true; } if (persistent) { container.store(this); container.activate(sourceData, 1); } if (freeData) { sourceData.free(); if (persistent) sourceData.removeFrom(container); sourceData = null; if (persistent) container.store(this); } parent.completedBlock(false, container, context); unregister(container, context, getPriorityClass(container)); if (persistent) container.activate(cb, 1); if (logMINOR) Logger.minor(this, "Calling onSuccess for " + cb); cb.onSuccess(this, container, context); if (persistent) container.deactivate(cb, 1); }
/** * Must be called just after construction, but within a transaction. * * @throws IdentifierCollisionException If the identifier is already in use. */ @Override void register(ObjectContainer container, boolean noTags) throws IdentifierCollisionException { if (client != null) assert (this.persistenceType == client.persistenceType); if (persistenceType != PERSIST_CONNECTION) try { client.register(this, container); } catch (IdentifierCollisionException e) { returnBucket.free(); if (persistenceType == PERSIST_FOREVER) returnBucket.removeFrom(container); throw e; } if (persistenceType != PERSIST_CONNECTION && !noTags) { FCPMessage msg = persistentTagMessage(container); client.queueClientRequestMessage(msg, 0, container); } }
public void removeFrom(ObjectContainer container, ClientContext context) { if (logMINOR) Logger.minor(this, "removeFrom() on " + this); container.activate(uri, 5); uri.removeFrom(container); if (resultingURI != null) { container.activate(resultingURI, 5); resultingURI.removeFrom(container); } // cb, parent are responsible for removing themselves // ctx is passed in and unmodified - usually the ClientPutter removes it container.activate(errors, 5); errors.removeFrom(container); if (freeData && sourceData != null && container.ext().isStored(sourceData)) { Logger.error(this, "Data not removed!"); container.activate(sourceData, 1); sourceData.removeFrom(container); } container.delete(this); }
private void fail( InsertException e, boolean forceFatal, ObjectContainer container, ClientContext context) { synchronized (this) { if (finished) return; finished = true; } if (persistent) container.store(this); if (e.isFatal() || forceFatal) parent.fatallyFailedBlock(container, context); else parent.failedBlock(container, context); unregister(container, context, getPriorityClass(container)); if (freeData) { if (persistent) container.activate(sourceData, 1); sourceData.free(); if (persistent) sourceData.removeFrom(container); sourceData = null; if (persistent) container.store(this); } if (persistent) container.activate(cb, 1); cb.onFailure(e, this, container, context); }
protected void onSuccess( Bucket data, boolean fromStore, Integer token, int blockNo, ClientKeyBlock block, ObjectContainer container, ClientContext context) { if (persistent) { container.activate(this, 1); container.activate(segment, 1); container.activate(parent, 1); } if (parent.isCancelled()) { data.free(); if (persistent) data.removeFrom(container); onFailure(new FetchException(FetchException.CANCELLED), token, container, context); return; } segment.onSuccess(data, blockNo, block, container, context, this); }
public void cancel(ObjectContainer container, ClientContext context) { synchronized (this) { if (finished) return; finished = true; } boolean wasActive = true; if (persistent) { container.store(this); wasActive = container.ext().isActive(cb); if (!wasActive) container.activate(cb, 1); container.activate(sourceData, 1); } if (freeData) { sourceData.free(); if (persistent) sourceData.removeFrom(container); sourceData = null; if (persistent) container.store(this); } super.unregister(container, context, getPriorityClass(container)); cb.onFailure(new InsertException(InsertException.CANCELLED), this, container, context); if (!wasActive) container.deactivate(cb, 1); }
@Override public void removeFrom(ObjectContainer container) { underlying.removeFrom(container); container.delete(this); }
public void onSuccess(FetchResult result, ClientGetter state, ObjectContainer container) { Logger.minor(this, "Succeeded: " + identifier); Bucket data = result.asBucket(); if (persistenceType == PERSIST_FOREVER) { if (data != null) container.activate(data, 5); if (returnBucket != null) container.activate(returnBucket, 5); container.activate(client, 1); if (tempFile != null) container.activate(tempFile, 5); if (targetFile != null) container.activate(targetFile, 5); } if (returnBucket != data && !binaryBlob) { boolean failed = true; synchronized (this) { if (finished) { Logger.error( this, "Already finished but onSuccess() for " + this + " data = " + data, new Exception("debug")); data.free(); if (persistenceType == PERSIST_FOREVER) data.removeFrom(container); return; // Already failed - bucket error maybe?? } if (returnType == ClientGetMessage.RETURN_TYPE_DIRECT && returnBucket == null) { // Lost bucket for some reason e.g. bucket error (caused by IOException) on previous try?? // Recover... returnBucket = data; failed = false; } } if (failed && persistenceType == PERSIST_FOREVER) { if (container.ext().getID(returnBucket) == container.ext().getID(data)) { Logger.error( this, "DB4O BUG DETECTED WITHOUT ARRAY HANDLING! EVIL HORRIBLE BUG! UID(returnBucket)=" + container.ext().getID(returnBucket) + " for " + returnBucket + " active=" + container.ext().isActive(returnBucket) + " stored = " + container.ext().isStored(returnBucket) + " but UID(data)=" + container.ext().getID(data) + " for " + data + " active = " + container.ext().isActive(data) + " stored = " + container.ext().isStored(data)); // Succeed anyway, hope that the returned bucket is consistent... returnBucket = data; failed = false; } } if (failed) { Logger.error( this, "returnBucket = " + returnBucket + " but onSuccess() data = " + data, new Exception("debug")); // Caller guarantees that data == returnBucket onFailure( new FetchException(FetchException.INTERNAL_ERROR, "Data != returnBucket"), null, container); return; } } boolean dontFree = false; // FIXME I don't think this is a problem in this case...? (Disk write while locked..) AllDataMessage adm = null; synchronized (this) { if (succeeded) { Logger.error(this, "onSuccess called twice for " + this + " (" + identifier + ')'); return; // We might be called twice; ignore it if so. } started = true; if (!binaryBlob) this.foundDataMimeType = result.getMimeType(); else this.foundDataMimeType = BinaryBlob.MIME_TYPE; if (returnType == ClientGetMessage.RETURN_TYPE_DIRECT) { // Send all the data at once // FIXME there should be other options // FIXME: CompletionTime is set on finish() : we need to give it current time here // but it means we won't always return the same value to clients... Does it matter ? adm = new AllDataMessage( returnBucket, identifier, global, startupTime, System.currentTimeMillis(), this.foundDataMimeType); if (persistenceType == PERSIST_CONNECTION) adm.setFreeOnSent(); dontFree = true; /* * } else if(returnType == ClientGetMessage.RETURN_TYPE_NONE) { // Do nothing */ } else if (returnType == ClientGetMessage.RETURN_TYPE_DISK) { // Write to temp file, then rename over filename if (!FileUtil.renameTo(tempFile, targetFile)) { postFetchProtocolErrorMessage = new ProtocolErrorMessage( ProtocolErrorMessage.COULD_NOT_RENAME_FILE, false, null, identifier, global); // Don't delete temp file, user might want it. } returnBucket = new FileBucket(targetFile, false, true, false, false, false); } if (persistenceType == PERSIST_FOREVER && progressPending != null) { container.activate(progressPending, 1); progressPending.removeFrom(container); } progressPending = null; this.foundDataLength = returnBucket.size(); this.succeeded = true; finished = true; } trySendDataFoundOrGetFailed(null, container); if (adm != null) trySendAllDataMessage(adm, null, container); if (!dontFree) { data.free(); } if (persistenceType == PERSIST_FOREVER) { returnBucket.storeTo(container); container.store(this); } finish(container); if (client != null) client.notifySuccess(this, container); }