public static void main(String[] args) throws Exception {
try {
lock = new Object();
if (args.length > 0) {
NUM = Integer.parseInt(args[0]);
}
execs = Executors.newFixedThreadPool(5);
httpServer = createHttpServer(execs);
port = httpServer.getAddress().getPort();
pool = Executors.newFixedThreadPool(10);
httpServer.start();
for (int i = 0; i < NUM; i++) {
pool.execute(new Client());
if (error) {
throw new Exception("error in test");
}
}
System.out.println("Main thread waiting");
pool.shutdown();
long latest = System.currentTimeMillis() + 200 * 1000;
while (System.currentTimeMillis() < latest) {
if (pool.awaitTermination(2000L, TimeUnit.MILLISECONDS)) {
System.out.println("Main thread done!");
return;
}
if (error) {
throw new Exception("error in test");
}
}
throw new Exception("error in test: timed out");
} finally {
httpServer.stop(0);
pool.shutdownNow();
execs.shutdownNow();
}
}
public static void main(String[] args) {
// TODO main
OptionParser parser = new OptionParser();
parser.acceptsAll(Arrays.asList("h", "help"), "Show this help dialog.");
OptionSpec<String> serverOption =
parser
.acceptsAll(Arrays.asList("s", "server"), "Server to join.")
.withRequiredArg()
.describedAs("server-address[:port]");
OptionSpec<String> proxyOption =
parser
.acceptsAll(
Arrays.asList("P", "proxy"),
"SOCKS proxy to use. Ignored in presence of 'socks-proxy-list'.")
.withRequiredArg()
.describedAs("proxy-address");
OptionSpec<String> ownerOption =
parser
.acceptsAll(
Arrays.asList("o", "owner"), "Owner of the bot (username of in-game control).")
.withRequiredArg()
.describedAs("username");
OptionSpec<?> offlineOption =
parser.acceptsAll(
Arrays.asList("O", "offline"),
"Offline-mode. Ignores 'password' and 'account-list' (will "
+ "generate random usernames if 'username' is not supplied).");
OptionSpec<?> autoRejoinOption =
parser.acceptsAll(Arrays.asList("a", "auto-rejoin"), "Auto-rejoin a server on disconnect.");
OptionSpec<Integer> loginDelayOption =
parser
.acceptsAll(
Arrays.asList("d", "login-delay"),
"Delay between bot joins, in milliseconds. 5000 is "
+ "recommended if not using socks proxies.")
.withRequiredArg()
.describedAs("delay")
.ofType(Integer.class);
OptionSpec<Integer> botAmountOption =
parser
.acceptsAll(
Arrays.asList("b", "bot-amount"),
"Amount of bots to join. Must be <= amount of accounts.")
.withRequiredArg()
.describedAs("amount")
.ofType(Integer.class);
OptionSpec<String> accountListOption =
parser
.accepts(
"account-list",
"File containing a list of accounts, in username/email:password format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> socksProxyListOption =
parser
.accepts(
"socks-proxy-list",
"File containing a list of SOCKS proxies, in address:port format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> httpProxyListOption =
parser
.accepts(
"http-proxy-list",
"File containing a list of HTTP proxies, in address:port format.")
.withRequiredArg()
.describedAs("file");
OptionSet options;
try {
options = parser.parse(args);
} catch (OptionException exception) {
try {
parser.printHelpOn(System.out);
} catch (Exception exception1) {
exception1.printStackTrace();
}
return;
}
if (options.has("help")) {
printHelp(parser);
return;
}
final boolean offline = options.has(offlineOption);
final boolean autoRejoin = options.has(autoRejoinOption);
final List<String> accounts;
if (options.has(accountListOption)) {
accounts = loadAccounts(options.valueOf(accountListOption));
} else if (!offline) {
System.out.println("Option 'accounts' must be supplied in " + "absence of option 'offline'.");
printHelp(parser);
return;
} else accounts = null;
final String server;
if (!options.has(serverOption)) {
System.out.println("Option 'server' required.");
printHelp(parser);
return;
} else server = options.valueOf(serverOption);
final String owner;
if (!options.has(ownerOption)) {
System.out.println("Option 'owner' required.");
printHelp(parser);
return;
} else owner = options.valueOf(ownerOption);
final List<String> socksProxies;
if (options.has(socksProxyListOption))
socksProxies = loadProxies(options.valueOf(socksProxyListOption));
else socksProxies = null;
final boolean useProxy = socksProxies != null;
final List<String> httpProxies;
if (options.has(httpProxyListOption))
httpProxies = loadLoginProxies(options.valueOf(httpProxyListOption));
else if (!offline && accounts != null) {
System.out.println(
"Option 'http-proxy-list' required if " + "option 'account-list' is supplied.");
printHelp(parser);
return;
} else httpProxies = null;
final int loginDelay;
if (options.has(loginDelayOption)) loginDelay = options.valueOf(loginDelayOption);
else loginDelay = 0;
final int botAmount;
if (!options.has(botAmountOption)) {
System.out.println("Option 'bot-amount' required.");
printHelp(parser);
return;
} else botAmount = options.valueOf(botAmountOption);
initGui();
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
final Queue<Runnable> lockQueue = new ArrayDeque<Runnable>();
ExecutorService service = Executors.newFixedThreadPool(botAmount + (loginDelay > 0 ? 1 : 0));
final Object firstWait = new Object();
if (loginDelay > 0) {
service.execute(
new Runnable() {
@Override
public void run() {
synchronized (firstWait) {
try {
firstWait.wait();
} catch (InterruptedException exception) {
}
}
while (true) {
if (die) return;
while (slotsTaken.get() >= 2) {
synchronized (slotsTaken) {
try {
slotsTaken.wait(500);
} catch (InterruptedException exception) {
}
}
}
synchronized (lockQueue) {
if (lockQueue.size() > 0) {
Runnable thread = lockQueue.poll();
synchronized (thread) {
thread.notifyAll();
}
lockQueue.offer(thread);
} else continue;
}
try {
Thread.sleep(loginDelay);
} catch (InterruptedException exception) {
}
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
}
}
});
}
final List<String> accountsInUse = new ArrayList<String>();
for (int i = 0; i < botAmount; i++) {
final int botNumber = i;
Runnable runnable =
new Runnable() {
@Override
public void run() {
if (loginDelay > 0)
synchronized (lockQueue) {
lockQueue.add(this);
}
Random random = new Random();
if (!offline) {
boolean authenticated = false;
user:
while (true) {
if (authenticated) {
authenticated = false;
sessionCount.decrementAndGet();
}
Session session = null;
String loginProxy;
String account = accounts.get(random.nextInt(accounts.size()));
synchronized (accountsInUse) {
if (accountsInUse.size() == accounts.size()) System.exit(0);
while (accountsInUse.contains(account))
account = accounts.get(random.nextInt(accounts.size()));
accountsInUse.add(account);
}
String[] accountParts = account.split(":");
while (true) {
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
loginProxy = httpProxies.get(random.nextInt(httpProxies.size()));
try {
session = Util.retrieveSession(accountParts[0], accountParts[1], loginProxy);
// addAccount(session);
sessionCount.incrementAndGet();
authenticated = true;
break;
} catch (AuthenticationException exception) {
System.err.println("[Bot" + botNumber + "] " + exception);
if (!exception.getMessage().startsWith("Exception"))
// && !exception.getMessage().equals(
// "Too many failed logins"))
continue user;
}
}
System.out.println(
"["
+ session.getUsername()
+ "] Password: "******", Session ID: "
+ session.getSessionId());
while (!joins.get()) {
synchronized (joins) {
try {
joins.wait(5000);
} catch (InterruptedException exception) {
}
}
}
if (loginDelay > 0) {
synchronized (this) {
try {
synchronized (firstWait) {
firstWait.notifyAll();
}
wait();
} catch (InterruptedException exception) {
}
}
}
while (true) {
String proxy =
useProxy ? socksProxies.get(random.nextInt(socksProxies.size())) : null;
try {
new DarkBotMCSpambot(
DARK_BOT,
server,
session.getUsername(),
session.getPassword(),
session.getSessionId(),
null,
proxy,
owner);
if (die) break user;
else if (!autoRejoin) break;
} catch (Exception exception) {
exception.printStackTrace();
System.out.println(
"["
+ session.getUsername()
+ "] Error connecting: "
+ exception.getCause().toString());
}
}
System.out.println("[" + session.getUsername() + "] Account failed");
}
} else {
while (true) {
String proxy =
useProxy ? socksProxies.get(random.nextInt(socksProxies.size())) : null;
try {
String username = "";
if (accounts != null) {
username = accounts.get(random.nextInt(accounts.size())).split(":")[0];
synchronized (accountsInUse) {
while (accountsInUse.contains(username))
username = accounts.get(random.nextInt(accounts.size()));
accountsInUse.add(username);
}
} else
for (int i = 0; i < 10 + random.nextInt(6); i++)
username += alphas[random.nextInt(alphas.length)];
if (loginDelay > 0) {
synchronized (this) {
try {
synchronized (firstWait) {
firstWait.notifyAll();
}
wait();
} catch (InterruptedException exception) {
}
}
}
new DarkBotMCSpambot(DARK_BOT, server, username, "", "", null, proxy, owner);
if (die || !autoRejoin) break;
else continue;
} catch (Exception exception) {
System.out.println(
"[Bot" + botNumber + "] Error connecting: " + exception.toString());
}
}
}
}
};
service.execute(runnable);
}
service.shutdown();
while (!service.isTerminated()) {
try {
service.awaitTermination(9000, TimeUnit.DAYS);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
}
System.exit(0);
}
/**
* Discover WS device on the local network
*
* @return list of unique devices access strings which might be URLs in most cases
*/
public static Collection<String> discoverWsDevices() {
final Collection<String> addresses = new ConcurrentSkipListSet<>();
final CountDownLatch serverStarted = new CountDownLatch(1);
final CountDownLatch serverFinished = new CountDownLatch(1);
final Collection<InetAddress> addressList = new ArrayList<>();
try {
final Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
if (interfaces != null) {
while (interfaces.hasMoreElements()) {
NetworkInterface anInterface = interfaces.nextElement();
if (!anInterface.isLoopback()) {
final List<InterfaceAddress> interfaceAddresses = anInterface.getInterfaceAddresses();
for (InterfaceAddress address : interfaceAddresses) {
addressList.add(address.getAddress());
}
}
}
}
} catch (SocketException e) {
e.printStackTrace();
}
ExecutorService executorService = Executors.newCachedThreadPool();
for (final InetAddress address : addressList) {
Runnable runnable =
new Runnable() {
public void run() {
try {
final String uuid = UUID.randomUUID().toString();
final String probe =
WS_DISCOVERY_PROBE_MESSAGE.replaceAll(
"<wsa:MessageID>urn:uuid:.*</wsa:MessageID>",
"<wsa:MessageID>urn:uuid:" + uuid + "</wsa:MessageID>");
final int port = random.nextInt(20000) + 40000;
@SuppressWarnings("SocketOpenedButNotSafelyClosed")
final DatagramSocket server = new DatagramSocket(port, address);
new Thread() {
public void run() {
try {
final DatagramPacket packet = new DatagramPacket(new byte[4096], 4096);
server.setSoTimeout(WS_DISCOVERY_TIMEOUT);
long timerStarted = System.currentTimeMillis();
while (System.currentTimeMillis() - timerStarted < (WS_DISCOVERY_TIMEOUT)) {
serverStarted.countDown();
server.receive(packet);
final Collection<String> collection =
parseSoapResponseForUrls(
Arrays.copyOf(packet.getData(), packet.getLength()));
for (String key : collection) {
addresses.add(key);
}
}
} catch (SocketTimeoutException ignored) {
} catch (Exception e) {
e.printStackTrace();
} finally {
serverFinished.countDown();
server.close();
}
}
}.start();
try {
serverStarted.await(1000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (address instanceof Inet4Address) {
server.send(
new DatagramPacket(
probe.getBytes(),
probe.length(),
InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv4),
WS_DISCOVERY_PORT));
} else {
server.send(
new DatagramPacket(
probe.getBytes(),
probe.length(),
InetAddress.getByName(WS_DISCOVERY_ADDRESS_IPv6),
WS_DISCOVERY_PORT));
}
} catch (Exception e) {
e.printStackTrace();
}
try {
serverFinished.await((WS_DISCOVERY_TIMEOUT), TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
executorService.submit(runnable);
}
try {
executorService.shutdown();
executorService.awaitTermination(WS_DISCOVERY_TIMEOUT + 2000, TimeUnit.MILLISECONDS);
} catch (InterruptedException ignored) {
}
return addresses;
}
public static void main(String[] args) {
// TODO main
OptionParser parser = new OptionParser();
parser.acceptsAll(Arrays.asList("h", "help"), "Show this help dialog.");
OptionSpec<String> serverOption =
parser
.acceptsAll(Arrays.asList("s", "server"), "Server to join.")
.withRequiredArg()
.describedAs("server-address[:port]");
OptionSpec<String> proxyOption =
parser
.acceptsAll(
Arrays.asList("P", "proxy"),
"SOCKS proxy to use. Ignored in presence of 'socks-proxy-list'.")
.withRequiredArg()
.describedAs("proxy-address");
OptionSpec<String> ownerOption =
parser
.acceptsAll(
Arrays.asList("o", "owner"), "Owner of the bot (username of in-game control).")
.withRequiredArg()
.describedAs("username");
OptionSpec<?> offlineOption =
parser.acceptsAll(
Arrays.asList("O", "offline"),
"Offline-mode. Ignores 'password' and 'account-list' (will "
+ "generate random usernames if 'username' is not supplied).");
OptionSpec<?> autoRejoinOption =
parser.acceptsAll(Arrays.asList("a", "auto-rejoin"), "Auto-rejoin a server on disconnect.");
OptionSpec<Integer> loginDelayOption =
parser
.acceptsAll(
Arrays.asList("d", "login-delay"),
"Delay between bot joins, in milliseconds. 5000 is "
+ "recommended if not using socks proxies.")
.withRequiredArg()
.describedAs("delay")
.ofType(Integer.class);
OptionSpec<Integer> botAmountOption =
parser
.acceptsAll(
Arrays.asList("b", "bot-amount"),
"Amount of bots to join. Must be <= amount of accounts.")
.withRequiredArg()
.describedAs("amount")
.ofType(Integer.class);
OptionSpec<String> protocolOption =
parser
.accepts(
"protocol",
"Protocol version to use. Can be either protocol number or Minecraft version.")
.withRequiredArg();
OptionSpec<?> protocolsOption =
parser.accepts("protocols", "List available protocols and exit.");
OptionSpec<String> accountListOption =
parser
.accepts(
"account-list",
"File containing a list of accounts, in username/email:password format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> socksProxyListOption =
parser
.accepts(
"socks-proxy-list",
"File containing a list of SOCKS proxies, in address:port format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> httpProxyListOption =
parser
.accepts(
"http-proxy-list",
"File containing a list of HTTP proxies, in address:port format.")
.withRequiredArg()
.describedAs("file");
OptionSpec<String> captchaListOption =
parser
.accepts("captcha-list", "File containing a list of chat baised captcha to bypass.")
.withRequiredArg()
.describedAs("file");
OptionSet options;
try {
options = parser.parse(args);
} catch (OptionException exception) {
try {
parser.printHelpOn(System.out);
} catch (Exception exception1) {
exception1.printStackTrace();
}
return;
}
if (options.has("help")) {
printHelp(parser);
return;
}
if (options.has(protocolsOption)) {
System.out.println("Available protocols:");
for (ProtocolProvider provider : ProtocolProvider.getProviders())
System.out.println(
"\t"
+ provider.getMinecraftVersion()
+ " ("
+ provider.getSupportedVersion()
+ "): "
+ provider.getClass().getName());
System.out.println(
"If no protocols are listed above, you may attempt to specify a protocol version in case the provider is actually in the class-path.");
return;
}
final boolean offline = options.has(offlineOption);
final boolean autoRejoin = options.has(autoRejoinOption);
final List<String> accounts;
if (options.has(accountListOption)) {
accounts = loadAccounts(options.valueOf(accountListOption));
} else if (!offline) {
System.out.println("Option 'accounts' must be supplied in " + "absence of option 'offline'.");
printHelp(parser);
return;
} else accounts = null;
final List<String> captcha;
if (options.has(captchaListOption)) readCaptchaFile(options.valueOf(captchaListOption));
final String server;
if (!options.has(serverOption)) {
System.out.println("Option 'server' required.");
printHelp(parser);
return;
} else server = options.valueOf(serverOption);
final String owner;
if (!options.has(ownerOption)) {
System.out.println("Option 'owner' required.");
printHelp(parser);
return;
} else owner = options.valueOf(ownerOption);
final int protocol;
if (options.has(protocolOption)) {
String protocolString = options.valueOf(protocolOption);
int parsedProtocol;
try {
parsedProtocol = Integer.parseInt(protocolString);
} catch (NumberFormatException exception) {
ProtocolProvider foundProvider = null;
for (ProtocolProvider provider : ProtocolProvider.getProviders())
if (protocolString.equals(provider.getMinecraftVersion())) foundProvider = provider;
if (foundProvider == null) {
System.out.println("No provider found for Minecraft version '" + protocolString + "'.");
return;
} else parsedProtocol = foundProvider.getSupportedVersion();
}
protocol = parsedProtocol;
} else protocol = MinecraftBot.LATEST_PROTOCOL;
final List<String> socksProxies;
if (options.has(socksProxyListOption))
socksProxies = loadProxies(options.valueOf(socksProxyListOption));
else socksProxies = null;
final boolean useProxy = socksProxies != null;
final List<String> httpProxies;
if (options.has(httpProxyListOption))
httpProxies = loadLoginProxies(options.valueOf(httpProxyListOption));
else if (!offline && accounts != null) {
System.out.println(
"Option 'http-proxy-list' required if " + "option 'account-list' is supplied.");
printHelp(parser);
return;
} else httpProxies = null;
final int loginDelay;
if (options.has(loginDelayOption)) loginDelay = options.valueOf(loginDelayOption);
else loginDelay = 0;
final int botAmount;
if (!options.has(botAmountOption)) {
System.out.println("Option 'bot-amount' required.");
printHelp(parser);
return;
} else botAmount = options.valueOf(botAmountOption);
initGui();
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
final Queue<Runnable> lockQueue = new ArrayDeque<Runnable>();
ExecutorService service = Executors.newFixedThreadPool(botAmount + (loginDelay > 0 ? 1 : 0));
final Object firstWait = new Object();
if (loginDelay > 0) {
service.execute(
new Runnable() {
@Override
public void run() {
synchronized (firstWait) {
try {
firstWait.wait();
} catch (InterruptedException exception) {
}
}
while (true) {
try {
Thread.sleep(loginDelay);
} catch (InterruptedException exception) {
}
synchronized (lockQueue) {
if (lockQueue.size() > 0) {
Runnable thread = lockQueue.poll();
synchronized (thread) {
thread.notifyAll();
}
lockQueue.offer(thread);
} else continue;
}
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
}
}
});
}
final List<String> accountsInUse = new ArrayList<String>();
final Map<String, AtomicInteger> workingProxies = new HashMap<String, AtomicInteger>();
for (int i = 0; i < botAmount; i++) {
final int botNumber = i;
Runnable runnable =
new Runnable() {
@Override
public void run() {
if (loginDelay > 0)
synchronized (lockQueue) {
lockQueue.add(this);
}
Random random = new Random();
if (!offline) {
AuthService authService = new LegacyAuthService();
boolean authenticated = false;
user:
while (true) {
if (authenticated) {
authenticated = false;
sessionCount.decrementAndGet();
}
Session session = null;
String loginProxy;
String account = accounts.get(random.nextInt(accounts.size()));
synchronized (accountsInUse) {
if (accountsInUse.size() == accounts.size()) System.exit(0);
while (accountsInUse.contains(account))
account = accounts.get(random.nextInt(accounts.size()));
accountsInUse.add(account);
}
String[] accountParts = account.split(":");
while (true) {
while (!sessions.get()) {
synchronized (sessions) {
try {
sessions.wait(5000);
} catch (InterruptedException exception) {
}
}
}
synchronized (workingProxies) {
Iterator<String> iterator = workingProxies.keySet().iterator();
if (iterator.hasNext()) loginProxy = iterator.next();
else loginProxy = httpProxies.get(random.nextInt(httpProxies.size()));
;
}
try {
session =
authService.login(
accountParts[0],
accountParts[1],
toProxy(loginProxy, Proxy.Type.HTTP));
// addAccount(session);
synchronized (workingProxies) {
AtomicInteger count = workingProxies.get(loginProxy);
if (count != null) count.set(0);
else workingProxies.put(loginProxy, new AtomicInteger());
}
sessionCount.incrementAndGet();
authenticated = true;
break;
} catch (IOException exception) {
synchronized (workingProxies) {
workingProxies.remove(loginProxy);
}
System.err.println("[Bot" + botNumber + "] " + loginProxy + ": " + exception);
} catch (AuthenticationException exception) {
if (exception.getMessage().contains("Too many failed logins")) {
synchronized (workingProxies) {
AtomicInteger count = workingProxies.get(loginProxy);
if (count != null && count.incrementAndGet() >= 5)
workingProxies.remove(loginProxy);
}
}
System.err.println("[Bot" + botNumber + "] " + loginProxy + ": " + exception);
continue user;
}
}
System.out.println("[" + session.getUsername() + "] " + session);
while (!joins.get()) {
synchronized (joins) {
try {
joins.wait(5000);
} catch (InterruptedException exception) {
}
}
}
if (loginDelay > 0) {
synchronized (this) {
try {
synchronized (firstWait) {
firstWait.notifyAll();
}
wait();
} catch (InterruptedException exception) {
}
}
}
while (true) {
String proxy =
useProxy ? socksProxies.get(random.nextInt(socksProxies.size())) : null;
try {
DarkBotMCSpambot bot =
new DarkBotMCSpambot(
generateData(
server,
session.getUsername(),
session.getPassword(),
authService,
session,
protocol,
null,
proxy),
owner);
while (bot.getBot().isConnected()) {
try {
Thread.sleep(500);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
}
if (!autoRejoin) break;
} catch (Exception exception) {
exception.printStackTrace();
System.out.println(
"["
+ session.getUsername()
+ "] Error connecting: "
+ exception.getCause().toString());
}
}
System.out.println("[" + session.getUsername() + "] Account failed");
}
} else {
while (true) {
String proxy =
useProxy ? socksProxies.get(random.nextInt(socksProxies.size())) : null;
try {
String username;
if (accounts != null) {
username = accounts.get(random.nextInt(accounts.size())).split(":")[0];
synchronized (accountsInUse) {
while (accountsInUse.contains(username))
username = accounts.get(random.nextInt(accounts.size()));
accountsInUse.add(username);
}
} else username = Util.generateRandomString(10 + random.nextInt(6));
if (loginDelay > 0) {
synchronized (this) {
try {
synchronized (firstWait) {
firstWait.notifyAll();
}
wait();
} catch (InterruptedException exception) {
}
}
}
DarkBotMCSpambot bot =
new DarkBotMCSpambot(
generateData(server, username, null, null, null, protocol, null, proxy),
owner);
while (bot.getBot().isConnected()) {
try {
Thread.sleep(500);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
}
if (!autoRejoin) break;
else continue;
} catch (Exception exception) {
System.out.println(
"[Bot" + botNumber + "] Error connecting: " + exception.toString());
}
}
}
}
};
service.execute(runnable);
}
service.shutdown();
while (!service.isTerminated()) {
try {
service.awaitTermination(9000, TimeUnit.DAYS);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
}
System.exit(0);
}