// serverSwitch.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.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Random;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;
import net.yacy.cora.protocol.ClientIdentification;
import net.yacy.cora.protocol.Domains;
import net.yacy.cora.protocol.HeaderFramework;
import net.yacy.cora.protocol.RequestHeader;
import net.yacy.cora.protocol.http.HTTPClient;
import net.yacy.kelondro.logging.Log;
import net.yacy.kelondro.order.Digest;
import net.yacy.kelondro.util.FileUtils;
import net.yacy.kelondro.workflow.BusyThread;
import net.yacy.kelondro.workflow.WorkflowThread;
import de.anomic.server.serverAccessTracker.Track;
import de.anomic.server.serverCore.Session;
public class serverSwitch {
// configuration management
private final File configFile;
private final String configComment;
private final File dataPath;
protected final File appPath;
protected boolean firstInit;
protected Log log;
protected int serverJobs;
private ConcurrentMap<String, String> configProps;
private final ConcurrentMap<String, String> configRemoved;
private final ConcurrentMap<InetAddress, String> authorization;
private final NavigableMap<String, BusyThread> workerThreads;
private final serverAccessTracker accessTracker;
public serverSwitch(final File dataPath, final File appPath, final String initPath, final String configPath) {
// 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.dataPath = dataPath;
this.appPath = appPath;
this.configComment = "This is an automatically generated file, updated by serverAbstractSwitch and initialized by " + initPath;
final File initFile = new File(appPath, initPath);
this.configFile = new File(dataPath, 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
final ConcurrentMap<String, String> initProps;
if (initFile.exists())
initProps = FileUtils.loadMap(initFile);
else
initProps = new ConcurrentHashMap<String, String>();
// if 'pro'-version is selected, overload standard settings with 'pro'-settings
Iterator<String> i;
String 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 ConcurrentHashMap<String, String>();
// remove all values from config that do not appear in init
configRemoved = new ConcurrentHashMap<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 ConcurrentHashMap<InetAddress, String>();
// init thread control
workerThreads = new TreeMap<String, BusyThread>();
// 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)
);
}
public String myPublicIP() {
// if a static IP was configured, we have to return it here ...
final String staticIP = getConfig("staticIP", "");
if (staticIP.length() > 0) {
return staticIP;
}
// otherwise we return the real IP address of this host
final InetAddress pLIP = Domains.myPublicLocalIP();
if (pLIP != null) return pLIP.getHostAddress();
return null;
}
// 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 float value) {
setConfig(key, Float.toString(value));
}
public void setConfig(final String key, final String value) {
// set the value
final String oldValue = configProps.put(key, value);
if (oldValue == null || !value.equals(oldValue)) saveConfig();
}
public void removeConfig(final String key) {
configProps.remove(key);
}
/**
* Gets a configuration parameter from the properties.
* @param key name of the configuration parameter
* @param dflt default value which will be used in case parameter can not be
* found or if it is invalid
* @return value if the parameter or default value
*/
public String getConfig(final String key, final String dflt) {
// get the value
final String s = configProps.get(key);
// return value
if (s == null) return dflt;
return s;
}
/**
* Gets a configuration parameter from the properties.
* @param key name of the configuration parameter
* @param dflt default value which will be used in case parameter can not be
* found or if it is invalid
* @return value if the parameter or default value
*/
public long getConfigLong(final String key, final long dflt) {
try {
return Long.parseLong(getConfig(key, Long.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
/**
* Gets a configuration parameter from the properties.
* @param key name of the configuration parameter
* @param dflt default value which will be used in case parameter can not be
* found or if it is invalid
* @return value if the parameter or default value
*/
public double getConfigFloat(final String key, final float dflt) {
try {
return Float.parseFloat(getConfig(key, Float.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
/**
* Gets a configuration parameter from the properties.
* @param key name of the configuration parameter
* @param dflt default value which will be used in case parameter can not be
* found or if it is invalid
* @return value if the parameter or default value
*/
public int getConfigInt(final String key, final int dflt) {
try {
return Integer.parseInt(getConfig(key, Integer.toString(dflt)));
} catch (final NumberFormatException e) {
return dflt;
}
}
/**
* Gets a configuration parameter from the properties.
* @param key name of the configuration parameter
* @param dflt default value which will be used in case parameter can not be
* found or if it is invalid
* @return value if the parameter or default value
*/
public boolean getConfigBool(final String key, final boolean dflt) {
return Boolean.parseBoolean(getConfig(key, Boolean.toString(dflt)));
}
/**
* 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 getDataPath(final String key, final String dflt) {
File ret;
final String path = getConfig(key, dflt).replace('\\', '/');
final File f = new File(path);
ret = (f.isAbsolute() ? new File(f.getAbsolutePath()) : new File(this.dataPath, path));
return ret;
}
public File getAppPath(final String key, final String dflt) {
File ret;
final String path = getConfig(key, dflt).replace('\\', '/');
final File f = new File(path);
ret = (f.isAbsolute() ? new File(f.getAbsolutePath()) : new File(this.appPath, path));
return ret;
}
public Iterator<String> configKeys() {
return configProps.keySet().iterator();
}
private void saveConfig() {
try {
ConcurrentMap<String, String> configPropsCopy = new ConcurrentHashMap<String, String>();
configPropsCopy.putAll(configProps); // avoid concurrency problems
FileUtils.saveMap(configFile, configPropsCopy, configComment);
} catch (final IOException e) {
log.logSevere("CONFIG: Cannot write config file " + configFile.toString() + ": " + e.getMessage(), e);
//System.out.println("ERROR: cannot write config file " + configFile.toString() + ": " + e.getMessage());
}
}
/**
* Gets configuration parameters which have been removed during initialization.
* @return contains parameter name as key and parameter value as value
*/
public ConcurrentMap<String, String> getRemoved() {
return configRemoved;
}
public void deployThread(
final String threadName,
final String threadShortDescription,
final String threadLongDescription,
final String threadMonitorURL,
final BusyThread 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 BusyThread 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.setDescription(threadShortDescription, threadLongDescription, threadMonitorURL);
workerThreads.put(threadName, newThread);
// start the thread
if (workerThreads.containsKey(threadName)) newThread.start();
}
public BusyThread getThread(final String threadName) {
return workerThreads.get(threadName);
}
public void setThreadPerformance(final String threadName, final long idleMillis, final long busyMillis, final long memprereqBytes) {
final BusyThread thread = workerThreads.get(threadName);
if (thread != null) {
setConfig(threadName + "_idlesleep", thread.setIdleSleep(idleMillis));
setConfig(threadName + "_busysleep", thread.setBusySleep(busyMillis));
setConfig(threadName + "_memprereq", memprereqBytes);
thread.setMemPreReqisite(memprereqBytes);
}
}
public synchronized void terminateThread(final String threadName, final boolean waitFor) {
if (workerThreads.containsKey(threadName)) {
((WorkflowThread) 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()) {
((WorkflowThread) workerThreads.get(e.next())).terminate(false);
}
if (waitFor) {
e = workerThreads.keySet().iterator();
while (e.hasNext()) {
((WorkflowThread) workerThreads.get(e.next())).terminate(true);
e.remove();
}
}
}
public String[] sessionsOlderThan(String threadName, long timeout) {
final List<String> list = new ArrayList<String>();
final WorkflowThread st = getThread(threadName);
for (final Session s: ((serverCore) st).getJobList()) {
if (!s.isAlive()) continue;
if (s.getTime() > timeout) {
list.add(s.getName());
}
}
return (String[]) list.toArray();
}
public void closeSessions(String threadName, String sessionName) {
if (sessionName == null) return;
final WorkflowThread st = getThread(threadName);
for (final Session s: ((serverCore) st).getJobList()) {
if (
(s.isAlive()) &&
(s.getName().equals(sessionName))
) {
// try to stop session
s.setStopped(true);
try { Thread.sleep(100); } catch (final InterruptedException ex) {}
// try to interrupt session
s.interrupt();
try { Thread.sleep(100); } catch (final InterruptedException ex) {}
// try to close socket
if (s.isAlive()) {
s.close();
}
// wait for session to finish
if (s.isAlive()) {
try { s.join(500); } catch (final InterruptedException ex) {}
}
}
}
}
public Iterator<String> /*of serverThread-Names (String)*/ threadNames() {
return workerThreads.keySet().iterator();
}
// authentication 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 authentication
setAuthentify(host, "unknown", right);
} else {
// add more authentication
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 getDataPath() {
return this.dataPath;
}
public File getAppPath() {
return this.appPath;
}
@Override
public String toString() {
return configProps.toString();
}
public void handleBusyState(final int jobs) {
serverJobs = jobs;
}
public void track(final String host, final String accessPath) {
this.accessTracker.track(host, accessPath);
}
public Collection<Track> accessTrack(final String host) {
return this.accessTracker.accessTrack(host);
}
public int latestAccessCount(final String host, final long timedelta) {
return this.accessTracker.latestAccessCount(host, timedelta);
}
public Iterator<String> accessHosts() {
return this.accessTracker.accessHosts();
}
/**
* Retrieve text data (e. g. config file) from file
*
* file may be an url or a filename with path relative to rootPath parameter
* @param file url or filename
* @param rootPath searchpath for file
* @param file file to use when remote fetching fails (null if unused)
*/
public Reader getConfigFileFromWebOrLocally(final String uri,
final String rootPath, final File file) throws IOException, FileNotFoundException {
if (uri.startsWith("http://") || uri.startsWith("https://")) {
final String[] uris = uri.split(",");
for (String netdef: uris) {
netdef = netdef.trim();
try {
final RequestHeader reqHeader = new RequestHeader();
reqHeader.put(HeaderFramework.USER_AGENT, ClientIdentification.getUserAgent());
final HTTPClient client = new HTTPClient();
client.setHeader(reqHeader.entrySet());
byte[] data = client.GETbytes(uri);
if (data == null || data.length == 0) continue;
// save locally in case next fetch fails
if (file != null) {
FileOutputStream f = new FileOutputStream(file);
f.write(data);
f.close();
}
return new InputStreamReader(new BufferedInputStream(new ByteArrayInputStream(data)));
} catch (final Exception e) {
continue;
}
}
if (file != null && file.exists()) {
return new FileReader(file);
} else {
throw new FileNotFoundException();
}
} else {
final File f = (uri.length() > 0 && uri.startsWith("/")) ? new File(uri) : new File(rootPath, uri);
if (f.exists()) {
return new FileReader(f);
} else {
throw new FileNotFoundException(f.toString());
}
}
}
private static Random pwGenerator = new Random();
/**
* Generates a random password.
* @return random password which is 20 characters long.
*/
public String genRandomPassword() {
return genRandomPassword(20);
}
/**
* Generates a random password of a given length.
* @param length length o password
* @return password of given length
*/
public String genRandomPassword(final int length) {
byte[] bytes = new byte[length];
pwGenerator.nextBytes(bytes);
return Digest.encodeMD5Hex(bytes);
}
}