liblttng-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 deamon. */
  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 rootPort = getPortFromFile(ROOT_PORT_FILE);
 174                 int userPort = getPortFromFile(getHomePath() + USER_PORT_FILE);
 175
 176                 /*
 177                  * Check for the edge case of both files existing but pointing to the
 178                  * same port. In this case, let the root client handle it.
 179                  */
 180                 if ((rootPort != 0) && (rootPort == userPort) && (!isRoot)) {
 181                         log("User and root config files both point to port " + rootPort +
 182                                         ". Letting the root client handle it.");
 183                         throw new IOException();
 184                 }
 185
 186                 int portToUse = (isRoot ? rootPort : userPort);
 187
 188                 if (portToUse == 0) {
 189                         /* No session daemon available. Stop and retry later. */
 190                         throw new IOException();
 191                 }
 192
 193                 this.sessiondSock = new Socket(SESSION_HOST, portToUse);
 194                 this.inFromSessiond = new DataInputStream(sessiondSock.getInputStream());
 195                 this.outToSessiond = new DataOutputStream(sessiondSock.getOutputStream());
 196         }
 197
 198         private static String getHomePath() {
 199                 /*
 200                  * The environment variable LTTNG_HOME overrides HOME if
 201                  * defined.
 202                  */
 203                 String homePath = System.getenv("LTTNG_HOME");
 204
 205                 if (homePath == null) {
 206                         homePath = System.getProperty("user.home");
 207                 }
 208                 return homePath;
 209         }
 210
 211         /**
 212          * Read port number from file created by the session daemon.
 213          *
 214          * @return port value if found else 0.
 215          */
 216         private static int getPortFromFile(String path) throws IOException {
 217                 BufferedReader br = null;
 218
 219                 try {
 220                         br = new BufferedReader(new InputStreamReader(new FileInputStream(path), PORT_FILE_ENCODING));
 221                         String line = br.readLine();
 222                         if (line == null) {
 223                                 /* File exists but is empty. */
 224                                 return 0;
 225                         }
 226
 227                         int port = Integer.parseInt(line, 10);
 228                         if (port < 0 || port > 65535) {
 229                                 /* Invalid value. Ignore. */
 230                                 port = 0;
 231                         }
 232                         return port;
 233
 234                 } catch (NumberFormatException e) {
 235                         /* File contained something that was not a number. */
 236                         return 0;
 237                 } catch (FileNotFoundException e) {
 238                         /* No port available. */
 239                         return 0;
 240                 } finally {
 241                         if (br != null) {
 242                                 br.close();
 243                         }
 244                 }
 245         }
 246
 247         private void registerToSessiond() throws IOException {
 248                 byte data[] = new byte[16];
 249                 ByteBuffer buf = ByteBuffer.wrap(data);
 250                 String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
 251
 252                 buf.putInt(domainValue);
 253                 buf.putInt(Integer.parseInt(pid));
 254                 buf.putInt(PROTOCOL_MAJOR_VERSION);
 255                 buf.putInt(PROTOCOL_MINOR_VERSION);
 256                 this.outToSessiond.write(data, 0, data.length);
 257                 this.outToSessiond.flush();
 258         }
 259
 260         /**
 261          * Handle session command from the session daemon.
 262          */
 263         private void handleSessiondCmd() throws IOException {
 264                 /* Data read from the socket */
 265                 byte inputData[] = null;
 266                 /* Reply data written to the socket, sent to the sessiond */
 267                 LttngAgentResponse response;
 268
 269                 while (true) {
 270                         /* Get header from session daemon. */
 271                         SessiondCommandHeader cmdHeader = recvHeader();
 272
 273                         if (cmdHeader.getDataSize() > 0) {
 274                                 inputData = recvPayload(cmdHeader);
 275                         }
 276
 277                         switch (cmdHeader.getCommandType()) {
 278                         case CMD_REG_DONE:
 279                         {
 280                                 /*
 281                                  * Countdown the registration latch, meaning registration is
 282                                  * done and we can proceed to continue tracing.
 283                                  */
 284                                 registrationLatch.countDown();
 285                                 /*
 286                                  * We don't send any reply to the registration done command.
 287                                  * This just marks the end of the initial session setup.
 288                                  */
 289                                 log("Registration done");
 290                                 continue;
 291                         }
 292                         case CMD_LIST:
 293                         {
 294                                 SessiondCommand listLoggerCmd = new SessiondListLoggersCommand();
 295                                 response = listLoggerCmd.execute(logAgent);
 296                                 log("Received list loggers command");
 297                                 break;
 298                         }
 299                         case CMD_EVENT_ENABLE:
 300                         {
 301                                 if (inputData == null) {
 302                                         /* Invalid command */
 303                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 304                                         break;
 305                                 }
 306                                 SessiondCommand enableEventCmd = new SessiondEnableEventCommand(inputData);
 307                                 response = enableEventCmd.execute(logAgent);
 308                                 log("Received enable event command: " + enableEventCmd.toString());
 309                                 break;
 310                         }
 311                         case CMD_EVENT_DISABLE:
 312                         {
 313                                 if (inputData == null) {
 314                                         /* Invalid command */
 315                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 316                                         break;
 317                                 }
 318                                 SessiondCommand disableEventCmd = new SessiondDisableEventCommand(inputData);
 319                                 response = disableEventCmd.execute(logAgent);
 320                                 log("Received disable event command: " + disableEventCmd.toString());
 321                                 break;
 322                         }
 323                         case CMD_APP_CTX_ENABLE:
 324                         {
 325                                 if (inputData == null) {
 326                                         /* This commands expects a payload, invalid command */
 327                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 328                                         break;
 329                                 }
 330                                 SessiondCommand enableAppCtxCmd = new SessiondEnableAppContextCommand(inputData);
 331                                 response = enableAppCtxCmd.execute(logAgent);
 332                                 log("Received enable app-context command");
 333                                 break;
 334                         }
 335                         case CMD_APP_CTX_DISABLE:
 336                         {
 337                                 if (inputData == null) {
 338                                         /* This commands expects a payload, invalid command */
 339                                         response = LttngAgentResponse.FAILURE_RESPONSE;
 340                                         break;
 341                                 }
 342                                 SessiondCommand disableAppCtxCmd = new SessiondDisableAppContextCommand(inputData);
 343                                 response = disableAppCtxCmd.execute(logAgent);
 344                                 log("Received disable app-context command");
 345                                 break;
 346                         }
 347                         default:
 348                         {
 349                                 /* Unknown command, send empty reply */
 350                                 response = null;
 351                                 log("Received unknown command, ignoring");
 352                                 break;
 353                         }
 354                         }
 355
 356                         /* Send response to the session daemon. */
 357                         byte[] responseData;
 358                         if (response == null) {
 359                                 responseData = new byte[4];
 360                                 ByteBuffer buf = ByteBuffer.wrap(responseData);
 361                                 buf.order(ByteOrder.BIG_ENDIAN);
 362                         } else {
 363                                 log("Sending response: " + response.toString());
 364                                 responseData = response.getBytes();
 365                         }
 366                         this.outToSessiond.write(responseData, 0, responseData.length);
 367                         this.outToSessiond.flush();
 368                 }
 369         }
 370
 371         /**
 372          * Receive header data from the session daemon using the LTTng command
 373          * static buffer of the right size.
 374          */
 375         private SessiondCommandHeader recvHeader() throws IOException {
 376                 byte data[] = new byte[SessiondCommandHeader.HEADER_SIZE];
 377                 int bytesLeft = data.length;
 378                 int bytesOffset = 0;
 379
 380                 while (bytesLeft > 0) {
 381                         int bytesRead = this.inFromSessiond.read(data, bytesOffset, bytesLeft);
 382
 383                         if (bytesRead < 0) {
 384                                 throw new IOException();
 385                         }
 386                         bytesLeft -= bytesRead;
 387                         bytesOffset += bytesRead;
 388                 }
 389                 return new SessiondCommandHeader(data);
 390         }
 391
 392         /**
 393          * Receive payload from the session daemon. This MUST be done after a
 394          * recvHeader() so the header value of a command are known.
 395          *
 396          * The caller SHOULD use isPayload() before which returns true if a payload
 397          * is expected after the header.
 398          */
 399         private byte[] recvPayload(SessiondCommandHeader headerCmd) throws IOException {
 400                 byte payload[] = new byte[(int) headerCmd.getDataSize()];
 401                 int bytesLeft = payload.length;
 402                 int bytesOffset = 0;
 403
 404                 /* Failsafe check so we don't waste our time reading 0 bytes. */
 405                 if (bytesLeft == 0) {
 406                         return null;
 407                 }
 408
 409                 while (bytesLeft > 0) {
 410                         int bytesRead = inFromSessiond.read(payload, bytesOffset, bytesLeft);
 411
 412                         if (bytesRead < 0) {
 413                                 throw new IOException();
 414                         }
 415                         bytesLeft -= bytesRead;
 416                         bytesOffset += bytesRead;
 417                 }
 418                 return payload;
 419         }
 420
 421         /**
 422          * Wrapper for this class's logging, adds the connection's characteristics
 423          * to help differentiate between multiple TCP clients.
 424          */
 425         private void log(String message) {
 426                 LttngUstAgentLogger.log(getClass(),
 427                                 "(root=" + isRoot + ", domain=" + domainValue + ") " + message);
 428         }
 429 }