aboutsummaryrefslogtreecommitdiffstats
path: root/config-provisioning/src/main/java/com/yahoo/config/provision/HostSpec.java
blob: 52a2008b6589a2d597564efea3179680a814160d (plain) (blame)
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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.config.provision;

import com.yahoo.component.Version;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * A specification of a host and its role.
 * Equality and order is determined by the host name.
 *
 * @author hmusum
 */
public class HostSpec implements Comparable<HostSpec> {

    /** The name of this host */
    private final String hostname;

    /** Aliases of this host */
    private final List<String> aliases;

    private final NodeResources realResources;
    private final NodeResources advertisedResources;
    private final NodeResources requestedResources;

    /** The current membership role of this host in the cluster it belongs to */
    private final Optional<ClusterMembership> membership;

    private final Optional<Version> version;

    private final Optional<DockerImage> dockerImageRepo;

    private final Optional<NetworkPorts> networkPorts;

    /** Create a host in a non-cloud system, where hosts are specified in config */
    public HostSpec(String hostname, List<String> aliases, Optional<NetworkPorts> networkPorts) {
        this(hostname, aliases,
             NodeResources.unspecified(), NodeResources.unspecified(), NodeResources.unspecified(),
             Optional.empty(), Optional.empty(), networkPorts, Optional.empty());
    }

    /** Create a host in a hosted system */
    public HostSpec(String hostname,
                    NodeResources realResources,
                    NodeResources advertisedResurces,
                    NodeResources requestedResources,
                    ClusterMembership membership,
                    Optional<Version> version,
                    Optional<NetworkPorts> networkPorts,
                    Optional<DockerImage> dockerImageRepo) {
        this(hostname, List.of(),
             realResources,
             advertisedResurces,
             requestedResources,
             Optional.of(membership),
             version,
             networkPorts,
             dockerImageRepo);
    }

    private HostSpec(String hostname,
                     List<String> aliases,
                     NodeResources realResources,
                     NodeResources advertisedResurces,
                     NodeResources requestedResources,
                     Optional<ClusterMembership> membership,
                     Optional<Version> version,
                     Optional<NetworkPorts> networkPorts,
                     Optional<DockerImage> dockerImageRepo) {
        if (hostname == null || hostname.isEmpty()) throw new IllegalArgumentException("Hostname must be specified");
        this.hostname = hostname;
        this.aliases = List.copyOf(aliases);
        this.realResources = Objects.requireNonNull(realResources);
        this.advertisedResources = Objects.requireNonNull(advertisedResurces);
        this.requestedResources = Objects.requireNonNull(requestedResources, "RequestedResources cannot be null");
        this.membership = Objects.requireNonNull(membership);
        this.version = Objects.requireNonNull(version, "Version cannot be null but can be empty");
        this.networkPorts = Objects.requireNonNull(networkPorts, "Network ports cannot be null but can be empty");
        this.dockerImageRepo = Objects.requireNonNull(dockerImageRepo, "Docker image repo cannot be null but can be empty");
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, Optional<ClusterMembership> membership) {
        this(hostname, new ArrayList<>(),
             NodeResources.unspecified(), NodeResources.unspecified(), NodeResources.unspecified(),
             membership,
             Optional.empty(), Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, ClusterMembership membership, Flavor flavor, Optional<Version> version) {
        this(hostname, new ArrayList<>(),
             flavor.resources(), flavor.resources(), NodeResources.unspecified(),
             Optional.of(membership), version, Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases) {
        this(hostname, aliases,
             NodeResources.unspecified(), NodeResources.unspecified(), NodeResources.unspecified(),
             Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases, Flavor flavor) {
        this(hostname, aliases,
             flavor.resources(), flavor.resources(), NodeResources.unspecified(),
             Optional.empty(), Optional.empty(), Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases, ClusterMembership membership) {
        this(hostname, aliases,
             NodeResources.unspecified(), NodeResources.unspecified(), NodeResources.unspecified(),
             Optional.of(membership),
             Optional.empty(), Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases, Optional<Flavor> flavor, Optional<ClusterMembership> membership) {
        this(hostname, aliases,
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             NodeResources.unspecified(),
             membership, Optional.empty(), Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases, Optional<Flavor> flavor,
                    Optional<ClusterMembership> membership, Optional<Version> version) {
        this(hostname, aliases,
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             NodeResources.unspecified(),
             membership, version,
             Optional.empty(), Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases, Optional<Flavor> flavor,
                    Optional<ClusterMembership> membership, Optional<Version> version,
                    Optional<NetworkPorts> networkPorts) {
        this(hostname, aliases,
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             NodeResources.unspecified(),
             membership, version, networkPorts,
             Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases,
                    Optional<Flavor> flavor,
                    Optional<ClusterMembership> membership, Optional<Version> version,
                    Optional<NetworkPorts> networkPorts, Optional<NodeResources> requestedResources) {
        this(hostname, aliases,
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             requestedResources.orElse(NodeResources.unspecified()),
             membership, version, networkPorts, Optional.empty());
    }

    // TODO: Remove after June 2020
    @Deprecated
    public HostSpec(String hostname, List<String> aliases, Optional<Flavor> flavor,
                    Optional<ClusterMembership> membership, Optional<Version> version,
                    Optional<NetworkPorts> networkPorts, Optional<NodeResources> requestedResources,
                    Optional<DockerImage> dockerImageRepo) {
        this(hostname, aliases,
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             flavor.map(f -> f.resources()).orElse(NodeResources.unspecified()),
             requestedResources.orElse(NodeResources.unspecified()),
             membership, version, networkPorts, dockerImageRepo);
    }

    /** Returns the name identifying this host */
    public String hostname() { return hostname; }

    /** Returns the aliases of this host as an immutable list. This may be empty but never null. */
    public List<String> aliases() { return aliases; }

    /** The real resources available for Vespa processes on this node, after subtracting infrastructure overhead. */
    public NodeResources realResources() { return realResources; }

    /** The total advertised resources of this node, typically matching what's requested. */
    public NodeResources advertisedResources() { return advertisedResources; }

    /** A flavor contained the advertised resources of this host */
    // TODO: Remove after June 2020
    public Optional<Flavor> flavor() {
        return advertisedResources.asOptional().map(resources -> new Flavor(resources));
    }

    /** Returns the current version of Vespa running on this node, or empty if not known */
    public Optional<com.yahoo.component.Version> version() { return version; }

    /** Returns the membership of this host, or an empty value if not present */
    public Optional<ClusterMembership> membership() { return membership; }

    /** Returns the network port allocations on this host, or empty if not present */
    public Optional<NetworkPorts> networkPorts() { return networkPorts; }

    /** Returns the requested resources leading to this host being provisioned, or empty if unspecified */
    public Optional<NodeResources> requestedResources() { return requestedResources.asOptional(); }

    public Optional<DockerImage> dockerImageRepo() { return dockerImageRepo; }

    public HostSpec withPorts(Optional<NetworkPorts> ports) {
        return new HostSpec(hostname, aliases, realResources, advertisedResources, requestedResources, membership, version, ports, dockerImageRepo);
    }

    @Override
    public String toString() {
        return hostname +
               (! aliases.isEmpty() ? " (aliases: " + aliases + ")" : "") +
               (membership.isPresent() ? " (membership: " + membership.get() + ")" : " (no membership)");
    }

    @Override
    public boolean equals(Object other) {
        if (other == this) return true;
        if ( ! (other instanceof HostSpec)) return false;

        return ((HostSpec)other).hostname.equals(this.hostname);
    }

    @Override
    public int hashCode() {
        return hostname.hashCode();
    }

    @Override
    public int compareTo(HostSpec other) {
        return hostname.compareTo(other.hostname);
    }

}