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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.config.server.application;
import com.fasterxml.jackson.databind.JsonNode;
import com.google.inject.Inject;
import com.yahoo.component.AbstractComponent;
import com.yahoo.config.model.api.HostInfo;
import com.yahoo.config.model.api.PortInfo;
import com.yahoo.config.model.api.ServiceInfo;
import com.yahoo.slime.Cursor;
import com.yahoo.vespa.config.server.http.JSONResponse;
import org.glassfish.jersey.client.proxy.WebResourceFactory;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.ProcessingException;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import java.io.IOException;
import java.net.URI;
import java.util.*;
/**
* Checks for convergence of config generation for a given application.
*
* @author lulf
* @author hmusum
*/
public class ApplicationConvergenceChecker extends AbstractComponent {
private static final String statePath = "/state/v1/";
private static final String configSubPath = "config";
private final StateApiFactory stateApiFactory;
private final Client client = ClientBuilder.newClient();
private final static Set<String> serviceTypesToCheck = new HashSet<>(Arrays.asList(
"container",
"container-clustercontroller",
"qrserver",
"docprocservice",
"searchnode",
"storagenode",
"distributor"
));
@Inject
public ApplicationConvergenceChecker() {
this(ApplicationConvergenceChecker::createStateApi);
}
public ApplicationConvergenceChecker(StateApiFactory stateApiFactory) {
this.stateApiFactory = stateApiFactory;
}
public ServiceListResponse serviceListToCheckForConfigConvergence(Application application, URI uri) {
List<ServiceInfo> servicesToCheck = new ArrayList<>();
application.getModel().getHosts()
.forEach(host -> host.getServices().stream()
.filter(service -> serviceTypesToCheck.contains(service.getServiceType()))
.forEach(service -> getStatePort(service).ifPresent(port -> servicesToCheck.add(service))));
return new ServiceListResponse(200, servicesToCheck, uri, application.getApplicationGeneration());
}
public ServiceResponse serviceConvergenceCheck(Application application, String hostAndPortToCheck, URI uri) {
Long wantedGeneration = application.getApplicationGeneration();
try {
if (! hostInApplication(application, hostAndPortToCheck))
return ServiceResponse.createHostNotFoundInAppResponse(uri, hostAndPortToCheck, wantedGeneration);
long currentGeneration = getServiceGeneration(URI.create("http://" + hostAndPortToCheck));
boolean converged = currentGeneration >= wantedGeneration;
return ServiceResponse.createOkResponse(uri, hostAndPortToCheck, wantedGeneration, currentGeneration, converged);
} catch (ProcessingException e) { // e.g. if we cannot connect to the service to find generation
return ServiceResponse.createNotFoundResponse(uri, hostAndPortToCheck, wantedGeneration, e.getMessage());
} catch (Exception e) {
return ServiceResponse.createErrorResponse(uri, hostAndPortToCheck, wantedGeneration, e.getMessage());
}
}
@Override
public void deconstruct() {
client.close();
}
@Path(statePath)
public interface StateApi {
@Path(configSubPath)
@GET
JsonNode config();
}
public interface StateApiFactory {
StateApi createStateApi(Client client, URI serviceUri);
}
private static Optional<Integer> getStatePort(ServiceInfo service) {
return service.getPorts().stream()
.filter(port -> port.getTags().contains("state"))
.map(PortInfo::getPort)
.findFirst();
}
private long generationFromContainerState(JsonNode state) {
return state.get("config").get("generation").asLong();
}
private static StateApi createStateApi(Client client, URI uri) {
WebTarget target = client.target(uri);
return WebResourceFactory.newResource(StateApi.class, target);
}
private long getServiceGeneration(URI serviceUri) {
StateApi state = stateApiFactory.createStateApi(client, serviceUri);
return generationFromContainerState(state.config());
}
private boolean hostInApplication(Application application, String hostPort) throws IOException {
for (HostInfo host : application.getModel().getHosts()) {
if (hostPort.startsWith(host.getHostname())) {
for (ServiceInfo service : host.getServices()) {
for (PortInfo port : service.getPorts()) {
if (hostPort.equals(host.getHostname() + ":" + port.getPort())) {
return true;
}
}
}
}
}
return false;
}
static class ServiceListResponse extends JSONResponse {
final Cursor debug;
// Pre-condition: servicesToCheck has a state port
private ServiceListResponse(int status, List<ServiceInfo> servicesToCheck, URI uri, Long wantedGeneration) {
super(status);
Cursor serviceArray = object.setArray("services");
for (ServiceInfo s : servicesToCheck) {
Cursor service = serviceArray.addObject();
String hostName = s.getHostName();
int statePort = getStatePort(s).get();
service.setString("host", hostName);
service.setLong("port", statePort);
service.setString("type", s.getServiceType());
service.setString("url", uri.toString() + "/" + hostName + ":" + statePort);
}
debug = object.setObject("debug");
object.setString("url", uri.toString());
debug.setLong("wantedGeneration", wantedGeneration);
}
}
static class ServiceResponse extends JSONResponse {
final Cursor debug;
private ServiceResponse(int status, URI uri, String hostname, Long wantedGeneration) {
super(status);
debug = object.setObject("debug");
object.setString("url", uri.toString());
debug.setString("host", hostname);
debug.setLong("wantedGeneration", wantedGeneration);
}
static ServiceResponse createOkResponse(URI uri, String hostname, Long wantedGeneration, Long currentGeneration, boolean converged) {
ServiceResponse serviceResponse = new ServiceResponse(200, uri, hostname, wantedGeneration);
serviceResponse.object.setBool("converged", converged);
serviceResponse.debug.setLong("currentGeneration", currentGeneration);
return serviceResponse;
}
static ServiceResponse createHostNotFoundInAppResponse(URI uri, String hostname, Long wantedGeneration) {
ServiceResponse serviceResponse = new ServiceResponse(410, uri, hostname, wantedGeneration);
serviceResponse.debug.setString("problem", "Host:port (service) no longer part of application, refetch list of services.");
return serviceResponse;
}
static ServiceResponse createErrorResponse(URI uri, String hostname, Long wantedGeneration, String error) {
ServiceResponse serviceResponse = new ServiceResponse(500, uri, hostname, wantedGeneration);
serviceResponse.object.setString("error", error);
return serviceResponse;
}
static ServiceResponse createNotFoundResponse(URI uri, String hostname, Long wantedGeneration, String error) {
ServiceResponse serviceResponse = new ServiceResponse(404, uri, hostname, wantedGeneration);
serviceResponse.object.setString("error", error);
return serviceResponse;
}
}
}
|
