2 * Copyright (C) 2015-2016 EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
3 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
5 * This library is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU Lesser General Public License, version 2.1 only,
7 * as published by the Free Software Foundation.
9 * This library is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 package org
.lttng
.ust
.agent
.client
;
21 import java
.io
.BufferedReader
;
22 import java
.io
.DataInputStream
;
23 import java
.io
.DataOutputStream
;
25 import java
.io
.FileNotFoundException
;
26 import java
.io
.FileReader
;
27 import java
.io
.IOException
;
28 import java
.lang
.management
.ManagementFactory
;
29 import java
.net
.Socket
;
30 import java
.net
.UnknownHostException
;
31 import java
.nio
.ByteBuffer
;
32 import java
.nio
.ByteOrder
;
33 import java
.util
.concurrent
.CountDownLatch
;
34 import java
.util
.concurrent
.TimeUnit
;
36 import org
.lttng
.ust
.agent
.utils
.LttngUstAgentLogger
;
39 * Client for agents to connect to a local session daemon, using a TCP socket.
41 * @author David Goulet
43 public class LttngTcpSessiondClient
implements Runnable
{
45 private static final String SESSION_HOST
= "127.0.0.1";
46 private static final String ROOT_PORT_FILE
= "/var/run/lttng/agent.port";
47 private static final String USER_PORT_FILE
= "/.lttng/agent.port";
49 private static final int PROTOCOL_MAJOR_VERSION
= 2;
50 private static final int PROTOCOL_MINOR_VERSION
= 0;
52 /** Command header from the session deamon. */
53 private final CountDownLatch registrationLatch
= new CountDownLatch(1);
55 private Socket sessiondSock
;
56 private volatile boolean quit
= false;
58 private DataInputStream inFromSessiond
;
59 private DataOutputStream outToSessiond
;
61 private final ILttngTcpClientListener logAgent
;
62 private final int domainValue
;
63 private final boolean isRoot
;
69 * The listener this client will operate on, typically an LTTng
72 * The integer to send to the session daemon representing the
73 * tracing domain to handle.
75 * True if this client should connect to the root session daemon,
76 * false if it should connect to the user one.
78 public LttngTcpSessiondClient(ILttngTcpClientListener logAgent
, int domainValue
, boolean isRoot
) {
79 this.logAgent
= logAgent
;
80 this.domainValue
= domainValue
;
85 * Wait until this client has successfully established a connection to its
86 * target session daemon.
89 * A timeout in seconds after which this method will return
91 * @return True if the the client actually established the connection, false
92 * if we returned because the timeout has elapsed or the thread was
95 public boolean waitForConnection(int seconds
) {
97 return registrationLatch
.await(seconds
, TimeUnit
.SECONDS
);
98 } catch (InterruptedException e
) {
113 * Connect to the session daemon before anything else.
115 LttngUstAgentLogger
.log(getClass(), "Connecting to sessiond");
119 * Register to the session daemon as the Java component of the
122 LttngUstAgentLogger
.log(getClass(), "Registering to sessiond");
123 registerToSessiond();
126 * Block on socket receive and wait for command from the
127 * session daemon. This will return if and only if there is a
128 * fatal error or the socket closes.
130 LttngUstAgentLogger
.log(getClass(), "Waiting on sessiond commands...");
132 } catch (UnknownHostException uhe
) {
133 uhe
.printStackTrace();
134 } catch (IOException ioe
) {
137 } catch (InterruptedException e
) {
145 * Dispose this client and close any socket connection it may hold.
147 public void close() {
148 LttngUstAgentLogger
.log(getClass(), "Closing client");
152 if (this.sessiondSock
!= null) {
153 this.sessiondSock
.close();
155 } catch (IOException e
) {
160 private void connectToSessiond() throws IOException
{
164 port
= getPortFromFile(ROOT_PORT_FILE
);
166 /* No session daemon available. Stop and retry later. */
167 throw new IOException();
170 port
= getPortFromFile(getHomePath() + USER_PORT_FILE
);
172 /* No session daemon available. Stop and retry later. */
173 throw new IOException();
177 this.sessiondSock
= new Socket(SESSION_HOST
, port
);
178 this.inFromSessiond
= new DataInputStream(sessiondSock
.getInputStream());
179 this.outToSessiond
= new DataOutputStream(sessiondSock
.getOutputStream());
182 private static String
getHomePath() {
184 * The environment variable LTTNG_HOME overrides HOME if
187 String homePath
= System
.getenv("LTTNG_HOME");
189 if (homePath
== null) {
190 homePath
= System
.getProperty("user.home");
196 * Read port number from file created by the session daemon.
198 * @return port value if found else 0.
200 private static int getPortFromFile(String path
) throws IOException
{
202 BufferedReader br
= null;
203 File file
= new File(path
);
206 br
= new BufferedReader(new FileReader(file
));
207 String line
= br
.readLine();
208 port
= Integer
.parseInt(line
, 10);
209 if (port
< 0 || port
> 65535) {
210 /* Invalid value. Ignore. */
213 } catch (FileNotFoundException e
) {
214 /* No port available. */
225 private void registerToSessiond() throws IOException
{
226 byte data
[] = new byte[16];
227 ByteBuffer buf
= ByteBuffer
.wrap(data
);
228 String pid
= ManagementFactory
.getRuntimeMXBean().getName().split("@")[0];
230 buf
.putInt(domainValue
);
231 buf
.putInt(Integer
.parseInt(pid
));
232 buf
.putInt(PROTOCOL_MAJOR_VERSION
);
233 buf
.putInt(PROTOCOL_MINOR_VERSION
);
234 this.outToSessiond
.write(data
, 0, data
.length
);
235 this.outToSessiond
.flush();
239 * Handle session command from the session daemon.
241 private void handleSessiondCmd() throws IOException
{
242 /* Data read from the socket */
243 byte inputData
[] = null;
244 /* Reply data written to the socket, sent to the sessiond */
245 byte responseData
[] = null;
248 /* Get header from session daemon. */
249 SessiondCommandHeader cmdHeader
= recvHeader();
251 if (cmdHeader
.getDataSize() > 0) {
252 inputData
= recvPayload(cmdHeader
);
255 switch (cmdHeader
.getCommandType()) {
259 * Countdown the registration latch, meaning registration is
260 * done and we can proceed to continue tracing.
262 registrationLatch
.countDown();
264 * We don't send any reply to the registration done command.
265 * This just marks the end of the initial session setup.
267 LttngUstAgentLogger
.log(getClass(), "Registration done");
272 SessiondCommand listLoggerCmd
= new SessiondListLoggersCommand();
273 LttngAgentResponse response
= listLoggerCmd
.execute(logAgent
);
274 responseData
= response
.getBytes();
275 LttngUstAgentLogger
.log(getClass(), "Received list loggers command");
278 case CMD_EVENT_ENABLE
:
280 if (inputData
== null) {
281 /* Invalid command */
282 responseData
= LttngAgentResponse
.FAILURE_RESPONSE
.getBytes();
285 SessiondCommand enableEventCmd
= new SessiondEnableEventCommand(inputData
);
286 LttngAgentResponse response
= enableEventCmd
.execute(logAgent
);
287 responseData
= response
.getBytes();
288 LttngUstAgentLogger
.log(getClass(), "Received enable event command");
291 case CMD_EVENT_DISABLE
:
293 if (inputData
== null) {
294 /* Invalid command */
295 responseData
= LttngAgentResponse
.FAILURE_RESPONSE
.getBytes();
298 SessiondCommand disableEventCmd
= new SessiondDisableEventCommand(inputData
);
299 LttngAgentResponse response
= disableEventCmd
.execute(logAgent
);
300 responseData
= response
.getBytes();
301 LttngUstAgentLogger
.log(getClass(), "Received disable event command");
304 case CMD_APP_CTX_ENABLE
:
306 if (inputData
== null) {
307 /* This commands expects a payload, invalid command */
308 responseData
= LttngAgentResponse
.FAILURE_RESPONSE
.getBytes();
311 SessiondCommand enableAppCtxCmd
= new SessiondEnableAppContextCommand(inputData
);
312 LttngAgentResponse response
= enableAppCtxCmd
.execute(logAgent
);
313 responseData
= response
.getBytes();
314 LttngUstAgentLogger
.log(getClass(), "Received enable app-context command");
317 case CMD_APP_CTX_DISABLE
:
319 if (inputData
== null) {
320 /* This commands expects a payload, invalid command */
321 responseData
= LttngAgentResponse
.FAILURE_RESPONSE
.getBytes();
324 SessiondCommand disableAppCtxCmd
= new SessiondDisableAppContextCommand(inputData
);
325 LttngAgentResponse response
= disableAppCtxCmd
.execute(logAgent
);
326 responseData
= response
.getBytes();
327 LttngUstAgentLogger
.log(getClass(), "Received disable app-context command");
332 /* Unknown command, send empty reply */
333 responseData
= new byte[4];
334 ByteBuffer buf
= ByteBuffer
.wrap(responseData
);
335 buf
.order(ByteOrder
.BIG_ENDIAN
);
336 LttngUstAgentLogger
.log(getClass(), "Received unknown command, ignoring");
341 /* Send response to the session daemon. */
342 LttngUstAgentLogger
.log(getClass(), "Sending response");
343 this.outToSessiond
.write(responseData
, 0, responseData
.length
);
344 this.outToSessiond
.flush();
349 * Receive header data from the session daemon using the LTTng command
350 * static buffer of the right size.
352 private SessiondCommandHeader
recvHeader() throws IOException
{
353 byte data
[] = new byte[SessiondCommandHeader
.HEADER_SIZE
];
355 int readLen
= this.inFromSessiond
.read(data
, 0, data
.length
);
356 if (readLen
!= data
.length
) {
357 throw new IOException();
359 return new SessiondCommandHeader(data
);
363 * Receive payload from the session daemon. This MUST be done after a
364 * recvHeader() so the header value of a command are known.
366 * The caller SHOULD use isPayload() before which returns true if a payload
367 * is expected after the header.
369 private byte[] recvPayload(SessiondCommandHeader headerCmd
) throws IOException
{
370 byte payload
[] = new byte[(int) headerCmd
.getDataSize()];
372 /* Failsafe check so we don't waste our time reading 0 bytes. */
373 if (payload
.length
== 0) {
377 int read
= inFromSessiond
.read(payload
, 0, payload
.length
);
378 if (read
!= payload
.length
) {
379 throw new IOException("Unexpected number of bytes read in sessiond command payload");