<controller.config.version>0.2.3-SNAPSHOT</controller.config.version>
<ietf.types.version>2010.09.24.2-SNAPSHOT</ietf.types.version>
<ietf.topology.version>2013.10.21.0-SNAPSHOT</ietf.topology.version>
+ <yang-ext.version>2013.09.07.1-SNAPSHOT</yang-ext.version>
</properties>
<dependencyManagement>
<version>1.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-util</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ </dependency>
<!-- Models -->
<dependency>
<artifactId>ietf-topology-ospf</artifactId>
<version>${ietf.topology.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>yang-ext</artifactId>
+ <version>${yang-ext.version}</version>
+ </dependency>
</dependencies>
</dependencyManagement>
<maven>3.0.4</maven>
</prerequisites>
+ <repositories>
+ <repository>
+ <id>opendaylight-mirror</id>
+ <name>opendaylight-mirror</name>
+ <url>${nexusproxy}/groups/public/</url>
+ <snapshots>
+ <enabled>false</enabled>
+ </snapshots>
+ <releases>
+ <enabled>true</enabled>
+ <updatePolicy>never</updatePolicy>
+ </releases>
+ </repository>
+ </repositories>
+
<properties>
<exam.version>3.3.0</exam.version>
<url.version>1.6.0</url.version>
<felix.version>4.2.1</felix.version>
+ <antlr.version>4.0</antlr.version>
+ <yang-concepts.version>0.1.1-SNAPSHOT</yang-concepts.version>
+ <xtend-lib-osgi.version>2.4.3</xtend-lib-osgi.version>
+ <logback-classic.version>1.0.9</logback-classic.version>
+ <moxy.controller.version>2.5.0</moxy.controller.version>
</properties>
- <dependencies>
+
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.ops4j.pax.exam</groupId>
+ <artifactId>maven-paxexam-plugin</artifactId>
+ <version>1.2.4</version>
+ <executions>
+ <execution>
+ <id>generate-config</id>
+ <goals>
+ <goal>generate-depends-file</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+
+ <!--This plugin's configuration is used to store Eclipse
+ m2e settings only. It has no influence on the Maven build itself. -->
+ <plugin>
+ <groupId>org.eclipse.m2e</groupId>
+ <artifactId>lifecycle-mapping</artifactId>
+ <version>1.0.0</version>
+ <configuration>
+ <lifecycleMappingMetadata>
+ <pluginExecutions>
+ <pluginExecution>
+ <pluginExecutionFilter>
+ <groupId>
+ org.ops4j.pax.exam
+ </groupId>
+ <artifactId>
+ maven-paxexam-plugin
+ </artifactId>
+ <versionRange>
+ [1.2.4,)
+ </versionRange>
+ <goals>
+ <goal>
+ generate-depends-file
+ </goal>
+ </goals>
+ </pluginExecutionFilter>
+ <action>
+ <ignore></ignore>
+ </action>
+ </pluginExecution>
+ </pluginExecutions>
+ </lifecycleMappingMetadata>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller.thirdparty</groupId>
+ <artifactId>exificient</artifactId>
+ <version>0.9.2-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>ch.qos.logback</groupId>
+ <artifactId>logback-classic</artifactId>
+ <version>${logback-classic.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>logback-config</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-manager</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-netconf-connector</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>yang-jmx-generator</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>netconf-monitoring</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>netconf-impl</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>ietf-netconf-monitoring</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>yang-store-impl</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-persister-impl</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-persister-file-xml-adapter</artifactId>
+ <version>${controller.config.version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.eclipse.persistence</groupId>
+ <artifactId>org.eclipse.persistence.moxy</artifactId>
+ <version>${moxy.controller.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.eclipse.persistence</groupId>
+ <artifactId>org.eclipse.persistence.core</artifactId>
+ <version>${moxy.controller.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.thirdparty</groupId>
+ <artifactId>antlr4-runtime-osgi-nohead</artifactId>
+ <version>${antlr.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>mockito-configuration</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>pcep-topology-api</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
- <artifactId>bgp-parser-mock</artifactId>
+ <artifactId>pcep-tunnel-api</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>pcep-api</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>topology-api</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>programming-topology-api</artifactId>
+ <version>${project.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>bgp-parser-mock</artifactId>
<version>${project.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-broker-impl</artifactId>
+ <exclusions>
+ <exclusion>
+ <groupId>xml-apis</groupId>
+ <artifactId>xml-apis</artifactId>
+ </exclusion>
+ </exclusions>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-util</artifactId>
+ <scope>test</scope>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<dependency>
<groupId>org.opendaylight.yangtools.thirdparty</groupId>
<artifactId>xtend-lib-osgi</artifactId>
- <version>2.4.3</version>
+ <version>${xtend-lib-osgi.version}</version>
<scope>test</scope>
</dependency>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>org.apache.felix</groupId>
- <artifactId>org.apache.felix.framework</artifactId>
- <version>${felix.version}</version>
+ <groupId>equinoxSDK381</groupId>
+ <artifactId>org.eclipse.osgi</artifactId>
+ <version>3.8.1.v20120830-144521</version>
<scope>test</scope>
</dependency>
<dependency>
private List<Option> coreBundles() {
final List<Option> ret = new ArrayList<>();
- ret.add(mavenBundle("ch.qos.logback", "logback-classic", "1.0.9"));
- ret.add(mavenBundle("ch.qos.logback", "logback-core", "1.0.9"));
- ret.add(mavenBundle("com.google.guava", "guava", "14.0.1"));
- ret.add(mavenBundle("commons-codec", "commons-codec", "1.7"));
- ret.add(mavenBundle("io.netty", "netty-buffer", "4.0.9.Final"));
- ret.add(mavenBundle("io.netty", "netty-codec", "4.0.9.Final"));
- ret.add(mavenBundle("io.netty", "netty-common", "4.0.9.Final"));
- ret.add(mavenBundle("io.netty", "netty-transport", "4.0.9.Final"));
- ret.add(mavenBundle("org.slf4j", "slf4j-api", "1.7.2"));
-
- ret.add(mavenBundle("org.opendaylight.yangtools", "concepts", "0.6.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.yangtools", "yang-binding", "0.6.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.yangtools", "yang-common", "0.6.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.yangtools.model", "ietf-inet-types", "2010.09.24.2-SNAPSHOT"));
-
- ret.add(mavenBundle("org.javassist", "javassist", "3.17.1-GA"));
- ret.add(mavenBundle("org.opendaylight.controller", "config-api", "0.2.3-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.controller", "protocol-framework", "0.4.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.controller", "sal-common-api", "1.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.controller", "sal-binding-api", "1.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.controller", "sal-binding-broker-impl", "1.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.controller", "sal-binding-config", "1.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.controller", "sal-common", "1.0-SNAPSHOT"));
- ret.add(mavenBundle("org.opendaylight.yangtools.thirdparty", "xtend-lib-osgi", "2.4.3"));
+ ret.add(mavenBundle("com.google.guava", "guava").versionAsInProject());
+ ret.add(mavenBundle("commons-codec", "commons-codec").versionAsInProject());
+
+ ret.add(TestHelper.getNettyBundles());
+ ret.add(TestHelper.getLoggingBundles());
+
+ ret.add(mavenBundle("org.opendaylight.yangtools", "concepts").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.yangtools", "yang-binding").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.yangtools", "yang-common").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.yangtools.model", "ietf-inet-types").versionAsInProject());
+
+ ret.add(mavenBundle("org.javassist", "javassist").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "config-api").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "protocol-framework").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "sal-common-api").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "sal-binding-api").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "sal-binding-broker-impl").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "sal-binding-config").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.controller", "sal-common").versionAsInProject());
+ ret.add(mavenBundle("org.opendaylight.yangtools.thirdparty", "xtend-lib-osgi").versionAsInProject());
return ret;
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.integration;
+
+import org.ops4j.pax.exam.Option;
+import org.ops4j.pax.exam.options.DefaultCompositeOption;
+import org.ops4j.pax.exam.util.PathUtils;
+
+import static org.ops4j.pax.exam.CoreOptions.frameworkProperty;
+import static org.ops4j.pax.exam.CoreOptions.junitBundles;
+import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
+import static org.ops4j.pax.exam.CoreOptions.systemProperty;
+
+public class TestHelper {
+
+ public static final String CONTROLLER = "org.opendaylight.controller";
+ public static final String YANGTOOLS = "org.opendaylight.yangtools";
+ public static final String CONTROLLER_MODELS = "org.opendaylight.controller.model";
+ public static final String YANGTOOLS_MODELS = "org.opendaylight.yangtools.model";
+
+ public static Option mdSalCoreBundles() {
+ return new DefaultCompositeOption( //
+ mavenBundle(YANGTOOLS, "concepts").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "yang-binding").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "yang-common").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-common").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-common-api").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-common-impl").versionAsInProject(), // //
+
+ mavenBundle("org.apache.commons", "commons-lang3").versionAsInProject(), //
+ mavenBundle("com.google.guava", "guava").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS + ".thirdparty", "xtend-lib-osgi").versionAsInProject() //
+ );
+ }
+
+ public static Option configMinumumBundles() {
+ return new DefaultCompositeOption(
+ mavenBundle("org.opendaylight.controller", "protocol-framework").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "util").versionAsInProject(), //
+ mavenBundle("commons-codec", "commons-codec").versionAsInProject(),
+
+ mavenBundle(CONTROLLER, "config-api").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "config-manager").versionAsInProject(), // //
+ mavenBundle("commons-io", "commons-io").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "config-api").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "config-manager").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "yang-jmx-generator").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "yang-store-api").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "yang-store-impl").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "logback-config").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "config-persister-api").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "netconf-api").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "ietf-netconf-monitoring").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "ietf-netconf-monitoring-extension").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "netconf-monitoring").versionAsInProject(), //
+
+ mavenBundle(CONTROLLER, "netconf-client").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "netconf-util").versionAsInProject(), //
+ mavenBundle(CONTROLLER + ".thirdparty", "ganymed", "1.0-SNAPSHOT"), //
+ mavenBundle(CONTROLLER, "netconf-mapping-api").versionAsInProject(), //
+
+ mavenBundle(CONTROLLER, "config-persister-impl").versionAsInProject(), //
+
+ getNettyBundles(), //
+
+ mavenBundle("org.opendaylight.controller.thirdparty", "exificient").versionAsInProject(), //
+
+ mavenBundle("org.apache.servicemix.bundles", "org.apache.servicemix.bundles.xerces", "2.11.0_1"),
+ mavenBundle("org.eclipse.birt.runtime.3_7_1", "org.apache.xml.resolver", "1.2.0"),
+
+ mavenBundle(CONTROLLER, "config-netconf-connector").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "netconf-impl").versionAsInProject(), //
+
+ mavenBundle(CONTROLLER, "config-persister-file-xml-adapter").versionAsInProject().noStart(),
+ mavenBundle("org.eclipse.persistence", "org.eclipse.persistence.moxy").versionAsInProject(),
+ mavenBundle("org.eclipse.persistence", "org.eclipse.persistence.core").versionAsInProject());
+
+ }
+
+ public static DefaultCompositeOption getNettyBundles() {
+ return new DefaultCompositeOption(
+ mavenBundle("io.netty", "netty-handler").versionAsInProject(), //
+ mavenBundle("io.netty", "netty-codec").versionAsInProject(), //
+ mavenBundle("io.netty", "netty-buffer").versionAsInProject(), //
+ mavenBundle("io.netty", "netty-transport").versionAsInProject(), //
+ mavenBundle("io.netty", "netty-common").versionAsInProject());
+ }
+
+ public static DefaultCompositeOption getLoggingBundles() {
+ return new DefaultCompositeOption(
+ mavenBundle("org.slf4j", "slf4j-api").versionAsInProject(), //
+ mavenBundle("ch.qos.logback", "logback-core").versionAsInProject(), //
+ mavenBundle("ch.qos.logback", "logback-classic").versionAsInProject());
+ }
+
+ public static Option bindingAwareSalBundles() {
+ return new DefaultCompositeOption( //
+ mavenBundle(CONTROLLER, "sal-binding-api").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-binding-config").versionAsInProject(), //
+ mavenBundle(CONTROLLER, "sal-binding-broker-impl").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-binding-util").versionAsInProject(), // //
+ mavenBundle("org.javassist", "javassist").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-common-util").versionAsInProject(), // //
+
+ mavenBundle(YANGTOOLS, "yang-data-api").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "yang-data-impl").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "yang-model-api").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "yang-model-util").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "yang-parser-api").versionAsInProject(), //
+ mavenBundle(YANGTOOLS, "yang-parser-impl").versionAsInProject(),
+
+ mavenBundle(YANGTOOLS, "binding-generator-spi").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "binding-model-api").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS, "binding-generator-util").versionAsInProject(), //
+ mavenBundle(YANGTOOLS, "yang-parser-impl").versionAsInProject(), //
+ mavenBundle(YANGTOOLS, "binding-type-provider").versionAsInProject(), //
+ mavenBundle(YANGTOOLS, "binding-generator-api").versionAsInProject(), mavenBundle(YANGTOOLS,
+ "binding-generator-spi").versionAsInProject(), //
+ mavenBundle(YANGTOOLS, "binding-generator-impl").versionAsInProject(),
+
+ mavenBundle(CONTROLLER, "sal-core-api").versionAsInProject().update(), //
+ mavenBundle(CONTROLLER, "sal-broker-impl").versionAsInProject(), // //
+ mavenBundle(CONTROLLER, "sal-core-spi").versionAsInProject().update(), //
+
+ mavenBundle(YANGTOOLS + ".thirdparty", "antlr4-runtime-osgi-nohead").versionAsInProject(), // //
+
+ systemProperty("netconf.tcp.address").value("0.0.0.0"), //
+ systemProperty("netconf.tcp.port").value("18383"), //
+ systemProperty("netconf.tcp.client.address").value("127.0.0.1"), //
+ systemProperty("netconf.tcp.client.port").value("18383"), //
+ systemProperty("netconf.config.persister.active").value("1"), //
+ systemProperty("netconf.config.persister.1.storageAdapterClass").value(
+ "org.opendaylight.controller.config.persist.storage.file.xml.XmlFileStorageAdapter"), //
+ systemProperty("netconf.config.persister.1.properties.fileStorage").value(
+ PathUtils.getBaseDir() + "/src/test/resources/config/controller.xml"), //
+ systemProperty("netconf.config.persister.1.properties.numberOfBackups").value("1") //
+ // systemProperty("yangstore.blacklist").value(".*controller.model.*")
+ );
+
+ }
+
+ public static Option flowCapableModelBundles() {
+ return new DefaultCompositeOption( //
+ mavenBundle(CONTROLLER_MODELS, "model-flow-base").versionAsInProject(), // //
+ mavenBundle(CONTROLLER_MODELS, "model-flow-service").versionAsInProject(), // //
+ mavenBundle(CONTROLLER_MODELS, "model-inventory").versionAsInProject() //
+ );
+
+ }
+
+ public static Option baseModelBundles() {
+ return new DefaultCompositeOption( //
+ mavenBundle(YANGTOOLS_MODELS, "yang-ext").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS_MODELS, "ietf-inet-types").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS_MODELS, "ietf-yang-types").versionAsInProject(), // //
+ mavenBundle(YANGTOOLS_MODELS, "opendaylight-l2-types").versionAsInProject(), // //
+ mavenBundle(CONTROLLER_MODELS, "model-inventory").versionAsInProject());
+ }
+
+ public static Option junitAndMockitoBundles() {
+ return new DefaultCompositeOption(
+ // Repository required to load harmcrest (OSGi-fied version).
+ // Mockito
+ mavenBundle("org.mockito", "mockito-all", "1.9.5"), junitBundles(),
+
+ /*
+ * Felix has implicit boot delegation enabled by default. It
+ * conflicts with Mockito: java.lang.LinkageError: loader
+ * constraint violation in interface itable initialization: when
+ * resolving method
+ * "org.osgi.service.useradmin.User$$EnhancerByMockitoWithCGLIB$$dd2f81dc
+ * .
+ * newInstance(Lorg/mockito/cglib/proxy/Callback;)Ljava/lang/Object
+ * ;" the class loader (instance of
+ * org/mockito/internal/creation/jmock/SearchingClassLoader) of
+ * the current class, org/osgi/service/useradmin/
+ * User$$EnhancerByMockitoWithCGLIB$$dd2f81dc, and the class
+ * loader (instance of org/apache/felix/framework/
+ * BundleWiringImpl$BundleClassLoaderJava5) for interface
+ * org/mockito/cglib/proxy/Factory have different Class objects
+ * for the type org/mockito/cglib/ proxy/Callback used in the
+ * signature
+ *
+ * So we disable the bootdelegation. this property has no effect
+ * on the other OSGi implementation.
+ */
+ frameworkProperty("felix.bootdelegation.implicit").value("false"));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.integration.pcep;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.protocol.integration.TestHelper;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.ops4j.pax.exam.Configuration;
+import org.ops4j.pax.exam.Option;
+import org.ops4j.pax.exam.options.DefaultCompositeOption;
+import org.ops4j.pax.exam.util.Filter;
+import org.osgi.framework.BundleContext;
+
+import javax.inject.Inject;
+import java.util.Collection;
+import java.util.Collections;
+
+import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
+import static org.ops4j.pax.exam.CoreOptions.options;
+import static org.ops4j.pax.exam.CoreOptions.systemProperty;
+
+public class AbstractPcepOsgiTest {
+ @Inject
+ @Filter(timeout=60*1000)
+ BindingAwareBroker broker;
+ @Inject
+ BundleContext bundleContext;
+
+ public BindingAwareBroker getBroker() {
+ return broker;
+ }
+
+ public void setBroker(BindingAwareBroker broker) {
+ this.broker = broker;
+ }
+
+ public BundleContext getBundleContext() {
+ return bundleContext;
+ }
+
+ public void setBundleContext(BundleContext bundleContext) {
+ this.bundleContext = bundleContext;
+ }
+
+ @Configuration
+ public Option[] config() {
+ return options(TestHelper.getLoggingBundles(), //
+
+ pcepModules(), //
+ systemProperty("osgi.bundles.defaultStartLevel").value("4"),
+
+ TestHelper.mdSalCoreBundles(),
+
+ TestHelper.bindingAwareSalBundles(),
+ TestHelper.configMinumumBundles(),
+ TestHelper.baseModelBundles(),
+ TestHelper.flowCapableModelBundles(),
+ TestHelper.junitAndMockitoBundles());
+ }
+
+ private Option pcepModules() {
+ return new DefaultCompositeOption(mavenBundle("org.opendaylight.yangtools.model", "ietf-topology").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "pcep-topology-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "pcep-tunnel-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "pcep-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "topology-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "topology-tunnel-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "programming-topology-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "programming-tunnel-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "concepts").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "util").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "rsvp-api").versionAsInProject(), //
+ mavenBundle("org.opendaylight.bgpcep", "programming-api").versionAsInProject());
+ }
+
+ abstract class AbstractTestProvider implements BindingAwareProvider {
+
+ @Override
+ public Collection<? extends RpcService> getImplementations() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public Collection<? extends ProviderFunctionality> getFunctionality() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public void onSessionInitialized(BindingAwareBroker.ConsumerContext session) {}
+
+ }
+
+ TopologyKey getTopologyId(String id) {
+ return new TopologyKey(new org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId(id));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.protocol.integration.pcep;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
+import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.NetworkTopologyPcepProgrammingService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitAddLspInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitAddLspInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitUpdateLspInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitUpdateLspInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.AddLspInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.AddLspInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.EnsureLspOperationalInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.EnsureLspOperationalInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.NetworkTopologyPcepService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepCreateP2pTunnelInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepCreateP2pTunnelInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepDestroyTunnelInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepDestroyTunnelInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.TopologyTunnelPcepProgrammingService;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.ops4j.pax.exam.junit.PaxExam;
+import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
+
+import java.lang.reflect.Method;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+@RunWith(PaxExam.class)
+@ExamReactorStrategy(org.ops4j.pax.exam.spi.reactors.PerClass.class)
+public class PcepRpcServicesRoutingTest extends AbstractPcepOsgiTest {
+
+ @Test
+ public void testRoutedRpcNetworkTopologyPcepService() throws Exception {
+ final NetworkTopologyPcepService pcepService1 = mock(NetworkTopologyPcepService.class, "First pcep Service");
+ final NetworkTopologyPcepService pcepService2 = mock(NetworkTopologyPcepService.class, "Second pcep Service");
+
+ assertNotNull(getBroker());
+
+ final InstanceIdentifier<Topology> topology =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId("Topo1"))).toInstance();
+
+ BindingAwareProvider provider1 = new AbstractTestProvider() {
+
+ @Override
+ public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
+ assertNotNull(session);
+ BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> firstReg = session.addRoutedRpcImplementation(NetworkTopologyPcepService.class, pcepService1);
+ assertNotNull("Registration should not be null", firstReg);
+ assertSame(pcepService1, firstReg.getInstance());
+
+ firstReg.registerPath(NetworkTopologyContext.class, topology);
+ }
+ };
+
+ broker.registerProvider(provider1, getBundleContext());
+
+ final InstanceIdentifier<Topology> topology2 =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId("Topo2"))).toInstance();
+
+ BindingAwareProvider provider2 = new AbstractTestProvider() {
+
+ @Override
+ public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
+ assertNotNull(session);
+ BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> secondReg = session.addRoutedRpcImplementation(NetworkTopologyPcepService.class, pcepService2);
+ secondReg.registerPath(NetworkTopologyContext.class, topology2);
+ }
+ };
+
+ broker.registerProvider(provider2, getBundleContext());
+
+ BindingAwareConsumer consumer = new BindingAwareConsumer() {
+ @Override
+ public void onSessionInitialized(final BindingAwareBroker.ConsumerContext session) {
+ NetworkTopologyPcepService consumerPcepService = session.getRpcService(NetworkTopologyPcepService.class);
+
+ assertNotNull(consumerPcepService);
+ assertNotSame(pcepService1, consumerPcepService);
+ assertNotSame(pcepService2, consumerPcepService);
+
+ testAddLspRpce(consumerPcepService);
+ testEnsureLspRpce(consumerPcepService);
+ }
+
+ private void testAddLspRpce(NetworkTopologyPcepService consumerPcepService) {
+ AddLspInput addLspInput = getInputForRpc(topology, AddLspInputBuilder.class, AddLspInput.class);
+ consumerPcepService.addLsp(addLspInput);
+
+ verify(pcepService1).addLsp(addLspInput);
+ verifyZeroInteractions(pcepService2);
+
+ addLspInput = getInputForRpc(topology2, AddLspInputBuilder.class, AddLspInput.class);
+
+ consumerPcepService.addLsp(addLspInput);
+
+ verifyZeroInteractions(pcepService1);
+ verify(pcepService2).addLsp(addLspInput);
+ }
+
+ private void testEnsureLspRpce(NetworkTopologyPcepService consumerPcepService) {
+ EnsureLspOperationalInput ensureInput = getInputForRpc(topology, EnsureLspOperationalInputBuilder.class, EnsureLspOperationalInput.class);
+
+ consumerPcepService.ensureLspOperational(ensureInput);
+
+ verify(pcepService1).ensureLspOperational(ensureInput);
+ verifyZeroInteractions(pcepService2);
+
+ ensureInput = getInputForRpc(topology2, EnsureLspOperationalInputBuilder.class, EnsureLspOperationalInput.class);
+
+ consumerPcepService.ensureLspOperational(ensureInput);
+
+ verifyZeroInteractions(pcepService1);
+ verify(pcepService2).ensureLspOperational(ensureInput);
+ }
+ };
+ broker.registerConsumer(consumer, getBundleContext());
+ }
+
+ private static <T> T getInputForRpc(final InstanceIdentifier<Topology> topology, Class<?> builderClass,
+ Class<T> builtObjectClass) {
+ try {
+ Object builderInstance = builderClass.newInstance();
+ Method method = builderClass.getMethod("setNetworkTopologyRef", NetworkTopologyRef.class);
+ method.invoke(builderInstance, new NetworkTopologyRef(topology));
+ return builtObjectClass.cast(builderClass.getMethod("build").invoke(builderInstance));
+ } catch (Exception e) {
+ throw new RuntimeException("Unable to create instance from " + builderClass, e);
+ }
+ }
+
+ @Test
+ public void testRoutedRpcNetworkTopologyPcepProgrammingService() throws Exception {
+ final NetworkTopologyPcepProgrammingService pcepService1 = mock(NetworkTopologyPcepProgrammingService.class, "First pcep program Service");
+ final NetworkTopologyPcepProgrammingService pcepService2 = mock(NetworkTopologyPcepProgrammingService.class, "Second pcep program Service");
+
+ assertNotNull(getBroker());
+
+ final InstanceIdentifier<Topology> topology =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId("Topo1"))).toInstance();
+
+ BindingAwareProvider provider1 = new AbstractTestProvider() {
+
+ @Override
+ public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
+ assertNotNull(session);
+ BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> firstReg = session.addRoutedRpcImplementation(NetworkTopologyPcepProgrammingService.class, pcepService1);
+ assertNotNull("Registration should not be null", firstReg);
+ assertSame(pcepService1, firstReg.getInstance());
+
+ firstReg.registerPath(NetworkTopologyContext.class, topology);
+ }
+ };
+
+ broker.registerProvider(provider1, getBundleContext());
+
+ final InstanceIdentifier<Topology> topology2 =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId("Topo2"))).toInstance();
+
+ BindingAwareProvider provider2 = new AbstractTestProvider() {
+
+ @Override
+ public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
+ assertNotNull(session);
+ BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> secondReg = session.addRoutedRpcImplementation(NetworkTopologyPcepProgrammingService.class, pcepService2);
+ secondReg.registerPath(NetworkTopologyContext.class, topology2);
+ }
+ };
+
+ broker.registerProvider(provider2, getBundleContext());
+
+ BindingAwareConsumer consumer = new BindingAwareConsumer() {
+ @Override
+ public void onSessionInitialized(final BindingAwareBroker.ConsumerContext session) {
+ NetworkTopologyPcepProgrammingService consumerPcepService = session.getRpcService(NetworkTopologyPcepProgrammingService.class);
+
+ assertNotNull(consumerPcepService);
+ assertNotSame(pcepService1, consumerPcepService);
+ assertNotSame(pcepService2, consumerPcepService);
+
+ testSubmitAddLspRpc(consumerPcepService);
+ testSubmitUpdateLspRpc(consumerPcepService);
+ }
+
+ private void testSubmitAddLspRpc(NetworkTopologyPcepProgrammingService consumerPcepService) {
+ SubmitAddLspInput addLspInput = getInputForRpc(topology, SubmitAddLspInputBuilder.class, SubmitAddLspInput.class);
+ consumerPcepService.submitAddLsp(addLspInput);
+
+ verify(pcepService1).submitAddLsp(addLspInput);
+ verifyZeroInteractions(pcepService2);
+
+ addLspInput = getInputForRpc(topology2, SubmitAddLspInputBuilder.class, SubmitAddLspInput.class);
+
+ consumerPcepService.submitAddLsp(addLspInput);
+
+ verifyZeroInteractions(pcepService1);
+ verify(pcepService2).submitAddLsp(addLspInput);
+ }
+
+ private void testSubmitUpdateLspRpc(NetworkTopologyPcepProgrammingService consumerPcepService) {
+ SubmitUpdateLspInput submitLspInput = getInputForRpc(topology, SubmitUpdateLspInputBuilder.class, SubmitUpdateLspInput.class);
+ consumerPcepService.submitUpdateLsp(submitLspInput);
+
+ verify(pcepService1).submitUpdateLsp(submitLspInput);
+ verifyZeroInteractions(pcepService2);
+
+ submitLspInput = getInputForRpc(topology2, SubmitUpdateLspInputBuilder.class, SubmitUpdateLspInput.class);
+
+ consumerPcepService.submitUpdateLsp(submitLspInput);
+
+ verifyZeroInteractions(pcepService1);
+ verify(pcepService2).submitUpdateLsp(submitLspInput);
+ }
+ };
+ broker.registerConsumer(consumer, getBundleContext());
+ }
+
+ @Test
+ public void testRoutedRpcTopologyTunnelPcepProgrammingService() throws Exception {
+ final TopologyTunnelPcepProgrammingService pcepService1 = mock(TopologyTunnelPcepProgrammingService.class, "First pcep program Service");
+ final TopologyTunnelPcepProgrammingService pcepService2 = mock(TopologyTunnelPcepProgrammingService.class, "Second pcep program Service");
+
+ assertNotNull(getBroker());
+
+ final InstanceIdentifier<Topology> topology =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId("Topo1"))).toInstance();
+
+ BindingAwareProvider provider1 = new AbstractTestProvider() {
+
+ @Override
+ public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
+ assertNotNull(session);
+ BindingAwareBroker.RoutedRpcRegistration<TopologyTunnelPcepProgrammingService> firstReg = session.addRoutedRpcImplementation(TopologyTunnelPcepProgrammingService.class, pcepService1);
+ assertNotNull("Registration should not be null", firstReg);
+ assertSame(pcepService1, firstReg.getInstance());
+
+ firstReg.registerPath(NetworkTopologyContext.class, topology);
+ }
+ };
+
+ broker.registerProvider(provider1, getBundleContext());
+
+ final InstanceIdentifier<Topology> topology2 =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId("Topo2"))).toInstance();
+
+ BindingAwareProvider provider2 = new AbstractTestProvider() {
+
+ @Override
+ public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
+ assertNotNull(session);
+ BindingAwareBroker.RoutedRpcRegistration<TopologyTunnelPcepProgrammingService> secondReg = session.addRoutedRpcImplementation(TopologyTunnelPcepProgrammingService.class, pcepService2);
+ secondReg.registerPath(NetworkTopologyContext.class, topology2);
+ }
+ };
+
+ broker.registerProvider(provider2, getBundleContext());
+
+ BindingAwareConsumer consumer = new BindingAwareConsumer() {
+ @Override
+ public void onSessionInitialized(final BindingAwareBroker.ConsumerContext session) {
+ TopologyTunnelPcepProgrammingService consumerPcepService = session.getRpcService(TopologyTunnelPcepProgrammingService.class);
+
+ assertNotNull(consumerPcepService);
+ assertNotSame(pcepService1, consumerPcepService);
+ assertNotSame(pcepService2, consumerPcepService);
+
+ testCreateP2pTunnel(consumerPcepService);
+ testDestroyP2pTunnel(consumerPcepService);
+ }
+
+ private void testCreateP2pTunnel(TopologyTunnelPcepProgrammingService consumerPcepService) {
+ PcepCreateP2pTunnelInput addLspInput = getInputForRpc(topology, PcepCreateP2pTunnelInputBuilder.class, PcepCreateP2pTunnelInput.class);
+ consumerPcepService.pcepCreateP2pTunnel(addLspInput);
+
+ verify(pcepService1).pcepCreateP2pTunnel(addLspInput);
+ verifyZeroInteractions(pcepService2);
+
+ addLspInput =getInputForRpc(topology2, PcepCreateP2pTunnelInputBuilder.class, PcepCreateP2pTunnelInput.class);
+
+ consumerPcepService.pcepCreateP2pTunnel(addLspInput);
+
+ verifyZeroInteractions(pcepService1);
+ verify(pcepService2).pcepCreateP2pTunnel(addLspInput);
+ }
+
+ private void testDestroyP2pTunnel(TopologyTunnelPcepProgrammingService consumerPcepService) {
+ PcepDestroyTunnelInput addLspInput = getInputForRpc(topology, PcepDestroyTunnelInputBuilder.class, PcepDestroyTunnelInput.class);
+ consumerPcepService.pcepDestroyTunnel(addLspInput);
+
+ verify(pcepService1).pcepDestroyTunnel(addLspInput);
+ verifyZeroInteractions(pcepService2);
+
+ addLspInput = getInputForRpc(topology2, PcepDestroyTunnelInputBuilder.class, PcepDestroyTunnelInput.class);
+
+ consumerPcepService.pcepDestroyTunnel(addLspInput);
+
+ verifyZeroInteractions(pcepService1);
+ verify(pcepService2).pcepDestroyTunnel(addLspInput);
+ }
+ };
+ broker.registerConsumer(consumer, getBundleContext());
+ }
+
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<persisted-snapshots>
+ <snapshots>
+ <snapshot>
+ <required-capabilities>
+ <capability>urn:opendaylight:l2:types?module=opendaylight-l2-types&revision=2013-08-27</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding?module=opendaylight-md-sal-binding&revision=2013-10-28</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom?module=opendaylight-md-sal-dom&revision=2013-10-28</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:config?module=config&revision=2013-04-05</capability>
+ <capability>urn:ietf:params:netconf:capability:candidate:1.0</capability>
+ <capability>urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring?module=ietf-netconf-monitoring&revision=2010-10-04</capability>
+ <capability>urn:ietf:params:xml:ns:yang:rpc-context?module=rpc-context&revision=2013-06-17</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl?module=opendaylight-sal-binding-broker-impl&revision=2013-10-28</capability>
+ <capability>urn:ietf:params:xml:ns:yang:ietf-inet-types?module=ietf-inet-types&revision=2010-09-24</capability>
+ <capability>urn:ietf:params:netconf:capability:rollback-on-error:1.0</capability>
+ <capability>urn:ietf:params:xml:ns:yang:ietf-yang-types?module=ietf-yang-types&revision=2010-09-24</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl?module=opendaylight-sal-dom-broker-impl&revision=2013-10-28</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:logback:config?module=config-logging&revision=2013-07-16</capability>
+ <capability>urn:opendaylight:yang:extension:yang-ext?module=yang-ext&revision=2013-07-09</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:common?module=opendaylight-md-sal-common&revision=2013-10-28</capability>
+ </required-capabilities>
+ <configuration>
+
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:impl">
+ prefix:schema-service-singleton
+ </type>
+ <name>yang-schema-service</name>
+ </module>
+ <module>
+ <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: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>
+ </data-store>
+ </module>
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ prefix:binding-broker-impl
+ </type>
+ <name>binding-broker-impl</name>
+ <notification-service
+ xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">
+ binding:binding-notification-service
+ </type>
+ <name>ref_binding-notification-broker</name>
+ </notification-service>
+ <data-broker xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">
+ binding:binding-data-broker
+ </type>
+ <name>ref_binding-data-broker</name>
+ </data-broker>
+ </module>
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ prefix:runtime-generated-mapping
+ </type>
+ <name>runtime-mapping-singleton</name>
+ </module>
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ prefix:binding-notification-broker
+ </type>
+ <name>binding-notification-broker</name>
+ </module>
+ <module>
+ <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ prefix:binding-data-broker
+ </type>
+ <name>binding-data-broker</name>
+ <dom-broker xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">
+ dom:dom-broker-osgi-registry
+ </type>
+ <name>ref_dom-broker</name>
+ </dom-broker>
+ <mapping-service xmlns="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ binding:binding-dom-mapping-service
+ </type>
+ <name>ref_runtime-mapping-singleton</name>
+ </mapping-service>
+ </module>
+ </modules>
+
+ <services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <service>
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">
+ dom:schema-service
+ </type>
+ <instance>
+ <name>ref_yang-schema-service</name>
+ <provider>
+ /config/modules/module[name='schema-service-singleton']/instance[name='yang-schema-service']
+ </provider>
+ </instance>
+ </service>
+ <service>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">
+ binding:binding-notification-service
+ </type>
+ <instance>
+ <name>ref_binding-notification-broker</name>
+ <provider>
+ /config/modules/module[name='binding-notification-broker']/instance[name='binding-notification-broker']
+ </provider>
+ </instance>
+ </service>
+ <service>
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">
+ dom:dom-data-store
+ </type>
+ <instance>
+ <name>ref_hash-map-data-store</name>
+ <provider>
+ /config/modules/module[name='hash-map-data-store']/instance[name='hash-map-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>
+ <instance>
+ <name>ref_binding-broker-impl</name>
+ <provider>
+ /config/modules/module[name='binding-broker-impl']/instance[name='binding-broker-impl']
+ </provider>
+ </instance>
+ </service>
+ <service>
+ <type xmlns:binding-impl="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding:impl">
+ binding-impl:binding-dom-mapping-service
+ </type>
+ <instance>
+ <name>ref_runtime-mapping-singleton</name>
+ <provider>
+ /config/modules/module[name='runtime-generated-mapping']/instance[name='runtime-mapping-singleton']
+ </provider>
+ </instance>
+ </service>
+ <service>
+ <type xmlns:dom="urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom">
+ dom:dom-broker-osgi-registry
+ </type>
+ <instance>
+ <name>ref_dom-broker</name>
+ <provider>/config/modules/module[name='dom-broker-impl']/instance[name='dom-broker']
+ </provider>
+ </instance>
+ </service>
+ <service>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">
+ binding:binding-data-broker
+ </type>
+ <instance>
+ <name>ref_binding-data-broker</name>
+ <provider>
+ /config/modules/module[name='binding-data-broker']/instance[name='binding-data-broker']
+ </provider>
+ </instance>
+ </service>
+ </services>
+ </data>
+
+ </configuration>
+ </snapshot>
+
+ </snapshots>
+</persisted-snapshots>
<configuration>
<instructions>
<Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
+ <Import-Package>
+ *,
+ org.opendaylight.yangtools.yang.binding.annotations,
+ </Import-Package>
</instructions>
</configuration>
</plugin>
import ietf-inet-types { prefix inet; revision-date 2010-09-24; }
import network-topology { prefix nt; revision-date 2013-10-21; }
+ import odl-network-topology { prefix ont; revision-date 2014-01-13; }
import pcep-types { prefix pcep; revision-date 2013-10-05; }
import pcep-ietf-stateful { prefix stateful; revision-date 2013-12-22; }
rpc add-lsp {
input {
+ uses ont:network-topology-reference;
uses add-lsp-args;
}
output {
rpc remove-lsp {
input {
+ uses ont:network-topology-reference;
uses remove-lsp-args;
}
output {
rpc update-lsp {
input {
+ uses ont:network-topology-reference;
uses update-lsp-args;
}
output {
operational status.";
input {
+ uses ont:network-topology-reference;
uses ensure-lsp-operational-args;
}
output {
import org.opendaylight.bgpcep.programming.spi.InstructionScheduler;
import org.opendaylight.bgpcep.topology.DefaultTopologyReference;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
import org.opendaylight.protocol.pcep.PCEPDispatcher;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.NetworkTopologyPcepProgrammingService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.NetworkTopologyPcepService;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import com.google.common.base.Preconditions;
public final class PCEPTopologyProvider extends DefaultTopologyReference implements AutoCloseable {
+
private static final Logger LOG = LoggerFactory.getLogger(PCEPTopologyProvider.class);
- private final RpcRegistration<NetworkTopologyPcepProgrammingService> network;
- private final RpcRegistration<NetworkTopologyPcepService> element;
+ private final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> network;
+ private final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> element;
private final ServerSessionManager manager;
private final Channel channel;
- private PCEPTopologyProvider(final Channel channel, final InstanceIdentifier<Topology> topology, final ServerSessionManager manager,
- final RpcRegistration<NetworkTopologyPcepService> element, final RpcRegistration<NetworkTopologyPcepProgrammingService> network) {
+ private PCEPTopologyProvider(final Channel channel, final InstanceIdentifier<Topology> topology,
+ final ServerSessionManager manager,
+ final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> element,
+ final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> network) {
super(topology);
this.channel = Preconditions.checkNotNull(channel);
this.manager = Preconditions.checkNotNull(manager);
final ChannelFuture f = dispatcher.createServer(address, manager);
f.get();
- final RpcRegistration<NetworkTopologyPcepService> element = rpcRegistry.addRpcImplementation(NetworkTopologyPcepService.class, new TopologyRPCs(manager));
- final RpcRegistration<NetworkTopologyPcepProgrammingService> network = rpcRegistry.addRpcImplementation(NetworkTopologyPcepProgrammingService.class, new TopologyProgramming(scheduler, manager));
+ final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> element = rpcRegistry.addRoutedRpcImplementation(
+ NetworkTopologyPcepService.class, new TopologyRPCs(manager));
+ element.registerPath(NetworkTopologyContext.class, topology);
+
+ final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> network = rpcRegistry.addRoutedRpcImplementation(
+ NetworkTopologyPcepProgrammingService.class, new TopologyProgramming(scheduler, manager));
+ network.registerPath(NetworkTopologyContext.class, topology);
return new PCEPTopologyProvider(f.channel(), topology, manager, element, network);
}
b.setResult(AbstractInstructionExecutor.schedule(scheduler, new AbstractInstructionExecutor(input) {
@Override
protected ListenableFuture<OperationResult> invokeOperation() {
- return TopologyProgramming.this.manager.realEnsureLspOperational(new EnsureLspOperationalInputBuilder(input).build());
+ EnsureLspOperationalInputBuilder ensureLspOperationalInputBuilder = new EnsureLspOperationalInputBuilder();
+ ensureLspOperationalInputBuilder.fieldsFrom(input);
+ return TopologyProgramming.this.manager.realEnsureLspOperational(ensureLspOperationalInputBuilder.build());
}
}));
<configuration>
<instructions>
<Bundle-Name>${project.groupId}.${project.artifactId}</Bundle-Name>
+ <Import-Package>
+ *,
+ org.opendaylight.yangtools.yang.binding.annotations,
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.programming.rev131102,
+ </Import-Package>
</instructions>
</configuration>
</plugin>
prefix "ttpp";
import pcep-types { prefix pcep; revision-date 2013-10-05; }
- import topology-tunnel-programming { prefix ttp; revision-date 2013-09-30; }
+ import topology-tunnel-programming { prefix ttp; revision-date 2013-09-30; }
import topology-tunnel-p2p { prefix p2p; revision-date 2013-08-19; }
import topology-tunnel-pcep { prefix ptp; revision-date 2013-08-20; }
import org.opendaylight.bgpcep.pcep.tunnel.provider.TunnelProgramming;
import org.opendaylight.bgpcep.topology.DefaultTopologyReference;
import org.opendaylight.controller.config.api.JmxAttributeValidationException;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.NetworkTopologyPcepService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.TopologyTunnelPcepProgrammingService;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
final PCEPTunnelTopologyProvider ttp = PCEPTunnelTopologyProvider.create(getDataProviderDependency(), getSourceTopologyDependency().getInstanceIdentifier(), getTopologyId());
final NetworkTopologyPcepService ntps = getRpcRegistryDependency().getRpcService(NetworkTopologyPcepService.class);
final TunnelProgramming tp = new TunnelProgramming(getSchedulerDependency(), getDataProviderDependency(), ntps);
- final RpcRegistration<TopologyTunnelPcepProgrammingService> reg =
- getRpcRegistryDependency().addRpcImplementation(TopologyTunnelPcepProgrammingService.class, tp);
+
+ final BindingAwareBroker.RoutedRpcRegistration<TopologyTunnelPcepProgrammingService> reg =
+ getRpcRegistryDependency().addRoutedRpcImplementation(TopologyTunnelPcepProgrammingService.class, tp);
+ final InstanceIdentifier<Topology> topology =
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(getTopologyId())).toInstance();
+ reg.registerPath(NetworkTopologyContext.class, topology);
final class TunnelTopologyReferenceCloseable extends DefaultTopologyReference implements AutoCloseable {
public TunnelTopologyReferenceCloseable(final InstanceIdentifier<Topology> instanceIdentifier) {
package org.opendaylight.bgpcep.programming.topology;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.programming.rev131102.TopologyInstructionInput;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.base.Preconditions;
}
+ @SuppressWarnings("unchecked")
public static InstanceIdentifier<Topology> topologyForInput(final TopologyInstructionInput input) {
- Preconditions.checkNotNull(input.getTopologyId());
- return InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class, new TopologyKey(input.getTopologyId())).toInstance();
+ Preconditions.checkNotNull(input.getNetworkTopologyRef());
+ return (InstanceIdentifier<Topology>) input.getNetworkTopologyRef().getValue();
}
}
prefix "tp";
import network-topology { prefix nt; revision-date 2013-10-21; }
+ import odl-network-topology { prefix ont; revision-date 2014-01-13; }
import programming { prefix pgm; revision-date 2013-09-30; }
organization "Cisco Systems, Inc.";
grouping topology-instruction-input {
uses pgm:submit-instruction-input;
-
- leaf topology-id {
- type nt:topology-id;
- mandatory true;
- }
+ uses ont:network-topology-reference;
}
grouping topology-instruction-output {
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-common</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools.model</groupId>
+ <artifactId>yang-ext</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools.model</groupId>
<artifactId>ietf-inet-types</artifactId>
<build>
<plugins>
+ <plugin>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-maven-plugin</artifactId>
+ </plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
--- /dev/null
+module odl-network-topology {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:network:topology";
+ prefix "ont";
+
+ import ietf-inet-types { prefix inet; revision-date 2010-09-24; }
+ import network-topology { prefix nt; revision-date 2013-10-21; }
+ import yang-ext {prefix ext; revision-date "2013-07-09"; }
+
+ organization "Cisco Systems, Inc.";
+ contact "Robert Varga <rovarga@cisco.com>";
+
+ description
+ "Augments IETF network topology model to define routing RPC
+ extensions.";
+
+ revision "2014-01-13" {
+ description
+ "Initial revision.";
+ reference "";
+ }
+
+ identity network-topology-context {
+ description
+ "Identity used to mark the network topology context.
+ This is useful for example binding RPCs to a particular
+ network topology instance.";
+ }
+
+ typedef network-topology-ref {
+ type instance-identifier;
+ ext:context-reference "network-topology-context";
+ }
+
+ grouping network-topology-reference {
+ leaf network-topology-ref {
+ type network-topology-ref;
+ mandatory true;
+ // Workaround for yangtools
+ ext:context-reference "network-topology-context";
+ }
+ }
+
+ augment "/nt:network-topology/nt:topology" {
+ ext:context-instance "network-topology-context";
+ }
+}
+
Code Review / bgpcep.git / commitdiff