2017-04-01 07:37:48 +02:00
|
|
|
package net.ME1312.SubServers.Bungee.Host.External;
|
|
|
|
|
2019-04-18 16:02:09 +02:00
|
|
|
import net.ME1312.Galaxi.Library.Callback.Callback;
|
2020-11-16 21:34:59 +01:00
|
|
|
import net.ME1312.Galaxi.Library.Config.YAMLConfig;
|
2020-11-14 08:07:25 +01:00
|
|
|
import net.ME1312.Galaxi.Library.Container.ContainedPair;
|
2020-06-12 07:45:49 +02:00
|
|
|
import net.ME1312.Galaxi.Library.Container.Container;
|
2020-11-14 08:07:25 +01:00
|
|
|
import net.ME1312.Galaxi.Library.Container.Pair;
|
2020-11-16 21:34:59 +01:00
|
|
|
import net.ME1312.Galaxi.Library.Container.Value;
|
|
|
|
import net.ME1312.Galaxi.Library.Map.ObjectMap;
|
|
|
|
import net.ME1312.Galaxi.Library.UniversalFile;
|
|
|
|
import net.ME1312.Galaxi.Library.Util;
|
|
|
|
import net.ME1312.Galaxi.Library.Version.Version;
|
2019-04-18 16:02:09 +02:00
|
|
|
import net.ME1312.SubData.Server.SubDataClient;
|
2017-04-01 07:37:48 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.Event.SubCreateEvent;
|
2019-12-18 08:49:40 +01:00
|
|
|
import net.ME1312.SubServers.Bungee.Event.SubCreatedEvent;
|
2017-04-01 07:37:48 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.Host.*;
|
2021-01-17 00:10:51 +01:00
|
|
|
import net.ME1312.SubServers.Bungee.Host.SubServer.StopAction;
|
2019-06-17 05:13:48 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
|
2017-08-17 01:29:02 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.Network.Packet.PacketExConfigureHost;
|
2017-04-01 07:37:48 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.Network.Packet.PacketExCreateServer;
|
2020-02-17 04:25:15 +01:00
|
|
|
import net.ME1312.SubServers.Bungee.Network.Packet.PacketExDownloadTemplates;
|
2020-06-20 03:00:50 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.Network.Packet.PacketExUploadTemplates;
|
2017-07-23 06:32:57 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.SubAPI;
|
2020-06-20 03:00:50 +02:00
|
|
|
import net.ME1312.SubServers.Bungee.SubProxy;
|
2020-11-16 21:34:59 +01:00
|
|
|
|
|
|
|
import com.google.common.collect.Range;
|
2019-04-18 16:02:09 +02:00
|
|
|
import net.md_5.bungee.api.ChatColor;
|
2017-04-01 07:37:48 +02:00
|
|
|
|
|
|
|
import java.io.File;
|
2018-08-30 03:55:59 +02:00
|
|
|
import java.lang.reflect.InvocationTargetException;
|
2018-10-08 23:07:44 +02:00
|
|
|
import java.net.InetSocketAddress;
|
2017-07-23 06:32:57 +02:00
|
|
|
import java.util.*;
|
2017-04-01 07:37:48 +02:00
|
|
|
|
2017-04-16 19:02:14 +02:00
|
|
|
/**
|
|
|
|
* External SubCreator Class
|
|
|
|
*/
|
2017-12-21 17:02:47 +01:00
|
|
|
@SuppressWarnings("unchecked")
|
2017-04-01 07:37:48 +02:00
|
|
|
public class ExternalSubCreator extends SubCreator {
|
2017-05-29 07:00:02 +02:00
|
|
|
private HashMap<String, ServerTemplate> templates = new HashMap<String, ServerTemplate>();
|
2020-06-20 03:00:50 +02:00
|
|
|
private HashMap<String, ServerTemplate> templatesR = new HashMap<String, ServerTemplate>();
|
|
|
|
private Boolean enableRT = false;
|
2017-04-01 07:37:48 +02:00
|
|
|
private ExternalHost host;
|
2019-01-05 22:04:45 +01:00
|
|
|
private Range<Integer> ports;
|
2020-11-14 08:07:25 +01:00
|
|
|
private Value<Boolean> log;
|
2017-04-01 07:37:48 +02:00
|
|
|
private String gitBash;
|
2020-11-14 08:07:25 +01:00
|
|
|
private TreeMap<String, Pair<Integer, ExternalSubLogger>> thread;
|
2017-04-01 07:37:48 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates an External SubCreator
|
|
|
|
*
|
|
|
|
* @param host Host
|
2019-01-05 22:04:45 +01:00
|
|
|
* @param ports The range of ports to auto-select from
|
|
|
|
* @param log Whether SubCreator should log to console
|
|
|
|
* @param gitBash The Git Bash directory
|
2017-04-01 07:37:48 +02:00
|
|
|
*/
|
2019-01-05 22:04:45 +01:00
|
|
|
public ExternalSubCreator(ExternalHost host, Range<Integer> ports, boolean log, String gitBash) {
|
|
|
|
if (!ports.hasLowerBound() || !ports.hasUpperBound()) throw new IllegalArgumentException("Port range is not bound");
|
|
|
|
if (Util.isNull(host, ports, log, gitBash)) throw new NullPointerException();
|
2017-04-01 07:37:48 +02:00
|
|
|
this.host = host;
|
2019-01-05 22:04:45 +01:00
|
|
|
this.ports = ports;
|
|
|
|
this.log = new Container<Boolean>(log);
|
2017-04-01 07:37:48 +02:00
|
|
|
this.gitBash = gitBash;
|
2020-11-14 08:07:25 +01:00
|
|
|
this.thread = new TreeMap<String, Pair<Integer, ExternalSubLogger>>();
|
2017-08-17 01:29:02 +02:00
|
|
|
reload();
|
|
|
|
}
|
2017-07-23 06:32:57 +02:00
|
|
|
|
2017-08-17 01:29:02 +02:00
|
|
|
@Override
|
|
|
|
public void reload() {
|
2020-06-20 03:00:50 +02:00
|
|
|
templatesR.clear();
|
2020-02-18 01:07:26 +01:00
|
|
|
if (new UniversalFile(host.plugin.dir, "SubServers:Templates").exists()) for (File file : new UniversalFile(host.plugin.dir, "SubServers:Templates").listFiles()) {
|
|
|
|
try {
|
|
|
|
if (file.isDirectory() && !file.getName().endsWith(".x")) {
|
|
|
|
ObjectMap<String> config = (new UniversalFile(file, "template.yml").exists())?new YAMLConfig(new UniversalFile(file, "template.yml")).get().getMap("Template", new ObjectMap<String>()):new ObjectMap<String>();
|
2021-06-06 04:44:33 +02:00
|
|
|
ServerTemplate template = loadTemplate(file.getName(), config.getBoolean("Enabled", true), config.getRawString("Icon", "::NULL::"), file, config.getMap("Build", new ObjectMap<String>()), config.getMap("Settings", new ObjectMap<String>()));
|
2020-06-20 03:00:50 +02:00
|
|
|
templatesR.put(file.getName().toLowerCase(), template);
|
2020-02-18 01:07:26 +01:00
|
|
|
if (config.getKeys().contains("Display")) template.setDisplayName(config.getString("Display"));
|
2017-07-23 06:32:57 +02:00
|
|
|
}
|
2020-02-18 01:07:26 +01:00
|
|
|
} catch (Exception e) {
|
|
|
|
System.out.println(host.getName() + "/Creator > Couldn't load template: " + file.getName());
|
|
|
|
e.printStackTrace();
|
2017-07-23 06:32:57 +02:00
|
|
|
}
|
2020-02-18 01:07:26 +01:00
|
|
|
}
|
2020-02-17 04:25:15 +01:00
|
|
|
|
2020-06-20 03:00:50 +02:00
|
|
|
if (host.available && !Util.getDespiteException(() -> Util.reflect(SubProxy.class.getDeclaredField("reloading"), host.plugin), false)) {
|
2020-02-17 04:25:15 +01:00
|
|
|
host.queue(new PacketExConfigureHost(host.plugin, host));
|
2020-06-20 03:00:50 +02:00
|
|
|
host.queue(new PacketExUploadTemplates(host.plugin));
|
|
|
|
if (enableRT == null || enableRT) host.queue(new PacketExDownloadTemplates(host.plugin, host));
|
2017-07-23 06:32:57 +02:00
|
|
|
}
|
2017-04-01 07:37:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2018-10-08 23:07:44 +02:00
|
|
|
public boolean create(UUID player, String name, ServerTemplate template, Version version, Integer port, Callback<SubServer> callback) {
|
2019-04-18 16:02:09 +02:00
|
|
|
if (Util.isNull(name, template)) throw new NullPointerException();
|
2019-05-09 22:17:15 +02:00
|
|
|
if (host.isAvailable() && host.isEnabled() && template.isEnabled() && !SubAPI.getInstance().getSubServers().keySet().contains(name.toLowerCase()) && !SubCreator.isReserved(name) && (version != null || !template.requiresVersion())) {
|
2018-08-30 03:55:59 +02:00
|
|
|
StackTraceElement[] origin = new Exception().getStackTrace();
|
2018-10-08 23:07:44 +02:00
|
|
|
|
|
|
|
if (port == null) {
|
2019-01-05 22:04:45 +01:00
|
|
|
Container<Integer> i = new Container<Integer>(ports.lowerEndpoint() - 1);
|
2018-10-08 23:07:44 +02:00
|
|
|
port = Util.getNew(getAllReservedAddresses(), () -> {
|
2019-01-05 22:04:45 +01:00
|
|
|
do {
|
2020-11-14 08:07:25 +01:00
|
|
|
++i.value;
|
|
|
|
if (i.value > ports.upperEndpoint()) throw new IllegalStateException("There are no more ports available in range: " + ports.toString());
|
|
|
|
} while (!ports.contains(i.value));
|
|
|
|
return new InetSocketAddress(host.getAddress(), i.value);
|
2018-10-08 23:07:44 +02:00
|
|
|
}).getPort();
|
|
|
|
}
|
2019-06-17 05:13:48 +02:00
|
|
|
String prefix = name + File.separator + "Creator";
|
|
|
|
ExternalSubLogger logger = new ExternalSubLogger(this, prefix, log, null);
|
2020-11-14 08:07:25 +01:00
|
|
|
thread.put(name.toLowerCase(), new ContainedPair<>(port, logger));
|
2018-10-08 23:07:44 +02:00
|
|
|
|
|
|
|
final int fport = port;
|
2017-05-29 07:00:02 +02:00
|
|
|
final SubCreateEvent event = new SubCreateEvent(player, host, name, template, version, port);
|
2017-04-01 07:37:48 +02:00
|
|
|
host.plugin.getPluginManager().callEvent(event);
|
|
|
|
if (!event.isCancelled()) {
|
|
|
|
logger.start();
|
2020-06-13 23:53:18 +02:00
|
|
|
host.queue(new PacketExCreateServer(player, name, template, version, port, logger.getExternalAddress(), data -> {
|
2020-08-20 03:15:55 +02:00
|
|
|
finish(player, null, name, template, version, fport, prefix, origin, data, callback);
|
2017-04-01 07:37:48 +02:00
|
|
|
logger.stop();
|
2017-07-23 06:32:57 +02:00
|
|
|
this.thread.remove(name.toLowerCase());
|
2017-04-01 07:37:48 +02:00
|
|
|
}));
|
|
|
|
return true;
|
2017-08-31 02:12:26 +02:00
|
|
|
} else {
|
|
|
|
thread.remove(name.toLowerCase());
|
|
|
|
return false;
|
|
|
|
}
|
2017-04-01 07:37:48 +02:00
|
|
|
} else return false;
|
2019-10-19 22:38:44 +02:00
|
|
|
} private <T> void callback(StackTraceElement[] origin, Callback<T> callback, T value) {
|
|
|
|
if (callback != null) try {
|
|
|
|
callback.run(value);
|
|
|
|
} catch (Throwable e) {
|
|
|
|
Throwable ew = new InvocationTargetException(e);
|
|
|
|
ew.setStackTrace(origin);
|
|
|
|
ew.printStackTrace();
|
|
|
|
}
|
2017-04-01 07:37:48 +02:00
|
|
|
}
|
|
|
|
|
2019-06-17 05:13:48 +02:00
|
|
|
@Override
|
2020-08-20 03:15:55 +02:00
|
|
|
public boolean update(UUID player, SubServer server, ServerTemplate template, Version version, Callback<Boolean> callback) {
|
2019-06-17 05:13:48 +02:00
|
|
|
if (Util.isNull(server)) throw new NullPointerException();
|
2020-08-20 03:15:55 +02:00
|
|
|
final ServerTemplate ft = (template == null)?server.getTemplate():template;
|
|
|
|
if (host.isAvailable() && host.isEnabled() && host == server.getHost() && server.isAvailable() && !server.isRunning() && ft != null && ft.isEnabled() && ft.canUpdate() && (version != null || !ft.requiresVersion())) {
|
2019-06-17 05:13:48 +02:00
|
|
|
StackTraceElement[] origin = new Exception().getStackTrace();
|
|
|
|
|
|
|
|
String name = server.getName();
|
|
|
|
String prefix = name + File.separator + "Updater";
|
2020-06-12 07:45:49 +02:00
|
|
|
Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("updating"), server, true));
|
2019-06-17 05:13:48 +02:00
|
|
|
ExternalSubLogger logger = new ExternalSubLogger(this, prefix, log, null);
|
2020-11-14 08:07:25 +01:00
|
|
|
thread.put(name.toLowerCase(), new ContainedPair<>(server.getAddress().getPort(), logger));
|
2019-06-17 05:13:48 +02:00
|
|
|
|
2021-04-15 06:45:04 +02:00
|
|
|
final SubCreateEvent event = new SubCreateEvent(player, server, ft, version);
|
2019-06-17 05:13:48 +02:00
|
|
|
host.plugin.getPluginManager().callEvent(event);
|
|
|
|
if (!event.isCancelled()) {
|
|
|
|
logger.start();
|
2020-08-20 03:15:55 +02:00
|
|
|
host.queue(new PacketExCreateServer(player, server, ft, version, logger.getExternalAddress(), data -> {
|
|
|
|
finish(player, server, server.getName(), ft, version, server.getAddress().getPort(), prefix, origin, data, s -> {
|
|
|
|
Util.isException(() -> Util.reflect(SubServerImpl.class.getDeclaredField("updating"), server, false));
|
|
|
|
if (callback != null) callback.run(s != null);
|
|
|
|
});
|
2019-06-17 05:13:48 +02:00
|
|
|
logger.stop();
|
|
|
|
this.thread.remove(name.toLowerCase());
|
|
|
|
}));
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
thread.remove(name.toLowerCase());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else return false;
|
|
|
|
}
|
|
|
|
|
2020-08-20 03:15:55 +02:00
|
|
|
private void finish(UUID player, SubServer update, String name, ServerTemplate template, Version version, int port, String prefix, StackTraceElement[] origin, ObjectMap<Integer> data, Callback<SubServer> callback) {
|
|
|
|
try {
|
|
|
|
if (data.getInt(0x0001) == 0) {
|
|
|
|
Logger.get(prefix).info("Saving...");
|
|
|
|
SubServer subserver = update;
|
|
|
|
if (update == null || update.getTemplate() != template || template.getBuildOptions().getBoolean("Update-Settings", false)) {
|
|
|
|
if (host.plugin.exServers.keySet().contains(name.toLowerCase()))
|
|
|
|
host.plugin.exServers.remove(name.toLowerCase());
|
|
|
|
|
|
|
|
ObjectMap<String> server = new ObjectMap<String>();
|
|
|
|
ObjectMap<String> config = new ObjectMap<String>((Map<String, ?>) data.getObject(0x0002));
|
|
|
|
|
|
|
|
if (update == null) {
|
|
|
|
server.set("Enabled", true);
|
|
|
|
server.set("Display", "");
|
|
|
|
server.set("Host", host.getName());
|
|
|
|
server.set("Template", template.getName());
|
|
|
|
server.set("Group", new ArrayList<String>());
|
|
|
|
server.set("Port", port);
|
|
|
|
server.set("Motd", "Some SubServer");
|
|
|
|
server.set("Log", true);
|
|
|
|
server.set("Directory", "./" + name);
|
|
|
|
server.set("Executable", "java -Xmx1024M -jar " + template.getType().toString() + ".jar");
|
|
|
|
server.set("Stop-Command", "stop");
|
|
|
|
server.set("Stop-Action", "NONE");
|
|
|
|
server.set("Run-On-Launch", false);
|
|
|
|
server.set("Restricted", false);
|
|
|
|
server.set("Incompatible", new ArrayList<String>());
|
|
|
|
server.set("Hidden", false);
|
|
|
|
} else {
|
|
|
|
server.setAll(host.plugin.servers.get().getMap("Servers").getMap(name, new HashMap<>()));
|
|
|
|
server.set("Template", template.getName());
|
|
|
|
}
|
|
|
|
server.setAll(config);
|
|
|
|
|
|
|
|
if (update != null) Util.isException(() -> update.getHost().forceRemoveSubServer(name));
|
2021-06-06 07:28:22 +02:00
|
|
|
subserver = host.constructSubServer(name, server.getBoolean("Enabled"), port, ChatColor.translateAlternateColorCodes('&', server.getString("Motd")), server.getBoolean("Log"),
|
2020-08-20 03:15:55 +02:00
|
|
|
server.getRawString("Directory"), server.getRawString("Executable"), server.getRawString("Stop-Command"), server.getBoolean("Hidden"), server.getBoolean("Restricted"));
|
|
|
|
|
|
|
|
if (server.getString("Display").length() > 0) subserver.setDisplayName(server.getString("Display"));
|
|
|
|
subserver.setTemplate(server.getRawString("Template"));
|
|
|
|
for (String group : server.getStringList("Group")) subserver.addGroup(group);
|
|
|
|
SubServer.StopAction action = Util.getDespiteException(() -> SubServer.StopAction.valueOf(server.getRawString("Stop-Action").toUpperCase().replace('-', '_').replace(' ', '_')), null);
|
|
|
|
if (action != null) subserver.setStopAction(action);
|
|
|
|
if (server.contains("Extra")) for (String extra : server.getMap("Extra").getKeys())
|
|
|
|
subserver.addExtra(extra, server.getMap("Extra").getObject(extra));
|
2021-01-17 00:10:51 +01:00
|
|
|
|
2021-04-15 06:45:04 +02:00
|
|
|
if ((update != null && host.plugin.servers.get().getMap("Servers").contains(name)) ||
|
|
|
|
!(subserver.getStopAction() == StopAction.REMOVE_SERVER || subserver.getStopAction() == StopAction.RECYCLE_SERVER || subserver.getStopAction() == StopAction.DELETE_SERVER)) {
|
2021-01-17 00:10:51 +01:00
|
|
|
host.plugin.servers.get().getMap("Servers").set(name, server);
|
|
|
|
host.plugin.servers.save();
|
|
|
|
}
|
2020-08-20 03:15:55 +02:00
|
|
|
|
2021-06-06 07:28:22 +02:00
|
|
|
host.addSubServer(subserver);
|
2020-08-20 03:15:55 +02:00
|
|
|
if (update == null && template.getBuildOptions().getBoolean("Run-On-Finish", true))
|
|
|
|
subserver.start();
|
|
|
|
}
|
|
|
|
|
|
|
|
host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, subserver, update != null, true));
|
|
|
|
callback(origin, callback, subserver);
|
|
|
|
} else {
|
|
|
|
Logger.get(prefix).info(data.getString(0x0003));
|
|
|
|
host.plugin.getPluginManager().callEvent(new SubCreatedEvent(player, host, name, template, version, port, update, update != null, false));
|
|
|
|
callback(origin, callback, null);
|
|
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
callback(origin, callback, null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-01 07:37:48 +02:00
|
|
|
@Override
|
|
|
|
public void terminate() {
|
2020-11-14 08:07:25 +01:00
|
|
|
HashMap<String, Pair<Integer, ExternalSubLogger>> thread = new HashMap<String, Pair<Integer, ExternalSubLogger>>();
|
2017-07-23 06:32:57 +02:00
|
|
|
thread.putAll(this.thread);
|
|
|
|
for (String i : thread.keySet()) {
|
|
|
|
terminate(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void terminate(String name) {
|
2017-07-23 23:05:33 +02:00
|
|
|
if (this.thread.keySet().contains(name.toLowerCase())) {
|
2019-05-10 04:43:34 +02:00
|
|
|
((SubDataClient) host.getSubData()[0]).sendPacket(new PacketExCreateServer(name.toLowerCase()));
|
2017-07-25 21:27:40 +02:00
|
|
|
thread.remove(name.toLowerCase());
|
2017-04-01 07:37:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void waitFor() throws InterruptedException {
|
2020-11-14 08:07:25 +01:00
|
|
|
HashMap<String, Pair<Integer, ExternalSubLogger>> thread = new HashMap<String, Pair<Integer, ExternalSubLogger>>();
|
2017-07-23 06:32:57 +02:00
|
|
|
thread.putAll(this.thread);
|
|
|
|
for (String i : thread.keySet()) {
|
|
|
|
waitFor(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void waitFor(String name) throws InterruptedException {
|
2019-05-10 04:43:34 +02:00
|
|
|
while (this.thread.keySet().contains(name.toLowerCase()) && host.getSubData()[0] != null) {
|
2017-04-01 07:37:48 +02:00
|
|
|
Thread.sleep(250);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Host getHost() {
|
|
|
|
return host;
|
|
|
|
}
|
|
|
|
|
2019-01-05 22:04:45 +01:00
|
|
|
@Override
|
|
|
|
public Range getPortRange() {
|
|
|
|
return ports;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void setPortRange(Range<Integer> value) {
|
|
|
|
if (!value.hasLowerBound() || !value.hasUpperBound()) throw new IllegalArgumentException("Port range is not bound");
|
|
|
|
ports = value;
|
|
|
|
}
|
|
|
|
|
2017-04-01 07:37:48 +02:00
|
|
|
@Override
|
|
|
|
public String getBashDirectory() {
|
|
|
|
return gitBash;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2018-10-08 23:07:44 +02:00
|
|
|
public List<SubLogger> getLoggers() {
|
|
|
|
List<SubLogger> loggers = new ArrayList<SubLogger>();
|
2020-11-14 08:07:25 +01:00
|
|
|
HashMap<String, Pair<Integer, ExternalSubLogger>> temp = new HashMap<String, Pair<Integer, ExternalSubLogger>>();
|
2018-10-08 23:07:44 +02:00
|
|
|
temp.putAll(thread);
|
|
|
|
for (String i : temp.keySet()) {
|
|
|
|
loggers.add(getLogger(i));
|
|
|
|
}
|
|
|
|
return loggers;
|
2017-07-23 06:32:57 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2017-07-23 23:05:33 +02:00
|
|
|
public SubLogger getLogger(String name) {
|
2020-11-14 08:07:25 +01:00
|
|
|
return this.thread.get(name.toLowerCase()).value();
|
2017-04-01 07:37:48 +02:00
|
|
|
}
|
|
|
|
|
2019-01-05 22:04:45 +01:00
|
|
|
@Override
|
|
|
|
public boolean isLogging() {
|
2020-11-14 08:07:25 +01:00
|
|
|
return log.value();
|
2019-01-05 22:04:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void setLogging(boolean value) {
|
|
|
|
if (Util.isNull(value)) throw new NullPointerException();
|
2020-11-14 08:07:25 +01:00
|
|
|
log.value(value);
|
2019-01-05 22:04:45 +01:00
|
|
|
}
|
|
|
|
|
2017-04-01 07:37:48 +02:00
|
|
|
@Override
|
2017-07-23 06:32:57 +02:00
|
|
|
public List<String> getReservedNames() {
|
|
|
|
return new ArrayList<String>(thread.keySet());
|
2017-04-01 07:37:48 +02:00
|
|
|
}
|
2017-05-29 07:00:02 +02:00
|
|
|
|
2018-10-08 23:07:44 +02:00
|
|
|
@Override
|
|
|
|
public List<Integer> getReservedPorts() {
|
|
|
|
List<Integer> ports = new ArrayList<Integer>();
|
2020-11-14 08:07:25 +01:00
|
|
|
for (Pair<Integer, ExternalSubLogger> task : thread.values()) ports.add(task.key());
|
2018-10-08 23:07:44 +02:00
|
|
|
return ports;
|
|
|
|
}
|
|
|
|
|
2017-05-29 07:00:02 +02:00
|
|
|
@Override
|
|
|
|
public Map<String, ServerTemplate> getTemplates() {
|
2020-06-20 03:00:50 +02:00
|
|
|
TreeMap<String, ServerTemplate> map = new TreeMap<String, ServerTemplate>();
|
|
|
|
if (enableRT != null && enableRT) map.putAll(templatesR);
|
|
|
|
map.putAll(templates);
|
|
|
|
return map;
|
2017-05-29 07:00:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public ServerTemplate getTemplate(String name) {
|
|
|
|
if (Util.isNull(name)) throw new NullPointerException();
|
|
|
|
return getTemplates().get(name.toLowerCase());
|
|
|
|
}
|
2017-04-01 07:37:48 +02:00
|
|
|
}
|