liblttng-ust-java-agent/java/org/lttng/ust/agent/LTTngTCPSessiondClient.java

   1 /*
   2  * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This library is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License, version 2.1 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This library is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this library; if not, write to the Free Software Foundation,
  15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  16  */
  17
  18 package org.lttng.ust.agent;
  19
  20 import java.io.BufferedReader;
  21 import java.io.DataInputStream;
  22 import java.io.DataOutputStream;
  23 import java.io.FileNotFoundException;
  24 import java.io.FileReader;
  25 import java.io.IOException;
  26 import java.lang.management.ManagementFactory;
  27 import java.net.Socket;
  28 import java.net.UnknownHostException;
  29 import java.nio.ByteBuffer;
  30 import java.nio.ByteOrder;
  31 import java.util.concurrent.Semaphore;
  32
  33 class LTTngTCPSessiondClient implements Runnable {
  34
  35         /* Command header from the session deamon. */
  36         private LTTngSessiondCmd2_6.sessiond_hdr headerCmd =
  37                 new LTTngSessiondCmd2_6.sessiond_hdr();
  38
  39         private Socket sessiondSock;
  40         private volatile boolean quit = false;
  41
  42         private DataInputStream inFromSessiond;
  43         private DataOutputStream outToSessiond;
  44
  45         private LogFramework log;
  46
  47         private Semaphore registerSem;
  48
  49         private static final String sessiondHost = "127.0.0.1";
  50         private static final String rootPortFile = "/var/run/lttng/agent.port";
  51         private static final String userPortFile = "/.lttng/agent.port";
  52
  53         private static Integer protocolMajorVersion = 1;
  54         private static Integer protocolMinorVersion = 0;
  55
  56         private LTTngAgent.Domain agentDomain;
  57
  58         /* Indicate if we've already release the semaphore. */
  59         private boolean sem_posted = false;
  60
  61         public LTTngTCPSessiondClient(LTTngAgent.Domain domain, LogFramework log, Semaphore sem) {
  62                 this.agentDomain = domain;
  63                 this.log = log;
  64                 this.registerSem = sem;
  65         }
  66
  67         /*
  68          * Try to release the registerSem if it's not already done.
  69          */
  70         private void tryReleaseSem()
  71         {
  72                 /* Release semaphore so we unblock the agent. */
  73                 if (!this.sem_posted) {
  74                         this.registerSem.release();
  75                         this.sem_posted = true;
  76                 }
  77         }
  78
  79         @Override
  80         public void run() {
  81                 for (;;) {
  82                         if (this.quit) {
  83                                 break;
  84                         }
  85
  86                         /* Cleanup Agent state before trying to connect or reconnect. */
  87                         this.log.reset();
  88
  89                         try {
  90
  91                                 /*
  92                                  * Connect to the session daemon before anything else.
  93                                  */
  94                                 connectToSessiond();
  95
  96                                 /*
  97                                  * Register to the session daemon as the Java component of the
  98                                  * UST application.
  99                                  */
 100                                 registerToSessiond();
 101
 102                                 /*
 103                                  * Block on socket receive and wait for command from the
 104                                  * session daemon. This will return if and only if there is a
 105                                  * fatal error or the socket closes.
 106                                  */
 107                                 handleSessiondCmd();
 108                         } catch (UnknownHostException uhe) {
 109                                 tryReleaseSem();
 110                                 System.out.println(uhe);
 111                         } catch (IOException ioe) {
 112                                 tryReleaseSem();
 113                                 try {
 114                                         Thread.sleep(3000);
 115                                 } catch (InterruptedException e) {
 116                                         e.printStackTrace();
 117                                 }
 118                         } catch (Exception e) {
 119                                 tryReleaseSem();
 120                                 e.printStackTrace();
 121                         }
 122                 }
 123         }
 124
 125         public void destroy() {
 126                 this.quit = true;
 127
 128                 try {
 129                         if (this.sessiondSock != null) {
 130                                 this.sessiondSock.close();
 131                         }
 132                 } catch (Exception e) {
 133                         e.printStackTrace();
 134                 }
 135         }
 136
 137         /*
 138          * Receive header data from the session daemon using the LTTng command
 139          * static buffer of the right size.
 140          */
 141         private void recvHeader() throws Exception {
 142                 int read_len;
 143                 byte data[] = new byte[LTTngSessiondCmd2_6.sessiond_hdr.SIZE];
 144
 145                 read_len = this.inFromSessiond.read(data, 0, data.length);
 146                 if (read_len != data.length) {
 147                         throw new IOException();
 148                 }
 149                 this.headerCmd.populate(data);
 150         }
 151
 152         /*
 153          * Receive payload from the session daemon. This MUST be done after a
 154          * recvHeader() so the header value of a command are known.
 155          *
 156          * The caller SHOULD use isPayload() before which returns true if a payload
 157          * is expected after the header.
 158          */
 159         private byte[] recvPayload() throws Exception {
 160                 byte payload[] = new byte[(int) this.headerCmd.data_size];
 161
 162                 /* Failsafe check so we don't waste our time reading 0 bytes. */
 163                 if (payload.length == 0) {
 164                         return null;
 165                 }
 166
 167                 this.inFromSessiond.read(payload, 0, payload.length);
 168                 return payload;
 169         }
 170
 171         /*
 172          * Handle session command from the session daemon.
 173          */
 174         private void handleSessiondCmd() throws Exception {
 175                 byte data[] = null;
 176
 177                 while (true) {
 178                         /* Get header from session daemon. */
 179                         recvHeader();
 180
 181                         if (headerCmd.data_size > 0) {
 182                                 data = recvPayload();
 183                         }
 184
 185                         switch (headerCmd.cmd) {
 186                                 case CMD_REG_DONE:
 187                                 {
 188                                         /*
 189                                          * Release semaphore so meaning registration is done and we
 190                                          * can proceed to continue tracing.
 191                                          */
 192                                         tryReleaseSem();
 193                                         /*
 194                                          * We don't send any reply to the registration done command.
 195                                          * This just marks the end of the initial session setup.
 196                                          */
 197                                         continue;
 198                                 }
 199                                 case CMD_LIST:
 200                                 {
 201                                         LTTngSessiondCmd2_6.sessiond_list_logger listLoggerCmd =
 202                                                 new LTTngSessiondCmd2_6.sessiond_list_logger();
 203                                         listLoggerCmd.execute(this.log);
 204                                         data = listLoggerCmd.getBytes();
 205                                         break;
 206                                 }
 207                                 case CMD_ENABLE:
 208                                 {
 209                                         LTTngSessiondCmd2_6.sessiond_enable_handler enableCmd =
 210                                                 new LTTngSessiondCmd2_6.sessiond_enable_handler();
 211                                         if (data == null) {
 212                                                 enableCmd.code = LTTngSessiondCmd2_6.lttng_agent_ret_code.CODE_INVALID_CMD;
 213                                                 break;
 214                                         }
 215                                         enableCmd.populate(data);
 216                                         enableCmd.execute(this.log);
 217                                         data = enableCmd.getBytes();
 218                                         break;
 219                                 }
 220                                 case CMD_DISABLE:
 221                                 {
 222                                         LTTngSessiondCmd2_6.sessiond_disable_handler disableCmd =
 223                                                 new LTTngSessiondCmd2_6.sessiond_disable_handler();
 224                                         if (data == null) {
 225                                                 disableCmd.code = LTTngSessiondCmd2_6.lttng_agent_ret_code.CODE_INVALID_CMD;
 226                                                 break;
 227                                         }
 228                                         disableCmd.populate(data);
 229                                         disableCmd.execute(this.log);
 230                                         data = disableCmd.getBytes();
 231                                         break;
 232                                 }
 233                                 default:
 234                                 {
 235                                         data = new byte[4];
 236                                         ByteBuffer buf = ByteBuffer.wrap(data);
 237                                         buf.order(ByteOrder.BIG_ENDIAN);
 238                                         break;
 239                                 }
 240                         }
 241
 242                         /* Send payload to session daemon. */
 243                         this.outToSessiond.write(data, 0, data.length);
 244                         this.outToSessiond.flush();
 245                 }
 246         }
 247
 248         private static String getHomePath() {
 249                 return System.getProperty("user.home");
 250         }
 251
 252         /**
 253          * Read port number from file created by the session daemon.
 254          *
 255          * @return port value if found else 0.
 256          */
 257         private static int getPortFromFile(String path) throws IOException {
 258                 int port;
 259                 BufferedReader br;
 260
 261                 try {
 262                         br = new BufferedReader(new FileReader(path));
 263                         String line = br.readLine();
 264                         port = Integer.parseInt(line, 10);
 265                         if (port < 0 || port > 65535) {
 266                                 /* Invalid value. Ignore. */
 267                                 port = 0;
 268                         }
 269                         br.close();
 270                 } catch (FileNotFoundException e) {
 271                         /* No port available. */
 272                         port = 0;
 273                 }
 274
 275                 return port;
 276         }
 277
 278         private void connectToSessiond() throws Exception {
 279                 int port;
 280
 281                 if (this.log.isRoot()) {
 282                         port = getPortFromFile(rootPortFile);
 283                         if (port == 0) {
 284                                 /* No session daemon available. Stop and retry later. */
 285                                 throw new IOException();
 286                         }
 287                 } else {
 288                         port = getPortFromFile(getHomePath() + userPortFile);
 289                         if (port == 0) {
 290                                 /* No session daemon available. Stop and retry later. */
 291                                 throw new IOException();
 292                         }
 293                 }
 294
 295                 this.sessiondSock = new Socket(sessiondHost, port);
 296                 this.inFromSessiond = new DataInputStream(
 297                                 sessiondSock.getInputStream());
 298                 this.outToSessiond = new DataOutputStream(
 299                                 sessiondSock.getOutputStream());
 300         }
 301
 302         private void registerToSessiond() throws Exception {
 303                 byte data[] = new byte[16];
 304                 ByteBuffer buf = ByteBuffer.wrap(data);
 305                 String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
 306
 307                 buf.putInt(this.agentDomain.value());
 308                 buf.putInt(Integer.parseInt(pid));
 309                 buf.putInt(protocolMajorVersion);
 310                 buf.putInt(protocolMinorVersion);
 311                 this.outToSessiond.write(data, 0, data.length);
 312                 this.outToSessiond.flush();
 313         }
 314 }