/
BasicDeviceConfig.java
287 lines (257 loc) · 9.21 KB
/
BasicDeviceConfig.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
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
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
/*
* Copyright 2015-present Open Networking Foundation
*
* 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.config.basics;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.key.DeviceKeyId;
import static com.google.common.base.Preconditions.checkArgument;
/**
* Basic configuration for network infrastructure devices.
*/
public final class BasicDeviceConfig extends BasicElementConfig<DeviceId> {
private static final String TYPE = "type";
private static final String DRIVER = "driver";
private static final String MANAGEMENT_ADDRESS = "managementAddress";
private static final String PIPECONF = "pipeconf";
private static final String MANUFACTURER = "manufacturer";
private static final String HW_VERSION = "hwVersion";
private static final String SW_VERSION = "swVersion";
private static final String SERIAL = "serial";
private static final String PURGE_ON_DISCONNECT = "purgeOnDisconnection";
private static final String DEVICE_KEY_ID = "deviceKeyId";
private static final int DRIVER_MAX_LENGTH = 256;
private static final int MANUFACTURER_MAX_LENGTH = 256;
private static final int HW_VERSION_MAX_LENGTH = 256;
private static final int SW_VERSION_MAX_LENGTH = 256;
private static final int SERIAL_MAX_LENGTH = 256;
private static final int MANAGEMENT_ADDRESS_MAX_LENGTH = 1024;
private static final int PIPECONF_MAX_LENGTH = 256;
@Override
public boolean isValid() {
// Validate type/DeviceKeyId
type();
deviceKeyId();
return super.isValid()
&& hasOnlyFields(ALLOWED, NAME, LOC_TYPE, LATITUDE, LONGITUDE,
GRID_Y, GRID_X, UI_TYPE, RACK_ADDRESS, OWNER, TYPE, DRIVER, ROLES,
MANUFACTURER, HW_VERSION, SW_VERSION, SERIAL,
MANAGEMENT_ADDRESS, PIPECONF, DEVICE_KEY_ID, PURGE_ON_DISCONNECT)
&& isValidLength(DRIVER, DRIVER_MAX_LENGTH)
&& isValidLength(MANUFACTURER, MANUFACTURER_MAX_LENGTH)
&& isValidLength(HW_VERSION, MANUFACTURER_MAX_LENGTH)
&& isValidLength(SW_VERSION, MANUFACTURER_MAX_LENGTH)
&& isValidLength(SERIAL, MANUFACTURER_MAX_LENGTH)
&& isValidLength(MANAGEMENT_ADDRESS, MANAGEMENT_ADDRESS_MAX_LENGTH)
&& isValidLength(PIPECONF, PIPECONF_MAX_LENGTH);
}
/**
* Returns the device type.
*
* @return device type override
*/
public Device.Type type() {
return get(TYPE, null, Device.Type.class);
}
/**
* Sets the device type.
*
* @param type device type override
* @return self
*/
public BasicDeviceConfig type(Device.Type type) {
return (BasicDeviceConfig) setOrClear(TYPE, type);
}
/**
* Returns the device driver name.
*
* @return driver name or null if not set
*/
public String driver() {
return get(DRIVER, null);
}
/**
* Sets the driver name.
*
* @param driverName new driver name; null to clear
* @return self
*/
public BasicDeviceConfig driver(String driverName) {
checkArgument(driverName.length() <= DRIVER_MAX_LENGTH,
"driver exceeds maximum length " + DRIVER_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(DRIVER, driverName);
}
/**
* Returns the device manufacturer.
*
* @return manufacturer or null if not set
*/
public String manufacturer() {
return get(MANUFACTURER, null);
}
/**
* Sets the device manufacturer.
*
* @param manufacturerName new manufacturer; null to clear
* @return self
*/
public BasicDeviceConfig manufacturer(String manufacturerName) {
checkArgument(manufacturerName.length() <= MANUFACTURER_MAX_LENGTH,
"manufacturer exceeds maximum length " + MANUFACTURER_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(MANUFACTURER, manufacturerName);
}
/**
* Returns the device hardware version.
*
* @return hardware version or null if not set
*/
public String hwVersion() {
return get(HW_VERSION, null);
}
/**
* Sets the device hardware version.
*
* @param hwVersion new hardware version; null to clear
* @return self
*/
public BasicDeviceConfig hwVersion(String hwVersion) {
checkArgument(hwVersion.length() <= HW_VERSION_MAX_LENGTH,
"hwVersion exceeds maximum length " + HW_VERSION_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(HW_VERSION, hwVersion);
}
/**
* Returns the device software version.
*
* @return software version or null if not set
*/
public String swVersion() {
return get(SW_VERSION, null);
}
/**
* Sets the device software version.
*
* @param swVersion new software version; null to clear
* @return self
*/
public BasicDeviceConfig swVersion(String swVersion) {
checkArgument(swVersion.length() <= SW_VERSION_MAX_LENGTH,
"swVersion exceeds maximum length " + SW_VERSION_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(SW_VERSION, swVersion);
}
/**
* Returns the device serial number.
*
* @return serial number or null if not set
*/
public String serial() {
return get(SERIAL, null);
}
/**
* Sets the device serial number.
*
* @param serial new serial number; null to clear
* @return self
*/
public BasicDeviceConfig serial(String serial) {
checkArgument(serial.length() <= SERIAL_MAX_LENGTH,
"serial exceeds maximum length " + SERIAL_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(SERIAL, serial);
}
/**
* Returns the device management address (e.g, "ip:port" or full URI
* string).
*
* @return device management address or null if not set
*/
public String managementAddress() {
return get(MANAGEMENT_ADDRESS, null);
}
/**
* Returns the device pipeconf.
*
* @return device pipeconf or null if not set
*/
public String pipeconf() {
return get(PIPECONF, null);
}
/**
* Sets the device management ip (ip:port).
*
* @param managementAddress new device management address (ip:port); null to clear
* @return self
*/
public BasicDeviceConfig managementAddress(String managementAddress) {
checkArgument(managementAddress.length() <= MANAGEMENT_ADDRESS_MAX_LENGTH,
"managementAddress exceeds maximum length " + MANAGEMENT_ADDRESS_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(MANAGEMENT_ADDRESS, managementAddress);
}
/**
* Sets the device pipeconf.
*
* @param pipeconf new device pipeconf
* @return self
*/
public BasicDeviceConfig pipeconf(String pipeconf) {
checkArgument(pipeconf.length() <= PIPECONF_MAX_LENGTH,
"pipeconf exceeds maximum length " + MANAGEMENT_ADDRESS_MAX_LENGTH);
return (BasicDeviceConfig) setOrClear(PIPECONF, pipeconf);
}
/**
* Returns the device key id.
*
* @return device key id or null if not set
*/
public DeviceKeyId deviceKeyId() {
String s = get(DEVICE_KEY_ID, null);
return s == null ? null : DeviceKeyId.deviceKeyId(s);
}
/**
* Sets the device key id.
*
* @param deviceKeyId the new device key id; null to clear
* @return self
*/
public BasicDeviceConfig deviceKeyId(DeviceKeyId deviceKeyId) {
return (BasicDeviceConfig) setOrClear(DEVICE_KEY_ID,
deviceKeyId != null ? deviceKeyId.id() : null);
}
/**
* Returns the device purgeOnDisconnection flag for this device.
*
* @return device purgeOnDisconnection, false if not set.
*/
public boolean purgeOnDisconnection() {
return get(PURGE_ON_DISCONNECT, false);
}
/**
* Sets the purgeOnDisconnection flag for the device.
*
* @param purgeOnDisconnection purges flows, groups, meters on disconnection.
* @return self
*/
public BasicDeviceConfig purgeOnDisconnection(boolean purgeOnDisconnection) {
return (BasicDeviceConfig) setOrClear(PURGE_ON_DISCONNECT, purgeOnDisconnection);
}
/**
* Returns if the device purgeOnDisconnection flag for this device has been explicitly configured.
*
* @return device purgeOnDisconnection explicitly configured, false if not.
*/
public boolean isPurgeOnDisconnectionConfigured() {
return hasField(PURGE_ON_DISCONNECT);
}
// TODO: device port meta-data to be configured via BasicPortsConfig
// TODO: device credentials/keys; in a separate config
}