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
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.hosted.controller.dns;
import com.yahoo.vespa.hosted.controller.api.integration.dns.NameService;
import com.yahoo.yolean.Exceptions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.function.UnaryOperator;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* A queue of outstanding {@link NameServiceRequest}s. Requests in this have not yet been dispatched to a
* {@link NameService} and are thus not visible in DNS.
*
* This is immutable.
*
* @author mpolden
*/
public class NameServiceQueue {
public static final NameServiceQueue EMPTY = new NameServiceQueue(List.of());
private static final Logger log = Logger.getLogger(NameServiceQueue.class.getName());
private final LinkedBlockingDeque<NameServiceRequest> requests;
/** DO NOT USE. Public for serialization purposes */
public NameServiceQueue(Collection<NameServiceRequest> requests) {
this.requests = new LinkedBlockingDeque<>();
this.requests.addAll(Objects.requireNonNull(requests, "requests must be non-null"));
}
/** Returns a view of requests in this queue */
public Collection<NameServiceRequest> requests() {
return Collections.unmodifiableCollection(requests);
}
/** Returns a copy of this containing the last n requests */
public NameServiceQueue last(int n) {
return resize(n, (requests) -> requests.subList(requests.size() - n, requests.size()));
}
/** Returns a copy of this containing the first n requests */
public NameServiceQueue first(int n) {
return resize(n, (requests) -> requests.subList(0, n));
}
/** Returns a copy of this with given request queued according to priority */
public NameServiceQueue with(NameServiceRequest request, Priority priority) {
var queue = new NameServiceQueue(this.requests);
if (priority == Priority.high) {
queue.requests.addFirst(request);
} else {
queue.requests.add(request);
}
return queue;
}
/** Returns a copy of this with given request added */
public NameServiceQueue with(NameServiceRequest request) {
return with(request, Priority.normal);
}
/**
* Dispatch n requests from the head of this to given name service.
*
* @return A copy of this, without the successfully dispatched requests.
*/
public NameServiceQueue dispatchTo(NameService nameService, int n) {
requireNonNegative(n);
if (requests.isEmpty()) return this;
var queue = new NameServiceQueue(requests);
for (int i = 0; i < n && !queue.requests.isEmpty(); i++) {
var request = queue.requests.peek();
try {
request.dispatchTo(nameService);
queue.requests.poll();
} catch (Exception e) {
log.log(Level.WARNING, "Failed to execute " + request + ": " + Exceptions.toMessageString(e) +
", request will be retried");
}
}
return queue;
}
@Override
public String toString() {
return requests.toString();
}
private NameServiceQueue resize(int n, UnaryOperator<List<NameServiceRequest>> resizer) {
requireNonNegative(n);
if (requests.size() <= n) return this;
List<NameServiceRequest> requests = new ArrayList<>(this.requests);
return new NameServiceQueue(resizer.apply(requests));
}
private static void requireNonNegative(int n) {
if (n < 0) throw new IllegalArgumentException("n must be >= 0, got " + n);
}
/** Priority of a request added to this */
public enum Priority {
/** Default priority. Request will be delivered in FIFO order */
normal,
/** Request is queued first. Useful for code that needs to act on effects of a request */
high
}
}
|
