<packaging>jar</packaging>
<properties>
<aaa.version>0.2.0-SNAPSHOT</aaa.version>
+ <yangtools.version>0.7.0-SNAPSHOT</yangtools.version>
+ <mdsal.version>1.2.0-SNAPSHOT</mdsal.version>
</properties>
-
+ <dependencyManagement>
+ <dependencies>
+ <!-- project specific dependencies -->
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yangtools-artifacts</artifactId>
+ <version>${yangtools.version}</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>mdsal-artifacts</artifactId>
+ <version>${mdsal.version}</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>features-yangtools</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-mdsal</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
<dependency>
<groupId>org.opendaylight.aaa</groupId>
<artifactId>features-aaa</artifactId>
<artifactId>transcriber</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>transcriber</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
</dependencies>
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/neutron.git</connection>
<bundle>mvn:org.osgi/org.osgi.core/${osgi.core.version}</bundle>
</feature>
<feature name='odl-neutron-transcriber' version='${project.version}' description="OpenDaylight :: Neutron :: Implementation">
+ <feature version='${mdsal.version}'>odl-mdsal-broker</feature>
<feature version='${project.version}'>odl-neutron-spi</feature>
<feature>war</feature>
<bundle>mvn:org.opendaylight.neutron/transcriber/${project.version}</bundle>
<bundle>mvn:org.osgi/org.osgi.core/${osgi.core.version}</bundle>
+ <configfile finalname="etc/opendaylight/karaf/neutron-transriber-default-config.xml">mvn:org.opendaylight.neutron/transcriber/${project.version}/xml/config</configfile>
</feature>
</features>
<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.neutron</groupId>
- <artifactId>project-neutron-parent</artifactId>
- <version>0.5.0-SNAPSHOT</version>
- <relativePath>../parent</relativePath>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-parent</artifactId>
+ <version>0.3.0-SNAPSHOT</version>
+ <relativePath/>
</parent>
-
<groupId>org.opendaylight.neutron</groupId>
<artifactId>transcriber</artifactId>
<version>0.5.0-SNAPSHOT</version>
<artifactId>org.osgi.core</artifactId>
</dependency>
</dependencies>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <Import-Package>*</Import-Package>
- <Bundle-Activator>org.opendaylight.neutron.transcriber.Activator</Bundle-Activator>
- </instructions>
- <manifestLocation>${project.basedir}/src/main/resources/META-INF</manifestLocation>
- </configuration>
- </plugin>
- </plugins>
- </build>
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/neutron.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/neutron.git</developerConnection>
<tag>HEAD</tag>
<url>https://wiki.opendaylight.org/view/NeutronNorthBound:Main</url>
</scm>
-
- <distributionManagement>
- <!-- OpenDayLight Released artifact -->
- <repository>
- <id>opendaylight-release</id>
- <url>${nexusproxy}/repositories/${nexus.repository.release}/</url>
- </repository>
- <!-- OpenDayLight Snapshot artifact -->
- <snapshotRepository>
- <id>opendaylight-snapshot</id>
- <url>${nexusproxy}/repositories/${nexus.repository.snapshot}/</url>
- </snapshotRepository>
- <!-- Site deployment -->
- <site>
- <id>website</id>
- <url>${sitedeploy}</url>
- </site>
- </distributionManagement>
</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+Copyright (c) 2014 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
+-->
+<snapshot>
+ <required-capabilities>
+ </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:neutron:transcriber:impl">prefix:neutron-transcriber-impl</type>
+ <name>neutron-transcriber-default</name>
+ <broker>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
+ <name>binding-osgi-broker</name>
+ </broker>
+ </module>
+ </modules>
+ </data>
+ </configuration>
+</snapshot>
--- /dev/null
+package org.opendaylight.neutron.transcriber;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+
+public abstract class AbstractNeutronInterface implements AutoCloseable {
+
+ private ProviderContext providerContext;
+ private DataBroker db;
+
+ AbstractNeutronInterface(ProviderContext providerContext) {
+ this.providerContext = providerContext;
+ this.db = providerContext.getSALService(DataBroker.class);
+ }
+
+ public DataBroker getDataBroker() {
+ return db;
+ }
+
+ @Override
+ public void close() throws Exception {
+ // TODO Auto-generated method stub
+
+ }
+
+}
import java.util.ArrayList;
import java.util.List;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronFirewallCRUD;
import org.opendaylight.neutron.spi.INeutronFirewallPolicyCRUD;
import org.opendaylight.neutron.spi.INeutronFirewallRuleCRUD;
import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
import org.opendaylight.neutron.spi.INeutronSecurityRuleCRUD;
import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
-import org.opendaylight.neutron.spi.INeutronVPNServiceCRUD;
import org.opendaylight.neutron.spi.INeutronVPNIPSECSiteConnectionsCRUD;
+import org.opendaylight.neutron.spi.INeutronVPNServiceCRUD;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
protected static final Logger logger = LoggerFactory
.getLogger(Activator.class);
private List<ServiceRegistration<?>> registrations = new ArrayList<ServiceRegistration<?>>();
+ private ProviderContext providerContext;
+
+ public Activator(ProviderContext providerContext) {
+ this.providerContext = providerContext;
+ }
@Override
public void start(BundleContext context) throws Exception {
- NeutronRouterInterface neutronRouterInterface = new NeutronRouterInterface();
+ NeutronRouterInterface neutronRouterInterface = new NeutronRouterInterface(providerContext);
ServiceRegistration<INeutronRouterCRUD> neutronRouterInterfaceRegistration = context.registerService(INeutronRouterCRUD.class, neutronRouterInterface, null);
if(neutronRouterInterfaceRegistration != null) {
registrations.add(neutronRouterInterfaceRegistration);
}
- NeutronPortInterface neutronPortInterface = new NeutronPortInterface();
+ NeutronPortInterface neutronPortInterface = new NeutronPortInterface(providerContext);
ServiceRegistration<INeutronPortCRUD> neutronPortInterfaceRegistration = context.registerService(INeutronPortCRUD.class, neutronPortInterface, null);
if(neutronPortInterfaceRegistration != null) {
registrations.add(neutronPortInterfaceRegistration);
}
- NeutronSubnetInterface neutronSubnetInterface = new NeutronSubnetInterface();
+ NeutronSubnetInterface neutronSubnetInterface = new NeutronSubnetInterface(providerContext);
ServiceRegistration<INeutronSubnetCRUD> neutronSubnetInterfaceRegistration = context.registerService(INeutronSubnetCRUD.class, neutronSubnetInterface, null);
if(neutronSubnetInterfaceRegistration != null) {
registrations.add(neutronSubnetInterfaceRegistration);
}
- NeutronNetworkInterface neutronNetworkInterface = new NeutronNetworkInterface();
+ NeutronNetworkInterface neutronNetworkInterface = new NeutronNetworkInterface(providerContext);
ServiceRegistration<INeutronNetworkCRUD> neutronNetworkInterfaceRegistration = context.registerService(INeutronNetworkCRUD.class, neutronNetworkInterface, null);
if(neutronNetworkInterfaceRegistration != null) {
registrations.add(neutronNetworkInterfaceRegistration);
}
- NeutronSecurityGroupInterface neutronSecurityGroupInterface = new NeutronSecurityGroupInterface();
+ NeutronSecurityGroupInterface neutronSecurityGroupInterface = new NeutronSecurityGroupInterface(providerContext);
ServiceRegistration<INeutronSecurityGroupCRUD> neutronSecurityGroupInterfaceRegistration = context.registerService(INeutronSecurityGroupCRUD.class, neutronSecurityGroupInterface, null);
if(neutronSecurityGroupInterfaceRegistration != null) {
registrations.add(neutronSecurityGroupInterfaceRegistration);
}
- NeutronSecurityRuleInterface neutronSecurityRuleInterface = new NeutronSecurityRuleInterface();
+ NeutronSecurityRuleInterface neutronSecurityRuleInterface = new NeutronSecurityRuleInterface(providerContext);
ServiceRegistration<INeutronSecurityRuleCRUD> neutronSecurityRuleInterfaceRegistration = context.registerService(INeutronSecurityRuleCRUD.class, neutronSecurityRuleInterface, null);
if(neutronSecurityRuleInterfaceRegistration != null) {
registrations.add(neutronSecurityRuleInterfaceRegistration);
}
- NeutronFirewallInterface neutronFirewallInterface = new NeutronFirewallInterface();
+ NeutronFirewallInterface neutronFirewallInterface = new NeutronFirewallInterface(providerContext);
ServiceRegistration<INeutronFirewallCRUD> neutronFirewallInterfaceRegistration = context.registerService(INeutronFirewallCRUD.class, neutronFirewallInterface, null);
if(neutronFirewallInterfaceRegistration != null) {
registrations.add(neutronFirewallInterfaceRegistration);
}
- NeutronFirewallPolicyInterface neutronFirewallPolicyInterface = new NeutronFirewallPolicyInterface();
+ NeutronFirewallPolicyInterface neutronFirewallPolicyInterface = new NeutronFirewallPolicyInterface(providerContext);
ServiceRegistration<INeutronFirewallPolicyCRUD> neutronFirewallPolicyInterfaceRegistration = context.registerService(INeutronFirewallPolicyCRUD.class, neutronFirewallPolicyInterface, null);
if(neutronFirewallPolicyInterfaceRegistration != null) {
registrations.add(neutronFirewallPolicyInterfaceRegistration);
}
- NeutronFirewallRuleInterface neutronFirewallRuleInterface = new NeutronFirewallRuleInterface();
+ NeutronFirewallRuleInterface neutronFirewallRuleInterface = new NeutronFirewallRuleInterface(providerContext);
ServiceRegistration<INeutronFirewallRuleCRUD> neutronFirewallRuleInterfaceRegistration = context.registerService(INeutronFirewallRuleCRUD.class, neutronFirewallRuleInterface, null);
if(neutronFirewallRuleInterfaceRegistration != null) {
registrations.add(neutronFirewallRuleInterfaceRegistration);
}
- NeutronLoadBalancerInterface neutronLoadBalancerInterface = new NeutronLoadBalancerInterface();
+ NeutronLoadBalancerInterface neutronLoadBalancerInterface = new NeutronLoadBalancerInterface(providerContext);
ServiceRegistration<INeutronLoadBalancerCRUD> neutronLoadBalancerInterfaceRegistration = context.registerService(INeutronLoadBalancerCRUD.class, neutronLoadBalancerInterface, null);
if(neutronLoadBalancerInterfaceRegistration != null) {
registrations.add(neutronLoadBalancerInterfaceRegistration);
}
- NeutronLoadBalancerPoolInterface neutronLoadBalancerPoolInterface = new NeutronLoadBalancerPoolInterface();
+ NeutronLoadBalancerPoolInterface neutronLoadBalancerPoolInterface = new NeutronLoadBalancerPoolInterface(providerContext);
ServiceRegistration<INeutronLoadBalancerPoolCRUD> neutronLoadBalancerPoolInterfaceRegistration = context.registerService(INeutronLoadBalancerPoolCRUD.class, neutronLoadBalancerPoolInterface, null);
if(neutronLoadBalancerPoolInterfaceRegistration != null) {
registrations.add(neutronLoadBalancerPoolInterfaceRegistration);
}
- NeutronLoadBalancerListenerInterface neutronLoadBalancerListenerInterface = new NeutronLoadBalancerListenerInterface();
+ NeutronLoadBalancerListenerInterface neutronLoadBalancerListenerInterface = new NeutronLoadBalancerListenerInterface(providerContext);
ServiceRegistration<INeutronLoadBalancerListenerCRUD> neutronLoadBalancerListenerInterfaceRegistration = context.registerService(INeutronLoadBalancerListenerCRUD.class, neutronLoadBalancerListenerInterface, null);
if(neutronLoadBalancerListenerInterfaceRegistration != null) {
registrations.add(neutronLoadBalancerListenerInterfaceRegistration);
}
- NeutronLoadBalancerHealthMonitorInterface neutronLoadBalancerHealthMonitorInterface = new NeutronLoadBalancerHealthMonitorInterface();
+ NeutronLoadBalancerHealthMonitorInterface neutronLoadBalancerHealthMonitorInterface = new NeutronLoadBalancerHealthMonitorInterface(providerContext);
ServiceRegistration<INeutronLoadBalancerHealthMonitorCRUD> neutronLoadBalancerHealthMonitorInterfaceRegistration = context.registerService(INeutronLoadBalancerHealthMonitorCRUD.class, neutronLoadBalancerHealthMonitorInterface, null);
if(neutronLoadBalancerHealthMonitorInterfaceRegistration != null) {
registrations.add(neutronLoadBalancerHealthMonitorInterfaceRegistration);
}
- NeutronLoadBalancerPoolMemberInterface neutronLoadBalancerPoolMemberInterface = new NeutronLoadBalancerPoolMemberInterface();
+ NeutronLoadBalancerPoolMemberInterface neutronLoadBalancerPoolMemberInterface = new NeutronLoadBalancerPoolMemberInterface(providerContext);
ServiceRegistration<INeutronLoadBalancerPoolMemberCRUD> neutronLoadBalancerPoolMemberInterfaceRegistration = context.registerService(INeutronLoadBalancerPoolMemberCRUD.class, neutronLoadBalancerPoolMemberInterface, null);
if(neutronLoadBalancerPoolMemberInterfaceRegistration != null) {
registrations.add(neutronLoadBalancerPoolMemberInterfaceRegistration);
}
- NeutronMeteringLabelInterface neutronMeteringLabelInterface = new NeutronMeteringLabelInterface();
+ NeutronMeteringLabelInterface neutronMeteringLabelInterface = new NeutronMeteringLabelInterface(providerContext);
ServiceRegistration<INeutronMeteringLabelCRUD> neutronMeteringLabelInterfaceRegistration = context.registerService(INeutronMeteringLabelCRUD.class, neutronMeteringLabelInterface, null);
if(neutronMeteringLabelInterfaceRegistration != null) {
registrations.add(neutronMeteringLabelInterfaceRegistration);
}
- NeutronVPNServiceInterface neutronVPNServiceInterface = new NeutronVPNServiceInterface();
+ NeutronVPNServiceInterface neutronVPNServiceInterface = new NeutronVPNServiceInterface(providerContext);
ServiceRegistration<INeutronVPNServiceCRUD> neutronVPNServiceInterfaceRegistration = context.registerService(INeutronVPNServiceCRUD.class, neutronVPNServiceInterface, null);
if(neutronVPNServiceInterfaceRegistration != null) {
registrations.add(neutronVPNServiceInterfaceRegistration);
}
- NeutronVPNIPSECSiteConnectionsInterface neutronVPNIPSECSiteConnectionsInterface = new NeutronVPNIPSECSiteConnectionsInterface();
+ NeutronVPNIPSECSiteConnectionsInterface neutronVPNIPSECSiteConnectionsInterface = new NeutronVPNIPSECSiteConnectionsInterface(providerContext);
ServiceRegistration<INeutronVPNIPSECSiteConnectionsCRUD> neutronVPNIPSECSiteConnectionsInterfaceRegistration = context.registerService(INeutronVPNIPSECSiteConnectionsCRUD.class, neutronVPNIPSECSiteConnectionsInterface, null);
if (neutronVPNIPSECSiteConnectionsInterfaceRegistration != null) {
registrations.add(neutronVPNIPSECSiteConnectionsInterfaceRegistration);
package org.opendaylight.neutron.transcriber;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronFirewallCRUD;
import org.opendaylight.neutron.spi.NeutronFirewall;
import org.slf4j.Logger;
import java.util.concurrent.ConcurrentMap;
/**
- * Deprecated as all Neutron FWaaS is experimental and so doesn't meet
+ * Deprecated as all Neutron FWaaS is experimental and so doesn't meet
* the scope of neutron northbound
*
* @deprecated
*/
-public class NeutronFirewallInterface implements INeutronFirewallCRUD {
+public class NeutronFirewallInterface extends AbstractNeutronInterface implements INeutronFirewallCRUD {
+
private static final Logger logger = LoggerFactory.getLogger(NeutronFirewallInterface.class);
private ConcurrentMap<String, NeutronFirewall> firewallDB = new ConcurrentHashMap<String, NeutronFirewall>();
+
+ NeutronFirewallInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronFirewallPolicyCRUD;
-import org.opendaylight.neutron.spi.NeutronFirewallPolicy;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronFirewallPolicyCRUD;
+import org.opendaylight.neutron.spi.NeutronFirewallPolicy;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
- * Deprecated as all Neutron FWaaS is experimental and so doesn't meet
+ * Deprecated as all Neutron FWaaS is experimental and so doesn't meet
* the scope of neutron northbound
*
* @deprecated
*/
-public class NeutronFirewallPolicyInterface implements INeutronFirewallPolicyCRUD {
+public class NeutronFirewallPolicyInterface extends AbstractNeutronInterface implements INeutronFirewallPolicyCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronFirewallPolicyInterface.class);
private ConcurrentMap<String, NeutronFirewallPolicy> firewallPolicyDB = new ConcurrentHashMap<String, NeutronFirewallPolicy>();
+
+ NeutronFirewallPolicyInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronFirewallRuleCRUD;
-import org.opendaylight.neutron.spi.NeutronFirewallRule;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronFirewallRuleCRUD;
+import org.opendaylight.neutron.spi.NeutronFirewallRule;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
/**
- * Deprecated as all Neutron FWaaS is experimental and so doesn't meet
+ * Deprecated as all Neutron FWaaS is experimental and so doesn't meet
* the scope of neutron northbound
*
* @deprecated
*/
-public class NeutronFirewallRuleInterface implements INeutronFirewallRuleCRUD {
+public class NeutronFirewallRuleInterface extends AbstractNeutronInterface implements INeutronFirewallRuleCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronFirewallRuleInterface.class);
private ConcurrentMap<String, NeutronFirewallRule> firewallRuleDB = new ConcurrentHashMap<String, NeutronFirewallRule>();
+
+ NeutronFirewallRuleInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronFloatingIPCRUD;
import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.INeutronPortCRUD;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronFloatingIPInterface implements INeutronFloatingIPCRUD {
+public class NeutronFloatingIPInterface extends AbstractNeutronInterface implements INeutronFloatingIPCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronFloatingIPInterface.class);
private ConcurrentMap<String, NeutronFloatingIP> floatingIPDB = new ConcurrentHashMap<String, NeutronFloatingIP>();
+
+ NeutronFloatingIPInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
@SuppressWarnings("unused")
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerHealthMonitorCRUD;
-import org.opendaylight.neutron.spi.NeutronLoadBalancerHealthMonitor;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-public class NeutronLoadBalancerHealthMonitorInterface implements INeutronLoadBalancerHealthMonitorCRUD {
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerHealthMonitorCRUD;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerHealthMonitor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NeutronLoadBalancerHealthMonitorInterface extends AbstractNeutronInterface implements INeutronLoadBalancerHealthMonitorCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronLoadBalancerHealthMonitorInterface.class);
private ConcurrentMap<String, NeutronLoadBalancerHealthMonitor> loadBalancerHealthMonitorDB = new ConcurrentHashMap<String, NeutronLoadBalancerHealthMonitor>();
+ NeutronLoadBalancerHealthMonitorInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
-import org.opendaylight.neutron.spi.NeutronLoadBalancer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-public class NeutronLoadBalancerInterface implements INeutronLoadBalancerCRUD {
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
+import org.opendaylight.neutron.spi.NeutronLoadBalancer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NeutronLoadBalancerInterface extends AbstractNeutronInterface implements INeutronLoadBalancerCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronLoadBalancerInterface.class);
private ConcurrentMap<String, NeutronLoadBalancer> loadBalancerDB = new ConcurrentHashMap<String, NeutronLoadBalancer>();
+ NeutronLoadBalancerInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerListenerCRUD;
-import org.opendaylight.neutron.spi.NeutronLoadBalancerListener;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-public class NeutronLoadBalancerListenerInterface implements INeutronLoadBalancerListenerCRUD {
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerListenerCRUD;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NeutronLoadBalancerListenerInterface extends AbstractNeutronInterface implements INeutronLoadBalancerListenerCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronLoadBalancerListenerInterface.class);
private ConcurrentMap<String, NeutronLoadBalancerListener> loadBalancerListenerDB = new ConcurrentHashMap<String, NeutronLoadBalancerListener>();
+ NeutronLoadBalancerListenerInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
-import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-public class NeutronLoadBalancerPoolInterface implements INeutronLoadBalancerPoolCRUD {
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NeutronLoadBalancerPoolInterface extends AbstractNeutronInterface implements INeutronLoadBalancerPoolCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronLoadBalancerPoolInterface.class);
private ConcurrentMap<String, NeutronLoadBalancerPool> loadBalancerPoolDB = new ConcurrentHashMap<String, NeutronLoadBalancerPool>();
+ NeutronLoadBalancerPoolInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
package org.opendaylight.neutron.transcriber;
-import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberCRUD;
-import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolMemberCRUD;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
public class NeutronLoadBalancerPoolMemberInterface
+ extends AbstractNeutronInterface
implements INeutronLoadBalancerPoolMemberCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronLoadBalancerPoolMemberInterface.class);
private ConcurrentMap<String, NeutronLoadBalancerPoolMember> loadBalancerPoolMemberDB = new ConcurrentHashMap<String, NeutronLoadBalancerPoolMember>();
+ NeutronLoadBalancerPoolMemberInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronMeteringLabelCRUD;
import org.opendaylight.neutron.spi.NeutronMeteringLabel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronMeteringLabelInterface implements INeutronMeteringLabelCRUD {
+public class NeutronMeteringLabelInterface extends AbstractNeutronInterface implements INeutronMeteringLabelCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronMeteringLabelInterface.class);
private ConcurrentMap<String, NeutronMeteringLabel> meteringLabelDB = new ConcurrentHashMap<String, NeutronMeteringLabel>();
-
-
+ NeutronMeteringLabelInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronMeteringLabelRuleCRUD;
import org.opendaylight.neutron.spi.NeutronMeteringLabelRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronMeteringLabelRuleInterface implements INeutronMeteringLabelRuleCRUD {
+public class NeutronMeteringLabelRuleInterface extends AbstractNeutronInterface implements INeutronMeteringLabelRuleCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronMeteringLabelRuleInterface.class);
private ConcurrentMap<String, NeutronMeteringLabelRule> meteringLabelRuleDB = new ConcurrentHashMap<String, NeutronMeteringLabelRule>();
+ NeutronMeteringLabelRuleInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronNetworkInterface implements INeutronNetworkCRUD {
+public class NeutronNetworkInterface extends AbstractNeutronInterface implements INeutronNetworkCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronNetworkInterface.class);
private ConcurrentMap<String, NeutronNetwork> networkDB = new ConcurrentHashMap<String, NeutronNetwork>();
+ NeutronNetworkInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.INeutronPortCRUD;
import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronPortInterface implements INeutronPortCRUD {
+public class NeutronPortInterface extends AbstractNeutronInterface implements INeutronPortCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronPortInterface.class);
private ConcurrentMap<String, NeutronPort> portDB = new ConcurrentHashMap<String, NeutronPort>();
+ NeutronPortInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronRouterCRUD;
import org.opendaylight.neutron.spi.NeutronRouter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronRouterInterface implements INeutronRouterCRUD {
+public class NeutronRouterInterface extends AbstractNeutronInterface implements INeutronRouterCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronRouterInterface.class);
private ConcurrentMap<String, NeutronRouter> routerDB = new ConcurrentHashMap<String, NeutronRouter>();
// methods needed for creating caches
+ NeutronRouterInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
-import java.util.Map.Entry;
import java.util.List;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
import org.opendaylight.neutron.spi.NeutronSecurityGroup;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronSecurityGroupInterface implements INeutronSecurityGroupCRUD {
+public class NeutronSecurityGroupInterface extends AbstractNeutronInterface implements INeutronSecurityGroupCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronSecurityGroupInterface.class);
private ConcurrentMap<String, NeutronSecurityGroup> securityGroupDB = new ConcurrentHashMap<String, NeutronSecurityGroup>();
+ NeutronSecurityGroupInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
-import java.util.Map.Entry;
import java.util.List;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronSecurityRuleCRUD;
import org.opendaylight.neutron.spi.NeutronSecurityRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronSecurityRuleInterface implements INeutronSecurityRuleCRUD {
+public class NeutronSecurityRuleInterface extends AbstractNeutronInterface implements INeutronSecurityRuleCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronSecurityRuleInterface.class);
private ConcurrentMap<String, NeutronSecurityRule> securityRuleDB = new ConcurrentHashMap<String, NeutronSecurityRule>();
+
+ NeutronSecurityRuleInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
Method[] methods = target.getClass().getMethods();
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronSubnetInterface implements INeutronSubnetCRUD {
+public class NeutronSubnetInterface extends AbstractNeutronInterface implements INeutronSubnetCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronSubnetInterface.class);
private ConcurrentMap<String, NeutronSubnet> subnetDB = new ConcurrentHashMap<String, NeutronSubnet>();
+ NeutronSubnetInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
--- /dev/null
+package org.opendaylight.neutron.transcriber;
+
+import java.util.List;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
+import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceRegistration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NeutronTranscriberProvider implements BindingAwareProvider, AutoCloseable {
+ private static final Logger logger = LoggerFactory.getLogger(NeutronTranscriberProvider.class);
+
+ private BundleContext bundleContext;
+
+ private List<ServiceRegistration<?>> registrations;
+
+ private Activator activator;
+
+ public NeutronTranscriberProvider(BundleContext bundleContext) {
+ logger.warn("BundleContext set to: {}",bundleContext);
+ this.bundleContext = bundleContext;
+ }
+
+ @Override
+ public void onSessionInitiated(ProviderContext providerContext) {
+ this.activator = new Activator(providerContext);
+ try {
+ logger.warn("BundleContext found to be: {}",bundleContext);
+ this.activator.start(bundleContext);
+ } catch (Exception e) {
+ logger.warn("Unable to start Neutron Transcriber because: ",e);
+ }
+ }
+
+ @Override
+ public void close() throws Exception {
+ this.activator.stop(bundleContext);
+ }
+}
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronVPNIKEPolicyCRUD;
import org.opendaylight.neutron.spi.NeutronVPNIKEPolicy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronVPNIKEPolicyInterface implements INeutronVPNIKEPolicyCRUD {
+public class NeutronVPNIKEPolicyInterface extends AbstractNeutronInterface implements INeutronVPNIKEPolicyCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronVPNIKEPolicyInterface.class);
private ConcurrentMap<String, NeutronVPNIKEPolicy> meteringLabelRuleDB = new ConcurrentHashMap<String, NeutronVPNIKEPolicy>();
+ NeutronVPNIKEPolicyInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
// this method uses reflection to update an object from it's delta.
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-import org.opendaylight.neutron.spi.NeutronVPNIPSECSiteConnection;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronVPNIPSECSiteConnectionsCRUD;
+import org.opendaylight.neutron.spi.NeutronVPNIPSECSiteConnection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronVPNIPSECSiteConnectionsInterface implements INeutronVPNIPSECSiteConnectionsCRUD {
+public class NeutronVPNIPSECSiteConnectionsInterface extends AbstractNeutronInterface implements INeutronVPNIPSECSiteConnectionsCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronVPNIKEPolicyInterface.class);
private ConcurrentMap<String, NeutronVPNIPSECSiteConnection> neutronVPNIPSECSiteConnectionDB = new ConcurrentHashMap<String, NeutronVPNIPSECSiteConnection>();
+
+ NeutronVPNIPSECSiteConnectionsInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
-import java.util.Set;
import java.util.Map.Entry;
+import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.neutron.spi.INeutronVPNServiceCRUD;
import org.opendaylight.neutron.spi.NeutronVPNService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NeutronVPNServiceInterface implements INeutronVPNServiceCRUD {
+public class NeutronVPNServiceInterface extends AbstractNeutronInterface implements INeutronVPNServiceCRUD {
private static final Logger logger = LoggerFactory.getLogger(NeutronVPNServiceInterface.class);
private ConcurrentMap<String, NeutronVPNService> VPNServiceDB = new ConcurrentHashMap<String, NeutronVPNService>();
+
+ NeutronVPNServiceInterface(ProviderContext providerContext) {
+ super(providerContext);
+ }
+
// this method uses reflection to update an object from it's delta.
private boolean overwrite(Object target, Object delta) {
--- /dev/null
+package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.neutron.transcriber.impl.rev141210;
+
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.neutron.transcriber.NeutronTranscriberProvider;
+import org.osgi.framework.BundleContext;
+
+public class NeutronTranscriberImplModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.neutron.transcriber.impl.rev141210.AbstractNeutronTranscriberImplModule {
+ private BundleContext bundleContext;
+
+ public NeutronTranscriberImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public NeutronTranscriberImplModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.neutron.transcriber.impl.rev141210.NeutronTranscriberImplModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void customValidation() {
+ // add custom validation form module attributes here.
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ NeutronTranscriberProvider provider = new NeutronTranscriberProvider(bundleContext);
+ BindingAwareBroker localBroker = getBrokerDependency();
+ localBroker.registerProvider(provider);
+ return provider;
+ }
+
+ public void setBundleContext(BundleContext bundleContext) {
+ this.bundleContext = bundleContext;
+ }
+
+}
--- /dev/null
+/*
+* Generated file
+*
+* Generated from: yang module name: neutron-transcriber-impl yang module local name: neutron-transcriber-impl
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Mon Apr 20 09:49:26 PDT 2015
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.neutron.transcriber.impl.rev141210;
+
+import org.opendaylight.controller.config.api.DependencyResolver;
+import org.opendaylight.controller.config.api.DynamicMBeanWithInstance;
+import org.opendaylight.controller.config.spi.Module;
+import org.osgi.framework.BundleContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NeutronTranscriberImplModuleFactory extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.neutron.transcriber.impl.rev141210.AbstractNeutronTranscriberImplModuleFactory {
+
+ private static final Logger logger = LoggerFactory.getLogger(NeutronTranscriberImplModuleFactory.class);
+
+ @Override
+ public Module createModule(String instanceName,
+ DependencyResolver dependencyResolver,
+ DynamicMBeanWithInstance old, BundleContext bundleContext)
+ throws Exception {
+ // TODO Auto-generated method stub
+ Module neutronTranscriberModule = super.createModule(instanceName, dependencyResolver, old, bundleContext);
+ setModuleBundleContext(bundleContext, neutronTranscriberModule);
+ return neutronTranscriberModule;
+ }
+
+ private void setModuleBundleContext(BundleContext bundleContext,
+ Module neutronTranscriberModule) {
+ if(neutronTranscriberModule instanceof NeutronTranscriberImplModule) {
+ ((NeutronTranscriberImplModule)neutronTranscriberModule).setBundleContext(bundleContext);
+ } else {
+ logger.warn("Mysteriously, Module is of type {} expected type {}",
+ neutronTranscriberModule.getClass(),
+ NeutronTranscriberImplModule.class);
+ }
+ }
+
+ @Override
+ public Module createModule(String instanceName,
+ DependencyResolver dependencyResolver, BundleContext bundleContext) {
+ // TODO Auto-generated method stub
+ Module neutronTranscriberModule = super.createModule(instanceName, dependencyResolver, bundleContext);
+ setModuleBundleContext(bundleContext, neutronTranscriberModule);
+ return neutronTranscriberModule;
+ }
+
+
+
+}
--- /dev/null
+module neutron-transcriber-impl {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:neutron:transcriber:impl";
+ prefix "neutron-transcriber-impl";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
+
+ description
+ "Service definition for southbound project";
+
+ revision "2014-12-10" {
+ description
+ "Initial revision";
+ }
+
+ identity neutron-transcriber-impl {
+ base config:module-type;
+ config:java-name-prefix NeutronTranscriberImpl;
+ }
+
+ augment "/config:modules/config:module/config:configuration" {
+ case neutron-transcriber-impl {
+ when "/config:modules/config:module/config:type = 'neutron-transcriber-impl'";
+ container broker {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity md-sal-binding:binding-broker-osgi-registry;
+ }
+ }
+ }
+ }
+ }
+}
Code Review / neutron.git / commitdiff