1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// Copyright 2019 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.hosted.node.admin.nodeagent;
import org.junit.Test;
import java.time.Clock;
import java.time.Duration;
import java.util.Optional;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* @author freva
*/
public class NodeAgentContextManagerTest {
private static final int TIMEOUT = 10_000;
private final Clock clock = Clock.systemUTC();
private final NodeAgentContext initialContext = generateContext();
private final NodeAgentContextManager manager = new NodeAgentContextManager(clock, initialContext);
@Test(timeout = TIMEOUT)
public void returns_immediately_if_next_context_is_ready() throws InterruptedException {
NodeAgentContext context1 = generateContext();
manager.scheduleTickWith(context1);
assertSame(initialContext, manager.currentContext());
assertSame(context1, manager.nextContext());
assertSame(context1, manager.currentContext());
}
@Test(timeout = TIMEOUT)
public void blocks_in_nextContext_until_one_is_scheduled() throws InterruptedException {
AsyncExecutor<NodeAgentContext> async = new AsyncExecutor<>(manager::nextContext);
assertFalse(async.response.isPresent());
Thread.sleep(10);
assertFalse(async.response.isPresent());
NodeAgentContext context1 = generateContext();
manager.scheduleTickWith(context1);
async.awaitResult();
assertEquals(Optional.of(context1), async.response);
assertFalse(async.exception.isPresent());
}
@Test(timeout = TIMEOUT)
public void blocks_in_nextContext_until_interrupt() throws InterruptedException {
AsyncExecutor<NodeAgentContext> async = new AsyncExecutor<>(manager::nextContext);
assertFalse(async.response.isPresent());
Thread.sleep(10);
assertFalse(async.response.isPresent());
manager.interrupt();
async.awaitResult();
assertEquals(Optional.of(InterruptedException.class), async.exception.map(Exception::getClass));
assertFalse(async.response.isPresent());
}
@Test(timeout = TIMEOUT)
public void setFrozen_does_not_block_with_no_timeout() throws InterruptedException {
assertFalse(manager.setFrozen(false, Duration.ZERO));
// Generate new context and get it from the supplier, this completes the unfreeze
NodeAgentContext context1 = generateContext();
manager.scheduleTickWith(context1);
assertSame(context1, manager.nextContext());
assertTrue(manager.setFrozen(false, Duration.ZERO));
}
@Test(timeout = TIMEOUT)
public void setFrozen_blocks_at_least_for_duration_of_timeout() {
long wantedDurationMillis = 100;
long start = clock.millis();
assertFalse(manager.setFrozen(false, Duration.ofMillis(wantedDurationMillis)));
long actualDurationMillis = clock.millis() - start;
assertTrue(actualDurationMillis >= wantedDurationMillis);
}
@Test(timeout = TIMEOUT)
public void setFrozen_is_successful_if_converged_in_time() throws InterruptedException {
AsyncExecutor<Boolean> async = new AsyncExecutor<>(() -> manager.setFrozen(false, Duration.ofMillis(500)));
assertFalse(async.response.isPresent());
NodeAgentContext context1 = generateContext();
manager.scheduleTickWith(context1);
assertSame(context1, manager.nextContext());
async.awaitResult();
assertEquals(Optional.of(true), async.response);
assertFalse(async.exception.isPresent());
}
private static NodeAgentContext generateContext() {
return new NodeAgentContextImpl.Builder("container-123.domain.tld").build();
}
private class AsyncExecutor<T> {
private final Object monitor = new Object();
private final Thread thread;
private volatile Optional<T> response = Optional.empty();
private volatile Optional<Exception> exception = Optional.empty();
private boolean completed = false;
private AsyncExecutor(ThrowingSupplier<T> supplier) {
this.thread = new Thread(() -> {
try {
response = Optional.of(supplier.get());
} catch (Exception e) {
exception = Optional.of(e);
}
synchronized (monitor) {
completed = true;
monitor.notifyAll();
}
});
this.thread.start();
}
private void awaitResult() {
synchronized (monitor) {
while (!completed) {
try {
monitor.wait();
} catch (InterruptedException ignored) { }
}
}
}
}
private interface ThrowingSupplier<T> {
T get() throws Exception;
}
}
|
