/
ConfigurationBuilderHolder.java
167 lines (137 loc) · 5.65 KB
/
ConfigurationBuilderHolder.java
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
package org.infinispan.configuration.parsing;
import static org.infinispan.util.logging.Log.CONFIG;
import java.lang.ref.WeakReference;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.commons.configuration.io.ConfigurationReaderContext;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.global.JGroupsConfigurationBuilder;
import org.infinispan.remoting.transport.jgroups.EmbeddedJGroupsChannelConfigurator;
import org.infinispan.remoting.transport.jgroups.FileJGroupsChannelConfigurator;
import org.infinispan.remoting.transport.jgroups.JGroupsChannelConfigurator;
public class ConfigurationBuilderHolder implements ConfigurationReaderContext {
private final GlobalConfigurationBuilder globalConfigurationBuilder;
private final Map<String, ConfigurationBuilder> namedConfigurationBuilders;
private ConfigurationBuilder currentConfigurationBuilder;
private final WeakReference<ClassLoader> classLoader;
private final Deque<String> scope;
private final JGroupsConfigurationBuilder jgroupsBuilder;
private NamespaceMappingParser namespaceMappingParser;
private List<ConfigurationParserListener> listeners = new ArrayList<>();
public ConfigurationBuilderHolder() {
this(Thread.currentThread().getContextClassLoader());
}
public ConfigurationBuilderHolder(ClassLoader classLoader) {
this(classLoader, new GlobalConfigurationBuilder().classLoader(classLoader));
}
public ConfigurationBuilderHolder(ClassLoader classLoader, GlobalConfigurationBuilder globalConfigurationBuilder) {
this.globalConfigurationBuilder = globalConfigurationBuilder;
this.namedConfigurationBuilders = new HashMap<>();
this.jgroupsBuilder = this.globalConfigurationBuilder.transport().jgroups();
this.classLoader = new WeakReference<>(classLoader);
scope = new ArrayDeque<>();
scope.push(ParserScope.GLOBAL.name());
}
public GlobalConfigurationBuilder getGlobalConfigurationBuilder() {
return globalConfigurationBuilder;
}
public ConfigurationBuilder newConfigurationBuilder(String name) {
ConfigurationBuilder builder = new ConfigurationBuilder();
namedConfigurationBuilders.put(name, builder);
currentConfigurationBuilder = builder;
return builder;
}
public Map<String, ConfigurationBuilder> getNamedConfigurationBuilders() {
return namedConfigurationBuilders;
}
public ConfigurationBuilder getCurrentConfigurationBuilder() {
return currentConfigurationBuilder;
}
public ConfigurationBuilder getDefaultConfigurationBuilder() {
if (globalConfigurationBuilder.defaultCacheName().isPresent()) {
return namedConfigurationBuilders.get(globalConfigurationBuilder.defaultCacheName().get());
} else {
return null;
}
}
void pushScope(Enum<?> scope) {
pushScope(scope.name());
}
public void pushScope(String scope) {
this.scope.push(scope);
}
public String popScope() {
return this.scope.pop();
}
public boolean inScope(String scope) {
return getScope().equals(scope);
}
public boolean inScope(Enum<?> scope) {
return inScope(scope.name());
}
public String getScope() {
return scope.peek();
}
public void addParserListener(ConfigurationParserListener listener) {
listeners.add(listener);
}
public void fireParserListeners() {
for (ConfigurationParserListener listener : listeners) {
listener.parsingComplete(this);
}
}
public ClassLoader getClassLoader() {
return classLoader.get();
}
public void validate() {
globalConfigurationBuilder.defaultCacheName().ifPresent(name -> {
if (!namedConfigurationBuilders.containsKey(name))
throw CONFIG.missingDefaultCacheDeclaration(name);
});
}
public void addJGroupsStack(FileJGroupsChannelConfigurator stack) {
String name = stack.getName();
if (jgroupsBuilder.getStack(name) != null) {
throw CONFIG.duplicateJGroupsStack(name);
}
jgroupsBuilder.addStackFile(name).fileChannelConfigurator(stack);
}
public void addJGroupsStack(EmbeddedJGroupsChannelConfigurator stack, String extend) {
String name = stack.getName();
if (jgroupsBuilder.getStack(name) != null) {
throw CONFIG.duplicateJGroupsStack(name);
}
if (extend == null) {
// Add as is
jgroupsBuilder.addStack(stack.getName()).channelConfigurator(stack);
} else {
// See if the parent exists
if (jgroupsBuilder.getStack(extend) == null) {
throw CONFIG.missingJGroupsStack(extend);
} else {
JGroupsChannelConfigurator baseStack = jgroupsBuilder.getStack(extend);
jgroupsBuilder.addStack(stack.getName()).channelConfigurator(EmbeddedJGroupsChannelConfigurator.combine(baseStack, stack));
}
}
}
JGroupsChannelConfigurator getJGroupsStack(String name) {
return jgroupsBuilder.getStack(name);
}
public void setNamespaceMappingParser(NamespaceMappingParser namespaceMappingParser) {
this.namespaceMappingParser = namespaceMappingParser;
}
@Override
public void handleAnyElement(ConfigurationReader reader) {
namespaceMappingParser.parseElement(reader, this);
}
@Override
public void handleAnyAttribute(ConfigurationReader reader, int i) {
namespaceMappingParser.parseAttribute(reader, i, this);
}
}