Пример #1
0
  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;
  }
Пример #3
0
 @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));
   }
 }
Пример #4
0
 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
}