2 * Copyright (C) 2015, EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
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.
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.
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.
19 package org
.lttng
.ust
.agent
.integration
.client
;
21 import static org
.junit
.Assert
.assertEquals
;
22 import static org
.junit
.Assert
.assertTrue
;
23 import static org
.junit
.Assume
.assumeTrue
;
25 import java
.util
.ArrayList
;
26 import java
.util
.Arrays
;
27 import java
.util
.Collections
;
28 import java
.util
.List
;
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
;
48 * Tests for the TCP client only, without using an agent.
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.
54 * @author Alexandre Montplaisir
56 @RunWith(TestPrintRunner
.class)
57 public class TcpClientIT
{
59 // ------------------------------------------------------------------------
61 // ------------------------------------------------------------------------
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";
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;
72 private static TcpClientDebugListener clientListener
;
73 private static LttngTcpSessiondClient client
;
74 private static Thread clientThread
;
76 private ILttngSession session
;
78 // ------------------------------------------------------------------------
80 // ------------------------------------------------------------------------
86 public static void setupClass() {
87 LttngToolsHelper
.destroyAllSessions();
89 clientListener
= new TcpClientDebugListener();
90 client
= new LttngTcpSessiondClient(clientListener
, DOMAIN_VALUE
, ROOT_SESSIOND
);
92 clientThread
= new Thread(client
);
95 assumeTrue("Timed out waiting for root sessiond", client
.waitForConnection(5));
102 public static void teardownClass() {
103 if (client
!= null) {
106 if (clientThread
!= null) {
109 } catch (InterruptedException e
) {
118 public void setup() {
119 session
= ILttngSession
.createSession(null, SESSION_DOMAIN
);
120 clientListener
.clearAllCommands();
127 public void teardown() {
132 private static ILogLevelStrings
getLogLevelStrings() {
133 return ILogLevelStrings
.JUL_LOGLEVEL_STRINGS
;
137 * Check that two lists contain the exact same element (including
138 * duplicates), but their order does not matter.
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
));
149 // ------------------------------------------------------------------------
151 // ------------------------------------------------------------------------
154 * Test enabling one event.
157 public void testEnableEvent() {
158 session
.enableEvent(EVENT_NAME_A
, null, false, null);
160 List
<EventRule
> expectedCommands
= Collections
.singletonList(
161 EventRuleFactory
.createRule(EVENT_NAME_A
));
163 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
164 assertEquals(expectedCommands
, actualCommands
);
168 * Test an "enable-event -a" command.
171 public void testEnableAllEvents() {
172 session
.enableAllEvents();
174 List
<EventRule
> expectedCommands
= Collections
.singletonList(
175 EventRuleFactory
.createRuleAllEvents());
176 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
178 assertEquals(expectedCommands
, actualCommands
);
182 * Test enabling then disabling one event.
185 public void testEnableThenDisableOneEvent() {
186 session
.enableEvent(EVENT_NAME_A
, null, false, null);
187 session
.disableEvents(EVENT_NAME_A
);
189 List
<EventRule
> expectedEnableCommands
= Collections
.singletonList(
190 EventRuleFactory
.createRule(EVENT_NAME_A
));
191 List
<String
> expectedDisableCommands
= Collections
.singletonList(EVENT_NAME_A
);
193 assertEquals(expectedEnableCommands
, clientListener
.getEnabledEventCommands());
194 assertTrue(containSameElements(expectedDisableCommands
, clientListener
.getDisabledEventCommands()));
198 * Test enabling some events manually, then disabling all events (-a).
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();
207 List
<EventRule
> expectedEnableCommands
= Arrays
.asList(
208 EventRuleFactory
.createRule(EVENT_NAME_A
),
209 EventRuleFactory
.createRule(EVENT_NAME_B
),
210 EventRuleFactory
.createRule(EVENT_NAME_C
));
212 * A "disable-event -a" will send one command for each enabled event.
213 * The order may be different though.
215 List
<String
> expectedDisableCommands
= Arrays
.asList(
216 EVENT_NAME_A
, EVENT_NAME_B
, EVENT_NAME_C
);
218 assertEquals(expectedEnableCommands
, clientListener
.getEnabledEventCommands());
219 assertTrue(containSameElements(expectedDisableCommands
, clientListener
.getDisabledEventCommands()));
223 * Test enabling then (enable-event -a) then disabling all (disable-event -a) events.
226 public void testEnableAllThenDisableAll() {
227 session
.enableAllEvents();
228 session
.disableAllEvents();
230 List
<EventRule
> expectedEnableCommands
= Arrays
.asList(EventRuleFactory
.createRuleAllEvents());
231 List
<String
> expectedDisableCommands
= Arrays
.asList(EventRuleFactory
.EVENT_NAME_ALL
);
233 assertEquals(expectedEnableCommands
, clientListener
.getEnabledEventCommands());
234 assertTrue(containSameElements(expectedDisableCommands
, clientListener
.getDisabledEventCommands()));
238 * Test enabling then destroying the session (should send corresponding
239 * disable event messages).
241 @SuppressWarnings("static-method")
243 public void testEnableEventThenDestroy() {
244 try (ILttngSession session2
= ILttngSession
.createSession(null, SESSION_DOMAIN
);) {
245 session2
.enableEvent(EVENT_NAME_A
, null, false, null);
246 session2
.enableEvent(EVENT_NAME_B
, null, false, null);
247 } // close(), aka destroy the session, sending "disable event" messages
249 List
<EventRule
> expectedEnabledCommands
= Arrays
.asList(EventRuleFactory
.createRule(EVENT_NAME_A
), EventRuleFactory
.createRule(EVENT_NAME_B
));
250 List
<String
> expectedDisabledCommands
= Arrays
.asList(EVENT_NAME_A
, EVENT_NAME_B
);
252 assertEquals(expectedEnabledCommands
, clientListener
.getEnabledEventCommands());
253 assertEquals(expectedDisabledCommands
, clientListener
.getDisabledEventCommands());
257 * Test specifying an event with a --loglevel option.
260 public void testEnableEventLogLevelRange() {
261 LogLevelSelector lls
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
263 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
265 List
<EventRule
> expectedCommands
= Collections
.singletonList(
266 EventRuleFactory
.createRule(EVENT_NAME_A
, lls
));
267 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
269 assertEquals(expectedCommands
, actualCommands
);
273 * Test enabling an event with a --loglevel-only option.
276 public void testEnableEventLogLevelSingle() {
277 LogLevelSelector lls
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_SINGLE
);
279 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
281 List
<EventRule
> expectedCommands
= Collections
.singletonList(
282 EventRuleFactory
.createRule(EVENT_NAME_A
, lls
));
283 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
285 assertEquals(expectedCommands
, actualCommands
);
289 * Test enabling an event twice, for the same loglevel, with --loglevel followed by --loglevel-only.
292 public void testEnableEventsLogLevelRangeAndSingle() {
293 LogLevelSelector lls1
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
294 LogLevelSelector lls2
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_SINGLE
);
296 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
297 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
299 List
<EventRule
> expectedCommands
= Arrays
.asList(
300 EventRuleFactory
.createRule(EVENT_NAME_A
, lls1
),
301 EventRuleFactory
.createRule(EVENT_NAME_A
, lls2
)
303 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
305 assertEquals(expectedCommands
, actualCommands
);
309 * Test enabling an event twice, for the same loglevel, with --loglevel-only followed by --loglevel.
312 public void testEnableEventsLogLevelSingleAndRange() {
313 LogLevelSelector lls1
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_SINGLE
);
314 LogLevelSelector lls2
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
316 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
317 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
319 List
<EventRule
> expectedCommands
= Arrays
.asList(
320 EventRuleFactory
.createRule(EVENT_NAME_A
, lls1
),
321 EventRuleFactory
.createRule(EVENT_NAME_A
, lls2
)
323 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
325 assertEquals(expectedCommands
, actualCommands
);
329 * Test enabling the same event, same loglevel, but different loglevel types
330 * (--loglevel vs --loglevel-only) in two separate sessions.
333 public void testEnableEventsLogLevelRangeAndSingleDiffSessions() {
334 try (ILttngSession session2
= ILttngSession
.createSession(null, SESSION_DOMAIN
);) {
336 LogLevelSelector lls1
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
337 LogLevelSelector lls2
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_SINGLE
);
339 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
340 session2
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
342 List
<EventRule
> expectedCommands
= Arrays
.asList(
343 EventRuleFactory
.createRule(EVENT_NAME_A
, lls1
),
344 EventRuleFactory
.createRule(EVENT_NAME_A
, lls2
));
345 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
347 assertEquals(expectedCommands
, actualCommands
);
352 * Enable the same event multiple times with different filter strings.
355 public void testEnableEventsDiffFilters() {
356 final String filter1
= "filter1";
357 final String filter2
= "filter2";
359 session
.enableEvent(EVENT_NAME_A
, null, false, null);
360 session
.enableEvent(EVENT_NAME_A
, null, false, filter1
);
361 session
.enableEvent(EVENT_NAME_A
, null, false, filter2
);
363 List
<EventRule
> expectedCommands
= Arrays
.asList(
364 EventRuleFactory
.createRule(EVENT_NAME_A
),
365 EventRuleFactory
.createRule(EVENT_NAME_A
, EventRuleFactory
.LOG_LEVEL_UNSPECIFIED
, filter1
),
366 EventRuleFactory
.createRule(EVENT_NAME_A
, EventRuleFactory
.LOG_LEVEL_UNSPECIFIED
, filter2
));
367 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
369 assertEquals(expectedCommands
, actualCommands
);
373 * Enable the same event multiple times with different log levels and
377 public void testEnableEventsLogLevelAndFilters() {
378 final LogLevelSelector lls
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
379 final String filter
= "filter1";
381 session
.enableEvent(EVENT_NAME_A
, null, false, null);
382 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
383 session
.enableEvent(EVENT_NAME_A
, null, false, filter
);
384 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, filter
);
386 List
<EventRule
> expectedCommands
= Arrays
.asList(
387 EventRuleFactory
.createRule(EVENT_NAME_A
),
388 EventRuleFactory
.createRule(EVENT_NAME_A
, lls
),
389 EventRuleFactory
.createRule(EVENT_NAME_A
, EventRuleFactory
.LOG_LEVEL_UNSPECIFIED
, filter
),
390 EventRuleFactory
.createRule(EVENT_NAME_A
, lls
, filter
));
391 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
393 assertEquals(expectedCommands
, actualCommands
);