Java tutorial
/** * Copyright (C) 2015 Orange * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/licenses/LICENSE-2.0 * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.francetelecom.clara.cloud.commons; import com.google.common.base.*; import com.google.common.collect.Lists; import org.apache.commons.lang3.StringUtils; import java.util.List; import static com.google.common.base.Preconditions.checkNotNull; /** * Cleans up a candidate domain name into a valid one. Inspired from guava InternetDomainName */ public final class InternetDomainNameCleaner { private static final CharMatcher DOTS_MATCHER = CharMatcher.anyOf(".\u3002\uFF0E\uFF61"); private static final Splitter DOT_SPLITTER = Splitter.on('.'); private static final Joiner DOT_JOINER = Joiner.on('.'); /** * Maximum parts (labels) in a domain name. This value arises from * the 255-octet limit described in * <a href="http://www.ietf.org/rfc/rfc2181.txt">RFC 2181</a> part 11 with * the fact that the encoding of each part occupies at least two bytes * (dot plus label externally, length byte plus label internally). Thus, if * all labels have the minimum size of one byte, 127 of them will fit. */ private static final int MAX_PARTS = 127; /** * Maximum length of a full domain name, including separators, and * leaving room for the root label. See * <a href="http://www.ietf.org/rfc/rfc2181.txt">RFC 2181</a> part 11. */ private static final int MAX_LENGTH = 253; /** * Maximum size of a single part of a domain name. See * <a href="http://www.ietf.org/rfc/rfc2181.txt">RFC 2181</a> part 11. */ private static final int MAX_DOMAIN_PART_LENGTH = 63; /** * The full domain name, converted to lower case. */ private final String name; /** * The parts of the domain name, converted to lower case. */ private final List<String> parts; /** * Constructor used to implement {@link #from(String)}, and from subclasses. */ InternetDomainNameCleaner(String name) { // Normalize: // * ASCII characters to lowercase // * All dot-like characters to '.' // * Strip trailing '.' name = Ascii.toLowerCase(DOTS_MATCHER.replaceFrom(name, '.')); if (name.endsWith(".")) { name = name.substring(0, name.length() - 1); } if (name.length() > MAX_LENGTH) { name = name.substring(MAX_LENGTH); } this.parts = Lists.newArrayList(DOT_SPLITTER.split(name)); while (parts.size() > MAX_PARTS) { parts.remove(0); } fixParts(parts); this.name = DOT_JOINER.join(parts); } /** * Returns an instance of {@link InternetDomainNameCleaner} after lenient * validation. Specifically, validation against <a * href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a> * ("Internationalizing Domain Names in Applications") is skipped, while * validation against <a * href="http://www.ietf.org/rfc/rfc1035.txt">RFC 1035</a> is relaxed in * the following ways: * <ul> * <li>Any part containing non-ASCII characters is considered valid. * <li>Underscores ('_') are permitted wherever dashes ('-') are permitted. * <li>Parts other than the final part may start with a digit. * </ul> * * * @param domain A domain name (not IP address) * @throws IllegalArgumentException if {@code name} is not syntactically valid * according to isValid() * @since 10.0 (previously named {@code fromLenient}) */ public static InternetDomainNameCleaner from(String domain) { return new InternetDomainNameCleaner(checkNotNull(domain)); } /** * Validation method used by {@from} to ensure that the domain name is * syntactically valid according to RFC 1035. * * @return Is the domain name syntactically valid? */ public static void fixParts(List<String> parts) { final int lastIndex = parts.size() - 1; // Validate the last part specially, as it has different syntax rules. parts.set(lastIndex, getFixedPart(parts.get(lastIndex), true)); for (int i = 0; i < lastIndex; i++) { String part = parts.get(i); parts.set(i, getFixedPart(part, false)); } } private static final CharMatcher DASH_MATCHER = CharMatcher.anyOf("-_"); private static final CharMatcher PART_CHAR_MATCHER = CharMatcher.JAVA_LETTER_OR_DIGIT.or(DASH_MATCHER); /** * Helper method for {@link #fixParts(List)}. Validates that one part of * a domain name is valid. * * @param part The domain name part to be validated * @param isFinalPart Is this the final (rightmost) domain part? * @return Whether the part is valid */ public static String getFixedPart(String part, boolean isFinalPart) { // These tests could be collapsed into one big boolean expression, but // they have been left as independent tests for clarity. if (part.length() > MAX_DOMAIN_PART_LENGTH) { part = StringUtils.left(part, MAX_DOMAIN_PART_LENGTH); } /* * GWT claims to support java.lang.Character's char-classification methods, * but it actually only works for ASCII. So for now, assume any non-ASCII * characters are valid. The only place this seems to be documented is here: * http://osdir.com/ml/GoogleWebToolkitContributors/2010-03/msg00178.html * * <p>ASCII characters in the part are expected to be valid per RFC 1035, * with underscore also being allowed due to widespread practice. */ String asciiChars = CharMatcher.ASCII.retainFrom(part); if (!part.isEmpty() && !PART_CHAR_MATCHER.matchesAllOf(asciiChars)) { part = PART_CHAR_MATCHER.retainFrom(asciiChars); } // No initial or final dashes or underscores. if (!part.isEmpty() && DASH_MATCHER.matches(part.charAt(0))) { part = part.substring(1); } else if (!part.isEmpty() && DASH_MATCHER.matches(part.charAt(part.length() - 1))) { part = part.substring(0, part.length() - 1); } /* * Note that we allow (in contravention of a strict interpretation of the * relevant RFCs) domain parts other than the last may begin with a digit * (for example, "3com.com"). It's important to disallow an initial digit in * the last part; it's the only thing that stops an IPv4 numeric address * like 127.0.0.1 from looking like a valid domain name. */ if (!part.isEmpty() && isFinalPart && CharMatcher.DIGIT.matches(part.charAt(0))) { part = part.substring(1); } return part; } /** * Returns the domain name, normalized to all lower case. */ public String name() { return name; } // TODO: specify this to return the same as name(); remove name() @Override public String toString() { return Objects.toStringHelper(this).add("name", name).toString(); } /** * Equality testing is based on the text supplied by the caller, * after normalization as described in the class documentation. For * example, a non-ASCII Unicode domain name and the Punycode version * of the same domain name would not be considered equal. * */ @Override public boolean equals(Object object) { if (object == this) { return true; } if (object instanceof InternetDomainNameCleaner) { InternetDomainNameCleaner that = (InternetDomainNameCleaner) object; return this.name.equals(that.name); } return false; } @Override public int hashCode() { return name.hashCode(); } }