2 * SPDX-License-Identifier: LGPL-2.1-only
4 * Copyright (C) 2015-2016 EfficiOS Inc.
5 * Copyright (C) 2015-2016 Alexandre Montplaisir <alexmonthy@efficios.com>
6 * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
9 package org
.lttng
.ust
.agent
.client
;
11 import java
.io
.BufferedReader
;
12 import java
.io
.DataInputStream
;
13 import java
.io
.DataOutputStream
;
14 import java
.io
.FileInputStream
;
15 import java
.io
.FileNotFoundException
;
16 import java
.io
.IOException
;
17 import java
.io
.InputStreamReader
;
18 import java
.lang
.management
.ManagementFactory
;
19 import java
.net
.Socket
;
20 import java
.net
.UnknownHostException
;
21 import java
.nio
.ByteBuffer
;
22 import java
.nio
.ByteOrder
;
23 import java
.nio
.charset
.Charset
;
24 import java
.util
.concurrent
.CountDownLatch
;
25 import java
.util
.concurrent
.TimeUnit
;
27 import org
.lttng
.ust
.agent
.utils
.LttngUstAgentLogger
;
30 * Client for agents to connect to a local session daemon, using a TCP socket.
32 * @author David Goulet
34 public class LttngTcpSessiondClient
implements Runnable
{
36 private static final String SESSION_HOST
= "127.0.0.1";
37 private static final String ROOT_PORT_FILE
= "/var/run/lttng/agent.port";
38 private static final String USER_PORT_FILE
= "/.lttng/agent.port";
39 private static final String APP_PATH_PORT_FILE
= "/agent.port";
40 private static final Charset PORT_FILE_ENCODING
= Charset
.forName("UTF-8");
42 private static final int PROTOCOL_MAJOR_VERSION
= 2;
43 private static final int PROTOCOL_MINOR_VERSION
= 0;
45 /** Command header from the session daemon. */
46 private final CountDownLatch registrationLatch
= new CountDownLatch(1);
48 private Socket sessiondSock
;
49 private volatile boolean quit
= false;
51 private DataInputStream inFromSessiond
;
52 private DataOutputStream outToSessiond
;
54 private final ILttngTcpClientListener logAgent
;
55 private final int domainValue
;
56 private final boolean isRoot
;
62 * The listener this client will operate on, typically an LTTng
65 * The integer to send to the session daemon representing the
66 * tracing domain to handle.
68 * True if this client should connect to the root session daemon,
69 * false if it should connect to the user one.
71 public LttngTcpSessiondClient(ILttngTcpClientListener logAgent
, int domainValue
, boolean isRoot
) {
72 this.logAgent
= logAgent
;
73 this.domainValue
= domainValue
;
78 * Wait until this client has successfully established a connection to its
79 * target session daemon.
82 * A timeout in seconds after which this method will return
84 * @return True if the the client actually established the connection, false
85 * if we returned because the timeout has elapsed or the thread was
88 public boolean waitForConnection(int seconds
) {
90 return registrationLatch
.await(seconds
, TimeUnit
.SECONDS
);
91 } catch (InterruptedException e
) {
106 * Connect to the session daemon before anything else.
108 log("Connecting to sessiond");
112 * Register to the session daemon as the Java component of the
115 log("Registering to sessiond");
116 registerToSessiond();
119 * Block on socket receive and wait for command from the
120 * session daemon. This will return if and only if there is a
121 * fatal error or the socket closes.
123 log("Waiting on sessiond commands...");
125 } catch (UnknownHostException uhe
) {
126 uhe
.printStackTrace();
128 * Terminate agent thread.
131 } catch (IOException ioe
) {
133 * I/O exception may have been triggered by a session daemon
134 * closing the socket. Close our own socket and
135 * retry connecting after a delay.
138 if (this.sessiondSock
!= null) {
139 this.sessiondSock
.close();
142 } catch (InterruptedException e
) {
144 * Retry immediately if sleep is interrupted.
146 } catch (IOException closeioe
) {
147 closeioe
.printStackTrace();
149 * Terminate agent thread.
158 * Dispose this client and close any socket connection it may hold.
160 public void close() {
161 log("Closing client");
165 if (this.sessiondSock
!= null) {
166 this.sessiondSock
.close();
168 } catch (IOException e
) {
173 private void connectToSessiond() throws IOException
{
177 * The environment variable LTTNG_UST_APP_PATH disables
178 * connection to per-user and root session daemons.
180 String lttngUstAppPath
= getUstAppPath();
182 if (lttngUstAppPath
!= null) {
183 portToUse
= getPortFromFile(lttngUstAppPath
+ APP_PATH_PORT_FILE
);
185 int rootPort
= getPortFromFile(ROOT_PORT_FILE
);
186 int userPort
= getPortFromFile(getHomePath() + USER_PORT_FILE
);
189 * Check for the edge case of both files existing but pointing to the
190 * same port. In this case, let the root client handle it.
192 if ((rootPort
!= 0) && (rootPort
== userPort
) && (!isRoot
)) {
193 log("User and root config files both point to port " + rootPort
+
194 ". Letting the root client handle it.");
195 throw new IOException();
198 portToUse
= (isRoot ? rootPort
: userPort
);
201 if (portToUse
== 0) {
202 /* No session daemon available. Stop and retry later. */
203 throw new IOException();
206 this.sessiondSock
= new Socket(SESSION_HOST
, portToUse
);
207 this.inFromSessiond
= new DataInputStream(sessiondSock
.getInputStream());
208 this.outToSessiond
= new DataOutputStream(sessiondSock
.getOutputStream());
211 private String
getUstAppPath() {
212 String ustAppPath
= System
.getenv("LTTNG_UST_APP_PATH");
213 if (ustAppPath
!= null) {
214 String
[] paths
= ustAppPath
.split(":");
215 if (paths
.length
> 1) {
216 log("':' separator in LTTNG_UST_APP_PATH, only the first path will be used");
223 private static String
getHomePath() {
225 * The environment variable LTTNG_HOME overrides HOME if
228 String lttngHomePath
= System
.getenv("LTTNG_HOME");
229 if (lttngHomePath
!= null) {
230 return lttngHomePath
;
232 return System
.getProperty("user.home");
236 * Read port number from file created by the session daemon.
238 * @return port value if found else 0.
240 private static int getPortFromFile(String path
) throws IOException
{
241 BufferedReader br
= null;
244 br
= new BufferedReader(new InputStreamReader(new FileInputStream(path
), PORT_FILE_ENCODING
));
245 String line
= br
.readLine();
247 /* File exists but is empty. */
251 int port
= Integer
.parseInt(line
, 10);
252 if (port
< 0 || port
> 65535) {
253 /* Invalid value. Ignore. */
258 } catch (NumberFormatException e
) {
259 /* File contained something that was not a number. */
261 } catch (FileNotFoundException e
) {
262 /* No port available. */
271 private void registerToSessiond() throws IOException
{
272 byte data
[] = new byte[16];
273 ByteBuffer buf
= ByteBuffer
.wrap(data
);
274 String pid
= ManagementFactory
.getRuntimeMXBean().getName().split("@")[0];
276 buf
.putInt(domainValue
);
277 buf
.putInt(Integer
.parseInt(pid
));
278 buf
.putInt(PROTOCOL_MAJOR_VERSION
);
279 buf
.putInt(PROTOCOL_MINOR_VERSION
);
280 this.outToSessiond
.write(data
, 0, data
.length
);
281 this.outToSessiond
.flush();
285 * Handle session command from the session daemon.
287 private void handleSessiondCmd() throws IOException
{
288 /* Data read from the socket */
289 byte inputData
[] = null;
290 /* Reply data written to the socket, sent to the sessiond */
291 LttngAgentResponse response
;
294 /* Get header from session daemon. */
295 SessiondCommandHeader cmdHeader
= recvHeader();
297 if (cmdHeader
.getDataSize() > 0) {
298 inputData
= recvPayload(cmdHeader
);
301 switch (cmdHeader
.getCommandType()) {
305 * Countdown the registration latch, meaning registration is
306 * done and we can proceed to continue tracing.
308 registrationLatch
.countDown();
310 * We don't send any reply to the registration done command.
311 * This just marks the end of the initial session setup.
313 log("Registration done");
318 SessiondCommand listLoggerCmd
= new SessiondListLoggersCommand();
319 response
= listLoggerCmd
.execute(logAgent
);
320 log("Received list loggers command");
323 case CMD_EVENT_ENABLE
:
325 if (inputData
== null) {
326 /* Invalid command */
327 response
= LttngAgentResponse
.FAILURE_RESPONSE
;
330 SessiondCommand enableEventCmd
= new SessiondEnableEventCommand(inputData
);
331 response
= enableEventCmd
.execute(logAgent
);
332 log("Received enable event command: " + enableEventCmd
.toString());
335 case CMD_EVENT_DISABLE
:
337 if (inputData
== null) {
338 /* Invalid command */
339 response
= LttngAgentResponse
.FAILURE_RESPONSE
;
342 SessiondCommand disableEventCmd
= new SessiondDisableEventCommand(inputData
);
343 response
= disableEventCmd
.execute(logAgent
);
344 log("Received disable event command: " + disableEventCmd
.toString());
347 case CMD_APP_CTX_ENABLE
:
349 if (inputData
== null) {
350 /* This commands expects a payload, invalid command */
351 response
= LttngAgentResponse
.FAILURE_RESPONSE
;
354 SessiondCommand enableAppCtxCmd
= new SessiondEnableAppContextCommand(inputData
);
355 response
= enableAppCtxCmd
.execute(logAgent
);
356 log("Received enable app-context command");
359 case CMD_APP_CTX_DISABLE
:
361 if (inputData
== null) {
362 /* This commands expects a payload, invalid command */
363 response
= LttngAgentResponse
.FAILURE_RESPONSE
;
366 SessiondCommand disableAppCtxCmd
= new SessiondDisableAppContextCommand(inputData
);
367 response
= disableAppCtxCmd
.execute(logAgent
);
368 log("Received disable app-context command");
373 /* Unknown command, send empty reply */
375 log("Received unknown command, ignoring");
380 /* Send response to the session daemon. */
382 if (response
== null) {
383 responseData
= new byte[4];
384 ByteBuffer buf
= ByteBuffer
.wrap(responseData
);
385 buf
.order(ByteOrder
.BIG_ENDIAN
);
387 log("Sending response: " + response
.toString());
388 responseData
= response
.getBytes();
390 this.outToSessiond
.write(responseData
, 0, responseData
.length
);
391 this.outToSessiond
.flush();
396 * Receive header data from the session daemon using the LTTng command
397 * static buffer of the right size.
399 private SessiondCommandHeader
recvHeader() throws IOException
{
400 byte data
[] = new byte[SessiondCommandHeader
.HEADER_SIZE
];
401 int bytesLeft
= data
.length
;
404 while (bytesLeft
> 0) {
405 int bytesRead
= this.inFromSessiond
.read(data
, bytesOffset
, bytesLeft
);
408 throw new IOException();
410 bytesLeft
-= bytesRead
;
411 bytesOffset
+= bytesRead
;
413 return new SessiondCommandHeader(data
);
417 * Receive payload from the session daemon. This MUST be done after a
418 * recvHeader() so the header value of a command are known.
420 * The caller SHOULD use isPayload() before which returns true if a payload
421 * is expected after the header.
423 private byte[] recvPayload(SessiondCommandHeader headerCmd
) throws IOException
{
424 byte payload
[] = new byte[(int) headerCmd
.getDataSize()];
425 int bytesLeft
= payload
.length
;
428 /* Failsafe check so we don't waste our time reading 0 bytes. */
429 if (bytesLeft
== 0) {
433 while (bytesLeft
> 0) {
434 int bytesRead
= inFromSessiond
.read(payload
, bytesOffset
, bytesLeft
);
437 throw new IOException();
439 bytesLeft
-= bytesRead
;
440 bytesOffset
+= bytesRead
;
446 * Wrapper for this class's logging, adds the connection's characteristics
447 * to help differentiate between multiple TCP clients.
449 private void log(String message
) {
450 LttngUstAgentLogger
.log(getClass(),
451 "(root=" + isRoot
+ ", domain=" + domainValue
+ ") " + message
);