<type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">prefix:hash-map-data-store</type>
<name>hash-map-data-store</name>
</module>
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:cluster:store">prefix:dom-clustered-store-impl</type>
+ <name>cluster-data-store</name>
+ </module>
<module>
<type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">prefix:dom-broker-impl</type>
<name>dom-broker</name>
<data-store xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">
<type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">dom:dom-data-store</type>
- <name>ref_hash-map-data-store</name>
+ <!-- to switch to the clustered data store, comment out the ref_hash-map-data-store <name> and uncomment the ref_cluster-data-store one -->
+ <name>ref_hash-map-data-store</name>
+ <!-- <name>ref_cluster-data-store</name> -->
</data-store>
</module>
<module>
<name>ref_hash-map-data-store</name>
<provider>/config/modules/module[name='hash-map-data-store']/instance[name='hash-map-data-store']</provider>
</instance>
+ <instance>
+ <name>ref_cluster-data-store</name>
+ <provider>/config/modules/module[name='dom-clustered-store-impl']/instance[name='cluster-data-store']</provider>
+ </instance>
</service>
<service>
<type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
urn:opendaylight:params:xml:ns:yang:iana?module=iana&revision=2013-08-16
urn:opendaylight:params:xml:ns:yang:controller:md:sal:common?module=opendaylight-md-sal-common&revision=2013-10-28
urn:opendaylight:params:xml:ns:yang:ieee754?module=ieee754&revision=2013-08-19
+urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:cluster:store?module=odl-sal-dom-clustered-store-cfg&revision=2013-10-28
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.5.1-SNAPSHOT</version>
+ <version>0.7.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>junit</groupId>
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;
-import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.opendaylight.controller.sal.action.ActionType;
import org.opendaylight.controller.sal.action.Controller;
import org.opendaylight.controller.sal.action.Drop;
+import org.opendaylight.controller.sal.action.Enqueue;
import org.opendaylight.controller.sal.action.Flood;
import org.opendaylight.controller.sal.action.HwPath;
import org.opendaylight.controller.sal.action.Loopback;
return true;
}
- public boolean isPortValid(Switch sw, Short port) {
- if (port < 1) {
- log.debug("port {} is not valid", port);
- return false;
- }
-
+ public boolean isPortValid(Switch sw, String port) {
if (sw == null) {
log.debug("switch info is not available. Skip checking if port is part of a switch or not.");
return true;
}
-
- Set<NodeConnector> nodeConnectorSet = sw.getNodeConnectors();
- for (NodeConnector nodeConnector : nodeConnectorSet) {
- if (((Short) nodeConnector.getID()).equals(port)) {
- return true;
- }
- }
- log.debug("port {} is not a valid port of node {}", port, sw.getNode());
- return false;
+ NodeConnector nc = NodeConnectorCreator.createNodeConnector(port, sw.getNode());
+ return sw.getNodeConnectors().contains(nc);
}
public boolean isVlanIdValid(String vlanId) {
}
if (ingressPort != null) {
- Short port = Short.decode(ingressPort);
- if (isPortValid(sw, port) == false) {
- String msg = String.format("Ingress port %d is not valid for the Switch", port);
+ if (!isPortValid(sw, ingressPort)) {
+ String msg = String.format("Ingress port %s is not valid for the Switch", ingressPort);
if (!containerName.equals(GlobalConstants.DEFAULT.toString())) {
msg += " in Container " + containerName;
}
if (sstr.matches()) {
for (String t : sstr.group(1).split(",")) {
Matcher n = Pattern.compile("(?:(\\d+))").matcher(t);
+ if (n.matches()) {
+ String port = n.group(1);
+ if (port != null) {
+ if (!isPortValid(sw, port)) {
+ String msg = String.format("Output port %s is not valid for this switch", port);
+ if (!containerName.equals(GlobalConstants.DEFAULT.toString())) {
+ msg += " in Container " + containerName;
+ }
+ return new Status(StatusCode.BADREQUEST, msg);
+ }
+ }
+ } else {
+ String msg = String.format("Output port %s is not valid", t);
+ return new Status(StatusCode.BADREQUEST, msg);
+ }
+ }
+ continue;
+ }
+ // check enqueue
+ sstr = Pattern.compile("ENQUEUE=(.*)").matcher(actiongrp);
+ if (sstr.matches()) {
+ for (String t : sstr.group(1).split(",")) {
+ Matcher n = Pattern.compile("(?:(\\d+:\\d+))").matcher(t);
if (n.matches()) {
if (n.group(1) != null) {
- Short port = Short.parseShort(n.group(1));
- if (isPortValid(sw, port) == false) {
+ String port = n.group(1).split(":")[0];
+ if (!isPortValid(sw, port)) {
String msg = String.format("Output port %d is not valid for this switch", port);
if (!containerName.equals(GlobalConstants.DEFAULT.toString())) {
msg += " in Container " + containerName;
}
}
} else {
- String msg = String.format("Output port %s is not valid", t);
+ String msg = String.format("Enqueue port %s is not valid", t);
return new Status(StatusCode.BADREQUEST, msg);
}
}
if (this.ingressPort != null) {
match.setField(MatchType.IN_PORT,
- NodeConnectorCreator.createOFNodeConnector(Short.parseShort(ingressPort), getNode()));
+ NodeConnector.fromString(String.format("%s|%s@%s", node.getType(), ingressPort, node.toString())));
}
if (this.dlSrc != null) {
match.setField(MatchType.DL_SRC, HexEncode.bytesFromHexString(this.dlSrc));
Matcher n = Pattern.compile("(?:(\\d+))").matcher(t);
if (n.matches()) {
if (n.group(1) != null) {
- short ofPort = Short.parseShort(n.group(1));
- actionList.add(new Output(NodeConnectorCreator.createOFNodeConnector(ofPort,
- this.getNode())));
+ String nc = String.format("%s|%s@%s", node.getType(), n.group(1), node.toString());
+ actionList.add(new Output(NodeConnector.fromString(nc)));
+ }
+ }
+ }
+ continue;
+ }
+
+ sstr = Pattern.compile(ActionType.ENQUEUE + "=(.*)").matcher(actiongrp);
+ if (sstr.matches()) {
+ for (String t : sstr.group(1).split(",")) {
+ Matcher n = Pattern.compile("(?:(\\d+:\\d+))").matcher(t);
+ if (n.matches()) {
+ if (n.group(1) != null) {
+ String parts[] = n.group(1).split(":");
+ String nc = String.format("%s|%s@%s", node.getType(), parts[0], node.toString());
+ if (parts.length == 1) {
+ actionList.add(new Enqueue(NodeConnector.fromString(nc)));
+ } else {
+ actionList
+ .add(new Enqueue(NodeConnector.fromString(nc), Integer.parseInt(parts[1])));
+ }
}
}
}
fc.setCookie("100");
Assert.assertTrue(fc.validate(null).isSuccess());
- fc.setIngressPort("-1");
- status = fc.validate(null);
- Assert.assertFalse(status.isSuccess());
- Assert.assertTrue(status.getDescription().contains("is not valid for the Switch"));
-
fc.setIngressPort("100");
Assert.assertTrue(fc.validate(null).isSuccess());
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.5.1-SNAPSHOT</version>
+ <version>0.7.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>clustered-datastore.integrationtest</artifactId>
<version>0.4.0-SNAPSHOT</version>
- <dependencies>
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>xml-apis</groupId>
+ <artifactId>xml-apis</artifactId>
+ <version>1.4.01</version>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
+
+ <dependencies>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
<version>1.0-SNAPSHOT</version>
+ <exclusions>
+ <exclusion>
+ <artifactId>xml-apis</artifactId>
+ <groupId>xml-apis</groupId>
+ </exclusion>
+ <exclusion>
+ <artifactId>reflections</artifactId>
+ <groupId>org.reflections</groupId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-netconf-connector</artifactId>
<version>${netconf.version}</version>
<scope>test</scope>
+ <exclusions>
+ <exclusion>
+ <artifactId>xml-apis</artifactId>
+ <groupId>xml-apis</groupId>
+ </exclusion>
+ </exclusions>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAdded;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowRemoved;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowUpdated;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeErrorNotification;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeExperimenterErrorNotification;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.NodeFlow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SwitchFlowRemoved;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.UpdatedFlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
public class FlowConsumerImpl implements IForwardingRulesManager {
protected static final Logger logger = LoggerFactory.getLogger(FlowConsumerImpl.class);
- // private final FlowEventListener flowEventListener = new
- // FlowEventListener();
+ private final FlowEventListener flowEventListener = new FlowEventListener();
private Registration<NotificationListener> listener1Reg;
private SalFlowService flowService;
// private FlowDataListener listener;
// }
// For switch events
- // listener1Reg =
- // FRMConsumerImpl.getNotificationService().registerNotificationListener(flowEventListener);
+ listener1Reg = FRMConsumerImpl.getNotificationService().registerNotificationListener(flowEventListener);
if (null == listener1Reg) {
logger.error("Listener to listen on flow data modifcation events");
input1.setNode(nodeOne);
AddFlowInput firstMsg = input1.build();
- if (null != flowService) {
+ if (null == flowService) {
logger.error("ConsumerFlowService is NULL");
}
@SuppressWarnings("unused")
}
}
+ final class FlowEventListener implements SalFlowListener {
+
+ List<FlowAdded> addedFlows = new ArrayList<>();
+ List<FlowRemoved> removedFlows = new ArrayList<>();
+ List<FlowUpdated> updatedFlows = new ArrayList<>();
+
+ @Override
+ public void onFlowAdded(FlowAdded notification) {
+ addedFlows.add(notification);
+ }
+
+ @Override
+ public void onFlowRemoved(FlowRemoved notification) {
+ removedFlows.add(notification);
+ }
+
+ @Override
+ public void onFlowUpdated(FlowUpdated notification) {
+ updatedFlows.add(notification);
+ }
+
+ @Override
+ public void onNodeErrorNotification(NodeErrorNotification notification) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void onNodeExperimenterErrorNotification(NodeExperimenterErrorNotification notification) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void onSwitchFlowRemoved(SwitchFlowRemoved notification) {
+ // TODO Auto-generated method stub
+
+ }
+
+ }
+
// Commented out DataChangeListene - to be used by Stats
// final class FlowDataListener implements DataChangeListener {
return new NodeRef(path);
}
-}
+}
\ No newline at end of file
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.SalGroupService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.UpdatedGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupTypes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.buckets.Bucket;
UpdateGroupInputBuilder groupData = new UpdateGroupInputBuilder();
updateGroupBuilder = new UpdatedGroupBuilder();
+ updateGroupBuilder.setGroupId(new GroupId(groupUpdateDataObject.getId()));
updateGroupBuilder.fieldsFrom(groupUpdateDataObject);
groupData.setUpdatedGroup(updateGroupBuilder.build());
groupService.updateGroup(groupData.build());
AddGroupInputBuilder groupData = new AddGroupInputBuilder();
groupData.setBuckets(groupAddDataObject.getBuckets());
groupData.setContainerName(groupAddDataObject.getContainerName());
- groupData.setGroupId(groupAddDataObject.getGroupId());
+ groupData.setGroupId(new GroupId(groupAddDataObject.getId()));
groupData.setGroupType(groupAddDataObject.getGroupType());
groupData.setNode(groupAddDataObject.getNode());
groupService.addGroup(groupData.build());
RemoveGroupInputBuilder groupData = new RemoveGroupInputBuilder();
groupData.setBuckets(groupRemoveDataObject.getBuckets());
groupData.setContainerName(groupRemoveDataObject.getContainerName());
- groupData.setGroupId(groupRemoveDataObject.getGroupId());
+ groupData.setGroupId(new GroupId(groupRemoveDataObject.getId()));
groupData.setGroupType(groupRemoveDataObject.getGroupType());
groupData.setNode(groupRemoveDataObject.getNode());
groupService.removeGroup(groupData.build());
for (Entry<InstanceIdentifier<?>, Group> entry : transaction.updates.entrySet()) {
- if (!updateGroup(entry.getKey(), entry.getValue()).isSuccess()) {
+ if (!addGroup(entry.getKey(), entry.getValue()).isSuccess()) {
transaction.updates.remove(entry.getKey());
return Rpcs.getRpcResult(false, null, Collections.<RpcError>emptySet());
}
if (null != meterKey && validateMeter(meterUpdateDataObject, FRMUtil.operation.UPDATE).isSuccess()) { UpdateMeterInputBuilder updateMeterInputBuilder = new UpdateMeterInputBuilder();
updateMeterBuilder = new UpdatedMeterBuilder();
updateMeterBuilder.fieldsFrom(meterUpdateDataObject);
+ updateMeterBuilder.setMeterId(new MeterId(meterUpdateDataObject.getId()));
+
updateMeterInputBuilder.setUpdatedMeter(updateMeterBuilder.build());
meterService.updateMeter(updateMeterInputBuilder.build());
} else {
meterBuilder.setNode(meterRemoveDataObject.getNode());
meterBuilder.setFlags(meterRemoveDataObject.getFlags());
meterBuilder.setMeterBandHeaders(meterRemoveDataObject.getMeterBandHeaders());
- meterBuilder.setMeterId(meterRemoveDataObject.getMeterId());
+ meterBuilder.setMeterId(new MeterId(meterRemoveDataObject.getId()));
meterBuilder.setNode(meterRemoveDataObject.getNode());
meterService.removeMeter(meterBuilder.build());
} else {
type uint32;
}
+ typedef bucket-id {
+ type uint32;
+ }
+
typedef group-types {
type enumeration {
enum group-all;
container buckets {
list bucket {
- key "order";
- leaf order {
- type int32;
+ key "bucket-id";
+ leaf bucket-id {
+ type bucket-id;
}
leaf weight {
grouping group-statistics {
leaf group-id {
- type int32;
+ type group-id;
}
leaf ref-count {
container buckets {
list bucket-counter {
- key "order";
- leaf order {
- type int32;
+ key "bucket-id";
+ leaf bucket-id {
+ type bucket-id;
}
leaf packet-count {
grouping group-statistics-request {
list group-stats {
key "group-id";
-
leaf group-id {
- type int32;
+ type group-id;
}
}
}
grouping group-statistics-reply {
list group-stats {
- key "group-stats-order";
- leaf group-stats-order {
- type int32;
- }
-
+ key "group-id";
uses group-statistics;
}
}
grouping group-desc-stats-reply {
list group-desc-stats {
- key "order-id";
- leaf order-id {
- type int32;
- }
-
+ key "group-id";
uses group;
}
}
}
typedef meter-id {
- type uint32;
+ type uint32;
+ }
+ typedef band-id {
+ type uint32;
}
typedef meter-flags {
container meter-band-headers {
list meter-band-header {
- key "order";
- leaf order {
- type int32;
+ key "band-id";
+ leaf band-id {
+ type band-id;
}
container meter-band-types {
grouping meter-statistics {
leaf meter-id {
- type int32;
+ type meter-id;
}
leaf flow-count {
container meter-band-stats {
list band-stat {
- key "order";
- leaf order {
- type int32;
+ key "band-id";
+ leaf band-id {
+ type band-id;
}
leaf packet-band-count {
grouping meter-stats-config-request {
list meter-stats {
key "meter-id";
-
leaf meter-id {
- type int32;
+ type meter-id;
}
}
}
grouping meter-statistics-reply {
list meter-stats {
- key "meter-stats-order";
- leaf meter-stats-order {
- type int32;
- }
+ key "meter-id";
uses meter-statistics;
}
}
grouping meter-config-stats-reply {
list meter-config-stats {
- key "meter-config-order";
- leaf meter-config-order {
- type int32;
- }
-
+ key "meter-id";
uses meter;
}
}
output {
uses tr:transaction-aware;
}
- }
+ }
+
+ notification table-updated {
+ uses "inv:node-context-ref";
+ uses tr:transaction-aware;
+ leaf moreReplies {
+ type boolean;
+ }
+ uses table-type:table-features;
+ }
}
\ No newline at end of file
<module>sal-binding-broker</module>
<module>sal-binding-util</module>
+ <module>sal-binding-dom-it</module>
<!-- Samples -->
<module>samples</module>
<dependencyManagement>
<dependencies>
-
-
-
+ <dependency>
+ <groupId>xml-apis</groupId>
+ <artifactId>xml-apis</artifactId>
+ <version>1.4.01</version>
+ </dependency>
<!-- YANG Tools Dependencies -->
<dependency>
</execution>
</executions>
</plugin>
+
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <executions>
+ <execution>
+ <goals>
+ <goal>test-jar</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
</plugins>
</build>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
<version>0.9.9-RC1</version>
+ <scope>compile</scope>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<groupId>org.eclipse.xtend</groupId>
<artifactId>org.eclipse.xtend.lib</artifactId>
</dependency>
- <dependency>
- <groupId>org.eclipse.xtend</groupId>
- <artifactId>org.eclipse.xtend.standalone</artifactId>
- <version>2.4.3</version>
- <scope>runtime</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-config</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-service</artifactId>
- <version>1.0-SNAPSHOT</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-management</artifactId>
- <version>1.0-SNAPSHOT</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
<version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.opendaylight.controller.model</groupId>
- <artifactId>model-flow-statistics</artifactId>
- <version>1.0-SNAPSHOT</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.reflections</groupId>
- <artifactId>reflections</artifactId>
- <version>0.9.9-RC1</version>
- <scope>test</scope>
- </dependency>
</dependencies>
</project>
Map<Type, WeakReference<Class>> typeToClass = new ConcurrentHashMap<>();
@SuppressWarnings("rawtypes")
- private ConcurrentMap<Type, ChoiceCaseCodecImpl> typeToCaseNodes = new ConcurrentHashMap<>();
+ private ConcurrentMap<Type, ChoiceCaseCodecImpl> typeToCaseCodecs = new ConcurrentHashMap<>();
private CaseClassMapFacade classToCaseRawCodec = new CaseClassMapFacade();
}
return weakRef.get();
}
-
+
@Override
- public void putPathToClass(List<QName> names,Class<?> cls) {
+ public void putPathToClass(List<QName> names, Class<?> cls) {
Type reference = Types.typeForClass(cls);
- pathToInstantiatedType.put(names, reference );
+ pathToInstantiatedType.put(names, reference);
bindingClassEncountered(cls);
}
-
@Override
public IdentifierCodec<?> getKeyCodecForPath(List<QName> names) {
@SuppressWarnings("unchecked")
return potential;
}
ConcreteType typeref = Types.typeForClass(caseClass);
- ChoiceCaseCodecImpl caseCodec = typeToCaseNodes.get(typeref);
+ ChoiceCaseCodecImpl caseCodec = typeToCaseCodecs.get(typeref);
+ checkState(caseCodec != null, "Case Codec was not created proactivelly for %s", caseClass.getName());
+ checkState(caseCodec.getSchema() != null, "Case schema is not available for %s", caseClass.getName());
@SuppressWarnings("unchecked")
- Class<? extends BindingCodec> newCodec = generator.caseCodecFor(caseClass, caseCodec.schema);
+ Class<? extends BindingCodec> newCodec = generator.caseCodecFor(caseClass, caseCodec.getSchema());
BindingCodec newInstance = newInstanceOf(newCodec);
caseCodec.setDelegate(newInstance);
caseCodecs.put(caseClass, caseCodec);
for (Entry<SchemaPath, GeneratedTypeBuilder> caseNode : cases.entrySet()) {
ReferencedTypeImpl typeref = new ReferencedTypeImpl(caseNode.getValue().getPackageName(), caseNode
.getValue().getName());
+
+ LOG.info("Case path: {} Type : {}", caseNode.getKey(), caseNode.getValue().getFullyQualifiedName());
+ pathToType.put(caseNode.getKey(), caseNode.getValue());
+
ChoiceCaseNode node = (ChoiceCaseNode) SchemaContextUtil.findDataSchemaNode(module, caseNode.getKey());
+
if (node == null) {
LOG.error("YANGTools Bug: SchemaNode for {}, with path {} was not found in context.",
typeref.getFullyQualifiedName(), caseNode.getKey());
+ @SuppressWarnings("rawtypes")
+ ChoiceCaseCodecImpl value = new ChoiceCaseCodecImpl();
+ typeToCaseCodecs.putIfAbsent(typeref, value);
continue;
}
-
- pathToType.put(caseNode.getKey(), caseNode.getValue());
@SuppressWarnings("rawtypes")
ChoiceCaseCodecImpl value = new ChoiceCaseCodecImpl(node);
- typeToCaseNodes.putIfAbsent(typeref, value);
+ typeToCaseCodecs.putIfAbsent(typeref, value);
}
}
choiceCodecs.put(choiceClass, newCodec);
CodecMapping.setClassToCaseMap(choiceCodec, (Map<Class<?>, BindingCodec<?, ?>>) classToCaseRawCodec);
CodecMapping.setCompositeNodeToCaseMap(choiceCodec, newCodec.getCompositeToCase());
-
+
tryToCreateCasesCodecs(schema);
}
private void tryToCreateCasesCodecs(ChoiceNode schema) {
- for(ChoiceCaseNode caseNode : schema.getCases()) {
+ for (ChoiceCaseNode caseNode : schema.getCases()) {
SchemaPath path = caseNode.getPath();
GeneratedTypeBuilder type;
- if(path != null && (type = pathToType.get(path)) != null) {
+ if (path != null && (type = pathToType.get(path)) != null) {
+ ReferencedTypeImpl typeref = new ReferencedTypeImpl(type.getPackageName(), type.getName());
+ ChoiceCaseCodecImpl partialCodec = typeToCaseCodecs.get(typeref);
+ if(partialCodec.getSchema() == null ) {
+ partialCodec.setSchema(caseNode);
+ }
+
Class<?> caseClass = ClassLoaderUtils.tryToLoadClassWithTCCL(type.getFullyQualifiedName());
- if(caseClass != null) {
+ if (caseClass != null) {
getCaseCodecFor(caseClass);
}
}
}
@Override
- public void onDataContainerCodecCreated(Class<?> dataClass,
- Class<? extends BindingCodec<?,?>> dataCodec) {
+ public void onDataContainerCodecCreated(Class<?> dataClass, Class<? extends BindingCodec<?, ?>> dataCodec) {
if (Augmentable.class.isAssignableFrom(dataClass)) {
AugmentableCompositeCodec augmentableCodec = getAugmentableCodec(dataClass);
CodecMapping.setAugmentationCodec(dataCodec, augmentableCodec);
@SuppressWarnings("rawtypes")
private static class ChoiceCaseCodecImpl<T extends DataContainer> implements ChoiceCaseCodec<T>, //
Delegator<BindingCodec> {
- private final boolean augmenting;
+ private boolean augmenting;
private BindingCodec delegate;
- private final Set<String> validNames;
- private final Set<QName> validQNames;
+ private Set<String> validNames;
+ private Set<QName> validQNames;
private ChoiceCaseNode schema;
- public ChoiceCaseCodecImpl(ChoiceCaseNode caseNode) {
- this.delegate = NOT_READY_CODEC;
+ public void setSchema(ChoiceCaseNode caseNode) {
+ this.schema = schema;
this.schema = caseNode;
validNames = new HashSet<>();
validQNames = new HashSet<>();
augmenting = caseNode.isAugmenting();
}
+ public ChoiceCaseCodecImpl() {
+ this.delegate = NOT_READY_CODEC;
+ }
+
+ public ChoiceCaseCodecImpl(ChoiceCaseNode caseNode) {
+ this.delegate = NOT_READY_CODEC;
+ setSchema(caseNode);
+ }
+
@Override
public ValueWithQName<T> deserialize(Node<?> input) {
throw new UnsupportedOperationException("Direct invocation of this codec is not allowed.");
for (entry : newBinding.moduleContexts.entrySet) {
registry.onModuleContextAdded(schemaContext, entry.key, entry.value);
-
+ binding.pathToType.putAll(entry.value.childNodes)
//val module = entry.key;
val context = entry.value;
updateBindingFor(context.childNodes, schemaContext);
}
private def void updateBindingFor(Map<SchemaPath, GeneratedTypeBuilder> map, SchemaContext module) {
+
for (entry : map.entrySet) {
val schemaNode = SchemaContextUtil.findDataSchemaNode(module, entry.key);
//LOG.info("{} : {}",entry.key,entry.value.fullyQualifiedName)
+ val typeRef = new ReferencedTypeImpl(entry.value.packageName,entry.value.name)
+ typeToDefinition.put(typeRef, entry.value);
if (schemaNode != null) {
- val typeRef = new ReferencedTypeImpl(entry.value.packageName,entry.value.name)
typeToSchemaNode.put(typeRef, schemaNode);
- typeToDefinition.put(typeRef, entry.value);
updatePromisedSchemas(typeRef, schemaNode);
}
+
}
}
import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl
import org.opendaylight.yangtools.yang.model.util.ExtendedType
import org.opendaylight.yangtools.yang.model.util.EnumerationType
+import static com.google.common.base.Preconditions.*
+import org.opendaylight.yangtools.yang.model.api.SchemaPath
class TransformerGenerator {
@Property
var Map<Type, GeneratedTypeBuilder> typeToDefinition = new ConcurrentHashMap();
+ @Property
+ var Map<SchemaPath, GeneratedTypeBuilder> pathToType = new ConcurrentHashMap();
+
@Property
var Map<Type, SchemaNode> typeToSchemaNode = new ConcurrentHashMap();
val ref = Types.typeForClass(inputType)
val node = typeToSchemaNode.get(ref)
val typeSpecBuilder = typeToDefinition.get(ref)
+ checkState(typeSpecBuilder !== null, "Could not find typedefinition for %s", inputType.name);
+ val typeSpec = typeSpecBuilder.toInstance();
+ val newret = generateTransformerFor(inputType, typeSpec, node);
+ listener.onClassProcessed(inputType);
+ return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
+ ]
+ }
+
+ def Class<? extends BindingCodec<Map<QName, Object>, Object>> transformerFor(Class<?> inputType, DataSchemaNode node) {
+ return withClassLoaderAndLock(inputType.classLoader, lock) [ |
+ val ret = getGeneratedClass(inputType)
+ if (ret !== null) {
+ listener.onClassProcessed(inputType);
+ return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
+ }
+ val ref = Types.typeForClass(inputType)
+ var typeSpecBuilder = typeToDefinition.get(ref)
+ if (typeSpecBuilder == null) {
+ typeSpecBuilder = pathToType.get(node.path);
+ }
+ checkState(typeSpecBuilder !== null, "Could not find TypeDefinition for %s, $s", inputType.name, node);
val typeSpec = typeSpecBuilder.toInstance();
val newret = generateTransformerFor(inputType, typeSpec, node);
listener.onClassProcessed(inputType);
keyTransformerFor(cls, type, node);
}
- private def serializer(Type type) {
+ private def serializer(Type type, DataSchemaNode node) {
val cls = loadClassWithTCCL(type.resolvedName);
-
- transformerFor(cls);
-
+ transformerFor(cls, node);
}
private def Class<?> getValueSerializer(GeneratedTransferObject type) {
]
val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain) as Class<? extends BindingCodec<Object, Object>>
- listener?.onDataContainerCodecCreated(inputType,ret);
+ listener?.onDataContainerCodecCreated(inputType, ret);
log.info("DOM Codec for {} was generated {}", inputType, ret)
return ret;
} catch (Exception e) {
Object _listItem = _iterator.next();
_is_empty = false;
//System.out.println(" item" + _listItem);
- Object _value = «type.actualTypeArguments.get(0).serializer.resolvedName».fromDomStatic(_localQName,_listItem);
+ Object _value = «type.actualTypeArguments.get(0).serializer(schema).resolvedName».fromDomStatic(_localQName,_listItem);
//System.out.println(" value" + _value);
«propertyName».add(_value);
_hasNext = _iterator.hasNext();
if(_dom_«propertyName»_list != null && _dom_«propertyName»_list.size() > 0) {
_is_empty = false;
java.util.Map _dom_«propertyName» = (java.util.Map) _dom_«propertyName»_list.get(0);
- «propertyName» = «type.serializer.resolvedName».fromDomStatic(_localQName,_dom_«propertyName»);
+ «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_dom_«propertyName»);
}
'''
private def dispatch CharSequence deserializeProperty(ChoiceNode schema, Type type, String propertyName) '''
- «type.resolvedName» «propertyName» = «type.serializer.resolvedName».fromDomStatic(_localQName,_compositeNode);
+ «type.resolvedName» «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_compositeNode);
if(«propertyName» != null) {
_is_empty = false;
}
boolean _hasNext = _iterator.hasNext();
while(_hasNext) {
Object _listItem = _iterator.next();
- Object _domValue = «type.actualTypeArguments.get(0).serializer.resolvedName».toDomStatic(_resultName,_listItem);
+ Object _domValue = «type.actualTypeArguments.get(0).serializer(schema).resolvedName».toDomStatic(_resultName,_listItem);
_childNodes.add(_domValue);
_hasNext = _iterator.hasNext();
}
String propertyName) '''
«type.resolvedName» «propertyName» = value.«propertyName»();
if(«propertyName» != null) {
- java.util.List domValue = «type.serializer.resolvedName».toDomStatic(_resultName,«propertyName»);
+ java.util.List domValue = «type.serializer(container).resolvedName».toDomStatic(_resultName,«propertyName»);
_childNodes.addAll(domValue);
}
'''
String propertyName) '''
«type.resolvedName» «propertyName» = value.«propertyName»();
if(«propertyName» != null) {
- Object domValue = «type.serializer.resolvedName».toDomStatic(_resultName,«propertyName»);
+ Object domValue = «type.serializer(container).resolvedName».toDomStatic(_resultName,«propertyName»);
_childNodes.add(domValue);
}
'''
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
+import com.google.common.base.Joiner;
import com.google.common.base.Optional;
public final class ClassLoaderUtils {
if ("byte[]".equals(name)) {
return byte[].class;
}
-
- return Thread.currentThread().getContextClassLoader().loadClass(name);
+ try {
+ return Thread.currentThread().getContextClassLoader().loadClass(name);
+ } catch (ClassNotFoundException e) {
+ String[] components = name.split("\\.");
+ String potentialOuter;
+ int length = components.length;
+ if (length > 2 && (potentialOuter = components[length - 2]) != null && Character.isUpperCase(potentialOuter.charAt(0))) {
+
+ String outerName = Joiner.on(".").join(Arrays.asList(components).subList(0, length - 1));
+ String innerName = outerName + "$" + components[length-1];
+ return Thread.currentThread().getContextClassLoader().loadClass(innerName);
+ } else {
+ throw e;
+ }
+ }
}
public static Class<?> tryToLoadClassWithTCCL(String fullyQualifiedName) {
try {
return loadClassWithTCCL(fullyQualifiedName);
} catch (ClassNotFoundException e) {
-
+
}
return null;
}
import org.opendaylight.controller.sal.binding.impl.DataBrokerImpl;
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentDataServiceConnector;
import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;
+import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
+import org.opendaylight.controller.sal.binding.test.util.BindingTestContext;
import org.opendaylight.controller.sal.binding.dom.serializer.impl.RuntimeGeneratedMappingServiceImpl;
import org.opendaylight.controller.sal.core.api.data.DataBrokerService;
import org.opendaylight.controller.sal.core.api.data.DataStore;
protected org.opendaylight.controller.sal.core.api.data.DataProviderService biDataService;
protected DataProviderService baDataService;
-
- /**
- * Workaround for JUNIT sharing classloaders
- *
- */
- protected static final ClassPool POOL = new ClassPool();
-
- protected RuntimeGeneratedMappingServiceImpl mappingServiceImpl;
protected BindingIndependentMappingService mappingService;
- protected DataBrokerImpl baDataImpl;
- protected org.opendaylight.controller.sal.dom.broker.DataBrokerImpl biDataImpl;
- protected ListeningExecutorService executor;
- protected BindingIndependentDataServiceConnector connectorServiceImpl;
- protected HashMapDataStore rawDataStore;
- protected SchemaAwareDataStoreAdapter schemaAwareDataStore;
private DataStoreStatsWrapper dataStoreStats;
-
protected DataStore dataStore;
+ protected BindingTestContext testContext;
@Before
public void setUp() {
- executor = MoreExecutors.sameThreadExecutor();
- baDataImpl = new DataBrokerImpl();
- baDataService = baDataImpl;
- baDataImpl.setExecutor(executor);
-
- biDataImpl = new org.opendaylight.controller.sal.dom.broker.DataBrokerImpl();
- biDataService = biDataImpl;
- biDataImpl.setExecutor(executor);
-
- rawDataStore = new HashMapDataStore();
- schemaAwareDataStore = new SchemaAwareDataStoreAdapter();
- schemaAwareDataStore.changeDelegate(rawDataStore);
- dataStoreStats = new DataStoreStatsWrapper(schemaAwareDataStore);
- dataStore = dataStoreStats;
-
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier treeRoot = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
- .builder().toInstance();
- biDataImpl.registerConfigurationReader(treeRoot, dataStore);
- biDataImpl.registerOperationalReader(treeRoot, dataStore);
- biDataImpl.registerCommitHandler(treeRoot, dataStore);
-
- mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl();
- mappingServiceImpl.setPool(POOL);
- mappingService = mappingServiceImpl;
- File pathname = new File("target/gen-classes-debug");
- // System.out.println("Generated classes are captured in " +
- // pathname.getAbsolutePath());
- mappingServiceImpl.start(null);
- // mappingServiceImpl.getBinding().setClassFileCapturePath(pathname);
-
- connectorServiceImpl = new BindingIndependentDataServiceConnector();
- connectorServiceImpl.setBaDataService(baDataService);
- connectorServiceImpl.setBiDataService(biDataService);
- connectorServiceImpl.setMappingService(mappingServiceImpl);
- connectorServiceImpl.start();
-
- String[] yangFiles = getModelFilenames();
- if (yangFiles != null && yangFiles.length > 0) {
- SchemaContext context = getContext(yangFiles);
- mappingServiceImpl.onGlobalContextUpdated(context);
- schemaAwareDataStore.onGlobalContextUpdated(context);
- }
+ ListeningExecutorService executor = MoreExecutors.sameThreadExecutor();
+ BindingBrokerTestFactory factory = new BindingBrokerTestFactory();
+ factory.setExecutor(executor);
+ factory.setStartWithParsedSchema(getStartWithSchema());
+ testContext = factory.getTestContext();
+ testContext.start();
+
+ baDataService = testContext.getBindingDataBroker();
+ biDataService = testContext.getDomDataBroker();
+ dataStore = testContext.getDomDataStore();
+ mappingService = testContext.getBindingToDomMappingService();
}
- protected String[] getModelFilenames() {
- return getAllModelFilenames();
- }
-
- public static String[] getAllModelFilenames() {
- Predicate<String> predicate = new Predicate<String>() {
- @Override
- public boolean apply(String input) {
- return input.endsWith(".yang");
- }
- };
- Reflections reflection = new Reflections("META-INF.yang", new ResourcesScanner());
- Set<String> result = reflection.getResources(predicate);
- return (String[]) result.toArray(new String[result.size()]);
- }
-
- public static SchemaContext getContext(String[] yangFiles) {
-
- ClassLoader loader = AbstractDataServiceTest.class.getClassLoader();
-
- List<InputStream> streams = new ArrayList<>();
- for (String string : yangFiles) {
- InputStream stream = loader.getResourceAsStream(string);
- streams.add(stream);
-
- }
- YangParserImpl parser = new YangParserImpl();
-
- Set<Module> modules = parser.parseYangModelsFromStreams(streams);
- return parser.resolveSchemaContext(modules);
+ protected boolean getStartWithSchema() {
+ return true;
}
@After
public void afterTest() {
- log.info("BIDataStore Statistics: Configuration Read Count: {} TotalTime: {} ms AverageTime (ns): {} ms",
- dataStoreStats.getConfigurationReadCount(), dataStoreStats.getConfigurationReadTotalTime(),
- dataStoreStats.getConfigurationReadAverageTime());
-
- log.info("BIDataStore Statistics: Operational Read Count: {} TotalTime: {} ms AverageTime (ns): {} ms",
- dataStoreStats.getOperationalReadCount(), dataStoreStats.getOperationalReadTotalTime(),
- dataStoreStats.getOperationalReadAverageTime());
-
- log.info("BIDataStore Statistics: Request Commit Count: {} TotalTime: {} ms AverageTime (ns): {} ms",
- dataStoreStats.getRequestCommitCount(), dataStoreStats.getRequestCommitTotalTime(),
- dataStoreStats.getRequestCommitAverageTime());
+ testContext.logDataStoreStatistics();
}
}
--- /dev/null
+package org.opendaylight.controller.sal.binding.test.util;
+
+import java.util.concurrent.ExecutorService;
+
+import javassist.ClassPool;
+
+import org.opendaylight.controller.sal.core.api.data.DataStore;
+import org.opendaylight.controller.sal.dom.broker.impl.DataStoreStatsWrapper;
+import org.opendaylight.controller.sal.dom.broker.impl.HashMapDataStore;
+import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter;
+
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+
+public class BindingBrokerTestFactory {
+
+ private static final ClassPool CLASS_POOL = new ClassPool();
+ private boolean startWithParsedSchema = true;
+ private ExecutorService executor;
+ private ClassPool classPool;
+
+
+ public boolean isStartWithParsedSchema() {
+ return startWithParsedSchema;
+ }
+
+ public void setStartWithParsedSchema(boolean startWithParsedSchema) {
+ this.startWithParsedSchema = startWithParsedSchema;
+ }
+
+ public ExecutorService getExecutor() {
+ return executor;
+ }
+
+ public void setExecutor(ExecutorService executor) {
+ this.executor = executor;
+ }
+
+
+ public BindingTestContext getTestContext() {
+ Preconditions.checkState(executor != null, "Executor is not set.");
+ ListeningExecutorService listenableExecutor = MoreExecutors.listeningDecorator(executor);
+ return new BindingTestContext(listenableExecutor, getClassPool(),startWithParsedSchema);
+ }
+
+ public ClassPool getClassPool() {
+ if(classPool == null) {
+ return CLASS_POOL;
+ }
+
+ return classPool;
+ }
+
+ public void setClassPool(ClassPool classPool) {
+ this.classPool = classPool;
+ }
+
+}
--- /dev/null
+package org.opendaylight.controller.sal.binding.test.util;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import javassist.ClassPool;
+
+import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
+import org.opendaylight.controller.sal.binding.dom.serializer.impl.RuntimeGeneratedMappingServiceImpl;
+import org.opendaylight.controller.sal.binding.impl.DataBrokerImpl;
+import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentDataServiceConnector;
+import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService;
+import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
+import org.opendaylight.controller.sal.core.api.data.DataStore;
+import org.opendaylight.controller.sal.dom.broker.impl.DataStoreStatsWrapper;
+import org.opendaylight.controller.sal.dom.broker.impl.HashMapDataStore;
+import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+import org.reflections.Reflections;
+import org.reflections.scanners.ResourcesScanner;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Predicate;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+
+import static com.google.common.base.Preconditions.*;
+
+public class BindingTestContext {
+
+
+ public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier TREE_ROOT = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ .builder().toInstance();
+
+ private static final Logger LOG = LoggerFactory.getLogger(BindingTestContext.class);
+
+ private RuntimeGeneratedMappingServiceImpl mappingServiceImpl;
+ private DataBrokerImpl baDataImpl;
+ private org.opendaylight.controller.sal.dom.broker.DataBrokerImpl biDataImpl;
+
+ private BindingIndependentDataServiceConnector connectorServiceImpl;
+ private HashMapDataStore rawDataStore;
+ private SchemaAwareDataStoreAdapter schemaAwareDataStore;
+ private DataStoreStatsWrapper dataStoreStats;
+ private DataStore dataStore;
+
+
+ private boolean dataStoreStatisticsEnabled = false;
+
+ private final ListeningExecutorService executor;
+ private final ClassPool classPool;
+
+ private final boolean startWithSchema;
+
+ protected BindingTestContext(ListeningExecutorService executor, ClassPool classPool, boolean startWithSchema) {
+ this.executor = executor;
+ this.classPool = classPool;
+ this.startWithSchema = startWithSchema;
+ }
+
+ public void startDomDataStore() {
+ checkState(dataStore == null, "DataStore already started.");
+ checkState(biDataImpl != null, "Dom Data Broker not present");
+ rawDataStore = new HashMapDataStore();
+ schemaAwareDataStore = new SchemaAwareDataStoreAdapter();
+ schemaAwareDataStore.changeDelegate(rawDataStore);
+ if(dataStoreStatisticsEnabled) {
+ dataStoreStats = new DataStoreStatsWrapper(schemaAwareDataStore);
+ dataStore = dataStoreStats;
+ } else {
+ dataStore = schemaAwareDataStore;
+ }
+
+ biDataImpl.registerConfigurationReader(TREE_ROOT, dataStore);
+ biDataImpl.registerOperationalReader(TREE_ROOT, dataStore);
+ biDataImpl.registerCommitHandler(TREE_ROOT, dataStore);
+ }
+
+ public void startDomDataBroker() {
+ checkState(executor != null,"Executor needs to be set");
+ biDataImpl = new org.opendaylight.controller.sal.dom.broker.DataBrokerImpl();
+ biDataImpl.setExecutor(executor);
+ }
+
+ public void startBindingDataBroker() {
+ checkState(executor != null,"Executor needs to be set");
+ baDataImpl = new DataBrokerImpl();
+ baDataImpl.setExecutor(executor);
+ }
+
+ public void startBindingToDomDataConnector() {
+ checkState(baDataImpl != null,"Binding Data Broker needs to be started");
+ checkState(biDataImpl != null,"DOM Data Broker needs to be started.");
+ checkState(mappingServiceImpl != null,"DOM Mapping Service needs to be started.");
+ connectorServiceImpl = new BindingIndependentDataServiceConnector();
+ connectorServiceImpl.setBaDataService(baDataImpl);
+ connectorServiceImpl.setBiDataService(biDataImpl);
+ connectorServiceImpl.setMappingService(mappingServiceImpl);
+ connectorServiceImpl.start();
+ }
+
+ public void startBindingToDomMappingService() {
+ checkState(classPool != null,"ClassPool needs to be present");
+ mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl();
+ mappingServiceImpl.setPool(classPool);
+ mappingServiceImpl.start(null);
+ }
+
+
+ public void updateYangSchema(String[] files) {
+ SchemaContext context = getContext(files);
+ if(schemaAwareDataStore != null) {
+ schemaAwareDataStore.onGlobalContextUpdated(context);
+ }
+ if(mappingServiceImpl != null) {
+ mappingServiceImpl.onGlobalContextUpdated(context);
+ }
+ }
+
+
+ public static String[] getAllYangFilesOnClasspath() {
+ Predicate<String> predicate = new Predicate<String>() {
+ @Override
+ public boolean apply(String input) {
+ return input.endsWith(".yang");
+ }
+ };
+ Reflections reflection = new Reflections("META-INF.yang", new ResourcesScanner());
+ Set<String> result = reflection.getResources(predicate);
+ return (String[]) result.toArray(new String[result.size()]);
+ }
+
+ private static SchemaContext getContext(String[] yangFiles) {
+ ClassLoader loader = BindingTestContext.class.getClassLoader();
+ List<InputStream> streams = new ArrayList<>();
+ for (String string : yangFiles) {
+ InputStream stream = loader.getResourceAsStream(string);
+ streams.add(stream);
+ }
+ YangParserImpl parser = new YangParserImpl();
+ Set<Module> modules = parser.parseYangModelsFromStreams(streams);
+ return parser.resolveSchemaContext(modules);
+ }
+
+ public void start() {
+ startBindingDataBroker();
+ startDomDataBroker();
+ startDomDataStore();
+ startBindingToDomMappingService();
+ startBindingToDomDataConnector();
+ if(startWithSchema) {
+ loadYangSchemaFromClasspath();
+ }
+ }
+
+ public void loadYangSchemaFromClasspath() {
+ String[] files = getAllYangFilesOnClasspath();
+ updateYangSchema(files);
+ }
+
+ public DataProviderService getBindingDataBroker() {
+ return baDataImpl;
+ }
+
+ public org.opendaylight.controller.sal.core.api.data.DataProviderService getDomDataBroker() {
+ return biDataImpl;
+ }
+
+ public DataStore getDomDataStore() {
+ return dataStore;
+ }
+
+ public BindingIndependentMappingService getBindingToDomMappingService() {
+ return mappingServiceImpl;
+ }
+
+ public void logDataStoreStatistics() {
+ if(dataStoreStats == null) {
+ return;
+ }
+
+ LOG.info("BIDataStore Statistics: Configuration Read Count: {} TotalTime: {} ms AverageTime (ns): {} ms",
+ dataStoreStats.getConfigurationReadCount(), dataStoreStats.getConfigurationReadTotalTime(),
+ dataStoreStats.getConfigurationReadAverageTime());
+
+ LOG.info("BIDataStore Statistics: Operational Read Count: {} TotalTime: {} ms AverageTime (ns): {} ms",
+ dataStoreStats.getOperationalReadCount(), dataStoreStats.getOperationalReadTotalTime(),
+ dataStoreStats.getOperationalReadAverageTime());
+
+ LOG.info("BIDataStore Statistics: Request Commit Count: {} TotalTime: {} ms AverageTime (ns): {} ms",
+ dataStoreStats.getRequestCommitCount(), dataStoreStats.getRequestCommitTotalTime(),
+ dataStoreStats.getRequestCommitAverageTime());
+ }
+}
--- /dev/null
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-parent</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ </parent>
+ <artifactId>sal-binding-dom-it</artifactId>
+ <packaging>bundle</packaging>
+ <scm>
+ <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
+ <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
+ <url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
+ </scm>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.eclipse.xtend</groupId>
+ <artifactId>xtend-maven-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <artifactId>maven-clean-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.jacoco</groupId>
+ <artifactId>jacoco-maven-plugin</artifactId>
+ <configuration>
+ <includes>org.opendaylight.controller.*</includes>
+ </configuration>
+ <executions>
+ <execution>
+ <id>pre-test</id>
+ <goals>
+ <goal>prepare-agent</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>post-test</id>
+ <phase>test</phase>
+ <goals>
+ <goal>report</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-broker-impl</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-broker-impl</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller.model</groupId>
+ <artifactId>model-flow-service</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller.model</groupId>
+ <artifactId>model-flow-management</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ </dependency>
+ </dependencies>
+</project>
.toInstance();
private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
- @Override
- protected String[] getModelFilenames() {
- return null;
- }
-
/**
*
*
}
});
- SchemaContext ctx = getContext(getAllModelFilenames());
- schemaAwareDataStore.onGlobalContextUpdated(ctx);
- mappingServiceImpl.onGlobalContextUpdated(ctx);
+ testContext.loadYangSchemaFromClasspath();
RpcResult<TransactionStatus> result = future.get().get();
assertEquals(TransactionStatus.COMMITED, result.getResult());
return (Nodes) baDataService.readOperationalData(NODES_INSTANCE_ID_BA);
}
+
+ @Override
+ protected boolean getStartWithSchema() {
+ return false;
+ }
}
</pluginManagement>
</build>
+
<dependencies>
<dependency>
<groupId>org.opendaylight.yangtools.thirdparty</groupId>
}\r
\r
override readConfigurationData(P path) {\r
+ val local = this.updatedConfigurationData.get(path);\r
+ if(local != null) {\r
+ return local;\r
+ }\r
+ \r
return broker.readConfigurationData(path);\r
}\r
\r
override readOperationalData(P path) {\r
+ val local = this.updatedOperationalData.get(path);\r
+ if(local != null) {\r
+ return local;\r
+ }\r
return broker.readOperationalData(path);\r
}\r
\r
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.YangNode;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import com.google.common.base.Preconditions;
public class XmlMapper {
+
+ private final Logger logger = LoggerFactory.getLogger(XmlMapper.class);
public Document write(CompositeNode data, DataNodeContainer schema) throws UnsupportedDataTypeException {
Preconditions.checkNotNull(data);
} else { // CompositeNode
for (Node<?> child : ((CompositeNode) data).getChildren()) {
DataSchemaNode childSchema = findFirstSchemaForNode(child, ((DataNodeContainer) schema).getChildNodes());
- if (childSchema == null) {
- throw new UnsupportedDataTypeException("Probably the data node \""
- + child.getNodeType().getLocalName() + "\" is not conform to schema");
+ if (logger.isDebugEnabled()) {
+ if (childSchema == null) {
+ logger.debug("Probably the data node \"" + ((child == null) ? "" : child.getNodeType().getLocalName())
+ + "\" is not conform to schema");
+ }
}
itemEl.appendChild(translateToXmlAndReturnRootElement(doc, child, childSchema));
}
}
private DataSchemaNode findFirstSchemaForNode(Node<?> node, Set<DataSchemaNode> dataSchemaNode) {
- for (DataSchemaNode dsn : dataSchemaNode) {
- if (node.getNodeType().getLocalName().equals(dsn.getQName().getLocalName())) {
- return dsn;
- } else if (dsn instanceof ChoiceNode) {
- for (ChoiceCaseNode choiceCase : ((ChoiceNode) dsn).getCases()) {
- DataSchemaNode foundDsn = findFirstSchemaForNode(node, choiceCase.getChildNodes());
- if (foundDsn != null) {
- return foundDsn;
+ if (dataSchemaNode != null && node != null) {
+ for (DataSchemaNode dsn : dataSchemaNode) {
+ if (node.getNodeType().getLocalName().equals(dsn.getQName().getLocalName())) {
+ return dsn;
+ } else if (dsn instanceof ChoiceNode) {
+ for (ChoiceCaseNode choiceCase : ((ChoiceNode) dsn).getCases()) {
+ DataSchemaNode foundDsn = findFirstSchemaForNode(node, choiceCase.getChildNodes());
+ if (foundDsn != null) {
+ return foundDsn;
+ }
}
}
}
import java.util.Collection;
-import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
-import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.*;
+
+public class DummyRpcResult<T> implements RpcResult<T> {
-public class DummyRpcResult implements RpcResult<TransactionStatus> {
-
private final boolean isSuccessful;
- private final TransactionStatus result;
+ private final T result;
private final Collection<RpcError> errors;
-
+
public DummyRpcResult() {
isSuccessful = false;
result = null;
errors = null;
}
-
- private DummyRpcResult(Builder builder) {
+
+ private DummyRpcResult(Builder<T> builder) {
isSuccessful = builder.isSuccessful;
result = builder.result;
errors = builder.errors;
}
-
- public static Builder builder() {
- return new DummyRpcResult.Builder();
- }
@Override
public boolean isSuccessful() {
}
@Override
- public TransactionStatus getResult() {
+ public T getResult() {
return result;
}
public Collection<RpcError> getErrors() {
return errors;
}
-
- public static class Builder {
+
+ public static class Builder<T> {
private boolean isSuccessful;
- private TransactionStatus result;
+ private T result;
private Collection<RpcError> errors;
-
- public Builder isSuccessful(boolean isSuccessful) {
+
+ public Builder<T> isSuccessful(boolean isSuccessful) {
this.isSuccessful = isSuccessful;
return this;
}
-
- public Builder result(TransactionStatus result) {
+
+ public Builder<T> result(T result) {
this.result = result;
return this;
}
-
- public Builder errors(Collection<RpcError> errors) {
+
+ public Builder<T> errors(Collection<RpcError> errors) {
this.errors = errors;
return this;
}
-
- public RpcResult<TransactionStatus> build() {
- return new DummyRpcResult(this);
+
+ public RpcResult<T> build() {
+ return new DummyRpcResult<T>(this);
}
-
+
}
}
--- /dev/null
+package org.opendaylight.controller.sal.restconf.impl.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.net.*;
+import java.util.*;
+
+import org.junit.*;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.opendaylight.controller.sal.restconf.impl.*;
+import org.opendaylight.yangtools.yang.common.*;
+import org.opendaylight.yangtools.yang.data.api.*;
+import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+public class InvokeRpcMethodTest {
+
+ private static Set<Module> modules;
+
+ private class AnswerImpl implements Answer<RpcResult<CompositeNode>> {
+ @Override
+ public RpcResult<CompositeNode> answer(InvocationOnMock invocation) throws Throwable {
+ CompositeNode compNode = (CompositeNode) invocation.getArguments()[1];
+ return new DummyRpcResult.Builder<CompositeNode>().result(compNode).build();
+ }
+ }
+
+ @BeforeClass
+ public static void initialization() {
+ modules = TestUtils.resolveModules("/invoke-rpc");
+ assertEquals(1, modules.size());
+ Module module = TestUtils.resolveModule("invoke-rpc-module", modules);
+ assertNotNull(module);
+ }
+
+ /**
+ * Test method invokeRpc in RestconfImpl class tests if composite node as
+ * input parameter of method invokeRpc (second argument) is wrapped to
+ * parent composite node which has QName equals to QName of rpc (resolved
+ * from string - first argument).
+ */
+ @Test
+ public void invokeRpcMethodTest() {
+ ControllerContext contContext = ControllerContext.getInstance();
+ contContext.onGlobalContextUpdated(TestUtils.loadSchemaContext(modules));
+ try {
+ contContext.findModuleByNamespace(new URI("invoke:rpc:module"));
+ } catch (URISyntaxException e) {
+ assertTrue("Uri wasn't created sucessfuly", false);
+ }
+
+ BrokerFacade mockedBrokerFacade = mock(BrokerFacade.class);
+
+ RestconfImpl restconf = RestconfImpl.getInstance();
+ restconf.setBroker(mockedBrokerFacade);
+ restconf.setControllerContext(contContext);
+
+ when(mockedBrokerFacade.invokeRpc(any(QName.class), any(CompositeNode.class))).thenAnswer(new AnswerImpl());
+
+ StructuredData structData = restconf.invokeRpc("invoke-rpc-module:rpc-test", preparePayload());
+
+ CompositeNode rpcCompNode = structData.getData();
+ CompositeNode cont = null;
+ assertEquals("invoke:rpc:module", rpcCompNode.getNodeType().getNamespace().toString());
+ assertEquals("rpc-test", rpcCompNode.getNodeType().getLocalName());
+
+ for (Node<?> node : rpcCompNode.getChildren()) {
+ if (node.getNodeType().getLocalName().equals("cont")
+ && node.getNodeType().getNamespace().toString().equals("nmspc")) {
+ if (node instanceof CompositeNode) {
+ cont = (CompositeNode) node;
+ }
+ }
+ }
+ assertNotNull(cont);
+
+ }
+
+ private CompositeNode preparePayload() {
+ MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
+ TestUtils.buildQName("cont", "nmspc", "2013-12-04"), null, null, ModifyAction.CREATE, null);
+ MutableSimpleNode<?> lf = NodeFactory.createMutableSimpleNode(
+ TestUtils.buildQName("lf", "nmspc", "2013-12-04"), cont, "any value", ModifyAction.CREATE, null);
+ cont.getChildren().add(lf);
+ cont.init();
+
+ return cont;
+ }
+
+}
ControllerContext contContext = ControllerContext.getInstance();
contContext.setSchemas(loadSchemaContext(modules));
-
+
StructuredDataToJsonProvider structuredDataToJsonProvider = StructuredDataToJsonProvider.INSTANCE;
structuredDataToJsonProvider.writeTo(new StructuredData(compositeNode, dataSchemaNode), null, null, null, null,
null, byteArrayOS);
jsonResult = byteArrayOS.toString();
if (outputPath != null) {
- try {
+ try {
outputToFile(byteArrayOS, outputPath);
} catch (IOException e) {
System.out.println("Output file wasn't cloased sucessfuly.");
ControllerContext controllerContext = mock(ControllerContext.class);
BrokerFacade broker = mock(BrokerFacade.class);
- RpcResult<TransactionStatus> rpcResult = DummyRpcResult.builder().result(TransactionStatus.COMMITED).build();
+ RpcResult<TransactionStatus> rpcResult = new DummyRpcResult.Builder<TransactionStatus>().result(
+ TransactionStatus.COMMITED).build();
Future<RpcResult<TransactionStatus>> future = DummyFuture.builder().rpcResult(rpcResult).build();
when(controllerContext.toInstanceIdentifier(any(String.class))).thenReturn(instIdAndSchema);
when(broker.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(
package org.opendaylight.controller.sal.restconf.impl.test;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
import java.io.IOException;
-import java.util.Set;
-import javax.activation.UnsupportedDataTypeException;
import javax.ws.rs.WebApplicationException;
import org.junit.*;
-import org.opendaylight.yangtools.yang.model.api.*;
-public class ToJsonChoiceCaseTest {
-
- private static Set<Module> modules;
- private static DataSchemaNode dataSchemaNode;
+public class ToJsonChoiceCaseTest extends YangAndXmlAndDataSchemaLoader {
@BeforeClass
public static void initialization() {
- modules = TestUtils.resolveModules("/yang-to-json-conversion/choice");
- Module module = TestUtils.resolveModule(null, modules);
- dataSchemaNode = TestUtils.resolveDataSchemaNode(module, null);
-
+ dataLoad("/yang-to-json-conversion/choice");
}
/**
/**
* Test when some data are in one case node and other in another.
- * Additionally data are loadef from various choices. This isn't
- * correct. Next Json validator should return error because nodes has to be
- * from one case below concrete choice.
+ * Additionally data are loadef from various choices. This isn't correct.
+ * Next Json validator should return error because nodes has to be from one
+ * case below concrete choice.
*
*/
@Test
package org.opendaylight.controller.sal.restconf.impl.test;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import java.io.IOException;
-import java.util.Set;
import java.util.regex.*;
import javax.ws.rs.WebApplicationException;
import org.junit.*;
import org.opendaylight.yangtools.yang.data.api.*;
import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
-import org.opendaylight.yangtools.yang.model.api.*;
-public class ToJsonIdentityrefTest {
-
- private static Set<Module> modules;
- private static DataSchemaNode dataSchemaNode;
+public class ToJsonIdentityrefTest extends YangAndXmlAndDataSchemaLoader {
@BeforeClass
public static void initialization() {
- modules = TestUtils.resolveModules("/yang-to-json-conversion/identityref");
- assertEquals(2, modules.size());
- Module module = TestUtils.resolveModule("identityref-module", modules);
- assertNotNull(module);
- dataSchemaNode = TestUtils.resolveDataSchemaNode(module, "cont");
- assertNotNull(dataSchemaNode);
-
+ dataLoad("/yang-to-json-conversion/identityref", 2, "identityref-module", "cont");
}
@Test
package org.opendaylight.controller.sal.restconf.impl.test;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
-import java.util.Set;
import java.util.regex.Matcher;
import javax.ws.rs.WebApplicationException;
import org.junit.*;
-import org.opendaylight.yangtools.yang.model.api.*;
-public class ToJsonLeafrefType {
- private static Set<Module> modules;
- private static DataSchemaNode dataSchemaNode;
+public class ToJsonLeafrefType extends YangAndXmlAndDataSchemaLoader {
@BeforeClass
public static void initialization() {
- modules = TestUtils.resolveModules("/yang-to-json-conversion/leafref");
- assertEquals(2, modules.size());
- Module module = TestUtils.resolveModule("main-module", modules);
- assertNotNull(module);
- dataSchemaNode = TestUtils.resolveDataSchemaNode(module, "cont");
- assertNotNull(dataSchemaNode);
-
+ dataLoad("/yang-to-json-conversion/leafref", 2, "main-module", "cont");
}
@Test
@BeforeClass
public static void init() throws FileNotFoundException {
- Set<Module> allModules = TestUtils.loadModules(RestconfImplTest.class.getResource("/full-versions/yangs").getPath());
+ Set<Module> allModules = TestUtils.loadModules(RestconfImplTest.class.getResource("/full-versions/yangs")
+ .getPath());
SchemaContext schemaContext = TestUtils.loadSchemaContext(allModules);
controllerContext = ControllerContext.getInstance();
controllerContext.setSchemas(schemaContext);
@Test
public void testStructuredDataToXmlProvider() throws FileNotFoundException, UnsupportedEncodingException {
String uri = createUri("/datastore/", "ietf-interfaces:interfaces/interface/eth0");
-
+
InputStream xmlStream = RestconfImplTest.class.getResourceAsStream("/parts/ietf-interfaces_interfaces.xml");
CompositeNode loadedCompositeNode = TestUtils.loadCompositeNode(xmlStream);
when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(loadedCompositeNode);
-
+
Response response = target(uri).request(MEDIA_TYPE).get();
assertEquals(200, response.getStatus());
}
@Test
public void testBadFormatXmlToCompositeNodeProvider() throws UnsupportedEncodingException, URISyntaxException {
String uri = createUri("/operations/", "ietf-interfaces:interfaces/interface/eth0");
-
+
Response response = target(uri).request(Draft01.MediaTypes.DATA + RestconfService.XML).post(
Entity.entity("<SimpleNode/>", MEDIA_TYPE));
assertEquals(400, response.getStatus());
-
+
response = target(uri).request(Draft01.MediaTypes.DATA + RestconfService.XML).post(
Entity.entity("<SimpleNode>", MEDIA_TYPE));
assertEquals(400, response.getStatus());
}
-
+
@Test
public void testXmlToCompositeNode404NotFound() throws UnsupportedEncodingException, URISyntaxException {
String uri = createUri("/datastore/", "ietf-interfaces:interfaces/interface/eth0");
-
+
when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(null);
-
- Response response = target(uri).request(Draft01.MediaTypes.DATA+RestconfService.XML).get();
+
+ Response response = target(uri).request(Draft01.MediaTypes.DATA + RestconfService.XML).get();
assertEquals(404, response.getStatus());
}
-
+
@Test
public void testXmlToCompositeNode400() throws UnsupportedEncodingException, URISyntaxException {
String uri = createUri("/datastore/", "simple-nodes:user/name");
-
+
when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(null);
-
- Response response = target(uri).request(Draft01.MediaTypes.DATA+RestconfService.XML).get();
+
+ Response response = target(uri).request(Draft01.MediaTypes.DATA + RestconfService.XML).get();
assertEquals(400, response.getStatus());
}
-
+
@Test
public void testRpcResultCommitedToStatusCodes() throws UnsupportedEncodingException {
InputStream xmlStream = RestconfImplTest.class.getResourceAsStream("/parts/ietf-interfaces_interfaces.xml");
String xml = TestUtils.getDocumentInPrintableForm(TestUtils.loadDocumentFrom(xmlStream));
Entity<String> entity = Entity.entity(xml, MEDIA_TYPE_DRAFT02);
- RpcResult<TransactionStatus> rpcResult = DummyRpcResult.builder().result(TransactionStatus.COMMITED).build();
+ RpcResult<TransactionStatus> rpcResult = new DummyRpcResult.Builder<TransactionStatus>().result(
+ TransactionStatus.COMMITED).build();
Future<RpcResult<TransactionStatus>> dummyFuture = DummyFuture.builder().rpcResult(rpcResult).build();
- when(brokerFacade.commitOperationalDataPut(any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
- when(brokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
-
+ when(brokerFacade.commitOperationalDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ .thenReturn(dummyFuture);
+ when(brokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ .thenReturn(dummyFuture);
+
String uri = createUri("/config/", "ietf-interfaces:interfaces/interface/eth0");
Response response = target(uri).request(MEDIA_TYPE_DRAFT02).put(entity);
assertEquals(204, response.getStatus());
response = target(uri).request(MEDIA_TYPE_DRAFT02).post(entity);
assertEquals(200, response.getStatus());
-
+
uri = createUri("/config/", "ietf-interfaces:interfaces/interface/eth0");
response = target(uri).request(MEDIA_TYPE_DRAFT02).put(entity);
assertEquals(204, response.getStatus());
response = target(uri).request(MEDIA_TYPE_DRAFT02).post(entity);
assertEquals(200, response.getStatus());
-
+
uri = createUri("/datastore/", "ietf-interfaces:interfaces/interface/eth0");
response = target(uri).request(MEDIA_TYPE).put(entity);
assertEquals(204, response.getStatus());
response = target(uri).request(MEDIA_TYPE).post(entity);
assertEquals(200, response.getStatus());
}
-
+
@Test
public void testRpcResultOtherToStatusCodes() throws UnsupportedEncodingException {
InputStream xmlStream = RestconfImplTest.class.getResourceAsStream("/parts/ietf-interfaces_interfaces.xml");
String xml = TestUtils.getDocumentInPrintableForm(TestUtils.loadDocumentFrom(xmlStream));
Entity<String> entity = Entity.entity(xml, MEDIA_TYPE_DRAFT02);
- RpcResult<TransactionStatus> rpcResult = DummyRpcResult.builder().result(TransactionStatus.FAILED).build();
+ RpcResult<TransactionStatus> rpcResult = new DummyRpcResult.Builder<TransactionStatus>().result(
+ TransactionStatus.FAILED).build();
Future<RpcResult<TransactionStatus>> dummyFuture = DummyFuture.builder().rpcResult(rpcResult).build();
- when(brokerFacade.commitOperationalDataPut(any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
- when(brokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
-
+ when(brokerFacade.commitOperationalDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ .thenReturn(dummyFuture);
+ when(brokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ .thenReturn(dummyFuture);
+
String uri = createUri("/config/", "ietf-interfaces:interfaces/interface/eth0");
Response response = target(uri).request(MEDIA_TYPE_DRAFT02).put(entity);
assertEquals(500, response.getStatus());
response = target(uri).request(MEDIA_TYPE_DRAFT02).post(entity);
assertEquals(500, response.getStatus());
-
+
uri = createUri("/config/", "ietf-interfaces:interfaces/interface/eth0");
response = target(uri).request(MEDIA_TYPE_DRAFT02).put(entity);
assertEquals(500, response.getStatus());
response = target(uri).request(MEDIA_TYPE_DRAFT02).post(entity);
assertEquals(500, response.getStatus());
-
+
uri = createUri("/datastore/", "ietf-interfaces:interfaces/interface/eth0");
response = target(uri).request(MEDIA_TYPE).put(entity);
assertEquals(500, response.getStatus());
response = target(uri).request(MEDIA_TYPE).post(entity);
assertEquals(500, response.getStatus());
}
-
+
private String createUri(String prefix, String encodedPart) throws UnsupportedEncodingException {
return URI.create(prefix + URLEncoder.encode(encodedPart, Charsets.US_ASCII.name()).toString()).toASCIIString();
}
enable(TestProperties.DUMP_ENTITY);
enable(TestProperties.RECORD_LOG_LEVEL);
set(TestProperties.RECORD_LOG_LEVEL, Level.ALL.intValue());
-
+
ResourceConfig resourceConfig = new ResourceConfig();
- resourceConfig = resourceConfig.registerInstances(restconfImpl, StructuredDataToXmlProvider.INSTANCE, XmlToCompositeNodeProvider.INSTANCE);
+ resourceConfig = resourceConfig.registerInstances(restconfImpl, StructuredDataToXmlProvider.INSTANCE,
+ XmlToCompositeNodeProvider.INSTANCE);
return resourceConfig;
}
--- /dev/null
+package org.opendaylight.controller.sal.restconf.impl.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.Set;
+import org.opendaylight.yangtools.yang.model.api.*;
+
+public abstract class YangAndXmlAndDataSchemaLoader {
+
+ protected static Set<Module> modules;
+ protected static DataSchemaNode dataSchemaNode;
+
+ protected static void dataLoad(String yangPath) {
+ dataLoad(yangPath, 1, null, null);
+ }
+
+ protected static void dataLoad(String yangPath, int modulesNumber, String moduleName, String dataSchemaName) {
+ modules = TestUtils.resolveModules(yangPath);
+ assertEquals(modulesNumber, modules.size());
+ Module module = TestUtils.resolveModule(moduleName, modules);
+ assertNotNull(module);
+ dataSchemaNode = TestUtils.resolveDataSchemaNode(module, dataSchemaName);
+ assertNotNull(dataSchemaNode);
+ }
+
+}
--- /dev/null
+module invoke-rpc-module {
+ namespace "invoke:rpc:module";
+
+ prefix "inrpcmod";
+
+ revision 2013-12-3 {
+
+ }
+
+ rpc rpc-test {
+ input {
+ container cont {
+ leaf lf {
+ type string;
+ }
+ }
+ }
+ }
+
+}
\ No newline at end of file
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GetAllGroupStatisticsInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GetAllGroupStatisticsOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GetGroupDescriptionInputBuilder;
return;
for (Node targetNode : targetNodes){
-
-
- //We need to add check, so see if groups/meters are supported
- //by the target node. Below check doesn't look good.
- if(targetNode.getId().getValue().contains("openflow:")){
+
+ if(targetNode.getAugmentation(FlowCapableNode.class) != null){
+
spLogger.info("Send request for stats collection to node : {})",targetNode.getId());
+
InstanceIdentifier<Node> targetInstanceId = InstanceIdentifier.builder(Nodes.class).child(Node.class,targetNode.getKey()).toInstance();
NodeRef targetNodeRef = new NodeRef(targetInstanceId);
//Update augmented data
nodeData.addAugmentation(NodeGroupDescStats.class, groupDesc.build());
-
+
InstanceIdentifier<? extends Object> refValue = ref.getValue();
it.putOperationalData(refValue, nodeData.build());
it.commit();
DataModificationTransaction it = this.statisticsManager.startChange();
NodeKey key = new NodeKey(notification.getId());
NodeRef ref = getNodeRef(key);
-
+
final NodeBuilder nodeData = new NodeBuilder();
nodeData.setKey(key);
GroupStatisticsBuilder stats = new GroupStatisticsBuilder();
stats.setGroupStats(notification.getGroupStats());
groupStats.setGroupStatistics(stats.build());
-
+
//Update augmented data
nodeData.addAugmentation(NodeGroupStatistics.class, groupStats.build());
-
+
InstanceIdentifier<? extends Object> refValue = ref.getValue();
it.putOperationalData(refValue, nodeData.build());
it.commit();
+
+// for (GroupStats groupstat : notification.getGroupStats()) {
+//
+// GroupStatsKey groupKey = groupstat.getKey();
+// InstanceIdentifier<? extends Object> id = InstanceIdentifier.builder(Nodes.class).child(Node.class, key).augmentation(NodeGroupStatistics.class).child(GroupStatistics.class).child(GroupStats.class,groupKey).toInstance();
+// it.putOperationalData(id, groupstat);
+// it.commit();
+// }
}
@Override
</Export-Package>
<Import-Package>
com.google.common.base,
- com.google.common.collect,
ch.ethz.ssh2,
ch.ethz.ssh2.signature,
- io.netty.buffer,
- io.netty.channel,
- io.netty.channel.nio,
- io.netty.channel.socket,
- io.netty.util,
- io.netty.util.concurrent,
- javax.annotation,
java.net,
- javax.net.ssl,
- javax.xml.namespace,
- javax.xml.parsers,
- javax.xml.xpath,
+ javax.annotation,
org.apache.commons.io,
- org.opendaylight.controller.netconf.api,
- org.opendaylight.controller.netconf.client,
org.opendaylight.controller.netconf.util,
org.opendaylight.controller.netconf.util.osgi,
- org.opendaylight.controller.netconf.util.xml,
org.opendaylight.protocol.framework,
org.osgi.framework,
- org.slf4j,
- org.w3c.dom,
- org.xml.sax
+ org.slf4j
</Import-Package>
</instructions>
</configuration>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.5.1-SNAPSHOT</version>
+ <version>0.7.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.codehaus.enunciate</groupId>
* },
* "activeCount": "11",
* "lookupCount": "816",
- * "matchedCount": "220"
+ * "matchedCount": "220",
+ * "maximumEntries": "1000"
* },
* {
* ...another table
* <activeCount>12</activeCount>
* <lookupCount>10935</lookupCount>
* <matchedCount>10084</matchedCount>
+ * <maximumEntries>1000</maximumEntries>
* </tableStatistic>
* <tableStatistic>
* <nodeTable>
* <activeCount>0</activeCount>
* <lookupCount>0</lookupCount>
* <matchedCount>0</matchedCount>
+ * <maximumEntries>0</maximumEntries>
* </tableStatistic>
* <tableStatistic>
* <nodeTable>
* <activeCount>0</activeCount>
* <lookupCount>0</lookupCount>
* <matchedCount>0</matchedCount>
+ * <maximumEntries>0</maximumEntries>
* </tableStatistic>
* </tableStatistics>
* <tableStatistics>
* },
* "activeCount": "12",
* "lookupCount": "11382",
- * "matchedCount": "10524"
+ * "matchedCount": "10524",
+ * "maximumEntries": "1000"
* },
* {
* "nodeTable": {
* },
* "activeCount": "0",
* "lookupCount": "0",
- * "matchedCount": "0"
+ * "matchedCount": "0",
+ * "maximumEntries": "0"
* }
* ]
* }
* <activeCount>12</activeCount>
* <lookupCount>10935</lookupCount>
* <matchedCount>10084</matchedCount>
+ * <maximumEntries>1000</maximumEntries>
* </tableStatistic>
* <tableStatistic>
* <nodeTable>
* <activeCount>0</activeCount>
* <lookupCount>0</lookupCount>
* <matchedCount>0</matchedCount>
+ * <maximumEntries>0</maximumEntries>
* </tableStatistic>
* <tableStatistic>
* <nodeTable>
* <activeCount>0</activeCount>
* <lookupCount>0</lookupCount>
* <matchedCount>0</matchedCount>
+ * <maximumEntries>0</maximumEntries>
* </tableStatistic>
* </nodeTableStatistics>
*
import org.openflow.protocol.action.OFActionDataLayer;
import org.openflow.protocol.action.OFActionDataLayerDestination;
import org.openflow.protocol.action.OFActionDataLayerSource;
+import org.openflow.protocol.action.OFActionEnqueue;
import org.openflow.protocol.action.OFActionNetworkLayerAddress;
import org.openflow.protocol.action.OFActionNetworkLayerDestination;
import org.openflow.protocol.action.OFActionNetworkLayerSource;
actionsLength += OFActionOutput.MINIMUM_LENGTH;
continue;
}
+ if (action.getType() == ActionType.ENQUEUE) {
+ Enqueue a = (Enqueue) action;
+ OFActionEnqueue ofAction = new OFActionEnqueue();
+ ofAction.setPort(PortConverter.toOFPort(a.getPort()));
+ ofAction.setQueueId(a.getQueue());
+ actionsList.add(ofAction);
+ actionsLength += OFActionEnqueue.MINIMUM_LENGTH;
+ continue;
+ }
if (action.getType() == ActionType.DROP) {
continue;
}
NodeConnectorCreator.createOFNodeConnector(
ofPort, node));
}
+ } else if (ofAction instanceof OFActionEnqueue) {
+ salAction = new Enqueue(NodeConnectorCreator.createOFNodeConnector(
+ ((OFActionEnqueue) ofAction).getPort(), node),
+ ((OFActionEnqueue) ofAction).getQueueId());
} else if (ofAction instanceof OFActionVirtualLanIdentifier) {
salAction = new SetVlanId(
((OFActionVirtualLanIdentifier) ofAction)
ntStat.setActiveCount(ofTableStat.getActiveCount());
ntStat.setLookupCount(ofTableStat.getLookupCount());
ntStat.setMatchedCount(ofTableStat.getMatchedCount());
+ ntStat.setMaximumEntries(ofTableStat.getMaximumEntries());
this.ntStatsList.add(ntStat);
}
}
private static final long serialVersionUID = 1L;
@XmlElement
private NodeConnector port;
+ @XmlElement
+ private int queue;
/* Dummy constructor for JAXB */
@SuppressWarnings("unused")
public Enqueue(NodeConnector port) {
type = ActionType.ENQUEUE;
this.port = port;
+ this.queue = 0;
+ }
+
+ public Enqueue(NodeConnector port, int queue) {
+ type = ActionType.ENQUEUE;
+ this.port = port;
+ this.queue = queue;
}
public NodeConnector getPort() {
return port;
}
+
+ public int getQueue() {
+ return queue;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("%s[%s:%s]", type, port, queue);
+ }
}
private long lookupCount;
@XmlElement
private long matchedCount;
+ @XmlElement
+ private int maximumEntries;
@Override
this.matchedCount = matchedCount;
}
+ /**
+ * @return the maximumEntries
+ */
+ public long getMaximumEntries() {
+ return maximumEntries;
+ }
+
+ /**
+ * @param maximumEntries the maximumEntries to set
+ */
+ public void setMaximumEntries(int maximumEntries) {
+ this.maximumEntries = maximumEntries;
+ }
+
@Override
public String toString() {
return "NodeTableStats[tableId = " + nodeTable
if (node.getType().equals(NodeIDType.OPENFLOW)) {
try {
return new NodeConnector(NodeConnectorIDType.OPENFLOW,
- (Short) portId, node);
+ portId, node);
} catch (ConstructionException e1) {
logger.error("",e1);
return null;
return null;
}
+ /**
+ * Generic NodeConnector creator
+ * The nodeConnector type is inferred from the node type
+ *
+ * @param portId The string representing the port id
+ * @param node The network node as {@link org.opendaylight.controller.sal.core.Node Node} object
+ * @return The corresponding {@link org.opendaylight.controller.sal.core.NodeConnector NodeConnector} object
+ */
+ public static NodeConnector createNodeConnector(String portId, Node node) {
+ return NodeConnector.fromString(String.format("%s|%s@%s", node.getType(), portId, node.toString()));
+ }
+
/**
* NodeConnector creator where NodeConnector type can be specified
* Needed to create special internal node connectors (like software stack)
* @return true if the Status code is {@code StatusCode.SUCCESS}
*/
public boolean isSuccess() {
- return code == StatusCode.SUCCESS;
+ return code == StatusCode.SUCCESS || code == StatusCode.CREATED;
}
/**
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
Status other = (Status) obj;
- if (code != other.code)
+ if (code != other.code) {
return false;
+ }
return true;
}
}
*/
public enum StatusCode {
SUCCESS("Success"),
+ CREATED("Created"),
BADREQUEST("Bad Request"),
UNAUTHORIZED("UnAuthorized"),
ntStats.setActiveCount(100);
ntStats.setLookupCount(200);
ntStats.setMatchedCount(500);
+ ntStats.setMaximumEntries(1000);
ntStats.setName("Test");
Assert.assertTrue(ntStats.getNodeTable().equals(nt));
Assert.assertTrue(ntStats.getActiveCount() == 100);
Assert.assertTrue(ntStats.getLookupCount() == 200);
Assert.assertTrue(ntStats.getMatchedCount() == 500);
+ Assert.assertTrue(ntStats.getMaximumEntries() == 1000);
Assert.assertTrue(ntStats.getName().equals("Test"));
}
}
po = e.getValue();
if (po != null) {
// Populate the Policy field now
- Status poStatus = this.frm.installFlowEntry(po);
+ Status poStatus = this.frm.modifyOrAddFlowEntry(po);
if (!poStatus.isSuccess()) {
log.error("Failed to install policy: "
+ po.getGroupName() + " ("
@Override
public void notifyNode(Node node, UpdateType type,
Map<String, Property> propMap) {
- if (node == null)
+ if (node == null) {
return;
+ }
switch (type) {
case REMOVED:
@Override
public void notifyNodeConnector(NodeConnector nodeConnector,
UpdateType type, Map<String, Property> propMap) {
- if (nodeConnector == null)
+ if (nodeConnector == null) {
return;
+ }
boolean up = false;
switch (type) {
Code Review / controller.git / commitdiff