HServerAddress.java

/**
 * Copyright 2007 The Apache Software Foundation
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.hadoop.hbase;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;

import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.io.WritableComparable;

/**
 * HServerAddress hosts a {@link InetSocketAddress} and makes it
 * {@link WritableComparable}.  Resolves on construction AND on
 * deserialization -- since we're internally creating an InetSocketAddress --
 * so could end up with different results if the two ends of serialization have
 * different resolvers. Be careful where you use it.  Should only be used when
 * you need to pass an InetSocketAddress across an RPC.  Even then its a bad
 * idea because of the above resolve issue.
 * @deprecated Use {@link InetSocketAddress} or {@link ServerName} or
 * a hostname String and port.
 */
public class HServerAddress implements WritableComparable<HServerAddress> {
  // Hard to deprecate this class. Its in the API as internal class,
  // in particular as an inner class of HRegionLocation.  Besides, sometimes
  // we do want to serialize a InetSocketAddress; this class can be used then.
  private InetSocketAddress address = null;
  private String cachedToString = "";

  /**
   * Constructor for deserialization use only.
   */
  public HServerAddress() {
    super();
  }

  /**
   * Construct an instance from an {@link InetSocketAddress}.
   * @param address InetSocketAddress of server
   */
  public HServerAddress(InetSocketAddress address) {
    this.address = address;
    checkBindAddressCanBeResolved();
    this.cachedToString = createCachedToString();
  }

  private String createCachedToString() {
    return this.address.toString();
  }

  /**
   * @param hostname Hostname
   * @param port Port number
   */
  public HServerAddress(final String hostname, final int port) {
    this(getResolvedAddress(new InetSocketAddress(hostname, port)));
  }

  /**
   * Copy-constructor.
   * @param other HServerAddress to copy from
   */
  public HServerAddress(HServerAddress other) {
    this(getResolvedAddress(new InetSocketAddress(other.getHostname(), other.getPort())));
  }

   private static InetSocketAddress getResolvedAddress(InetSocketAddress address) {
     String bindAddress = getBindAddressInternal(address);
     int port = address.getPort();
     return new InetSocketAddress(bindAddress, port);
   }
  
  /** @return Bind address -- the raw IP, the result of a call to
   * InetSocketAddress#getAddress()#getHostAddress() --
   * or null if cannot resolve */
  public String getBindAddress() {
    return getBindAddressInternal(address);
  }

  private static String getBindAddressInternal(InetSocketAddress address) {
    final InetAddress addr = address.getAddress();
    if (addr != null) {
      return addr.getHostAddress();
    } else {
      LogFactory.getLog(HServerAddress.class).error("Could not resolve the"
          + " DNS name of " + address.getHostName());
      return null;
    }
  }
  
  private void checkBindAddressCanBeResolved() {
    if (getBindAddress() == null) {
      throw new IllegalArgumentException("Could not resolve the"
          + " DNS name of " + this.address.toString());
    }
  }

  /** @return Port number */
  public int getPort() {
    return this.address.getPort();
  }

  /** @return Hostname */
  public String getHostname() {
    // Kerberos is case-sensitive, and dictates that, where hostnames are
    // case-insensitive (as in DNS), the lowercase version must be used
    // So here we lowercase to properly interact with kerberos auth
    return this.address.getHostName().toLowerCase();
  }

  /**
   * @return Returns <hostname> ':' <port>
   */
  public String getHostnameAndPort() {
    return getHostname() + ":" + getPort();
  }

  /** @return The InetSocketAddress */
  public InetSocketAddress getInetSocketAddress() {
    return this.address;
  }

  /**
   * @return String formatted as <code><bind address> ':' <port></code>
   */
  @Override
  public String toString() {
    return this.cachedToString;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null) return false;
    if (getClass() != o.getClass()) return false;
    return compareTo((HServerAddress)o) == 0;
  }

  @Override
  public int hashCode() {
    int result = address == null? 0: address.hashCode();
    result ^= toString().hashCode();
    return result;
  }

  //
  // Writable
  //

  public void readFields(DataInput in) throws IOException {
    String hostname = in.readUTF();
    int port = in.readInt();
    if (hostname != null && hostname.length() > 0) {
      this.address = getResolvedAddress(new InetSocketAddress(hostname, port));
      checkBindAddressCanBeResolved();
      createCachedToString();
    }
  }

  public void write(DataOutput out) throws IOException {
    if (this.address == null) {
      out.writeUTF("");
      out.writeInt(0);
    } else {
      out.writeUTF(this.address.getAddress().getHostName());
      out.writeInt(this.address.getPort());
    }
  }

  //
  // Comparable
  //

  public int compareTo(HServerAddress o) {
    // Addresses as Strings may not compare though address is for the one
    // server with only difference being that one address has hostname
    // resolved whereas other only has IP.
    if (this.address.equals(o.address)) return 0;
    return toString().compareTo(o.toString());
  }
}