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 specifying an event with a --loglevel option.
241 public void testEnableEventLogLevelRange() {
242 LogLevelSelector lls
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
244 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
246 List
<EventRule
> expectedCommands
= Collections
.singletonList(
247 EventRuleFactory
.createRule(EVENT_NAME_A
, lls
));
248 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
250 assertEquals(expectedCommands
, actualCommands
);
254 * Test enabling an event with a --loglevel-only option.
257 public void testEnableEventLogLevelSingle() {
258 LogLevelSelector lls
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_SINGLE
);
260 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
262 List
<EventRule
> expectedCommands
= Collections
.singletonList(
263 EventRuleFactory
.createRule(EVENT_NAME_A
, lls
));
264 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
266 assertEquals(expectedCommands
, actualCommands
);
270 * Test enabling an event twice, for the same loglevel, with --loglevel followed by --loglevel-only.
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
);
277 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
278 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
280 List
<EventRule
> expectedCommands
= Arrays
.asList(
281 EventRuleFactory
.createRule(EVENT_NAME_A
, lls1
),
282 EventRuleFactory
.createRule(EVENT_NAME_A
, lls2
)
284 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
286 assertEquals(expectedCommands
, actualCommands
);
290 * Test enabling an event twice, for the same loglevel, with --loglevel-only followed by --loglevel.
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
);
297 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
298 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
300 List
<EventRule
> expectedCommands
= Arrays
.asList(
301 EventRuleFactory
.createRule(EVENT_NAME_A
, lls1
),
302 EventRuleFactory
.createRule(EVENT_NAME_A
, lls2
)
304 List
<EventRule
> actualCommands
= clientListener
.getEnabledEventCommands();
306 assertEquals(expectedCommands
, actualCommands
);
310 * Test enabling the same event, same loglevel, but different loglevel types
311 * (--loglevel vs --loglevel-only) in two separate sessions.
314 public void testEnableEventsLogLevelRangeAndSingleDiffSessions() {
315 try (ILttngSession session2
= ILttngSession
.createSession(null, SESSION_DOMAIN
);) {
317 LogLevelSelector lls1
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
318 LogLevelSelector lls2
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_SINGLE
);
320 session
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), false, null);
321 session2
.enableEvent(EVENT_NAME_A
, getLogLevelStrings().warningName(), true, null);
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();
328 assertEquals(expectedCommands
, actualCommands
);
333 * Enable the same event multiple times with different filter strings.
336 public void testEnableEventsDiffFilters() {
337 final String filter1
= "filter1";
338 final String filter2
= "filter2";
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
);
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();
350 assertEquals(expectedCommands
, actualCommands
);
354 * Enable the same event multiple times with different log levels and
358 public void testEnableEventsLogLevelAndFilters() {
359 final LogLevelSelector lls
= new LogLevelSelector(getLogLevelStrings().warningInt(), LogLevelType
.LTTNG_EVENT_LOGLEVEL_RANGE
);
360 final String filter
= "filter1";
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
);
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();
374 assertEquals(expectedCommands
, actualCommands
);