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
|
// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.hosted.controller;
import com.yahoo.config.provision.TenantName;
import com.yahoo.vespa.curator.Lock;
import com.yahoo.vespa.hosted.controller.athenz.impl.AthenzFacade;
import com.yahoo.vespa.hosted.controller.concurrent.Once;
import com.yahoo.vespa.hosted.controller.persistence.CuratorDb;
import com.yahoo.vespa.hosted.controller.security.AccessControl;
import com.yahoo.vespa.hosted.controller.security.Credentials;
import com.yahoo.vespa.hosted.controller.security.TenantSpec;
import com.yahoo.vespa.hosted.controller.tenant.Tenant;
import com.yahoo.vespa.hosted.controller.tenant.UserTenant;
import java.time.Duration;
import java.time.Instant;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
/**
* A singleton owned by the Controller which contains the methods and state for controlling tenants.
*
* @author bratseth
* @author mpolden
*/
public class TenantController {
private static final Logger log = Logger.getLogger(TenantController.class.getName());
private final Controller controller;
private final CuratorDb curator;
private final AccessControl accessControl;
public TenantController(Controller controller, CuratorDb curator, AccessControl accessControl) {
this.controller = Objects.requireNonNull(controller, "controller must be non-null");
this.curator = Objects.requireNonNull(curator, "curator must be non-null");
this.accessControl = accessControl;
// Update serialization format of all tenants
Once.after(Duration.ofMinutes(1), () -> {
Instant start = controller.clock().instant();
int count = 0;
for (TenantName name : curator.readTenantNames()) {
lockIfPresent(name, LockedTenant.class, this::store);
count++;
}
log.log(Level.INFO, String.format("Wrote %d tenants in %s", count,
Duration.between(start, controller.clock().instant())));
});
}
/** Returns a list of all known tenants sorted by name */
public List<Tenant> asList() {
return curator.readTenants().stream()
.sorted(Comparator.comparing(Tenant::name))
.collect(Collectors.toList());
}
// TODO jonmv: Remove.
/** Returns the list of tenants accessible to the given user. */
public List<Tenant> asList(Credentials credentials) {
return ((AthenzFacade) accessControl).accessibleTenants(asList(), credentials);
}
/** Locks a tenant for modification and applies the given action. */
public <T extends LockedTenant> void lockIfPresent(TenantName name, Class<T> token, Consumer<T> action) {
try (Lock lock = lock(name)) {
get(name).map(tenant -> LockedTenant.of(tenant, lock))
.map(token::cast)
.ifPresent(action);
}
}
/** Lock a tenant for modification and apply action. Throws if the tenant does not exist */
public <T extends LockedTenant> void lockOrThrow(TenantName name, Class<T> token, Consumer<T> action) {
try (Lock lock = lock(name)) {
action.accept(token.cast(LockedTenant.of(require(name), lock)));
}
}
/** Returns the tenant with the given name, or throws. */
public Tenant require(TenantName name) {
return get(name).orElseThrow(() -> new IllegalArgumentException("No such tenant '" + name + "'."));
}
/** Replace and store any previous version of given tenant */
public void store(LockedTenant tenant) {
curator.writeTenant(tenant.get());
}
/** Create an user tenant with given username */
public void createUser(UserTenant tenant) {
try (Lock lock = lock(tenant.name())) {
requireNonExistent(tenant.name());
curator.writeTenant(tenant);
}
}
/** Create a tenant, provided the given credentials are valid. */
public void create(TenantSpec tenantSpec, Credentials credentials) {
try (Lock lock = lock(tenantSpec.tenant())) {
requireNonExistent(tenantSpec.tenant());
curator.writeTenant(accessControl.createTenant(tenantSpec, credentials, asList()));
}
}
/** Find tenant by name */
public Optional<Tenant> get(TenantName name) {
return curator.readTenant(name);
}
/** Find tenant by name */
public Optional<Tenant> get(String name) {
return get(TenantName.from(name));
}
/** Updates the tenant contained in the given tenant spec with new data. */
public void update(TenantSpec tenantSpec, Credentials credentials) {
try (Lock lock = lock(tenantSpec.tenant())) {
curator.writeTenant(accessControl.updateTenant(tenantSpec, credentials, asList(),
controller.applications().asList(tenantSpec.tenant())));
}
}
/** Deletes the given tenant. */
public void delete(TenantName tenant, Credentials credentials) {
try (Lock lock = lock(tenant)) {
require(tenant);
if ( ! controller.applications().asList(tenant).isEmpty())
throw new IllegalArgumentException("Could not delete tenant '" + tenant.value()
+ "': This tenant has active applications");
curator.removeTenant(tenant);
accessControl.deleteTenant(tenant, credentials);
}
}
/** Deletes the given user tenant. */
public void deleteUser(UserTenant tenant) {
try (Lock lock = lock(tenant.name())) {
curator.removeTenant(tenant.name());
}
}
private void requireNonExistent(TenantName name) {
if ( "hosted-vespa".equals(name.value())
|| get(name).isPresent()
// Underscores are allowed in existing tenant names, but tenants with - and _ cannot co-exist. E.g.
// my-tenant cannot be created if my_tenant exists.
|| get(name.value().replace('-', '_')).isPresent()) {
throw new IllegalArgumentException("Tenant '" + name + "' already exists");
}
}
/**
* Returns a lock which provides exclusive rights to changing this tenant.
* Any operation which stores a tenant need to first acquire this lock, then read, modify
* and store the tenant, and finally release (close) the lock.
*/
private Lock lock(TenantName tenant) {
return curator.lock(tenant);
}
}
|
