lttng-ust-java-tests-common/src/test/java/org/lttng/ust/agent/integration/client/TcpClientIT.java

   1 /*
   2  * Copyright (C) 2015, EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 package org.lttng.ust.agent.integration.client;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertTrue;
  23 import static org.junit.Assume.assumeTrue;
  24
  25 import java.util.ArrayList;
  26 import java.util.Arrays;
  27 import java.util.Collections;
  28 import java.util.List;
  29
  30 import org.junit.After;
  31 import org.junit.AfterClass;
  32 import org.junit.Before;
  33 import org.junit.BeforeClass;
  34 import org.junit.Test;
  35 import org.junit.runner.RunWith;
  36 import org.lttng.tools.ILttngSession;
  37 import org.lttng.tools.LttngToolsHelper;
  38 import org.lttng.ust.agent.ILttngAgent;
  39 import org.lttng.ust.agent.client.LttngTcpSessiondClient;
  40 import org.lttng.ust.agent.session.EventRule;
  41 import org.lttng.ust.agent.session.LogLevelSelector;
  42 import org.lttng.ust.agent.session.LogLevelSelector.LogLevelType;
  43 import org.lttng.ust.agent.utils.EventRuleFactory;
  44 import org.lttng.ust.agent.utils.ILogLevelStrings;
  45 import org.lttng.ust.agent.utils.TestPrintRunner;
  46
  47 /**
  48  * Tests for the TCP client only, without using an agent.
  49  *
  50  * This test suite requires that a *root* session daemon is running on the
  51  * system. Since we have to explicitly tell the TCP client which sessiond to
  52  * connect to, we have to hard-code it in here.
  53  *
  54  * @author Alexandre Montplaisir
  55  */
  56 @RunWith(TestPrintRunner.class)
  57 public class TcpClientIT {
  58
  59     // ------------------------------------------------------------------------
  60     // Attributes
  61     // ------------------------------------------------------------------------
  62
  63     private static final String EVENT_NAME_A = "eventA";
  64     private static final String EVENT_NAME_B = "eventB";
  65     private static final String EVENT_NAME_C = "eventC";
  66
  67     /* Test configuration */
  68     private static final int DOMAIN_VALUE = ILttngAgent.Domain.JUL.value();
  69     private static final ILttngSession.Domain SESSION_DOMAIN = ILttngSession.Domain.JUL;
  70     private static final boolean ROOT_SESSIOND = true;
  71
  72     private static TcpClientDebugListener clientListener;
  73     private static LttngTcpSessiondClient client;
  74     private static Thread clientThread;
  75
  76     private ILttngSession session;
  77
  78     // ------------------------------------------------------------------------
  79     // Maintenance
  80     // ------------------------------------------------------------------------
  81
  82     /**
  83      * Class setup
  84      */
  85     @BeforeClass
  86     public static void setupClass() {
  87         LttngToolsHelper.destroyAllSessions();
  88
  89         clientListener = new TcpClientDebugListener();
  90         client = new LttngTcpSessiondClient(clientListener, DOMAIN_VALUE, ROOT_SESSIOND);
  91
  92         clientThread = new Thread(client);
  93         clientThread.start();
  94
  95         assumeTrue("Timed out waiting for root sessiond", client.waitForConnection(5));
  96     }
  97
  98     /**
  99      * Class teardown
 100      */
 101     @AfterClass
 102     public static void teardownClass() {
 103         if (client != null) {
 104             client.close();
 105         }
 106         if (clientThread != null) {
 107             try {
 108                 clientThread.join();
 109             } catch (InterruptedException e) {
 110             }
 111         }
 112     }
 113
 114     /**
 115      * Test setup
 116      */
 117     @Before
 118     public void setup() {
 119         session = ILttngSession.createSession(null, SESSION_DOMAIN);
 120         clientListener.clearAllCommands();
 121     }
 122
 123     /**
 124      * Test teardown
 125      */
 126     @After
 127     public void teardown() {
 128         session.close();
 129     }
 130
 131
 132     private static ILogLevelStrings getLogLevelStrings() {
 133         return ILogLevelStrings.JUL_LOGLEVEL_STRINGS;
 134     }
 135
 136     /**
 137      * Check that two lists contain the exact same element (including
 138      * duplicates), but their order does not matter.
 139      */
 140     private static <T extends Comparable<T>> boolean containSameElements(List<T> list1, List<T> list2) {
 141         List<T> newlist1 = new ArrayList<>(list1);
 142         List<T> newlist2 = new ArrayList<>(list2);
 143         Collections.sort(newlist1);
 144         Collections.sort(newlist2);
 145         return (newlist1.equals(newlist2));
 146
 147     }
 148
 149     // ------------------------------------------------------------------------
 150     // Test cases
 151     // ------------------------------------------------------------------------
 152
 153     /**
 154      * Test enabling one event.
 155      */
 156     @Test
 157     public void testEnableEvent() {
 158         session.enableEvent(EVENT_NAME_A, null, false, null);
 159
 160         List<EventRule> expectedCommands = Collections.singletonList(
 161                 EventRuleFactory.createRule(EVENT_NAME_A));
 162
 163         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 164         assertEquals(expectedCommands, actualCommands);
 165     }
 166
 167     /**
 168      * Test an "enable-event -a" command.
 169      */
 170     @Test
 171     public void testEnableAllEvents() {
 172         session.enableAllEvents();
 173
 174         List<EventRule> expectedCommands = Collections.singletonList(
 175                 EventRuleFactory.createRuleAllEvents());
 176         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 177
 178         assertEquals(expectedCommands, actualCommands);
 179     }
 180
 181     /**
 182      * Test enabling then disabling one event.
 183      */
 184     @Test
 185     public void testEnableThenDisableOneEvent() {
 186         session.enableEvent(EVENT_NAME_A, null, false, null);
 187         session.disableEvents(EVENT_NAME_A);
 188
 189         List<EventRule> expectedEnableCommands = Collections.singletonList(
 190                 EventRuleFactory.createRule(EVENT_NAME_A));
 191         List<String> expectedDisableCommands = Collections.singletonList(EVENT_NAME_A);
 192
 193         assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
 194         assertTrue(containSameElements(expectedDisableCommands, clientListener.getDisabledEventCommands()));
 195     }
 196
 197     /**
 198      * Test enabling some events manually, then disabling all events (-a).
 199      */
 200     @Test
 201     public void testEnableSomeThenDisableAll() {
 202         session.enableEvent(EVENT_NAME_A, null, false, null);
 203         session.enableEvent(EVENT_NAME_B, null, false, null);
 204         session.enableEvent(EVENT_NAME_C, null, false, null);
 205         session.disableAllEvents();
 206
 207         List<EventRule> expectedEnableCommands = Arrays.asList(
 208                 EventRuleFactory.createRule(EVENT_NAME_A),
 209                 EventRuleFactory.createRule(EVENT_NAME_B),
 210                 EventRuleFactory.createRule(EVENT_NAME_C));
 211         /*
 212          * A "disable-event -a" will send one command for each enabled event.
 213          * The order may be different though.
 214          */
 215         List<String> expectedDisableCommands = Arrays.asList(
 216                 EVENT_NAME_A, EVENT_NAME_B, EVENT_NAME_C);
 217
 218         assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
 219         assertTrue(containSameElements(expectedDisableCommands, clientListener.getDisabledEventCommands()));
 220     }
 221
 222     /**
 223      * Test enabling then (enable-event -a) then disabling all (disable-event -a) events.
 224      */
 225     @Test
 226     public void testEnableAllThenDisableAll() {
 227         session.enableAllEvents();
 228         session.disableAllEvents();
 229
 230         List<EventRule> expectedEnableCommands = Arrays.asList(EventRuleFactory.createRuleAllEvents());
 231         List<String> expectedDisableCommands = Arrays.asList(EventRuleFactory.EVENT_NAME_ALL);
 232
 233         assertEquals(expectedEnableCommands, clientListener.getEnabledEventCommands());
 234         assertTrue(containSameElements(expectedDisableCommands, clientListener.getDisabledEventCommands()));
 235     }
 236
 237     /**
 238      * Test specifying an event with a --loglevel option.
 239      */
 240     @Test
 241     public void testEnableEventLogLevelRange() {
 242         LogLevelSelector lls = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_RANGE);
 243
 244         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
 245
 246         List<EventRule> expectedCommands = Collections.singletonList(
 247                 EventRuleFactory.createRule(EVENT_NAME_A, lls));
 248         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 249
 250         assertEquals(expectedCommands, actualCommands);
 251     }
 252
 253     /**
 254      * Test enabling an event with a --loglevel-only option.
 255      */
 256     @Test
 257     public void testEnableEventLogLevelSingle() {
 258         LogLevelSelector lls = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_SINGLE);
 259
 260         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
 261
 262         List<EventRule> expectedCommands = Collections.singletonList(
 263                 EventRuleFactory.createRule(EVENT_NAME_A, lls));
 264         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 265
 266         assertEquals(expectedCommands, actualCommands);
 267     }
 268
 269     /**
 270      * Test enabling an event twice, for the same loglevel, with --loglevel followed by --loglevel-only.
 271      */
 272     @Test
 273     public void testEnableEventsLogLevelRangeAndSingle() {
 274         LogLevelSelector lls1 = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_RANGE);
 275         LogLevelSelector lls2 = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_SINGLE);
 276
 277         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
 278         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
 279
 280         List<EventRule> expectedCommands = Arrays.asList(
 281                 EventRuleFactory.createRule(EVENT_NAME_A, lls1),
 282                 EventRuleFactory.createRule(EVENT_NAME_A, lls2)
 283                 );
 284         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 285
 286         assertEquals(expectedCommands, actualCommands);
 287     }
 288
 289     /**
 290      * Test enabling an event twice, for the same loglevel, with --loglevel-only followed by --loglevel.
 291      */
 292     @Test
 293     public void testEnableEventsLogLevelSingleAndRange() {
 294         LogLevelSelector lls1 = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_SINGLE);
 295         LogLevelSelector lls2 = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_RANGE);
 296
 297         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
 298         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
 299
 300         List<EventRule> expectedCommands = Arrays.asList(
 301                 EventRuleFactory.createRule(EVENT_NAME_A, lls1),
 302                 EventRuleFactory.createRule(EVENT_NAME_A, lls2)
 303                 );
 304         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 305
 306         assertEquals(expectedCommands, actualCommands);
 307     }
 308
 309     /**
 310      * Test enabling the same event, same loglevel, but different loglevel types
 311      * (--loglevel vs --loglevel-only) in two separate sessions.
 312      */
 313     @Test
 314     public void testEnableEventsLogLevelRangeAndSingleDiffSessions() {
 315         try (ILttngSession session2 = ILttngSession.createSession(null, SESSION_DOMAIN);) {
 316
 317             LogLevelSelector lls1 = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_RANGE);
 318             LogLevelSelector lls2 = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_SINGLE);
 319
 320             session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
 321             session2.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), true, null);
 322
 323             List<EventRule> expectedCommands = Arrays.asList(
 324                     EventRuleFactory.createRule(EVENT_NAME_A, lls1),
 325                     EventRuleFactory.createRule(EVENT_NAME_A, lls2));
 326             List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 327
 328             assertEquals(expectedCommands, actualCommands);
 329         }
 330     }
 331
 332     /**
 333      * Enable the same event multiple times with different filter strings.
 334      */
 335     @Test
 336     public void testEnableEventsDiffFilters() {
 337         final String filter1 = "filter1";
 338         final String filter2 = "filter2";
 339
 340         session.enableEvent(EVENT_NAME_A, null, false, null);
 341         session.enableEvent(EVENT_NAME_A, null, false, filter1);
 342         session.enableEvent(EVENT_NAME_A, null, false, filter2);
 343
 344         List<EventRule> expectedCommands = Arrays.asList(
 345                 EventRuleFactory.createRule(EVENT_NAME_A),
 346                 EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter1),
 347                 EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter2));
 348         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 349
 350         assertEquals(expectedCommands, actualCommands);
 351     }
 352
 353     /**
 354      * Enable the same event multiple times with different log levels and
 355      * filters.
 356      */
 357     @Test
 358     public void testEnableEventsLogLevelAndFilters() {
 359         final LogLevelSelector lls = new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType.LTTNG_EVENT_LOGLEVEL_RANGE);
 360         final String filter = "filter1";
 361
 362         session.enableEvent(EVENT_NAME_A, null, false, null);
 363         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, null);
 364         session.enableEvent(EVENT_NAME_A, null, false, filter);
 365         session.enableEvent(EVENT_NAME_A, getLogLevelStrings().warningName(), false, filter);
 366
 367         List<EventRule> expectedCommands = Arrays.asList(
 368                 EventRuleFactory.createRule(EVENT_NAME_A),
 369                 EventRuleFactory.createRule(EVENT_NAME_A, lls),
 370                 EventRuleFactory.createRule(EVENT_NAME_A, EventRuleFactory.LOG_LEVEL_UNSPECIFIED, filter),
 371                 EventRuleFactory.createRule(EVENT_NAME_A, lls, filter));
 372         List<EventRule> actualCommands = clientListener.getEnabledEventCommands();
 373
 374         assertEquals(expectedCommands, actualCommands);
 375     }
 376 }