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
|
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.net.driver;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.HierarchicalConfiguration;
import org.apache.commons.configuration.XMLConfiguration;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
/**
* Utility capable of reading driver configuration XML resources and producing
* a device driver provider as a result.
* <p>
* The drivers stream structure is as follows:
* </p>
* <pre>
* <drivers>
* <driver name=“...” [manufacturer="..." hwVersion="..." swVersion="..."]>
* <behaviour api="..." impl="..."/>
* ...
* [<property name=“key”>value</key>]
* ...
* </driver>
* ...
* </drivers>
* </pre>
*/
public class XmlDriverLoader {
private static final String DRIVERS = "drivers";
private static final String DRIVER = "driver";
private static final String BEHAVIOUR = "behaviour";
private static final String PROPERTY = "property";
private static final String NAME = "[@name]";
private static final String EXTENDS = "[@extends]";
private static final String MFG = "[@manufacturer]";
private static final String HW = "[@hwVersion]";
private static final String SW = "[@swVersion]";
private static final String API = "[@api]";
private static final String IMPL = "[@impl]";
private final ClassLoader classLoader;
private Map<String, Driver> drivers = Maps.newHashMap();
/**
* Creates a new driver loader capable of loading drivers from the supplied
* class loader.
*
* @param classLoader class loader to use
*/
public XmlDriverLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
}
/**
* Loads the specified drivers resource as an XML stream and parses it to
* produce a ready-to-register driver provider.
*
* @param driversStream stream containing the drivers definitions
* @param resolver driver resolver
* @return driver provider
* @throws java.io.IOException if issues are encountered reading the stream
* or parsing the driver definitions within
*/
public DefaultDriverProvider loadDrivers(InputStream driversStream,
DriverResolver resolver) throws IOException {
try {
XMLConfiguration cfg = new XMLConfiguration();
cfg.setRootElementName(DRIVERS);
cfg.setAttributeSplittingDisabled(true);
cfg.load(driversStream);
return loadDrivers(cfg, resolver);
} catch (ConfigurationException e) {
throw new IOException("Unable to load drivers", e);
}
}
/**
* Loads a driver provider from the supplied hierarchical configuration.
*
* @param driversCfg hierarchical configuration containing the drivers definitions
* @param resolver driver resolver
* @return driver provider
*/
public DefaultDriverProvider loadDrivers(HierarchicalConfiguration driversCfg,
DriverResolver resolver) {
DefaultDriverProvider provider = new DefaultDriverProvider();
for (HierarchicalConfiguration cfg : driversCfg.configurationsAt(DRIVER)) {
DefaultDriver driver = loadDriver(cfg, resolver);
drivers.put(driver.name(), driver);
provider.addDriver(driver);
}
drivers.clear();
return provider;
}
/**
* Loads a driver from the supplied hierarchical configuration.
*
* @param driverCfg hierarchical configuration containing the driver definition
* @param resolver driver resolver
* @return driver
*/
public DefaultDriver loadDriver(HierarchicalConfiguration driverCfg,
DriverResolver resolver) {
String name = driverCfg.getString(NAME);
String parentName = driverCfg.getString(EXTENDS);
String manufacturer = driverCfg.getString(MFG, "");
String hwVersion = driverCfg.getString(HW, "");
String swVersion = driverCfg.getString(SW, "");
Driver parent = parentName != null ? resolve(parentName, resolver) : null;
return new DefaultDriver(name, parent, manufacturer, hwVersion, swVersion,
parseBehaviours(driverCfg),
parseProperties(driverCfg));
}
// Resolves the driver by name locally at first and then using the specified resolver.
private Driver resolve(String parentName, DriverResolver resolver) {
Driver driver = drivers.get(parentName);
return driver != null ? driver :
(resolver != null ? resolver.getDriver(parentName) : null);
}
// Parses the behaviours section.
private Map<Class<? extends Behaviour>, Class<? extends Behaviour>>
parseBehaviours(HierarchicalConfiguration driverCfg) {
ImmutableMap.Builder<Class<? extends Behaviour>,
Class<? extends Behaviour>> behaviours = ImmutableMap.builder();
for (HierarchicalConfiguration b : driverCfg.configurationsAt(BEHAVIOUR)) {
behaviours.put(getClass(b.getString(API)), getClass(b.getString(IMPL)));
}
return behaviours.build();
}
// Parses the properties section.
private Map<String, String> parseProperties(HierarchicalConfiguration driverCfg) {
ImmutableMap.Builder<String, String> properties = ImmutableMap.builder();
for (HierarchicalConfiguration b : driverCfg.configurationsAt(PROPERTY)) {
properties.put(b.getString(NAME), (String) b.getRootNode().getValue());
}
return properties.build();
}
@SuppressWarnings("unchecked")
private Class<? extends Behaviour> getClass(String className) {
try {
return (Class<? extends Behaviour>) classLoader.loadClass(className);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("Unable to load class " + className, e);
}
}
}
|
