private static final class MessageFormatter {
private static final Pattern variablePattern =
Pattern.compile("(?i)\\$(\\{[a-z0-9_]{1,}\\}|[a-z0-9_]{1,})");
private static final Pattern colorPattern = Pattern.compile("(?i)&[0-9A-FK-OR]");
private final Map<String, String> variables;
public MessageFormatter() {
variables = new HashMap<String, String>();
}
public synchronized void setVariable(String variable, String value) {
if (value == null) variables.remove(value);
else variables.put(variable, value);
}
public synchronized String format(String message) {
Matcher matcher = variablePattern.matcher(message);
while (matcher.find()) {
String variable = matcher.group();
variable = variable.substring(1);
if (variable.startsWith("{") && variable.endsWith("}"))
variable = variable.substring(1, variable.length() - 1);
String value = variables.get(variable);
if (value == null) value = "";
message =
message.replaceFirst(Pattern.quote(matcher.group()), Matcher.quoteReplacement(value));
}
matcher = colorPattern.matcher(message);
while (matcher.find())
message =
message.substring(0, matcher.start()) + "\247" + message.substring(matcher.end() - 1);
return message;
}
}
/**
* Check whether provided path must be excluded from evictions.
*
* @param path Path.
* @return {@code True} in case non block of related file must be excluded.
* @throws GridException In case of faulty patterns.
*/
public boolean exclude(GridGgfsPath path) throws GridException {
assert path != null;
Collection<Pattern> excludePatterns0;
if (excludeRecompile.compareAndSet(true, false)) {
// Recompile.
Collection<String> excludePaths0 = excludePaths;
if (excludePaths0 != null) {
excludePatterns0 = new HashSet<>(excludePaths0.size(), 1.0f);
for (String excludePath : excludePaths0) {
try {
excludePatterns0.add(Pattern.compile(excludePath));
} catch (PatternSyntaxException ignore) {
throw new GridException("Invalid regex pattern: " + excludePath);
}
}
excludePatterns = excludePatterns0;
} else excludePatterns0 = excludePatterns = null;
} else excludePatterns0 = excludePatterns;
if (excludePatterns0 != null) {
String pathStr = path.toString();
for (Pattern pattern : excludePatterns0) {
if (pattern.matcher(pathStr).matches()) return true;
}
}
return false;
}
@Override
@EventHandler
public void onChatReceived(ChatReceivedEvent event) {
super.onChatReceived(event);
String message = Util.stripColors(event.getMessage());
if (message.startsWith("Please register with \"/register")) {
String password = Util.generateRandomString(10 + random.nextInt(6));
bot.say("/register " + password + " " + password);
} else if (message.contains("You are not member of any faction.")
&& spamMessage != null
&& createFaction) {
String msg = "/f create " + Util.generateRandomString(7 + random.nextInt(4));
bot.say(msg);
}
for (String s : captchaList) {
Matcher captchaMatcher = Pattern.compile(s).matcher(message);
if (captchaMatcher.matches()) bot.say(captchaMatcher.group(1));
}
}
private static List<String> loadAccounts(String fileName) {
List<String> accounts = new ArrayList<String>();
try {
Pattern pattern = Pattern.compile("[\\w]{1,16}");
BufferedReader reader = new BufferedReader(new FileReader(new File(fileName)));
String line;
while ((line = reader.readLine()) != null) {
Matcher matcher = pattern.matcher(line);
if (!matcher.find()) continue;
String username = matcher.group();
if (!matcher.find()) continue;
String password = matcher.group();
accounts.add(username + ":" + password);
}
reader.close();
} catch (Exception exception) {
throw new RuntimeException(exception);
}
System.out.println("Loaded " + accounts.size() + " accounts.");
return accounts;
}
public abstract class AbstractHTTPKeyServerClient extends AbstractRetryingKeyServerClient {
private static final Pattern resultParserPattern =
Pattern.compile("Result:\\s*(.*?)\\r?\\n", Pattern.CASE_INSENSITIVE);
public String createKey(String hostName, KeyServerClient.Usage usage) {
String res = null;
if (hostName != null) {
switch (usage) {
case SNMP:
{
res = hostName + "-" + "adsl";
break;
}
default:
{
throw new IllegalArgumentException();
}
}
}
return res;
}
/*
* Parse the response HTML
*/
protected static ReplyType parseResponseHTML(String responseHTML) {
ReplyType res = ReplyType.UNKNOWN_RESPONSE;
String strres = null;
Matcher matcher = resultParserPattern.matcher(responseHTML);
if (matcher.find()) {
strres = matcher.group(1);
}
if (strres != null) {
for (ReplyType rt : ReplyType.values()) {
if (strres.equalsIgnoreCase(rt.nativeReply)) {
res = rt;
break;
}
}
}
return res;
}
/**
* Builds the actual string that is POSTed to the KeyServer
*
* @param localhostname Local Hostname
* @param request KeyServer request
* @param key Key to allocate/deallocate
* @return String to POST
*/
protected static String buildRequestString(
String localhostname, RequestType request, String key) {
return buildRequestString(localhostname, request.getNativeRequest(), key);
}
protected static String buildRequestString(String localhostname, String requesttype, String key) {
return "remote_address=" + localhostname + "&reqtype=" + requesttype + "&dslam-key=" + key;
}
/** Possible replies from the KeyServer */
protected static enum ReplyType {
/** Attempt to get/allocate key successful */
KEY_GRANTED("Key_Granted"),
/** Attempt to get/allocate key failed - Key allocated elsewhere */
KEY_BUSY("Key Busy"),
/** Attempt to return/deallocate key successful */
KEY_RETURNED("Key_Returned"),
/** Attempt to get/allocate key failed - Key blocked by other party */
KEY_BLOCKED("Key_Blocked"),
/** Attempt to block entire DSLAM successful */
KEY_BLOCK_OK("KeyServer_BLOCK Ok"),
/** Attempt to unblock entire DSLAM successful */
KEY_UNBLOCK_OK("KeyServer UNBLOCK Ok"),
UNKNOWN_RESPONSE("UNKNOWN_RESPONSE"), // not a direct reply
KEYSERVER_ERROR("KEYSERVER_ERROR"), // not a direct reply
KEY_NOT_RETURNED("KEY_NOT_RETURNED"); // not a direct reply
private String nativeReply;
ReplyType(String reply) {
this.nativeReply = reply;
}
public String getNativeReply() {
return this.nativeReply;
}
}
/** Possible KeyServer requests */
protected static enum RequestType {
/** Get/Allocate Key Request */
GET_KEY("get_dslamkey", ReplyType.KEY_GRANTED),
/** Return/Deallocate Key Request */
RETURN_KEY("return_dslamkey", ReplyType.KEY_RETURNED);
private String nativeRequest;
private ReplyType successReply;
RequestType(String request, ReplyType success) {
this.nativeRequest = request;
this.successReply = success;
}
public String getNativeRequest() {
return this.nativeRequest;
}
public ReplyType getSuccessReply() {
return this.successReply;
}
}
/** KeyServer returned {@link ReplyType} does not match expected {@link ReplyType} */
protected static class OperationFailedException extends Exception {
public OperationFailedException(String message) {
super(message);
}
/** */
private static final long serialVersionUID = -7363443310028754594L;
}
public static AtomicLong httpBeginCount = new AtomicLong();
public static AtomicLong httpEndCount = new AtomicLong();
public static AtomicLong httpRunningCount = new AtomicLong();
public static AtomicLong httpRunningCountMax = new AtomicLong();
public static FrequencyCounter httpBeginFrequencyCounter =
new CountLimitedFrequencyCounter(8640, 10 * 1000L * 1000L * 1000L); // 8640*(10 sec)=24 hours
public static FrequencyCounter httpEndFrequencyCounter =
new CountLimitedFrequencyCounter(8640, 10 * 1000L * 1000L * 1000L); // 8640*(10 sec)=24 hours
}