import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import org.opendaylight.controller.liblldp.Packet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.endpoint.endpoint.type.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.endpoint.endpoint.type.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.monitor.configs.MonitoringInfo;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.OdlArputilService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.SendArpRequestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.arputil.rev151126.SendArpRequestInputBuilder;
BigInteger metadata = packetReceived.getMatch().getMetadata().getMetadata();
int portTag = MetaDataUtil.getLportFromMetadata(metadata).intValue();
String interfaceName = null;
- NodeConnectorId connId = packetReceived.getMatch().getInPort();
-// try {
-// interfaceName = serviceProvider.getInterfaceManager().getInterfaceNameForInterfaceTag(portTag);
-// } catch(InterfaceNotFoundException e) {
-// LOG.warn("Error retrieving interface Name for tag {}", portTag, e);
-// }
+
+ try {
+ GetInterfaceFromIfIndexInput input = new GetInterfaceFromIfIndexInputBuilder().setIfIndex(portTag).build();
+ Future<RpcResult<GetInterfaceFromIfIndexOutput>> output = serviceProvider.getInterfaceManager().getInterfaceFromIfIndex(input);
+ RpcResult<GetInterfaceFromIfIndexOutput> result = output.get();
+ if(result.isSuccessful()) {
+ GetInterfaceFromIfIndexOutput ifIndexOutput = result.getResult();
+ interfaceName = ifIndexOutput.getInterfaceName();
+ } else {
+ LOG.warn("RPC call to get interface name for if index {} failed with errors {}", portTag, result.getErrors());
+ return null;
+ }
+ } catch(InterruptedException | ExecutionException e) {
+ LOG.warn("Error retrieving interface Name for tag {}", portTag, e);
+ }
if(!Strings.isNullOrEmpty(interfaceName)) {
String sourceIp = toStringIpAddress(packet.getSenderProtocolAddress());
String targetIp = toStringIpAddress(packet.getTargetProtocolAddress());
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.endpoint.endpoint.type.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.alivenessmonitor.rev150629.monitor.configs.MonitoringInfo;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
-//import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfaceType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetDpidFromInterfaceOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetInterfaceFromIfIndexOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.interfacemgr.rpcs.rev151003.GetPortFromInterfaceOutput;
}
String destInterfaceName = null;
- //TODO: Use latest interface RPC
-// try {
-// destInterfaceName = serviceProvider.getInterfaceManager().getInterfaceNameForInterfaceTag(portTag);
-// } catch(InterfaceNotFoundException e) {
-// LOG.warn("Error retrieving interface Name for tag {}", portTag, e);
-// }
+
+ try {
+ GetInterfaceFromIfIndexInput input = new GetInterfaceFromIfIndexInputBuilder().setIfIndex(portTag).build();
+ Future<RpcResult<GetInterfaceFromIfIndexOutput>> output = serviceProvider.getInterfaceManager().getInterfaceFromIfIndex(input);
+ RpcResult<GetInterfaceFromIfIndexOutput> result = output.get();
+ if(result.isSuccessful()) {
+ GetInterfaceFromIfIndexOutput ifIndexOutput = result.getResult();
+ destInterfaceName = ifIndexOutput.getInterfaceName();
+ } else {
+ LOG.warn("RPC call to get interface name for if index {} failed with errors {}", portTag, result.getErrors());
+ return null;
+ }
+ } catch(InterruptedException | ExecutionException e) {
+ LOG.warn("Error retrieving interface Name for tag {}", portTag, e);
+ }
if(!Strings.isNullOrEmpty(interfaceName)) {
String monitorKey = new StringBuilder().append(interfaceName).append(EtherTypes.LLDP).toString();
return;
}
}catch(InterruptedException | ExecutionException e) {
- LOG.error("Failed to retrieve RPC Result ", e);
+ LOG.error("Failed to retrieve interface service RPC Result ", e);
return;
}
public static final short dhcpServerPort = 67;
public static final int DEFAULT_LEASE_TIME = 86400;
+ public static final String DEFAULT_DOMAIN_NAME = "openstacklocal";
}
<artifactId>mdsalutil-api</artifactId>
<version>${vpnservices.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>neutronvpn-api</artifactId>
+ <version>${vpnservices.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.karaf.shell</groupId>
+ <artifactId>org.apache.karaf.shell.console</artifactId>
+ <version>${karaf.shell.console.version}</version>
+ </dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
<artifactId>model</artifactId>
<capability>urn:opendaylight:params:xml:ns:yang:dhcpservice:impl?module=dhcpservice-impl&revision=2015-07-10</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:mdsalutil:api?module=odl-mdsalutil&revision=2015-04-10</capability>
+ <capability>urn:opendaylight:params:xml:ns:yang:neutronvpn:api?module=neutronvpn-api&revision=2015-08-12</capability>
</required-capabilities>
<configuration>
<type xmlns:mdsalutil="urn:opendaylight:params:xml:ns:yang:mdsalutil:api">mdsalutil:odl-mdsalutil</type>
<name>mdsalutil-service</name>
</mdsalutil>
+ <neutronvpn>
+ <type xmlns:neutronvpn="urn:opendaylight:params:xml:ns:yang:neutronvpn:api">neutronvpn:neutronvpn-api</type>
+ <name>neutronvpn</name>
+ </neutronvpn>
</module>
</modules>
</data>
--- /dev/null
+/*
+ * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. 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.vpnservice.dhcpservice;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.dhcp.config.Configs;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.vpnservice.datastoreutils.AsyncDataChangeListenerBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DhcpConfig;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.vpnservice.dhcpservice.api.DHCPMConstants;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DhcpConfigListener extends AsyncDataChangeListenerBase<DhcpConfig, DhcpConfigListener> implements AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(DhcpConfigListener.class);
+
+ private ListenerRegistration<DataChangeListener> listenerRegistration;
+ private DhcpManager dhcpManager;
+
+ public DhcpConfigListener(final DataBroker db, final DhcpManager dhcpMgr) {
+ super(DhcpConfig.class, DhcpConfigListener.class);
+ dhcpManager = dhcpMgr;
+ registerListener(db);
+ }
+
+ private void registerListener(final DataBroker db) {
+ try {
+ listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ getWildCardPath(), DhcpConfigListener.this, AsyncDataBroker.DataChangeScope.SUBTREE);
+ } catch (final Exception e) {
+ LOG.error("NodeListener: DataChange listener registration fail!", e);
+ throw new IllegalStateException("NodeListener: registration Listener failed.", e);
+ }
+ }
+
+ protected InstanceIdentifier<DhcpConfig> getWildCardPath() {
+ return InstanceIdentifier.create(DhcpConfig.class);
+ }
+
+ @Override
+ public void close() throws Exception {
+ if (listenerRegistration != null) {
+ try {
+ listenerRegistration.close();
+ } catch (final Exception e) {
+ LOG.error("Error when cleaning up DhcpConfigListener.", e);
+ }
+ listenerRegistration = null;
+ }
+ LOG.debug("DhcpConfig Listener Closed");
+ }
+
+ @Override
+ protected void remove(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig del) {
+ LOG.trace("DhcpConfig removed: {}", del);
+ updateConfig(null);
+ }
+
+ @Override
+ protected void update(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig original, DhcpConfig update) {
+ LOG.trace("DhcpConfig changed to {}", update);
+ updateConfig(update);
+ }
+
+ @Override
+ protected void add(InstanceIdentifier<DhcpConfig> identifier, DhcpConfig add) {
+ LOG.trace("DhcpConfig added {}", add);
+ updateConfig(add);
+ }
+
+ private void updateConfig(DhcpConfig update) {
+ //TODO: Update operational with actual values
+ if(update == null || update.getConfigs() == null || update.getConfigs().isEmpty()) {
+ dhcpManager.setLeaseDuration(DHCPMConstants.DEFAULT_LEASE_TIME);
+ dhcpManager.setDefaultDomain(DHCPMConstants.DEFAULT_DOMAIN_NAME);
+ return;
+ }
+ Configs config = update.getConfigs().get(0);
+ if(config.getLeaseDuration() != null) {
+ dhcpManager.setLeaseDuration(config.getLeaseDuration());
+ }
+ if(config.getDefaultDomain() != null) {
+ dhcpManager.setDefaultDomain(config.getDefaultDomain());
+ //TODO: What to do if string is ""
+ }
+ }
+
+ @Override
+ protected DataChangeListener getDataChangeListener() {
+ return DhcpConfigListener.this;
+ }
+
+ @Override
+ protected DataChangeScope getDataChangeScope() {
+ return AsyncDataBroker.DataChangeScope.BASE;
+ }
+}
*/
package org.opendaylight.vpnservice.dhcpservice;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
+import org.opendaylight.vpnservice.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
import com.google.common.base.Optional;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
private int dhcpOptLeaseTime = 0;
private int dhcpOptRenewalTime = 0;
private int dhcpOptRebindingTime = 0;
- private String dhcpOptDefDomainName = "openstacklocal";
+ private String dhcpOptDefDomainName;
+ private INeutronVpnManager neutronVpnService;
private static final FutureCallback<Void> DEFAULT_CALLBACK =
new FutureCallback<Void>() {
this.mdsalUtil = mdsalManager;
}
+ public void setNeutronVpnService(INeutronVpnManager neutronVpnService) {
+ logger.debug("Setting NeutronVpn dependency");
+ this.neutronVpnService = neutronVpnService;
+ }
+
@Override
public void close() throws Exception {
logger.info("DHCP Manager Closed");
}
public Subnet getNeutronSubnet(Port nPort) {
- /* TODO: Once NeutronVpn is merged, use it to get Subnet
if (nPort != null) {
try {
return neutronVpnService.getNeutronSubnet(nPort.getFixedIps().get(0).getSubnetId());
logger.warn("Failed to get Neutron Subnet from Port: {}", e);
}
}
- */
- if (nPort.getFixedIps() != null && !nPort.getFixedIps().isEmpty()) {
- InstanceIdentifier<Subnet> sIid =
- InstanceIdentifier.create(Neutron.class).child(Subnets.class)
- .child(Subnet.class, new SubnetKey(nPort.getFixedIps().get(0).getSubnetId()));
- Optional<Subnet> optSubnet = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, sIid, broker);
- if (optSubnet.isPresent()) {
- return optSubnet.get();
- }
- }
return null;
}
public Port getNeutronPort(String name) {
- // TODO Once NeutronVpn is merged, use it to get port
- //return neutronVpnService.getNeutronPort(name);
- InstanceIdentifier<Ports> pIid = InstanceIdentifier.create(Neutron.class).child(Ports.class);
- Optional<Ports> optPorts = MDSALUtil.read(LogicalDatastoreType.CONFIGURATION, pIid, broker);
- if(optPorts.isPresent()) {
- for(Port port: optPorts.get().getPort()) {
- if(port.getUuid().getValue().startsWith(name.substring(3))) {
- return port;
- }
- }
- }
- return null;
+ return neutronVpnService.getNeutronPort(name);
}
}
*/
package org.opendaylight.vpnservice.dhcpservice;
-import java.math.BigInteger;
+import org.opendaylight.vpnservice.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
private NotificationProviderService notificationService;
private DhcpManager dhcpManager;
private NodeListener dhcpNodeListener;
+ private INeutronVpnManager neutronVpnManager;
+ private DhcpConfigListener dhcpConfigListener;
@Override
public void onSessionInitiated(ProviderContext session) {
final PacketProcessingService pktProcessingService = session.getRpcService(PacketProcessingService.class);
dhcpManager = new DhcpManager(dataBroker);
dhcpManager.setMdsalManager(mdsalManager);
+ dhcpManager.setNeutronVpnService(neutronVpnManager);
dhcpPktHandler = new DhcpPktHandler(dataBroker, dhcpManager);
dhcpPktHandler.setPacketProcessingService(pktProcessingService);
packetListener = notificationService.registerNotificationListener(dhcpPktHandler);
dhcpNodeListener = new NodeListener(dataBroker, dhcpManager);
+ dhcpConfigListener = new DhcpConfigListener(dataBroker, dhcpManager);
} catch (Exception e) {
LOG.error("Error initializing services", e);
}
this.mdsalManager = mdsalManager;
}
+ public void setNeutronVpnManager(INeutronVpnManager neutronVpnManager) {
+ this.neutronVpnManager = neutronVpnManager;
+ }
+
@Override
public void close() throws Exception {
if(packetListener != null) {
DhcpProvider dhcpProvider = new DhcpProvider();
dhcpProvider.setNotificationProviderService(getNotificationServiceDependency());
dhcpProvider.setMdsalManager(getMdsalutilDependency());
+ dhcpProvider.setNeutronVpnManager(getNeutronvpnDependency());
getBrokerDependency().registerProvider(dhcpProvider);
return dhcpProvider;
}
import config { prefix config; revision-date 2013-04-05; }
import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28;}
import odl-mdsalutil { prefix odl-mdsal; revision-date 2015-04-10;}
+ import neutronvpn-api { prefix nvpn; revision-date 2015-08-12;}
description
"Service definition for dhcpservice project";
}
}
}
+
+ container neutronvpn {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity nvpn:neutronvpn-api;
+ }
+ }
+ }
}
}
}
-->
<snapshot>
<required-capabilities>
- <capability>urn:opendaylight:params:xml:ns:yang:itm?module=itm&revision=2015-07-01</capability>
- <capability>urn:opendaylight:params:xml:ns:yang:itm:impl?module=itm-impl&revision=2014-12-10</capability>
+ <capability>urn:opendaylight:vpnservice:itm?module=itm&revision=2015-07-01</capability>
+ <capability>urn:opendaylight:vpnservice:itm:impl?module=itm-impl&revision=2014-12-10</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:binding:impl?module=opendaylight-sal-binding-broker-impl&revision=2013-10-28</capability>
<capability>urn:opendaylight:params:xml:ns:yang:mdsalutil:api?module=odl-mdsalutil&revision=2015-04-10</capability>
<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:itm:impl">prefix:itm</type>
+ <type xmlns:prefix="urn:opendaylight:vpnservice:itm:impl">prefix:itm</type>
<name>itm-default</name>
<broker>
<type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
</modules>
<services xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
<service>
- <type xmlns:prefix="urn:opendaylight:params:xml:ns:yang:itm">prefix:itm</type>
+ <type xmlns:prefix="urn:opendaylight:vpnservice:itm">prefix:itm</type>
<instance>
<name>itm</name>
<provider>/modules/module[type='itm'][name='itm-default']</provider>
}
}
+ /* container for DHCP Configuration */
+ container dhcp-config {
+ list configs {
+ leaf lease-duration {
+ type int32;
+ description "default lease duration for dhcp lease.
+ -1 means infinite";
+ }
+ leaf default-domain {
+ type string;
+ description "default domain-name. used in dhcp reply";
+ }
+ }
+ }
+
rpc createL3VPN{
description "Create one or more L3 VPN";
input {