src/lib/lttng-ust-java-agent/java/lttng-ust-agent-common/org/lttng/ust/agent/client/LttngTcpSessiondClient.java

   1 /*
   2  * SPDX-License-Identifier: LGPL-2.1-only
   3  *
   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>
   7  */
   8
   9 package org.lttng.ust.agent.client;
  10
  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;
  26
  27 import org.lttng.ust.agent.utils.LttngUstAgentLogger;
  28
  29 /**
  30  * Client for agents to connect to a local session daemon, using a TCP socket.
  31  *
  32  * @author David Goulet
  33  */
  34 public class LttngTcpSessiondClient implements Runnable {
  35
  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 Charset PORT_FILE_ENCODING = Charset.forName("UTF-8");
  40
  41         private static final int PROTOCOL_MAJOR_VERSION = 2;
  42         private static final int PROTOCOL_MINOR_VERSION = 0;
  43
  44         /** Command header from the session daemon. */
  45         private final CountDownLatch registrationLatch = new CountDownLatch(1);
  46
  47         private Socket sessiondSock;
  48         private volatile boolean quit = false;
  49
  50         private DataInputStream inFromSessiond;
  51         private DataOutputStream outToSessiond;
  52
  53         private final ILttngTcpClientListener logAgent;
  54         private final int domainValue;
  55         private final boolean isRoot;
  56
  57         /**
  58          * Constructor
  59          *
  60          * @param logAgent
  61          *            The listener this client will operate on, typically an LTTng
  62          *            agent.
  63          * @param domainValue
  64          *            The integer to send to the session daemon representing the
  65          *            tracing domain to handle.
  66          * @param isRoot
  67          *            True if this client should connect to the root session daemon,
  68          *            false if it should connect to the user one.
  69          */
  70         public LttngTcpSessiondClient(ILttngTcpClientListener logAgent, int domainValue, boolean isRoot) {
  71                 this.logAgent = logAgent;
  72                 this.domainValue = domainValue;
  73                 this.isRoot = isRoot;
  74         }
  75
  76         /**
  77          * Wait until this client has successfully established a connection to its
  78          * target session daemon.
  79          *
  80          * @param seconds
  81          *            A timeout in seconds after which this method will return
  82          *            anyway.
  83          * @return True if the the client actually established the connection, false
  84          *         if we returned because the timeout has elapsed or the thread was
  85          *         interrupted.
  86          */
  87         public boolean waitForConnection(int seconds) {
  88                 try {
  89                         return registrationLatch.await(seconds, TimeUnit.SECONDS);
  90                 } catch (InterruptedException e) {
  91                         return false;
  92                 }
  93         }
  94
  95         @Override
  96         public void run() {
  97                 for (;;) {
  98                         if (this.quit) {
  99                                 break;
 100                         }
 101
 102                         try {
 103
 104                                 /*
 105                                  * Connect to the session daemon before anything else.
 106                                  */
 107                                 log("Connecting to sessiond");
 108                                 connectToSessiond();
 109
 110                                 /*
 111                                  * Register to the session daemon as the Java component of the
 112                                  * UST application.
 113                                  */
 114                                 log("Registering to sessiond");
 115                                 registerToSessiond();
 116
 117                                 /*
 118                                  * Block on socket receive and wait for command from the
 119                                  * session daemon. This will return if and only if there is a
 120                                  * fatal error or the socket closes.
 121                                  */
 122                                 log("Waiting on sessiond commands...");
 123                                 handleSessiondCmd();
 124                         } catch (UnknownHostException uhe) {
 125                                 uhe.printStackTrace();
 126                                 /*
 127                                  * Terminate agent thread.
 128                                  */
 129                                 close();
 130                         } catch (IOException ioe) {
 131                                 /*
 132                                  * I/O exception may have been triggered by a session daemon
 133                                  * closing the socket. Close our own socket and
 134                                  * retry connecting after a delay.
 135                                  */
 136                                 try {
 137                                         if (this.sessiondSock != null) {
 138                                                 this.sessiondSock.close();
 139                                         }
 140                                         Thread.sleep(3000);
 141                                 } catch (InterruptedException e) {
 142                                         /*
 143                                          * Retry immediately if sleep is interrupted.
 144                                          */
 145                                 } catch (IOException closeioe) {
 146                                         closeioe.printStackTrace();
 147                                         /*
 148                                          * Terminate agent thread.
 149                                          */
 150                                         close();
 151                                 }
 152                         }
 153                 }
 154         }
 155
 156         /**
 157          * Dispose this client and close any socket connection it may hold.
 158          */
 159         public void close() {
 160                 log("Closing client");
 161                 this.quit = true;
 162
 163                 try {
 164                         if (this.sessiondSock != null) {
 165                                 this.sessiondSock.close();
 166                         }
 167                 } catch (IOException e) {
 168                         e.printStackTrace();
 169                 }
 170         }
 171
 172         private void connectToSessiond() throws IOException {
 173                 int portToUse;
 174
 175                 /*
 176                  * The environment variable LTTNG_UST_APP_PATH disables
 177                  * connection to per-user and root session daemons.
 178                  */
 179                 String lttngUstAppPath = getUstAppPath();
 180
 181                 if (lttngUstAppPath != null) {
 182                         portToUse = getPortFromFile(lttngUstAppPath + USER_PORT_FILE);
 183                 } else {
 184                         int rootPort = getPortFromFile(ROOT_PORT_FILE);
 185                         int userPort = getPortFromFile(getHomePath() + USER_PORT_FILE);
 186
 187                         /*
 188                          * Check for the edge case of both files existing but pointing to the
 189                          * same port. In this case, let the root client handle it.
 190                          */
 191                         if ((rootPort != 0) && (rootPort == userPort) && (!isRoot)) {
 192                                 log("User and root config files both point to port " + rootPort +
 193                                                 ". Letting the root client handle it.");
 194                                 throw new IOException();
 195                         }
 196
 197                         portToUse = (isRoot ? rootPort : userPort);
 198                 }
 199
 200                 if (portToUse == 0) {
 201                         /* No session daemon available. Stop and retry later. */
 202                         throw new IOException();
 203                 }
 204
 205                 this.sessiondSock = new Socket(SESSION_HOST, portToUse);
 206                 this.inFromSessiond = new DataInputStream(sessiondSock.getInputStream());
 207                 this.outToSessiond = new DataOutputStream(sessiondSock.getOutputStream());
 208         }
 209
 210         private static String getUstAppPath() {
 211                 return System.getenv("LTTNG_UST_APP_PATH");
 212         }
 213
 214         private static String getHomePath() {
 215                 /*
 216                  * The environment variable LTTNG_HOME overrides HOME if
 217                  * set.
 218                  */
 219                 String lttngHomePath = System.getenv("LTTNG_HOME");
 220                 if (lttngHomePath != null) {
 221                         return lttngHomePath;
 222                 }
 223                 return System.getProperty("user.home");
 224         }
 225
 226         /**
 227          * Read port number from file created by the session daemon.
 228          *
 229          * @return port value if found else 0.
 230          */
 231         private static int getPortFromFile(String path) throws IOException {
 232                 BufferedReader br = null;
 233
 234                 try {
 235                         br = new BufferedReader(new InputStreamReader(new FileInputStream(path), PORT_FILE_ENCODING));
 236                         String line = br.readLine();
 237                         if (line == null) {
 238                                 /* File exists but is empty. */
 239                                 return 0;
 240                         }
 241
 242                         int port = Integer.parseInt(line, 10);
 243                         if (port < 0 || port > 65535) {
 244                                 /* Invalid value. Ignore. */
 245                                 port = 0;
 246                         }
 247                         return port;
 248
 249                 } catch (NumberFormatException e) {
 250                         /* File contained something that was not a number. */
 251                         return 0;
 252                 } catch (FileNotFoundException e) {
 253                         /* No port available. */
 254                         return 0;
 255                 } finally {
 256                         if (br != null) {
 257                                 br.close();
 258                         }
 259                 }
 260         }
 261
 262         private void registerToSessiond() throws IOException {
 263                 byte data[] = new byte[16];
 264                 ByteBuffer buf = ByteBuffer.wrap(data);
 265                 String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
 266
 267                 buf.putInt(domainValue);
 268                 buf.putInt(Integer.parseInt(pid));
 269                 buf.putInt(PROTOCOL_MAJOR_VERSION);
 270                 buf.putInt(PROTOCOL_MINOR_VERSION);
 271                 this.outToSessiond.write(data, 0, data.length);
 272                 this.outToSessiond.flush();
 273         }
 274
 275         /**
 276          * Handle session command from the session daemon.
 277          */
 278         private void handleSessiondCmd() throws IOException {
 279                 /* Data read from the socket */
 280                 byte inputData[] = null;
 281                 /* Reply data written to the socket, sent to the sessiond */
 282                 LttngAgentResponse response;
 283
 284                 while (true) {
 285                         /* Get header from session daemon. */
 286                         SessiondCommandHeader cmdHeader = recvHeader();
 287
 288                         if (cmdHeader.getDataSize() > 0) {
 289                                 inputData = recvPayload(cmdHeader);
 290                         }
 291
 292                         switch (cmdHeader.getCommandType()) {
 293                         case CMD_REG_DONE:
 294                         {
 295                                 /*
 296                                  * Countdown the registration latch, meaning registration is
 297                                  * done and we can proceed to continue tracing.
 298                                  */
 299                                 registrationLatch.countDown();
 300                                 /*
 301                                  * We don't send any reply to the registration done command.
 302                                  * This just marks the end of the initial session setup.
 303                                  */
 304                                 log("Registration done");
 305                                 continue;
 306                         }
 307                         case CMD_LIST:
 308                         {
 309                                 SessiondCommand listLoggerCmd = new SessiondListLoggersCommand();
 310                                 response = listLoggerCmd.execute(logAgent);
 311                                 log("Received list loggers command");
 312                                 break;
 313                         }
 314                         case CMD_EVENT_ENABLE:
 315                         {
 316                                 if (inputData == null) {
 317                                         /* Invalid command */
 318                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 319                                         break;
 320                                 }
 321                                 SessiondCommand enableEventCmd = new SessiondEnableEventCommand(inputData);
 322                                 response = enableEventCmd.execute(logAgent);
 323                                 log("Received enable event command: " + enableEventCmd.toString());
 324                                 break;
 325                         }
 326                         case CMD_EVENT_DISABLE:
 327                         {
 328                                 if (inputData == null) {
 329                                         /* Invalid command */
 330                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 331                                         break;
 332                                 }
 333                                 SessiondCommand disableEventCmd = new SessiondDisableEventCommand(inputData);
 334                                 response = disableEventCmd.execute(logAgent);
 335                                 log("Received disable event command: " + disableEventCmd.toString());
 336                                 break;
 337                         }
 338                         case CMD_APP_CTX_ENABLE:
 339                         {
 340                                 if (inputData == null) {
 341                                         /* This commands expects a payload, invalid command */
 342                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 343                                         break;
 344                                 }
 345                                 SessiondCommand enableAppCtxCmd = new SessiondEnableAppContextCommand(inputData);
 346                                 response = enableAppCtxCmd.execute(logAgent);
 347                                 log("Received enable app-context command");
 348                                 break;
 349                         }
 350                         case CMD_APP_CTX_DISABLE:
 351                         {
 352                                 if (inputData == null) {
 353                                         /* This commands expects a payload, invalid command */
 354                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 355                                         break;
 356                                 }
 357                                 SessiondCommand disableAppCtxCmd = new SessiondDisableAppContextCommand(inputData);
 358                                 response = disableAppCtxCmd.execute(logAgent);
 359                                 log("Received disable app-context command");
 360                                 break;
 361                         }
 362                         default:
 363                         {
 364                                 /* Unknown command, send empty reply */
 365                                 response = null;
 366                                 log("Received unknown command, ignoring");
 367                                 break;
 368                         }
 369                         }
 370
 371                         /* Send response to the session daemon. */
 372                         byte[] responseData;
 373                         if (response == null) {
 374                                 responseData = new byte[4];
 375                                 ByteBuffer buf = ByteBuffer.wrap(responseData);
 376                                 buf.order(ByteOrder.BIG_ENDIAN);
 377                         } else {
 378                                 log("Sending response: " + response.toString());
 379                                 responseData = response.getBytes();
 380                         }
 381                         this.outToSessiond.write(responseData, 0, responseData.length);
 382                         this.outToSessiond.flush();
 383                 }
 384         }
 385
 386         /**
 387          * Receive header data from the session daemon using the LTTng command
 388          * static buffer of the right size.
 389          */
 390         private SessiondCommandHeader recvHeader() throws IOException {
 391                 byte data[] = new byte[SessiondCommandHeader.HEADER_SIZE];
 392                 int bytesLeft = data.length;
 393                 int bytesOffset = 0;
 394
 395                 while (bytesLeft > 0) {
 396                         int bytesRead = this.inFromSessiond.read(data, bytesOffset, bytesLeft);
 397
 398                         if (bytesRead < 0) {
 399                                 throw new IOException();
 400                         }
 401                         bytesLeft -= bytesRead;
 402                         bytesOffset += bytesRead;
 403                 }
 404                 return new SessiondCommandHeader(data);
 405         }
 406
 407         /**
 408          * Receive payload from the session daemon. This MUST be done after a
 409          * recvHeader() so the header value of a command are known.
 410          *
 411          * The caller SHOULD use isPayload() before which returns true if a payload
 412          * is expected after the header.
 413          */
 414         private byte[] recvPayload(SessiondCommandHeader headerCmd) throws IOException {
 415                 byte payload[] = new byte[(int) headerCmd.getDataSize()];
 416                 int bytesLeft = payload.length;
 417                 int bytesOffset = 0;
 418
 419                 /* Failsafe check so we don't waste our time reading 0 bytes. */
 420                 if (bytesLeft == 0) {
 421                         return null;
 422                 }
 423
 424                 while (bytesLeft > 0) {
 425                         int bytesRead = inFromSessiond.read(payload, bytesOffset, bytesLeft);
 426
 427                         if (bytesRead < 0) {
 428                                 throw new IOException();
 429                         }
 430                         bytesLeft -= bytesRead;
 431                         bytesOffset += bytesRead;
 432                 }
 433                 return payload;
 434         }
 435
 436         /**
 437          * Wrapper for this class's logging, adds the connection's characteristics
 438          * to help differentiate between multiple TCP clients.
 439          */
 440         private void log(String message) {
 441                 LttngUstAgentLogger.log(getClass(),
 442                                 "(root=" + isRoot + ", domain=" + domainValue + ") " + message);
 443         }
 444 }