refactoring

git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@6390 6c8d7289-2bf4-0310-a012-ef5d649a1542
pull/1/head
orbiter 16 years ago
parent 735e2737e3
commit ea473e32b8

2
debian/changelog vendored

@ -1,4 +1,4 @@
yacy (0.91svn6326) unstable; urgency=low yacy (0.91svn6388) unstable; urgency=low
* SVN Update * SVN Update

@ -76,7 +76,7 @@ public final class Segments implements Iterable<Segment> {
final int entityCacheMaxSize, final int entityCacheMaxSize,
final long maxFileSize, final long maxFileSize,
final boolean useTailCache, final boolean useTailCache,
final boolean exceed134217727) throws IOException { final boolean exceed134217727) {
this.log = log; this.log = log;
this.segmentsPath = segmentsPath; this.segmentsPath = segmentsPath;
this.entityCacheMaxSize = entityCacheMaxSize; this.entityCacheMaxSize = entityCacheMaxSize;
@ -215,7 +215,7 @@ public final class Segments implements Iterable<Segment> {
); );
} }
public synchronized Segment.ReferenceCleaner getReferenceCleaner(final String segmentName, final byte[] startHash) throws IOException { public synchronized Segment.ReferenceCleaner getReferenceCleaner(final String segmentName, final byte[] startHash) {
return segment(segmentName).getReferenceCleaner(startHash); return segment(segmentName).getReferenceCleaner(startHash);
} }

@ -169,17 +169,15 @@ import de.anomic.kelondro.util.MemoryControl;
import de.anomic.kelondro.util.SetTools; import de.anomic.kelondro.util.SetTools;
import de.anomic.net.UPnP; import de.anomic.net.UPnP;
import de.anomic.search.blockrank.CRDistribution; import de.anomic.search.blockrank.CRDistribution;
import de.anomic.server.serverAbstractSwitch; import de.anomic.server.serverSwitch;
import de.anomic.server.serverBusyThread; import de.anomic.server.serverBusyThread;
import de.anomic.server.serverCore; import de.anomic.server.serverCore;
import de.anomic.server.serverDomains; import de.anomic.server.serverDomains;
import de.anomic.server.serverInstantBusyThread; import de.anomic.server.serverInstantBusyThread;
import de.anomic.server.serverObjects;
import de.anomic.server.serverProcessor; import de.anomic.server.serverProcessor;
import de.anomic.server.serverProcessorJob; import de.anomic.server.serverProcessorJob;
import de.anomic.server.serverProfiling; import de.anomic.server.serverProfiling;
import de.anomic.server.serverSemaphore; import de.anomic.server.serverSemaphore;
import de.anomic.server.serverSwitch;
import de.anomic.server.serverSystem; import de.anomic.server.serverSystem;
import de.anomic.server.serverThread; import de.anomic.server.serverThread;
import de.anomic.tools.crypt; import de.anomic.tools.crypt;
@ -200,7 +198,7 @@ import de.anomic.yacy.dht.PeerSelection;
import de.anomic.yacy.logging.Log; import de.anomic.yacy.logging.Log;
import de.anomic.ymage.WebStructureGraph; import de.anomic.ymage.WebStructureGraph;
public final class Switchboard extends serverAbstractSwitch implements serverSwitch { public final class Switchboard extends serverSwitch {
// load slots // load slots
public static int xstackCrawlSlots = 2000; public static int xstackCrawlSlots = 2000;
@ -244,18 +242,18 @@ public final class Switchboard extends serverAbstractSwitch implements serverSwi
public blogBoardComments blogCommentDB; public blogBoardComments blogCommentDB;
public RobotsTxt robots; public RobotsTxt robots;
public boolean rankingOn; public boolean rankingOn;
public CRDistribution rankingOwnDistribution; public CRDistribution rankingOwnDistribution;
public CRDistribution rankingOtherDistribution; public CRDistribution rankingOtherDistribution;
public HashMap<String, Object[]> outgoingCookies, incomingCookies; public HashMap<String, Object[]> outgoingCookies, incomingCookies;
public volatile long proxyLastAccess, localSearchLastAccess, remoteSearchLastAccess; public volatile long proxyLastAccess, localSearchLastAccess, remoteSearchLastAccess;
public yacyCore yc; public yacyCore yc;
public ResourceObserver observer; public ResourceObserver observer;
public userDB userDB; public userDB userDB;
public bookmarksDB bookmarksDB; public bookmarksDB bookmarksDB;
public WebStructureGraph webStructure; public WebStructureGraph webStructure;
public ImporterManager dbImportManager; public ImporterManager dbImportManager;
public ArrayList<QueryParams> localSearches; // array of search result properties as HashMaps public ArrayList<QueryParams> localSearches; // array of search result properties as HashMaps
public ArrayList<QueryParams> remoteSearches; // array of search result properties as HashMaps public ArrayList<QueryParams> remoteSearches; // array of search result properties as HashMaps
public ConcurrentHashMap<String, TreeSet<Long>> localSearchTracker, remoteSearchTracker; // mappings from requesting host to a TreeSet of Long(access time) public ConcurrentHashMap<String, TreeSet<Long>> localSearchTracker, remoteSearchTracker; // mappings from requesting host to a TreeSet of Long(access time)
public long indexedPages = 0; public long indexedPages = 0;
public double requestedQueries = 0d; public double requestedQueries = 0d;
@ -352,37 +350,32 @@ public final class Switchboard extends serverAbstractSwitch implements serverSwi
this.queuesRoot = new File(new File(indexPath, networkName), "QUEUES"); this.queuesRoot = new File(new File(indexPath, networkName), "QUEUES");
this.networkRoot.mkdirs(); this.networkRoot.mkdirs();
this.queuesRoot.mkdirs(); this.queuesRoot.mkdirs();
try { final File mySeedFile = new File(networkRoot, yacySeedDB.DBFILE_OWN_SEED);
final File mySeedFile = new File(networkRoot, yacySeedDB.DBFILE_OWN_SEED); peers = new yacySeedDB(
peers = new yacySeedDB( networkRoot,
networkRoot, "seed.new.heap",
"seed.new.heap", "seed.old.heap",
"seed.old.heap", "seed.pot.heap",
"seed.pot.heap", mySeedFile,
mySeedFile, redundancy,
redundancy, partitionExponent,
partitionExponent, this.useTailCache,
this.useTailCache, this.exceed134217727);
this.exceed134217727); File oldSingleSegment = new File(new File(indexPath, networkName), "TEXT");
File oldSingleSegment = new File(new File(indexPath, networkName), "TEXT"); File newSegmentsPath = new File(new File(indexPath, networkName), "SEGMENTS");
File newSegmentsPath = new File(new File(indexPath, networkName), "SEGMENTS"); Segments.migrateOld(oldSingleSegment, newSegmentsPath, getConfig(SwitchboardConstants.SEGMENT_PUBLIC, "default"));
Segments.migrateOld(oldSingleSegment, newSegmentsPath, getConfig(SwitchboardConstants.SEGMENT_PUBLIC, "default")); indexSegments = new Segments(
indexSegments = new Segments( log,
log, newSegmentsPath,
newSegmentsPath, wordCacheMaxCount,
wordCacheMaxCount, fileSizeMax,
fileSizeMax, this.useTailCache,
this.useTailCache, this.exceed134217727);
this.exceed134217727); crawler = new CrawlSwitchboard(
crawler = new CrawlSwitchboard( peers,
peers, networkName,
networkName, log,
log, this.queuesRoot);
this.queuesRoot);
} catch (IOException e1) {
e1.printStackTrace();
indexSegments = null;
}
// set the default segment names // set the default segment names
indexSegments.setSegment(Segments.Process.RECEIPTS, getConfig(SwitchboardConstants.SEGMENT_RECEIPTS, "default")); indexSegments.setSegment(Segments.Process.RECEIPTS, getConfig(SwitchboardConstants.SEGMENT_RECEIPTS, "default"));
@ -846,17 +839,13 @@ public final class Switchboard extends serverAbstractSwitch implements serverSwi
partitionExponent, partitionExponent,
this.useTailCache, this.useTailCache,
this.exceed134217727); this.exceed134217727);
try { indexSegments = new Segments(
indexSegments = new Segments( log,
log, new File(new File(indexPrimaryPath, networkName), "SEGMENTS"),
new File(new File(indexPrimaryPath, networkName), "SEGMENTS"), wordCacheMaxCount,
wordCacheMaxCount, fileSizeMax,
fileSizeMax, this.useTailCache,
this.useTailCache, this.exceed134217727);
this.exceed134217727);
} catch (IOException e) {
e.printStackTrace();
}
// startup // startup
crawler = new CrawlSwitchboard( crawler = new CrawlSwitchboard(
@ -1817,12 +1806,6 @@ public final class Switchboard extends serverAbstractSwitch implements serverSwi
} }
} }
public serverObjects action(final String actionName, final serverObjects actionInput) {
// perform an action. (not used)
return null;
}
// method for index deletion // method for index deletion
public int removeAllUrlReferences(Segment indexSegment, final yacyURL url, final boolean fetchOnline) { public int removeAllUrlReferences(Segment indexSegment, final yacyURL url, final boolean fetchOnline) {
return removeAllUrlReferences(indexSegment, url.hash(), fetchOnline); return removeAllUrlReferences(indexSegment, url.hash(), fetchOnline);

@ -1,547 +0,0 @@
// serverAbstractSwitch.java
// -------------------------------------
// (C) by Michael Peter Christen; mc@yacy.net
// first published on http://www.anomic.de
// Frankfurt, Germany, 2004, 2005
// last major change: 24.03.2005
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
package de.anomic.server;
import java.io.File;
import java.io.IOException;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import de.anomic.kelondro.util.FileUtils;
import de.anomic.server.serverCore.Session;
import de.anomic.yacy.logging.Log;
public abstract class serverAbstractSwitch implements serverSwitch {
// configuration management
private final File configFile;
private final String configComment;
private final File rootPath;
protected boolean firstInit;
protected Log log;
protected int serverJobs;
private Map<String, String> configProps;
private final Map<String, String> configRemoved;
private final HashMap<InetAddress, String> authorization;
private final TreeMap<String, serverBusyThread> workerThreads;
private final TreeMap<String, serverSwitchAction> switchActions;
private final serverAccessTracker accessTracker;
public serverAbstractSwitch(final File rootPath, final String initPath, final String configPath, final boolean applyPro) {
// we initialize the switchboard with a property file,
// but maintain these properties then later in a new 'config' file
// to reset all changed configs, the config file must
// be deleted, but not the init file
// the only attribute that will always be read from the init is the
// file name of the config file
this.rootPath = rootPath;
this.configComment = "This is an automatically generated file, updated by serverAbstractSwitch and initialized by " + initPath;
final File initFile = new File(rootPath, initPath);
this.configFile = new File(rootPath, configPath); // propertiesFile(config);
firstInit = !configFile.exists(); // this is true if the application was started for the first time
new File(configFile.getParent()).mkdir();
// predefine init's
Map<String, String> initProps;
if (initFile.exists())
initProps = FileUtils.loadMap(initFile);
else
initProps = new HashMap<String, String>();
// if 'pro'-version is selected, overload standard settings with 'pro'-settings
Iterator<String> i;
String prop;
if (applyPro) {
i = new HashMap<String, String>(initProps).keySet().iterator(); // clone the map to avoid concurrent modification exceptions
while (i.hasNext()) {
prop = i.next();
if (prop.endsWith("__pro")) {
initProps.put(prop.substring(0, prop.length() - 5), initProps.get(prop));
}
}
}
// delete the 'pro' init settings
i = initProps.keySet().iterator();
while (i.hasNext()) {
prop = i.next();
if (prop.endsWith("__pro")) {
i.remove();
}
}
// load config's from last save
if (configFile.exists())
configProps = FileUtils.loadMap(configFile);
else
configProps = new HashMap<String, String>();
// remove all values from config that do not appear in init
configRemoved = new HashMap<String, String>();
synchronized (configProps) {
i = configProps.keySet().iterator();
String key;
while (i.hasNext()) {
key = i.next();
if (!(initProps.containsKey(key))) {
configRemoved.put(key, this.configProps.get(key));
i.remove();
}
}
// doing a config settings migration
//HashMap migratedSettings = migrateSwitchConfigSettings((HashMap) removedProps);
//if (migratedSettings != null) configProps.putAll(migratedSettings);
// merge new props from init to config
// this is necessary for migration, when new properties are attached
initProps.putAll(configProps);
configProps = initProps;
// save result; this may initially create a config file after
// initialization
saveConfig();
}
// other settings
authorization = new HashMap<InetAddress, String>();
// init thread control
workerThreads = new TreeMap<String, serverBusyThread>();
// init switch actions
switchActions = new TreeMap<String, serverSwitchAction>();
// init busy state control
serverJobs = 0;
// init server tracking
this.accessTracker = new serverAccessTracker(
getConfigLong("server.maxTrackingTime", 60 * 60 * 1000),
(int) getConfigLong("server.maxTrackingCount", 1000),
(int) getConfigLong("server.maxTrackingHostCount", 100)
);
}
// a logger for this switchboard
public void setLog(final Log log) {
this.log = log;
}
public Log getLog() {
return log;
}
public void setConfig(final Map<String, String> otherConfigs) {
final Iterator<Map.Entry<String, String>> i = otherConfigs.entrySet().iterator();
Map.Entry<String, String> entry;
while (i.hasNext()) {
entry = i.next();
setConfig(entry.getKey(), entry.getValue());
}
}
public void setConfig(final String key, final boolean value) {
setConfig(key, (value) ? "true" : "false");
}
public void setConfig(final String key, final long value) {
setConfig(key, Long.toString(value));
}
public void setConfig(final String key, final double value) {
setConfig(key, Double.toString(value));
}
public void setConfig(final String key, final String value) {
// perform action before setting new value
final Iterator<serverSwitchAction> bevore = switchActions.values().iterator();
final Iterator<serverSwitchAction> after = switchActions.values().iterator();
synchronized (configProps) {
serverSwitchAction action;
while (bevore.hasNext()) {
action = bevore.next();
try {
action.doBevoreSetConfig(key, value);
} catch (final Exception e) {
log.logSevere("serverAction bevoreSetConfig '" + action.getShortDescription() + "' failed with exception: " + e.getMessage());
}
}
// set the value
final Object oldValue = configProps.put(key, value);
saveConfig();
// perform actions afterwards
while (after.hasNext()) {
action = after.next();
try {
action.doAfterSetConfig(key, value, (oldValue == null) ? null : (String) oldValue);
} catch (final Exception e) {
log.logSevere("serverAction afterSetConfig '" + action.getShortDescription() + "' failed with exception: " + e.getMessage());
}
}
}
}
public void removeConfig(final String key) {
configProps.remove(key);
}
/* (non-Javadoc)
* @see de.anomic.server.serverSwitch#getConfig(java.lang.String, java.lang.String)
*/
public String getConfig(final String key, final String dflt) {
final Iterator<serverSwitchAction> i = switchActions.values().iterator();
synchronized (configProps) {
// get the value
final Object s = configProps.get(key);
// do action
serverSwitchAction action;
while (i.hasNext()) {
action = i.next();
try {
action.doWhenGetConfig(key, (s == null) ? null : (String) s, dflt);
} catch (final Exception e) {
log.logSevere("serverAction whenGetConfig '" + action.getShortDescription() + "' failed with exception: " + e.getMessage());
}
}
// return value
if (s == null) return dflt;
return (String) s;
}
}
public long getConfigLong(final String key, final long dflt) {
try {
return Long.parseLong(getConfig(key, Long.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
public double getConfigDouble(final String key, final double dflt) {
try {
return Double.parseDouble(getConfig(key, Double.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
public boolean getConfigBool(final String key, final boolean dflt) {
return Boolean.valueOf(getConfig(key, Boolean.toString(dflt))).booleanValue();
}
/**
* Create a File instance for a configuration setting specifying a path.
* @param key config key
* @param dflt default path value, that is used when there is no value
* <code>key</code> in the configuration.
* @return if the value of the setting is an absolute path String, then the
* returned File is derived from this setting only. Otherwise the path's file
* is constructed from the applications root path + the relative path setting.
*/
public File getConfigPath(final String key, final String dflt) {
File ret;
final String path = getConfig(key, dflt).replace('\\', '/');
final File f = new File(path);
if (f == null) {
ret = null;
} else {
ret = (f.isAbsolute() ? f : new File(this.rootPath, path));
}
return ret;
}
public Iterator<String> configKeys() {
return configProps.keySet().iterator();
}
private void saveConfig() {
try {
synchronized (configProps) {
FileUtils.saveMap(configFile, configProps, configComment);
}
} catch (final IOException e) {
System.out.println("ERROR: cannot write config file " + configFile.toString() + ": " + e.getMessage());
}
}
public Map<String, String> getRemoved() {
// returns configuration that had been removed during initialization
return configRemoved;
}
// add/remove action listener
public void deployAction(final String actionName, final String actionShortDescription, final String actionLongDescription,
final serverSwitchAction newAction) {
newAction.setLog(log);
newAction.setDescription(actionShortDescription, actionLongDescription);
switchActions.put(actionName, newAction);
log.logInfo("Deployed Action '" + actionShortDescription + "', (" + switchActions.size() + " actions registered)");
}
public void undeployAction(final String actionName) {
final serverSwitchAction action = switchActions.get(actionName);
action.close();
switchActions.remove(actionName);
log.logInfo("Undeployed Action '" + action.getShortDescription() + "', (" + switchActions.size() + " actions registered)");
}
public void deployThread(
final String threadName,
final String threadShortDescription,
final String threadLongDescription,
final String threadMonitorURL,
final serverBusyThread newThread,
final long startupDelay) {
deployThread(threadName, threadShortDescription, threadLongDescription, threadMonitorURL,
newThread, startupDelay,
Long.parseLong(getConfig(threadName + "_idlesleep" , "100")),
Long.parseLong(getConfig(threadName + "_busysleep" , "1000")),
Long.parseLong(getConfig(threadName + "_memprereq" , "1000000")));
}
public void deployThread(
final String threadName,
final String threadShortDescription,
final String threadLongDescription,
final String threadMonitorURL,
final serverBusyThread newThread,
final long startupDelay,
final long initialIdleSleep,
final long initialBusySleep,
final long initialMemoryPreRequisite) {
if (newThread.isAlive()) throw new RuntimeException("undeployed threads must not live; they are started as part of the deployment");
newThread.setStartupSleep(startupDelay);
long x;
try {
x = Long.parseLong(getConfig(threadName + "_idlesleep" , "novalue"));
newThread.setIdleSleep(x);
} catch (final NumberFormatException e) {
newThread.setIdleSleep(initialIdleSleep);
setConfig(threadName + "_idlesleep", initialIdleSleep);
}
try {
x = Long.parseLong(getConfig(threadName + "_busysleep" , "novalue"));
newThread.setBusySleep(x);
} catch (final NumberFormatException e) {
newThread.setBusySleep(initialBusySleep);
setConfig(threadName + "_busysleep", initialBusySleep);
}
try {
x = Long.parseLong(getConfig(threadName + "_memprereq" , "novalue"));
newThread.setMemPreReqisite(x);
} catch (final NumberFormatException e) {
newThread.setMemPreReqisite(initialMemoryPreRequisite);
setConfig(threadName + "_memprereq", initialMemoryPreRequisite);
}
newThread.setLog(log);
newThread.setDescription(threadShortDescription, threadLongDescription, threadMonitorURL);
workerThreads.put(threadName, newThread);
// start the thread
if (workerThreads.containsKey(threadName)) newThread.start();
}
public serverBusyThread getThread(final String threadName) {
return workerThreads.get(threadName);
}
public void setThreadPerformance(final String threadName, final long idleMillis, final long busyMillis, final long memprereqBytes) {
final serverBusyThread thread = workerThreads.get(threadName);
if (thread != null) {
thread.setIdleSleep(idleMillis);
thread.setBusySleep(busyMillis);
thread.setMemPreReqisite(memprereqBytes);
}
}
public synchronized void terminateThread(final String threadName, final boolean waitFor) {
if (workerThreads.containsKey(threadName)) {
((serverThread) workerThreads.get(threadName)).terminate(waitFor);
workerThreads.remove(threadName);
}
}
public void intermissionAllThreads(final long pause) {
final Iterator<String> e = workerThreads.keySet().iterator();
while (e.hasNext()) {
workerThreads.get(e.next()).intermission(pause);
}
}
public synchronized void terminateAllThreads(final boolean waitFor) {
Iterator<String> e = workerThreads.keySet().iterator();
while (e.hasNext()) {
((serverThread) workerThreads.get(e.next())).terminate(false);
}
if (waitFor) {
e = workerThreads.keySet().iterator();
while (e.hasNext()) {
((serverThread) workerThreads.get(e.next())).terminate(true);
e.remove();
}
}
}
public String[] sessionsOlderThan(String threadName, long timeout) {
ArrayList<String> list = new ArrayList<String>();
final serverThread st = getThread(threadName);
final Thread[] threadList = new Thread[((serverCore) st).getJobCount()];
serverCore.sessionThreadGroup.enumerate(threadList);
for (Thread t: threadList) {
if (t == null) continue;
if (!(t instanceof serverCore.Session)) continue;
if (!t.isAlive()) continue;
if (t == null) continue;
final Session s = (Session) t;
if (s.getTime() > timeout) {
list.add(s.getName());
}
}
return (String[]) list.toArray();
}
public void closeSessions(String threadName, String sessionName) {
if (sessionName == null) return;
final serverThread st = getThread(threadName);
final Thread[] threadList = new Thread[((serverCore) st).getJobCount()];
serverCore.sessionThreadGroup.enumerate(threadList);
for (Thread t: threadList) {
if (
(t != null) &&
(t instanceof serverCore.Session) &&
(t.isAlive()) &&
(t.getName().equals(sessionName))
) {
// try to stop session
((Session)t).setStopped(true);
try { Thread.sleep(100); } catch (final InterruptedException ex) {}
// try to interrupt session
if (t.isAlive()) {
t.interrupt();
try { Thread.sleep(100); } catch (final InterruptedException ex) {}
}
// try to close socket
if (t.isAlive()) {
((Session)t).close();
}
// wait for session to finish
if (t.isAlive()) {
try { t.join(500); } catch (final InterruptedException ex) {}
}
}
}
}
public Iterator<String> /*of serverThread-Names (String)*/ threadNames() {
return workerThreads.keySet().iterator();
}
// authentification routines:
public void setAuthentify(final InetAddress host, final String user, final String rights) {
// sets access attributes according to host addresses
authorization.put(host, user + "@" + rights);
}
public void removeAuthentify(final InetAddress host) {
// remove access attributes according to host addresses
authorization.remove(host);
}
public String getAuthentifyUser(final InetAddress host) {
// read user name according to host addresses
final String a = authorization.get(host);
if (a == null) return null;
final int p = a.indexOf("@");
if (p < 0) return null;
return a.substring(0, p);
}
public String getAuthentifyRights(final InetAddress host) {
// read access rigths according to host addresses
final String a = authorization.get(host);
if (a == null) return null;
final int p = a.indexOf("@");
if (p < 0) return null;
return a.substring(p + 1);
}
public void addAuthentifyRight(final InetAddress host, final String right) {
final String rights = getAuthentifyRights(host);
if (rights == null) {
// create new authentification
setAuthentify(host, "unknown", right);
} else {
// add more authentification
final String user = getAuthentifyUser(host);
setAuthentify(host, user, rights + right);
}
}
public boolean hasAuthentifyRight(final InetAddress host, final String right) {
final String rights = getAuthentifyRights(host);
if (rights == null) return false;
return rights.indexOf(right) >= 0;
}
public abstract serverObjects action(String actionName, serverObjects actionInput);
public File getRootPath() {
return rootPath;
}
public String toString() {
return configProps.toString();
}
public void handleBusyState(final int jobs) {
serverJobs = jobs;
}
public void track(String host, String accessPath) {
this.accessTracker.track(host, accessPath);
}
public SortedMap<Long, String> accessTrack(String host) {
return this.accessTracker.accessTrack(host);
}
public Iterator<String> accessHosts() {
return this.accessTracker.accessHosts();
}
}

@ -1,42 +0,0 @@
// serverPlainSwitch.java
// (C) 2006 by Michael Peter Christen; mc@yacy.net, Frankfurt a. M., Germany
// first published 10.08.2006 on http://www.anomic.de
//
// This is a part of YaCy, a peer-to-peer based web search engine
//
// $LastChangedDate: 2006-04-02 22:40:07 +0200 (So, 02 Apr 2006) $
// $LastChangedRevision: 1986 $
// $LastChangedBy: orbiter $
//
// LICENSE
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
package de.anomic.server;
import java.io.File;
public class serverPlainSwitch extends serverAbstractSwitch implements serverSwitch {
public serverPlainSwitch(final File rootPath, final String initPath, final String configPath, final boolean applyPro) {
super(rootPath, initPath, configPath, applyPro);
}
public serverObjects action(final String actionName, final serverObjects actionInput) {
// no actions
return null;
}
}

@ -1,12 +1,9 @@
// serverSwitch.java // serverSwitch.java
// ------------------------------------------- // -------------------------------------
// (C) by Michael Peter Christen; mc@yacy.net // (C) by Michael Peter Christen; mc@yacy.net
// first published on http://www.anomic.de // first published on http://www.anomic.de
// Frankfurt, Germany, 2004 // Frankfurt, Germany, 2004, 2005
// // last major change: 24.03.2005
// $LastChangedDate$
// $LastChangedRevision$
// $LastChangedBy$
// //
// This program is free software; you can redistribute it and/or modify // This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
@ -22,89 +19,527 @@
// along with this program; if not, write to the Free Software // along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
/*
this is an interface for possible switchboard implementations
Its purpose is to provide a mechanism which cgi pages can use
to influence the behavior of a concurrntly running application
*/
package de.anomic.server; package de.anomic.server;
import java.io.File; import java.io.File;
import java.io.IOException;
import java.net.InetAddress; import java.net.InetAddress;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.Map; import java.util.Map;
import java.util.SortedMap; import java.util.SortedMap;
import java.util.TreeMap;
import de.anomic.kelondro.util.FileUtils;
import de.anomic.server.serverCore.Session;
import de.anomic.yacy.logging.Log; import de.anomic.yacy.logging.Log;
public interface serverSwitch { public class serverSwitch {
// configuration management
private final File configFile;
private final String configComment;
private final File rootPath;
protected boolean firstInit;
protected Log log;
protected int serverJobs;
private Map<String, String> configProps;
private final Map<String, String> configRemoved;
private final HashMap<InetAddress, String> authorization;
private final TreeMap<String, serverBusyThread> workerThreads;
private final TreeMap<String, serverSwitchAction> switchActions;
private final serverAccessTracker accessTracker;
public serverSwitch(final File rootPath, final String initPath, final String configPath, final boolean applyPro) {
// we initialize the switchboard with a property file,
// but maintain these properties then later in a new 'config' file
// to reset all changed configs, the config file must
// be deleted, but not the init file
// the only attribute that will always be read from the init is the
// file name of the config file
this.rootPath = rootPath;
this.configComment = "This is an automatically generated file, updated by serverAbstractSwitch and initialized by " + initPath;
final File initFile = new File(rootPath, initPath);
this.configFile = new File(rootPath, configPath); // propertiesFile(config);
firstInit = !configFile.exists(); // this is true if the application was started for the first time
new File(configFile.getParent()).mkdir();
// predefine init's
Map<String, String> initProps;
if (initFile.exists())
initProps = FileUtils.loadMap(initFile);
else
initProps = new HashMap<String, String>();
// if 'pro'-version is selected, overload standard settings with 'pro'-settings
Iterator<String> i;
String prop;
if (applyPro) {
i = new HashMap<String, String>(initProps).keySet().iterator(); // clone the map to avoid concurrent modification exceptions
while (i.hasNext()) {
prop = i.next();
if (prop.endsWith("__pro")) {
initProps.put(prop.substring(0, prop.length() - 5), initProps.get(prop));
}
}
}
// delete the 'pro' init settings
i = initProps.keySet().iterator();
while (i.hasNext()) {
prop = i.next();
if (prop.endsWith("__pro")) {
i.remove();
}
}
// load config's from last save
if (configFile.exists())
configProps = FileUtils.loadMap(configFile);
else
configProps = new HashMap<String, String>();
// remove all values from config that do not appear in init
configRemoved = new HashMap<String, String>();
synchronized (configProps) {
i = configProps.keySet().iterator();
String key;
while (i.hasNext()) {
key = i.next();
if (!(initProps.containsKey(key))) {
configRemoved.put(key, this.configProps.get(key));
i.remove();
}
}
// the root path for the application // doing a config settings migration
public File getRootPath(); //HashMap migratedSettings = migrateSwitchConfigSettings((HashMap) removedProps);
//if (migratedSettings != null) configProps.putAll(migratedSettings);
// merge new props from init to config
// this is necessary for migration, when new properties are attached
initProps.putAll(configProps);
configProps = initProps;
// save result; this may initially create a config file after
// initialization
saveConfig();
}
// other settings
authorization = new HashMap<InetAddress, String>();
// init thread control
workerThreads = new TreeMap<String, serverBusyThread>();
// init switch actions
switchActions = new TreeMap<String, serverSwitchAction>();
// init busy state control
serverJobs = 0;
// init server tracking
this.accessTracker = new serverAccessTracker(
getConfigLong("server.maxTrackingTime", 60 * 60 * 1000),
(int) getConfigLong("server.maxTrackingCount", 1000),
(int) getConfigLong("server.maxTrackingHostCount", 100)
);
}
// a logger for this switchboard // a logger for this switchboard
public void setLog(Log log); public void setLog(final Log log) {
public Log getLog(); this.log = log;
}
public Log getLog() {
return log;
}
public void setConfig(final Map<String, String> otherConfigs) {
final Iterator<Map.Entry<String, String>> i = otherConfigs.entrySet().iterator();
Map.Entry<String, String> entry;
while (i.hasNext()) {
entry = i.next();
setConfig(entry.getKey(), entry.getValue());
}
}
public void setConfig(final String key, final boolean value) {
setConfig(key, (value) ? "true" : "false");
}
public void setConfig(final String key, final long value) {
setConfig(key, Long.toString(value));
}
public void setConfig(final String key, final double value) {
setConfig(key, Double.toString(value));
}
public void setConfig(final String key, final String value) {
// perform action before setting new value
final Iterator<serverSwitchAction> bevore = switchActions.values().iterator();
final Iterator<serverSwitchAction> after = switchActions.values().iterator();
synchronized (configProps) {
serverSwitchAction action;
while (bevore.hasNext()) {
action = bevore.next();
try {
action.doBevoreSetConfig(key, value);
} catch (final Exception e) {
log.logSevere("serverAction bevoreSetConfig '" + action.getShortDescription() + "' failed with exception: " + e.getMessage());
}
}
// set the value
final Object oldValue = configProps.put(key, value);
saveConfig();
// perform actions afterwards
while (after.hasNext()) {
action = after.next();
try {
action.doAfterSetConfig(key, value, (oldValue == null) ? null : (String) oldValue);
} catch (final Exception e) {
log.logSevere("serverAction afterSetConfig '" + action.getShortDescription() + "' failed with exception: " + e.getMessage());
}
}
}
}
public void removeConfig(final String key) {
configProps.remove(key);
}
/* (non-Javadoc)
* @see de.anomic.server.serverSwitch#getConfig(java.lang.String, java.lang.String)
*/
public String getConfig(final String key, final String dflt) {
final Iterator<serverSwitchAction> i = switchActions.values().iterator();
synchronized (configProps) {
// get the value
final Object s = configProps.get(key);
// do action
serverSwitchAction action;
while (i.hasNext()) {
action = i.next();
try {
action.doWhenGetConfig(key, (s == null) ? null : (String) s, dflt);
} catch (final Exception e) {
log.logSevere("serverAction whenGetConfig '" + action.getShortDescription() + "' failed with exception: " + e.getMessage());
}
}
// return value
if (s == null) return dflt;
return (String) s;
}
}
public long getConfigLong(final String key, final long dflt) {
try {
return Long.parseLong(getConfig(key, Long.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
public double getConfigDouble(final String key, final double dflt) {
try {
return Double.parseDouble(getConfig(key, Double.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
public boolean getConfigBool(final String key, final boolean dflt) {
return Boolean.valueOf(getConfig(key, Boolean.toString(dflt))).booleanValue();
}
/**
* Create a File instance for a configuration setting specifying a path.
* @param key config key
* @param dflt default path value, that is used when there is no value
* <code>key</code> in the configuration.
* @return if the value of the setting is an absolute path String, then the
* returned File is derived from this setting only. Otherwise the path's file
* is constructed from the applications root path + the relative path setting.
*/
public File getConfigPath(final String key, final String dflt) {
File ret;
final String path = getConfig(key, dflt).replace('\\', '/');
final File f = new File(path);
if (f == null) {
ret = null;
} else {
ret = (f.isAbsolute() ? f : new File(this.rootPath, path));
}
return ret;
}
public Iterator<String> configKeys() {
return configProps.keySet().iterator();
}
private void saveConfig() {
try {
synchronized (configProps) {
FileUtils.saveMap(configFile, configProps, configComment);
}
} catch (final IOException e) {
System.out.println("ERROR: cannot write config file " + configFile.toString() + ": " + e.getMessage());
}
}
public Map<String, String> getRemoved() {
// returns configuration that had been removed during initialization
return configRemoved;
}
// add/remove action listener
public void deployAction(final String actionName, final String actionShortDescription, final String actionLongDescription,
final serverSwitchAction newAction) {
newAction.setLog(log);
newAction.setDescription(actionShortDescription, actionLongDescription);
switchActions.put(actionName, newAction);
log.logInfo("Deployed Action '" + actionShortDescription + "', (" + switchActions.size() + " actions registered)");
}
public void undeployAction(final String actionName) {
final serverSwitchAction action = switchActions.get(actionName);
action.close();
switchActions.remove(actionName);
log.logInfo("Undeployed Action '" + action.getShortDescription() + "', (" + switchActions.size() + " actions registered)");
}
public void deployThread(
final String threadName,
final String threadShortDescription,
final String threadLongDescription,
final String threadMonitorURL,
final serverBusyThread newThread,
final long startupDelay) {
deployThread(threadName, threadShortDescription, threadLongDescription, threadMonitorURL,
newThread, startupDelay,
Long.parseLong(getConfig(threadName + "_idlesleep" , "100")),
Long.parseLong(getConfig(threadName + "_busysleep" , "1000")),
Long.parseLong(getConfig(threadName + "_memprereq" , "1000000")));
}
// access tracker public void deployThread(
public void track(String host, String accessPath); // learn that a specific host has accessed a specific path final String threadName,
public SortedMap<Long, String> accessTrack(String host); // returns mapping from Long(accesstime) to path final String threadShortDescription,
public Iterator<String> accessHosts(); // returns an iterator of hosts in tracker (String) final String threadLongDescription,
final String threadMonitorURL,
final serverBusyThread newThread,
final long startupDelay,
final long initialIdleSleep,
final long initialBusySleep,
final long initialMemoryPreRequisite) {
if (newThread.isAlive()) throw new RuntimeException("undeployed threads must not live; they are started as part of the deployment");
newThread.setStartupSleep(startupDelay);
long x;
try {
x = Long.parseLong(getConfig(threadName + "_idlesleep" , "novalue"));
newThread.setIdleSleep(x);
} catch (final NumberFormatException e) {
newThread.setIdleSleep(initialIdleSleep);
setConfig(threadName + "_idlesleep", initialIdleSleep);
}
try {
x = Long.parseLong(getConfig(threadName + "_busysleep" , "novalue"));
newThread.setBusySleep(x);
} catch (final NumberFormatException e) {
newThread.setBusySleep(initialBusySleep);
setConfig(threadName + "_busysleep", initialBusySleep);
}
try {
x = Long.parseLong(getConfig(threadName + "_memprereq" , "novalue"));
newThread.setMemPreReqisite(x);
} catch (final NumberFormatException e) {
newThread.setMemPreReqisite(initialMemoryPreRequisite);
setConfig(threadName + "_memprereq", initialMemoryPreRequisite);
}
newThread.setLog(log);
newThread.setDescription(threadShortDescription, threadLongDescription, threadMonitorURL);
workerThreads.put(threadName, newThread);
// start the thread
if (workerThreads.containsKey(threadName)) newThread.start();
}
public serverBusyThread getThread(final String threadName) {
return workerThreads.get(threadName);
}
public void setThreadPerformance(final String threadName, final long idleMillis, final long busyMillis, final long memprereqBytes) {
final serverBusyThread thread = workerThreads.get(threadName);
if (thread != null) {
thread.setIdleSleep(idleMillis);
thread.setBusySleep(busyMillis);
thread.setMemPreReqisite(memprereqBytes);
}
}
public synchronized void terminateThread(final String threadName, final boolean waitFor) {
if (workerThreads.containsKey(threadName)) {
((serverThread) workerThreads.get(threadName)).terminate(waitFor);
workerThreads.remove(threadName);
}
}
public void intermissionAllThreads(final long pause) {
final Iterator<String> e = workerThreads.keySet().iterator();
while (e.hasNext()) {
workerThreads.get(e.next()).intermission(pause);
}
}
public synchronized void terminateAllThreads(final boolean waitFor) {
Iterator<String> e = workerThreads.keySet().iterator();
while (e.hasNext()) {
((serverThread) workerThreads.get(e.next())).terminate(false);
}
if (waitFor) {
e = workerThreads.keySet().iterator();
while (e.hasNext()) {
((serverThread) workerThreads.get(e.next())).terminate(true);
e.remove();
}
}
}
public String[] sessionsOlderThan(String threadName, long timeout) {
ArrayList<String> list = new ArrayList<String>();
final serverThread st = getThread(threadName);
final Thread[] threadList = new Thread[((serverCore) st).getJobCount()];
serverCore.sessionThreadGroup.enumerate(threadList);
for (Thread t: threadList) {
if (t == null) continue;
if (!(t instanceof serverCore.Session)) continue;
if (!t.isAlive()) continue;
if (t == null) continue;
final Session s = (Session) t;
if (s.getTime() > timeout) {
list.add(s.getName());
}
}
return (String[]) list.toArray();
}
public void closeSessions(String threadName, String sessionName) {
if (sessionName == null) return;
final serverThread st = getThread(threadName);
final Thread[] threadList = new Thread[((serverCore) st).getJobCount()];
serverCore.sessionThreadGroup.enumerate(threadList);
// a switchboard can have action listener for (Thread t: threadList) {
// these listeners are hooks for numerous methods below if (
public void deployAction(String actionName, (t != null) &&
String actionShortDescription, (t instanceof serverCore.Session) &&
String actionLongDescription, (t.isAlive()) &&
serverSwitchAction action); (t.getName().equals(sessionName))
public void undeployAction(String actionName); ) {
// try to stop session
// the switchboard can manage worker threads ((Session)t).setStopped(true);
public void deployThread(String threadName, try { Thread.sleep(100); } catch (final InterruptedException ex) {}
String threadShortDescription,
String threadLongDescription, // try to interrupt session
String threadMonitorURL, if (t.isAlive()) {
serverBusyThread newThread, t.interrupt();
long startupDelay, try { Thread.sleep(100); } catch (final InterruptedException ex) {}
long initialIdleSleep, long initialBusySleep, }
long initialMemoryPreRequisite);
public serverBusyThread getThread(String threadName); // try to close socket
public void setThreadPerformance(String threadName, long idleMillis, long busyMillis, long memprereq); if (t.isAlive()) {
public void terminateThread(String threadName, boolean waitFor); ((Session)t).close();
public void intermissionAllThreads(long pause); }
public void terminateAllThreads(boolean waitFor);
// wait for session to finish
public Iterator<String> /*of serverThread-Names (String)*/ threadNames(); if (t.isAlive()) {
try { t.join(500); } catch (final InterruptedException ex) {}
// the switchboard can be used to set and read properties }
public void setConfig(Map<String, String> otherConfigs); }
public void setConfig(String key, long value); }
public void setConfig(String key, String value); }
public String getConfig(String key, String dflt);
public long getConfigLong(String key, long dflt); public Iterator<String> /*of serverThread-Names (String)*/ threadNames() {
public boolean getConfigBool(String key, boolean dflt); return workerThreads.keySet().iterator();
public File getConfigPath(String key, String dflt); }
public void removeConfig(String key);
public Iterator<String> configKeys(); // authentification routines:
public Map<String, String> getRemoved();
public void setAuthentify(final InetAddress host, final String user, final String rights) {
// authentification routines: sets and reads access attributes according to host addresses // sets access attributes according to host addresses
public void setAuthentify(InetAddress host, String user, String rigth); authorization.put(host, user + "@" + rights);
public void removeAuthentify(InetAddress host); }
public String getAuthentifyUser(InetAddress host);
public String getAuthentifyRights(InetAddress host); public void removeAuthentify(final InetAddress host) {
public void addAuthentifyRight(InetAddress host, String right); // remove access attributes according to host addresses
public boolean hasAuthentifyRight(InetAddress host, String right); authorization.remove(host);
}
// ask the switchboard to perform an action
// the result is a properties structure with the result of the action public String getAuthentifyUser(final InetAddress host) {
// The actionName selects an action // read user name according to host addresses
// the actionInput is an input for the selected action final String a = authorization.get(host);
public serverObjects action(String actionName, serverObjects actionInput); if (a == null) return null;
final int p = a.indexOf("@");
// performance control: the server can announce busy and idle status to the switchboard if (p < 0) return null;
// these announcements can be used to trigger events or interrupts return a.substring(0, p);
public void handleBusyState(int jobs); }
public String getAuthentifyRights(final InetAddress host) {
// read access rigths according to host addresses
final String a = authorization.get(host);
if (a == null) return null;
final int p = a.indexOf("@");
if (p < 0) return null;
return a.substring(p + 1);
}
public void addAuthentifyRight(final InetAddress host, final String right) {
final String rights = getAuthentifyRights(host);
if (rights == null) {
// create new authentification
setAuthentify(host, "unknown", right);
} else {
// add more authentification
final String user = getAuthentifyUser(host);
setAuthentify(host, user, rights + right);
}
}
public boolean hasAuthentifyRight(final InetAddress host, final String right) {
final String rights = getAuthentifyRights(host);
if (rights == null) return false;
return rights.indexOf(right) >= 0;
}
public File getRootPath() {
return rootPath;
}
public String toString() {
return configProps.toString();
}
public void handleBusyState(final int jobs) {
serverJobs = jobs;
}
public void track(String host, String accessPath) {
this.accessTracker.track(host, accessPath);
}
public SortedMap<Long, String> accessTrack(String host) {
return this.accessTracker.accessTrack(host);
}
public Iterator<String> accessHosts() {
return this.accessTracker.accessHosts();
}
} }

Loading…
Cancel
Save