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
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.hosted.provision.provisioning;
import ai.vespa.http.DomainName;
import com.yahoo.component.Version;
import com.yahoo.component.annotation.Inject;
import com.yahoo.config.provision.ActivationContext;
import com.yahoo.config.provision.ApplicationId;
import com.yahoo.config.provision.ApplicationTransaction;
import com.yahoo.config.provision.Deployment;
import com.yahoo.config.provision.HostFilter;
import com.yahoo.config.provision.HostSpec;
import com.yahoo.config.provision.InfraDeployer;
import com.yahoo.config.provision.NodeType;
import com.yahoo.config.provision.Provisioner;
import com.yahoo.transaction.NestedTransaction;
import com.yahoo.vespa.hosted.provision.NodeRepository;
import com.yahoo.vespa.hosted.provision.maintenance.InfrastructureVersions;
import com.yahoo.vespa.service.monitor.DuperModelInfraApi;
import com.yahoo.vespa.service.monitor.InfraApplicationApi;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
/**
* @author freva
*/
public class InfraDeployerImpl implements InfraDeployer {
private static final Logger logger = Logger.getLogger(InfraDeployerImpl.class.getName());
private final NodeRepository nodeRepository;
private final Provisioner provisioner;
private final InfrastructureVersions infrastructureVersions;
private final DuperModelInfraApi duperModel;
@Inject
public InfraDeployerImpl(NodeRepository nodeRepository, Provisioner provisioner, DuperModelInfraApi duperModel) {
this.nodeRepository = nodeRepository;
this.provisioner = provisioner;
this.infrastructureVersions = nodeRepository.infrastructureVersions();
this.duperModel = duperModel;
}
@Override
public Optional<Deployment> getDeployment(ApplicationId application) {
return duperModel.getInfraApplication(application).map(InfraDeployment::new);
}
@Override
public void activateAllSupportedInfraApplications(boolean propagateException) {
duperModel.getSupportedInfraApplications().stream()
// nodes cannot be activated before their host, so try to activate the host first
.sorted(Comparator.comparing(n -> !n.getCapacity().type().isHost()))
.forEach(api -> {
var application = api.getApplicationId();
var deployment = new InfraDeployment(api);
try (var lock = nodeRepository.applications().lockMaintenance(application)) {
deployment.activate();
} catch (RuntimeException e) {
logger.log(Level.INFO, "Failed to activate " + application, e);
if (propagateException) {
throw e;
}
// loop around to activate the next application
}
});
duperModel.infraApplicationsIsNowComplete();
}
private class InfraDeployment implements Deployment {
private final InfraApplicationApi application;
private boolean prepared = false;
private List<HostSpec> hostSpecs;
private InfraDeployment(InfraApplicationApi application) {
this.application = application;
}
@Override
public void prepare() {
if (prepared) return;
NodeType nodeType = application.getCapacity().type();
Version targetVersion = infrastructureVersions.getTargetVersionFor(nodeType);
hostSpecs = provisioner.prepare(application.getApplicationId(),
application.getClusterSpecWithVersion(targetVersion),
application.getCapacity(),
logger::log);
prepared = true;
}
@Override
public long activate() {
prepare();
try (var lock = provisioner.lock(application.getApplicationId())) {
if (hostSpecs.isEmpty()) {
logger.log(Level.FINE, () -> "No nodes to provision for " + application.getCapacity().type() + ", removing application");
removeApplication(application.getApplicationId());
} else {
NestedTransaction nestedTransaction = new NestedTransaction();
provisioner.activate(hostSpecs, new ActivationContext(0), new ApplicationTransaction(lock, nestedTransaction));
nestedTransaction.commit();
duperModel.infraApplicationActivated(
application.getApplicationId(),
hostSpecs.stream().map(HostSpec::hostname).map(DomainName::of).toList());
logger.log(Level.FINE, () -> generateActivationLogMessage(hostSpecs, application.getApplicationId()));
}
return 0; // No application config version here
}
}
@Override
public void restart(HostFilter filter) {
provisioner.restart(application.getApplicationId(), filter);
}
}
private void removeApplication(ApplicationId applicationId) {
// Use the DuperModel as source-of-truth on whether it has also been activated (to avoid periodic removals)
if (duperModel.infraApplicationIsActive(applicationId)) {
try (var lock = provisioner.lock(applicationId)) {
NestedTransaction nestedTransaction = new NestedTransaction();
provisioner.remove(new ApplicationTransaction(lock, nestedTransaction));
nestedTransaction.commit();
duperModel.infraApplicationRemoved(applicationId);
}
}
}
private static String generateActivationLogMessage(List<HostSpec> hostSpecs, ApplicationId applicationId) {
String detail;
if (hostSpecs.size() < 10) {
detail = ": " + hostSpecs.stream().map(HostSpec::hostname).collect(Collectors.joining(","));
} else {
detail = " with " + hostSpecs.size() + " hosts";
}
return "Infrastructure application " + applicationId + " activated" + detail;
}
}
|
