Author: saces
Date: 2009-04-14 19:24:13 +0000 (Tue, 14 Apr 2009)
New Revision: 26799
Added:
trunk/freenet/src/freenet/client/async/BaseManifestPutter.java
Log:
new ManifestPutter infrastructure
this class BaseManifestPutter contains all the code to insert the stuff and
provide helpers functions to add elements,
but does not have any 'pack logic'. this needs to be implemented in sub classes.
Added: trunk/freenet/src/freenet/client/async/BaseManifestPutter.java
===================================================================
--- trunk/freenet/src/freenet/client/async/BaseManifestPutter.java
(rev 0)
+++ trunk/freenet/src/freenet/client/async/BaseManifestPutter.java
2009-04-14 19:24:13 UTC (rev 26799)
@@ -0,0 +1,1864 @@
+package freenet.client.async;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+import java.util.Vector;
+
+import com.db4o.ObjectContainer;
+
+import freenet.client.ClientMetadata;
+import freenet.client.DefaultMIMETypes;
+import freenet.client.InsertBlock;
+import freenet.client.InsertContext;
+import freenet.client.InsertException;
+import freenet.client.Metadata;
+import freenet.client.MetadataUnresolvedException;
+import freenet.client.ArchiveManager.ARCHIVE_TYPE;
+import freenet.client.events.SplitfileProgressEvent;
+import freenet.keys.BaseClientKey;
+import freenet.keys.FreenetURI;
+import freenet.node.RequestClient;
+import freenet.support.LogThresholdCallback;
+import freenet.support.Logger;
+import freenet.support.api.Bucket;
+import freenet.support.io.BucketTools;
+import freenet.support.io.NativeThread;
+
+public abstract class BaseManifestPutter extends BaseClientPutter implements
PutCompletionCallback {
+
+ private static volatile boolean logMINOR;
+ private static volatile boolean logDEBUG;
+
+ static {
+ Logger.registerLogThresholdCallback(new LogThresholdCallback() {
+
+ @Override
+ public void shouldUpdate() {
+ logMINOR = Logger.shouldLog(Logger.MINOR, this);
+ logDEBUG = Logger.shouldLog(Logger.DEBUG, this);
+ }
+ });
+ }
+
+ // Only implements PutCompletionCallback for the final metadata insert
+ protected class PutHandler extends BaseClientPutter implements
PutCompletionCallback {
+
+ protected PutHandler(final BaseManifestPutter smp, String name,
Bucket data, ClientMetadata cm, boolean getCHKOnly) {
+ this(smp, null, name, data, cm, getCHKOnly);
+ }
+
+ protected PutHandler(final BaseManifestPutter smp, PutHandler
parent, String name, Bucket data, ClientMetadata cm, boolean getCHKOnly) {
+ super(smp.priorityClass, smp.client);
+ this.persistent = BaseManifestPutter.this.persistent();
+ this.cm = cm;
+ this.name = name;
+ InsertBlock block =
+ new InsertBlock(data, cm, persistent() ?
FreenetURI.EMPTY_CHK_URI.clone() : FreenetURI.EMPTY_CHK_URI);
+ this.origSFI =
+ new SingleFileInserter(this, this, block,
false, ctx, false, getCHKOnly, true, null, null, false, null, earlyEncode);
+ metadata = null;
+ parentContainerHandle = parent;
+ isArchive = isContainer = false;
+ }
+
+ //protected PutHandler(final SimpleManifestPutter smp, String
name, HashMap<String, Object> data, ClientMetadata cm, boolean getCHKOnly) {
+ // this(smp, null, name, data, cm, getCHKOnly);
+ //}
+
+ protected PutHandler(final BaseManifestPutter smp, PutHandler
parent, String name, HashMap<String, Object> data, ClientMetadata cm, boolean
getCHKOnly, boolean isArchive2) {
+ super(smp.priorityClass, smp.client);
+ this.persistent = BaseManifestPutter.this.persistent();
+ this.cm = cm;
+ this.name = name;
+ this.origSFI =
+ new ContainerInserter(this, this, data,
(persistent ? FreenetURI.EMPTY_CHK_URI.clone() : FreenetURI.EMPTY_CHK_URI),
ctx, false, getCHKOnly, !isArchive2, null, ARCHIVE_TYPE.TAR, false,
earlyEncode);
+ metadata = null;
+ parentContainerHandle = parent;
+ isContainer = true;
+ isArchive = isArchive2;
+ }
+
+ protected PutHandler(final BaseManifestPutter smp, String name,
FreenetURI target, ClientMetadata cm) {
+ this(smp, null, name, name, target, cm);
+ }
+
+ protected PutHandler(final BaseManifestPutter smp, PutHandler
parent, String name, String targetInArchive2, FreenetURI target, ClientMetadata
cm) {
+ super(smp.getPriorityClass(), smp.client);
+ this.persistent = BaseManifestPutter.this.persistent();
+ this.cm = cm;
+ this.name = name;
+ Metadata m = new Metadata(Metadata.SIMPLE_REDIRECT,
null, null, target, cm);
+ metadata = m;
+ if(logMINOR) Logger.minor(this, "Simple redirect
metadata: "+m);
+ origSFI = null;
+ parentContainerHandle = parent;
+ isArchive = isContainer = false;
+ targetInArchive = targetInArchive2;
+ }
+
+ private ClientPutState origSFI;
+ private ClientPutState currentState;
+ private ClientMetadata cm;
+ private Metadata metadata;
+ private String targetInArchive;
+ private final String name;
+ private final boolean persistent;
+ private final PutHandler parentContainerHandle;
+ private final boolean isContainer;
+ private final boolean isArchive;
+
+ public void start(ObjectContainer container, ClientContext
context) throws InsertException {
+ if (logDEBUG)
+ Logger.debug(this, "Starting a PutHandler for
'"+this.name+"' (isRootContainer="+ (this==rootContainerPutHandler)+",
isArchive="+this.isArchive+") " + this);
+
+ if (origSFI == null) {
+ Logger.error(this, "origSFI is null on
start(), should be impossible", new Exception("debug"));
+ return;
+ }
+ if (metadata != null) {
+ Logger.error(this, "metdata=" + metadata + " on
start(), should be impossible", new Exception("debug"));
+ return;
+ }
+ ClientPutState sfi;
+ synchronized(this) {
+ sfi = origSFI;
+ currentState = sfi;
+ origSFI = null;
+ }
+ if(persistent) {
+ container.activate(sfi, 1);
+ container.store(this);
+ }
+ sfi.schedule(container, context);
+ if(persistent) {
+ container.deactivate(sfi, 1);
+ }
+ }
+
+ @Override
+ public void cancel(ObjectContainer container, 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(persistent()) {
+ container.store(this);
+ if(oldState != null)
+ container.activate(oldState, 1);
+ }
+ if(oldState != null) oldState.cancel(container,
context);
+ onFailure(new
InsertException(InsertException.CANCELLED), null, container, context);
+ }
+
+ @Override
+ public FreenetURI getURI() {
+ return null;
+ }
+
+ @Override
+ public boolean isFinished() {
+ if(logMINOR) Logger.minor(this, "Finished "+this, new
Exception("debug"));
+ return BaseManifestPutter.this.finished || cancelled ||
BaseManifestPutter.this.cancelled;
+ }
+
+ public void onSuccess(ClientPutState state, ObjectContainer
container, ClientContext context) {
+ if(logMINOR) Logger.minor(this, "Completed
'"+this.name+"' "+this);
+
+
+ if (isArchive) {
+
+ Vector<PutHandler> phv =
putHandlersArchiveTransformMap.get(this);
+ for (PutHandler ph: phv) {
+//
+
perContainerPutHandlersWaitingForFetchable.get(ph.parentContainerHandle).remove(this);
+// Metadata m = new
Metadata(Metadata.SIMPLE_REDIRECT, null, null,
archiveURI.setDocName(targetInArchive), cm);
+// hm.put(ph.name, m);
+// putHandlersTransformMap.remove(ph);
+ try {
+
maybeStartParentContainer(ph.parentContainerHandle, container, context);
+ } catch (InsertException e) {
+ fail(new
InsertException(InsertException.INTERNAL_ERROR, e, null), container, context);
+ return;
+ }
+ }
+ return;
+ }
+
+ if(persistent) {
+ container.activate(BaseManifestPutter.this, 1);
+ container.activate(runningPutHandlers, 2);
+ }
+ BaseManifestPutter.this.onFetchable(this, container);
+ ClientPutState oldState;
+ boolean insertedAllFiles = true;
+ synchronized(this) {
+ oldState = currentState;
+ currentState = null;
+ }
+ synchronized(BaseManifestPutter.this) {
+ if(persistent) container.store(this);
+ runningPutHandlers.remove(this);
+ if(persistent) {
+
container.ext().store(runningPutHandlers, 2);
+
container.activate(putHandlersWaitingForMetadata, 2);
+ }
+
if(putHandlersWaitingForMetadata.contains(this)) {
+
putHandlersWaitingForMetadata.remove(this);
+
container.ext().store(putHandlersWaitingForMetadata, 2);
+ Logger.error(this, "PutHandler
'"+this.name+"' was in waitingForMetadata in onSuccess() on "+this+" for
"+BaseManifestPutter.this);
+ }
+
+ if(persistent) {
+
container.deactivate(putHandlersWaitingForMetadata, 1);
+ container.activate(waitingForBlockSets,
2);
+ }
+ if(waitingForBlockSets.contains(this)) {
+ waitingForBlockSets.remove(this);
+ container.store(waitingForBlockSets);
+ Logger.error(this, "PutHandler was in
waitingForBlockSets in onSuccess() on "+this+" for "+BaseManifestPutter.this);
+ }
+ if(persistent) {
+
container.deactivate(waitingForBlockSets, 1);
+
container.deactivate(putHandlersWaitingForFetchable, 1);
+
container.activate(putHandlersWaitingForFetchable, 2);
+ }
+
if(putHandlersWaitingForFetchable.contains(this)) {
+
putHandlersWaitingForFetchable.remove(this);
+
container.ext().store(putHandlersWaitingForFetchable, 2);
+ // Not getting an onFetchable is not
unusual, just ignore it.
+ if(logMINOR) Logger.minor(this,
"PutHandler was in waitingForFetchable in onSuccess() on "+this+" for
"+BaseManifestPutter.this);
+ }
+ if(persistent)
+
container.deactivate(putHandlersWaitingForFetchable, 1);
+
+ if(!runningPutHandlers.isEmpty()) {
+ if(logMINOR) {
+ Logger.minor(this, "Running put
handlers: "+runningPutHandlers.size());
+ for(Object o :
runningPutHandlers) {
+ boolean activated =
true;
+ if(persistent) {
+ activated =
container.ext().isActive(o);
+ if(!activated)
container.activate(o, 1);
+ }
+ Logger.minor(this,
"Still running: "+o);
+ if(!activated)
+
container.deactivate(o, 1);
+ }
+ }
+ insertedAllFiles = false;
+ }
+ }
+ if(oldState != null && oldState != state && persistent)
{
+ container.activate(oldState, 1);
+ oldState.removeFrom(container, context);
+ } else if(state != null && persistent) {
+ state.removeFrom(container, context);
+ }
+ if(insertedAllFiles)
+ insertedAllFiles(container, context);
+ if(persistent) {
+ container.deactivate(runningPutHandlers, 1);
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+ }
+
+ public void onFailure(InsertException e, ClientPutState state,
ObjectContainer container, ClientContext context) {
+ ClientPutState oldState;
+ synchronized(this) {
+ oldState = currentState;
+ currentState = null;
+ }
+ if(oldState != null && oldState != state && persistent)
{
+ container.activate(oldState, 1);
+ oldState.removeFrom(container, context);
+ } else if(state != null && persistent) {
+ state.removeFrom(container, context);
+ }
+ if(logMINOR) Logger.minor(this, "Failed: "+this+" -
"+e, e);
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ fail(e, container, context);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ public void onEncode(BaseClientKey key, ClientPutState state,
ObjectContainer container, ClientContext context) {
+ if(logMINOR) Logger.minor(this, "onEncode("+key+") for
"+this);
+ System.out.println("Got a URI:
"+key.getURI().toString(false, false) + " for "+this);
+ if (isArchive) {
+
+ FreenetURI archiveURI = key.getURI();
+
+ Vector<PutHandler> phv =
putHandlersArchiveTransformMap.get(this);
+ for (PutHandler ph: phv) {
+ HashMap<String, Object> hm =
putHandlersTransformMap.get(ph);
+
+
perContainerPutHandlersWaitingForFetchable.get(ph.parentContainerHandle).remove(this);
+ if (ph.targetInArchive == null) throw
new NullPointerException();
+ Metadata m = new
Metadata(Metadata.SIMPLE_REDIRECT, null, null, archiveURI.setMetaString(new
String[]{ph.targetInArchive}), cm);
+ hm.put(ph.name, m);
+ putHandlersTransformMap.remove(ph);
+ }
+
//perContainerPutHandlersWaitingForFetchable.get(parentContainerHandle).remove(this);
+ //putHandlersArchiveTransformMap.remove(this);
+ return;
+ }
+
+ if(metadata == null) {
+ // The file was too small to have its own
metadata, we get this instead.
+ // So we make the key into metadata.
+ if(persistent) {
+ container.activate(key, 5);
+
container.activate(BaseManifestPutter.this, 1);
+ }
+ Metadata m =
+ new Metadata(Metadata.SIMPLE_REDIRECT,
null, null, key.getURI(), cm);
+ onMetadata(m, null, container, context);
+ if(persistent) {
+
container.deactivate(BaseManifestPutter.this, 1);
+ }
+ }
+ }
+
+ /**
+ * The caller of onTransition removes the old state, so we
don't have to.
+ * However, in onSuccess or onFailure, we need to remove the
new state, even if
+ * what is passed in is different (in which case we remove that
too).
+ */
+ public void onTransition(ClientPutState oldState,
ClientPutState newState, ObjectContainer container) {
+ if(newState == null) throw new NullPointerException();
+
+ // onTransition is *not* responsible for removing the
old state, the caller is.
+ synchronized (this) {
+ if (currentState == oldState) {
+ currentState = newState;
+ if(persistent())
+ container.store(this);
+ if(logMINOR)
+ Logger.minor(this,
"onTransition: cur=" + currentState + ", old=" + oldState + ", new=" +
newState+" for "+this);
+ return;
+ }
+ Logger.error(this, "Ignoring onTransition:
cur=" + currentState + ", old=" + oldState + ", new=" + newState+" for "+this);
+ }
+ }
+
+ public void onMetadata(Metadata m, ClientPutState state,
ObjectContainer container, ClientContext context) {
+ if(logMINOR) Logger.minor(this, "Assigning metadata:
"+m+" for '"+this.name+"' "+this+" from "+state+" persistent="+persistent);
+ if(metadata != null) {
+ Logger.error(this, "Reassigning metadata", new
Exception("debug"));
+ return;
+ }
+ metadata = m;
+
+ if (parentContainerHandle != null) {
+ // it is a subcontainer/archive, but not the
root container
+
perContainerPutHandlersWaitingForMetadata.get(parentContainerHandle).remove(this);
+ HashMap<String, Object> hm =
putHandlersTransformMap.get(this);
+ hm.put(name, m);
+ putHandlersTransformMap.remove(this);
+ try {
+
maybeStartParentContainer(parentContainerHandle, container, context);
+ } catch (InsertException e) {
+ fail(new
InsertException(InsertException.INTERNAL_ERROR, e, null), container, context);
+ }
+ return;
+ }
+
+ if (this==rootContainerPutHandler) {
+ baseMetadata = m;
+ resolveAndStartBase(container, context);
+ return;
+ }
+
+ if (containerMode) {
+ try {
+
rootContainerPutHandler.start(container, context);
+ } catch (InsertException e) {
+ fail(new
InsertException(InsertException.INTERNAL_ERROR, e, null), container, context);
+ }
+ return;
+ }
+
+ if(persistent) {
+ container.activate(BaseManifestPutter.this, 1);
+
container.activate(putHandlersWaitingForMetadata, 2);
+ }
+ boolean allMetadatas = false;
+
+ synchronized(BaseManifestPutter.this) {
+ putHandlersWaitingForMetadata.remove(this);
+ if(persistent) {
+
container.ext().store(putHandlersWaitingForMetadata, 2);
+ container.store(this);
+ }
+ allMetadatas =
putHandlersWaitingForMetadata.isEmpty();
+ if(!allMetadatas) {
+ if(logMINOR)
+ Logger.minor(this, "Still
waiting for metadata: "+putHandlersWaitingForMetadata.size());
+ }
+ }
+ if(allMetadatas) {
+ // Will resolve etc.
+ gotAllMetadata(container, context);
+ } else {
+ // Resolve now to speed up the insert.
+ try {
+ byte[] buf = m.writeToByteArray();
+ if(buf.length >
Metadata.MAX_SIZE_IN_MANIFEST)
+ throw new
MetadataUnresolvedException(new Metadata[] { m }, "Too big");
+ } catch (MetadataUnresolvedException e) {
+ try {
+ resolve(e, container, context);
+ } catch (IOException e1) {
+ fail(new
InsertException(InsertException.BUCKET_ERROR, e1, null), container, context);
+ return;
+ } catch (InsertException e1) {
+ fail(e1, container, context);
+ }
+ }
+ }
+ if(persistent) {
+
container.deactivate(putHandlersWaitingForMetadata, 1);
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+ }
+
+ @Override
+ public void addBlock(ObjectContainer container) {
+ if(persistent) {
+ container.activate(BaseManifestPutter.this, 1);
+ }
+ BaseManifestPutter.this.addBlock(container);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void addBlocks(int num, ObjectContainer container) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.addBlocks(num, container);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void completedBlock(boolean dontNotify, ObjectContainer
container, ClientContext context) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.completedBlock(dontNotify,
container, context);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void failedBlock(ObjectContainer container,
ClientContext context) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.failedBlock(container, context);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void fatallyFailedBlock(ObjectContainer container,
ClientContext context) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.fatallyFailedBlock(container,
context);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void addMustSucceedBlocks(int blocks, ObjectContainer
container) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.addMustSucceedBlocks(blocks,
container);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void notifyClients(ObjectContainer container,
ClientContext context) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.notifyClients(container,
context);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ public void onBlockSetFinished(ClientPutState state,
ObjectContainer container, ClientContext context) {
+ if(persistent) {
+ container.activate(BaseManifestPutter.this, 1);
+ container.activate(waitingForBlockSets, 2);
+ }
+ boolean allBlockSets = false;
+ synchronized(BaseManifestPutter.this) {
+ waitingForBlockSets.remove(this);
+ if(persistent)
+ container.store(waitingForBlockSets);
+ allBlockSets = waitingForBlockSets.isEmpty();
+ }
+ if(allBlockSets)
+
BaseManifestPutter.this.blockSetFinalized(container, context);
+ if(persistent) {
+ container.deactivate(waitingForBlockSets, 1);
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+ }
+
+ @Override
+ public void onMajorProgress(ObjectContainer container) {
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.onMajorProgress(container);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ public void onFetchable(ClientPutState state, ObjectContainer
container) {
+ if(logMINOR) Logger.minor(this, "onFetchable "+this,
new Exception("debug"));
+
+ if (isArchive) {
+
+
+
+
//perContainerPutHandlersWaitingForFetchable.get(containerHandle).remove(this);
+
+ return;
+
+ }
+
+ if(persistent)
+ container.activate(BaseManifestPutter.this, 1);
+ BaseManifestPutter.this.onFetchable(this, container);
+ if(persistent)
+ container.deactivate(BaseManifestPutter.this,
1);
+ }
+
+ @Override
+ public void onTransition(ClientGetState oldState,
ClientGetState newState, ObjectContainer container) {
+ // Ignore
+ }
+
+ public void clearMetadata(ObjectContainer container) {
+ metadata = null;
+ if(persistent) container.store(this);
+ }
+
+ @Override
+ public void removeFrom(ObjectContainer container, ClientContext
context) {
+ if(logMINOR) Logger.minor(this, "Removing "+this);
+ ClientPutState oldSFI;
+ ClientPutState oldState;
+ synchronized(this) {
+ oldSFI = origSFI;
+ oldState = currentState;
+ oldSFI = null;
+ currentState = null;
+ }
+ if(oldSFI != null) {
+ Logger.error(this, "origSFI is set in
removeFrom() on "+this+" for "+BaseManifestPutter.this, new Exception("debug"));
+ container.activate(oldSFI, 1);
+ oldSFI.cancel(container, context);
+ oldSFI.removeFrom(container, context);
+ if(oldState == oldSFI) oldState = null;
+ }
+ if(oldState != null) {
+ Logger.error(this, "currentState is set in
removeFrom() on "+this+" for "+BaseManifestPutter.this, new Exception("debug"));
+ container.activate(oldState, 1);
+ oldState.cancel(container, context);
+ oldState.removeFrom(container, context);
+ }
+ if(cm != null) {
+ container.activate(cm, 5);
+ cm.removeFrom(container);
+ }
+ if(metadata != null) {
+ // Possible if cancelled
+ Logger.normal(this, "Metadata is set in
removeFrom() on "+this+" for "+BaseManifestPutter.this);
+ container.activate(metadata, 1);
+ metadata.removeFrom(container);
+ }
+ // Data is responsibility of original caller (usually
ClientPutDir), we don't support freeData atm
+ super.removeFrom(container, context);
+ }
+
+ public boolean objectCanNew(ObjectContainer container) {
+ if(cancelled) {
+ Logger.error(this, "Storing "+this+" when
already cancelled!", new Exception("error"));
+ return false;
+ }
+ if(logMINOR) Logger.minor(this, "Storing "+this+"
activated="+container.ext().isActive(this)+"
stored="+container.ext().isStored(this), new Exception("debug"));
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ if (logDEBUG)
+ return super.toString() + "{Name="+this.name+",
isRootContainer="+ (this==rootContainerPutHandler)+",
isContainer="+this.isContainer+", isArchive="+this.isArchive+'}';
+ return super.toString();
+ }
+
+ }
+
+ // if true top level metadata is a container
+ private boolean containerMode = false;
+ private ContainerBuilder rootContainer;
+ private PutHandler rootContainerPutHandler;
+ private HashSet<PutHandler> containerPutHandlers;
+ private HashMap<PutHandler, HashSet<PutHandler>>
perContainerPutHandlersWaitingForMetadata;
+ private HashMap<PutHandler, HashSet<PutHandler>>
perContainerPutHandlersWaitingForFetchable;
+ private HashMap<PutHandler, HashMap<String, Object>>
putHandlersTransformMap;
+ private HashMap<PutHandler, Vector<PutHandler>>
putHandlersArchiveTransformMap;
+
+ private HashMap<String,Object> putHandlersByName;
+ private HashSet<PutHandler> runningPutHandlers;
+ private HashSet<PutHandler> putHandlersWaitingForMetadata;
+ private HashSet<PutHandler> waitingForBlockSets;
+ private HashSet<PutHandler> putHandlersWaitingForFetchable;
+ private FreenetURI finalURI;
+ private FreenetURI targetURI;
+ private boolean finished;
+ private final InsertContext ctx;
+ final ClientCallback cb;
+ private final boolean getCHKOnly;
+ private boolean insertedAllFiles;
+ private boolean insertedManifest;
+ private final HashMap<Metadata,ClientPutState>
metadataPuttersByMetadata;
+ private final HashMap<Metadata,ClientPutState>
metadataPuttersUnfetchable;
+ private final String defaultName;
+ private int numberOfFiles;
+ private long totalSize;
+ private boolean metadataBlockSetFinalized;
+ private Metadata baseMetadata;
+ private boolean hasResolvedBase;
+ private final static String[] defaultDefaultNames =
+ new String[] { "index.html", "index.htm", "default.html",
"default.htm" };
+ private boolean fetchable;
+ private final boolean earlyEncode;
+
+ public BaseManifestPutter(ClientCallback cb,
+ HashMap<String, Object> manifestElements, short
prioClass, FreenetURI target,
+ String defaultName, InsertContext ctx, boolean
getCHKOnly2, RequestClient clientContext, boolean earlyEncode) {
+ super(prioClass, clientContext);
+ this.defaultName = defaultName;
+ if(client.persistent())
+ this.targetURI = target.clone();
+ else
+ this.targetURI = target;
+ this.cb = cb;
+ this.ctx = ctx;
+ this.getCHKOnly = getCHKOnly2;
+ this.earlyEncode = earlyEncode;
+ putHandlersByName = new HashMap<String,Object>();
+ runningPutHandlers = new HashSet<PutHandler>();
+ putHandlersWaitingForMetadata = new HashSet<PutHandler>();
+ putHandlersWaitingForFetchable = new HashSet<PutHandler>();
+ waitingForBlockSets = new HashSet<PutHandler>();
+ metadataPuttersByMetadata = new
HashMap<Metadata,ClientPutState>();
+ metadataPuttersUnfetchable = new
HashMap<Metadata,ClientPutState>();
+
+ containerPutHandlers = new HashSet<PutHandler>();
+ perContainerPutHandlersWaitingForMetadata = new
HashMap<PutHandler, HashSet<PutHandler>>();
+ perContainerPutHandlersWaitingForFetchable = new
HashMap<PutHandler, HashSet<PutHandler>>();
+ putHandlersTransformMap = new HashMap<PutHandler,
HashMap<String, Object>>();
+ putHandlersArchiveTransformMap = new HashMap<PutHandler,
Vector<PutHandler>>();
+ makePutHandlers(manifestElements, putHandlersByName);
+ }
+
+ public void start(ObjectContainer container, ClientContext context)
throws InsertException {
+ if (logMINOR)
+ Logger.minor(this, "Starting " + this+"
persistence="+persistent()+ " containermode="+containerMode);
+ PutHandler[] running;
+ PutHandler[] containers;
+
+ if(persistent()) {
+ container.activate(runningPutHandlers, 2);
+ }
+ synchronized (this) {
+ running = runningPutHandlers.toArray(new
PutHandler[runningPutHandlers.size()]);
+ if (containerMode) {
+ containers = getContainersToStart();
+ } else {
+ containers = null;
+ }
+ }
+
+ try {
+ boolean persistent = persistent(); // this might get
deactivated ...
+ for (int i = 0; i < running.length; i++) {
+ running[i].start(container, context);
+ if(persistent &&
!container.ext().isActive(this))
+ container.activate(this, 1);
+ if (logMINOR)
+ Logger.minor(this, "Started " + i + "
of " + running.length);
+ if (isFinished()) {
+ if (logMINOR)
+ Logger.minor(this, "Already
finished, killing start() on " + this);
+ return;
+ }
+ }
+ if (logMINOR)
+ Logger.minor(this, "Started " + running.length
+ " PutHandler's for " + this);
+
+ if (containerMode) {
+ for (int i = 0; i < containers.length; i++) {
+ containers[i].start(container, context);
+ if(persistent &&
!container.ext().isActive(this))
+ container.activate(this, 1);
+ if (logMINOR)
+ Logger.minor(this, "Started " +
i + " of " + containers.length);
+ if (isFinished()) {
+ if (logMINOR)
+ Logger.minor(this,
"Already finished, killing start() on " + this);
+ return;
+ }
+ }
+ if (logMINOR)
+ Logger.minor(this, "Started " +
containers.length + " PutHandler's (containers) for " + this);
+
+ }
+ if (!containerMode && running.length == 0) {
+ insertedAllFiles = true;
+ if(persistent())
+ container.store(this);
+ gotAllMetadata(container, context);
+ }
+ } catch (InsertException e) {
+ synchronized(this) {
+ finished = true;
+ }
+ cancelAndFinish(container, context);
+ throw e;
+ }
+ }
+
+ private PutHandler[] getContainersToStart() {
+ PutHandler[] maybeStartPH = containerPutHandlers.toArray(new
PutHandler[containerPutHandlers.size()]);
+ ArrayList<PutHandler> phToStart = new ArrayList<PutHandler>();
+
+ for (PutHandler ph: maybeStartPH) {
+ if
(perContainerPutHandlersWaitingForMetadata.get(ph).isEmpty() &&
perContainerPutHandlersWaitingForFetchable.get(ph).isEmpty() ) {
+ phToStart.add(ph);
+ }
+ }
+ if (maybeStartPH.length == 0) {
+ phToStart.add(rootContainer.selfHandle);
+ }
+ return phToStart.toArray(new PutHandler[phToStart.size()]);
+ }
+
+ /**
+ * Implement the pack logic
+ *
+ * @param manifestElements
+ * @param putHandlersByName
+ */
+ protected abstract void makePutHandlers(HashMap<String, Object>
manifestElements, HashMap<String,Object> putHandlersByName);
+
+ @Override
+ public FreenetURI getURI() {
+ return finalURI;
+ }
+
+ @Override
+ public synchronized boolean isFinished() {
+ return finished || cancelled;
+ }
+
+ private final DBJob runGotAllMetadata = new DBJob() {
+
+ public void run(ObjectContainer container, ClientContext
context) {
+ context.jobRunner.removeRestartJob(this,
NativeThread.NORM_PRIORITY, container);
+ container.activate(BaseManifestPutter.this, 1);
+ innerGotAllMetadata(container, context);
+ container.deactivate(BaseManifestPutter.this, 1);
+ }
+
+ };
+
+ /**
+ * Called when we have metadata for all the PutHandler's.
+ * This does *not* necessarily mean we can immediately insert the final
metadata, since
+ * if these metadata's are too big, they will need to be inserted
separately. See
+ * resolveAndStartBase().
+ * @param container
+ * @param context
+ */
+ private void gotAllMetadata(ObjectContainer container, ClientContext
context) {
+ // This can be huge! Run it on its own transaction to minimize
the build up of stuff to commit
+ // and maximise the opportunities for garbage collection.
+ if(persistent()) {
+ container.activate(runGotAllMetadata, 1); // need to
activate .this!
+ context.jobRunner.queueRestartJob(runGotAllMetadata,
NativeThread.NORM_PRIORITY, container, false);
+ context.jobRunner.queue(runGotAllMetadata,
NativeThread.NORM_PRIORITY, false);
+ } else {
+ innerGotAllMetadata(null, context);
+ }
+ }
+
+ /**
+ * Generate the global metadata, and then call resolveAndStartBase.
+ * @param container
+ * @param context
+ */
+ private void innerGotAllMetadata(ObjectContainer container,
ClientContext context) {
+ if(logMINOR) Logger.minor(this, "Got all metadata");
+ //if (!containerMode) {
+ HashMap<String, Object> namesToByteArrays = new HashMap<String,
Object>();
+ // We'll end up committing it all anyway, and hash maps in hash
maps can cause
+ // *severe* problems (see COR-1582), so activate to max depth
first.
+ if(persistent()) container.activate(putHandlersByName,
Integer.MAX_VALUE);
+ namesToByteArrays(putHandlersByName, namesToByteArrays,
container);
+ if(defaultName != null) {
+ Metadata meta = (Metadata)
namesToByteArrays.get(defaultName);
+ if(meta == null) {
+ fail(new
InsertException(InsertException.INVALID_URI, "Default name "+defaultName+" does
not exist", null), container, context);
+ return;
+ }
+ namesToByteArrays.put("", meta);
+ } else {
+ for(int j=0;j<defaultDefaultNames.length;j++) {
+ String name = defaultDefaultNames[j];
+ Metadata meta = (Metadata)
namesToByteArrays.get(name);
+ if(meta != null) {
+ namesToByteArrays.put("", meta);
+ break;
+ }
+ }
+ }
+ baseMetadata =
+
Metadata.mkRedirectionManifestWithMetadata(namesToByteArrays);
+ if(persistent()) {
+ container.store(baseMetadata);
+ container.store(this);
+ }
+ resolveAndStartBase(container, context);
+
+ }
+
+ /**
+ * Attempt to insert the base metadata and the container. If the base
metadata cannot be resolved,
+ * try to resolve it: start inserts for each part that cannot be
resolved, and wait for them to generate
+ * URIs that can be incorporated into the metadata. This method will
then be called again, and will
+ * complete, or do more resolutions as necessary.
+ * @param container
+ * @param context
+ */
+ private void resolveAndStartBase(ObjectContainer container,
ClientContext context) {
+ Bucket bucket = null;
+ synchronized(this) {
+ if(hasResolvedBase) return;
+ }
+ while(true) {
+ try {
+ if(persistent())
+ container.activate(baseMetadata,
Integer.MAX_VALUE);
+ bucket =
BucketTools.makeImmutableBucket(context.getBucketFactory(persistent()),
baseMetadata.writeToByteArray());
+ if(logMINOR)
+ Logger.minor(this, "Metadata bucket is
"+bucket.size()+" bytes long");
+ break;
+ } catch (IOException e) {
+ fail(new
InsertException(InsertException.BUCKET_ERROR, e, null), container, context);
+ return;
+ } catch (MetadataUnresolvedException e) {
+ try {
+ // Start the insert for the
sub-Metadata.
+ // Eventually it will generate a URI
and call onEncode(), which will call back here.
+ if(logMINOR) Logger.minor(this, "Main
metadata needs resolving: "+e);
+ resolve(e, container, context);
+ if(persistent())
+
container.deactivate(baseMetadata, 1);
+ return;
+ } catch (IOException e1) {
+ if(persistent())
+
container.deactivate(baseMetadata, 1);
+ fail(new
InsertException(InsertException.BUCKET_ERROR, e, null), container, context);
+ return;
+ } catch (InsertException e2) {
+ if(persistent())
+
container.deactivate(baseMetadata, 1);
+ fail(e2, container, context);
+ return;
+ }
+ }
+ }
+ if(bucket == null) return;
+ synchronized(this) {
+ if(hasResolvedBase) return;
+ hasResolvedBase = true;
+ }
+ if(persistent()) {
+ container.store(this);
+ //container.activate(elementsToPutInArchive, 2);
+ }
+ InsertBlock block;
+ boolean isMetadata = true;
+ ARCHIVE_TYPE archiveType = null;
+ block = new InsertBlock(bucket, null, persistent() ?
targetURI.clone() : targetURI);
+ SingleFileInserter metadataInserter;
+ try {
+ metadataInserter =
+ new SingleFileInserter(this, this, block,
isMetadata, ctx, (archiveType == ARCHIVE_TYPE.ZIP) , getCHKOnly, false,
baseMetadata, archiveType, true, null, earlyEncode);
+ if(logMINOR) Logger.minor(this, "Inserting main
metadata: "+metadataInserter+" for "+baseMetadata);
+ if(persistent()) {
+ container.activate(metadataPuttersByMetadata,
2);
+ container.activate(metadataPuttersUnfetchable,
2);
+ }
+ this.metadataPuttersByMetadata.put(baseMetadata,
metadataInserter);
+ metadataPuttersUnfetchable.put(baseMetadata,
metadataInserter);
+ if(persistent()) {
+
container.ext().store(metadataPuttersByMetadata, 2);
+
container.ext().store(metadataPuttersUnfetchable, 2);
+ container.deactivate(metadataPuttersByMetadata,
1);
+
container.deactivate(metadataPuttersUnfetchable, 1);
+ container.deactivate(baseMetadata, 1);
+
+ }
+ metadataInserter.start(null, container, context);
+ } catch (InsertException e) {
+ fail(e, container, context);
+ return;
+ }
+ if(persistent()) {
+ container.deactivate(metadataInserter, 1);
+ }
+ }
+
+ /**
+ * Start inserts for unresolved (too big) Metadata's. Eventually these
will call back with an onEncode(),
+ * meaning they have the CHK, and we can progress to
resolveAndStartBase().
+ * @param e
+ * @param container
+ * @param context
+ * @return
+ * @throws InsertException
+ * @throws IOException
+ */
+ private void resolve(MetadataUnresolvedException e, ObjectContainer
container, ClientContext context) throws InsertException, IOException {
+ Metadata[] metas = e.mustResolve;
+ if(persistent())
+ container.activate(metadataPuttersByMetadata, 2);
+ for(int i=0;i<metas.length;i++) {
+ Metadata m = metas[i];
+ if(persistent()) container.activate(m, 100);
+ if(logMINOR) Logger.minor(this, "Resolving "+m);
+ synchronized(this) {
+ if(metadataPuttersByMetadata.containsKey(m)) {
+ if(logMINOR) Logger.minor(this,
"Already started insert for "+m+" in resolve() for "+metas.length+"
Metadata's");
+ continue;
+ }
+ }
+ if(m.isResolved()) {
+ Logger.error(this, "Already resolved: "+m+" in
resolve() - race condition???");
+ if(persistent()) container.deactivate(m, 1);
+ continue;
+ }
+ try {
+ Bucket b =
m.toBucket(context.getBucketFactory(persistent()));
+
+ InsertBlock ib = new InsertBlock(b, null,
persistent() ? FreenetURI.EMPTY_CHK_URI.clone() : FreenetURI.EMPTY_CHK_URI);
+ SingleFileInserter metadataInserter =
+ new SingleFileInserter(this, this, ib,
true, ctx, false, getCHKOnly, false, m, null, true, null, earlyEncode);
+ if(logMINOR) Logger.minor(this, "Inserting
subsidiary metadata: "+metadataInserter+" for "+m);
+ synchronized(this) {
+ this.metadataPuttersByMetadata.put(m,
metadataInserter);
+ }
+ metadataInserter.start(null, container,
context);
+ if(persistent()) {
+ container.deactivate(metadataInserter,
1);
+ container.deactivate(m, 1);
+ }
+ } catch (MetadataUnresolvedException e1) {
+ resolve(e1, container, context);
+ container.deactivate(m, 1);
+ }
+ }
+ if(persistent()) {
+ container.ext().store(metadataPuttersByMetadata, 2);
+ container.deactivate(metadataPuttersByMetadata, 1);
+ }
+ }
+
+ private void namesToByteArrays(HashMap<String, Object>
putHandlersByName, HashMap<String,Object> namesToByteArrays, ObjectContainer
container) {
+ Iterator<String> i = putHandlersByName.keySet().iterator();
+ while(i.hasNext()) {
+ String name = i.next();
+ Object o = putHandlersByName.get(name);
+ if(o instanceof PutHandler) {
+ PutHandler ph = (PutHandler) o;
+ if(persistent())
+ container.activate(ph, 1);
+ Metadata meta = ph.metadata;
+ if(ph.metadata == null)
+ Logger.error(this, "Metadata for
"+name+" : "+ph+" is null");
+ else {
+ ph.clearMetadata(container);
+ if(persistent())
+ container.activate(meta, 100);
+ Logger.minor(this, "Putting "+name);
+ namesToByteArrays.put(name, meta);
+ if(logMINOR)
+ Logger.minor(this, "Putting
PutHandler into base metadata: "+ph+" name "+name);
+ }
+ } else if(o instanceof HashMap) {
+ HashMap<String,Object> subMap = new
HashMap<String,Object>();
+ // Already activated
+ namesToByteArrays.put(name, subMap);
+ if(logMINOR)
+ Logger.minor(this, "Putting hashmap
into base metadata: "+name+" size "+((HashMap)o).size()+" active = "+container
== null ? "null" : Boolean.toString(container.ext().isActive(o)));
+ Logger.minor(this, "Putting directory: "+name);
+ namesToByteArrays((HashMap<String, Object>)o,
subMap, container);
+ } else
+ throw new IllegalStateException();
+ }
+ }
+
+ private void insertedAllFiles(ObjectContainer container, ClientContext
context) {
+ if(logMINOR) Logger.minor(this, "Inserted all files");
+ synchronized(this) {
+ insertedAllFiles = true;
+ if(finished || cancelled) {
+ if(logMINOR) Logger.minor(this, "Already
"+(finished?"finished":"cancelled"));
+ if(persistent())
+ container.store(this);
+ return;
+ }
+ if(!insertedManifest) {
+ if(logMINOR) Logger.minor(this, "Haven't
inserted manifest");
+ if(persistent())
+ container.store(this);
+ return;
+ }
+ finished = true;
+ }
+ if(persistent())
+ container.store(this);
+ complete(container, context);
+ }
+
+ private void complete(ObjectContainer container, ClientContext context)
{
+ // FIXME we could remove the put handlers after inserting all
files but not having finished the insert of the manifest
+ // However it would complicate matters for no real gain in most
cases...
+ // Also doing it this way means we don't need to worry about
+ if(persistent()) removePutHandlers(container, context);
+ boolean deactivateCB = false;
+ if(persistent()) {
+ deactivateCB = !container.ext().isActive(cb);
+ container.activate(cb, 1);
+ }
+ cb.onSuccess(this, container);
+ if(deactivateCB)
+ container.deactivate(cb, 1);
+ }
+
+ private void fail(InsertException e, ObjectContainer container,
ClientContext context) {
+ // Cancel all, then call the callback
+ synchronized(this) {
+ if(finished) return;
+ finished = true;
+ }
+ cancelAndFinish(container, context);
+ if(persistent()) removePutHandlers(container, context);
+
+ if(persistent())
+ container.activate(cb, 1);
+ cb.onFailure(e, this, container);
+ }
+
+ private void removePutHandlers(ObjectContainer container, ClientContext
context) {
+ container.activate(putHandlersByName, 2);
+ container.activate(runningPutHandlers, 2);
+ container.activate(putHandlersWaitingForMetadata, 2);
+ container.activate(waitingForBlockSets, 2);
+ container.activate(putHandlersWaitingForFetchable, 2);
+ removePutHandlersByName(container, context, putHandlersByName);
+ putHandlersByName = null;
+
+ if(!runningPutHandlers.isEmpty()) {
+ Logger.error(this, "Running put handlers not part of
putHandlersByName: "+runningPutHandlers.size()+" in removePutHandlers() on
"+this, new Exception("error"));
+ PutHandler[] handlers = runningPutHandlers.toArray(new
PutHandler[runningPutHandlers.size()]);
+ for(PutHandler handler : handlers) {
+ container.activate(handler, 1);
+ Logger.error(this, "Still running, but not in
putHandlersByName: "+handler);
+ handler.cancel();
+ handler.removeFrom(container, context);
+ }
+ runningPutHandlers.clear();
+ }
+ if(!putHandlersWaitingForMetadata.isEmpty()) {
+ Logger.error(this, "Put handlers waiting for metadata,
not part of putHandlersByName: "+putHandlersWaitingForMetadata.size()+" in
removePutHandlers() on "+this, new Exception("error"));
+ PutHandler[] handlers =
putHandlersWaitingForMetadata.toArray(new
PutHandler[putHandlersWaitingForMetadata.size()]);
+ for(PutHandler handler : handlers) {
+ container.activate(handler, 1);
+ Logger.error(this, "Still waiting for metadata,
but not in putHandlersByName: "+handler);
+ handler.cancel();
+ handler.removeFrom(container, context);
+ }
+ putHandlersWaitingForMetadata.clear();
+ }
+ if(!waitingForBlockSets.isEmpty()) {
+ Logger.error(this, "Put handlers waiting for block
sets, not part of putHandlersByName: "+waitingForBlockSets.size()+" in
removePutHandlers() on "+this, new Exception("error"));
+ PutHandler[] handlers = waitingForBlockSets.toArray(new
PutHandler[waitingForBlockSets.size()]);
+ for(PutHandler handler : handlers) {
+ container.activate(handler, 1);
+ Logger.error(this, "Still waiting for block
set, but not in putHandlersByName: "+handler);
+ handler.cancel();
+ handler.removeFrom(container, context);
+ }
+ waitingForBlockSets.clear();
+ }
+ if(!putHandlersWaitingForFetchable.isEmpty()) {
+ Logger.error(this, "Put handlers waiting for fetchable,
not part of putHandlersByName: "+putHandlersWaitingForFetchable.size()+" in
removePutHandlers() on "+this, new Exception("error"));
+ PutHandler[] handlers =
putHandlersWaitingForFetchable.toArray(new
PutHandler[putHandlersWaitingForFetchable.size()]);
+ for(PutHandler handler : handlers) {
+ container.activate(handler, 1);
+ Logger.error(this, "Still waiting for
fetchable, but not in putHandlersByName: "+handler);
+ handler.cancel();
+ handler.removeFrom(container, context);
+ }
+ putHandlersWaitingForFetchable.clear();
+ }
+
+ container.delete(runningPutHandlers);
+ container.delete(putHandlersWaitingForMetadata);
+ container.delete(waitingForBlockSets);
+ container.delete(putHandlersWaitingForFetchable);
+ runningPutHandlers = null;
+ putHandlersWaitingForMetadata = null;
+ waitingForBlockSets = null;
+ putHandlersWaitingForFetchable = null;
+ container.store(this);
+ }
+
+ /**
+ * Remove all PutHandler's from the given putHandlersByName sub-map.
+ * Remove the PutHandler's themselves also, remove them from and
complain about
+ * runningPutHandlers, putHandlersWaitingForMetadata,
waitingForBlockSets,
+ * putHandlersWaitingForFetchable, which must have been activated by
the caller.
+ * @param container
+ * @param putHandlersByName
+ */
+ private void removePutHandlersByName(ObjectContainer container,
ClientContext context, HashMap<String, Object> putHandlersByName) {
+ if(logMINOR) Logger.minor(this, "removePutHandlersByName on
"+this+" : map size = "+putHandlersByName.size());
+ for(Map.Entry<String, Object> entry :
putHandlersByName.entrySet()) {
+ String key = entry.getKey();
+ Object value = entry.getValue();
+ if(value instanceof PutHandler) {
+ PutHandler handler = (PutHandler) value;
+ container.activate(handler, 1);
+ if(runningPutHandlers.remove(handler))
+
container.ext().store(runningPutHandlers, 2);
+
if(putHandlersWaitingForMetadata.remove(handler))
+
container.ext().store(putHandlersWaitingForMetadata, 2);
+ if(waitingForBlockSets.remove(handler))
+
container.ext().store(waitingForBlockSets, 2);
+
if(putHandlersWaitingForFetchable.remove(handler))
+
container.ext().store(putHandlersWaitingForFetchable, 2);
+ //if(elementsToPutInArchive.remove(handler))
+ //
container.ext().store(elementsToPutInArchive, 2);
+ handler.removeFrom(container, context);
+ } else {
+ @SuppressWarnings("unchecked")
+ HashMap<String, Object> subMap =
(HashMap<String, Object>) value;
+ container.activate(subMap, 2);
+ removePutHandlersByName(container, context,
subMap);
+ }
+ container.delete(key);
+ }
+ putHandlersByName.clear();
+ container.delete(putHandlersByName);
+ }
+
+ /**
+ * Cancel all running inserters.
+ */
+ private void cancelAndFinish(ObjectContainer container, ClientContext
context) {
+ PutHandler[] running;
+ boolean persistent = persistent();
+ if(persistent)
+ container.activate(runningPutHandlers, 2);
+ synchronized(this) {
+ running = runningPutHandlers.toArray(new
PutHandler[runningPutHandlers.size()]);
+ }
+
+ if(logMINOR) Logger.minor(this, "PutHandler's to cancel:
"+running.length);
+ for(PutHandler putter : running) {
+ boolean active = true;
+ if(persistent) {
+ active = container.ext().isActive(putter);
+ if(!active) container.activate(putter, 1);
+ }
+ putter.cancel(container, context);
+ if(!active) container.deactivate(putter, 1);
+ if(persistent) container.activate(this, 1);
+ }
+
+ ClientPutState[] runningMeta;
+ if(persistent())
+ container.activate(metadataPuttersByMetadata, 2);
+ synchronized(this) {
+ runningMeta =
metadataPuttersByMetadata.values().toArray(new
ClientPutState[metadataPuttersByMetadata.size()]);
+ }
+
+ if(logMINOR) Logger.minor(this, "Metadata putters to cancel:
"+runningMeta.length);
+ for(ClientPutState putter : runningMeta) {
+ boolean active = true;
+ if(persistent) {
+ active = container.ext().isActive(putter);
+ if(!active) container.activate(putter, 1);
+ }
+ putter.cancel(container, context);
+ if(!active) container.deactivate(putter, 1);
+ if(persistent) container.activate(this, 1);
+ }
+
+ }
+
+ @Override
+ public void cancel(ObjectContainer container, ClientContext context) {
+ synchronized(this) {
+ if(finished) return;
+ if(super.cancel()) return;
+ }
+ if(persistent())
+ container.store(this);
+ fail(new InsertException(InsertException.CANCELLED), container,
context);
+ }
+
+ public void onSuccess(ClientPutState state, ObjectContainer container,
ClientContext context) {
+ if(persistent()) {
+ container.activate(metadataPuttersByMetadata, 2);
+ }
+ boolean fin = false;
+ ClientPutState oldState = null;
+ Metadata token = (Metadata) state.getToken();
+ synchronized(this) {
+ if(persistent()) container.activate(token, 1);
+ boolean present =
metadataPuttersByMetadata.containsKey(token);
+ if(present) {
+ oldState =
metadataPuttersByMetadata.remove(token);
+ if(persistent())
+
container.activate(metadataPuttersUnfetchable, 2);
+
if(metadataPuttersUnfetchable.containsKey(token)) {
+
metadataPuttersUnfetchable.remove(token);
+ if(persistent())
+
container.ext().store(metadataPuttersUnfetchable, 2);
+ }
+ }
+ if(!metadataPuttersByMetadata.isEmpty()) {
+ if(logMINOR) Logger.minor(this, "Still running
metadata putters: "+metadataPuttersByMetadata.size());
+ } else {
+ Logger.minor(this, "Inserted manifest
successfully on "+this+" : "+state);
+ insertedManifest = true;
+ if(finished) {
+ if(logMINOR) Logger.minor(this,
"Already finished");
+ if(persistent())
+ container.store(this);
+ } else if(!insertedAllFiles) {
+ if(logMINOR) Logger.minor(this, "Not
inserted all files");
+ if(persistent())
+ container.store(this);
+ } else {
+ finished = true;
+ if(persistent()) container.store(this);
+ fin = true;
+ }
+ }
+ }
+ if(token != baseMetadata)
+ token.removeFrom(container);
+ if(persistent()) {
+ container.ext().store(metadataPuttersByMetadata, 2);
+ container.deactivate(metadataPuttersByMetadata, 1);
+ state.removeFrom(container, context);
+ if(oldState != state && oldState != null) {
+ container.activate(oldState, 1);
+ oldState.removeFrom(container, context);
+ }
+ }
+ if(fin)
+ complete(container, context);
+ }
+
+ public void onFailure(InsertException e, ClientPutState state,
ObjectContainer container, ClientContext context) {
+ if(persistent()) {
+ container.activate(metadataPuttersByMetadata, 2);
+ }
+ ClientPutState oldState = null;
+ Metadata token = (Metadata) state.getToken();
+ synchronized(this) {
+ if(persistent()) container.activate(token, 1);
+ boolean present =
metadataPuttersByMetadata.containsKey(token);
+ if(present) {
+ oldState =
metadataPuttersByMetadata.remove(token);
+ if(persistent())
+
container.activate(metadataPuttersUnfetchable, 2);
+
if(metadataPuttersUnfetchable.containsKey(token)) {
+
metadataPuttersUnfetchable.remove(token);
+ if(persistent())
+
container.ext().store(metadataPuttersUnfetchable);
+ }
+ }
+ }
+ if(token != baseMetadata)
+ token.removeFrom(container);
+ if(persistent()) {
+ container.ext().store(metadataPuttersByMetadata, 2);
+ container.deactivate(metadataPuttersByMetadata, 1);
+ state.removeFrom(container, context);
+ if(oldState != state && oldState != null) {
+ container.activate(oldState, 1);
+ oldState.removeFrom(container, context);
+ }
+ }
+ fail(e, container, context);
+ }
+
+ public void onEncode(BaseClientKey key, ClientPutState state,
ObjectContainer container, ClientContext context) {
+ if(state.getToken() == baseMetadata) {
+ this.finalURI = key.getURI();
+ if(logMINOR) Logger.minor(this, "Got metadata key:
"+finalURI);
+ if(persistent())
+ container.activate(cb, 1);
+ cb.onGeneratedURI(persistent() ? finalURI.clone() :
finalURI, this, container);
+ if(persistent())
+ container.deactivate(cb, 1);
+ if(persistent())
+ container.store(this);
+ } else {
+ // It's a sub-Metadata
+ Metadata m = (Metadata) state.getToken();
+ if(persistent())
+ container.activate(m, 2);
+ m.resolve(key.getURI());
+ if(persistent())
+ container.store(m);
+ if(logMINOR) Logger.minor(this, "Resolved "+m+" :
"+key.getURI());
+ resolveAndStartBase(container, context);
+ }
+ }
+
+ public void onTransition(ClientPutState oldState, ClientPutState
newState, ObjectContainer container) {
+ Metadata m = (Metadata) oldState.getToken();
+ if(persistent()) {
+ container.activate(m, 100);
+ container.activate(metadataPuttersUnfetchable, 2);
+ container.activate(metadataPuttersByMetadata, 2);
+ }
+ synchronized(this) {
+ if(metadataPuttersByMetadata.containsKey(m)) {
+ ClientPutState prevState =
metadataPuttersByMetadata.get(m);
+ if(prevState != oldState) {
+ if(logMINOR) Logger.minor(this,
"Ignoring transition in "+this+" for metadata putter: "+oldState+" ->
"+newState+" because current for "+m+" is "+prevState);
+
container.deactivate(metadataPuttersUnfetchable, 1);
+
container.deactivate(metadataPuttersByMetadata, 1);
+ return;
+ }
+ if(persistent()) container.store(newState);
+ metadataPuttersByMetadata.put(m, newState);
+ if(persistent())
container.ext().store(metadataPuttersByMetadata, 2);
+ if(logMINOR) Logger.minor(this, "Metadata
putter transition: "+oldState+" -> "+newState);
+ if(metadataPuttersUnfetchable.containsKey(m)) {
+ metadataPuttersUnfetchable.put(m,
newState);
+ if(persistent())
container.ext().store(metadataPuttersUnfetchable, 2);
+ if(logMINOR) Logger.minor(this,
"Unfetchable metadata putter transition: "+oldState+" -> "+newState);
+ }
+ if(logMINOR) Logger.minor(this, "Transition:
"+oldState+" -> "+newState);
+ } else {
+ Logger.error(this, "onTransition() but
metadataPuttersByMetadata does not contain metadata tag "+m+" for "+oldState+"
should -> "+newState);
+ }
+ }
+
+ if(persistent()) {
+ container.deactivate(m, 100);
+ container.deactivate(metadataPuttersUnfetchable, 2);
+ container.deactivate(metadataPuttersByMetadata, 2);
+ }
+ }
+
+ public void onMetadata(Metadata m, ClientPutState state,
ObjectContainer container, ClientContext context) {
+ // Ignore
+ }
+
+ @Override
+ public void notifyClients(ObjectContainer container, ClientContext
context) {
+ if(persistent()) {
+ container.activate(ctx, 1);
+ container.activate(ctx.eventProducer, 1);
+ }
+ ctx.eventProducer.produceEvent(new
SplitfileProgressEvent(this.totalBlocks, this.successfulBlocks,
this.failedBlocks, this.fatallyFailedBlocks, this.minSuccessBlocks,
this.blockSetFinalized), container, context);
+ }
+
+ public void onBlockSetFinished(ClientPutState state, ObjectContainer
container, ClientContext context) {
+ synchronized(this) {
+ this.metadataBlockSetFinalized = true;
+ if(persistent())
+ container.activate(waitingForBlockSets, 2);
+ if(!waitingForBlockSets.isEmpty()) {
+ if(persistent()) {
+ container.store(this);
+
container.deactivate(waitingForBlockSets, 1);
+ }
+ return;
+ }
+ }
+ this.blockSetFinalized(container, context);
+ if(persistent()) {
+ container.store(this);
+ container.deactivate(waitingForBlockSets, 1);
+ }
+ }
+
+ @Override
+ public void blockSetFinalized(ObjectContainer container, ClientContext
context) {
+ synchronized(this) {
+ if(!metadataBlockSetFinalized) return;
+ if(persistent())
+ container.activate(waitingForBlockSets, 2);
+ if(waitingForBlockSets.isEmpty()) {
+ if(persistent())
+
container.deactivate(waitingForBlockSets, 1);
+ return;
+ }
+ }
+ if(persistent())
+ container.deactivate(waitingForBlockSets, 1);
+ super.blockSetFinalized(container, context);
+ if(persistent())
+ container.store(this);
+ }
+
+ /**
+ * Convert a HashMap of name -> bucket to a HashSet of ManifestEntry's.
+ * All are to have mimeOverride=null, i.e. we use the auto-detected
mime type
+ * from the filename.
+ */
+ public static HashMap<String, Object>
bucketsByNameToManifestEntries(HashMap<String,Object> bucketsByName) {
+ HashMap<String,Object> manifestEntries = new
HashMap<String,Object>();
+ Iterator<String> i = bucketsByName.keySet().iterator();
+ while(i.hasNext()) {
+ String name = i.next();
+ Object o = bucketsByName.get(name);
+ if(o instanceof Bucket) {
+ Bucket data = (Bucket) bucketsByName.get(name);
+ manifestEntries.put(name, new
ManifestElement(name, data, null,data.size()));
+ } else if(o instanceof HashMap) {
+ manifestEntries.put(name,
bucketsByNameToManifestEntries((HashMap<String, Object>)o));
+ } else
+ throw new
IllegalArgumentException(String.valueOf(o));
+ }
+ return manifestEntries;
+ }
+
+ /**
+ * Convert a hierarchy of HashMap's of ManifestEntries into a series of
+ * ManifestElement's, each of which has a full path.
+ */
+ public static ManifestElement[] flatten(HashMap<String,Object>
manifestElements) {
+ Vector<ManifestElement> v = new Vector<ManifestElement>();
+ flatten(manifestElements, v, "");
+ return v.toArray(new ManifestElement[v.size()]);
+ }
+
+ public static void flatten(HashMap<String,Object> manifestElements,
Vector<ManifestElement> v, String prefix) {
+ Iterator<String> i = manifestElements.keySet().iterator();
+ while(i.hasNext()) {
+ String name = i.next();
+ String fullName = prefix.length() == 0 ? name : prefix+
'/' +name;
+ Object o = manifestElements.get(name);
+ if(o instanceof HashMap) {
+ flatten((HashMap<String, Object>)o, v,
fullName);
+ } else if(o instanceof ManifestElement) {
+ ManifestElement me = (ManifestElement) o;
+ v.add(new ManifestElement(me, fullName));
+ } else
+ throw new
IllegalStateException(String.valueOf(o));
+ }
+ }
+
+ /**
+ * Opposite of flatten(...).
+ * Note that this can throw a ClassCastException if the vector passed
in is
+ * bogus (has files pretending to be directories).
+ */
+ public static <T> HashMap<String, Object>
unflatten(List<ManifestElement> v) {
+ HashMap<String, Object> manifestElements = new HashMap<String,
Object>();
+ for(ManifestElement oldElement : v) {
+ add(oldElement, oldElement.getName(), manifestElements);
+ }
+ return manifestElements;
+ }
+
+ private static void add(ManifestElement e, String namePart, Map<String,
Object> target) {
+ int idx = namePart.indexOf('/');
+ if(idx < 0) {
+ target.put(namePart, new ManifestElement(e, namePart));
+ } else {
+ String before = namePart.substring(0, idx);
+ String after = namePart.substring(idx+1);
+ @SuppressWarnings("unchecked")
+ HashMap<String, Object> hm = (HashMap<String, Object>)
target.get(before);
+ if(hm == null) {
+ hm = new HashMap<String, Object>();
+ target.put(before.intern(), hm);
+ }
+ add(e, after, hm);
+ }
+ }
+
+ public int countFiles() {
+ return numberOfFiles;
+ }
+
+ public long totalSize() {
+ return totalSize;
+ }
+
+ @Override
+ public void onMajorProgress(ObjectContainer container) {
+ boolean deactivate = false;
+ if(persistent()) {
+ deactivate = !container.ext().isActive(cb);
+ if(deactivate) container.activate(cb, 1);
+ }
+ cb.onMajorProgress(container);
+ if(deactivate) container.deactivate(cb, 1);
+ }
+
+ protected void onFetchable(PutHandler handler, ObjectContainer
container) {
+ if(persistent()) {
+ container.activate(putHandlersWaitingForFetchable, 2);
+ container.activate(metadataPuttersUnfetchable, 2);
+ }
+ if(checkFetchable(handler)) {
+ if(persistent()) {
+
container.ext().store(putHandlersWaitingForMetadata, 2);
+ container.store(this);
+
container.deactivate(putHandlersWaitingForFetchable, 1);
+
container.deactivate(metadataPuttersUnfetchable, 1);
+ container.activate(cb, 1);
+ }
+ cb.onFetchable(this, container);
+ if(persistent())
+ container.deactivate(cb, 1);
+ } else {
+ if(persistent()) {
+
container.deactivate(putHandlersWaitingForFetchable, 1);
+
container.deactivate(metadataPuttersUnfetchable, 1);
+ }
+ }
+ }
+
+ private synchronized boolean checkFetchable(PutHandler handler) {
+ putHandlersWaitingForFetchable.remove(handler);
+ if(fetchable) return false;
+ if(!putHandlersWaitingForFetchable.isEmpty()) return false;
+ if(!hasResolvedBase) return false;
+ if(!metadataPuttersUnfetchable.isEmpty()) return false;
+ fetchable = true;
+ return true;
+ }
+
+ public void onFetchable(ClientPutState state, ObjectContainer
container) {
+ Metadata m = (Metadata) state.getToken();
+ if(persistent()) {
+ container.activate(m, 100);
+ container.activate(metadataPuttersUnfetchable, 2);
+ container.activate(putHandlersWaitingForFetchable, 2);
+ }
+ if(checkFetchable(m)) {
+ if(persistent()) {
+
container.ext().store(metadataPuttersUnfetchable, 2);
+ container.store(this);
+ container.activate(cb, 1);
+ }
+ cb.onFetchable(this, container);
+ if(persistent())
+ container.deactivate(cb, 1);
+ }
+ if(persistent()) {
+ container.deactivate(metadataPuttersUnfetchable, 1);
+ container.deactivate(putHandlersWaitingForFetchable, 1);
+ }
+ }
+
+ private synchronized boolean checkFetchable(Metadata m) {
+ metadataPuttersUnfetchable.remove(m);
+ if(!metadataPuttersUnfetchable.isEmpty()) return false;
+ if(fetchable) return false;
+ if(!putHandlersWaitingForFetchable.isEmpty()) return false;
+ fetchable = true;
+ return true;
+ }
+
+ @Override
+ public void onTransition(ClientGetState oldState, ClientGetState
newState, ObjectContainer container) {
+ // Ignore
+ }
+
+ @Override
+ public void removeFrom(ObjectContainer container, ClientContext
context) {
+ if(putHandlersByName != null) {
+ Logger.error(this, "Put handlers list still present in
removeFrom() on "+this);
+ removePutHandlers(container, context);
+ }
+ if(finalURI != null) {
+ container.activate(finalURI, 5);
+ finalURI.removeFrom(container);
+ }
+ container.activate(targetURI, 5);
+ targetURI.removeFrom(container);
+ // This is passed in. We should not remove it, because the
caller (ClientPutDir) should remove it.
+// container.activate(ctx, 1);
+// ctx.removeFrom(container);
+ container.activate(metadataPuttersByMetadata, 2);
+ container.activate(metadataPuttersUnfetchable, 2);
+ ArrayList<Metadata> metas = null;
+ if(!metadataPuttersByMetadata.isEmpty()) {
+ Logger.error(this, "Metadata putters by metadata not
empty in removeFrom() on "+this);
+ for(Map.Entry<Metadata, ClientPutState> entry :
metadataPuttersByMetadata.entrySet()) {
+ Metadata meta = entry.getKey();
+ container.activate(meta, 1);
+ ClientPutState sfi = entry.getValue();
+ container.activate(sfi, 1);
+ metadataPuttersUnfetchable.remove(meta);
+ Logger.error(this, "Metadata putters not empty:
"+sfi+" for "+this);
+ sfi.cancel(container, context);
+ sfi.removeFrom(container, context);
+ if(metas == null) metas = new
ArrayList<Metadata>();
+ metas.add(meta);
+ }
+ }
+ if(!metadataPuttersUnfetchable.isEmpty()) {
+ Logger.error(this, "Metadata putters unfetchable by
metadata not empty in removeFrom() on "+this);
+ for(Map.Entry<Metadata, ClientPutState> entry :
metadataPuttersByMetadata.entrySet()) {
+ Metadata meta = entry.getKey();
+ container.activate(meta, 1);
+ ClientPutState sfi = entry.getValue();
+ container.activate(sfi, 1);
+ metadataPuttersUnfetchable.remove(meta);
+ Logger.error(this, "Metadata putters
unfetchable not empty: "+sfi+" for "+this);
+ sfi.cancel(container, context);
+ sfi.removeFrom(container, context);
+ }
+ }
+ if(metas != null) {
+ for(Metadata meta : metas) {
+ if(meta == baseMetadata) continue;
+ container.activate(meta, 1);
+ meta.removeFrom(container);
+ }
+ }
+ metadataPuttersByMetadata.clear();
+ metadataPuttersUnfetchable.clear();
+ container.delete(metadataPuttersByMetadata);
+ container.delete(metadataPuttersUnfetchable);
+ if(baseMetadata != null) {
+ container.activate(baseMetadata, 1);
+ baseMetadata.removeFrom(container);
+ }
+ container.activate(runGotAllMetadata, 1);
+ container.delete(runGotAllMetadata);
+ super.removeFrom(container, context);
+ }
+
+ public void objectOnUpdate(ObjectContainer container) {
+ if(logDEBUG) Logger.debug(this, "Updating "+this+"
activated="+container.ext().isActive(this)+"
stored="+container.ext().isStored(this), new Exception("debug"));
+ }
+
+ public boolean objectCanNew(ObjectContainer container) {
+ if(finished) {
+ Logger.error(this, "Storing "+this+" when already
finished!", new Exception("error"));
+ return false;
+ }
+ if(logDEBUG) Logger.debug(this, "Storing "+this+"
activated="+container.ext().isActive(this)+"
stored="+container.ext().isStored(this), new Exception("debug"));
+ return true;
+ }
+
+
+ private void maybeStartParentContainer(PutHandler containerHandle2,
ObjectContainer container, ClientContext context) throws InsertException {
+ if
(perContainerPutHandlersWaitingForMetadata.get(containerHandle2).isEmpty() &&
perContainerPutHandlersWaitingForFetchable.get(containerHandle2).isEmpty()) {
+ containerHandle2.start(container, context);
+ }
+ }
+
+
+ // compose helper stuff
+
+ protected final ClientMetadata guessMime(String name, ManifestElement
me) {
+ return guessMime(name, me.mimeOverride);
+ }
+
+ protected final ClientMetadata guessMime(String name, String mimetype)
{
+ String mimeType = mimetype;
+ if(mimeType == null)
+ mimeType = DefaultMIMETypes.guessMIMEType(name, true);
+ ClientMetadata cm;
+ if(mimeType == null ||
mimeType.equals(DefaultMIMETypes.DEFAULT_MIME_TYPE))
+ cm = null;
+ else
+ cm = new ClientMetadata(mimeType);
+ return cm;
+ }
+
+ protected final void addRedirectNoMime(String name, ManifestElement me,
HashMap<String, Object> putHandlersByName2) {
+ addRedirect(name, me, null, putHandlersByName2);
+ }
+
+ protected final void addRedirect(String name, ManifestElement me,
HashMap<String, Object> putHandlersByName2) {
+ addRedirect(name, me, guessMime(name, me), putHandlersByName2);
+ }
+
+ protected final void addRedirect(String name, ManifestElement me,
ClientMetadata cm, HashMap<String, Object> putHandlersByName2) {
+ if (containerMode) throw new IllegalStateException("You can not
add freeform elements in container mode!");
+ PutHandler ph;
+ Bucket data = me.data;
+ if(me.targetURI != null) {
+ ph = new PutHandler(this, name, me.targetURI, cm);
+ // Just a placeholder, don't actually run it
+ } else {
+ ph = new PutHandler(this, name, data, cm, getCHKOnly);
+ runningPutHandlers.add(ph);
+ putHandlersWaitingForMetadata.add(ph);
+ putHandlersWaitingForFetchable.add(ph);
+ if(logMINOR)
+ Logger.minor(this, "Inserting separately as
PutHandler: "+name+" : "+ph+" persistent="+ph.persistent()+":"+ph.persistent+"
"+persistent());
+ numberOfFiles++;
+ totalSize += data.size();
+ }
+ putHandlersByName2.put(name, ph);
+ }
+
+ public ContainerBuilder makeArchive() {
+ return new ContainerBuilder(false, null, null, true);
+ }
+
+ protected ContainerBuilder getRootContainer() {
+ if (!containerMode) {
+ containerMode = true;
+ rootContainer = new ContainerBuilder(true);
+ putHandlersByName = null;
+ }
+ return rootContainer;
+ }
+
+ protected final class ContainerBuilder {
+
+ private final HashMap<String, Object> rootDir;
+ private HashMap<String, Object> currentDir;
+ private final PutHandler selfHandle;
+
+ private final Stack<HashMap<String, Object>> dirStack;
+
+ private ContainerBuilder(boolean isRoot) {
+ this(isRoot, null, null, false);
+ }
+
+ private ContainerBuilder(PutHandler parent, String name) {
+ this(false, parent, name, false);
+ }
+
+ private ContainerBuilder(boolean isRoot, PutHandler parent,
String name, boolean isArchive) {
+ if (putHandlersByName != null &&
putHandlersByName.size() > 0) {
+ throw new IllegalStateException("You can not
add containers in free form mode!");
+ }
+ dirStack = new Stack<HashMap<String, Object>>();
+ rootDir = new HashMap<String, Object>();
+ selfHandle = new PutHandler(BaseManifestPutter.this,
parent, name, rootDir, null, getCHKOnly, isArchive);
+ currentDir = rootDir;
+ if (isRoot) {
+ rootContainerPutHandler = selfHandle;
+ } else {
+ containerPutHandlers.add(selfHandle);
+ }
+
perContainerPutHandlersWaitingForMetadata.put(selfHandle, new
HashSet<PutHandler>());
+
perContainerPutHandlersWaitingForFetchable.put(selfHandle, new
HashSet<PutHandler>());
+ if (isArchive)
putHandlersArchiveTransformMap.put(selfHandle, new Vector<PutHandler>());
+ }
+
+ public ContainerBuilder makeSubContainer(String name) {
+ ContainerBuilder subCon = new
ContainerBuilder(selfHandle, name);
+ currentDir.put(name , subCon.selfHandle);
+
perContainerPutHandlersWaitingForMetadata.get(selfHandle).add(subCon.selfHandle);
+ putHandlersTransformMap.put(subCon.selfHandle,
currentDir);
+
//perContainerPutHandlersWaitingForFetchable.get(selfHandle).add(subCon.selfHandle);
+ return subCon;
+ }
+
+ public void makeSubDirCD(String name) {
+ currentDir = makeSubDir(currentDir, name);
+ }
+
+ private HashMap<String, Object> makeSubDir(HashMap<String,
Object> parentDir, String name) {
+ HashMap<String, Object> newDir = new HashMap<String,
Object>();
+ parentDir.put(name , newDir);
+ return newDir;
+ }
+
+ public void addItem(String name, String nameInArchive, String
mimeOverride, Bucket data) {
+ addItem(name, nameInArchive, mimeOverride, data, false);
+ }
+
+ public void addItem(String name, String nameInArchive, String
mimeOverride, Bucket data, boolean isDefaultDoc) {
+ ManifestElement element = new ManifestElement(name,
nameInArchive, data, mimeOverride, data.size());
+ addElement(name, element, isDefaultDoc);
+ }
+
+ public void addRedirect(String name, String mimeOverride,
FreenetURI targetURI2) {
+ addRedirect(name, mimeOverride, targetURI2, false);
+ }
+
+ public void addRedirect(String name, String mimeOverride,
FreenetURI targetURI2, boolean isDefaultDoc) {
+ ManifestElement element = new ManifestElement(name,
targetURI2, mimeOverride);
+ addElement(name, element, isDefaultDoc);
+ }
+
+ public void addExternal(String name, String mimeOverride,
Bucket data) {
+ addExternal(name, mimeOverride, data, false);
+ }
+
+ public void addExternal(String name, String mimeOverride,
Bucket data, boolean isDefaultDoc) {
+ PutHandler ph = new PutHandler(BaseManifestPutter.this,
selfHandle, name, data, guessMime(name, mimeOverride), getCHKOnly);
+ runningPutHandlers.add(ph);
+
perContainerPutHandlersWaitingForMetadata.get(selfHandle).add(ph);
+ putHandlersTransformMap.put(ph, currentDir);
+ }
+
+ private void addElement(String name, ManifestElement element,
boolean isDefaultDoc) {
+ currentDir.put(name, element);
+ if (isDefaultDoc) currentDir.put("", element);
+ }
+
+ public void addArchiveItem(ContainerBuilder archive, String
name, String nameInArchive, String mimeTypeOverride, Bucket data) {
+ addArchiveItem(archive, name, nameInArchive,
mimeTypeOverride, data, false);
+ }
+
+ public void addArchiveItem(ContainerBuilder archive, String
name, String nameInArchive, String mimeTypeOverride, Bucket data, boolean
isDefaultDoc) {
+ archive.addItem(name, nameInArchive, mimeTypeOverride,
data, isDefaultDoc);
+ PutHandler ph = new PutHandler(BaseManifestPutter.this,
selfHandle, name, nameInArchive, FreenetURI.EMPTY_CHK_URI, guessMime(name,
mimeTypeOverride));
+ putHandlersTransformMap.put(ph, currentDir);
+
perContainerPutHandlersWaitingForFetchable.get(selfHandle).add(archive.selfHandle);
+
putHandlersArchiveTransformMap.get(archive.selfHandle).add(ph);
+ }
+
+ public void pushCurrentDir() {
+ dirStack.push(currentDir);
+ }
+
+ public void popCurrentDir() {
+ currentDir = dirStack.pop();
+ }
+ }
+}
+
Property changes on:
trunk/freenet/src/freenet/client/async/BaseManifestPutter.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
