public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 0; i < N_ELEMENTS; i++)
for (int j = 0; j < N_GENES; j++) GRID[i][j] = new AtomicInteger(rand.nextInt(1000));
for (int i = 0; i < N_EVOLVERS; i++) exec.execute(new Evolver());
TimeUnit.SECONDS.sleep(5);
exec.shutdownNow();
}
class TestingThreadFactory implements ThreadFactory {
public final AtomicInteger numCreated = new AtomicInteger();
private final ThreadFactory factory = Executors.defaultThreadFactory();
public Thread newThread(Runnable r) {
numCreated.incrementAndGet();
return factory.newThread(r);
}
}
public void testPoolExpansion() throws InterruptedException {
int MAX_SIZE = 10;
ExecutorService exec = Executors.newFixedThreadPool(MAX_SIZE);
for (int i = 0; i < 10 * MAX_SIZE; i++)
exec.execute(
new Runnable() {
public void run() {
try {
Thread.sleep(Long.MAX_VALUE);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
for (int i = 0; i < 20 && threadFactory.numCreated.get() < MAX_SIZE; i++) Thread.sleep(100);
assertEquals(threadFactory.numCreated.get(), MAX_SIZE);
exec.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);
}
/** @author Artem Loginov */
@Test
public class ReadWriteCacheConcurrentTest {
private final int systemOffset = 2 * (OIntegerSerializer.INT_SIZE + OLongSerializer.LONG_SIZE);
private static final int THREAD_COUNT = 4;
private static final int PAGE_COUNT = 20;
private static final int FILE_COUNT = 8;
private OReadWriteDiskCache buffer;
private OLocalPaginatedStorage storageLocal;
private String[] fileNames;
private byte seed;
private final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
private final List<Future<Void>> futures = new ArrayList<Future<Void>>(THREAD_COUNT);
private AtomicLongArray fileIds = new AtomicLongArray(FILE_COUNT);
private AtomicIntegerArray pageCounters = new AtomicIntegerArray(FILE_COUNT);
private final AtomicReferenceArray<Queue<Integer>> pagesQueue =
new AtomicReferenceArray<Queue<Integer>>(FILE_COUNT);
private AtomicBoolean continuousWrite = new AtomicBoolean(true);
private AtomicInteger version = new AtomicInteger(1);
@BeforeClass
public void beforeClass() throws IOException {
OGlobalConfiguration.FILE_LOCK.setValue(Boolean.FALSE);
String buildDirectory = System.getProperty("buildDirectory");
if (buildDirectory == null) buildDirectory = ".";
storageLocal =
(OLocalPaginatedStorage)
Orient.instance()
.loadStorage("plocal:" + buildDirectory + "/ReadWriteCacheConcurrentTest");
storageLocal.create(null);
prepareFilesForTest(FILE_COUNT);
}
private void prepareFilesForTest(int filesCount) {
fileNames = new String[filesCount];
for (int i = 0; i < fileNames.length; i++) {
fileNames[i] = "readWriteCacheTest" + i + ".tst";
}
}
@BeforeMethod
public void beforeMethod() throws IOException {
if (buffer != null) {
buffer.close();
deleteUsedFiles(FILE_COUNT);
}
initBuffer();
Random random = new Random();
seed = (byte) (random.nextInt() & 0xFF);
}
private void initBuffer() throws IOException {
buffer =
new OReadWriteDiskCache(
4 * (8 + systemOffset),
15000 * (8 + systemOffset),
8 + systemOffset,
10000,
-1,
storageLocal,
null,
true,
false);
}
@AfterClass
public void afterClass() throws IOException {
buffer.close();
deleteUsedFiles(FILE_COUNT);
storageLocal.delete();
}
private void deleteUsedFiles(int filesCount) {
for (int k = 0; k < filesCount; k++) {
File file =
new File(
storageLocal.getConfiguration().getDirectory() + "/readWriteCacheTest" + k + ".tst");
if (file.exists()) Assert.assertTrue(file.delete());
}
}
public void testAdd() throws Exception {
getIdentitiesOfFiles();
fillFilesWithContent();
validateFilesContent(version.byteValue());
version.compareAndSet(1, 2);
continuousWrite.compareAndSet(true, false);
generateRemainingPagesQueueForAllFiles();
executeConcurrentRandomReadAndWriteOperations();
buffer.flushBuffer();
validateFilesContent(version.byteValue());
}
private void executeConcurrentRandomReadAndWriteOperations()
throws InterruptedException, ExecutionException {
for (int i = 0; i < THREAD_COUNT; i++) {
futures.add(executorService.submit(new Writer()));
}
for (int i = 0; i < THREAD_COUNT; i++) {
futures.add(executorService.submit(new Reader()));
}
for (Future<Void> future : futures) future.get();
}
private void generateRemainingPagesQueueForAllFiles() {
List<Integer>[] array = new ArrayList[FILE_COUNT];
for (int k = 0; k < FILE_COUNT; ++k) {
array[k] = new ArrayList<Integer>(PAGE_COUNT);
for (Integer i = 0; i < PAGE_COUNT; ++i) {
array[k].add(i);
}
}
for (int i = 0; i < FILE_COUNT; ++i) {
Collections.shuffle(array[i]);
pagesQueue.set(i, new ConcurrentLinkedQueue<Integer>(array[i]));
}
}
private void fillFilesWithContent() throws InterruptedException, ExecutionException, IOException {
for (int i = 0; i < THREAD_COUNT; i++) {
futures.add(executorService.submit(new Writer()));
}
for (Future<Void> future : futures) future.get();
futures.clear();
buffer.flushBuffer();
}
private void getIdentitiesOfFiles() throws IOException {
for (int i = 0; i < fileIds.length(); i++) {
fileIds.set(i, buffer.openFile(fileNames[i]));
}
}
private void validateFilesContent(byte version) throws IOException {
for (int k = 0; k < FILE_COUNT; ++k) {
validateFileContent(version, k);
}
}
private void validateFileContent(byte version, int k) throws IOException {
String path =
storageLocal.getConfiguration().getDirectory() + "/readWriteCacheTest" + k + ".tst";
OFileClassic fileClassic = new OFileClassic();
fileClassic.init(path, "r");
fileClassic.open();
for (int i = 0; i < PAGE_COUNT; i++) {
byte[] content = new byte[8];
fileClassic.read(i * (8 + systemOffset) + systemOffset, content, 8);
Assert.assertEquals(
content,
new byte[] {version, 2, 3, seed, 5, 6, (byte) k, (byte) (i & 0xFF)},
" i = " + i);
}
fileClassic.close();
}
private class Writer implements Callable<Void> {
@Override
public Void call() throws Exception {
int fileNumber = getNextFileNumber();
while (shouldContinue(fileNumber)) {
final long pageIndex = getNextPageIndex(fileNumber);
if (pageIndex >= 0) {
writeToFile(fileNumber, pageIndex);
}
fileNumber = getNextFileNumber();
}
return null;
}
private void writeToFile(int fileNumber, long pageIndex) throws IOException {
OCacheEntry cacheEntry = buffer.load(fileIds.get(fileNumber), pageIndex, false);
OCachePointer pointer = cacheEntry.getCachePointer();
pointer.acquireExclusiveLock();
cacheEntry.markDirty();
pointer
.getDataPointer()
.set(
systemOffset,
new byte[] {
version.byteValue(), 2, 3, seed, 5, 6, (byte) fileNumber, (byte) (pageIndex & 0xFF)
},
0,
8);
pointer.releaseExclusiveLock();
buffer.release(cacheEntry);
}
private long getNextPageIndex(int fileNumber) {
if (continuousWrite.get()) {
return pageCounters.getAndIncrement(fileNumber);
} else {
final Integer pageIndex = pagesQueue.get(fileNumber).poll();
if (pageIndex == null) {
return -1;
} else {
return pageIndex;
}
}
}
private boolean shouldContinue(int fileNumber) {
return fileNumber != -1;
}
public int getNextFileNumber() {
int firstFileNumber = new Random().nextInt(FILE_COUNT - 1);
for (int i = 0; i < FILE_COUNT; ++i) {
int fileNumber = (firstFileNumber + i) % FILE_COUNT;
if (isFileFull(fileNumber)) return fileNumber;
}
return -1;
}
private boolean isFileFull(int fileNumber) {
if (continuousWrite.get()) {
return pageCounters.get(fileNumber) < PAGE_COUNT;
} else {
return !pagesQueue.get(fileNumber).isEmpty();
}
}
}
private class Reader implements Callable<Void> {
@Override
public Void call() throws Exception {
long pageIndex = Math.abs(new Random().nextInt() % PAGE_COUNT);
int fileNumber = new Random().nextInt(FILE_COUNT);
OCacheEntry cacheEntry = buffer.load(fileIds.get(fileNumber), pageIndex, false);
OCachePointer pointer = cacheEntry.getCachePointer();
byte[] content = pointer.getDataPointer().get(systemOffset, 8);
buffer.release(cacheEntry);
Assert.assertTrue(content[0] == 1 || content[0] == 2);
Assert.assertEquals(
content,
new byte[] {content[0], 2, 3, seed, 5, 6, (byte) fileNumber, (byte) (pageIndex & 0xFF)});
return null;
}
}
}
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);
}
