ServerName (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.ServerName

All Implemented Interfaces:

Serializable, Comparable<ServerName>
```
@InterfaceAudience.Public
@InterfaceStability.Evolving
public class ServerName
extends Object
implements Comparable<ServerName>, Serializable
```
Instance of an HBase ServerName. A server name is used uniquely identifying a server instance in a cluster and is made of the combination of hostname, port, and startcode. The startcode distingushes restarted servers on same hostname and port (startcode is usually timestamp of server startup). The toString() format of ServerName is safe to use in the filesystem and as znode name up in ZooKeeper. Its format is: <hostname> 'SERVERNAME_SEPARATOR' <port> 'SERVERNAME_SEPARATOR' <startcode>. For example, if hostname is www.example.org, port is 1234, and the startcode for the regionserver is 1212121212, then the toString() would be www.example.org,1234,1212121212.
You can obtain a versioned serialized form of this class by calling getVersionedBytes(). To deserialize, call parseVersionedServerName(byte[])
Immutable.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`private byte[]`	`bytes` Cached versioned bytes of this ServerName instance.
`static List<ServerName>`	`EMPTY_SERVER_LIST`
`private String`	`hostnameOnly`
`static int`	`NON_STARTCODE` What to use if no startcode supplied.
`private int`	`port`
`private static long`	`serialVersionUID`
`private String`	`servername`
`static Pattern`	`SERVERNAME_PATTERN`
`static String`	`SERVERNAME_SEPARATOR` This character is used as separator between server hostname, port and startcode.
`private long`	`startcode`
`static String`	`UNKNOWN_SERVERNAME` What to use if server name is unknown.
`private static short`	`VERSION` Version for this class.
`(package private) static byte[]`	`VERSION_BYTES`

Constructor Summary

Constructors
Modifier	Constructor and Description
`private`	`ServerName(String serverName)`
`private`	`ServerName(String hostname, int port, long startcode)`
`private`	`ServerName(String hostAndPort, long startCode)`

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`compareTo(ServerName other)`
`boolean`	`equals(Object o)`
`String`	`getHostAndPort()`
`String`	`getHostname()`
`(package private) static String`	`getHostNameMinusDomain(String hostname)`
`int`	`getPort()`
`String`	`getServerName()`
`(package private) static String`	`getServerName(String hostName, int port, long startcode)` For internal use only.
`static String`	`getServerName(String hostAndPort, long startcode)`
`static String`	`getServerNameLessStartCode(String inServerName)` Utility method to excise the start code from a server name
`static long`	`getServerStartcodeFromServerName(String serverName)`
`long`	`getStartcode()`
`byte[]`	`getVersionedBytes()`
`int`	`hashCode()`
`static boolean`	`isFullServerName(String str)`
`static boolean`	`isSameHostnameAndPort(ServerName left, ServerName right)`
`static ServerName`	`parseFrom(byte[] data)` Get a ServerName from the passed in data bytes.
`static String`	`parseHostname(String serverName)`
`static int`	`parsePort(String serverName)`
`static ServerName`	`parseServerName(String str)`
`static long`	`parseStartcode(String serverName)`
`static ServerName`	`parseVersionedServerName(byte[] versionedBytes)` Use this method instantiating a `ServerName` from bytes gotten from a call to `getVersionedBytes()`.
`String`	`toShortString()`
`String`	`toString()`
`static ServerName`	`valueOf(String serverName)` Retrieve an instance of ServerName.
`static ServerName`	`valueOf(String hostname, int port, long startcode)` Retrieve an instance of ServerName.
`static ServerName`	`valueOf(String hostAndPort, long startCode)` Retrieve an instance of ServerName.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    Constant Field Values
  - VERSION
```
private static final short VERSION
```
    Version for this class. Its a short rather than a byte so I can for sure distinguish between this version of this class and the version previous to this which did not have a version.
    
    See Also:
    Constant Field Values
  - VERSION_BYTES
```
static final byte[] VERSION_BYTES
```
  - NON_STARTCODE
```
public static final int NON_STARTCODE
```
    What to use if no startcode supplied.
    
    See Also:
    Constant Field Values
  - SERVERNAME_SEPARATOR
```
public static final String SERVERNAME_SEPARATOR
```
    This character is used as separator between server hostname, port and startcode.
    
    See Also:
    Constant Field Values
  - SERVERNAME_PATTERN
```
public static final Pattern SERVERNAME_PATTERN
```
  - UNKNOWN_SERVERNAME
```
public static final String UNKNOWN_SERVERNAME
```
    What to use if server name is unknown.
    
    See Also:
    Constant Field Values
  - servername
```
private final String servername
```
  - hostnameOnly
```
private final String hostnameOnly
```
  - port
```
private final int port
```
  - startcode
```
private final long startcode
```
  - bytes
```
private byte[] bytes
```
    Cached versioned bytes of this ServerName instance.
    
    See Also:
    getVersionedBytes()
  - EMPTY_SERVER_LIST
```
public static final List<ServerName> EMPTY_SERVER_LIST
```
- Constructor Detail
  - ServerName
```
private ServerName(String hostname,
          int port,
          long startcode)
```
  - ServerName
```
private ServerName(String serverName)
```
  - ServerName
```
private ServerName(String hostAndPort,
          long startCode)
```
- Method Detail
  - getHostNameMinusDomain
```
static String getHostNameMinusDomain(String hostname)
```
    Parameters:
    hostname -
    
    Returns:
    hostname minus the domain, if there is one (will do pass-through on ip addresses)
  - parseHostname
```
public static String parseHostname(String serverName)
```
  - parsePort
```
public static int parsePort(String serverName)
```
  - parseStartcode
```
public static long parseStartcode(String serverName)
```
  - valueOf
```
public static ServerName valueOf(String hostname,
                 int port,
                 long startcode)
```
    Retrieve an instance of ServerName. Callers should use the equals method to compare returned instances, though we may return a shared immutable object as an internal optimization.
  - valueOf
```
public static ServerName valueOf(String serverName)
```
    Retrieve an instance of ServerName. Callers should use the equals method to compare returned instances, though we may return a shared immutable object as an internal optimization.
  - valueOf
```
public static ServerName valueOf(String hostAndPort,
                 long startCode)
```
    Retrieve an instance of ServerName. Callers should use the equals method to compare returned instances, though we may return a shared immutable object as an internal optimization.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toShortString
```
public String toShortString()
```
    Returns:
    Return a SHORT version of toString(), one that has the host only, minus the domain, and the port only -- no start code; the String is for us internally mostly tying threads to their server. Not for external use. It is lossy and will not work in in compares, etc.
  - getVersionedBytes
```
public byte[] getVersionedBytes()
```
    Returns:
    getServerName() as bytes with a short-sized prefix with the ServerName#VERSION of this class.
  - getServerName
```
public String getServerName()
```
  - getHostname
```
public String getHostname()
```
  - getPort
```
public int getPort()
```
  - getStartcode
```
public long getStartcode()
```
  - getServerName
```
static String getServerName(String hostName,
                   int port,
                   long startcode)
```
    For internal use only.
    
    Parameters:
    hostName -
    port -
    startcode -
    
    Returns:
    Server name made of the concatenation of hostname, port and startcode formatted as <hostname> ',' <port> ',' <startcode>
  - getServerName
```
public static String getServerName(String hostAndPort,
                   long startcode)
```
    Parameters:
    hostAndPort - String in form of <hostname> ':' <port>
    startcode -
    
    Returns:
    Server name made of the concatenation of hostname, port and startcode formatted as <hostname> ',' <port> ',' <startcode>
  - getHostAndPort
```
public String getHostAndPort()
```
    Returns:
    Hostname and port formatted as described at Addressing.createHostAndPortStr(String, int)
  - getServerStartcodeFromServerName
```
public static long getServerStartcodeFromServerName(String serverName)
```
    Parameters:
    serverName - ServerName in form specified by getServerName()
    
    Returns:
    The server start code parsed from servername
  - getServerNameLessStartCode
```
public static String getServerNameLessStartCode(String inServerName)
```
    Utility method to excise the start code from a server name
    
    Parameters:
    inServerName - full server name
    
    Returns:
    server name less its start code
  - compareTo
```
public int compareTo(ServerName other)
```
    Specified by:
    
    compareTo in interface Comparable<ServerName>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - isSameHostnameAndPort
```
public static boolean isSameHostnameAndPort(ServerName left,
                            ServerName right)
```
    Parameters:
    left -
    right -
    
    Returns:
    True if other has same hostname and port.
  - parseVersionedServerName
```
public static ServerName parseVersionedServerName(byte[] versionedBytes)
```
    Use this method instantiating a ServerName from bytes gotten from a call to getVersionedBytes(). Will take care of the case where bytes were written by an earlier version of hbase.
    
    Parameters:
    versionedBytes - Pass bytes gotten from a call to getVersionedBytes()
    
    Returns:
    A ServerName instance.
    See Also:
    getVersionedBytes()
  - parseServerName
```
public static ServerName parseServerName(String str)
```
    Parameters:
    str - Either an instance of toString() or a "'<hostname>' ':' '<port>'".
    
    Returns:
    A ServerName instance.
  - isFullServerName
```
public static boolean isFullServerName(String str)
```
    Returns:
    true if the String follows the pattern of toString(), false otherwise.
  - parseFrom
```
public static ServerName parseFrom(byte[] data)
                            throws DeserializationException
```
    Get a ServerName from the passed in data bytes.
    
    Parameters:
    data - Data with a serialize server name in it; can handle the old style servername where servername was host and port. Works too with data that begins w/ the pb 'PBUF' magic and that is then followed by a protobuf that has a serialized ServerName in it.
    
    Returns:
    Returns null if data is null else converts passed data to a ServerName instance.
    
    Throws:
    
    DeserializationException

Class ServerName

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

serialVersionUID

VERSION

VERSION_BYTES

NON_STARTCODE

SERVERNAME_SEPARATOR

SERVERNAME_PATTERN

UNKNOWN_SERVERNAME

servername

hostnameOnly

port

startcode

bytes

EMPTY_SERVER_LIST

Constructor Detail

ServerName

ServerName

ServerName

Method Detail

getHostNameMinusDomain

parseHostname

parsePort

parseStartcode

valueOf

valueOf

valueOf

toString

toShortString

getVersionedBytes

getServerName

getHostname

getPort

getStartcode

getServerName

getServerName

getHostAndPort

getServerStartcodeFromServerName

getServerNameLessStartCode

compareTo

hashCode

equals

isSameHostnameAndPort

parseVersionedServerName

parseServerName

isFullServerName

parseFrom