/src/freenet/node/Node.java
Java | 5311 lines | 3982 code | 508 blank | 821 comment | 326 complexity | ef64a1efa861fd49520d8b84be251a55 MD5 | raw file
Possible License(s): GPL-2.0
- package freenet.node;
- import java.io.DataInputStream;
- import java.io.DataOutputStream;
- import java.io.File;
- import java.io.FileInputStream;
- import java.io.FileOutputStream;
- import java.io.IOException;
- import java.nio.channels.FileLock;
- import java.text.NumberFormat;
- import java.util.Enumeration;
- import freenet.Address;
- import freenet.Authentity;
- import freenet.Core;
- import freenet.CoreException;
- import freenet.DSAAuthentity;
- import freenet.DSAIdentity;
- import freenet.FieldSet;
- import freenet.Identity;
- import freenet.Key;
- import freenet.KeyException;
- import freenet.Message;
- import freenet.MessageSendCallback;
- import freenet.OpenConnectionManager;
- import freenet.Peer;
- import freenet.PeerPacketMessage;
- import freenet.Presentation;
- import freenet.PresentationHandler;
- import freenet.SendFailedException;
- import freenet.SessionHandler;
- import freenet.Ticker;
- import freenet.TrailerWriter;
- import freenet.TransportHandler;
- import freenet.Version;
- import freenet.client.BackgroundInserter;
- import freenet.client.ClientFactory;
- import freenet.client.FECTools;
- import freenet.client.InternalClient;
- import freenet.config.Config;
- import freenet.config.Params;
- import freenet.config.RandomPortOption;
- import freenet.diagnostics.Diagnostics;
- import freenet.fs.dir.Directory;
- import freenet.interfaces.NIOInterface;
- import freenet.node.ds.DataStore;
- import freenet.node.rt.ExtrapolatingTimeDecayingEventCounter;
- import freenet.node.rt.NGRouting;
- import freenet.node.rt.NGRoutingTable;
- import freenet.node.rt.NodeSortingRoutingTable;
- import freenet.node.rt.RTDiagSnapshot;
- import freenet.node.rt.RunningAverage;
- import freenet.node.rt.SimpleBinaryRunningAverage;
- import freenet.node.rt.SimpleIntervalledRunningAverage;
- import freenet.node.rt.SynchronizedRunningAverage;
- import freenet.node.rt.TimeDecayingRunningAverage;
- import freenet.session.LinkManager;
- import freenet.support.Bucket;
- import freenet.support.BucketFactory;
- import freenet.support.Checkpointed;
- import freenet.support.HexUtil;
- import freenet.support.IntervalledSum;
- import freenet.support.LimitCounter;
- import freenet.support.LoadSaveCheckpointed;
- import freenet.support.Logger;
- import freenet.support.io.Bandwidth;
- import freenet.support.io.ReadInputStream;
- import freenet.thread.ThreadFactory;
- import freenet.transport.tcpAddress;
- import freenet.transport.tcpConnection;
- import freenet.transport.tcpListener;
- /*
- * This code is part of the Java Adaptive Network Client by Ian Clarke. It is
- * distributed under the GNU Public Licence (GPL) version 2. See
- * http://www.gnu.org/ for further details of the GPL.
- */
- /**
- * This is a Wrapper object that contains the components of a Node in the
- * Adaptive Network. It uses a Network object to communicate with other Nodes
- * in the Network.
- *
- * @author <A HREF="mailto:I.Clarke@strs.co.uk">Ian Clarke</A>
- * @author <a href="mailto:blanu@uts.cc.utexas.edu">Brandon Wiley</a>
- */
- public class Node extends Core implements ConnectionThrottler{
- /**
- * @author root
- *
- * TODO To change the template for this generated type comment go to
- * Window - Preferences - Java - Code Generation - Code and Comments
- */
- private class RateLimitingWriterCheckpointed extends LoadSaveCheckpointed {
- public RateLimitingWriterCheckpointed(File routingDir) {
- super(routingDir, new String[] { "ratedata_a", "ratedata_b" });
- }
- protected int checkpointPeriod() {
- return 60000;
- }
- public void writeData(DataOutputStream dos) throws IOException {
- receivedRequestCounter.writeDataTo(dos);
- acceptedExternalRequestCounter.writeDataTo(dos);
- globalQuotaAverager.writeDataTo(dos);
- sentRequestCounter.writeDataTo(dos);
- }
- protected void fillInBlanks() {
- if(receivedRequestCounter == null)
- receivedRequestCounter = new ExtrapolatingTimeDecayingEventCounter(rateLimitingInterval, 1000);
- Core.logger.log(this, "receivedRequestCounter = "+receivedRequestCounter, Logger.DEBUG);
- if(acceptedExternalRequestCounter == null)
- acceptedExternalRequestCounter = new ExtrapolatingTimeDecayingEventCounter(rateLimitingInterval, 1000);
- Core.logger.log(this, "acceptedExternalRequestCounter = "+acceptedExternalRequestCounter, Logger.DEBUG);
- if(globalQuotaAverager == null)
- globalQuotaAverager = new TimeDecayingRunningAverage(1000, rateLimitingInterval, 0, Double.MAX_VALUE);
- Core.logger.log(this, "globalQuotaAverager = "+globalQuotaAverager, Logger.DEBUG);
- if(sentRequestCounter == null)
- sentRequestCounter = new ExtrapolatingTimeDecayingEventCounter(rateLimitingInterval/2, 1000);
- Core.logger.log(this, "sentRequestCounter = "+sentRequestCounter, Logger.DEBUG);
- }
- protected void readFrom(DataInputStream dis) throws IOException {
- receivedRequestCounter = new ExtrapolatingTimeDecayingEventCounter(1000, rateLimitingInterval, dis);
- Core.logger.log(this, "Read receivedRequestCounter: "+receivedRequestCounter, Logger.MINOR);
- acceptedExternalRequestCounter = new ExtrapolatingTimeDecayingEventCounter(1000, rateLimitingInterval, dis);
- Core.logger.log(this, "Read acceptedExternalRequestCounter: "+acceptedExternalRequestCounter, Logger.MINOR);
- globalQuotaAverager = new TimeDecayingRunningAverage(1000, rateLimitingInterval, 0, Double.MAX_VALUE, dis);
- Core.logger.log(this, "Read globalQuotaAverager: "+globalQuotaAverager, Logger.MINOR);
- sentRequestCounter = new ExtrapolatingTimeDecayingEventCounter(1000, rateLimitingInterval, dis);
- Core.logger.log(this, "Read sentRequestCounter: "+sentRequestCounter, Logger.MINOR);
- }
- protected void preload() {
- // All will be initted to null
- }
- public String getCheckpointName() {
- return "Rate limiting data save process";
- }
- }
- public static int maxConnDefault = 200;
- public static int maxFileDefault = 256;
- public static boolean isWin95;
- public static boolean isWin9X;
- public static boolean isWinCE;
- public static boolean isOSX;
- public static String sysName = System.getProperty("os.name");
- private static final NumberFormat nfp;
- private static final NumberFormat nf1;
- private static final NumberFormat nf03;
- private static final NumberFormat nf3;
- static float overloadHighDefault = 1.25f;
- private static final String ARG_BOOLEAN = "<true|false>";
- static {
- nfp = NumberFormat.getPercentInstance();
- nfp.setMinimumFractionDigits(0);
- nfp.setMaximumFractionDigits(1);
- nf1 = NumberFormat.getInstance();
- nf1.setMaximumFractionDigits(1);
- nf1.setMinimumFractionDigits(1);
- nf1.setGroupingUsed(false);
- nf03 = NumberFormat.getInstance();
- nf03.setMinimumFractionDigits(0);
- nf03.setMaximumFractionDigits(3);
- nf03.setGroupingUsed(false);
- nf3 = NumberFormat.getInstance();
- nf3.setMaximumFractionDigits(3);
- nf3.setMinimumFractionDigits(3);
- nf3.setGroupingUsed(false);
- // System.err.println("Node.java static initialization start.");
- Config config = getConfig();
- // internal defaults
- config.addOption("rtMaxRefs", 1, 50, 1300); // 50 refs/node
- // rtMaxNodes later down because of OS detection
- config.addOption("maxRoutingSteps", 1, 200, 1303); // to 10 refs
- config.addOption("messageStoreSize", 1, 10000, 1350);
- // 10000 live chains
- config.addOption("failureTableSize", 1, 20000, 1360);
- // 20000 failed keys - uses ~ 2.7MB
- config.addOption("failureTableItems", 1, 100000, 1361);
- config.addOption("failureTableTime", 1, 1800000l, 1362); // 30 min
- config.addOption("newNodePollInterval", 1, 30000, 1363); // 30 seconds
- // ARK stuff
- config.addOption("minCP", 1, 0.01F, 1370);
- config.addOption("failuresLookupARK", 1, 10, 1371);
- config.addOption("minARKDelay", 1, 900 * 1000, 1372);
- config.addOption("maxARKThreadsFraction", 1, 0.1F, 1373);
- // network defaults
- config.addOption("routeConnectTimeout", 1, 10000, 1400); // 10 sec
- config.addOption("maxHopsToLive", 1, 20, 1410);
- config.addOption("probIncHopsSinceReset", 1, 0.95F, 1411);
- config.addOption("cacheProbPerHop", 1, 0.8F, 1412);
- config.addOption("minStoreFullPCache", 1, 0.9F, 1413);
- config.addOption("minRTFullPRef", 1, 0.3F, 1414);
- config.addOption("minRTNodesPRef", 1, 0.8F, 1415);
- config.addOption("maxLog2DataSize", 1, 20, 1416);
- // network resource limiting options
- config.addOption("bandwidthLimit", 1, 0, 1200);
- config.addOption("inputBandwidthLimit", 1, 0, 1201); // disabled
- config.addOption("outputBandwidthLimit", 1, 12 * 1024, 1202);
- // 12kB/sec, so it doesn't ruin 128kbps uplink which is unfortunately
- // way too common
- config.addOption("averageBandwidthLimit", 1, 0, 1203); // disabled
- config.addOption("averageInputBandwidthLimit", 1, 0, 1204); // disabled
- config.addOption("averageOutputBandwidthLimit", 1, 0, 1205);
- // disabled
- sysName = sysName.toLowerCase();
- if (sysName.startsWith("windows")) {
- maxFileDefault = 1024;
- // http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vccore98/html/_crt__setmaxstdio.asp
- if (sysName.startsWith("windows ce"))
- isWinCE = true;
- else if (sysName.startsWith("windows 95")) {
- isWin95 = true;
- isWin9X = true;
- maxConnDefault = 20;
- } else if (
- sysName.startsWith("windows 98")
- || (sysName.startsWith("windows")
- && (sysName.indexOf("millennium") != -1))
- || (sysName.startsWith("windows me"))) {
- // Detected Windows 9X
- maxConnDefault = 60;
- isWin9X = true;
- } else {
- isWin9X = false;
- }
- }
- if (sysName.startsWith("mac os x")) {
- maxConnDefault = 128;
- maxFileDefault = 64;
- isOSX = true;
- } else
- isOSX = false;
- if (sysName.startsWith("netware")) {
- // supports unlimited FDs
- maxFileDefault = 0;
- }
- config.addOption("rtMaxNodes", 1, 100, 1301);
- config.addOption("doEstimatorSmoothing", 1, true, 1304);
- config.addOption("useFastEstimators", 1, true, 1305);
- config.addOption("maxNodeConnections", 1, maxConnDefault, 1224);
- config.addOption("maxOpenConnectionsNewbieFraction", 1, 0.2, 1225);
- config.addOption("maxNodeFilesOpen", 1, maxFileDefault, 1226);
- config.addOption("maxNegotiations", 1, 50, 1227);
- // I'm deprecating these in favor of
- config.addOption("maxConnectionsPerMinute", 1, 60, 1228);
- config.addOption("maxConnectionsMinute", 1, 60000, 1229);
- // these, and increasing the default quite a bit while at it.
- config.addOption("maxRequestsPerInterval", 1, -1, 1230);
- config.addOption("maxRequestsInterval", 1, 60000, 1231);
- // data store settings
- config.addOption("storeType", 1, "freenet", 999);
- // "freenet" or "native"
- config.addOption("nodeFile", 1, "", 1000); // node_<port>
- config.addOption("storeFile", 1, "", 1001); // store_<port>
- config.addOption("storeSize", 1, 256L*1024L*1024L, 1010, true);
- // 256MB is reasonable, strictish minimum would be 101MB ((1MB chunk +
- // header) * 100)
- config.addOption("storeBlockSize", 1, 4096, 1011);
- config.addOption("storeMaxTempFraction", 1, (1F / 3F), 1012);
- config.addOption("storeCipherName", 1, "Twofish", 1020);
- // Twofish cipher
- config.addOption("storeCipherWidth", 1, 128, 1021); // 128 bits
- config.addOption("routingDir", 1, "", 1022);
- config.addOption("useDSIndex", 1, true, 1023);
- // network settings
- config.addOption("ipAddress", 1, "", 100); // autodetected if not set
- config.addOption(new RandomPortOption("listenPort", 1, 101));
- // random choice
- config.addOption("clientPort", 1, 8481, 110);
- config.addOption("fcpHosts", 1, "", 112); // loopback only
- config.addOption("transient", 1, false, 300);
- config.setDeprecated("transient", true);
- config.addOption("seedFile", 1, "seednodes.ref", 320);
- config.addOption("routingTableImpl", 1, "ng", 330);
- // logging options
- config.addOption("logLevel", 1, "normal", 1250);
- config.addOption("logFile", 1, "freenet.log", 1251);
- config.addOption("logFormat", 1, "d (c, t, p): m", 1252);
- config.addOption("logDate", 1, "", 1253); // locale default
- config.addOption("logLevelDetail", 1, "", 1254);
- config.addOption("logMaxLinesCached", 1, 10000, 1255);
- config.addOption("logMaxBytesCached", 1, 10L*1024L*1024L, 1256);
- config.addOption("logRotate", 1, false, 1257);
- config.addOption("logRotateUseNativeGzip", 1, false, 1258);
- config.addOption("logRotateInterval", 1, "hour", 1259);
- config.addOption("logOverwrite", 1, true, 1260);
- // diagnostics options
- config.addOption("diagnosticsPath", 1, "stats", 501);
- // announcement options
- config.addOption("doAnnounce", 1, true, 310);
- config.addOption("announcementHTL", 1, 15, 1501);
- config.addOption("announcementAttempts", 1, 3, 1502);
- config.addOption("announcementPollInterval", 1, 900 * 1000, 1513);
- // Set to 0 - with bidi, new nodes should announce immediately
- config.addOption("announcementFirstDelay", 1, /*2 * 3600 * 1000*/0, 1514);
- config.addOption("announcementThreads", 1, 3, 1515);
- config.addOption("announcementUseRT", 1, true, 1516);
- config.addOption("initialRequests", 1, 10, 1520);
- config.addOption("initialRequestHTL", 1, 25, 1521);
- // Load balancing
- config.addOption("doLoadBalance", 1, true, 1550);
- // wierd stuff
- config.addOption("localIsOK", 1, false, 1551);
- config.addOption("dontLimitClients", 1, false, 1552);
- config.addOption("limitAll", 1, false, 1553);
- config.addOption("mainportURIOverride", 1, "", 1554);
- config.addOption("distributionURIOverride", 1, "", 1555);
- config.addOption("aggressiveGC", 1, 0, 1556);
- config.addOption("configUpdateInterval", 1, 5, 1557);
- config.addOption("seednodesUpdateInterval", 1, 5, 1558);
- config.addOption("defaultToSimpleUIMode", 1, true, 1559);
- config.addOption("defaultToOCMHTMLPeerHandlerMode", 1, false, 1560);
- config.addOption("ipDetectorInterval", 1, 10, 1561);
- // FCP admin options
- config.addOption("adminPassword", 1, String.class, 200);
- config.addOption("adminPeer", 1, String.class, 201);
- config.addOption("logOutputBytes", 1, true, 3540);
- config.addOption("logInputBytes", 1, true, 3541);
- // Logging, overload, triage
- config.addOption("logInboundContacts", 1, false, 3500);
- config.addOption("logOutboundContacts", 1, false, 3510);
- config.addOption("logInboundRequests", 1, false, 3520);
- config.addOption("logOutboundRequests", 1, false, 3530);
- config.addOption("logInboundInsertRequestDist", 1, false, 3541);
- config.addOption("logSuccessfulInsertRequestDist", 1, false, 3546);
- config.addOption("doRequestTriageByDelay", 1, true, 3250);
- config.addOption("doRequestTriageBySendTime", 1, true, 3251);
- config.addOption("overloadLow", 1, 1.0f, 3252);
- config.addOption("overloadHigh", 1, overloadHighDefault, 3253);
- config.addOption("threadConnectCutoff", 1, 1.5F, 3254);
- config.addOption("requestDelayCutoff", 1, 1000, 3255);
- config.addOption("successfulDelayCutoff", 1, 2000, 3256);
- config.addOption("requestSendTimeCutoff", 1, 500, 3257);
- config.addOption("successfulSendTimeCutoff", 1, 1000, 3258);
- config.addOption("doOutLimitCutoff", 1, false, 3259);
- config.addOption("outLimitCutoff", 1, 0.8F, 3260);
- config.addOption("doOutLimitConnectCutoff", 1, true, 3261);
- config.addOption("outLimitConnectCutoff", 1, 2.0F, 3262);
- config.addOption("lowLevelBWLimitFudgeFactor", 1, 3F / 4F, 3263);
- config.addOption("doReserveOutputBandwidthForSuccess", 1, false, 3264);
- // Give high-level a chance - if low level is too aggressive, high level
- // won't be effective
- config.addOption("lowLevelBWLimitMultiplier", 1, 1.4F, 3265);
- config.addOption("doLowLevelOutputLimiting", 1, true, 3266);
- config.addOption("doLowLevelInputLimiting", 1, true, 3267);
- // Commented out because of limited use and potential political
- // problems i.e. not cross platform
- config.addOption("doCPULoad",1,false,3264);
- config.addOption("sendingQueueLength", 1, 256, 3266);
- config.addOption("sendingQueueBytes", 1, 1492 * 8, 3267);
- config.addOption("requestIntervalDefault", 1, 1000, 3268);
- config.addOption("requestIntervalQRFactor", 1, 1.05, 3269);
- // WatchMe options.
- config.addOption("watchme", 1, false, 3541);
- config.addOption("watchmeRetries", 1, 3, 3542);
- // LoadStats options.
- config.addOption("defaultResetProbability", 1, 0.05, 3557);
- config.addOption("lsMaxTableSize", 1, 100, 3558);
- config.addOption("lsAcceptRatioSamples", 1, 500, 3559);
- config.addOption("lsHalfLifeHours", 1, 1.2, 3560);
- // Forward Error Correction (FEC) options
- config.addOption("FECTempDir", 1, "", 3600);
- config.addOption("FECInstanceCacheSize", 1, 1, 3610);
- config.addOption("FECMaxConcurrentCodecs", 1, 1, 3612);
- // Default FEC encoder and decoder implementations.
- config.addOption("FEC.Encoders.0.class", 1, "OnionFECEncoder", 3620);
- config.addOption("FEC.Decoders.0.class", 1, "OnionFECDecoder", 3630);
- // Default temp dir for FEC and fproxy if theirs aren't specified
- config.addOption("tempDir", 1, "", 3640);
- config.addOption("tempInStore", 1, false, 3641);
- config.addOption("publicNode", 1, false, 3650);
- // Allow HTTP inserts?
- config.addOption("httpInserts", 1, true, 3651);
- // Allow FCP inserts?
- config.addOption("fcpInserts", 1, true, 3652);
- // UI template set
- config.addOption("UITemplateSet", 1, "aqua", 3653);
- // Bundled client stuff
- config.addOption(
- "filterPassThroughMimeTypes",
- 1,
- "text/plain,image/jpeg,image/gif,image/png",
- 4000);
- // Mainport
- config.addOption(
- "mainport.class",
- 1,
- "freenet.interfaces.servlet.MultipleHttpServletContainer",
- 4100);
- config.addOption("mainport.port", 1, 8888, 4101);
- config.addOption("mainport.allowedHosts", 1, "127.0.0.0/8", 4102);
- config.addOption("mainport.bindAddress", 1, "", 4103);
- config.addOption("mainport.params.servlet.1.uri", 1, "/", 4110);
- config.addOption("mainport.params.servlet.1.method", 1, "GET", 4111);
- config.addOption(
- "mainport.params.servlet.1.class",
- 1,
- "freenet.client.http.FproxyServlet",
- 4112);
- config.addOption(
- "mainport.params.servlet.1.name",
- 1,
- "Freenet HTTP proxy (fproxy)",
- 4113);
- config.addOption(
- "mainport.params.servlet.1.params.requestHtl",
- 1,
- 15,
- 4114);
- config.addOption(
- "mainport.params.servlet.1.params.passThroughMimeTypes",
- 1,
- "",
- 4115);
- config.addOption(
- "mainport.params.servlet.1.params.filter",
- 1,
- true,
- 4116);
- config.addOption(
- "mainport.params.servlet.1.params.filterParanoidStringCheck",
- 1,
- false,
- 4117);
- config.addOption(
- "mainport.params.servlet.1.params.maxForceKeys",
- 1,
- 100,
- 4118);
- config.addOption(
- "mainport.params.servlet.1.params.doSendRobots",
- 1,
- true,
- 4119);
- config.addOption(
- "mainport.params.servlet.1.params.noCache",
- 1,
- false,
- 4119);
- config.addOption(
- "mainport.params.servlet.1.params.dontWarnOperaUsers",
- 1,
- false,
- 4119);
- config.addOption(
- "mainport.params.servlet.2.uri",
- 1,
- "/servlet/nodeinfo/",
- 4120);
- config.addOption("mainport.params.servlet.2.method", 1, "GET", 4121);
- config.addOption(
- "mainport.params.servlet.2.class",
- 1,
- "freenet.node.http.NodeInfoServlet",
- 4122);
- config.addOption(
- "mainport.params.servlet.2.name",
- 1,
- "Web Interface",
- 4123);
- // default bookmarks. Bookmarks start at 6000 so they come last in the config file
- config.addOption("mainport.params.servlet.2.bookmarks.count", 1, -1, 6000);
- config.addOption("mainport.params.servlet.2.bookmarks.0.key", 1, "SSK@qe3ZRJg1Nv1XErADrz7ZYjhDidUPAgM/nubile/11//", 6100);
- config.addOption("mainport.params.servlet.2.bookmarks.0.title", 1, "Nubile", 6101);
- config.addOption("mainport.params.servlet.2.bookmarks.0.activelinkFile", 1, "nubile.png", 6102);
- config.addOption("mainport.params.servlet.2.bookmarks.0.description", 1,
- "Freesite aimed at beginners. Learn basic methods of retrieving and inserting data from and into freenet. " +
- "Unfortunately some of the specifics are slightly outdated.", 6103);
- config.addOption("mainport.params.servlet.2.bookmarks.1.key", 1, "SSK@a7SLJXxcl2eT967cHE5~mzQaYTkPAgM/newtofn/7//", 6130);
- config.addOption("mainport.params.servlet.2.bookmarks.1.title", 1, "New to Freenet?", 6131);
- config.addOption("mainport.params.servlet.2.bookmarks.1.activelinkFile", 1, "newtofn.jpg", 6132);
- config.addOption("mainport.params.servlet.2.bookmarks.1.description", 1,
- "Another freesite aimed at beginners, with emphasis on Windows users connecting via modem.", 6133);
- config.addOption("mainport.params.servlet.2.bookmarks.2.key", 1, "SSK@y~-NCd~il6RMxOe9jjf~VR7mSYwPAgM,ds52dBUTmr8fSHePn1Sn4g/OneMore//", 6140);
- config.addOption("mainport.params.servlet.2.bookmarks.2.title", 1, "One More Time", 6141);
- config.addOption("mainport.params.servlet.2.bookmarks.2.activelinkFile", 1, "activelink.gif", 6142);
- config.addOption("mainport.params.servlet.2.bookmarks.2.description", 1,
- "A freesite indexing other freesites. The index is categorized, with one page per category.", 6143);
- config.addOption("mainport.params.servlet.2.bookmarks.3.key", 1, "SSK@pHWN3FglLQOoBleE3pQ3EX3PLFoPAgM,xgvJe~4roO7d3lT~4QPIzA/atwocentindex//", 6150);
- config.addOption("mainport.params.servlet.2.bookmarks.3.title", 1, "A Two Cent Index", 6151);
- config.addOption("mainport.params.servlet.2.bookmarks.3.activelinkFile", 1, "activelink.jpg", 6152);
- config.addOption("mainport.params.servlet.2.bookmarks.3.description", 1, "A freesite index with narrower inclusion criteria.", 6153);
- config.addOption("mainport.params.servlet.2.bookmarks.4.key", 1, "SSK@rgFrfo~dAesFgV5vylYVNvNGXO0PAgM,wo3T~oLnVbWq-vuD2Kr86Q/frost/19//", 6160);
- config.addOption("mainport.params.servlet.2.bookmarks.4.title", 1, "Frost", 6161);
- config.addOption("mainport.params.servlet.2.bookmarks.4.activelinkFile", 1, "activelink.png", 6162);
- config.addOption("mainport.params.servlet.2.bookmarks.4.description", 1, "Bulletin board and filesharing software.", 6163);
- config.addOption("mainport.params.servlet.2.bookmarks.5.key", 1, "SSK@TEx6TiaPeszpV4AFw3ToutDb49EPAgM/mytwocents/59//", 6200);
- config.addOption("mainport.params.servlet.2.bookmarks.5.title", 1, "My Two Cents Worth", 6201);
- config.addOption("mainport.params.servlet.2.bookmarks.5.activelinkFile", 1, "activelink.jpg", 6202);
- config.addOption("mainport.params.servlet.2.bookmarks.5.description", 1,
- "A flog (freenet blog) about \"my 2cents worth on just about any subject\", according to the author.", 6203);
- // end bookmarks
-
-
- config.addOption(
- "mainport.params.servlet.3.uri",
- 1,
- "/servlet/images/",
- 4130);
- config.addOption("mainport.params.servlet.3.method", 1, "GET", 4131);
- config.addOption(
- "mainport.params.servlet.3.class",
- 1,
- "freenet.client.http.ImageServlet",
- 4132);
- config.addOption(
- "mainport.params.servlet.3.name",
- 1,
- "Server Images",
- 4133);
- config.addOption(
- "mainport.params.servlet.4.uri",
- 1,
- "/servlet/Insert",
- 4140);
- config.addOption("mainport.params.servlet.4.method", 1, "BOTH", 4141);
- config.addOption(
- "mainport.params.servlet.4.class",
- 1,
- "freenet.client.http.InsertServlet",
- 4142);
- config.addOption(
- "mainport.params.servlet.4.name",
- 1,
- "Insert Proxy Status",
- 4143);
- config.addOption(
- "mainport.params.servlet.4.params.insertHtl",
- 1,
- 20,
- 4144);
- config.addOption(
- "mainport.params.servlet.4.params.sfInsertThreads",
- 1,
- 30,
- 4145);
- config.addOption(
- "mainport.params.servlet.4.params.sfInsertRetries",
- 1,
- 3,
- 4146);
- config.addOption(
- "mainport.params.servlet.4.params.sfRefreshIntervalSecs",
- 1,
- 15,
- 4147);
- config.addOption("mainport.params.servlet.6.uri", 1, "/", 4190);
- config.addOption("mainport.params.servlet.6.method", 1, "POST", 4191);
- config.addOption(
- "mainport.params.servlet.6.class",
- 1,
- "freenet.client.http.InsertServlet",
- 4192);
- config.addOption(
- "mainport.params.servlet.6.name",
- 1,
- "Insert Proxy",
- 4193);
- config.addOption(
- "mainport.params.servlet.6.params.insertHtl",
- 1,
- 20,
- 4194);
- config.addOption(
- "mainport.params.servlet.6.params.sfInsertThreads",
- 1,
- 20,
- 4195);
- config.addOption(
- "mainport.params.servlet.6.params.sfInsertRetries",
- 1,
- 3,
- 4196);
- config.addOption(
- "mainport.params.servlet.6.params.sfRefreshIntervalSecs",
- 1,
- 15,
- 4197);
- config.addOption(
- "mainport.params.servlet.5.uri",
- 1,
- "/servlet/nodestatus/",
- 4150);
- config.addOption("mainport.params.servlet.5.method", 1, "BOTH", 4151);
- config.addOption(
- "mainport.params.servlet.5.class",
- 1,
- "freenet.client.http.NodeStatusServlet",
- 4152);
- config.addOption(
- "mainport.params.servlet.5.name",
- 1,
- "Node Status",
- 4153);
- config.addOption(
- "mainport.params.servlet.7.uri",
- 1,
- "/servlet/SFRequest/",
- 4160);
- config.addOption("mainport.params.servlet.7.method", 1, "BOTH", 4161);
- config.addOption(
- "mainport.params.servlet.7.class",
- 1,
- "freenet.client.http.SplitFileRequestServlet",
- 4162);
- config.addOption(
- "mainport.params.servlet.7.name",
- 1,
- "SplitFile Download Servlet (alpha!)",
- 4163);
- config.addOption(
- "mainport.params.servlet.7.params.requestHtl",
- 1,
- 20,
- 4164);
- config.addOption(
- "mainport.params.servlet.7.params.sfBlockRequestHtl",
- 1,
- 0,
- 4165);
- config.addOption(
- "mainport.params.servlet.7.params.sfRequestRetries",
- 1,
- 4,
- 4166);
- // Safer to go straight from 0 to 20
- config.addOption(
- "mainport.params.servlet.7.params.sfRetryHtlIncrement",
- 1,
- 20,
- 4167);
- config.addOption(
- "mainport.params.servlet.7.params.sfRequestThreads",
- 1,
- 30,
- 4168);
- config.addOption(
- "mainport.params.servlet.7.params.sfDoParanoidChecks",
- 1,
- true,
- 4169);
- config.addOption(
- "mainport.params.servlet.7.params.sfRefreshIntervalSecs",
- 1,
- 15,
- 4170);
- config.addOption(
- "mainport.params.servlet.7.params.sfForceSave",
- 1,
- false,
- 4171);
- config.addOption(
- "mainport.params.servlet.7.params.sfSkipDS",
- 1,
- false,
- 4172);
- config.addOption(
- "mainport.params.servlet.7.params.sfUseUI",
- 1,
- true,
- 4173);
- config.addOption(
- "mainport.params.servlet.7.params.sfRunFilter",
- 1,
- true,
- 4174);
- config.addOption(
- "mainport.params.servlet.7.params.sfRandomSegs",
- 1,
- true,
- 4175);
- config.addOption(
- "mainport.params.servlet.7.params.sfFilterParanoidStringCheck",
- 1,
- false,
- 4176);
- config.addOption(
- "mainport.params.servlet.7.params.sfHealHtl",
- 1,
- 20,
- 4177);
- config.addOption(
- "mainport.params.servlet.7.params.sfHealPercentage",
- 1,
- 100,
- 4178);
- config.addOption(
- "mainport.params.servlet.7.params.sfForceSave",
- 1,
- true,
- 4179);
- config.addOption(
- "mainport.params.servlet.7.params.maxRetries",
- 1,
- 50,
- 4179);
- String downloadDir;
- try {
- downloadDir =
- System.getProperty("user.home")
- + File.separator
- + "freenet-downloads";
- } catch (Throwable e) {
- downloadDir = "";
- }
- config.addOption(
- "mainport.params.servlet.7.params.sfDefaultSaveDir",
- 1,
- downloadDir,
- 4180);
- config.addOption(
- "mainport.params.servlet.7.params.sfDefaultWriteToDisk",
- 1,
- downloadDir.length()!=0,
- 4181);
- config.addOption(
- "mainport.params.servlet.7.params.sfDisableWriteToDisk",
- 1,
- false,
- 4182);
- config.addOption(
- "mainport.params.servlet.8.uri",
- 1,
- "/servlet/stream/",
- 4190);
- config.addOption("mainport.params.servlet.8.method", 1, "GET", 4191);
- config.addOption(
- "mainport.params.servlet.8.class",
- 1,
- "freenet.client.http.StreamServlet",
- 4192);
- config.addOption(
- "mainport.params.servlet.8.name",
- 1,
- "Freenet Streaming Servlet",
- 4193);
- config.addOption(
- "mainport.params.servlet.9.uri",
- 1,
- "/servlet/streamInsert/",
- 5101);
- config.addOption("mainport.params.servlet.9.method", 1, "GET", 5102);
- config.addOption(
- "mainport.params.servlet.9.class",
- 1,
- "freenet.client.http.StreamInsertServlet",
- 5103);
- config.addOption(
- "mainport.params.servlet.9.name",
- 1,
- "Freenet Stream Insert Servlet",
- 5104);
- config.setExpert("mainport.params.servlet.8.uri", true);
- config.setExpert("mainport.params.servlet.8.method", true);
- config.setExpert("mainport.params.servlet.8.class", true);
- config.setExpert("mainport.params.servlet.8.name", true);
- config.setExpert("mainport.params.servlet.9.uri", true);
- config.setExpert("mainport.params.servlet.9.method", true);
- config.setExpert("mainport.params.servlet.9.class", true);
- config.setExpert("mainport.params.servlet.9.name", true);
- config.addOption(
- "mainport.params.defaultServlet.uri",
- 1,
- "/default",
- 4190);
- config.addOption(
- "mainport.params.defaultServlet.method",
- 1,
- "GET",
- 4191);
- config.addOption(
- "mainport.params.defaultServlet.class",
- 1,
- "freenet.client.http.RedirectServlet",
- 4192);
- config.addOption(
- "mainport.params.defaultServlet.name",
- 1,
- "Web Interface Redirect",
- 4193);
- config.addOption(
- "mainport.params.defaultServlet.params.targetURL",
- 1,
- "/servlet/nodeinfo/",
- 4194);
- // RouteConnectTimeout
- config.setExpert("routeConnectTimeout", true);
- config.argDesc("routeConnectTimeout", "<millis>");
- config.shortDesc(
- "routeConnectTimeout",
- "wait on new connection when routing.");
- config.longDesc(
- "routeConnectTimeout",
- "The time to wait for connections to be established and ",
- "authenticated before passing by a node while routing out.",
- "Connections that are by passed are still finished and cached ",
- "for the time set by <connectionTimeout> (in milliseconds).");
- // maxHopsToLive
- config.setExpert("maxHopsToLive", true);
- config.argDesc("maxHopsToLive", "<integer>");
- config.shortDesc("maxHopsToLive", "max HTL allowed on routed requests");
- config.longDesc(
- "maxHopsToLive",
- "When forwarding a request, the node will reduce the HTL to this value",
- "if it is found to be in excess.");
- // maxLog2DataSize
- config.setExpert("maxLog2DataSize", true);
- config.argDesc("maxLog2DataSize", "<integer>");
- config.shortDesc(
- "maxLog2DataSize",
- "maximum file data size (log to base 2)");
- config.longDesc(
- "maxLog2DataSize",
- "The logarithm to the base 2 of the maximum file data+metadata size ",
- "that the node will accept. 20 means 1 megabyte, which is reasonable.");
- // probIncHopsSinceReset
- config.setExpert("probIncHopsSinceReset", true);
- config.argDesc("probIncHopsSinceReset", "<number between 0 and 1>");
- config.shortDesc(
- "probIncHopsSinceReset",
- "Probability of incrementing hopsSinceReset when forwarding a request. Leave this alone.");
- // cacheProbPerHop
- config.setExpert("cacheProbPerHop", true);
- config.argDesc("cacheProbPerHop", "<number between 0 and 1>");
- config.longDesc(
- "cacheProbPerHop",
- "Number which is raised to the power of the number of hops since a datasource reset to determine the cache probability. Set lower for better routing, higher for more caching/redundancy. The default is equivalent to approximately 5 nodes caching a file in a request.");
- // minStoreFullPCache
- config.setExpert("minStoreFullPCache", true);
- config.argDesc("minStoreFullPCache", "<number between 0 and 1>");
- config.longDesc(
- "minStoreFullPCache",
- "Minimum proportion of the datastore that must be filled before probabilistic caching kicks in.");
- // minRTFullPRef
- config.setExpert("minRTFullPRef", true);
- config.argDesc("minRTFullPRef", "<number between 0 and 1>");
- config.longDesc(
- "minRTFullPRef",
- "Minimium proportion of the routing table (classic mode) that must be filled before probabilistic ",
- "referencing kicks in.");
- // minRTNodesPRef
- config.setExpert("minRTNodesPRef", true);
- config.argDesc("minRTNodesPRef", "<number between 0 and 1>");
- config.longDesc(
- "minRTNodesPRef",
- "Minimum proportion of the routing table nodes that must be filled and not backed off before ",
- "probabilistic referencing kicks in");
- // nodeFile
- config.setExpert("nodeFile", true);
- config.argDesc("nodeFile", "<file>");
- config.shortDesc("nodeFile", "location of node's key file");
- config.longDesc(
- "nodeFile",
- "The path to the file containing the node's private key, DSA group,",
- "cipher key, etc. Defaults to node in the current directory.");
- // storeFile
- config.setExpert("storeFile", true);
- config.argDesc("storeFile", "<file>[,..]");
- config.shortDesc(
- "storeFile",
- "location of data store directory - do not put anywhere with existing files");
- config.longDesc(
- "storeFile",
- "The path to the single directory containing the data "
- + "store. The total maximum size of the files in the "
- + "directory is given by <storeSize>. It will create new "
- + "files and directories in this dir, and DELETE OLD ONES. "
- + "Defaults to store in the current directory.");
- // storeSize
- config.argDesc(
- "storeSize",
- "<bytes - can use kKmMgGtTpPeE multipliers>");
- config.shortDesc("storeSize", "size of the data store file(s)");
- config.longDesc(
- "storeSize",
- "The byte size of the data store directory.",
- "The maximum sized file that will be cached is 1/100th of",
- "this value. We recommend the default 256MB, to cache the largest common",
- "file size on freenet, 1MB plus some headers, with plenty of elbowroom, but",
- "any size about 101MB should be adequate (a 1MB chunk is not exactly 1MB...).",
- "Note that if you increase settings such as maximumThreads, you may need to",
- "use a larger store.");
- // storeType
- config.setExpert("storeType", true);
- config.argDesc("storeType", "<string>");
- config.shortDesc(
- "storeType",
- "datastore implementation: \"native\" (new), \"monolithic\" (old, gets the DSB), \"freenet\" (autodetect, prefer native), or \"convert\" (convert old to new)");
- config.longDesc(
- "storeType",
- "Datastore implementation. Put \"native\" (without the quotes) if you want the new native filesystem datastore, which stores the files in a directory. Put \"convert\" to convert from an old monolithic store to a native store. Note that convert uses lots of disk space while doing the conversion (approximately twice the datastore size), and the resulting store may be (temporarily) slightly larger than the old one due to block size mismatch (this will be fixed as soon as the node tries to add a file to the store).");
- // storeBlockSize
- config.setExpert("storeBlockSize", true);
- config.argDesc("storeBlockSize", "<bytes>");
- config.shortDesc(
- "storeBlockSize",
- "Size of filesystem accounting blocks for storeType=native");
- config.longDesc(
- "storeBlockSize",
- "Size of blocks in the underlying filesystem for purposes of calculating space usage when storeType=native.");
- // storeMaxTempFraction
- config.setExpert("storeMaxTempFraction", true);
- config.argDesc("storeMaxTempFraction", "<number between 0 and 1>");
- config.shortDesc(
- "storeMaxTempFraction",
- "Maximum fraction of the datastore to use for temp files (assuming the temp dir is not overridden)");
- // storeCipherName
- config.setExpert("storeCipherName", true);
- config.argDesc("storeCipherName", "<string>");
- config.shortDesc(
- "storeCipherName",
- "name of symmetric cipher algorithm");
- config.longDesc("storeCipherName", "deprecated");
- // storeCipherWidth
- config.setExpert("storeCipherWidth", true);
- config.argDesc("storeCipherWidth", "<integer>");
- config.shortDesc("storeCipherWidth", "bit-width of cipher key");
- config.longDesc("storeCipherWidth", "deprecated");
- // routingDir
- config.setExpert("routingDir", true);
- config.argDesc("routingDir", "<directory>");
- config.shortDesc(
- "routingDir",
- "The directory in which to store the routing table files. Defaults to parent dir of storeDir");
- // useDSIndex
- config.setExpert("useDSIndex", true);
- config.argDesc("useDSIndex", "true|false");
- config.shortDesc("useDSIndex", "Use a datastore index file");
- config.longDesc(
- "useDSIndex",
- "Use a datastore index file. Shorter startup time, but we have to run checkpoints, which lock the datastore, causing a hiccup");
- // rtMaxRefs
- config.setExpert("rtMaxRefs", true);
- config.argDesc("rtMaxRefs", "<integer>");
- config.shortDesc("rtMaxRefs", "max no. of refs per node");
- config.longDesc(
- "rtMaxRefs",
- "The number of references allowed per node in the routing table.",
- "This should not be set too high.");
- // rtMaxNodes
- config.setExpert("rtMaxNodes", true);
- config.argDesc("rtMaxNodes", "<integer>");
- config.shortDesc("rtMaxNodes", "max no. unique nodes in routing table");
- config.longDesc(
- "rtMaxNodes",
- "The number of unique nodes that can be contained in the routing table. Note that the node will try to keep an idle connection open to each of these, so don't set it to more than half the value of maxNodeConnections. Too big or too small will result in inefficient or completely useless routing, or slow specialization; the default 50 is reasonable (if you see another default, it's because you have an OS with too few connections).");
- // doEstimatorSmoothing
- config.setExpert("doEstimatorSmoothing", true);
- config.argDesc("doEstimatorSmoothing", ARG_BOOLEAN);
- config.longDesc("doEstimatorSmoothing",
- "Whether to use adjacent buckets to estimate the value of a given bucket in a KeyspaceEstimator when it has no reports. "+
- "If you don't understand what I just said you should probably leave it alone!");
- // useFastEstimators
- config.setExpert("useFastEstimators", true);
- config.argDesc("useFastEstimators", ARG_BOOLEAN);
- config.longDesc("useFastEstimators",
- "Whether to use doubles (floating point, 53 bit mantissa, implemented in hardware on most systems) instead of BigIntegers (full 160 bits, slow) in NGRouting estimators.");
-
- // minCP
- config.setExpert("minCP", true);
- config.argDesc("minCP", "<number between 0 and 1>");
- config.shortDesc(
- "minCP",
- "Lower bound on Contact Probability of nodes in the Routing Table");
- // failuresLookupARK
- config.setExpert("failuresLookupARK", true);
- config.argDesc("failuresLookupARK", "<integer>");
- config.shortDesc(
- "failuresLookupARK",
- "Number of consecutive failures required to trigger an ARK lookup");
- // minARKDelay
- config.setExpert("minARKDelay", true);
- config.argDesc("minARKDelay", "<milliseconds>");
- config.shortDesc(
- "minARKDelay",
- "Minimum time that a node in the routing table must have been uncontactable for before we can trigger an ARK lookup");
- // maxARKThreadsFraction
- config.setExpert("maxARKThreadsFraction", true);
- config.argDesc("maxARKThreadsFraction", "<number between 0 and 1>");
- config.shortDesc(
- "maxARKThreadsFraction",
- "Maximum fraction of maximumThreads to use for ARK lookups");
- // maxRoutingSteps
- config.setExpert("maxRoutingSteps", true);
- config.argDesc("maxRoutingSteps", "<integer>");
- config.shortDesc(
- "maxRoutingSteps",
- "max no. node refs used per routing attempt.");
- config.longDesc(
- "maxRoutingSteps",
- "The maximum number or node refs that will be used to route a request before RNFing. ",
- "-1 means 1/10th the routing table size.");
- // messageStoreSize
- config.setExpert("messageStoreSize", true);
- config.argDesc("messageStoreSize", "<integer>");
- config.shortDesc(
- "messageStoreSize",
- "max no. of simultaneous requests.");
- config.longDesc(
- "messageStoreSize",
- "The number of outstanding message replies the node will",
- "wait for before it starts to abandon them.");
- // failureTableSize
- config.setExpert("failureTableSize", true);
- config.argDesc("failureTableSize", "<integer>");
- config.shortDesc("failureTableSize", "max. no. cached failed keys.");
- config.longDesc(
- "failureTableSize",
- "The number keys that failed to be retrieved the node should key track of.");
- //failureTableItems
- config.setExpert("failureTableItems", true);
- // failureTableTime
- config.setExpert("failureTableTime", true);
- config.argDesc("failureTableTime", "<milliseconds>");
- config.shortDesc("failureTableTime", "max. time to fail keys.");
- config.longDesc(
- "failureTableTime",
- "The amount of time to keep keys cache keys that could not be found and",
- "automatically fail requests for them.");
- // newNodePollInterval
- config.setExpert("newNodePollInterval", true);
- config.argDesc("newNodePollInterval", "<milliseconds>");
- config.shortDesc(
- "newNodePollInterval",
- "interval between polling new nodes");
- config.longDesc(
- "newNodePollInterval",
- "The node will send a request for a random "
- + "recently requested key to the node in the routing table with the fewest accesses, "
- + "every N milliseconds. Please enter N.");
- // bandwidthLimit
- config.setExpert("bandwidthLimit", true); // because deprecated
- config.argDesc("bandwidthLimit", "<bytes/sec>");
- config.shortDesc("bandwidthLimit", "DEPRECATED");
- config.setDeprecated("bandwidthLimit", true);
- config.longDesc(
- "bandwidthLimit",
- "The maximum number of bytes per second to transmit, totaled between",
- "incoming and outgoing connections. Ignored if either inputBandwidthLimit",
- "or outputBandwidthLimit is nonzero. DEPRECATED - please set inputBandwidthLimit and outputBandwidthLimit directly. Difficult to implement for NIO and not widely used.");
- // inputBandwidthLimit
- config.argDesc("inputBandwidthLimit", "<bytes/sec>");
- config.shortDesc("inputBandwidthLimit", "incoming bandwidth limit");
- config.longDesc(
- "inputBandwidthLimit",
- "If nonzero, specifies an independent limit for incoming data only, in bytes",
- "per second. A 512kbps broadband (DSL or cable) connection is 64kB/sec, but",
- "you may want to use other things than Freenet on it. However, Freenet's",
- "background usage should be close to the output limit most of the time. ",
- "You may want to set this and then set doLowLevelInputLimiting=false, in ",
- "order to have more accurate pending-transfers load. You SHOULD do this if ",
- "your connection has more outbound than inbound bandwidth.");
- // outputBandwidthLimit
- config.argDesc("outputBandwidthLimit", "<bytes/sec>");
- config.shortDesc(
- "outputBandwidthLimit",
- "if enabled, outgoing bandwidth limit");
- config.longDesc(
- "outputBandwidthLimit",
- "If nonzero, specifies an independent limit for outgoing data only, in bytes",
- "per second. Not entirely accurate. If you need exact limiting, do it at the",
- "OS level. A typical broadband connection has either a 128kbps or a 256kbps",
- "uplink, this equates to 16kB/sec and 32kB/sec respectively. You will need to",
- "keep some bandwidth back for other apps and for downloads (yes, downloading",
- "uses a small amount of upload bandwidth). We suggest therefore limits of",
- "12000 for a 128kbps upload connection, or 24000 for a 256kbps upload",
- "connection. Most broadband connections have far more download bandwidth than",
- "upload bandwidth... just because you have 1Mbps download, does not mean you",
- "have 1Mbps upload; if you do not know what your connection's upload speed is,",
- "use one of the above options.");
- // averageBandwidthLimit
- config.setExpert("averageBandwidthLimit", true);
- config.argDesc("averageBandwidthLimit", "<bytes/sec>");
- config.setDeprecated("averageBandwidthLimit", true);
- config.shortDesc("averageBandwidthLimit", "DEPRECATED");
- config.longDesc(
- "averageBandwidthLimit",
- "The maximum number of bytes per second to transmit (averaged over a week),",
- "totaled between incoming and outgoing connections. Error to define it if",
- "any of (average)inputBandwidthLimit or (average)outputBandwidthLimit is",
- "nonzero. DEPRECATED - please set inputBandwidthLimit and outputBandwidthLimit directly. Difficult to implement for NIO and not widely used.");
- // averageInputBandwidthLimit
- config.argDesc("averageInputBandwidthLimit", "<bytes/sec>");
- config.shortDesc(
- "averageInputBandwidthLimit",
- "incoming bandwidth limit averaged over a week");
- config.longDesc(
- "averageInputBandwidthLimit",
- "If nonzero, specifies an independent limit for incoming data only (averaged",
- "over a week). (overrides averageBandwidthLimit if nonzero)");
- // averageOutputBandwidthLimit
- config.argDesc("averageOutputBandwidthLimit", "<bytes/sec>");
- config.shortDesc(
- "averageOutputBandwidthLimit",
- "outgoing bandwidth limit averaged over a week");
- config.longDesc(
- "averageOutputBandwidthLimit",
- "If nonzero, specifies an independent limit for outgoing data only (averaged",
- "over a week). (overrides bandwidthLimit if nonzero)");
- // maxConnectionsPerMinute
- config.setExpert("maxConnectionsPerMinute", true);
- config.argDesc("maxConnectionsPerMinute", "<int>");
- config.shortDesc(
- "maxConnectionsPerMinute",
- "Max no. of connections in one minute.");
- config.longDesc(
- "maxConnectionsPerMinute",
- "The maximum number of outgoing connections established in a one minute period. "
- + "Deprecated and ignored.");
- // maxConnectionsMinute
- config.setExpert("maxConnectionsMinute", true);
- config.argDesc("maxConnectionsMinute", "<milliseconds>");
- config.shortDesc(
- "maxConnectionsMinute",
- "Length of a minute in milliseconds for purposes of maxConnectionsPerMinute");
- config.longDesc(
- "maxConnectionsMinute",
- "The length of the period over which there must be at most maxConnectionsPerMinute connections. Deprecated"
- + " and ignored.");
- // maxRequestsPerInterval
- config.setExpert("maxRequestsPerInterval", true);
- config.argDesc("maxRequestsPerInterval", "<int>");
- config.shortDesc(
- "maxRequestsPerInterval",
- "Max no. of outgoing requests per maxRequestsInterval.");
- config.longDesc(
- "maxRequestsPerInterval",
- "The maximum number of outgoing requests per maxRequestsInterval. -1 = disable.");
- // maxRequestsInterval
- config.setExpert("maxRequestsInterval", true);
- config.argDesc("maxRequestsInterval", "<milliseconds>");
- config.shortDesc(
- "maxRequestsInterval",
- "Length of the period in milliseconds for purposes of maxRequestsPerInterval");
- config.longDesc(
- "maxRequestsInterval",
- "The length of the period over which there must be at most maxRequestsPerInterval connections.");
- // maxNodeConnections
- config.setExpert("maxNodeConnections", true);
- config.argDesc("maxNodeConnections", "<positive integer>");
- config.shortDesc(
- "maxNodeConnections",
- "Max. no. of connections to other "
- + "nodes. Deprecated unless maximumThreads=0.");
- config.longDesc(
- "maxNodeConnections",
- "The maximum number of incoming and outgoing connections to "
- + "allow at the same time. Forced to 0.4*maximumThreads unless"
- + " maximumThreads = 0.");
- // maxOpenConnectionsNewbieFraction
- config.setExpert("maxOpenConnectionsNewbieFraction", true);
- config.argDesc ("maxOpenConnectionsNewbieFraction", "<number between 0.0 and 1.0>");
- config.shortDesc("maxOpenConnectionsNewbieFraction",
- "Proportion of open connections limit that may be newbie nodes before we start "+
- "rejecting new connections (unless there are free slots)");
-
- // maxNodeFilesOpen
- config.setExpert("maxNodeFilesOpen", true);
- config.argDesc("maxNodeFilesOpen", "<positive integer>");
- config.longDesc(
- "maxNodeFilesOpen",
- "Maximum number of file descriptors used by the node for files. Not including connections.");
- // maxNegotiations
- config.setExpert("maxNegotiations", true);
- config.argDesc ("maxNegotiations", "<positive integer>");
- config.shortDesc("maxNegotiations", "maximum number of simultaneous connection opens initiated by the node");
-
- // ipAddress
- config.setExpert("ipAddress", true);
- config.argDesc("ipAddress", "xxx.xxx.xxx.xxx");
- config.shortDesc(
- "ipAddress",
- "your IP as seen by the public internet (normally this is autoconfigured)");
- config.longDesc(
- "ipAddress",
- "The IP address of this node as seen by the "
- + "public Internet. You only need to override this "
- + "if it cannot be autodetected, for example if you "
- + "have a NAT (a.k.a. IP Masquerading) "
- + "firewall/router, in which case you will need "
- + "to set it to the IP address or DNS name of the "
- + "internet-side interface of the router, which "
- + "needs to be static (www.dyndns.org and similar "
- + "services can help here if you have a dynamic IP).");
- // listenPort
- config.argDesc("listenPort", "<port no.>");
- config.shortDesc("listenPort", "incoming FNP port");
- config.longDesc(
- "listenPort",
- "The port to listen for incoming FNP (Freenet Node Protocol) connections on.");
- // clientPort
- config.setExpert("clientPort", true);
- config.argDesc("clientPort", "<port no.>");
- config.shortDesc("clientPort", "incoming FCP port");
- config.longDesc(
- "clientPort",
- "The port to listen for local FCP (Freenet Client Protocol) connections on.");
- // fcpHosts
- config.setExpert("fcpHosts", true);
- config.argDesc("fcpHosts", "<host list>");
- config.shortDesc("fcpHosts", "hosts allowed to connect with FCP");
- config.longDesc(
- "fcpHosts",
- "A comma-separated list of hosts that may connect to the FCP port",
- "(clientPort). If left blank, only the localhost will be allowed."
- + " If you set this, make sure localhost is included in the list or "
- + " access won't be allowed from the local machine. ",
- "May be given as IP addresses or host names.");
- // logLevel
- config.argDesc("logLevel", "<word>");
- config.shortDesc("logLevel", "error, normal, minor, or debug");
- config.longDesc(
- "logLevel",
- "The error reporting threshold, one of:",
- " Error: Errors only",
- " Normal: Report significant events, and errors",
- " Minor: Report minor events, significant events, and errors",
- " Debug: Report everything that can be reported");
- // logLevelDetail
- config.setExpert("logLevelDetail", true);
- config.argDesc(
- "logLevelDetail",
- "<list of class name or package name = level e.g. freenet.node.rt:debug,freenet.support:minor>");
- config.shortDesc(
- "logLevelDetail",
- "Detailed list of parts of freenet we want different logging for");
- // logFile
- config.setExpert("logFile", true);
- config.argDesc("logFile", "<filename>|NO");
- config.shortDesc("logFile", "path to the log file, or NO for STDERR");
- config.longDesc(
- "logFile",
- "The name of the log file (`NO' to log to standard out)");
- // logFormat
- config.setExpert("logFormat", true);
- config.argDesc("logFormat", "<tmpl.>");
- config.shortDesc("logFormat", "template, like d:c:h:t:p:m");
- config.longDesc(
- "logFormat",
- "A template string for log messages. All non-alphabet characters are",
- "reproduced verbatim. Alphabet characters are substituted as follows:",
- "d = date (timestamp), c = class name of the source object,",
- "h = hashcode of the object, t = thread name, p = priority,",
- "m = the actual log message, u = name the local interface");
- // logDate
- config.setExpert("logDate", true);
- config.argDesc("logDate", "<tmpl.>");
- config.shortDesc("logDate", "java style date/time template");
- config.longDesc(
- "logDate",
- "A template for formatting the timestamp in log messages. Defaults to",
- "the locale specific fully specified date format. The template string",
- "is an ordinary Java date/time template - see:",
- "http://java.sun.com/products/jdk/1.1/docs/api/java.text.SimpleDateFormat.html");
- // logMaxLinesCached
- config.setExpert("logMaxLinesCached", true);
- config.argDesc("logMaxLinesCached", "<integer>");
- config.shortDesc(
- "logMaxLinesCached",
- "Maximum number of log lines to cache, anything above this will be discarded to prevent deadlocks and blocking");
- // logMaxBytes
- config.setExpert("logMaxBytesCached", true);
- config.argDesc(
- "logMaxBytesCached",
- "<bytes - can use kKmMgGg multipliers>");
- config.shortDesc(
- "logMaxBytesCached",
- "Maximum number of logged bytes to cache, anything above this will be discarded to prevent deadlocks and blocking");
- // logRotate
- config.setExpert("logRotate", true);
- config.argDesc("logRotate", "<true|false>");
- config.shortDesc(
- "logRotate",
- "Whether to rotate the log files. This is best done inside freenet because restarting Fred is slow and loses open connections.");
- // logRotateUseNativeGzip
- config.setExpert("logRotateUseNativeGzip", true);
- config.argDesc("logRotateUseNativeGzip", "<true|false>");
- config.shortDesc(
- "logRotateUseNativeGzip",
- "Whether to launch a native gzip to compress the old log files.");
- // logRotateInterval
- config.setExpert("logRotateInterval", true);
- config.argDesc("logRotateInterval", "<minute|hour|week|month|year>");
- config.shortDesc(
- "logRotateInterval",
- "Time interval for logfile rotation.");
- // logOverwrite
- config.setExpert("logOverwrite", true);
- config.argDesc("logOverwrite", "<yes|no>");
- config.shortDesc(
- "logOverwrite",
- "Whether to overwrite old log files; otherwise they are appended to.");
- // seedFile
- config.argDesc("seedFile", "<file>");
- config.shortDesc("seedFile", "initial node ref(s), for announcing");
- config.longDesc(
- "seedFile",
- "A file containing one or more node references which will be incorporated",
- "into the node's routing table on startup. A reference is only added if",
- "there is no previously existing reference to that node. When this node",
- "announces, it will announce to the nodes listed in this file.");
- // routingTableImpl
- config.setExpert("routingTableImpl", true);
- config.argDesc("routingTableImpl", "classic or ng");
- config.longDesc(
- "routingTableImpl",
- "Set to ng for the Next Generation Routing implementation, classic for the old Freenet routing algorithm.");
- // doAnnounce
- config.setExpert("doAnnounce", true);
- config.argDesc("doAnnounce", "yes|no");
- config.shortDesc("doAnnounce", "whether to automatically announce");
- config.longDesc(
- "doAnnounce",
- "If this is true, the node will automatically announce to all nodes in",
- "the <seedFile> file, as specified by <announcementDelay>, etc.");
- // announcementPeers
- config.setExpert("announcementHTL", true);
- config.argDesc("announcementHTL", "<integer>");
- config.shortDesc(
- "announcementHTL",
- "no. of nodes announcement goes to");
- config.longDesc(
- "announcementHTL",
- "The number of nodes that each announcement message should be"
- + "sent to.");
- // announcementAttempts
- config.setExpert("announcementAttempts", true);
- config.argDesc("announcementAttempts", "<integer>");
- config.shortDesc(
- "announcementAttempts",
- "number of attempts to announce");
- config.longDesc(
- "announcementAttempts",
- "The number of attempts to make at announcing this node "
- + "in any given attempt for any given node . Zero means "
- + "the node will not announce itself.");
- // announcementPollInterval
- config.setExpert("announcementPollInterval", true);
- config.argDesc("announcementPollInterval", "<milliseconds>");
- config.shortDesc(
- "announcementPollInterval",
- "Interval between polling for inactivity to reannounce");
- config.longDesc(
- "announcementPollInterval",
- "The time between polling for 1 hours no incoming requests to ",
- "force reannouncement.");
- // announcementFirstDelay
- config.setExpert("announcementFirstDelay", true);
- config.argDesc("announcementFirstDelay", "<milliseconds>");
- config.shortDesc(
- "announcementFirstDelay",
- "Delay before announcing on first startup");
- // announcementThreads
- config.setExpert("announcementThreads", true);
- config.argDesc("announcementThreads", "<integer>");
- config.shortDesc(
- "announcementThreads",
- "Number of simultaneous announcement attempts");
- config.longDesc(
- "announcementThreads",
- "The number of simultaneous announcement attempts; when a"
- + "permanent node sees no traffic for a while, or when it"
- + "initially joins the network, it will try to announce to "
- + "this many nodes.");
- // announcementUseRT
- config.setExpert("announcementUseRT", true);
- config.argDesc("announcementUseRT", "yes|no");
- config.shortDesc(
- "announcementUseRT",
- "announce to nodes from routing table?");
- config.longDesc(
- "announcementThreads",
- "If we run out of seed nodes, we can use other nodes from the"
- + "routing table to announce to. However, since the trust level"
- + "of these nodes is unknown, this is not recommended for the"
- + "truly paranoid.");
- // initialRequests
- config.setExpert("initialRequests", true);
- config.argDesc("initialRequests", "<integer>");
- config.shortDesc("initialRequests", "number of initial requests");
- config.longDesc(
- "initialRequests",
- "The number of keys to request from the returned close values",
- "after an Announcement (this is per announcement made).");
- // initialRequestHTL
- config.setExpert("initialRequestHTL", true);
- config.argDesc("initialRequestHTL", "<integer>");
- config.shortDesc("initialRequestHTL", "HopsToLive on initial requests");
- config.longDesc(
- "initialRequestHTL",
- "The hops that initial requests should make.");
- //doLoadBalance
- config.setExpert("doLoadBalance", true);
- config.argDesc("doLoadBalance", "yes|no");
- config.shortDesc("doLoadBalance", "Use load balancing.");
- config.longDesc(
- "doLoadBalance",
- "Whether to emply load balancing algorithms against the ",
- "network.");
- //localIsOK
- config.setExpert("localIsOK", true);
- config.argDesc("localIsOK", "yes|no");
- config.shortDesc(
- "localIsOK",
- "set yes to allow permanent nodes with non-internet-resolvable addresses. Do not use this except in a local testing network.");
- //dontLimitClients
- config.setExpert("dontLimitClients", true);
- config.argDesc("dontLimitClients", "yes|no");
- config.shortDesc(
- "dontLimitClients",
- "set yes to not bandwidth throttle connections to LocalInterfaces i.e. FCP and mainport");
- //limitAll
- config.setExpert("limitAll", true);
- config.argDesc("limitAll", "yes|no");
- config.shortDesc(
- "limitAll",
- "set yes to run the bandwidth limiter over all connections, local, network or internet. Overridden by dontLimitClients.");
- //mainportURIOverride
- config.setExpert("mainportURIOverride", true);
- config.argDesc("mainportURIOverride", "URI");
- config.shortDesc(
- "mainportURIOverride",
- "URI to mainport servlet, e.g. for SSL tunneling");
- //distributionURIOverride
- config.setExpert("distributionURIOverride", true);
- config.argDesc("distributionURIOverride", "URI");
- config.shortDesc(
- "distributionURIOverride",
- "URI to distribution servlet, e.g. for SSL tunneling");
- //aggressiveGC
- config.setExpert("aggressiveGC", true);
- config.argDesc("aggressiveGC", "<seconds>");
- config.shortDesc(
- "aggressiveGC",
- "How often (in seconds) to do aggressive garbage collection. May impact performance but should reduce working set. Set to 0 to disable.");
- //configUpdateInterval
- config.setExpert("configUpdateInterval", true);
- config.argDesc("configUpdateInterval", "<minutes>");
- config.shortDesc(
- "configUpdateInterval",
- "How often (in minutes) to check for config file changes. Set to 0 to disable.");
- // seednodesUpdateInterval
- config.setExpert("seednodesUpdateInterval", true);
- config.argDesc("seednodesUpdateInterval", "<minutes>");
- config.shortDesc(
- "seednodesUpdateInterval",
- "How often (in minutes) to check for seednodes file changes. Set to 0 to disable.");
- // adminPassword
- config.setExpert("adminPassword", true);
- config.argDesc("adminPassword", "<string>");
- config.shortDesc(
- "adminPassword",
- "allows remote admin using password.");
- config.longDesc(
- "adminPassword",
- "If this is set then users that can provide the password can",
- "can have administrative access. It is recommended that",
- "you do not use this without also using adminPeer below",
- "in which case both are required.");
- // adminPeer
- config.setExpert("adminPeer", true);
- config.argDesc("adminPeer", "<Identity FieldSet>");
- config.shortDesc("adminPeer", "allows remote admin using PKI");
- config.longDesc(
- "adminPeer",
- "If this is set, then users that are authenticated owners",
- "of the given PK identity can have administrative access.",
- "If adminPassword is also set both are required.");
- // ipDetectorInterval
- config.setExpert("ipDetectorInterval", true);
- config.argDesc("ipDetectorInterval", "time in seconds or 0");
- config.shortDesc(
- "ipDetectorInterval",
- "Frequency in seconds to run the IP detector. Set to 0 or less to disable.");
- //defaultToSimpleUIMode
- config.setExpert("defaultToSimpleUIMode", true);
- config.shortDesc(
- "defaultToSimpleUIMode",
- "Wheter the web interface should default to simple mode");
- config.longDesc(
- "defaultToSimpleUIMode",
- "The mainport and distribution servlets can display data in one out of two modes, Simple or Advanced. This parameter selects which of the two modes that should be the default mode.");
- //defaultToOCMHTMLPeerHandlerMode
- config.setExpert("defaultToOCMHTMLPeerHandlerMode", true);
- config.shortDesc(
- "defaultToOCMHTMLPeerHandlerMode",
- "Wheter the PeerHandler mode or the Connections mode should be the default mode int the OCM web interface");
- config.longDesc(
- "defaultToOCMHTMLPeerHandlerMode",
- "The OCM web page display data in one out of two modes, ConnectionsMode or PeerMode. This parameter selects which of the two modes that should be the default mode.");
- // diagnosticsPath
- config.setExpert("diagnosticsPath", true);
- config.argDesc("diagnosticsPath", "<dir>");
- config.shortDesc("diagnosticsPath", "directory to save statistics in");
- config.longDesc(
- "diagnosticsPath",
- "The directory in which to save diagnostics data. Defaults to",
- "<storePath>/stats if left blank.");
- /*
- * Class and port of the services are set as installation, because the
- * bad way that these are read requires them to be in the config. That
- * is dumb of course - a config file shouldn't even be necessary.
- * Hopefully I will fix that some day... -oskar
- */
- // NOTE: The default options for fproxy were moved into
- // addDefaultHTTPPortParams. 20020922. --gj.
- //
- // Options for NodeStatusServlet.
- //config.addOption("nodestatus.class", 1,
- // "freenet.client.http.NodeStatusServlet", 2040, true);
- //config.addOption("nodestatus.port", 1, 8889, 2041, true);
- // Options for distribution servlet
- config.addOption(
- "distribution.class",
- 1,
- "freenet.node.http.DistributionServlet",
- 2100);
- config.addOption("distribution.port", 1, 8891, 2101);
- config.addOption("distribution.params.unpacked", 1, ".", 2102);
- config.addOption("distribution.params.distribDir", 1, "", 2105);
- config.addOption("distribution.params.generatorAllowedHosts", 1, "localhost", 2104);
- config.addOption("distribution.allowedHosts", 1, "*", 2103);
- // Turn on fproxy, nodeinfo and NodeStatusServlet by default.
- // mainport is a MultipleHttpServletContainer instance which
- // runs fproxy and nodeinfo on the same port.
- config.addOption("services", 1, "mainport, distribution", 2011);
- config.addOption(
- "mainport.params.servlet.10.uri",
- 1,
- "/servlet/bookmarkmanager",
- 7000);
- config.addOption("mainport.params.servlet.10.method", 1, "GET", 7001);
- config.addOption(
- "mainport.params.servlet.10.class",
- 1,
- "freenet.node.http.BookmarkManagerServlet",
- 7002);
- config.addOption(
- "mainport.params.servlet.10.name",
- 1,
- "Bookmark Manager Servlet",
- 7003);
- config.setExpert("mainport.params.servlet.10.uri", true);
- config.setExpert("mainport.params.servlet.10.method", true);
- config.setExpert("mainport.params.servlet.10.class", true);
- config.setExpert("mainport.params.servlet.10.name", true);
- config.addOption(
- "mainport.params.servlet.11.uri",
- 1,
- "/servlet/coloredpixel",
- 7000);
- config.addOption("mainport.params.servlet.11.method", 1, "GET", 7001);
- config.addOption(
- "mainport.params.servlet.11.class",
- 1,
- "freenet.node.http.ColoredPixelServlet",
- 7002);
- config.addOption(
- "mainport.params.servlet.11.name",
- 1,
- "Colored Pixel Servlet",
- 7003);
- config.setExpert("mainport.params.servlet.11.uri", true);
- config.setExpert("mainport.params.servlet.11.method", true);
- config.setExpert("mainport.params.servlet.11.class", true);
- config.setExpert("mainport.params.servlet.11.name", true);
- // NodeStatusServlet class
- /*
- * config.setExpert ("nodestatus.class", true); config.argDesc
- * ("nodestatus.class", " <class name> "); config.shortDesc
- * ("nodestatus.class", "NodeStatusServlet class"); config.longDesc
- * ("nodestatus.class", "The Java class for the NodeStatusServlet. You
- * shouldn't need to change this."
- */
- // NodeStatusServlet port
- /*
- * config.setExpert ("nodestatus.port", true); config.argDesc
- * ("nodestatus.port", " <port number> "); config.shortDesc
- * ("nodestatus.port", "NodeStatusServlet listen port");
- * config.longDesc ("nodestatus.port", "The port that the node status
- * servlet listens for HTTP requests on."
- */
- config.setExpert("services", true);
- config.argDesc("services", "service_0,service_1,...");
- config.shortDesc("services", "services run at start up");
- config.longDesc(
- "services",
- "A comma delimited list of services that are run when the node starts. "
- + "If you don't know what this means, just accept the defaults.");
- // DistributionServlet class
- config.setExpert("distribution.class", true);
- config.argDesc("distribution.class", "<class name>");
- config.shortDesc("distribution.class", "Distribution servlet class");
- config.longDesc(
- "distribution.class",
- "The Java class of the distribution servlet. You shouldn't need to touch this.");
- config.setExpert("distribution.port", true);
- config.argDesc("distribution.port", "<port number>");
- config.shortDesc(
- "distribution.port",
- "DistributionServlet listen port");
- config.longDesc(
- "distribution.port",
- "The port that the distribution servlet listens for HTTP requests on.");
- // distribution.params
- config.setExpert("distribution.params.unpacked", true);
- config.argDesc("distribution.params.unpacked", "<directory>");
- config.shortDesc(
- "distribution.params.unpacked",
- "Dir where freenet was unpacked");
- config.longDesc(
- "distribution.params.unpacked",
- "A directory containing (some of) the files needed for the Distribution Servlet - for example, a CVS tree, or where the UNIX tarball was unpacked.");
- // distribution.params.distribDir
- config.setExpert("distribution.params.distribDir", true);
- config.argDesc("distribution.params.distribDir", "<directory>");
- config.shortDesc(
- "distribution.params.distribDir",
- "Dir to store redistributibles for the Distribution Servlet");
- config.longDesc(
- "distribution.params.distribDir",
- "Directory used by the node to store redistributibles for the Distribution Servlet - there is rarely any need to override this.");
- // distribution.allowedHosts - whole internet by default
- config.setExpert("distribution.allowedHosts", true);
- config.argDesc("distribution.allowedHosts", "<list of IP addresses>");
- config.shortDesc(
- "distribution.allowedHosts",
- "List of addresses that will be allowed to access distribution pages from the DistributionServlet");
- config.longDesc(
- "distribution.allowedHosts",
- "These IP addresses will be allowed to access the distribution pages generated by the DistributionServlet. Default * means everyone.");
- // distribution.generatorAllowedHosts - localhost only by default
- config.setExpert("distribution.params.generatorAllowedHosts", true);
- config.argDesc("distribution.params.generatorAllowedHosts", "<list of IP addresses>");
- config.shortDesc("distribution.params.generatorAllowedHosts", "Lists of addresses that will be allowed to generate new distribution pages.");
- config.longDesc("distribution.params.generatorAllowedHosts", "Lists of addresses that will be allowed to generate new distribution pages. Default is localhost only.");
- config.setExpert("logOutputBytes", true);
- config.argDesc("logOutputBytes", "true/false");
- config.shortDesc(
- "logOutputBytes",
- "Set true to count non-local TCP bytes sent for diagnostics."
- + " Also used for medium range bandwidth limiting."
- + " Since we for performance reasons don't limit messages"
- + " and connection negotiation, we need to have some other"
- + " way to keep bandwidth under control. This is it. We"
- + " reject all queries if the previous minute's total was"
- + " more than 50% over the limit.");
- config.setExpert("logInputBytes", true);
- config.argDesc ("logInputBytes", "true/false");
- config.shortDesc("logInputBytes", "Set true to count non-local TCP bytes "
- + "received for diagnostics. Also used for part of rate limiting.");
-
- config.setExpert("watchme", true);
- config.argDesc("watchme", "true/false");
- config.shortDesc(
- "watchme",
- "Debugging only, setting this to true will remove your anonymity!");
- config.setExpert("watchmeRetries", true);
- config.argDesc("watchmeRetries", "<integer>");
- config.shortDesc(
- "watchmeRetries",
- "Number of times watchMe will attempt to initialize");
- // FEC options
- config.setExpert("FECTempDir", true); // unnecessary
- config.argDesc("FECTempDir", "<directory>");
- config.shortDesc(
- "FECTempDir",
- "Dir. used for FEC temp files. You don't need to set this.");
- config.setExpert("FEC.Encoders.0.class", true);
- config.argDesc("FEC.Encoders.0.class", "<class name>");
- config.shortDesc(
- "FEC.Encoders.0.class",
- "Default FEC encoder implementation.");
- config.setExpert("FEC.Decoders.0.class", true);
- config.argDesc("FEC.Decoders.0.class", "<class name>");
- config.shortDesc(
- "FEC.Decoders.0.class",
- "Default FEC decoder implementation.");
- // tempDir
- config.setExpert("tempDir", true);
- config.argDesc("tempDir", "<directory>");
- config.shortDesc(
- "tempDir",
- "Dir used for temporary files, currently for fproxy");
- config.longDesc(
- "tempDir",
- "The directory used for temporary files. Used currently by fproxy and the FCP FEC mechanism, if their individual temp dirs are not set. If this is left unset, it will create a tempdir in the datastore (if the datastore is native).");
- // tempInStore
- config.setExpert("tempInStore", true);
- config.argDesc("tempInStore", "true/false");
- config.shortDesc(
- "tempInStore",
- "Does temp space count as part of the datastore?");
- config.longDesc(
- "tempInStore",
- "If true, temp space counts as part of the datastore for space accounting purposes. This means that freenet will never use significantly more disk space than the configured storeSize (ignoring space used for log files and routing table files), but it also means that if you have a small store you may not be able to download large files.");
- // doRequestTriageByDelay
- config.setExpert("doRequestTriageByDelay", true);
- config.argDesc("doRequestTriageByDelay", "true/false");
- config.shortDesc(
- "doRequestTriageByDelay",
- "triage requests if tickerDelay gets too high");
- config.longDesc(
- "doRequestTriageByDelay",
- "If true, above 2000ms "
- + "tickerDelay (successfulDelayCutoff) all incoming requests "
- + "will be rejected, and above 1000ms, nearly all incoming "
- + "requests will be rejected. This is an attempt to prevent "
- + "the node from totally overwhelming the hardware it runs "
- + "on, and slowing down the network in the process.");
- config.setExpert("doRequestTriageBySendTime", true);
- config.argDesc("doRequestTriageBySendTime", "true/false");
- config.shortDesc(
- "doRequestTriageBySendTime",
- "Triage requests if messageSendTimeRequest > requestSendTimeCutoff");
- config.longDesc(
- "doRequestTriageBySendTime",
- "If true, when messageSendTimeRequest goes above requestSendTimeCutoff, nearly all incoming requests will be rejected. messageSendTime correlates with CPU and bandwidth usage, and if it is too high your node will not do any useful work anyway because the messages will time out.");
- // overloadLow
- config.setExpert("overloadLow", true);
- config.argDesc("overloadLow", "<float between 0 and 1>");
- config.shortDesc(
- "overloadLow",
- "start to selectively reject requests at this load");
- config.longDesc(
- "overloadLow",
- "The node will start to selectively reject requests above this load level.");
- // overloadHigh
- config.setExpert("overloadHigh", true);
- config.argDesc("overloadHigh", "<float between 0 and infinity>");
- config.shortDesc("overloadHigh", "reject all requests above this load");
- config.longDesc(
- "overloadHigh",
- "The node will reject all QueryRequests above this load level. "+
- "Should be over 1.0, because rate limiting will try to keep the load near 100%.");
- // requestDelayCutoff
- config.setExpert("requestDelayCutoff", true);
- config.argDesc("requestDelayCutoff", "<milliseconds>");
- config.shortDesc(
- "requestDelayCutoff",
- "reject queries above this routingTime");
- config.longDesc(
- "requestDelayCutoff",
- "The node will reject nearly all incoming queries when routingTime is over this value.");
- // successfulDelayCutoff
- config.setExpert("successfulDelayCutoff", true);
- config.argDesc("successfulDelayCutoff", "<milliseconds>");
- config.shortDesc(
- "successfulDelayCutoff",
- "if enabled, reject ALL connections when routingTime > cutoff");
- config.longDesc(
- "successfulDelayCutoff",
- "If doRequestTriageByDelay is true, the node will reject ALL connections when routingTime > successfulDelayCutoff.");
- // requestSendTimeCutoff
- config.setExpert("requestSendTimeCutoff", true);
- config.argDesc("requestSendTimeCutoff", "<milliseconds>");
- config.shortDesc(
- "requestSendTimeCutoff",
- "if enabled, reject queries when messageSendTimeRequest > cutoff");
- config.longDesc(
- "requestSendTimeCutoff",
- "If doRequestTriageBySendTime is true, the node will reject queries when messageSendTimeRequest > requestSendTimeCutoff.");
- // successfulSendTimeCutoff
- config.setExpert("successfulSendTimeCutoff", true);
- config.argDesc("successfulSendTimeCutoff", "<integer, per minute>");
- config.shortDesc(
- "successfulSendTimeCutoff",
- "if enabled, reject ALL connections if messageSendTimeRequest > cutoff");
- config.longDesc(
- "successfulSendTimeCutoff",
- "If doRequestTriageBySendTime is true, the node will reject ALL connections if messageSendTimeRequest > successfulSendTimeCutoff");
- // doOutLimitCutoff
- config.setExpert("doOutLimitCutoff", true);
- config.argDesc("doOutLimitCutoff", "<true|false>");
- config.shortDesc(
- "doOutLimitCutoff",
- "enable use of outLimitCutoff value");
- config.longDesc(
- "doOutLimitCutoff",
- "If true, the node will refuse incoming requests according to outLimitCutoff.");
- // outLimitCutoff
- config.setExpert("outLimitCutoff", true);
- config.argDesc("outLimitCutoff", "<floatint point number over 0>");
- config.shortDesc(
- "outLimitCutoff",
- "if enabled, reject queries when outbound bandwidth exceeds outLimitCutoff*outputBandwidthLimit");
- config.longDesc(
- "outLimitCutoff",
- "If the previous minute's outbound transfer limit was exceeded by this factor or more, the node will reject incoming requests.");
- // doOutLimitConnectCutoff
- config.setExpert("doOutLimitConnectCutoff", true);
- config.argDesc("doOutLimitConnectCutoff", "<true|false>");
- config.longDesc(
- "doOutLimitConnectCutoff",
- "Whether to refuse incoming conections when the node's outbound bandwidth limit is exceeded by the factor specified by outLimitConnectCutoff.");
- // outLimitConnectCutoff
- config.setExpert("outLimitConnectCutoff", true);
- config.argDesc(
- "outLimitConnectCutoff",
- "<floating point number over 0>");
- config.longDesc(
- "outLimitConnectCutoff",
- "If the previous minute's outbound transfer limit was exceeded by this factor or more, the node will reject incoming connections.");
- // threadConnectCutoff
- config.setExpert("threadConnectCutoff", true);
- config.argDesc ("threadConnectCutoff",
- "<floating point number over 0>");
- config.shortDesc ("threadConnectCutoff",
- "Fraction of thread limit over which to reject all incoming connections");
-
- // lowLevelBWLimitFudgeFactor
- config.setExpert("lowLevelBWLimitFudgeFactor", true);
- config.argDesc(
- "lowLevelBWLimitFudgeFactor",
- "<floating point number over 0>");
- config.longDesc(
- "lowLevelBWLimitFudgeFactor",
- "The low level bandwidth limiter is not entirely accurate. It has however been found that it can be made more accurate by multiplying the limit by a fudge factor of around 70%. This may vary from system to system so is a config option. Probably not useful with the new outLimitCutoff option... Leave it alone unless you know what you are doing. Distinct from lowLevelBWLimitMultiplier so that we can change the default even if the latter has been overridden.");
- // doReserveOutputBandwidthForSuccess
- config.setExpert("doReserveOutputBandwidthForSuccess", true);
- config.argDesc("doReserveOutputBandwidthForSuccess", "<true|false>");
- config.longDesc("doReserveOutputBandwidthForSuccess",
- "If set to true, adjust the high level bandwidth limiting to "+
- "underuse our available bandwidth according to the ratio of "+
- "the actual probability of success to the best reasonable "+
- "probability of success (estimated from the nodes in the RT). "+
- "The idea here is that if you limit the number of requests "+
- "this way, then on average the network won't accept too much "+
- "work and end up backing off all over the place. This WILL "+
- "reduce your upstream bandwidth usage, so if you don't like "+
- "that, don't set it.");
-
- // lowLevelBWLimitMultiplier
- config.setExpert("lowLevelBWLimitMultiplier", true);
- config.argDesc(
- "lowLevelBWLimitMultiplier",
- "<floating point number over 0>");
- config.longDesc(
- "lowLevelBWLimitMultiplier",
- "Freenet has 2 separate bandwidth limiting mechanisms. The low level bandwidth limiter is more accurate, but can cause bad things to happeen and is quite expensive in terms of CPU time, and works by delaying messages, which may not be desirable. So by default limiting is done mainly by the high level limiter (see outLimitCutoff and outLimitConnectCutoff), and the low level limiter is set to a higher value to ensure that the node's usage does not get completely out of control when something unusual happens. Set the factor to multiply the bandwidth limits by before feeding them to the low level limiter here.");
- // doLowLevelOutputLimiting
- config.setExpert("doLowLevelOutputLimiting", true);
- // doLowLevelInputLimiting
- config.setExpert("doLowLevelInputLimiting", true);
- // doCPULoad
- config.setExpert ("doCPULoad", true);
- config.argDesc ("doCPULoad", "<true|false>");
- config.longDesc ("doCPULoad", "Whether to try to use the actual CPU"
- +"usage percentage in the load estimate calculation.");
- // sendingQueueLength
- config.setExpert("sendingQueueLength", true);
- config.argDesc("sendingQueueLength", "<positive integer>");
- config.longDesc(
- "sendingQueueLength",
- "Maximum number of messages queued on a connection before we force opening of a new connection. Note that a value too low will cause lots of connections to be opened; this takes time and bandwidth. Note also that messages are not necessarily sent one at a time; over 10 messages (approximately) can sometimes be packed into a single packet.");
- // sendingQueueBytes
- config.setExpert("sendingQueueBytes", true);
- config.argDesc("sendingQueueBytes", "<bytes>");
- config.longDesc(
- "sendingQueueBytes",
- "Maximum number of bytes queued on a connection before we force opening of a new connection. Note that a value too low will cause lots of connections to be opened; this takes time and bandwidth. Note also that messages are not necessarily sent one at a time; over 10 messages (approximately) can sometimes be packed into a single packet.");
- // requestIntervalDefault
- config.setDeprecated("requestIntervalDefault", true);
- // requestIntervalQRFactor
- config.setDeprecated("requestIntervalQRFactor", true);
- // defaultResetProbability
- config.setExpert("defaultResetProbability", true);
- config.argDesc("defaultResetProbability", "<probability>");
- config.shortDesc(
- "defaultResetProbability",
- "Default probability of resetting the DataSource");
- config.longDesc(
- "defaultResetProbability",
- "The node will have this probability, on average (it varies according to load unless you set doLoadBalance=no), of resetting the datasource. Increase this to get more load, reduce it to get less load.");
- // lsMaxTableSize
- config.setExpert("lsMaxTableSize", true);
- config.argDesc("lsMaxTableSize", "<positive integer>");
- config.shortDesc(
- "lsMaxTableSize",
- "Maximum number of peers to save queries/hour from");
- config.longDesc(
- "lsMaxTableSize",
- "LoadStats: Global queries/hour is calculated from at most this number of peers.");
- // lsAcceptRatioSamples
- config.setExpert("lsAcceptRatioSamples", true);
- config.argDesc("lsAcceptRatioSamples", "<positive integer>");
- config.shortDesc(
- "lsAcceptRatioSamples",
- "Number of query arrival time and accepted/rejected status entries.");
- config.longDesc(
- "lsAcceptRatioSamples",
- "LoadStats: Current proportion of requests being accepted is calculated from the fate of this number of recent requests. The local queries/hour is calculated from the time it took for this number of queries to arrive, averaged at least every time this number of queries is received.");
- // lsHalfLifeHours
- config.setExpert("lsHalfLifeHours", true);
- config.argDesc("lsHalfLifeHours", "<positive real>");
- config.shortDesc(
- "lsHalfLifeHours",
- "Half life in hours of the queries per hour decaying average.");
- config.longDesc(
- "lsHalfLifeHours",
- "Half life in hours of the queries per hour decaying average. Small values permit the value to change rapidly; large values force it to change slowly. Use zero to get prior behavior.");
- // logOutboundContacts
- config.setExpert("logOutboundContacts", true);
- config.argDesc("logOutboundContacts", "true/false");
- config.shortDesc(
- "logOutboundContacts",
- "Set true to enable outbound contact monitoring.");
- // logInboundContacts
- config.setExpert("logInboundContacts", true);
- config.argDesc("logInboundContacts", "true/false");
- config.shortDesc(
- "logInboundContacts",
- "Set true to enable inbound contact monitoring.");
- // logInboundRequests
- config.setExpert("logInboundRequests", true);
- config.argDesc("logInboundRequests", "true/false");
- config.shortDesc(
- "logInboundRequests",
- "Set true to enable per host inbound request monitoring.");
- // logOutboundRequests
- config.setExpert("logOutboundRequests", true);
- config.argDesc("logOutboundRequests", "true/false");
- config.shortDesc(
- "logOutboundRequests",
- "Set true to enable per host outbound request monitoring.");
- // logInboundInsertRequestDist
- config.setExpert("logInboundInsertRequestDist", true);
- config.argDesc("logInboundInsertRequestDist", "true/false");
- config.shortDesc(
- "logInboundInsertRequestDist",
- "Set true to enable logging of inbound InsertRequest key distribution.");
- // logSuccessfulInsertRequestDist
- config.setExpert("logSuccessfulInsertRequestDist", true);
- config.argDesc("logSuccessfulInsertRequestDist", "true/false");
- config.shortDesc(
- "logSuccessfulInsertRequestDist",
- "Set true to enable logging of successful inbound InsertRequests' key distribution.");
- // FECInstanceCacheSize
- config.setExpert("FECInstanceCacheSize", true);
- config.argDesc("FECInstanceCacheSize", "<integer>");
- config.shortDesc(
- "FECInstanceCacheSize",
- "Number of FEC instances to cache. Set to 1 unless you expect more than one simultaneous FEC operation.");
- // FECMaxConcurrentCodecs
- config.setExpert("FECMaxConcurrentCodecs", true);
- config.argDesc("FECMaxConcurrentCodecs", "<integer>");
- config.shortDesc(
- "FECMaxConcurrentCodecs",
- "Number of concurrent FEC encodes/decodes allowed. "
- + "Each codec can use up to 24Mb of memory.");
- // publicNode
- config.setExpert("publicNode", true);
- config.argDesc("publicNode", "true/false");
- config.shortDesc(
- "publicNode",
- "Disables anonymity threatening servlets and infolets on a multi-user machine");
- // httpInserts
- config.setExpert("httpInserts", true);
- config.argDesc("httpInserts", "true/false");
- config.shortDesc(
- "httpInserts",
- "Set false to disable inserts through FProxy.");
- // fcpInserts
- config.setExpert("fcpInserts", true);
- config.argDesc("fcpInserts", "true/false");
- config.shortDesc("fcpInserts", "Set false to disable FCP insertion.");
- // UITemplateSet
- config.setExpert("UITemplateSet", true);
- config.argDesc("UITemplateSet", "name of a template set");
- config.longDesc(
- "UITemplateSet",
- "Template set to use for user interface over HTTP. Default is aqua. Change it if you want to use another one - currently there is just one extra set (simple), but they can be added to src/freenet/node/http/templates/ easily enough");
- // filterPassThroughMimeTypes
- config.setExpert("filterPassThroughMimeTypes", true /* ? */
- );
- config.argDesc(
- "filterPassThroughMimeTypes",
- "comma delimited list of MIME types");
- config.shortDesc(
- "filterPassThroughMimeTypes",
- "safe MIME types that will be passed through to the browser without query or filtering");
- // mainport.class
- config.setExpert("mainport.class", true);
- config.argDesc("mainport.class", "interface class");
- config.shortDesc(
- "mainport.class",
- "Name of the interface class to run the mainport service. Leave it alone.");
- config.longDesc(
- "mainport.class",
- "Name of the interface class to run the mainport service. You do not need to change this.");
- // mainport.port
- config.setExpert("mainport.port", true);
- config.argDesc("mainport.port", "port number");
- config.shortDesc(
- "mainport.port",
- "Port to run the main Freenet HTTP interface on");
- config.longDesc(
- "mainport.port",
- "Port to run the main Freenet HTTP interface on... this is the port that is accessed by your web browser when you are browsing freenet via fproxy, or looking at the various status monitors. This is normally only accessible from localhost, and is different from the public FNP port that other freenet nodes talk to, the FCP port that client programs talk to, and the distribution port that you can run a freenet distribution website on.");
- // mainport.allowedHosts
- config.setExpert("mainport.allowedHosts", true);
- config.argDesc(
- "mainport.allowedHosts",
- "Comma delimited list of IP addresses, netmasks or hostnames");
- config.shortDesc(
- "mainport.allowedHosts",
- "hosts allowed to access main freenet web interface");
- config.longDesc(
- "mainport.allowedHosts",
- "List of IP addresses (for example \"192.168.1.7\"), DNS names (\"erica\" or \"www.nsa.gov\") or netmasks (\"192.168.1.0/24\") of hosts (computers) that should be allowed to access the main web interface of your freenet node. Defaults to localhost (127.0.0.0/8) only.");
- // mainport.bindAddress
- config.setExpert("mainport.bindAddress", true);
- config.argDesc("mainport.bindAddress", "IP address or \"*\"");
- config.shortDesc(
- "mainport.bindAddress",
- "IP address for main freenet web interface to listen on or \"*\"");
- config.longDesc(
- "mainport.bindAddress",
- "IP address of one interface for the main freenet web interface to listen on, or \"*\" to listen on all interfaces. Will be automatically determined from mainport.allowedHosts if not given; leave it alone.");
- // mainport.params.servlet.1.uri
- config.setExpert("mainport.params.servlet.1.uri", true);
- config.argDesc("mainport.params.servlet.1.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.1.uri",
- "Path within mainport for fproxy. Leave this alone");
- // mainport.params.servlet.1.method
- config.setExpert("mainport.params.servlet.1.method", true);
- config.argDesc("mainport.params.servlet.1.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.1.method",
- "HTTP method for fproxy. Leave this alone.");
- // mainport.params.servlet.1.class
- config.setExpert("mainport.params.servlet.1.class", true);
- config.argDesc("mainport.params.servlet.1.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.1.class",
- "servlet class to run fproxy. Leave this alone.");
- // mainport.params.servlet.1.name
- config.setExpert("mainport.params.servlet.1.name", true);
- config.argDesc("mainport.params.servlet.1.name", "string");
- config.shortDesc(
- "mainport.params.servlet.1.name",
- "name of first servlet on mainport (normally fproxy - \"Freenet HTTP proxy (fproxy)\"). Leave this alone.)");
- // mainport.params.servlet.1.params.requestHtl
- config.setExpert("mainport.params.servlet.1.params.requestHtl", true);
- config.argDesc(
- "mainport.params.servlet.1.params.requestHtl",
- "integer HTL value between 0 and maxHopsToLive");
- config.shortDesc(
- "mainport.params.servlet.1.params.requestHtl",
- "hops to live of fproxy requests");
- config.longDesc(
- "mainport.params.servlet.1.params.requestHtl",
- "hops to live (HTL) of requests made by fproxy");
- // mainport.params.servlet.1.params.passThroughMimeTypes
- config.setExpert(
- "mainport.params.servlet.1.params.passThroughMimeTypes",
- true);
- config.argDesc(
- "mainport.params.servlet.1.params.passThroughMimeTypes",
- "comma delimited list of MIME types");
- config.shortDesc(
- "mainport.params.servlet.1.params.passThroughMimeTypes",
- "safe MIME types, defaults to filterPassThroughMimeTypes");
- config.longDesc(
- "mainport.params.servlet.1.params.passThroughMimeTypes",
- "MIME types regarded as safe that are passed to the browser without filtering or warning in fproxy. The default is empty (\"\"), which means to use the node global default filterPassThroughMimeTypes");
- // mainport.params.servlet.1.params.filter
- config.setExpert("mainport.params.servlet.1.params.filter", true);
- config.argDesc("mainport.params.servlet.1.params.filter", "true|false");
- config.shortDesc(
- "mainport.params.servlet.1.params.filter",
- "run the anonymity filter on HTML/CSS");
- config.longDesc(
- "mainport.params.servlet.1.params.filter",
- "Whether to run the anonymity filter to remove HTML and CSS tags that might cause your browser to damage your anonymity");
- // mainport.params.servlet.1.params.filterParanoidStringCheck
- config.setExpert(
- "mainport.params.servlet.1.params.filterParanoidStringCheck",
- true);
- config.argDesc(
- "mainport.params.servlet.1.params.filterParanoidStringCheck",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.1.params.filterParanoidStringCheck",
- "whether to make the anonymity filter really paranoid");
- config.longDesc(
- "mainport.params.servlet.1.params.filterParanoidStringCheck",
- "whether to make the anonymity filter really paranoid; currently this causes strings in CSS to be removed if they contain colons (\":\")");
- // mainport.params.servlet.1.params.maxForceKeys
- config.setExpert("mainport.params.servlet.1.params.maxForceKeys", true);
- config.argDesc(
- "mainport.params.servlet.1.params.maxForceKeys",
- "integer");
- config.shortDesc(
- "mainport.params.servlet.1.params.maxForceKeys",
- "Number of ?force= keys for fproxy to track");
- config.longDesc(
- "mainport.params.servlet.1.params.maxForceKeys",
- "Number of key overrides Fproxy should track... these are the confirmation pages you get when you go to some file that fproxy doesn't know how to handle");
- // mainport.params.servlet.1.params.doSendRobots
- config.setExpert("mainport.params.servlet.1.params.doSendRobots", true);
- config.argDesc(
- "mainport.params.servlet.1.params.doSendRobots",
- "yes|no");
- config.shortDesc(
- "mainport.params.servlet.1.params.doSendRobots",
- "Whether to send /robots.txt to the browser");
- // mainport.params.servlet.1.params.noCache
- config.setExpert("mainport.params.servlet.1.params.noCache", true);
- config.argDesc("mainport.params.servlet.1.params.noCache", "yes|no");
- config.shortDesc(
- "mainport.params.servlet.1.params.noCache",
- "Whether to tell the browser not to cache Freenet content");
- // mainport.params.servlet.1.params.dontWarnOperaUsers
- config.setExpert("mainport.params.servlet.1.params.dontWarnOperaUsers", true);
- config.argDesc ("mainport.params.servlet.1.params.dontWarnOperaUsers", "yes|no");
- config.shortDesc("mainport.params.servlet.1.params.dontWarnOperaUsers",
- "Set true to not warn Opera users about MIME types. READ LONG DESCRIPTION.");
- config.longDesc ("mainport.params.servlet.1.params.dontWarnOperaUsers",
- "Opera and IE suffer from a design flaw that prevent FProxy from protecting ",
- "your anonymity properly. In Opera, it can be turned off. If you are sure you ",
- "have done so (read the warning page for instructions), enable this option to ",
- "eliminate the warning page.");
-
- // mainport.params.servlet.2.uri
- config.setExpert("mainport.params.servlet.2.uri", true);
- config.argDesc("mainport.params.servlet.2.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.2.uri",
- "Path within mainport for the Node Info Servlet");
- config.longDesc(
- "mainport.params.servlet.2.uri",
- "Path within mainport for the Node Info Servlet - this contains infolets which present pages of information about the node as well as the default front page");
- // mainport.params.servlet.2.method
- config.setExpert("mainport.params.servlet.2.method", true);
- config.argDesc("mainport.params.servlet.2.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.2.method",
- "HTTP method for Node Info Servlet. Leave this alone.");
- // mainport.params.servlet.2.class
- config.setExpert("mainport.params.servlet.2.class", true);
- config.argDesc("mainport.params.servlet.2.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.2.class",
- "servlet class to run Node Info Servlet. Leave this alone");
- // mainport.params.servlet.2.name
- config.setExpert("mainport.params.servlet.2.name", true);
- config.argDesc("mainport.params.servlet.2.name", "string");
- config.shortDesc(
- "mainport.params.servlet.2.name",
- "name of (usually) Node Info Servlet. Leave this alone.");
- // default bookmarks
- config.setExpert("mainport.params.servlet.2.bookmarks.count", true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.count",
- "Number of bookmarks on fproxy");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.count",
- "Number of bookmarks on fproxy, or -1 to include all specified ones");
- config.setExpert("mainport.params.servlet.2.bookmarks.0.key", true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.0.key",
- "freenet key");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.0.key",
- "The first bookmark for the web proxy");
- config.setExpert("mainport.params.servlet.2.bookmarks.0.title", true);
- config.argDesc("mainport.params.servlet.2.bookmarks.0.title", "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.0.title",
- "The title for the first bookmark for the web proxy");
- config.setExpert(
- "mainport.params.servlet.2.bookmarks.0.activelinkFile",
- true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.0.activelinkFile",
- "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.0.activelinkFile",
- "The name of the activelink image within the key for the first bookmark");
- config.setExpert(
- "mainport.params.servlet.2.bookmarks.0.description",
- true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.0.description",
- "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.0.description",
- "The description of the first bookmark on the web proxy");
- config.setExpert("mainport.params.servlet.2.bookmarks.1.key", true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.1.key",
- "freenet key");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.1.key",
- "The second bookmark for the web proxy");
- config.setExpert("mainport.params.servlet.2.bookmarks.1.title", true);
- config.argDesc("mainport.params.servlet.2.bookmarks.1.title", "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.1.title",
- "The title for the second bookmark for the web proxy");
- config.setExpert(
- "mainport.params.servlet.2.bookmarks.1.activelinkFile",
- true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.1.activelinkFile",
- "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.1.activelinkFile",
- "The name of the activelink image within the key for the second bookmark");
- config.setExpert(
- "mainport.params.servlet.2.bookmarks.1.description",
- true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.1.description",
- "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.1.description",
- "The description of the second bookmark on the web proxy");
- config.setExpert("mainport.params.servlet.2.bookmarks.2.key", true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.2.key",
- "freenet key");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.2.key",
- "The third bookmark for the web proxy");
- config.setExpert("mainport.params.servlet.2.bookmarks.2.title", true);
- config.argDesc("mainport.params.servlet.2.bookmarks.2.title", "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.2.title",
- "The title for the third bookmark for the web proxy");
- config.setExpert(
- "mainport.params.servlet.2.bookmarks.2.activelinkFile",
- true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.2.activelinkFile",
- "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.2.activelinkFile",
- "The name of the activelink image within the key for the third bookmark");
- config.setExpert(
- "mainport.params.servlet.2.bookmarks.2.description",
- true);
- config.argDesc(
- "mainport.params.servlet.2.bookmarks.2.description",
- "string");
- config.shortDesc(
- "mainport.params.servlet.2.bookmarks.2.description",
- "The description of the third bookmark on the web proxy");
- // config.setExpert("mainport.params.servlet.2.bookmarks.3.key", true);
- // config.argDesc(
- // "mainport.params.servlet.2.bookmarks.3.key",
- // "freenet key");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.3.key",
- // "The fourth bookmark for the web proxy");
- // config.setExpert("mainport.params.servlet.2.bookmarks.3.title", true);
- // config.argDesc("mainport.params.servlet.2.bookmarks.3.title", "string");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.3.title",
- // "The title for the fourth bookmark for the web proxy");
- // config.setExpert(
- // "mainport.params.servlet.2.bookmarks.3.activelinkFile",
- // true);
- // config.argDesc(
- // "mainport.params.servlet.2.bookmarks.3.activelinkFile",
- // "string");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.3.activelinkFile",
- // "The name of the activelink image within the key for the fourth bookmark");
- // config.setExpert(
- // "mainport.params.servlet.2.bookmarks.3.description",
- // true);
- // config.argDesc(
- // "mainport.params.servlet.2.bookmarks.3.description",
- // "string");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.3.description",
- // "The description of the fourth bookmark on the web proxy");
- //
- // config.setExpert("mainport.params.servlet.2.bookmarks.4.key", true);
- // config.argDesc(
- // "mainport.params.servlet.2.bookmarks.4.key",
- // "freenet key");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.4.key",
- // "The fifth bookmark for the web proxy");
- // config.setExpert("mainport.params.servlet.2.bookmarks.4.title", true);
- // config.argDesc("mainport.params.servlet.2.bookmarks.4.title", "string");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.4.title",
- // "The title for the fifth bookmark for the web proxy");
- // config.setExpert(
- // "mainport.params.servlet.2.bookmarks.4.activelinkFile",
- // true);
- // config.argDesc(
- // "mainport.params.servlet.2.bookmarks.4.activelinkFile",
- // "string");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.4.activelinkFile",
- // "The name of the activelink image within the key for the fifth bookmark");
- // config.setExpert(
- // "mainport.params.servlet.2.bookmarks.4.description",
- // true);
- // config.argDesc(
- // "mainport.params.servlet.2.bookmarks.4.description",
- // "string");
- // config.shortDesc(
- // "mainport.params.servlet.2.bookmarks.4.description",
- // "The description of the fifth bookmark on the web proxy");
- //
- // mainport.params.servlet.3.uri
- config.setExpert("mainport.params.servlet.3.uri", true);
- config.argDesc("mainport.params.servlet.3.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.3.uri",
- "Path within mainport for the Images Servlet");
- config.longDesc(
- "mainport.params.servlet.3.uri",
- "Path within mainport for the Images - this serves static images needed by fproxy and the Node Info Servlet");
- // mainport.params.servlet.3.method
- config.setExpert("mainport.params.servlet.3.method", true);
- config.argDesc("mainport.params.servlet.3.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.3.method",
- "HTTP method for Images Servlet. Leave this alone.");
- // mainport.params.servlet.3.class
- config.setExpert("mainport.params.servlet.3.class", true);
- config.argDesc("mainport.params.servlet.3.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.3.class",
- "servlet class to run Images Servlet. Leave this alone");
- // mainport.params.servlet.3.name
- config.setExpert("mainport.params.servlet.3.name", true);
- config.argDesc("mainport.params.servlet.3.name", "string");
- config.shortDesc(
- "mainport.params.servlet.3.name",
- "name of (usually) Images Servlet. Leave this alone.");
- // mainport.params.servlet.4.uri
- config.setExpert("mainport.params.servlet.4.uri", true);
- config.argDesc("mainport.params.servlet.4.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.4.uri",
- "Path within mainport for the Insert Servlet");
- config.longDesc(
- "mainport.params.servlet.4.uri",
- "Path within mainport for the Insert Servlet - used to insert files into freenet from the web interface");
- // mainport.params.servlet.4.method
- config.setExpert("mainport.params.servlet.4.method", true);
- config.argDesc("mainport.params.servlet.4.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.4.method",
- "HTTP method for Insert "
- + "Servlet (needs BOTH GET for status and PUT for uploads). "
- + "Leave this alone.");
- // mainport.params.servlet.4.class
- config.setExpert("mainport.params.servlet.4.class", true);
- config.argDesc("mainport.params.servlet.4.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.4.class",
- "servlet class to run Insert Servlet. Leave this alone");
- // mainport.params.servlet.4.name
- config.setExpert("mainport.params.servlet.4.name", true);
- config.argDesc("mainport.params.servlet.4.name", "string");
- config.shortDesc(
- "mainport.params.servlet.4.name",
- "name of (usually) Insert Servlet. Leave this alone.");
- // mainport.params.servlet.4.params.insertHtl
- config.setExpert("mainport.params.servlet.4.params.insertHtl", true);
- config.argDesc(
- "mainport.params.servlet.4.params.insertHtl",
- "integer between 0 and maxHopsToLive");
- config.shortDesc(
- "mainport.params.servlet.4.params.insertHtl",
- "hops to live (HTL) of inserts");
- config.longDesc(
- "mainport.params.servlet.4.params.insertHtl",
- "Hops-to-Live value (HTL) of inserts through the web interface");
- // mainport.params.servlet.4.params.sfInsertThreads
- config.setExpert(
- "mainport.params.servlet.4.params.sfInsertThreads",
- true);
- config.argDesc(
- "mainport.params.servlet.4.params.sfInsertThreads",
- "integer");
- config.shortDesc(
- "mainport.params.servlet.4.params.sfInsertThreads",
- "threads to use to insert a splitfile");
- config.longDesc(
- "mainport.params.servlet.4.params.sfInsertThreads",
- "Number of threads to allocate to insert a splitfile through the web interface");
- // mainport.params.servlet.4.params.sfInsertRetries
- config.setExpert(
- "mainport.params.servlet.4.params.sfInsertRetries",
- true);
- config.argDesc(
- "mainport.params.servlet.4.params.sfInsertRetries",
- "integer");
- config.shortDesc(
- "mainport.params.servlet.4.params.sfInsertRetries",
- "Number of retries if a block insert fails");
- // mainport.params.servlet.4.params.sfRefreshIntervalSecs
- config.setExpert(
- "mainport.params.servlet.4.params.sfRefreshIntervalSecs",
- true);
- config.argDesc(
- "mainport.params.servlet.4.params.sfRefreshIntervalSecs",
- "<seconds>");
- config.shortDesc(
- "mainport.params.servlet.4.params.sfRefreshIntervalSecs",
- "How frequently to update insert status");
- // mainport.params.servlet.6.uri
- config.setExpert("mainport.params.servlet.6.uri", true);
- config.argDesc("mainport.params.servlet.6.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.6.uri",
- "Path within mainport for the Insert Servlet");
- config.longDesc(
- "mainport.params.servlet.6.uri",
- "Path within mainport for the Insert Servlet - used to insert files into freenet from the web interface");
- // mainport.params.servlet.6.method
- config.setExpert("mainport.params.servlet.6.method", true);
- config.argDesc("mainport.params.servlet.6.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.6.method",
- "HTTP method for Insert Servlet (should be PUT). Leave this alone.");
- // mainport.params.servlet.6.class
- config.setExpert("mainport.params.servlet.6.class", true);
- config.argDesc("mainport.params.servlet.6.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.6.class",
- "servlet class to run Insert Servlet. Leave this alone");
- // mainport.params.servlet.6.name
- config.setExpert("mainport.params.servlet.6.name", true);
- config.argDesc("mainport.params.servlet.6.name", "string");
- config.shortDesc(
- "mainport.params.servlet.6.name",
- "name of (usually) Insert Servlet. Leave this alone.");
- // mainport.params.servlet.6.params.insertHtl
- config.setExpert("mainport.params.servlet.6.params.insertHtl", true);
- config.argDesc(
- "mainport.params.servlet.6.params.insertHtl",
- "integer between 0 and maxHopsToLive");
- config.shortDesc(
- "mainport.params.servlet.6.params.insertHtl",
- "hops to live (HTL) of inserts");
- config.longDesc(
- "mainport.params.servlet.6.params.insertHtl",
- "Hops-to-Live value (HTL) of inserts through the web interface");
- // mainport.params.servlet.6.params.sfInsertThreads
- config.setExpert(
- "mainport.params.servlet.6.params.sfInsertThreads",
- true);
- config.argDesc(
- "mainport.params.servlet.6.params.sfInsertThreads",
- "integer");
- config.shortDesc(
- "mainport.params.servlet.6.params.sfInsertThreads",
- "threads to use to insert a splitfile");
- config.longDesc(
- "mainport.params.servlet.6.params.sfInsertThreads",
- "Number of threads to allocate to insert a splitfile through the web interface");
- // mainport.params.servlet.6.params.sfInsertRetries
- config.setExpert(
- "mainport.params.servlet.6.params.sfInsertRetries",
- true);
- config.argDesc(
- "mainport.params.servlet.6.params.sfInsertRetries",
- "integer");
- config.shortDesc(
- "mainport.params.servlet.6.params.sfInsertRetries",
- "Number of retries if a block insert fails");
- // mainport.params.servlet.6.params.sfRefreshIntervalSecs
- config.setExpert(
- "mainport.params.servlet.6.params.sfRefreshIntervalSecs",
- true);
- config.argDesc(
- "mainport.params.servlet.6.params.sfRefreshIntervalSecs",
- "<seconds>");
- config.shortDesc(
- "mainport.params.servlet.6.params.sfRefreshIntervalSecs",
- "How frequently to update insert status");
- // mainport.params.servlet.5.uri
- config.setExpert("mainport.params.servlet.5.uri", true);
- config.argDesc("mainport.params.servlet.5.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.5.uri",
- "Path within mainport for the Node Status Servlet");
- config.longDesc(
- "mainport.params.servlet.5.uri",
- "Path within mainport for the Node Status Servlet - displays detailed information about node status. Disabled if publicNode is on.");
- // mainport.params.servlet.5.method
- config.setExpert("mainport.params.servlet.5.method", true);
- config.argDesc("mainport.params.servlet.5.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.5.method",
- "HTTP method for Node Status Servlet. Leave this alone.");
- // mainport.params.servlet.5.class
- config.setExpert("mainport.params.servlet.5.class", true);
- config.argDesc("mainport.params.servlet.5.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.5.class",
- "servlet class to run Node Status Servlet. Leave this alone");
- // mainport.params.servlet.5.name
- config.setExpert("mainport.params.servlet.5.name", true);
- config.argDesc("mainport.params.servlet.5.name", "string");
- config.shortDesc(
- "mainport.params.servlet.5.name",
- "name of (usually) Node Status Servlet. Leave this alone.");
- // mainport.params.servlet.7.uri
- config.setExpert("mainport.params.servlet.7.uri", true);
- config.argDesc("mainport.params.servlet.7.uri", "path");
- config.shortDesc(
- "mainport.params.servlet.7.uri",
- "Path within mainport for the SplitFile Download Servlet");
- config.longDesc(
- "mainport.params.servlet.7.uri",
- "Path within mainport for the SplitFile Download Servlet - used to download large files through the web interface");
- // mainport.params.servlet.7.method
- config.setExpert("mainport.params.servlet.7.method", true);
- config.argDesc("mainport.params.servlet.7.method", "HTTP method");
- config.shortDesc(
- "mainport.params.servlet.7.method",
- "HTTP method for SplitFile Download Servlet. Leave this alone.");
- // mainport.params.servlet.7.class
- config.setExpert("mainport.params.servlet.7.class", true);
- config.argDesc("mainport.params.servlet.7.class", "servlet class");
- config.shortDesc(
- "mainport.params.servlet.7.class",
- "servlet class to run SplitFile Download Servlet. Leave this alone");
- // mainport.params.servlet.7.name
- config.setExpert("mainport.params.servlet.7.name", true);
- config.argDesc("mainport.params.servlet.7.name", "string");
- config.shortDesc(
- "mainport.params.servlet.7.name",
- "name of (usually) SplitFile Download Servlet. Leave this alone.");
- // mainport.params.servlet.7.params.requestHtl
- config.setExpert("mainport.params.servlet.7.params.requestHtl", true);
- config.argDesc(
- "mainport.params.servlet.7.params.requestHtl",
- "integer value between 0 and maxHopsToLive");
- config.shortDesc(
- "mainport.params.servlet.7.params.requestHtl",
- "request HTL getting metadata in splitfile servlet");
- config.longDesc(
- "mainport.params.servlet.7.params.requestHtl",
- "Hops-To-Live of requests for the metadata of the splitfiles downloading splitfiles from the web interface.");
- // mainport.params.servlet.7.params.sfBlockRequestHtl
- config.setExpert(
- "mainport.params.servlet.7.params.sfBlockRequestHtl",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfBlockRequestHtl",
- "integer value between 0 and maxHopsToLive");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfBlockRequestHtl",
- "initial request HTL for blocks in splitfile downloads");
- config.longDesc(
- "mainport.params.servlet.7.params.sfBlockRequestHtl",
- "initial Hops-To-Live (HTL) of requests for blocks downloading splitfiles");
- // mainport.params.servlet.7.params.sfRequestRetries
- config.setExpert(
- "mainport.params.servlet.7.params.sfRequestRetries",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfRequestRetries",
- "positive integer");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfRequestRetries",
- "Number of retries on each block in a splitfile download");
- // mainport.params.servlet.7.params.maxRetries
- config.setExpert(
- "mainport.params.servlet.7.params.maxRetries",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.maxRetries",
- "positive integer");
- config.shortDesc(
- "mainport.params.servlet.7.params.maxRetries",
- "Maximum number of retries per block for a splitfile");
-
- // mainport.params.servlet.7.params.sfRetryHtlIncrement
- config.setExpert(
- "mainport.params.servlet.7.params.sfRetryHtlIncrement",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfRetryHtlIncrement",
- "positive integer");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfRetryHtlIncrement",
- "Amount to increase the HTL by on each retry");
- // mainport.params.servlet.7.params.sfRequestThreads
- config.setExpert(
- "mainport.params.servlet.7.params.sfRequestThreads",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfRequestThreads",
- "positive integer");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfRequestThreads",
- "Number of threads to use to download a splitfile via the web interface");
- // mainport.params.servlet.7.params.sfDoParanoidChecks
- config.setExpert(
- "mainport.params.servlet.7.params.sfDoParanoidChecks",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfDoParanoidChecks",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfDoParanoidChecks",
- "Whether to run paranoid checks on blocks downloaded as part of a splitfile");
- // mainport.params.servlet.7.params.sfRefreshIntervalSecs
- config.setExpert(
- "mainport.params.servlet.7.params.sfRefreshIntervalSecs",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfRefreshIntervalSecs",
- "<seconds>");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfRefreshIntervalSecs",
- "How frequently to update the splitfile user interface while downloading");
- // mainport.params.servlet.7.params.sfForceSave
- config.setExpert("mainport.params.servlet.7.params.sfForceSave", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfForceSave",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfForceSave",
- "Whether to (by default) force the browser to save splitfiles to disk");
- // mainport.params.servlet.7.params.sfSkipDS
- config.setExpert("mainport.params.servlet.7.params.sfSkipDS", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfSkipDS",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfSkipDS",
- "Skip local datastore when downloading splitfiles?");
- config.longDesc(
- "mainport.params.servlet.7.params.sfSkipDS",
- "Whether to "
- + "skip the local datastore when downloading splitfiles. "
- + "If you don't know what this means you don't need it.");
- // mainport.params.servlet.7.params.sfUseUI
- config.setExpert("mainport.params.servlet.7.params.sfUseUI", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfUseUI",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfUseUI",
- "Use downloader user interface when downloading files?");
- config.longDesc(
- "mainport.params.servlet.7.params.sfUseUI",
- "Whether to use the downloader user interface when downloading files. If set to no, files will be downloaded directly without showing any progress monitor, but this may take a very long time and most splitfiles do not send any data until the whole file has been downloaded");
- // mainport.params.servlet.7.params.sfRunFilter
- config.setExpert("mainport.params.servlet.7.params.sfRunFilter", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfRunFilter",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfRunFilter",
- "Run the anonymity filter on HTML splitfiles?");
- // mainport.params.servlet.7.params.sfRandomSegs
- config.setExpert("mainport.params.servlet.7.params.sfRandomSegs", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfRandomSegs",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfRandomSegs",
- "Randomize the order of segment downloads for splitfiles?");
- config.longDesc(
- "mainport.params.servlet.7.params.sfRandomSegs",
- "Whether to randomize the order of segment downloads for splitfiles. Normally this is a good thing.");
- // mainport.params.servlet.7.params.sfFilterParanoidStringCheck
- config.setExpert(
- "mainport.params.servlet.7.params.sfFilterParanoidStringCheck",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfFilterParanoidStringCheck",
- "true|false");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfFilterParanoidStringCheck",
- "Make the anonymity filter on HTML splitfiles really paranoid?");
- config.longDesc(
- "mainport.params.servlet.7.params.sfFilterParanoidStringCheck",
- "Make the anonymity filter on HTML splitfiles really paranoid? Currently this causes strings in CSS to be removed if they contain colons (\":\")");
- // mainport.params.servlet.7.params.sfHealHtl
- config.setExpert("mainport.params.servlet.7.params.sfHealHtl", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfHealHtl",
- "integer between 0 and maxHopsToLive");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfHealHtl",
- "default HTL of splitfile healing insertions");
- config.longDesc(
- "mainport.params.servlet.7.params.sfHealHtl",
- "Default HTL of inserts caused by splitfile healing code");
- // mainport.params.servlet.7.params.sfHealPercentage
- config.setExpert(
- "mainport.params.servlet.7.params.sfHealPercentage",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfHealPercentage",
- "0...100");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfHealPercentage",
- "Percentage of missing blocks to reinsert after fetching a redundant splitfile. Reinsertion is done in the background, so the default of 100 is quite reasonable.");
- // mainport.params.servlet.7.params.sfForceSave
- config.setExpert("mainport.params.servlet.7.params.sfForceSave", true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfForceSave",
- "yes|no");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfForceSave",
- "force save splitfile downloads by default?");
- config.longDesc(
- "mainport.params.servlet.7.params.sfForceSave",
- "If true, large \"splitfiles\" will always be saved as application/octet-stream, to force the browser to save the file to disk rather than trying to open it in place.");
- // mainport.params.servlet.7.params.sfDefaultSaveDir
- config.setExpert(
- "mainport.params.servlet.7.params.sfDefaultSaveDir",
- false);
- config.argDesc(
- "mainport.params.servlet.7.params.sfDefaultSaveDir",
- "path to folder");
- config.shortDesc(
- "mainport.params.servlet.7.params.sfDefaultSaveDir",
- "Default folder to save large downloaded files to.");
- config.longDesc(
- "mainport.params.servlet.7.params.sfDefaultSaveDir",
- "Default folder to save large downloaded files to. Defaults to a folder",
- "called \"freenet-downloads\" in your home directory.");
- // mainport.params.servlet.7.params.sfDefaultWriteToDisk
- config.setExpert(
- "mainport.params.servlet.7.params.sfDefaultWriteToDisk",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfDefaultWriteToDisk",
- "yes|no");
- config.longDesc(
- "mainport.params.servlet.7.params.sfDefaultWriteToDisk",
- "Whether to write splitfiles to disk by default, rather than sending them to the browser");
- // mainport.params.servlet.7.params.sfDisableWriteToDisk
- config.setExpert(
- "mainport.params.servlet.7.params.sfDisableWriteToDisk",
- true);
- config.argDesc(
- "mainport.params.servlet.7.params.sfDisableWriteToDisk",
- "yes|no");
- config.longDesc(
- "mainport.params.servlet.7.params.sfDisableWriteToDisk",
- "Set true to disable the option to write splitfile downloads direct to disk rather than streaming them to the browser. Automatically enabled if publicNode is set.");
- // mainport.params.defaultServlet.uri
- config.setExpert("mainport.params.defaultServlet.uri", true);
- config.argDesc("mainport.params.defaultServlet.uri", "path");
- config.shortDesc(
- "mainport.params.defaultServlet.uri",
- "Path within mainport for web interface redirect");
- config.longDesc(
- "mainport.params.defaultServlet.uri",
- "Path within mainport for web interface redirect");
- // mainport.params.defaultServlet.method
- config.setExpert("mainport.params.defaultServlet.method", true);
- config.argDesc("mainport.params.defaultServlet.method", "HTTP method");
- config.shortDesc(
- "mainport.params.defaultServlet.method",
- "HTTP method for web interface redirect. Leave this alone.");
- // mainport.params.defaultServlet.class
- config.setExpert("mainport.params.defaultServlet.class", true);
- config.argDesc("mainport.params.defaultServlet.class", "servlet class");
- config.shortDesc(
- "mainport.params.defaultServlet.class",
- "servlet class to run web interface redirect. Leave this alone");
- // mainport.params.defaultServlet.name
- config.setExpert("mainport.params.defaultServlet.name", true);
- config.argDesc("mainport.params.defaultServlet.name", "string");
- config.shortDesc(
- "mainport.params.defaultServlet.name",
- "name of (usually) web interface redirect. Leave this alone.");
- // mainport.params.defaultServlet.params.targetURL
- config.setExpert(
- "mainport.params.defaultServlet.params.targetURL",
- true);
- config.argDesc(
- "mainport.params.defaultServlet.params.targetURL",
- "path");
- config.shortDesc(
- "mainport.params.defaultServlet.params.targetURL",
- "path in the servlet to the default page");
- // System.err.println("Node.java static initialization end.");
- }
- //=== Static elements
- // ======================================================
- // node specific options
- static public int routeConnectTimeout;
- static public int maxHopsToLive;
- static public float probIncHopsSinceReset;
- static public float cacheProbPerHop;
- static public float minStoreFullPCache;
- static public float minRTFullPRef;
- static public float minRTNodesPRef;
- static public String routingTableImpl;
- static public RunningAverage myPQueryRejected;
- static public int newNodePollInterval = 30000; // 30 seconds
- // announcement options
- static public int announcementAttempts;
- static public int announcementThreads;
- static public int initialRequests;
- static public int initialRequestHTL;
- static public float overloadLow;
- static public float overloadHigh;
- static public boolean doRequestTriageByDelay;
- static public boolean doRequestTriageBySendTime;
- static public int requestDelayCutoff;
- static public int successfulDelayCutoff;
- static public int requestSendTimeCutoff;
- static public int successfulSendTimeCutoff;
- static public double defaultResetProbability;
- static public int lsMaxTableSize;
- static public int lsAcceptRatioSamples;
- static public double lsHalfLifeHours;
- static public boolean doOutLimitCutoff;
- static public boolean doOutLimitConnectCutoff;
- static public float outLimitCutoff;
- static public float outLimitConnectCutoff;
- static public float threadConnectCutoff;
- static public boolean doCPULoad;
- static public int sendingQueueLength;
- static public int sendingQueueBytes;
- static public int rateLimitingInterval = 0;
- // calculated from above 2
- public static final int muxTrailerBufferLength = 65535;
- static public boolean doLoadBalance;
- static public boolean localIsOK;
- static public boolean dontLimitClients;
- static public String mainportURIOverride;
- static public String distributionURIOverride;
- static public int aggressiveGC;
- static public int configUpdateInterval;
- static public int seednodesUpdateInterval;
- static public boolean badAddress = false;
- static public boolean logInputBytes;
- static public boolean logOutputBytes;
- public static int maxLog2DataSize = 20;
- //static public int maxForwardTries;
- static public boolean firstTime = false;
- // node data files
- static public String nodeFile;
- static public File storeFiles[];
-
- //The lock instance keeping the lock on the above file
- private static FileLock lockFileLock=null;
- // seednodes file
- static public String seedFile;
- // node limits
- static public long storeSize;
- static public int storeBlockSize;
- static public float storeMaxTempFraction;
- static public int rtMaxRefs, rtMaxNodes;
- static public int listenPort;
- static public String storeType;
- static public int maxNodeConnections;
- static public double maxOpenConnectionsNewbieFraction;
- static public int maxNodeFilesOpen;
- static public int bandwidthLimit, inputBandwidthLimit, outputBandwidthLimit;
- static public int averageBandwidthLimit,
- averageInputBandwidthLimit,
- averageOutputBandwidthLimit;
- static public double lowLevelBWLimitMultiplier;
- // the param value * the fudge factor
- static public double lowLevelBWLimitFudgeFactor;
- static public boolean doLowLevelOutputLimiting, doLowLevelInputLimiting;
- static public boolean doReserveOutputBandwidthForSuccess;
- static public int maxNegotiations;
- static public boolean doEstimatorSmoothing;
- static public boolean useFastEstimators;
- // The maximum number of node references that
- // will be returned by successive calls to
- // Routing.getNextRoute().
- static public int maxRoutingSteps;
- static public float minCP;
- static public int minARKDelay;
- static public int failuresLookupARK;
- static public float maxARKThreadsFraction;
- // datastore encryption
- static public String storeCipherName;
- static public int storeCipherWidth;
- static public File routingDir;
- static public boolean useDSIndex;
- // So we can keep track of how long the
- // node has been running. Approximate, but good enough.
- static final public long startupTimeMs = System.currentTimeMillis();
- // remote admin stuff
- static private String adminPassword;
- static private Identity adminPeer;
- // common service ports
- static public int distributionPort;
- static public int fproxyPort;
- // thread management. Parameters read in Main.java
- static public int maxThreads; // maximumThreads parameter.
- static public int targetMaxThreads;
- static public String threadFactoryName;
- static public int tfTolerableQueueDelay;
- static public int tfAbsoluteMaxThreads;
- static protected ThreadFactory threadFactory;
- // client stuff
- static public String filterPassThroughMimeTypes;
- static public boolean httpInserts;
- static public boolean fcpInserts;
- static public String uiTemplateSet = Node.uiTemplateSet + "";
- static public Bandwidth ibw, obw;
- static public boolean defaultToSimpleUIMode;
- static public boolean defaultToOCMHTMLPeerHandlerMode;
- static public RecentKeyList recentKeys;
- private static Object syncCountsByBackoffCount = new Object();
- private static long[] successesByBackoffCount;
- private static long[] failuresByBackoffCount;
- public static boolean isAuthorized(Identity id, String p) {
- if (adminPassword != null
- && !adminPassword.equals("")
- && adminPeer != null) {
- return adminPassword.equals(p) && adminPeer.equals(id);
- } else if (adminPassword != null && adminPassword.length()!=0) {
- return adminPassword.equals(p);
- } else if (adminPeer != null) {
- return adminPeer.equals(id);
- } else { // no remote admin
- return false;
- }
- }
- /**
- * @throws CoreException
- * if initialization has already occurred
- */
- public static void init(Params params) throws CoreException {
- // Init the core settings
- Core.init(params);
- // set keytypes
- try {
- Key.addKeyType(freenet.keys.SVK.keyNumber, freenet.keys.SVK.class);
- Key.addKeyType(freenet.keys.CHK.keyNumber, freenet.keys.CHK.class);
- } catch (KeyException e) {
- String s = "Failed initializing Key classes: " + e;
- logger.log(Node.class, s, e, Logger.ERROR);
- System.err.println(s);
- e.printStackTrace(System.err);
- CoreException ce = new CoreException(s);
- ce.initCause(e);
- throw ce;
- }
- String[] keyTypes = params.getList("keyTypes");
- for (int i = 1; keyTypes != null && i < keyTypes.length; i += 2) {
- try {
- Key.addKeyType(
- Integer.parseInt(keyTypes[i - 1]),
- Class.forName(keyTypes[i]));
- } catch (ClassNotFoundException e) {
- logger.log(
- Node.class,
- "No such class: "
- + keyTypes[i]
- + " for Key type "
- + keyTypes[i
- - 1],
- Logger.ERROR);
- } catch (ClassCastException e) {
- logger.log(
- Node.class,
- "Class " + keyTypes[i] + " is not a Key",
- Logger.ERROR);
- } catch (KeyException e) {
- String s = "Failed initializing Key classes: " + e;
- logger.log(Node.class, s, e, Logger.ERROR);
- System.err.println(s);
- e.printStackTrace(System.err);
- CoreException ce = new CoreException(s);
- ce.initCause(e);
- throw ce;
- }
- }
- myPQueryRejected = new SimpleBinaryRunningAverage(1000, 1.0);
- // set network parameters
- newNodePollInterval = params.getInt("newNodePollInterval");
- recentKeys = new RecentKeyList(512, Core.getRandSource());
- routeConnectTimeout = params.getInt("routeConnectTimeout");
- maxHopsToLive = params.getInt("maxHopsToLive");
- maxLog2DataSize = params.getInt("maxLog2DataSize");
- probIncHopsSinceReset = params.getFloat("probIncHopsSinceReset");
- cacheProbPerHop = params.getFloat("cacheProbPerHop");
- minStoreFullPCache = params.getFloat("minStoreFullPCache");
- minRTFullPRef = params.getFloat("minRTFullPRef");
- minRTNodesPRef = params.getFloat("minRTNodesPRef");
- //routingTableImpl = params.getString("routingTableImpl");
- maxNegotiations = params.getInt("maxNegotiations");
- routingTableImpl = "ng";
- announcementAttempts = params.getInt("announcementAttempts");
- announcementThreads = params.getInt("announcementThreads");
- initialRequests = params.getInt("initialRequests");
- initialRequestHTL = params.getInt("initialRequestHTL");
- //maxForwardTries = Defaults.getInt("maxForwardTries", params);
- int maxRequestsPerInterval = params.getInt("maxRequestsPerInterval");
- if (maxRequestsPerInterval > 0)
- outboundRequestLimit =
- new LimitCounter(
- params.getInt("maxRequestsInterval"),
- maxRequestsPerInterval);
- lowLevelBWLimitFudgeFactor =
- params.getFloat("lowLevelBWLimitFudgeFactor");
- lowLevelBWLimitMultiplier =
- params.getFloat("lowLevelBWLimitMultiplier")
- * lowLevelBWLimitFudgeFactor;
- // doLowLevelOutputLimiting = false;
- // doLowLevelInputLimiting = false;
- doLowLevelOutputLimiting =
- params.getBoolean("doLowLevelOutputLimiting");
- doLowLevelInputLimiting = params.getBoolean("doLowLevelInputLimiting");
- doReserveOutputBandwidthForSuccess =
- params.getBoolean("doReserveOutputBandwidthForSuccess");
- bandwidthLimit = params.getInt("bandwidthLimit");
- inputBandwidthLimit = params.getInt("inputBandwidthLimit");
- outputBandwidthLimit = params.getInt("outputBandwidthLimit");
- averageBandwidthLimit = params.getInt("averageBandwidthLimit");
- averageInputBandwidthLimit =
- params.getInt("averageInputBandwidthLimit");
- averageOutputBandwidthLimit =
- params.getInt("averageOutputBandwidthLimit");
- if (inputBandwidthLimit == 0
- && outputBandwidthLimit == 0
- && averageInputBandwidthLimit == 0
- && averageOutputBandwidthLimit == 0) {
- if (bandwidthLimit != 0 || averageBandwidthLimit != 0) {
- String err =
- "Overall bandwidth limit NO LONGER SUPPORTED! - approximating by setting each direction to half the specified limit";
- logger.log(Node.class, err, Logger.ERROR);
- System.err.println(err);
- System.out.println(err);
- outputBandwidthLimit = bandwidthLimit / 2;
- inputBandwidthLimit = bandwidthLimit / 2;
- }
- }
- if (doLowLevelInputLimiting) {
- ibw =
- inputBandwidthLimit == 0
- ? null
- : new Bandwidth(
- (int) (inputBandwidthLimit * lowLevelBWLimitMultiplier),
- (int) (averageInputBandwidthLimit
- * lowLevelBWLimitMultiplier),
- Bandwidth.RECEIVED);
- } else
- ibw = null;
- if (doLowLevelOutputLimiting) {
- obw =
- outputBandwidthLimit == 0
- ? null
- : new Bandwidth(
- (int) (outputBandwidthLimit
- * lowLevelBWLimitMultiplier),
- (int) (averageOutputBandwidthLimit
- * lowLevelBWLimitMultiplier),
- Bandwidth.SENT);
- } else
- obw = null;
- if (params.getBoolean("limitAll")) {
- logger.log(Node.class, "Limiting all connections", Logger.DEBUG);
- tcpAddress.throttleAll = true;
- tcpListener.throttleAll = true;
- }
- try {
- tcpConnection.setInputBandwidth(ibw);
- tcpConnection.setOutputBandwidth(obw);
- } catch (NoClassDefFoundError e) {
- if (e
- .getMessage()
- .indexOf("java/nio/channels/spi/AbstractInterruptibleChannel")
- != -1) {
- String error =
- "Your Java installation is too old (insufficient NIO support). Please update it to 1.4.1 or later; you can do that at http://java.sun.com/ .";
- System.err.println(error);
- logger.log(Node.class, error, Logger.ERROR);
- System.exit(1);
- } else
- throw e;
- }
- // ThrottledInputStream.setThrottle(ibw);
- // ThrottledOutputStream.setThrottle(obw);
- // set storage parameters
- storeSize = params.getLong("storeSize");
- if (storeSize > 0 && storeSize < (101L * (1 << 20))) {
- String error =
- "Store size insufficient to store 1MB chunks! Your datastore is so small that it will not be able to store 1MB chunks, the maximum size of a single data key that most tools insert. You will still be able to fetch them but your node will not be very useful to the network, and consequentially will not perform well. To eliminate this error increase your storeSize to at least 101M. It is currently "
- + storeSize
- + ".";
- System.err.println(error);
- logger.log(Node.class, error, Logger.ERROR);
- }
- storeBlockSize = params.getInt("storeBlockSize");
- storeMaxTempFraction = params.getFloat("storeMaxTempFraction");
- //maxFileSize = cacheSize / params.getInt("storeCacheCount");
- maxNodeConnections = params.getInt("maxNodeConnections");
- maxNodeFilesOpen = params.getInt("maxNodeFilesOpen");
- maxOpenConnectionsNewbieFraction =
- params.getDouble("maxOpenConnectionsNewbieFraction");
- rtMaxRefs = params.getInt("rtMaxRefs");
- if(maxNodeConnections > 0)
- rtMaxNodes = maxNodeConnections * 2;
- else
- rtMaxNodes = params.getInt("rtMaxNodes");
- doEstimatorSmoothing = params.getBoolean("doEstimatorSmoothing");
- useFastEstimators = params.getBoolean("useFastEstimators");
- successesByBackoffCount = new long[rtMaxNodes+1];
- failuresByBackoffCount = new long[rtMaxNodes+1];
- maxRoutingSteps = params.getInt("maxRoutingSteps");
- if(maxRoutingSteps < 0) maxRoutingSteps = rtMaxNodes/4;
- minCP = params.getFloat("minCP");
- failuresLookupARK = params.getInt("failuresLookupARK");
- minARKDelay = params.getInt("minARKDelay");
- maxARKThreadsFraction =
- params.getFloat("maxARKThreadsFraction");
- storeCipherName = params.getString("storeCipherName");
- if (storeCipherName.equals("none")
- || storeCipherName.equals("null")
- || storeCipherName.equals("void"))
- storeCipherName = null;
- storeCipherWidth = params.getInt("storeCipherWidth");
- routingDir = new File(params.getString("routingDir"));
- useDSIndex = params.getBoolean("useDSIndex");
- // get the listening port
- listenPort = params.getInt("listenPort");
- // seednodes file
- seedFile = params.getString("seedFile");
- String[] storeFile = params.getList("storeFile");
- if (storeFile.length == 0
- || storeFile[0] == null
- || storeFile[0].length()==0) {
- storeFile = new String[] { "store" };
- File f = new File("store_" + listenPort);
- if (f.exists()) {
- if (!f.renameTo(new File("store"))) {
- logger.log(
- Node.class,
- "Cannot rename "
- + f
- + " to \"store\". This would be useful"
- + " because then you could change the port"
- + " without causing the datastore to"
- + " disappear, causing a major disk space leak"
- + " and a significant loss of performance.",
- Logger.NORMAL);
- storeFile = new String[] { "store_" + listenPort };
- } else {
- File idx = new File("store", "index");
- if (idx.exists())
- idx.delete();
- idx = new File("store", "index.old");
- if (idx.exists())
- idx.delete();
- }
- }
- }
- storeFiles = new File[storeFile.length];
- for (int i = 0; i < storeFiles.length; ++i) {
- storeFiles[i] = new File(storeFile[i]);
- if (storeFiles[i].exists())
- firstTime = false;
- }
- if ((routingDir == null
- || routingDir.toString().length() == 0)
- && storeFiles[0] != null
- && storeFiles[0].getPath().length() > 0) {
- routingDir =
- storeFiles[0].getAbsoluteFile().getParentFile();
- }
- //The file used to prevent additional instances of a node from starting
- final File lockFile = new File(routingDir, "lock.lck");
-
- //See if 'we' are already running
- try {
- lockFile.createNewFile();
- } catch (IOException e) {
- //Dont care if we managed to create the file or not (wheter or not it already existed really).
- //What really matters is wheter or not we manage to lock it below
- }
- if(!lockFile.exists()){
- //Hmmm.. this is bad.. better shut down I assume
- logger.log(Node.class, "Lockfile '"+lockFile.getAbsolutePath()+"' doesn't exist after we tried to create it. Permissions problem? Shutting down.",Logger.ERROR);
- System.exit(2);
- }
- try {
- lockFileLock = new FileOutputStream(lockFile).getChannel().tryLock();
- } catch (Exception e) {
- logger.log(Node.class, "Encountered an unexpected error when locking the lockfile '"+lockFile.getAbsolutePath()+"'. Shutting down.",e,Logger.ERROR);
- System.exit(3);
- }
- if(lockFileLock ==null){
- logger.log(Node.class, "Lockfile '"+lockFile.getAbsolutePath()+"' locked by another process. Maybe another node is running? Shutting down.",Logger.ERROR);
- System.exit(4);
- }
- //Unfortunately the below method doesn't work then the JVM is killed bu the user...
- //However, it looks better if we at least _try_ to clean up after us.
- lockFile.deleteOnExit();
- // locate the data files
- nodeFile = params.getString("nodeFile");
- if (nodeFile == null || nodeFile.length()==0) {
- File f = new File("node_" + listenPort);
- nodeFile = "node";
- if (f.exists()) {
- if (!f.renameTo(new File(nodeFile))) {
- logger.log(
- Node.class,
- "Cannot rename "
- + f
- + " to \"node\". This would be useful "
- + " because then you could change the port "
- + " without causing the node identity to"
- + " disappear, taking with it all references to"
- + " your node from the rest of the network.",
- Logger.NORMAL);
- nodeFile = "node_" + listenPort;
- }
- }
- }
- // set admin permisions
- String pword = params.getString("adminPassword");
- if (!"".equals(pword))
- adminPassword = pword;
- FieldSet peer = params.getSet("adminPeer");
- if (peer != null) {
- adminPeer = new DSAIdentity(peer);
- }
- overloadLow = params.getFloat("overloadLow");
- overloadHigh = params.getFloat("overloadHigh");
- if(overloadHigh < 1.0) {
- Core.logger.log(Main.class, "overloadHigh set to "+nfp.format(overloadHigh)+
- " - this will NOT WORK with rate limiting", Logger.ERROR);
- overloadHigh = overloadHighDefault;
- }
- doRequestTriageByDelay = params.getBoolean("doRequestTriageByDelay");
- doRequestTriageBySendTime =
- params.getBoolean("doRequestTriageBySendTime");
- requestDelayCutoff = params.getInt("requestDelayCutoff");
- successfulDelayCutoff = params.getInt("successfulDelayCutoff");
- requestSendTimeCutoff = params.getInt("requestSendTimeCutoff");
- successfulSendTimeCutoff = params.getInt("successfulSendTimeCutoff");
- defaultResetProbability = params.getDouble("defaultResetProbability");
- lsMaxTableSize = params.getInt("lsMaxTableSize");
- lsAcceptRatioSamples = params.getInt("lsAcceptRatioSamples");
- lsHalfLifeHours = params.getDouble("lsHalfLifeHours");
- doOutLimitCutoff = params.getBoolean("doOutLimitCutoff");
- outLimitCutoff = params.getFloat("outLimitCutoff");
- doOutLimitConnectCutoff = params.getBoolean("doOutLimitConnectCutoff");
- outLimitConnectCutoff = params.getFloat("outLimitConnectCutoff");
- threadConnectCutoff = params.getFloat("threadConnectCutoff");
- doCPULoad = params.getBoolean("doCPULoad");
- sendingQueueLength = params.getInt("sendingQueueLength");
- sendingQueueBytes = params.getInt("sendingQueueBytes");
- doLoadBalance = params.getBoolean("doLoadBalance");
- localIsOK = params.getBoolean("localIsOK");
- dontLimitClients = params.getBoolean("dontLimitClients");
- mainportURIOverride = params.getString("mainportURIOverride");
- distributionURIOverride = params.getString("distributionURIOverride");
- aggressiveGC = params.getInt("aggressiveGC");
- configUpdateInterval = params.getInt("configUpdateInterval");
- seednodesUpdateInterval = params.getInt("seednodesUpdateInterval");
- distributionPort = params.getInt("distribution.port");
- fproxyPort = params.getInt("mainport.port");
- filterPassThroughMimeTypes =
- params.getString("filterPassThroughMimeTypes");
- httpInserts = params.getBoolean("httpInserts");
- fcpInserts = params.getBoolean("fcpInserts");
- defaultToSimpleUIMode = params.getBoolean("defaultToSimpleUIMode");
- defaultToOCMHTMLPeerHandlerMode =
- params.getBoolean("defaultToOCMHTMLPeerHandlerMode");
- uiTemplateSet = params.getString("UITemplateSet");
- logOutputBytes = params.getBoolean("logOutputBytes");
- logInputBytes = params.getBoolean("logInputBytes");
- freenet.support.servlet.HtmlTemplate.defaultTemplateSet = uiTemplateSet;
- // If we are in watchme mode, initialize watchme and change the
- // protocol
- // version to prevent spy nodes from polluting the real network
- if (params.getBoolean("watchme")) {
- watchme = new WatchMe();
- watchme.init(params.getInt("watchmeRetries"));
- Version.protocolVersion = Version.protocolVersion + "wm";
- freenet.session.FnpLink.AUTH_LAYER_VERSION = 0x05;
- }
- // Around 1000 seconds.
- // This is the time it would take for a request to start and finish
- // at 1kB/sec.
- // As of 29/7/04, this is relatively rare.
- // So we have a less-alchemical way of setting it, than just "5 minutes sounds good" :).
- rateLimitingInterval = 800*1000 + getRandSource().nextInt(400*1000);
- }
- /**
- * Construct this node's NodeReference from the given private key.
- */
- static NodeReference makeNodeRef(
- Authentity priv,
- Address[] addr,
- SessionHandler sh,
- PresentationHandler ph,
- long ARKversion,
- byte[] ARKcrypt) {
- long[] sessions, presentations;
- Enumeration e;
- sessions = new long[sh.size()];
- e = sh.getLinkManagers();
- for (int i = 0; i < sessions.length; ++i)
- sessions[i] = ((LinkManager) e.nextElement()).designatorNum();
- presentations = new long[ph.size()];
- e = ph.getPresentations();
- for (int i = 0; i < presentations.length; ++i)
- presentations[i] = ((Presentation) e.nextElement()).designatorNum();
- NodeReference nr =
- new NodeReference(
- priv.getIdentity(),
- addr,
- sessions,
- presentations,
- Version.getVersionString(),
- ARKversion,
- ARKcrypt);
- // FIXME - this method should accept an uncast Authentity
- nr.addSignature((DSAAuthentity) priv);
- return nr;
- }
- /**
- * The Directory that stores all the node's data.
- */
- public final Directory dir;
- /**
- * A source of temp file buckets.
- */
- public final BucketFactory bf;
- /**
- * The nodes table of cached documents.
- */
- public final DataStore ds;
- /**
- * The routing table for routing requests on a key.
- */
- public final NodeSortingRoutingTable rt;
- /**
- * The table of recently failed keys.
- */
- public final FailureTable ft;
- /**
- * Queue manager
- */
- public QueueManager queueManager;
-
- /**
- * Load statistics module.
- */
- public final LoadStats loadStats;
- /**
- * Support for FEC encoding / FEC decoding.
- */
- public static FECTools fecTools = null;
- // REDFLAG: initialize, better interface, i.e make final?
- /**
- * Temp dir for servlets, FEC etc
- */
- public static File tempDir = null;
- // REDFLAG: initialize, better interface, i.e make final?
- /**
- * A node reference to this node. Basically this is who the node is to the
- * network.
- */
- protected NodeReference myRef;
- // FIXME: make protected, use an accessor
- // Only the update-ARK code needs to modify myRef
- public final NodeReference getNodeReference() {
- return myRef;
- }
- public final void setNodeReference(NodeReference newRef) {
- myRef=newRef;
- }
- //A couple of diagnostic variables used in load calculation
- private final RunningAverage routingTimeMinuteAverage;
- private final RunningAverage messageSendTimeRequestMinuteAverage;
- private final IntervalledSum outputBytesLastMinute;
- // Main rate limiting variables
- public ExtrapolatingTimeDecayingEventCounter receivedRequestCounter;
- public ExtrapolatingTimeDecayingEventCounter acceptedExternalRequestCounter;
- RunningAverage globalQuotaAverager;
-
- // Number of outbound requests per minute the node will make.
- static public LimitCounter outboundRequestLimit;
- public ExtrapolatingTimeDecayingEventCounter sentRequestCounter;
-
- /** Watchme (aka test network) functionality */
- public static WatchMe watchme = null;
- /**
- * Internal client access.
- */
- public final ClientFactory client;
- /**
- * Creates a new Node.
- *
- * @param privKey
- * The node's private key.
- * @param dir
- * Directory of the node's storage repository.
- * @param bf
- * The source for temp file buckets.
- * @param ds
- * The store where cached data is kept.
- * @param rt
- * The table for routing requests based on key values.
- * @param ft
- * The table that keeps track recently failed keys.
- * @param myRef
- * The NodeReference name to send to other nodes.
- * @param th
- * A transporthandler on which the available transports are
- * registered.
- * @param sh
- * The sessionhandler to use for making connections
- * @param ph
- * The presentationHandler to use for making connections
- * @param loadStats
- * The restored LoadStats object
- */
- public Node(
- Authentity privKey,
- NodeReference myRef,
- Directory dir,
- BucketFactory bf,
- DataStore ds,
- NodeSortingRoutingTable rt,
- FailureTable ft,
- TransportHandler th,
- SessionHandler sh,
- PresentationHandler ph,
- LoadStats loadStats,
- File routingDir) {
- super(privKey, myRef.getIdentity(), th, sh, ph);
- this.myRef = myRef;
- this.dir = dir;
- this.bf = bf;
- this.ds = ds;
- this.ft = ft;
- this.rt = rt;
- this.client = new InternalClient(this);
-
- this.loadStats = loadStats;
- int ONE_MINUTE_MILLISECONDS_COUNT = 60000; //Just to make my intention somewhat clearer
- //Initialize the routingTime RunningAverage
- RunningAverage r1 = new SimpleIntervalledRunningAverage(ONE_MINUTE_MILLISECONDS_COUNT,100,false);
- routingTimeMinuteAverage = new SynchronizedRunningAverage(r1);
- diagnostics.getExternalContinuousVariable("routingTime").relayReportsTo(routingTimeMinuteAverage,Diagnostics.MEAN_VALUE);
- //Initialize the messageSendTimeRequest average
- messageSendTimeRequestMinuteAverage = new SynchronizedRunningAverage(new SimpleIntervalledRunningAverage(ONE_MINUTE_MILLISECONDS_COUNT,100,false));
- diagnostics.getExternalContinuousVariable("messageSendTimeRequest").relayReportsTo(messageSendTimeRequestMinuteAverage,Diagnostics.MEAN_VALUE);
- //Initialize the outputBytes average
- outputBytesLastMinute = new IntervalledSum(ONE_MINUTE_MILLISECONDS_COUNT);
- diagnostics.getExternalCountingVariable("outputBytes").relayReportsTo(outputBytesLastMinute,Diagnostics.COUNT_CHANGE);
- if(rateLimitingInterval == 0)
- throw new IllegalStateException("Must call init() first!");
-
- rlwc = new RateLimitingWriterCheckpointed(routingDir);
-
- rlwc.load();
- }
- final RateLimitingWriterCheckpointed rlwc;
-
- public void begin(Ticker t,
- OpenConnectionManager ocm, NIOInterface[] inter,
- boolean daemon) throws CoreException {
- connectionOpener =
- new ConnectionOpenerManager(maxNegotiations, rt, ocm, this);
- queueManager = new QueueManager(ocm, (NGRoutingTable)(Main.origRT), t);
- super.begin(t, ocm, inter, daemon);
- }
-
- protected class NodeBackgroundInserter extends BackgroundInserter {
- public NodeBackgroundInserter(
- int nThreads,
- int maxSize,
- ClientFactory cf,
- BucketFactory bf) {
- super(nThreads, maxSize, cf, bf);
- }
- protected void onDone(
- boolean success,
- int htl,
- freenet.client.FreenetURI uri) {
- super.onDone(success, htl, uri);
- logger.log(
- this,
- "Background healing insert: "
- + (success ? "Success: " : "Failure: ")
- + ((uri == null) ? "(null)" : uri.toString()),
- Logger.DEBUG);
- if (success)
- diagnostics.occurrenceCounting("successBackgroundInsert", 1);
- else
- diagnostics.occurrenceCounting("failureBackgroundInsert", 1);
- }
- protected void logDebug(String s, boolean trace) {
- if (logger.shouldLog(Logger.DEBUG,this)) {
- if (trace)
- logger.log(this, s, Logger.DEBUG);
- else
- logger.log(
- this,
- s,
- new Exception("debug"),
- Logger.DEBUG);
- }
- }
- public void queue(
- Bucket block,
- BucketFactory owner,
- int htl,
- String cipher) {
- super.queue(block, owner, htl, cipher);
- if (logger.shouldLog(Logger.MINOR,this))
- logger.log(
- this,
- "Queued a background insert at HTL " + htl,
- Logger.MINOR);
- diagnostics.occurrenceCounting("queuedBackgroundInsert", 1);
- }
- protected void onRawEvent(freenet.client.ClientEvent e) {
- if (logger.shouldLog(Logger.DEBUG,this)) {
- logger.log(
- this,
- "BI: " + e.getDescription(),
- Logger.DEBUG);
- }
- }
- protected void onStart() {
- if (logger.shouldLog(Logger.MINOR,this)) {
- logger.log(
- this,
- "BackgroundInserter -- thread started.",
- Logger.MINOR);
- }
- }
- protected void onExit() {
- if (logger.shouldLog(Logger.MINOR,this)) {
- logger.log(
- this,
- "BackgroundInserter -- thread exited.",
- Logger.MINOR);
- }
- }
- }
- /** @return something for the logs.. */
- public final String toString() {
- return "Freenet Node: " + HexUtil.bytesToHex(identity.fingerprint());
- }
- /**
- * Returns a peer object for which a connection with a node can be made.
- *
- * @param nr
- * The node for which a Peer object is needed.
- */
- public final Peer getPeer(NodeReference nr) {
- return nr.getPeer(transports, sessions, presentations);
- }
- /**
- * @return Number of jobs running or queued for execution by the node's
- * ThreadManager. Can return -1 if no thread manager is being used.
- */
- public final int activeJobs() {
- return threadFactory.activeThreads();
- }
- public final int availableThreads() {
- return threadFactory.availableThreads();
- }
- public ThreadFactory getThreadFactory() {
- return threadFactory;
- }
- /**
- * @return true if the Node is Rejecting inbound connections, false
- * otherwise.
- */
- public boolean rejectingConnections() {
- return rejectingConnections(null);
- }
- public boolean rejectingConnections(StringBuffer why) {
- int maximumThreads = threadFactory.maximumThreads();
- int activeThreads = threadFactory.activeThreads();
- if ((maximumThreads > 0) && threadConnectCutoff > 0 &&
- (activeThreads >= (maximumThreads*threadConnectCutoff))) {
- if (why != null) {
- why.append("activeThreads(");
- why.append(activeThreads);
- why.append(") >= maximumThreads (");
- why.append(maximumThreads);
- why.append(")");
- }
- return true;
- }
- if (diagnostics != null
- && logOutputBytes
- && doOutLimitConnectCutoff
- && obw != null) {
- double sent =
- diagnostics.getCountingValue(
- "outputBytes",
- Diagnostics.MINUTE,
- Diagnostics.COUNT_CHANGE);
- if (Double.isNaN(sent))
- sent = 0.0;
- double limit = outputBandwidthLimit * 60 * outLimitConnectCutoff;
- if (sent > limit) {
- if (nextLoggedRejectingConns < System.currentTimeMillis()) {
- logger.log(
- this,
- "Rejecting connections because bwlimit exceeded by 200%!",
- Logger.NORMAL);
- nextLoggedRejectingConns =
- System.currentTimeMillis() + 60000;
- }
- if (why != null) {
- why.append("outputBytesPerMinute(");
- why.append(nf1.format(sent));
- why.append(") > outLimitConnectCutoff(");
- why.append(nf1.format(outLimitConnectCutoff));
- why.append(") * outputBandwidthLimit(");
- why.append(nf1.format(outputBandwidthLimit));
- why.append(") * 60 = ");
- why.append(nf1.format(limit));
- }
- return true; // Reject connections - emergency bwlimiting
- }
- }
- if (diagnostics != null && doRequestTriageByDelay) {
- double delay = routingTimeMinuteAverage.currentValue();
- if (Double.isNaN(delay))
- delay = 0.0;
- if (delay > successfulDelayCutoff) {
- if (why != null) {
- why.append("avgRoutingTime(");
- why.append(nf3.format(delay));
- why.append(") > successfulDelayCutoff(");
- why.append(nf3.format(successfulDelayCutoff) + ")");
- }
- return true;
- }
- }
- if (diagnostics != null && doRequestTriageBySendTime) {
- double delay = messageSendTimeRequestMinuteAverage.currentValue();
- if (Double.isNaN(delay))
- delay = 0.0;
- if (delay > successfulSendTimeCutoff) {
- if (why != null) {
- why.append("avgMessageSendTimeRequest(");
- why.append(nf3.format(delay));
- why.append(") > successfulSendTimeCutoff(");
- why.append(nf3.format(successfulSendTimeCutoff));
- why.append(")");
- }
- return true;
- }
- }
- return false;
- }
- long nextLoggedRejectingConns = 0;
- /**
- * @param all
- * if true, only return true if the node is rejecting nearly all
- * incoming reqs
- * @return true if the Node is QueryRejecting inbound requests, false
- * otherwise.
- */
- public boolean rejectingRequests(boolean all) {
- return rejectingRequests(null, all);
- }
- public boolean rejectingRequests(StringBuffer why, boolean all) {
- if (outboundRequestLimit != null && outboundRequestLimit.exceeded()) {
- if (why != null) {
- why.append("outboundRequestLimit exceeded.");
- }
- return true;
- }
- float estimatedLoad = estimatedLoad(false);
- if (estimatedLoad > (all ? overloadHigh : overloadLow)) {
- if (why != null) {
- why.append("Estimated load (");
- why.append(nfp.format(estimatedLoad));
- why.append(") > overload" + (all ? "High" : "Low") + " (");
- why.append(nfp.format(all ? overloadHigh : overloadLow));
- why.append(")");
- }
- return true;
- }
- return false;
- }
- static class TickStat {
- long user;
- long nice;
- long system;
- long spare;
- boolean read(File f) {
- String firstline;
- try {
- FileInputStream fis = new FileInputStream(f);
- ReadInputStream ris = new ReadInputStream(fis);
- firstline = ris.readln();
- ris.close();
- } catch (IOException e) {
- return false;
- }
- logger.log(this, "Read first line: " + firstline, Logger.DEBUG);
- if(!firstline.startsWith("cpu")) return false;
- long[] data = new long[4];
- for(int i = 0; i < 4; i++) {
- firstline = firstline.substring("cpu".length()).trim();
- firstline = firstline + ' ';
- int x = firstline.indexOf(' ');
- if(x == -1)
- return false;
- String firstbit = firstline.substring(0, x);
- try {
- data[i] = Long.parseLong(firstbit);
- } catch (NumberFormatException e) {
- return false;
- }
- firstline = firstline.substring(x);
- }
- user = data[0];
- nice = data[1];
- system = data[2];
- spare = data[3];
- logger.log(this, "Read from file: user " + user + " nice " + nice + " system " +system + " spare " + spare, Logger.DEBUG);
- return true;
- }
- int calculate(TickStat old) {
- long userdiff = user - old.user;
- long nicediff = nice - old.nice;
- long systemdiff = system - old.system;
- long sparediff = spare - old.spare;
- if (userdiff + nicediff + systemdiff + sparediff <= 0)
- return 0;
- logger.log(this, "User changed by " + userdiff + ", Nice: " + nicediff + ", System: " + systemdiff + ", Spare: " + sparediff, Logger.DEBUG);
- int usage = (int) ((100 * (userdiff + nicediff + systemdiff)) / (userdiff + nicediff + systemdiff + sparediff));
- logger.log(this, "CPU usage: " + usage, Logger.DEBUG);
- return usage;
- }
- void copyFrom(TickStat old) {
- user = old.user;
- nice = old.nice;
- system = old.system;
- spare = old.spare;
- }
- }
- int lastCPULoadEstimate = 0;
- long lastCPULoadEstimateTime = 0;
- File proc = File.separator.equals("/") ? new File("/proc/stat") : null;
- TickStat tsOld = new TickStat();
- TickStat tsNew = null;
- float lastEstimatedLoad = 0;
- float lastEstimatedRateLimitingLoad = 0;
- long lastCalculatedEstimatedLoad = -1;
- long lastCalculatedRateLimitingLoad = -1;
- long minLoadEstimationInterval = 1000; // 1 second
- Object loadSync = new Object();
-
- /**
- * This is a rough estimate based on the number of running jobs. Hopefully
- * we can come up with a better metric later.
- *
- * @param forRateLimiting if true, return the rate limiting load, if false,
- * return the QueryReject load
- * @return a value between (0.0, 1.0), where 0.0 indicates no load and 1.0
- * indicates total overload.
- *
- */
- public final float estimatedLoad(boolean forRateLimiting) {
- return estimatedLoad(null, forRateLimiting);
- }
- public final float estimatedLoad(StringBuffer why, boolean forRateLimiting) {
- double ret;
- long now = System.currentTimeMillis();
- if(why == null) {
- synchronized(loadSync) {
- long last = forRateLimiting ? lastCalculatedRateLimitingLoad :
- lastCalculatedEstimatedLoad;
- if(last + minLoadEstimationInterval > now) {
- return forRateLimiting ? lastEstimatedRateLimitingLoad :
- lastEstimatedLoad;
- }
- }
- }
-
- // FIXME: make it proportional?
- // FIXME: get rid?
- if (outboundRequestLimit != null && outboundRequestLimit.exceeded()) {
- if (why != null) {
- why.append(
- "Load = 100% because outboundRequestLimit is exceeded.");
- }
- return 1.0F;
- }
- // Thread load
- int maximumThreads = threadFactory.maximumThreads();
- if (maximumThreads <= 0) {
- ret = 0.0;
- if (why != null) {
- why.append(
- "Load due to thread limit = 0% because maximumThreads <= 0");
- }
- } else {
- ret = (double) activeJobs() / (double) maximumThreads;
- if (why != null) {
- why.append("Load due to thread limit = ");
- why.append(nfp.format(ret));
- }
- }
- if (doRequestTriageByDelay && forRateLimiting) {
- double delay = routingTimeMinuteAverage.currentValue();
- if (Double.isNaN(delay))
- delay = 0.0;
- double load;
- load = calculateLoadForUnit("routingTime", "ms", why, delay,
- requestDelayCutoff, successfulDelayCutoff, forRateLimiting);
-
- if (ret < load)
- ret = load;
- }
- if (doRequestTriageBySendTime && forRateLimiting) {
- double delay = messageSendTimeRequestMinuteAverage.currentValue();
- if (Double.isNaN(delay))
- delay = 0.0;
-
- double load = calculateLoadForUnit("messageSendTimeRequest", "ms", why,
- delay, requestSendTimeCutoff, successfulSendTimeCutoff,
- forRateLimiting);
-
- if (load > overloadLow && ret < load)
- ret = load;
- }
- // by backedOffCount
- //if(Main.origRT instanceof NGRoutingTable && forRateLimiting) {
- // int totnod=((NGRoutingTable)Main.origRT).countConnectedN
- // odes();
- // if(totnod>20) {
- // int openod=((NGRoutingTable)Main.origRT).countUn
- // backedOffNodes();
- // double load=(double)(totnod-openod)/(double)totn
- // od;
- // // multiply by 1/x , where x is the desired percent
- // // of backed off routes. As of 08/26, anything below
- // // about 70% is foolhardy
- // load *= 1.333 ; // target 75% closed (25% open)
- // if (load > overloadLow && ret < load)
- // ret = load;
- // if (why != null) {
- // why.append("<br />Load due to backoff = ");
- // why.append(nfp.format(load));
- // why.append(" (");
- // why.append(openod);
- // why.append(" of ");
- // why.append(totnod);
- // why.append(" backed off)");
- // }
- // }
- //}
- if (logOutputBytes
- && (doOutLimitCutoff || forRateLimiting)
- && outputBandwidthLimit > 0) {
- double sent = getBytesSentLastMinute();
- if (Double.isNaN(sent))
- sent = 0.0;
- // Because high level limiting is primarily to limit trailers,
- // We want outLimitCutoff => 100%, on both measures.
- double limit = outputBandwidthLimit * 60.0 * outLimitCutoff;
-
- if(doReserveOutputBandwidthForSuccess) {
- // Adjust limit to maximum attainable succcess ratio
- double maxRatio = rt.maxPSuccess();
- double actualRatio = Core.diagnostics.getBinomialValue("routingSuccessRatio", Diagnostics.HOUR, Diagnostics.SUCCESS_PROBABILITY);
- Core.logger.log(this, "maxRatio: "+maxRatio+", actualRatio: "+actualRatio,
- Logger.MINOR);
- if((!Double.isInfinite(actualRatio)) && (!Double.isNaN(actualRatio)) &&
- actualRatio > 0.0 && actualRatio <= 1.0 && (!Double.isNaN(maxRatio)) &&
- !Double.isInfinite(maxRatio) && maxRatio > 0.0 && maxRatio <= 1.0) {
- double oldLimit = limit;
- double adjustment = actualRatio / maxRatio;
- if(adjustment < 1.0) limit = limit * adjustment;
- Core.logger.log(this, "Adjusting limit: max ratio="+maxRatio+", actualRatio="+
- actualRatio+", adjustment: "+adjustment+", limit was: "+oldLimit+
- ", limit now: "+limit, Logger.MINOR);
- }
- }
-
- double load = sent / limit;
- if (why != null) {
- why.append("<br />Load due to output bandwidth limiting = ");
- why.append(nfp.format(load));
- why.append(" because outputBytes(");
- why.append(nf03.format(sent));
- why.append(") " + (sent > limit ? ">" : "<=") + " limit (");
- why.append(nf03.format(limit));
- why.append(" ) = outLimitCutoff (");
- why.append(nf03.format(outLimitCutoff));
- why.append(") * outputBandwidthLimit (");
- why.append(nf03.format(outputBandwidthLimit));
- why.append(") * 60");
- }
- if (ret < load)
- ret = load;
- }
- if (doCPULoad && File.separator.equals("/") && forRateLimiting) {
- if (now - lastCPULoadEstimateTime > 1000) {
- try {
- lastCPULoadEstimateTime = now;
- if (tsNew == null) {
- tsOld.read(proc);
- tsNew = new TickStat();
- } else {
- if (!tsNew.read(proc)) {
- logger.log(this, "Failed to parse /proc",
- Logger.MINOR);
- }
- lastCPULoadEstimate = tsNew.calculate(tsOld);
- tsOld.copyFrom(tsNew);
- }
- } catch (Throwable t) {
- lastCPULoadEstimate = 0;
- logger.log(this, "Failed real-CPU-load estimation: "
- + t, t, Logger.NORMAL);
- }
- }
- float f = (float)(((lastCPULoadEstimate) / 100.0F) / 0.75);
- // target 75% cpu usage - FIXME
- if(why != null) {
- why.append("<br />\nLoad due to CPU usage = ");
- why.append(nfp.format(f));
- why.append(" = ");
- why.append(lastCPULoadEstimate);
- why.append("% / 0.75");
- }
-
- if (f > ret) ret = f;
- }
- // Predicted inbound bandwidth load
- if(Main.origRT instanceof NGRoutingTable && forRateLimiting) {
- double sentRequestsHour = sentRequestCounter.getExtrapolatedEventsPerHour();
- double pTransfer = ((NGRoutingTable)Main.origRT).pTransferGivenRequest();
- double stdFileSize = calculateStandardFileSize();
- double bytesExpected = sentRequestsHour * pTransfer *
- stdFileSize;
- double maxBytesPerMinute;
- String reason;
- if(inputBandwidthLimit > 0) {
- maxBytesPerMinute = inputBandwidthLimit * 60;
- reason = " (set input limit) ";
- } else {
- maxBytesPerMinute = tcpConnection.maxSeenIncomingBytesPerMinute();
- reason = " (max observed bytes per minute) ";
- // Assume output is at least as wide as input
- // If this is wrong, set inputBandwidthLimit
- double altMaxBytesPerMinute = outputBandwidthLimit * 60 * 4;
- if(altMaxBytesPerMinute > maxBytesPerMinute) {
- maxBytesPerMinute = altMaxBytesPerMinute;
- reason = " (output limit assumed smaller than input capacity) ";
- }
- }
- double maxBytes = maxBytesPerMinute * (60 * 1.1);
- double myLoad = maxBytes==0?0:bytesExpected / maxBytes;
- if(ret < myLoad) ret = myLoad;
- if(why != null) {
- why.append("<br />\nLoad due to expected inbound transfers: ");
- why.append(nfp.format(myLoad));
- why.append(" because: ");
- why.append(sentRequestsHour);
- why.append(" req/hr * ");
- why.append(pTransfer);
- why.append(" (pTransfer) * ");
- why.append(stdFileSize);
- why.append(" bytes = ");
- why.append((long)bytesExpected);
- why.append(" bytes/hr expected from current requests, but maxInputBytes/minute = ");
- why.append((long)maxBytesPerMinute);
- why.append(reason);
- why.append(" * 60 * 1.1 = ");
- why.append((long)maxBytes);
- why.append(" bytes/hr target");
- }
- }
- // Predicted outbound bandwidth load
- if(Main.origRT instanceof NGRoutingTable && forRateLimiting &&
- outputBandwidthLimit > 0 && acceptedExternalRequestCounter.countEvents() > 10) {
- double receivedRequestsHour = acceptedExternalRequestCounter.getExtrapolatedEventsPerHour();
- double pTransfer = ((NGRoutingTable)Main.origRT).pTransferGivenInboundRequest();
- double stdFileSize = calculateStandardFileSize();
- double bytesExpected = receivedRequestsHour * pTransfer *
- stdFileSize;
- double maxBytesPerMinute;
- maxBytesPerMinute = outputBandwidthLimit * 60 * 0.7; // assume significant overhead
- double maxBytes = maxBytesPerMinute * 60;
- double myLoad = maxBytes==0?0:bytesExpected / maxBytes;
- if(ret < myLoad) ret = myLoad;
- if(why != null) {
- why.append("<br />\nLoad due to expected outbound transfers: ");
- why.append(nfp.format(myLoad));
- why.append(" because: ");
- why.append(receivedRequestsHour);
- why.append(" req/hr * ");
- why.append(pTransfer);
- why.append("(");
- why.append(((NGRoutingTable)Main.origRT).whyPTransferGivenInboundRequest());
- why.append(") (pTransfer) * ");
- why.append(stdFileSize);
- why.append(" bytes = ");
- why.append((long)bytesExpected);
- why.append(" bytes/hr expected from current requests, but maxOutputBytes/minute = ");
- why.append((long)maxBytesPerMinute);
- why.append(" * 60 = ");
- why.append((long)maxBytes);
- why.append(" bytes/hr target");
- }
- }
- // if(forRateLimiting) {
- // // Propagation
- // double outgoingRequestRate = sentRequestCounter.getExtrapolatedEventsPerHour();
- // double incomingRequestRate = acceptedExternalRequestCounter.getExtrapolatedEventsPerHour();
- // /**
- // * Don't use it until we have received a certain number of requests.
- // * Otherwise fetches on startup will cause MAJOR problems.
- // */
- // if(acceptedExternalRequestCounter.countEvents() > 10) {
- // double myLoad = outgoingRequestRate / incomingRequestRate;
- // if(ret < myLoad) ret = myLoad;
- // if(why != null) {
- // why.append("<br />Load due to propagation = ");
- // why.append(nfp.format(myLoad));
- // why.append(" = ");
- // why.append(outgoingRequestRate);
- // why.append(" / ");
- // why.append(incomingRequestRate);
- // }
- // }
- // }
- //
- // // Backoff load
- // if (forRateLimiting) {
- // double meanLogBackoffLoad = Core.diagnostics.getContinuousValue("logBackoffLoad", Diagnostics.MINUTE, Diagnostics.MEAN_VALUE);
- // if(!(Double.isNaN(meanLogBackoffLoad))) {
- // double estBackoffLoad = Math.exp(meanLogBackoffLoad);
- // if(estBackoffLoad > ret) ret = estBackoffLoad;
- // if(why != null) {
- // why.append("<br />\nLoad due to backoff: ");
- // why.append(nfp.format(estBackoffLoad));
- // why.append(" = e^");
- // why.append(meanLogBackoffLoad);
- // why.append(" (average logBackoffLoad)");
- // }
- // }
- // }
-
- // Allow >100% load either way
- // if ((!forRateLimiting) && ret > 1.0f) {
- // ret = 1.0f;
- // }
- synchronized(loadSync) {
- now = System.currentTimeMillis();
- if(forRateLimiting) {
- lastEstimatedRateLimitingLoad = (float) ret;
- lastCalculatedRateLimitingLoad = now;
- } else {
- lastEstimatedLoad = (float) ret;
- lastCalculatedEstimatedLoad = now;
- }
- }
-
- return (float) ret;
- }
- private double calculateLoadForUnit(String name, String units, StringBuffer why,
- double delay, int delayCutoff, int successCutoff,
- boolean forRateLimiting) {
- double load;
- double denom = successCutoff - delayCutoff;
- if(forRateLimiting) {
- load = delay / delayCutoff;
- } else {
- load = overloadLow
- + (1 - overloadLow)
- * (delay - delayCutoff)
- / (denom == 0.0 ? 1.0 : denom);
- }
- if (why != null) {
- why.append("<br />\nLoad due to "+name+" = ");
- why.append(nfp.format(load) + " = ");
- if(forRateLimiting) {
- why.append((int)delay + units + " / " +
- delayCutoff + units);
- why.append(load > overloadLow ? " > " : " <= ");
- why.append("overloadLow (");
- why.append(nfp.format(overloadLow));
- } else {
- why.append(
- nfp.format(overloadLow)
- + " + "
- + nfp.format(1 - overloadLow)
- + " * ("
- + nf3.format(delay)
- + units
- + " - "
- + nf3.format(delayCutoff)
- + units
- + ") / "
- + nf3.format(denom)
- + units);
- }
- why.append(")");
- }
- return load;
- }
- double lastGlobalQuota;
- long lastGlobalQuotaTime;
- Object lastGlobalQuotaSync = new Object();
-
- /**
- * @return the target total number of queries per hour that the
- * node can handle, based on the current load and traffic levels.
- * If load is zero returns positive infinity.
- */
- public double getGlobalQuota() {
- /** Cache it for 2 reasons:
- * 1. Save CPU usage.
- * 2. Make the averages more or less averages over time, rather than
- * being biased by message send rates.
- */
- synchronized(lastGlobalQuotaSync) {
- if(System.currentTimeMillis() < lastGlobalQuotaTime + 5000)
- return lastGlobalQuota;
- }
- // First calculate the total number of queries received per hour
- // This is a kind of average, necessarily...
- double requestsPerHour = receivedRequestCounter.getExtrapolatedEventsPerHour();
- Core.diagnostics.occurrenceContinuous("estimatedIncomingRequestsPerHour",
- requestsPerHour);
- if(Double.isInfinite(requestsPerHour)) {
- return Double.POSITIVE_INFINITY;
- }
- double load = estimatedLoad(true);
- /** DO NOT average load.
- * Why?
- * If an external stimulus causes a slightly increased load for
- * a while, and traffic starts to fall, and then the external stimulus
- * is taken away, traffic will CONTINUE FALLING for as long as it
- * takes for the load average to come back down to below 1.0.
- */
- Core.diagnostics.occurrenceContinuous("rateLimitingLoad", load);
- // try {
- // loadAverager.report(rawLoad);
- // } catch (IllegalArgumentException e) {
- // logger.log(this, "Caught exception reporting load to load averager",e,
- // Logger.NORMAL);
- // }
- // double load = loadAverager.currentValue();
- // Core.diagnostics.occurrenceContinuous("rateLimitingLoad", load);
- if(load == 0.0) return Double.POSITIVE_INFINITY;
- double ret = requestsPerHour / load;
- Core.diagnostics.occurrenceContinuous("globalQuotaPerHourRaw", ret);
- // Now clip it to the maximum the link can sustain
- double wasGlobalQuota = ret;
- double maxGlobalQuota = getMaxGlobalQuota();
- if(ret > maxGlobalQuota) ret = maxGlobalQuota;
- logger.log(this, "getGlobalQuota(): requests per hour: "+
- requestsPerHour+", load: "+load+
- ", raw globalQuota="+wasGlobalQuota+", maxGlobalQuota="+
- maxGlobalQuota+", unaveraged globalQuota="+ret, Logger.MINOR);
- // Now we DEFINITELY need to average the output
- globalQuotaAverager.report(ret);
- ret = globalQuotaAverager.currentValue();
- Core.diagnostics.occurrenceContinuous("globalQuotaPerHour", ret);
- logger.log(this, "getGlobalQuota() returning "+ret, Logger.MINOR);
- synchronized(lastGlobalQuotaSync) {
- lastGlobalQuota = ret;
- lastGlobalQuotaTime = System.currentTimeMillis();
- }
- return ret;
- }
-
- /**
- * @return the upper limit on the globalQuota, calculated from
- * the output and input bandwidth limits.
- */
- public double getMaxGlobalQuota() {
- int limit = 0;
- if(outputBandwidthLimit > 0) limit = outputBandwidthLimit;
- if(inputBandwidthLimit > 0 && inputBandwidthLimit < outputBandwidthLimit)
- limit = inputBandwidthLimit;
- if(limit > 0) {
- double pTransfer = ((NGRoutingTable)Main.origRT).pTransferGivenInboundRequest();
- double maxGlobalQuota = (limit * 60 * 60) /
- (calculateStandardFileSize() * pTransfer);
- return maxGlobalQuota;
- }
- return Double.MAX_VALUE;
- }
- private void accept(
- Key searchKey,
- int hopsToLive,
- String diagAddr,
- String verstr) {
- if (inboundRequests != null && diagAddr != null) {
- inboundRequests.incSuccesses(diagAddr);
- }
- acceptedExternalRequestCounter.logEvent();
- }
- private void reject(
- Key searchKey,
- int hopsToLive,
- String diagAddr,
- String verstr) {
- // Do nothing
- }
- private static final int DEFAULT_FILE_SIZE = 350000;
- // typical value 13/3/04
- public static long calculateStandardFileSize(Node node) {
- if (node == null)
- return DEFAULT_FILE_SIZE;
- else return node.calculateStandardFileSize();
- }
-
- long lastCalculatedStandardFileSizeTime = -1;
- private boolean isRecalculatingStandardFileSize = false;
- long lastStandardFileSize = 0;
- private final Object fileSizeTimestampSync = new Object();
-
- //Takes a shot on calculating a mean network file size
- //falls back to 128k if insufficent data is available or this NGRT is
- //unable to ask the store (== if this NGRT doesn't know what node it is
- // used in)
- public long calculateStandardFileSize() {
- long now = System.currentTimeMillis();
- //Avoid contention for the lastUpdatedNewNodeStatsLock lock if possible
- if (isRecalculatingStandardFileSize || now - lastCalculatedStandardFileSizeTime < 60*1000)
- return lastStandardFileSize;
-
- //Then test again, holding the proper lock, just to be _sure_ that we should run
- synchronized(fileSizeTimestampSync){
- if (isRecalculatingStandardFileSize || now - lastCalculatedStandardFileSizeTime < 60*1000)
- return lastStandardFileSize;
- isRecalculatingStandardFileSize = true;
- }
- try{
- long keys = dir.countKeys();
- if (keys > 16) {
- lastStandardFileSize = dir.used() / keys;
- lastCalculatedStandardFileSizeTime = now;
- return lastStandardFileSize;
- } else
- return DEFAULT_FILE_SIZE;
- }finally{
- lastCalculatedStandardFileSizeTime = now;
- isRecalculatingStandardFileSize = false;
- }
- }
- public void logRequest(Key k) {
- receivedRequestCounter.logEvent();
- }
-
- /**
- * Hook for rate limiting.
- */
- public boolean acceptRequest(
- Key searchKey,
- int hopsToLive,
- Address source,
- String verstr) {
- String diagAddr = null;
- if (inboundRequests != null) {
- if (source != null) {
- diagAddr = source.toString();
- inboundRequests.incTotal(diagAddr);
- inboundRequests.setLastVersion(diagAddr, verstr);
- }
- }
- float load = estimatedLoad(false);
- if ((outboundRequestLimit == null
- || (!outboundRequestLimit.exceeded()))
- && load < overloadLow) {
- accept(searchKey, hopsToLive, diagAddr, verstr);
- return true;
- }
- // Node is loaded
- if (load < overloadHigh) {
- if (searchKey != null
- && ds.contains(searchKey)) {
- accept(searchKey, hopsToLive, diagAddr, verstr);
- return true;
- } else {
- // Give the request another chance
- // 0.0 = (almost) always accept
- // 1.0 = (almost) never accept
- double rankFraction;
- if (Main.origRT instanceof NGRoutingTable &&
- searchKey != null) {
- /** Selective request accept/reject, based on estimate.
- * a.k.a. unobtanium accept.
- *
- * We want to accept the top x% of incoming requests, where
- * x depends on load, by their estimates (lower is better).
- *
- * So we route the request and see what the estimate is for
- * the first node on the list.
- */
- NGRouting routes = (NGRouting) (Main.origRT.route(searchKey, hopsToLive, calculateStandardFileSize(),
- /* searchKey.getExpectedTransmissionLength(), */ //Don't bias the estimate with the size of the key
- false, false, false, false, false));
- if (routes.getNextRoute() == null) {
- // Sh*t happens
- // No currently contactable nodes we could route to
- rankFraction = Math.random();
- logger.log(this, "Initial getNextRoute() call during load calculation returned no estimate, using random value "
- + "for rankFraktion, routes=" + routes, Logger.MINOR);
- } else {
- double estimate = routes.lastEstimatedTime();
- routes.terminateNoDiagnostic();
- rankFraction = getRankFraction(estimate);
- if(logger.shouldLog(Logger.DEBUG, this))
- logger.log(this, "Unobtanium: key=" + searchKey + ", hopsToLive=" + hopsToLive + " -> estimate: " + estimate
- + " -> rank: " + rankFraction, Logger.MINOR);
- }
- } else {
- rankFraction = Math.random();
- }
- // If loadThreshold is higher than load, reject
- // Therefore loadThreshold high = accept more requests
- double loadThreshold =
- overloadLow + (1.0-rankFraction) * (overloadHigh - overloadLow);
-
- logger.log(
- this,
- "Unobtanium: "
- + (load <= loadThreshold ? "ACCEPTING" : "REJECTING")
- + " load threshold = "
- + loadThreshold
- + ", load="
- + load
- + ", rank="
- + rankFraction,
- Logger.MINOR);
-
- if (load <= loadThreshold) {
- accept(searchKey, hopsToLive, diagAddr, verstr);
- return true;
- }
-
- }
- reject(searchKey, hopsToLive, diagAddr, verstr);
- return false;
- }
- // Over overloadHigh, we don't accept ANYTHING
-
- reject(searchKey, hopsToLive, diagAddr, verstr);
- // Node is overloaded
- return false;
- }
- protected Object selectiveAcceptRankingSync = new Object();
- protected final int SELECTIVE_ACCEPT_REQUESTS = 100;
- protected Comparable[] selectiveAcceptList =
- new Comparable[SELECTIVE_ACCEPT_REQUESTS];
- protected int selectiveAcceptListPosition = 0;
- /**
- * Return the rank of the request by estimate in a list of recent requests
- *
- * @param estimate
- * @return rank between 0.0 and 1.0. 1.0=estimate is higher than any in
- * list. 0.0=estimate is lower than any in list.
- */
- private double getRankFraction(double estimate) {
- return getRankFraction(new Double(estimate));
- }
- private double getRankFraction(Comparable estimate) {
- if (estimate == null) return 0.0;
- int requestsBelow = 0;
- int curLength = 0;
- synchronized (selectiveAcceptRankingSync) {
- // Iterate the list
- // We want to find:
- // A) the number of items in the list
- // B) the number of items with estimates lower than that of the
- // estimate
- for (curLength = 0;
- curLength < SELECTIVE_ACCEPT_REQUESTS;
- curLength++) {
- Comparable cur = selectiveAcceptList[curLength];
- if (cur == null)
- break;
- if (cur.compareTo(estimate) < 0)
- requestsBelow++;
- }
- selectiveAcceptList[selectiveAcceptListPosition] = estimate;
- selectiveAcceptListPosition++;
- selectiveAcceptListPosition %= SELECTIVE_ACCEPT_REQUESTS;
- }
- if (curLength == 0)
- return 0.0;
- return ((double) requestsBelow) / ((double) curLength);
- }
- //=== communications methods
- // ===============================================
- // /**
- // * Returns a connection that messages can be sent on. This saves a little
- // * time as getPeer is only called if a free connection isn't available.
- // *
- // * @param nr
- // * The node to connect to.
- // * @param timeout
- // * The time to allow in connecting.
- // */
- // public ConnectionHandler makeConnection(NodeReference nr, long timeout)
- // throws CommunicationException {
- // Peer p = getPeer(nr);
- // if (p == null)
- // throw new ConnectFailedException(new VoidAddress(), nr.getIdentity(),
- // "Unusable node ref", true);
- // return makeConnection(p, timeout);
- // }
- // public final ConnectionHandler makeConnection(NodeReference nr)
- // throws CommunicationException {
- // return makeConnection(nr, 0);
- // }
- /**
- * Sends a message accross an open or new connection. This saves a little
- * time as getPeer is only called if a free connection isn't available.
- *
- * @param nr
- * The node to connect to.
- * @param m
- * The message to send.
- * @param timeout
- * The time to allow in connecting.
- * @return The trailing field stream (if there is one).
- */
- public final TrailerWriter sendMessage(
- Message m,
- NodeReference nr,
- long timeout)
- throws SendFailedException {
- return connections.sendMessage(
- m,
- nr.getIdentity(),
- nr,
- timeout,
- PeerPacketMessage.NORMAL,
- presentations.getDefault());
- }
- /**
- * Sends a message accross an open or new connection. This saves a little
- * time as getPeer is only called if a free connection isn't available.
- *
- * @param id
- * The node to connect to.
- * @param m
- * The message to send.
- * @param timeout
- * The time to allow in connecting.
- * @return The trailing field stream (if there is one).
- */
- public final TrailerWriter sendMessage(
- Message m,
- Identity id,
- long timeout)
- throws SendFailedException {
- return connections.sendMessage(
- m,
- id,
- null,
- timeout,
- PeerPacketMessage.NORMAL,
- presentations.getDefault());
- }
-
-
- /**
- * Send a message, asynchronously
- *
- * @param m
- * the message
- * @param p
- * the peer
- * @param msgPrio
- * the priority of the message, see PeerHandler
- * @param timeout -
- * number of milliseconds after which the send will be dropped.
- * @param cb
- * callback to be called when the message send has completed
- * (successfully or not) - null if no notification is needed.
- */
- public final void sendMessageAsync(
- Message m,
- Peer p,
- int msgPrio,
- long timeout,
- MessageSendCallback cb) {
- connections.sendMessageAsync(
- m,
- p.getIdentity(),
- null,
- cb,
- timeout,
- msgPrio);
- }
- public final void sendMessageAsync(
- Message m,
- Peer p,
- long timeout,
- MessageSendCallback cb) {
- connections.sendMessageAsync(
- m,
- p.getIdentity(),
- null,
- cb,
- timeout,
- PeerPacketMessage.NORMAL);
- }
- public final void sendMessageAsync(
- Message m,
- NodeReference nr,
- long timeout,
- MessageSendCallback cb) {
- connections.sendMessageAsync(
- m,
- nr.getIdentity(),
- nr,
- cb,
- timeout,
- PeerPacketMessage.NORMAL);
- }
- public final void sendMessageAsync(
- Message m,
- Identity id,
- long timeout,
- MessageSendCallback cb) {
- connections.sendMessageAsync(
- m,
- id,
- null,
- cb,
- timeout,
- PeerPacketMessage.NORMAL);
- }
- public final void sendMessageAsync(
- Message m,
- Identity id,
- int msgPrio,
- long timeout,
- MessageSendCallback cb) {
- connections.sendMessageAsync(m, id, null, cb, timeout, msgPrio);
- }
-
- public final void sendMessageAsync(
- Message m,
- NodeReference nr,
- int prio,
- long timeout,
- MessageSendCallback cb) {
- connections.sendMessageAsync(
- m,
- nr.getIdentity(),
- nr,
- cb,
- timeout,
- prio);
- }
- public final void unsendMessage(Identity i, MessageSendCallback cb) {
- connections.unsendMessage(i, cb);
- }
- /**
- * Change the HTL given slightly, randomly, if it is high enough.
- * Use with care. Specifically, because of the 50% chance of not
- * decrementing the HTL at maxHTL, should NOT be used on individual
- * blocks. Otherwise you get a telltale distribution of HTLs which
- * can distinguish between first hop and second hop (i.e. you get
- * equal numbers on 16,17,18,19,20 on the first hop, on the second
- * hop you get half as many on 20 and 19 but equal numbers on 15-18,
- * on the third hop... etc). So only use this for individual
- * requests.
- * @param htl
- * @return
- */
- public static int perturbHTL(int htl) {
- float f = getRandSource().nextFloat();
- Core.logger.log(Node.class, "Perturbing HTL: htl="+htl, Logger.MINOR);
- if (maxHopsToLive == 0) return htl;
- if (htl > 3 && ((float)htl / (float)maxHopsToLive) > 0.5) {
- if(htl > (maxHopsToLive - 2)) htl = (maxHopsToLive - 2);
- Core.logger.log(Node.class, "HTL now "+htl, Logger.MINOR);
- f = getRandSource().nextFloat();
- if (f < 0.2)
- htl += 2;
- else if (f < 0.4)
- htl += 1;
- else if (f < 0.6)
- htl += 0;
- else if (f < 0.8)
- htl -= 1;
- else
- htl -= 2;
- }
- Core.logger.log(Node.class, "HTL now: "+htl, Logger.MINOR);
- if (htl > maxHopsToLive)
- htl = maxHopsToLive;
- return htl;
- }
- public boolean shouldCache(freenet.message.StoreData sd) {
- if (logger == null)
- throw new NullPointerException();
- if (sd == null) {
- logger.log(
- this,
- "shouldCache returning true because sd == null",
- Logger.DEBUG);
- return true;
- }
- logger.log(
- this,
- "shouldCache(" + (sd == null ? "(null)" : sd.toString()) + ")",
- Logger.DEBUG);
- if (storeSize == 0) {
- logger.log(
- this,
- "shouldCache returning true because " + "storeSize == 0",
- Logger.DEBUG);
- return true;
- }
- long used = dir.used();
- long target = (long) (storeSize * (double) minStoreFullPCache);
- if (used < target) {
- logger.log(
- this,
- "shouldCache returning true because "
- + "used space ("
- + used
- + ") < target ("
- + target
- + ") "
- + "out of maximum "
- + storeSize,
- Logger.DEBUG);
- return true;
- }
- if (sd.shouldCache(getRandSource(), cacheProbPerHop)) {
- logger.log(
- this,
- "shouldCache returning true because "
- + "sd.shouldCache says so for "
- + sd,
- Logger.DEBUG);
- return true;
- } else {
- logger.log(
- this,
- "shouldCache returning false because "
- + "sd.shouldCache says so for "
- + sd,
- Logger.DEBUG);
- return false;
- }
- }
- public boolean shouldReference(
- NodeReference nr,
- freenet.message.StoreData sd) {
- return rt.shouldReference(nr, sd);
- }
- /**
- * Add a reference for a node.
- *
- * @param nr
- * the reference to be added to the routing table
- * @param k
- * the key this resulted from, which may be ignored by the RT
- * @param estimator
- * FieldSet of initial estimator, or null
- */
- public void reference(Key k, Identity id,
- NodeReference nr, FieldSet estimator) {
- boolean logDEBUG = logger.shouldLog(Logger.DEBUG, this);
- if(logDEBUG) logger.log(this, "referencing: "+k+", "+nr+", "+
- estimator, Logger.DEBUG);
- if(id == null) id = nr.getIdentity();
- if(id == null) {
- Core.logger.log(this, "Referencing: "+k+","+id+","+nr+","+estimator,
- new Exception("debug"), Logger.ERROR);
- return;
- }
- rt.reference(k, id, nr, estimator);
- if(logDEBUG) logger.log(this, "adding peer for: "+id+": "+ nr,
- Logger.DEBUG);
- connections.makePeerHandler(id, nr, presentations.getDefault());
- if(logDEBUG) logger.log(this, "scheduling connection open: "+id+
- ": "+nr, Logger.DEBUG);
- connectionOpener.rescheduleNow();
- if(logDEBUG) logger.log(this, "Referenced "+k+": "+nr+": "+
- estimator, Logger.DEBUG);
- }
- /**
- * Create ConnectionOpeners to open connections to all nodes in the RT,
- * called on startup. Also creates PeerHandlers for each.
- */
- public void scheduleOpenAllConnections() {
- logger.log(this, "Scheduling open on all connections", Logger.MINOR);
- RTDiagSnapshot snap =
- rt.getSnapshot(true);
- IdRefPair[] nodes = snap.getIdRefPairs();
- for(int i=0;i<nodes.length;i++)
- connections.makePeerHandler(nodes[i].id, nodes[i].ref,
- presentations.getDefault());
- logger.log(this, "Scheduling open on all "+nodes.length+" connections",
- Logger.MINOR);
- rescheduleConnectionOpener();
- logger.log(this, "Scheduled open on all connections",
- Logger.MINOR);
- }
- public void rescheduleConnectionOpener() {
- if(connectionOpener != null)
- connectionOpener.reschedule();
- }
- public int getMaxPacketLength() {
- if (obw != null)
- return obw.maximumPacketLength();
- else
- return 1492; // fixme
- }
- /**
- * @return
- */
- public int getMaxTrailerChunkSize() {
- if (obw != null) {
- int i = obw.maximumPacketLength();
- i = i / 5;
- /** Impose a minimum:
- * The chunk overhead is 10 bytes
- * Lets say the maximum acceptable overhead is 5%
- * That makes 200 bytes a reasonable minimum.
- */
- if(i < 200) i = 200;
- return i;
- } else {
- return 500;
- }
- }
- long lastReportedRequestInterval = -1;
-
- public double getBytesSentLastMinute()
- {
- return outputBytesLastMinute.currentSum();
- }
- /**
- * @param success whether the request succeeded
- * @param backedOffCount the number of nodes that were tried and unavailable
- * due to backoff or rate limiting, before we reached a node that eventually
- * sent us a DNF or a transfer.
- */
- public void routingRequestEndedWithBackedOffCount(boolean success, int backedOffCount) {
- if(backedOffCount > rtMaxNodes) backedOffCount = rtMaxNodes;
- if(backedOffCount < 0) backedOffCount = 0;
- synchronized(Node.syncCountsByBackoffCount) {
- if(success)
- Node.successesByBackoffCount[backedOffCount]++;
- else
- Node.failuresByBackoffCount[backedOffCount]++;
- }
- }
-
- public String routingResultsByBackoffCount() {
- StringBuffer sb = new StringBuffer();
- synchronized(Node.syncCountsByBackoffCount) {
- sb.append("Backoff count Successes Failures\n");
- for(int i=0;i<=rtMaxNodes;i++) {
- long successes = Node.successesByBackoffCount[i];
- long failures = Node.failuresByBackoffCount[i];
- String s1 = Integer.toString(i);
- sb.append(s1);
- for(int j=0;j<20-s1.length();j++) sb.append(' ');
- s1 = Long.toString(successes);
- sb.append(s1);
- for(int j=0;j<20-s1.length();j++) sb.append(' ');
- s1 = Long.toString(failures);
- sb.append(s1);
- for(int j=0;j<20-s1.length();j++) sb.append(' ');
- sb.append(Double.toString(successes/((double)failures+successes)));
- sb.append('\n');
- }
- }
- return sb.toString();
- }
- /**
- * @return
- */
- public double getActualRequestsPerHour() {
- return receivedRequestCounter.getExtrapolatedEventsPerHour();
- }
- /**
- * @return whether we want a single incoming connection, right now.
- */
- public boolean wantIncomingConnection() {
- // Is the last node in the RT newbie?
- return connections.wantUnkeyedReference();
- }
- /**
- * @return the highest seen build number for nodes of the same
- * type as us. Unlike Version, we actually check that more than
- * one node has this :).
- */
- public int getHighestSeenBuild() {
- return connections.getHighestSeenBuild(this);
- }
- public BackgroundInserter newBackgroundInserter(int i, int j, ClientFactory factory, BucketFactory bf2) {
- return new NodeBackgroundInserter(i,j,factory,bf2);
- }
- /**
- * @return true if this particular request should be routed
- * to the newest node first.
- */
- public static boolean shouldRouteByNewness() {
- return (getRandSource().nextInt(20) == 0);
- }
- /**
- * Get a string-format address for a given identity
- * @param origPeer
- * @return
- */
- public String getStringAddress(Identity origPeer) {
- NodeReference ref = rt.getNodeReference(origPeer);
- if(ref == null) return "(null)";
- return ref.firstPhysicalToString();
- }
- static final int PADDING_CHUNK_SIZE = 160;
-
- /**
- * Pad a packet size up to a reasonable level that minimizes the
- * amount of information given away.
- * For now, lets round to the nearest PADDING_CHUNK_SIZE bytes.
- */
- public static int padPacketSize(int totalLength) {
- if(totalLength % PADDING_CHUNK_SIZE == 0) return totalLength;
- return ((totalLength / PADDING_CHUNK_SIZE) + 1) * PADDING_CHUNK_SIZE;
- }
- public static int minPaddingChunkSize() {
- return PADDING_CHUNK_SIZE;
- }
- public Checkpointed getRateLimitingWriterCheckpoint() {
- return rlwc;
- }
- /**
- * Log a sent request
- */
- public void logOutgoingRequest() {
- sentRequestCounter.logEvent();
- }
- }