Module org.elasticsearch.server

Package org.elasticsearch.transport

Class TransportService

java.lang.Object

org.elasticsearch.common.component.AbstractLifecycleComponent

org.elasticsearch.transport.TransportService

All Implemented Interfaces:

Closeable, AutoCloseable, LifecycleComponent, 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 Setting<Boolean>	ENABLE_STACK_OVERFLOW_AVOIDANCE	Undocumented on purpose, may be removed at any time.
static final String	HANDSHAKE_ACTION_NAME
static final TransportInterceptor	NOOP_TRANSPORT_INTERCEPTOR
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)
TransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor transportInterceptor, Function<BoundTransportAddress,DiscoveryNode> localNodeFactory, ClusterSettings clusterSettings, Set<String> taskHeaders, Tracer tracer)
TransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor transportInterceptor, Function<BoundTransportAddress,DiscoveryNode> localNodeFactory, ClusterSettings clusterSettings, TaskManager taskManager, Tracer tracer)	Build the service.
TransportService(Settings settings, Transport transport, ThreadPool threadPool, TransportInterceptor transportInterceptor, Function<BoundTransportAddress,DiscoveryNode> localNodeFactory, ClusterSettings clusterSettings, ConnectionManager connectionManager, TaskManager taskManger, Tracer tracer)

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()
BoundTransportAddress	boundRemoteAccessAddress()
ConnectionManager.ConnectionValidator	connectionValidator(DiscoveryNode node)
void	connectToNode(DiscoveryNode node, ActionListener<Releasable> listener)	Connect to the specified node with the given connection profile.
void	connectToNode(DiscoveryNode node, ConnectionProfile connectionProfile, ActionListener<Releasable> listener)	Connect to the specified node with the given connection profile.
void	disconnectFromNode(DiscoveryNode node)
protected void	doClose()	Close this component.
protected void	doStart()	Start this component.
protected void	doStop()	Stop this component.
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
protected void	handleInternalSendException(String action, DiscoveryNode node, long requestId, org.elasticsearch.transport.TransportService.TimeoutHandler timeoutHandler, Exception failure)
void	handshake(Transport.Connection connection, 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, 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()
static boolean	isDirectResponseChannel(TransportChannel transportChannel)
boolean	isTransportSecure()
static boolean	isValidActionName(String actionName)	Returns true iff the action name starts with a valid prefix.
RecyclerBytesStreamOutput	newNetworkBytesStream()
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
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, Executor executor, boolean forceExecution, boolean canTripCircuitBreaker, Writeable.Reader<Request> requestReader, TransportRequestHandler<Request> handler)	Registers a new request handler
<Request extends TransportRequest> void	registerRequestHandler(String action, Executor executor, Writeable.Reader<Request> requestReader, TransportRequestHandler<Request> handler)	Registers a new request handler
void	removeConnectionListener(TransportConnectionListener listener)
void	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()
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, 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

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

ENABLE_STACK_OVERFLOW_AVOIDANCE

public static final Setting<Boolean> ENABLE_STACK_OVERFLOW_AVOIDANCE

Undocumented on purpose, may be removed at any time. Only use this if instructed to do so, can have other unintended consequences including deadlocks.

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)

TransportService

public TransportService(Settings settings,
 Transport transport,
 ThreadPool threadPool,
 TransportInterceptor transportInterceptor,
 Function<BoundTransportAddress,DiscoveryNode> localNodeFactory,
 @Nullable
 ClusterSettings clusterSettings,
 TaskManager taskManager,
 Tracer tracer)

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,
 Tracer tracer)

TransportService

public TransportService(Settings settings,
 Transport transport,
 ThreadPool threadPool,
 TransportInterceptor transportInterceptor,
 Function<BoundTransportAddress,DiscoveryNode> localNodeFactory,
 @Nullable
 ClusterSettings clusterSettings,
 ConnectionManager connectionManager,
 TaskManager taskManger,
 Tracer tracer)

Method Details

getRemoteClusterService

public RemoteClusterService getRemoteClusterService()

getLocalNode

public DiscoveryNode getLocalNode()

getLocalNodeConnection

public Transport.Connection getLocalNodeConnection()

getTaskManager

public TaskManager getTaskManager()

doStart

protected void doStart()

Description copied from class: AbstractLifecycleComponent

Start this component. Typically that means doing things like launching background processes and registering listeners on other components. Other components have been initialized by this point, but may not yet be started.

If this method throws an exception then the startup process will fail, but this component will not be stopped before it is closed.

This method is called while synchronized on AbstractLifecycleComponent.lifecycle. It is only called once in the lifetime of a component, although it may not be called at all if the startup process encountered some kind of fatal error, such as the failure of some other component to initialize or start.

Specified by:

doStart in class AbstractLifecycleComponent

doStop

protected void doStop()

Description copied from class: AbstractLifecycleComponent

Stop this component. Typically that means doing the reverse of whatever AbstractLifecycleComponent.doStart() does.

This method is called while synchronized on AbstractLifecycleComponent.lifecycle. It is only called once in the lifetime of a component, after calling AbstractLifecycleComponent.doStart(), although it will not be called at all if this component did not successfully start.

Specified by:

doStop in class AbstractLifecycleComponent

doClose

protected void doClose()
                throws IOException

Description copied from class: AbstractLifecycleComponent

Close this component. Typically that means doing the reverse of whatever happened during initialization, such as releasing resources acquired there.

This method is called while synchronized on AbstractLifecycleComponent.lifecycle. It is called once in the lifetime of a component. If the component was started then it will be stopped before it is closed, and once it is closed it will not be started or stopped.

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()

boundRemoteAccessAddress

public BoundTransportAddress boundRemoteAccessAddress()

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,
 ActionListener<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,
 @Nullable
 ConnectionProfile connectionProfile,
 ActionListener<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 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,
 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,
 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()

newNetworkBytesStream

public RecyclerBytesStreamOutput newNetworkBytesStream()

disconnectFromNode

public void disconnectFromNode(DiscoveryNode node)

addMessageListener

public void addMessageListener(TransportMessageListener listener)

removeMessageListener

public void removeMessageListener(TransportMessageListener listener)

addConnectionListener

public void addConnectionListener(TransportConnectionListener listener)

removeConnectionListener

public void removeConnectionListener(TransportConnectionListener listener)

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)

handleInternalSendException

protected void handleInternalSendException(String action,
 DiscoveryNode node,
 long requestId,
 @Nullable
 org.elasticsearch.transport.TransportService.TimeoutHandler timeoutHandler,
 Exception failure)

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,
 Executor 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,
 Executor 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

isDirectResponseChannel

public static boolean isDirectResponseChannel(TransportChannel transportChannel)

getThreadPool

public ThreadPool getThreadPool()

Returns the internal thread pool