blob: b10bd29aee2cb6001069d53bc35eeb41760728f0 (
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
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.config.model.producer;
import com.yahoo.api.annotations.Beta;
import com.yahoo.config.model.ApplicationConfigProducerRoot;
import com.yahoo.vespa.model.Service;
import com.yahoo.vespa.model.SimpleConfigProducer;
import com.yahoo.vespa.model.utils.FreezableMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* Superclass for all producers with children.
* Config producers constructs and returns config instances on request.
*
* @author gjoranv
* @author arnej
*/
public abstract class TreeConfigProducer<CHILD extends AnyConfigProducer>
extends AnyConfigProducer
{
private final List<Service> descendantServices = new ArrayList<>();
private final FreezableMap<String, CHILD> childrenBySubId = new FreezableMap<>(LinkedHashMap.class);
/**
* Creates a new TreeConfigProducer with the given parent and subId.
* This constructor will add the resulting producer to the children of parent.
*
* @param parent the parent of this ConfigProducer
* @param subId the fragment of the config id for the producer
*/
public TreeConfigProducer(TreeConfigProducer parent, String subId) {
super(parent, subId);
}
/**
* Create an config producer with a configId only. Used e.g. to create root nodes, and producers
* that are given children after construction using {@link #addChild(AnyConfigProducer)}.
*
* @param subId The sub configId. Note that this can be prefixed when calling addChild with this producer as arg.
*/
public TreeConfigProducer(String subId) {
super(subId);
}
/**
* Helper to provide an error message on collisions of sub ids (ignore SimpleConfigProducer, use the parent in that case)
*/
private String errorMsgClassName() {
if (getClass().equals(SimpleConfigProducer.class)) return getParent().getClass().getSimpleName();
return getClass().getSimpleName();
}
/**
* Adds a child to this config producer.
*
* @param child the child config producer to add
*/
protected void addChild(CHILD child) {
if (child == null) {
throw new IllegalArgumentException("Trying to add null child for: " + this);
}
if (child instanceof AbstractConfigProducerRoot) {
throw new IllegalArgumentException("Child cannot be a root node: " + child);
}
child.setParent(this);
if (childrenBySubId.get(child.getSubId()) != null) {
throw new IllegalArgumentException("Multiple services/instances of the id '" + child.getSubId() + "' under the service/instance " +
errorMsgClassName() + " '" + getSubId() + "'. (This is commonly caused by service/node index " +
"collisions in the config.)." +
"\nExisting instance: " + childrenBySubId.get(child.getSubId()) +
"\nAttempted to add: " + child +
"\nStack trace: " + Arrays.toString(Thread.currentThread().getStackTrace()));
}
childrenBySubId.put(child.getSubId(), child);
if (child instanceof Service) {
addDescendantService((Service)child);
}
}
public void removeChild(CHILD child) {
if (child.getParent() != this)
throw new IllegalArgumentException("Could not remove " + child + ": Expected its parent to be " +
this + ", but was " + child.getParent());
if (child instanceof Service)
descendantServices.remove(child);
childrenBySubId.remove(child.getSubId());
child.setParent(null);
}
/** Returns this ConfigProducer's children (only 1st level) */
public Map<String, CHILD> getChildren() { return Collections.unmodifiableMap(childrenBySubId); }
@Beta
public <J extends AnyConfigProducer> List<J> getChildrenByTypeRecursive(Class<J> type) {
List<J> validChildren = new ArrayList<>();
if (this.getClass().equals(type)) {
validChildren.add(type.cast(this));
}
Map<String, CHILD> children = this.getChildren();
for (CHILD child : children.values()) {
validChildren.addAll(child.getChildrenByTypeRecursive(type));
}
return Collections.unmodifiableList(validChildren);
}
/** Returns a list of all the children of this who are instances of Service */
public List<Service> getDescendantServices() { return Collections.unmodifiableList(descendantServices); }
protected void addDescendantService(Service s) { descendantServices.add(s); }
void setupConfigId(String parentConfigId) {
super.setupConfigId(parentConfigId);
setupChildConfigIds(getConfigIdPrefix());
}
String getConfigIdPrefix() {
if (this instanceof AbstractConfigProducerRoot || this instanceof ApplicationConfigProducerRoot) {
return "";
}
if (currentConfigId() == null) {
return null;
}
return getConfigId() + "/";
}
@Override
protected ClassLoader getConfigClassLoader(String producerName) {
ClassLoader classLoader = findInheritedClassLoader(getClass(), producerName);
if (classLoader != null)
return classLoader;
// TODO: Make logic correct, so that the deepest child will be the one winning.
for (AnyConfigProducer child : childrenBySubId.values()) {
ClassLoader loader = child.getConfigClassLoader(producerName);
if (loader != null) {
return loader;
}
}
return null;
}
private void setupChildConfigIds(String currentConfigId) {
for (AnyConfigProducer child : childrenBySubId.values()) {
child.setupConfigId(currentConfigId);
}
}
@Override
void aggregateDescendantServices() {
for (CHILD child : childrenBySubId.values()) {
child.aggregateDescendantServices();
descendantServices.addAll(child.getDescendantServices());
}
}
@Override
void freeze() {
childrenBySubId.freeze();
for (CHILD child : childrenBySubId.values()) {
child.freeze();
}
}
@Override
public void validate() throws Exception {
assert (childrenBySubId.isFrozen());
for (CHILD child : childrenBySubId.values()) {
child.validate();
}
}
}
|
