/**
* 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.cassandra.net;
import java.io.IOException;
import java.io.Serializable;
import java.net.*;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.util.HashMap;
import java.util.Map;
import org.apache.cassandra.utils.FBUtilities;
import org.apache.cassandra.utils.LogUtil;
import org.apache.log4j.Logger;
import org.apache.cassandra.config.DatabaseDescriptor;
/**
* Author : Avinash Lakshman ( alakshman@facebook.com) & Prashant Malik ( pmalik@facebook.com )
*/
public class EndPoint implements Serializable, Comparable<EndPoint>
{
// logging and profiling.
private static Logger logger_ = Logger.getLogger(EndPoint.class);
private static final long serialVersionUID = -4962625949179835907L;
private static Map<CharBuffer, String> hostNames_ = new HashMap<CharBuffer, String>();
protected static final int randomPort_ = 5555;
public static EndPoint randomLocalEndPoint_;
static
{
try
{
randomLocalEndPoint_ = new EndPoint(FBUtilities.getHostName(), EndPoint.randomPort_);
}
catch ( IOException ex )
{
logger_.warn(LogUtil.throwableToString(ex));
}
}
private String host_;
private int port_;
private transient InetSocketAddress ia_;
/* Ctor for JAXB. DO NOT DELETE */
private EndPoint()
{
}
public EndPoint(String host, int port)
{
/*
* Attempts to resolve the host, but does not fail if it cannot.
*/
host_ = host;
port_ = port;
}
// create a local endpoint id
public EndPoint(int port)
{
try
{
host_ = FBUtilities.getHostName();
}
catch (UnknownHostException e)
{
throw new RuntimeException(e);
}
port_ = port;
}
public String getHost()
{
return host_;
}
public int getPort()
{
return port_;
}
public void setPort(int port)
{
port_ = port;
}
public InetSocketAddress getInetAddress()
{
if (ia_ == null || ia_.isUnresolved())
{
ia_ = new InetSocketAddress(host_, port_);
}
return ia_;
}
public boolean equals(Object o)
{
if (!(o instanceof EndPoint))
return false;
EndPoint rhs = (EndPoint) o;
return (host_.equals(rhs.host_) && port_ == rhs.port_);
}
public int hashCode()
{
return (host_ + port_).hashCode();
}
public int compareTo(EndPoint rhs)
{
return host_.compareTo(rhs.host_);
}
public String toString()
{
return (host_ + ":" + port_);
}
public static EndPoint fromString(String str)
{
String[] values = str.split(":");
return new EndPoint(values[0], Integer.parseInt(values[1]));
}
public static byte[] toBytes(EndPoint ep)
{
ByteBuffer buffer = ByteBuffer.allocate(6);
byte[] iaBytes = ep.getInetAddress().getAddress().getAddress();
buffer.put(iaBytes);
buffer.put(MessagingService.toByteArray((short) ep.getPort()));
buffer.flip();
return buffer.array();
}
public static EndPoint fromBytes(byte[] bytes)
{
ByteBuffer buffer = ByteBuffer.allocate(4);
System.arraycopy(bytes, 0, buffer.array(), 0, 4);
byte[] portBytes = new byte[2];
System.arraycopy(bytes, 4, portBytes, 0, portBytes.length);
try
{
CharBuffer charBuffer = buffer.asCharBuffer();
String host = hostNames_.get(charBuffer);
if (host == null)
{
host = InetAddress.getByAddress(buffer.array()).getHostName();
hostNames_.put(charBuffer, host);
}
int port = (int) MessagingService.byteArrayToShort(portBytes);
return new EndPoint(host, port);
}
catch (UnknownHostException e)
{
throw new IllegalArgumentException(e);
}
}
}