Package org.elasticsearch.transport

Class TransportService

java.lang.Object

org.elasticsearch.common.component.AbstractLifecycleComponent

org.elasticsearch.transport.TransportService

All Implemented Interfaces:

Closeable, AutoCloseable, LifecycleComponent, org.elasticsearch.core.Releasable, ReportingService<TransportInfo>, TransportConnectionListener, TransportMessageListener

public class TransportService
extends AbstractLifecycleComponent
implements ReportingService<TransportInfo>, TransportMessageListener, TransportConnectionListener

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static final class	TransportService.ContextRestoreResponseHandler<T extends TransportResponse>	This handler wrapper ensures that the response thread executes with the correct thread context.
static class	TransportService.HandshakeResponse

Nested classes/interfaces inherited from interface org.elasticsearch.node.ReportingService

ReportingService.Info

Field Summary

Fields

Modifier and Type	Field	Description
protected final ClusterName	clusterName
protected final ConnectionManager	connectionManager
static final String	DIRECT_RESPONSE_PROFILE
static final String	HANDSHAKE_ACTION_NAME
static final TransportInterceptor	NOOP_TRANSPORT_INTERCEPTOR
static final String	PERMIT_HANDSHAKES_FROM_INCOMPATIBLE_BUILDS_KEY
protected final TaskManager	taskManager
protected final ThreadPool	threadPool
protected final Transport	transport
static final Set<String>	VALID_ACTION_PREFIXES	A set of all valid action prefixes.

Fields inherited from class org.elasticsearch.common.component.AbstractLifecycleComponent

lifecycle

Fields inherited from interface org.elasticsearch.transport.TransportMessageListener

NOOP_LISTENER

Constructor Summary

Constructors

Constructor	Description
TransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor transportInterceptor, Function<BoundTransportAddress,DiscoveryNode> localNodeFactory, ClusterSettings clusterSettings, Set<String> taskHeaders)	Build the service.
TransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor transportInterceptor, Function<BoundTransportAddress,DiscoveryNode> localNodeFactory, ClusterSettings clusterSettings, Set<String> taskHeaders, ConnectionManager connectionManager)

Method Summary

Modifier and Type	Method	Description
final void	acceptIncomingRequests()	Start accepting incoming requests.
void	addConnectionListener(TransportConnectionListener listener)
void	addMessageListener(TransportMessageListener listener)
TransportAddress[]	addressesFromString(String address)
BoundTransportAddress	boundAddress()
ConnectionManager.ConnectionValidator	connectionValidator(DiscoveryNode node)
void	connectToNode(DiscoveryNode node)	Connect to the specified node with the default connection profile
void	connectToNode(DiscoveryNode node, ActionListener<org.elasticsearch.core.Releasable> listener)	Connect to the specified node with the given connection profile.
void	connectToNode(DiscoveryNode node, ConnectionProfile connectionProfile)	Connect to the specified node with the given connection profile
void	connectToNode(DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<org.elasticsearch.core.Releasable> listener)	Connect to the specified node with the given connection profile.
protected TaskManager	createTaskManager(Settings settings, ThreadPool threadPool, Set<String> taskHeaders)
void	disconnectFromNode(DiscoveryNode node)
protected void	doClose()
protected void	doStart()
protected void	doStop()
Transport.Connection	getConnection(DiscoveryNode node)	Returns either a real transport connection or a local node connection if we are using the local node optimization.
ConnectionManager	getConnectionManager()
List<String>	getDefaultSeedAddresses()
DiscoveryNode	getLocalNode()
Transport.Connection	getLocalNodeConnection()
RemoteClusterService	getRemoteClusterService()
RequestHandlerRegistry<? extends TransportRequest>	getRequestHandler(String action)
TaskManager	getTaskManager()
ThreadPool	getThreadPool()	Returns the internal thread pool
void	handshake(Transport.Connection connection, org.elasticsearch.core.TimeValue handshakeTimeout, Predicate<ClusterName> clusterNamePredicate, ActionListener<TransportService.HandshakeResponse> listener)	Executes a high-level handshake using the given connection and returns the discovery node of the node the connection was established with.
void	handshake(Transport.Connection connection, org.elasticsearch.core.TimeValue handshakeTimeout, ActionListener<DiscoveryNode> listener)	Executes a high-level handshake using the given connection and returns the discovery node of the node the connection was established with.
TransportInfo	info()
boolean	isTransportSecure()
static boolean	isValidActionName(String actionName)	Returns true iff the action name starts with a valid prefix.
boolean	nodeConnected(DiscoveryNode node)	Returns true iff the given node is already connected.
void	onConnectionClosed(Transport.Connection connection)	Called once a connection ws closed.
void	onRequestReceived(long requestId, String action)	called by the Transport implementation when an incoming request arrives but before any parsing of it has happened (with the exception of the requestId and action)
void	onRequestSent(DiscoveryNode node, long requestId, String action, TransportRequest request, TransportRequestOptions options)	called by the Transport implementation once a request has been sent
void	onResponseReceived(long requestId, Transport.ResponseContext holder)	Called for every response received
void	onResponseSent(long requestId, String action, Exception e)	called by the Transport implementation after an exception was sent as a response to an incoming request
void	onResponseSent(long requestId, String action, TransportResponse response)	called by the Transport implementation once a response was sent to calling node
Transport.Connection	openConnection(DiscoveryNode node, ConnectionProfile connectionProfile)	Establishes and returns a new connection to the given node.
void	openConnection(DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Transport.Connection> listener)	Establishes a new connection to the given node.
<Request extends TransportRequest> void	registerRequestHandler(String action, String executor, boolean forceExecution, boolean canTripCircuitBreaker, Writeable.Reader<Request> requestReader, TransportRequestHandler<Request> handler)	Registers a new request handler
<Request extends TransportRequest> void	registerRequestHandler(String action, String executor, Writeable.Reader<Request> requestReader, TransportRequestHandler<Request> handler)	Registers a new request handler
void	removeConnectionListener(TransportConnectionListener listener)
boolean	removeMessageListener(TransportMessageListener listener)
final <T extends TransportResponse> void	sendChildRequest(DiscoveryNode node, String action, TransportRequest request, Task parentTask, TransportRequestOptions options, TransportResponseHandler<T> handler)
<T extends TransportResponse> void	sendChildRequest(Transport.Connection connection, String action, TransportRequest request, Task parentTask, TransportRequestOptions options, TransportResponseHandler<T> handler)
<T extends TransportResponse> void	sendChildRequest(Transport.Connection connection, String action, TransportRequest request, Task parentTask, TransportResponseHandler<T> handler)
final <T extends TransportResponse> void	sendRequest(DiscoveryNode node, String action, TransportRequest request, TransportRequestOptions options, TransportResponseHandler<T> handler)
<T extends TransportResponse> void	sendRequest(DiscoveryNode node, String action, TransportRequest request, TransportResponseHandler<T> handler)
final <T extends TransportResponse> void	sendRequest(Transport.Connection connection, String action, TransportRequest request, TransportRequestOptions options, TransportResponseHandler<T> handler)	Sends a request on the specified connection.
static boolean	shouldTraceAction(String action, String[] include, String[] exclude)
TransportStats	stats()
<T extends TransportResponse> TransportFuture<T>	submitRequest(DiscoveryNode node, String action, TransportRequest request, TransportRequestOptions options, TransportResponseHandler<T> handler)
<T extends TransportResponse> TransportFuture<T>	submitRequest(DiscoveryNode node, String action, TransportRequest request, TransportResponseHandler<T> handler)
static Transport.Connection	unwrapConnection(Transport.Connection connection)	Unwraps and returns the actual underlying connection of the given connection.

Methods inherited from class org.elasticsearch.common.component.AbstractLifecycleComponent

addLifecycleListener, close, lifecycleState, removeLifecycleListener, start, stop

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.elasticsearch.transport.TransportConnectionListener

onConnectionOpened, onNodeConnected, onNodeDisconnected

Field Details

PERMIT_HANDSHAKES_FROM_INCOMPATIBLE_BUILDS_KEY

public static final String PERMIT_HANDSHAKES_FROM_INCOMPATIBLE_BUILDS_KEY

See Also:

• Constant Field Values

DIRECT_RESPONSE_PROFILE

public static final String DIRECT_RESPONSE_PROFILE

See Also:

• Constant Field Values

HANDSHAKE_ACTION_NAME

public static final String HANDSHAKE_ACTION_NAME

See Also:

• Constant Field Values

transport

protected final Transport transport

connectionManager

protected final ConnectionManager connectionManager

threadPool

protected final ThreadPool threadPool

clusterName

protected final ClusterName clusterName

taskManager

protected final TaskManager taskManager

NOOP_TRANSPORT_INTERCEPTOR

public static final TransportInterceptor NOOP_TRANSPORT_INTERCEPTOR

VALID_ACTION_PREFIXES

public static final Set<String> VALID_ACTION_PREFIXES

A set of all valid action prefixes.

Constructor Details

TransportService

public TransportService(Settings settings,
 Transport transport,
 ThreadPool threadPool,
 TransportInterceptor transportInterceptor,
 Function<BoundTransportAddress,DiscoveryNode> localNodeFactory,
 @Nullable
 ClusterSettings clusterSettings,
 Set<String> taskHeaders)

Build the service.

Parameters:

clusterSettings - if non null, the TransportService will register with the ClusterSettings for settings * updates for TransportSettings.TRACE_LOG_EXCLUDE_SETTING and TransportSettings.TRACE_LOG_INCLUDE_SETTING.

TransportService

public TransportService(Settings settings,
 Transport transport,
 ThreadPool threadPool,
 TransportInterceptor transportInterceptor,
 Function<BoundTransportAddress,DiscoveryNode> localNodeFactory,
 @Nullable
 ClusterSettings clusterSettings,
 Set<String> taskHeaders,
 ConnectionManager connectionManager)

Method Details

getRemoteClusterService

public RemoteClusterService getRemoteClusterService()

getLocalNode

public DiscoveryNode getLocalNode()

getLocalNodeConnection

public Transport.Connection getLocalNodeConnection()

getTaskManager

public TaskManager getTaskManager()

createTaskManager

protected TaskManager createTaskManager(Settings settings,
 ThreadPool threadPool,
 Set<String> taskHeaders)

doStart

protected void doStart()

Specified by:

doStart in class AbstractLifecycleComponent

doStop

protected void doStop()

Specified by:

doStop in class AbstractLifecycleComponent

doClose

protected void doClose()
                throws IOException

Specified by:

doClose in class AbstractLifecycleComponent

Throws:

IOException

acceptIncomingRequests

public final void acceptIncomingRequests()

Start accepting incoming requests. The transport service starts before it's ready to accept incoming requests because we need to know the address(es) to which we are bound, which means we have to actually bind to them and start accepting incoming connections. However until this method is called we reject any incoming requests, including handshakes, by closing the connection.

info

public TransportInfo info()

Specified by:

info in interface ReportingService<TransportInfo>

stats

public TransportStats stats()

isTransportSecure

public boolean isTransportSecure()

boundAddress

public BoundTransportAddress boundAddress()

getDefaultSeedAddresses

public List<String> getDefaultSeedAddresses()

nodeConnected

public boolean nodeConnected(DiscoveryNode node)

Returns true iff the given node is already connected.

connectToNode

public void connectToNode(DiscoveryNode node)
                   throws ConnectTransportException

Connect to the specified node with the default connection profile

Parameters:

node - the node to connect to

Throws:

ConnectTransportException

connectToNode

public void connectToNode(DiscoveryNode node,
 ConnectionProfile connectionProfile)

Connect to the specified node with the given connection profile

Parameters:

node - the node to connect to

connectionProfile - the connection profile to use when connecting to this node

connectToNode

public void connectToNode(DiscoveryNode node,
 ActionListener<org.elasticsearch.core.Releasable> listener)
                   throws ConnectTransportException

Connect to the specified node with the given connection profile. The ActionListener will be called on the calling thread or the generic thread pool.

Parameters:

node - the node to connect to

listener - the action listener to notify

Throws:

ConnectTransportException

connectToNode

public void connectToNode(DiscoveryNode node,
 ConnectionProfile connectionProfile,
 ActionListener<org.elasticsearch.core.Releasable> listener)

Connect to the specified node with the given connection profile. The ActionListener will be called on the calling thread or the generic thread pool.

Parameters:

node - the node to connect to

connectionProfile - the connection profile to use when connecting to this node

listener - the action listener to notify

connectionValidator

public ConnectionManager.ConnectionValidator connectionValidator(DiscoveryNode node)

openConnection

public Transport.Connection openConnection(DiscoveryNode node,
 ConnectionProfile connectionProfile)

Establishes and returns a new connection to the given node. The connection is NOT maintained by this service, it's the callers responsibility to close the connection once it goes out of scope. The ActionListener will be called on the calling thread or the generic thread pool.

Parameters:

node - the node to connect to

connectionProfile - the connection profile to use

openConnection

public void openConnection(DiscoveryNode node,
 ConnectionProfile connectionProfile,
 ActionListener<Transport.Connection> listener)

Establishes a new connection to the given node. The connection is NOT maintained by this service, it's the callers responsibility to close the connection once it goes out of scope. The ActionListener will be called on the calling thread or the generic thread pool.

Parameters:

node - the node to connect to

connectionProfile - the connection profile to use

listener - the action listener to notify

handshake

public void handshake(Transport.Connection connection,
 org.elasticsearch.core.TimeValue handshakeTimeout,
 ActionListener<DiscoveryNode> listener)

Executes a high-level handshake using the given connection and returns the discovery node of the node the connection was established with. The handshake will fail if the cluster name on the target node mismatches the local cluster name. The ActionListener will be called on the calling thread or the generic thread pool.

Parameters:

connection - the connection to a specific node

handshakeTimeout - handshake timeout

listener - action listener to notify

Throws:

ConnectTransportException - if the connection failed

IllegalStateException - if the handshake failed

handshake

public void handshake(Transport.Connection connection,
 org.elasticsearch.core.TimeValue handshakeTimeout,
 Predicate<ClusterName> clusterNamePredicate,
 ActionListener<TransportService.HandshakeResponse> listener)

Executes a high-level handshake using the given connection and returns the discovery node of the node the connection was established with. The handshake will fail if the cluster name on the target node doesn't match the local cluster name. The ActionListener will be called on the calling thread or the generic thread pool.

Parameters:

connection - the connection to a specific node

handshakeTimeout - handshake timeout

clusterNamePredicate - cluster name validation predicate

listener - action listener to notify

Throws:

IllegalStateException - if the handshake failed

getConnectionManager

public ConnectionManager getConnectionManager()

disconnectFromNode

public void disconnectFromNode(DiscoveryNode node)

addMessageListener

public void addMessageListener(TransportMessageListener listener)

removeMessageListener

public boolean removeMessageListener(TransportMessageListener listener)

addConnectionListener

public void addConnectionListener(TransportConnectionListener listener)

removeConnectionListener

public void removeConnectionListener(TransportConnectionListener listener)

submitRequest

public <T extends TransportResponse>
TransportFuture<T> submitRequest(DiscoveryNode node,
 String action,
 TransportRequest request,
 TransportResponseHandler<T> handler)
                          throws TransportException

Throws:

TransportException

submitRequest

public <T extends TransportResponse>
TransportFuture<T> submitRequest(DiscoveryNode node,
 String action,
 TransportRequest request,
 TransportRequestOptions options,
 TransportResponseHandler<T> handler)
                          throws TransportException

Throws:

TransportException

sendRequest

public <T extends TransportResponse> void sendRequest(DiscoveryNode node,
 String action,
 TransportRequest request,
 TransportResponseHandler<T> handler)

sendRequest

public final <T extends TransportResponse> void sendRequest(DiscoveryNode node,
 String action,
 TransportRequest request,
 TransportRequestOptions options,
 TransportResponseHandler<T> handler)

unwrapConnection

public static Transport.Connection unwrapConnection(Transport.Connection connection)

Unwraps and returns the actual underlying connection of the given connection.

sendRequest

public final <T extends TransportResponse> void sendRequest(Transport.Connection connection,
 String action,
 TransportRequest request,
 TransportRequestOptions options,
 TransportResponseHandler<T> handler)

Sends a request on the specified connection. If there is a failure sending the request, the specified handler is invoked.

Type Parameters:

T - the type of the transport response

Parameters:

connection - the connection to send the request on

action - the name of the action

request - the request

options - the options for this request

handler - the response handler

getConnection

public Transport.Connection getConnection(DiscoveryNode node)

Returns either a real transport connection or a local node connection if we are using the local node optimization.

Throws:

NodeNotConnectedException - if the given node is not connected

sendChildRequest

public final <T extends TransportResponse> void sendChildRequest(DiscoveryNode node,
 String action,
 TransportRequest request,
 Task parentTask,
 TransportRequestOptions options,
 TransportResponseHandler<T> handler)

sendChildRequest

public <T extends TransportResponse> void sendChildRequest(Transport.Connection connection,
 String action,
 TransportRequest request,
 Task parentTask,
 TransportResponseHandler<T> handler)

sendChildRequest

public <T extends TransportResponse> void sendChildRequest(Transport.Connection connection,
 String action,
 TransportRequest request,
 Task parentTask,
 TransportRequestOptions options,
 TransportResponseHandler<T> handler)

shouldTraceAction

public static boolean shouldTraceAction(String action,
 String[] include,
 String[] exclude)

addressesFromString

public TransportAddress[] addressesFromString(String address)
                                       throws UnknownHostException

Throws:

UnknownHostException

isValidActionName

public static boolean isValidActionName(String actionName)

Returns true iff the action name starts with a valid prefix.

See Also:

• VALID_ACTION_PREFIXES

registerRequestHandler

public <Request extends TransportRequest> void registerRequestHandler(String action,
 String executor,
 Writeable.Reader<Request> requestReader,
 TransportRequestHandler<Request> handler)

Registers a new request handler

Parameters:

action - The action the request handler is associated with

requestReader - a callable to be used construct new instances for streaming

executor - The executor the request handling will be executed on

handler - The handler itself that implements the request handling

registerRequestHandler

public <Request extends TransportRequest> void registerRequestHandler(String action,
 String executor,
 boolean forceExecution,
 boolean canTripCircuitBreaker,
 Writeable.Reader<Request> requestReader,
 TransportRequestHandler<Request> handler)

Registers a new request handler

Parameters:

action - The action the request handler is associated with

requestReader - The request class that will be used to construct new instances for streaming

executor - The executor the request handling will be executed on

forceExecution - Force execution on the executor queue and never reject it

canTripCircuitBreaker - Check the request size and raise an exception in case the limit is breached.

handler - The handler itself that implements the request handling

onRequestReceived

public void onRequestReceived(long requestId,
 String action)

called by the Transport implementation when an incoming request arrives but before any parsing of it has happened (with the exception of the requestId and action)

Specified by:

onRequestReceived in interface TransportMessageListener

Parameters:

requestId - the internal request ID

action - the request action

onRequestSent

public void onRequestSent(DiscoveryNode node,
 long requestId,
 String action,
 TransportRequest request,
 TransportRequestOptions options)

called by the Transport implementation once a request has been sent

Specified by:

onRequestSent in interface TransportMessageListener

Parameters:

node - the node the request was sent to

requestId - the internal request id

action - the action name

request - the actual request

options - the request options

onResponseReceived

public void onResponseReceived(long requestId,
 Transport.ResponseContext holder)

Description copied from interface: TransportMessageListener

Called for every response received

Specified by:

onResponseReceived in interface TransportMessageListener

Parameters:

requestId - the request id for this response

holder - the response context or null if the context was already processed ie. due to a timeout.

onResponseSent

public void onResponseSent(long requestId,
 String action,
 TransportResponse response)

called by the Transport implementation once a response was sent to calling node

Specified by:

onResponseSent in interface TransportMessageListener

Parameters:

requestId - the request ID (unique per client)

action - the request action

response - the response send

onResponseSent

public void onResponseSent(long requestId,
 String action,
 Exception e)

called by the Transport implementation after an exception was sent as a response to an incoming request

Specified by:

onResponseSent in interface TransportMessageListener

Parameters:

requestId - the request ID (unique per client)

action - the request action

e - the error sent back to the caller

getRequestHandler

public RequestHandlerRegistry<? extends TransportRequest> getRequestHandler(String action)

onConnectionClosed

public void onConnectionClosed(Transport.Connection connection)

Description copied from interface: TransportConnectionListener

Called once a connection ws closed.

Specified by:

onConnectionClosed in interface TransportConnectionListener

Parameters:

connection - the closed connection

getThreadPool

public ThreadPool getThreadPool()

Returns the internal thread pool