private static List<Pair<String, Token>> preTokensToUndelimitedTokens( List<Pair<String, PreToken>> pretokens) { List<Pair<String, Token>> tokens = new ArrayList<>(); int size = pretokens.size(); for (int i = 0; i < size; i++) { String chars = pretokens.get(i).getFirst(); PreToken pt = pretokens.get(i).getSecond(); switch (pt) { case ALPHA_PLUS: int next = i + 1; if (next >= size) { tokens.add(new Pair<>(chars, Token.ALPHA_PLUS)); } else { // the next token must be DIGIT_PLUS since we know there are no delimiters String bothChars = chars + pretokens.get(next).getFirst(); tokens.add(new Pair<>(bothChars, Token.ALPHA_PLUS_DIGIT_PLUS)); i++; } break; case DIGIT_PLUS: tokens.add(new Pair<>(chars, Token.DIGIT_PLUS)); break; default: throw new BatfishException("Unexpected pretoken " + pt); } } return tokens; }
@Override @JsonValue public String toString() { return super.toString(); } }
private Pair<Integer, Integer> minHammingDistance(String s, String[] choices, int len) { int min = Integer.MAX_VALUE; int minIndex = -1; for (int i = 0; i < len; i++) { int dist = hammingDistance(s, choices[i]); if (dist < min) { min = dist; minIndex = i; } } return new Pair<>(minIndex, min); } }
public boolean isChanged(String s) { for (Pair<String, Expr> pair : this._changedVariables) { if (pair.getFirst().equals(s)) { return true; } } return false; }
@JsonIgnore public Ip getRemoteIp() { return _key.getSecond(); }
private static List<Pair<String, PreToken>> pretokenizeName(String name) { List<Pair<String, PreToken>> pattern = new ArrayList<>(); char c = name.charAt(0); PreToken currPT = PreToken.charToPreToken(c); StringBuffer curr = new StringBuffer(); curr.append(c); for (int i = 1; i < name.length(); i++) { c = name.charAt(i); PreToken newPT = PreToken.charToPreToken(c); if (newPT != currPT) { pattern.add(new Pair<>(new String(curr), currPT)); curr = new StringBuffer(); currPT = newPT; } curr.append(c); } pattern.add(new Pair<>(new String(curr), currPT)); return pattern; }
@JsonIgnore public Ip getLocalIp() { return _key.getFirst(); }
private Optional<NodeRoleDimension> toPrimaryNodeRoleDimensionIfAboveThreshold( Pair<Integer, Double> bestRegexAndScore, List<List<String>> candidates) { if (bestRegexAndScore.getSecond() >= ROLE_THRESHOLD) { NodeRoleDimension bestNRD = toNodeRoleDimension( bestRegexAndScore, candidates, NodeRoleDimension.AUTO_DIMENSION_PRIMARY); return Optional.of(bestNRD); } else { return Optional.empty(); } }
private static List<Pair<String, Token>> preTokensToDelimitedTokens( List<Pair<String, PreToken>> pretokens) { List<Pair<String, Token>> tokens = new ArrayList<>(); int size = pretokens.size(); for (int i = 0; i < size; i++) { StringBuilder chars = new StringBuilder(pretokens.get(i).getFirst()); PreToken pt = pretokens.get(i).getSecond(); switch (pt) { case ALPHA_PLUS: // combine everything up to the next delimiter into a single alphanumeric token int next = i + 1; while (next < size && pretokens.get(next).getSecond() != PreToken.DELIMITER) { chars.append(pretokens.get(next).getFirst()); next++; } i = next - 1; tokens.add(new Pair<>(chars.toString(), Token.ALNUM_PLUS)); break; case DELIMITER: tokens.add(new Pair<>(chars.toString(), Token.DELIMITER)); break; case DIGIT_PLUS: tokens.add(new Pair<>(chars.toString(), Token.DIGIT_PLUS)); break; default: throw new BatfishException("Unknown pretoken " + pt); } } return tokens; }
private Pair<Integer, Double> findBestRegex(final List<List<String>> candidates) { // choose the candidate role regex with the maximal "role score" return IntStream.range(0, candidates.size()) .mapToObj(i -> new Pair<>(i, computeRoleScore(regexTokensToRegex(candidates.get(i))))) .max(Comparator.comparingDouble(Pair::getSecond)) .orElseThrow(() -> new BatfishException("this exception should not be reachable")); }
@Override protected T1 featureValueOf(Pair<T1, T2> actual) { return actual.getFirst(); } }
@Override protected T2 featureValueOf(Pair<T1, T2> actual) { return actual.getSecond(); } }
private boolean inferCommonRegex(Collection<String> nodes) { for (int attempts = 0; attempts < 10; attempts++) { // pick a random node name, in order to find one with a common pattern // the node name that is used to infer a regex String chosenNode = Iterables.get(nodes, new Random().nextInt(nodes.size())); _tokens = tokenizeName(chosenNode); _regex = _tokens.stream() .map((p) -> p.getSecond().tokenToRegex(p.getFirst())) .collect(Collectors.toList()); Pattern p = Pattern.compile(String.join("", _regex), _patternFlags); _matchingNodes = nodes.stream().filter((node) -> p.matcher(node).matches()).collect(Collectors.toList()); // keep this regex if it matches a sufficient fraction of node names; otherwise try again if ((double) _matchingNodes.size() / nodes.size() >= REGEX_THRESHOLD) { return true; } } return false; }
public PList<Pair<String, Pair<Expr, Expr>>> mergeChangedVariables(TransferResult<U, T> other) { Set<String> seen = new HashSet<>(); PList<Pair<String, Pair<Expr, Expr>>> vars = PList.empty(); for (Pair<String, Expr> cv1 : this._changedVariables) { String s = cv1.getFirst(); Expr x = cv1.getSecond(); if (!seen.contains(s)) { seen.add(s); Expr e = find(other._changedVariables, s); Pair<Expr, Expr> pair = new Pair<>(x, e); vars = vars.plus(new Pair<>(s, pair)); } } for (Pair<String, Expr> cv1 : other._changedVariables) { String s = cv1.getFirst(); Expr x = cv1.getSecond(); if (!seen.contains(s)) { seen.add(s); Expr e = find(this._changedVariables, s); Pair<Expr, Expr> pair = new Pair<>(e, x); // preserve order vars = vars.plus(new Pair<>(s, pair)); } } return vars; }
public TransferResult<U, T> addChangedVariable(String s, Expr x) { TransferResult<U, T> ret = new TransferResult<>(this); ret._changedVariables = ret._changedVariables.plus(new Pair<>(s, x)); return ret; }
private NodeRoleDimension toNodeRoleDimension( Pair<Integer, Double> bestRegexAndScore, List<List<String>> candidates, String dimName) { List<String> bestRegexTokens = candidates.get(bestRegexAndScore.getFirst()); String bestRegex = regexTokensToRegex(bestRegexTokens); return regexToNodeRoleDimension(bestRegex, dimName); }
private static List<Pair<String, Token>> tokenizeName(String name) { List<Pair<String, PreToken>> pretokens = pretokenizeName(name); if (pretokens.stream().anyMatch((p) -> p.getSecond() == PreToken.DELIMITER)) { return preTokensToDelimitedTokens(pretokens); } else { return preTokensToUndelimitedTokens(pretokens); } }