From 4582fda1bcb5c39a57e8f3900f7ec534d1107faa Mon Sep 17 00:00:00 2001 From: Viji J Date: Tue, 3 May 2016 19:18:48 +0530 Subject: [PATCH] Integration of fcaps applications Change-Id: If2fffa37ebed025b203b280ebf7b88a606c4823d Signed-off-by: Viji J --- .../fcapsapplication-impl/pom.xml | 91 ++++++++ .../vpnservice/fcapsapp/FcapsProvider.java | 96 +++++++++ .../fcapsapp/NodeEventListener.java | 132 ++++++++++++ .../vpnservice/fcapsapp/alarm/AlarmAgent.java | 139 ++++++++++++ .../FlowCapableNodeConnectorCommitter.java | 52 +++++ ...wNodeConnectorInventoryTranslatorImpl.java | 202 ++++++++++++++++++ .../NodeConnectorEventListener.java | 53 +++++ .../performancecounter/NodeUpdateCounter.java | 59 +++++ .../fcapsapp/performancecounter/PMAgent.java | 93 ++++++++ .../PacketInCounterHandler.java | 90 ++++++++ .../fcapsapp/portinfo/PortNameMapping.java | 65 ++++++ .../portinfo/PortNameMappingMBean.java | 16 ++ .../fcaps/app/rev151211/FcapsAppModule.java | 28 +++ .../app/rev151211/FcapsAppModuleFactory.java | 13 ++ .../main/resources/initial/73-fcaps-app.xml | 50 +++++ .../src/main/yang/fcaps-app.yang | 64 ++++++ .../fcapsapplication-jmxapi/pom.xml | 23 ++ .../fcapsappjmx/ControlPathFailureAlarm.java | 65 ++++++ .../ControlPathFailureAlarmMBean.java | 20 ++ .../fcapsappjmx/NumberOfOFPorts.java | 25 +++ .../fcapsappjmx/NumberOfOFPortsMBean.java | 18 ++ .../fcapsappjmx/NumberOfOFSwitchCounter.java | 25 +++ .../NumberOfOFSwitchCounterMBean.java | 18 ++ .../fcapsappjmx/PacketInCounter.java | 25 +++ .../fcapsappjmx/PacketInCounterMBean.java | 18 ++ fcapsapplication/pom.xml | 49 +++++ features/pom.xml | 13 +- features/src/main/features/features.xml | 9 +- pom.xml | 1 + 29 files changed, 1548 insertions(+), 4 deletions(-) create mode 100644 fcapsapplication/fcapsapplication-impl/pom.xml create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/FcapsProvider.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/NodeEventListener.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/alarm/AlarmAgent.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowCapableNodeConnectorCommitter.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeConnectorEventListener.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeUpdateCounter.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PMAgent.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PacketInCounterHandler.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMapping.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMappingMBean.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModule.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModuleFactory.java create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/resources/initial/73-fcaps-app.xml create mode 100644 fcapsapplication/fcapsapplication-impl/src/main/yang/fcaps-app.yang create mode 100644 fcapsapplication/fcapsapplication-jmxapi/pom.xml create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarm.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarmMBean.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPorts.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPortsMBean.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounter.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounterMBean.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounter.java create mode 100644 fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounterMBean.java create mode 100644 fcapsapplication/pom.xml diff --git a/fcapsapplication/fcapsapplication-impl/pom.xml b/fcapsapplication/fcapsapplication-impl/pom.xml new file mode 100644 index 0000000000..39a450dc91 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/pom.xml @@ -0,0 +1,91 @@ + + + + + org.opendaylight.vpnservice + config-parent + 0.3.0-SNAPSHOT + ../../commons/config-parent + + + 4.0.0 + org.opendaylight.vpnservice + fcapsapplication-impl + ${vpnservices.version} + bundle + + + + org.opendaylight.controller + sal-binding-broker-impl + + + org.opendaylight.controller + config-api + + + org.opendaylight.controller + sal-binding-api + + + org.opendaylight.controller + sal-binding-config + + + org.opendaylight.vpnservice + fcapsapplication-jmxapi + ${vpnservices.version} + + + org.opendaylight.openflowplugin.model + model-flow-service + ${openflowplugin.version} + + + org.opendaylight.openflowplugin + openflowplugin-common + ${openflowplugin.version} + + + + + + org.apache.felix + maven-bundle-plugin + + + org.opendaylight.yangtools + yang-maven-plugin + + + + org.codehaus.mojo + build-helper-maven-plugin + + + attach-artifacts + + attach-artifact + + package + + + + ${project.build.directory}/classes/initial/73-fcaps-app.xml + xml + config + + + + + + + + + diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/FcapsProvider.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/FcapsProvider.java new file mode 100644 index 0000000000..b890afc93e --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/FcapsProvider.java @@ -0,0 +1,96 @@ +/* + * 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.fcapsapp; + +import com.google.common.base.Preconditions; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; +import org.opendaylight.controller.md.sal.binding.api.NotificationService; +import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.vpnservice.fcapsapp.performancecounter.FlowNodeConnectorInventoryTranslatorImpl; +import org.opendaylight.vpnservice.fcapsapp.performancecounter.PMAgent; +import org.opendaylight.vpnservice.fcapsapp.performancecounter.PacketInCounterHandler; +import org.opendaylight.vpnservice.fcapsapp.portinfo.PortNameMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; +import org.opendaylight.vpnservice.fcapsapp.alarm.AlarmAgent; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class FcapsProvider implements AutoCloseable { + + public static Logger s_logger = LoggerFactory.getLogger(FcapsProvider.class); + private final DataBroker dataService; + private final NotificationService notificationProviderService; + private final EntityOwnershipService entityOwnershipService; + private FlowNodeConnectorInventoryTranslatorImpl flowNodeConnectorInventoryTranslatorImpl; + private PacketInCounterHandler packetInCounterHandler; + private NodeEventListener nodeNodeEventListener; + private final AlarmAgent alarmAgent; + private final PMAgent pmAgent; + + /** + * Contructor sets the services + * @param dataBroker instance of databroker + * @param notificationService instance of notificationservice + * @param eos instance of EntityOwnershipService + */ + public FcapsProvider(DataBroker dataBroker,NotificationService notificationService, + final EntityOwnershipService eos) { + this.dataService = Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!"); + s_logger.info("FcapsProvider dataBroket is set"); + + this.notificationProviderService = Preconditions.checkNotNull(notificationService, + "notificationService can not be null!"); + s_logger.info("FcapsProvider notificationProviderService is set"); + + this.entityOwnershipService = Preconditions.checkNotNull(eos, "EntityOwnership service can not be null"); + s_logger.info("FcapsProvider entityOwnershipService is set"); + + alarmAgent = new AlarmAgent(); + pmAgent = new PMAgent(); + + alarmAgent.registerAlarmMbean(); + + pmAgent.registerMbeanForEFS(); + pmAgent.registerMbeanForPorts(); + pmAgent.registerMbeanForPacketIn(); + PortNameMapping.registerPortMappingBean(); + + nodeNodeEventListener = new NodeEventListener<>(entityOwnershipService); + registerListener(dataService); + flowNodeConnectorInventoryTranslatorImpl = new + FlowNodeConnectorInventoryTranslatorImpl(dataService,entityOwnershipService); + packetInCounterHandler = new PacketInCounterHandler(); + notificationProviderService.registerNotificationListener(packetInCounterHandler); + } + + private void registerListener(DataBroker dataBroker) { + final DataTreeIdentifier treeId = + new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, getWildCardPath()); + try { + dataBroker.registerDataTreeChangeListener(treeId, nodeNodeEventListener); + } catch (Exception e) { + s_logger.error("Registeration failed on DataTreeChangeListener {}",e); + } + } + + private InstanceIdentifier getWildCardPath() { + return InstanceIdentifier.create(Nodes.class) + .child(Node.class) + .augmentation(FlowCapableNode.class); + } + + @Override + public void close() throws Exception { + + } +} diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/NodeEventListener.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/NodeEventListener.java new file mode 100644 index 0000000000..8b0be7cb8b --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/NodeEventListener.java @@ -0,0 +1,132 @@ +/* + * 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.fcapsapp; + +import com.google.common.base.Optional; +import org.opendaylight.controller.md.sal.binding.api.*; + +import org.opendaylight.controller.md.sal.common.api.clustering.Entity; +import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService; +import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; +import org.opendaylight.vpnservice.fcapsapp.alarm.AlarmAgent; +import org.opendaylight.vpnservice.fcapsapp.performancecounter.NodeUpdateCounter; +import org.opendaylight.vpnservice.fcapsapp.performancecounter.PacketInCounterHandler; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import java.net.InetAddress; +import java.util.Collection; + +public class NodeEventListener implements ClusteredDataTreeChangeListener,AutoCloseable { + private static final Logger LOG = LoggerFactory.getLogger(NodeEventListener.class); + public static final AlarmAgent alarmAgent = new AlarmAgent(); + public static final NodeUpdateCounter nodeUpdateCounter = new NodeUpdateCounter(); + public static final PacketInCounterHandler packetInCounter = new PacketInCounterHandler(); + private final EntityOwnershipService entityOwnershipService; + + /** + * Construcor set EntityOwnershipService + * @param eos + */ + public NodeEventListener(final EntityOwnershipService eos) { + this.entityOwnershipService = eos; + } + + @Override + public void onDataTreeChanged(Collection> changes) { + for (DataTreeModification change : changes) { + final InstanceIdentifier key = change.getRootPath().getRootIdentifier(); + final DataObjectModification mod = change.getRootNode(); + final InstanceIdentifier nodeConnIdent = + key.firstIdentifierOf(FlowCapableNode.class); + String nodeId = null, hostName = null; + try { + nodeId = getDpnId(String.valueOf(nodeConnIdent.firstKeyOf(Node.class).getId())); + } catch (Exception ex) { + LOG.error("Dpn retrieval failed"); + return; + } + + hostName = System.getenv().get("HOSTNAME"); + if (hostName == null) { + try { + hostName = InetAddress.getLocalHost().getHostName(); + } catch (Exception e) { + LOG.error("Retrieving hostName failed {}", e); + } + } + LOG.debug("retrieved hostname {}", hostName); + if (nodeId != null) { + switch (mod.getModificationType()) { + case DELETE: + LOG.debug("NodeRemoved {} notification is received on host {}", nodeId, hostName); + if (nodeUpdateCounter.isDpnConnectedLocal(nodeId)) { + alarmAgent.raiseControlPathAlarm(nodeId, hostName); + nodeUpdateCounter.nodeRemovedNotification(nodeId, hostName); + } + packetInCounter.nodeRemovedNotification(nodeId); + break; + case SUBTREE_MODIFIED: + if (isNodeOwner(nodeId)) { + LOG.debug("NodeUpdated {} notification is received", nodeId); + } else { + LOG.debug("UPDATE: Node {} is not connected to host {}", nodeId, hostName); + } + break; + case WRITE: + if (mod.getDataBefore() == null) { + if (isNodeOwner(nodeId)) { + LOG.debug("NodeAdded {} notification is received on host {}", nodeId, hostName); + alarmAgent.clearControlPathAlarm(nodeId); + nodeUpdateCounter.nodeAddedNotification(nodeId, hostName); + } else { + LOG.debug("ADD: Node {} is not connected to host {}", nodeId, hostName); + } + } + break; + default: + LOG.debug("Unhandled Modification type {}", mod.getModificationType()); + throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType()); + + } + } else { + LOG.error("DpnID is null"); + } + } + } + + private String getDpnId(String node) { + //Uri [_value=openflow:1] + String temp[] = node.split("="); + String dpnId = temp[1].substring(0,temp[1].length() - 1); + return dpnId; + + } + + /** + * Method checks if *this* instance of controller is owner of + * the given openflow node. + * @param nodeId DpnId + * @return True if owner, else false + */ + public boolean isNodeOwner(String nodeId) { + Entity entity = new Entity("openflow", nodeId); + Optional entityState = this.entityOwnershipService.getOwnershipState(entity); + if (entityState.isPresent()) { + return entityState.get().isOwner(); + } + return false; + } + + @Override + public void close() throws Exception { + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/alarm/AlarmAgent.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/alarm/AlarmAgent.java new file mode 100644 index 0000000000..e8cb1d453e --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/alarm/AlarmAgent.java @@ -0,0 +1,139 @@ +/* + * 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.fcapsapp.alarm; + +import org.opendaylight.vpnservice.fcapsappjmx.ControlPathFailureAlarm; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.management.MBeanServer; +import javax.management.MalformedObjectNameException; +import javax.management.ObjectName; +import java.lang.management.ManagementFactory; + +public class AlarmAgent { + static Logger s_logger = LoggerFactory.getLogger(AlarmAgent.class); + private MBeanServer mbs = null; + private ObjectName alarmName = null; + private static final String BEANNAME = "SDNC.FM:name=ControlPathFailureAlarmBean"; + private static ControlPathFailureAlarm alarmBean = new ControlPathFailureAlarm(); + + /** + * constructor get the instance of platform MBeanServer + */ + public AlarmAgent() { + mbs = ManagementFactory.getPlatformMBeanServer(); + try { + alarmName = new ObjectName(BEANNAME); + } catch (MalformedObjectNameException e) { + s_logger.error("ObjectName instance creation failed for BEANAME {} : {}",BEANNAME, e); + } + } + + /** + * Method registers alarm mbean in platform MbeanServer + */ + public void registerAlarmMbean() { + try { + if (!mbs.isRegistered(alarmName)) { + mbs.registerMBean(alarmBean, alarmName); + s_logger.info("Registered Mbean {} successfully", alarmName); + } + } catch (Exception e) { + s_logger.error("Registeration failed for Mbean {} :{}", alarmName,e); + } + } + + /** + * Method invoke raise alarm JMX API in platform MbeanServer with alarm details + * @param alarmId + * alarm to be raised + * @param text + * Additional details describing about the alarm on which dpnId and hostname + * @param src + * Source of the alarm ex: dpnId=openflow:1 + * the source node that caused this alarm + */ + public void invokeFMraisemethod(String alarmId,String text,String src) { + try { + mbs.invoke(alarmName, "raiseAlarm", new Object[]{alarmId, text, src}, + new String[]{String.class.getName(), String.class.getName(), String.class.getName()}); + s_logger.debug("Invoked raiseAlarm function for Mbean {} with source {}", BEANNAME, src); + } catch (Exception e) { + s_logger.error("Invoking raiseAlarm method failed for Mbean {} :{}", alarmName,e); + } + } + + /** + * Method invoke clear alarm JMX API in platform MbeanServer with alarm details + * @param alarmId + * alarm to be cleared + * @param text + * Additional details describing about the alarm on which dpnId and hostname + * @param src + * Source of the alarm ex: dpn=openflow:1 + * the source node that caused this alarm + */ + public void invokeFMclearmethod(String alarmId,String text,String src) { + try { + mbs.invoke(alarmName, "clearAlarm", new Object[]{alarmId, text, src}, + new String[]{String.class.getName(), String.class.getName(), String.class.getName()}); + s_logger.debug("Invoked clearAlarm function for Mbean {} with source {}",BEANNAME,src); + } catch (Exception e) { + s_logger.error("Invoking clearAlarm method failed for Mbean {} :{}", alarmName,e); + } + } + + /** + * Method gets the alarm details to be raised and construct the alarm objects + * @param nodeId + * Source of the alarm dpnId + * @param host + * Controller hostname + */ + public void raiseControlPathAlarm(String nodeId,String host) { + StringBuilder alarmText = new StringBuilder(); + StringBuilder source = new StringBuilder(); + + if (host != null) { + try { + alarmText.append("OF Switch ").append(nodeId).append(" lost heart beat communication with controller ") + .append(host); + source.append("Dpn=").append(nodeId); + + s_logger.debug("Raising ControlPathConnectionFailure alarm... alarmText {} source {} ", alarmText, source); + //Invokes JMX raiseAlarm method + invokeFMraisemethod("ControlPathConnectionFailure", alarmText.toString(), source.toString()); + } catch (Exception e) { + s_logger.error("Exception before invoking raise method in jmx {}", e); + } + } else { + s_logger.error("Received hostname is null"); + } + } + + /** + * Method gets the alarm details to be cleared and construct the alarm objects + * @param nodeId + * Source of the alarm dpnId + */ + public void clearControlPathAlarm(String nodeId) { + StringBuilder source = new StringBuilder(); + + try { + source.append("Dpn=").append(nodeId); + s_logger.debug("Clearing ControlPathConnectionFailure alarm of source {} ", source); + //Invokes JMX clearAlarm method + invokeFMclearmethod("ControlPathConnectionFailure", "OF Switch gained communication with controller", + source.toString()); + } catch (Exception e) { + s_logger.error("Exception before invoking clear method jmx {}", e); + } + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowCapableNodeConnectorCommitter.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowCapableNodeConnectorCommitter.java new file mode 100644 index 0000000000..b3ec4ac37a --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowCapableNodeConnectorCommitter.java @@ -0,0 +1,52 @@ +/* + * 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.fcapsapp.performancecounter; + +import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener; +import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public interface FlowCapableNodeConnectorCommitter extends AutoCloseable, ClusteredDataTreeChangeListener { + /** + * Method removes DataObject which is identified by InstanceIdentifier + * from device. + * + * @param identifier - the whole path to DataObject + * @param del - DataObject for removing + * @param nodeConnIdent NodeConnector InstanceIdentifier + */ + void remove(InstanceIdentifier identifier, D del, + InstanceIdentifier nodeConnIdent); + + /** + * Method updates the original DataObject to the update DataObject + * in device. Both are identified by same InstanceIdentifier + * + * @param identifier - the whole path to DataObject + * @param original - original DataObject (for update) + * @param update - changed DataObject (contain updates) + * @param nodeConnIdent NodeConnector InstanceIdentifier + */ + void update(InstanceIdentifier identifier, D original, D update, + InstanceIdentifier nodeConnIdent); + + /** + * Method adds the DataObject which is identified by InstanceIdentifier + * to device. + * + * @param identifier - the whole path to new DataObject + * @param add - new DataObject + * @param nodeConnIdent NodeConnector InstanceIdentifier + */ + void add(InstanceIdentifier identifier, D add, + InstanceIdentifier nodeConnIdent); + +} + diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java new file mode 100644 index 0000000000..c3357738ec --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java @@ -0,0 +1,202 @@ +/* + * 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.fcapsapp.performancecounter; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.*; +import org.opendaylight.controller.md.sal.binding.api.*; +import org.opendaylight.controller.md.sal.common.api.clustering.Entity; +import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService; +import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper; +import org.opendaylight.vpnservice.fcapsapp.portinfo.PortNameMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import java.lang.String; +import java.util.HashMap; +import java.util.Collection; +import java.util.concurrent.Callable; + +public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEventListener { + public static final int STARTUP_LOOP_TICK = 500; + public static final int STARTUP_LOOP_MAX_RETRIES = 8; + private static final Logger LOG = LoggerFactory.getLogger(FlowNodeConnectorInventoryTranslatorImpl.class); + private final EntityOwnershipService entityOwnershipService; + + private ListenerRegistration dataTreeChangeListenerRegistration; + + public static final String SEPARATOR = ":"; + private static final PMAgent pmAgent = new PMAgent(); + + private static final InstanceIdentifier II_TO_FLOW_CAPABLE_NODE_CONNECTOR + = InstanceIdentifier.builder(Nodes.class) + .child(Node.class) + .child(NodeConnector.class) + .augmentation(FlowCapableNodeConnector.class) + .build(); + + private static Multimap dpnToPortMultiMap = Multimaps.synchronizedListMultimap(ArrayListMultimap.create()); + + private static HashMap nodeConnectorCountermap = new HashMap(); + + public FlowNodeConnectorInventoryTranslatorImpl(final DataBroker dataBroker,final EntityOwnershipService eos) { + super( FlowCapableNodeConnector.class); + Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!"); + + entityOwnershipService = eos; + final DataTreeIdentifier treeId = + new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, getWildCardPath()); + try { + SimpleTaskRetryLooper looper = new SimpleTaskRetryLooper(STARTUP_LOOP_TICK, + STARTUP_LOOP_MAX_RETRIES); + dataTreeChangeListenerRegistration = looper.loopUntilNoException(new Callable>() { + @Override + public ListenerRegistration call() throws Exception { + return dataBroker.registerDataTreeChangeListener(treeId, FlowNodeConnectorInventoryTranslatorImpl.this); + } + }); + } catch (final Exception e) { + LOG.warn(" FlowNodeConnectorInventoryTranslatorImpl listener registration fail!"); + LOG.debug("FlowNodeConnectorInventoryTranslatorImpl DataChange listener registration fail ..", e); + throw new IllegalStateException("FlowNodeConnectorInventoryTranslatorImpl startup fail! System needs restart.", e); + } + } + + + protected InstanceIdentifier getWildCardPath() { + return InstanceIdentifier.create(Nodes.class) + .child(Node.class) + .child(NodeConnector.class) + .augmentation(FlowCapableNodeConnector.class); + } + + @Override + public void close() { + if (dataTreeChangeListenerRegistration != null) { + try { + dataTreeChangeListenerRegistration.close(); + } catch (final Exception e) { + LOG.warn("Error by stop FRM FlowNodeConnectorInventoryTranslatorImpl: {}", e.getMessage()); + LOG.debug("Error by stop FRM FlowNodeConnectorInventoryTranslatorImpl..", e); + } + dataTreeChangeListenerRegistration = null; + } + } + @Override + public void remove(InstanceIdentifier identifier, FlowCapableNodeConnector del, InstanceIdentifier nodeConnIdent) { + if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE_CONNECTOR)) { + String sNodeConnectorIdentifier = getNodeConnectorId(String.valueOf(nodeConnIdent.firstKeyOf(NodeConnector.class).getId())); + long nDpId = getDpIdFromPortName(sNodeConnectorIdentifier); + if (dpnToPortMultiMap.containsKey(nDpId)) { + LOG.debug("Node Connector {} removed", sNodeConnectorIdentifier); + dpnToPortMultiMap.remove(nDpId, sNodeConnectorIdentifier); + sendNodeConnectorUpdation(nDpId); + PortNameMapping.updatePortMap("openflow:" + nDpId + ":" + del.getName(), sNodeConnectorIdentifier, "DELETE"); + } + } + } + + @Override + public void update(InstanceIdentifier identifier, FlowCapableNodeConnector original, FlowCapableNodeConnector update, InstanceIdentifier nodeConnIdent) { + if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE_CONNECTOR)) { + + //donot need to do anything as we are not considering updates here + String sNodeConnectorIdentifier = getNodeConnectorId(String.valueOf(nodeConnIdent.firstKeyOf(NodeConnector.class).getId())); + long nDpId = getDpIdFromPortName(sNodeConnectorIdentifier); + if (isNodeOwner(getNodeId(nDpId))) { + boolean original_portstatus = original.getConfiguration().isPORTDOWN(); + boolean update_portstatus = update.getConfiguration().isPORTDOWN(); + + if (update_portstatus == true) { + //port has gone down + LOG.debug("Node Connector {} updated port is down", sNodeConnectorIdentifier); + } else if (original_portstatus == true) { + //port has come up + LOG.debug("Node Connector {} updated port is up", sNodeConnectorIdentifier); + } + } + } + } + + @Override + public void add(InstanceIdentifier identifier, FlowCapableNodeConnector add, InstanceIdentifier nodeConnIdent) { + if (compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE_CONNECTOR)){ + + String sNodeConnectorIdentifier = getNodeConnectorId(String.valueOf(nodeConnIdent.firstKeyOf(NodeConnector.class).getId())); + long nDpId = getDpIdFromPortName(sNodeConnectorIdentifier); + if (isNodeOwner(getNodeId(nDpId))) { + if (!dpnToPortMultiMap.containsEntry(nDpId, sNodeConnectorIdentifier)) { + LOG.debug("Node Connector {} added", sNodeConnectorIdentifier); + dpnToPortMultiMap.put(nDpId, sNodeConnectorIdentifier); + sendNodeConnectorUpdation(nDpId); + PortNameMapping.updatePortMap("openflow:" + nDpId + ":" + add.getName(), sNodeConnectorIdentifier, "ADD"); + } else { + LOG.error("Duplicate Event.Node Connector already added"); + } + } + } + } + private String getNodeConnectorId(String node) { + //Uri [_value=openflow:1:1] + String temp[] = node.split("="); + String dpnId = temp[1].substring(0,temp[1].length() - 1); + return dpnId; + } + + private String getNodeId(Long dpnId){ + return "openflow:" + dpnId; + } + /** + * Method checks if *this* instance of controller is owner of + * the given openflow node. + * @param nodeId openflow node Id + * @return True if owner, else false + */ + public boolean isNodeOwner(String nodeId) { + Entity entity = new Entity("openflow", nodeId); + Optional eState = this.entityOwnershipService.getOwnershipState(entity); + if(eState.isPresent()) { + return eState.get().isOwner(); + } + return false; + } + + private boolean compareInstanceIdentifierTail(InstanceIdentifier identifier1, + InstanceIdentifier identifier2) { + return Iterables.getLast(identifier1.getPathArguments()).equals(Iterables.getLast(identifier2.getPathArguments())); + } + + private long getDpIdFromPortName(String portName) { + String dpId = portName.substring(portName.indexOf(SEPARATOR) + 1, portName.lastIndexOf(SEPARATOR)); + return Long.parseLong(dpId); + } + + private void sendNodeConnectorUpdation(Long dpnId) { + Collection portname = dpnToPortMultiMap.get(dpnId); + String nodeListPortsCountStr,counterkey; + nodeListPortsCountStr = "dpnId_" + dpnId + "_NumberOfOFPorts"; + counterkey = "NumberOfOFPorts:" + nodeListPortsCountStr; + + if (portname.size()!=0) { + nodeConnectorCountermap.put(counterkey, "" + portname.size()); + } else { + nodeConnectorCountermap.remove(counterkey); + } + LOG.debug("NumberOfOFPorts:" + nodeListPortsCountStr + " portlistsize " + portname.size()); + pmAgent.connectToPMAgentForNOOfPorts(nodeConnectorCountermap); + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeConnectorEventListener.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeConnectorEventListener.java new file mode 100644 index 0000000000..74272e6cfb --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeConnectorEventListener.java @@ -0,0 +1,53 @@ +/* + * 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.fcapsapp.performancecounter; + +import org.opendaylight.controller.md.sal.binding.api.*; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import java.util.Collection; + +public abstract class NodeConnectorEventListener implements ClusteredDataTreeChangeListener,AutoCloseable,FlowCapableNodeConnectorCommitter { + NodeConnectorEventListener(Class flowCapableNodeConnectorClass) { + } + + @Override + public void onDataTreeChanged(Collection> changes) { + for (DataTreeModification change : changes) { + final InstanceIdentifier key = change.getRootPath().getRootIdentifier(); + final DataObjectModification mod = change.getRootNode(); + final InstanceIdentifier nodeConnIdent = + key.firstIdentifierOf(FlowCapableNodeConnector.class); + + switch (mod.getModificationType()) { + case DELETE: + remove(key, mod.getDataBefore(), nodeConnIdent); + break; + case SUBTREE_MODIFIED: + update(key, mod.getDataBefore(), mod.getDataAfter(), nodeConnIdent); + break; + case WRITE: + if (mod.getDataBefore() == null) { + add(key, mod.getDataAfter(), nodeConnIdent); + } else { + update(key, mod.getDataBefore(), mod.getDataAfter(), nodeConnIdent); + } + break; + + + default: + throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType()); + } + } + } + + @Override + public void close() throws Exception { + } +} diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeUpdateCounter.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeUpdateCounter.java new file mode 100644 index 0000000000..c0cf9c2e01 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/NodeUpdateCounter.java @@ -0,0 +1,59 @@ +/* + * 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.fcapsapp.performancecounter; + + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import java.lang.Integer; +import java.lang.String; +import java.net.InetAddress; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; + +public class NodeUpdateCounter { + + private static final Logger LOG = LoggerFactory.getLogger(NodeUpdateCounter.class); + private String nodeListEFSCountStr; + private static HashSet dpnList = new HashSet(); + public static final PMAgent pmagent = new PMAgent(); + Map counter_map = new HashMap(); + + public NodeUpdateCounter() { + } + + public void nodeAddedNotification(String sNode,String hostName) { + dpnList.add(sNode); + sendNodeUpdation(dpnList.size(),hostName); + } + + public void nodeRemovedNotification(String sNode,String hostName) { + dpnList.remove(sNode); + sendNodeUpdation(dpnList.size(), hostName); + } + + private void sendNodeUpdation(Integer count,String hostName) { + + if (hostName != null) { + nodeListEFSCountStr = "Node_" + hostName + "_NumberOfEFS"; + LOG.debug("NumberOfEFS:" + nodeListEFSCountStr + " dpnList.size " + count); + + counter_map.put("NumberOfEFS:" + nodeListEFSCountStr, "" + count); + pmagent.connectToPMAgent(counter_map); + } else + LOG.error("Hostname is null upon NumberOfEFS counter"); + } + + public boolean isDpnConnectedLocal(String sNode) { + if (dpnList.contains(sNode)) + return true; + return false; + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PMAgent.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PMAgent.java new file mode 100644 index 0000000000..1a5031161e --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PMAgent.java @@ -0,0 +1,93 @@ +/* + * 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.fcapsapp.performancecounter; + + +import org.opendaylight.vpnservice.fcapsappjmx.NumberOfOFPorts; +import org.opendaylight.vpnservice.fcapsappjmx.NumberOfOFSwitchCounter; +import org.opendaylight.vpnservice.fcapsappjmx.PacketInCounter; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.management.*; +import java.lang.String; +import java.lang.management.ManagementFactory; +import java.util.Map; + +public class PMAgent { + private static Logger s_logger = LoggerFactory.getLogger(PMAgent.class); + private MBeanServer mbs = null; + private ObjectName switch_mbeanName = null; + private ObjectName port_mbeanName = null; + private ObjectName pktIn_mbeanName = null; + private static final String SWITCH_BEANNAME = "SDNC.PM:type=NumberOfOFSwitchCounter"; + private static final String PORTS_BEANNAME = "SDNC.PM:type=NumberOfOFPortsCounter"; + private static final String PKTIN_BEANNAME = "SDNC.PM:type=InjectedPacketInCounter"; + + private static NumberOfOFSwitchCounter switchCounterBean = new NumberOfOFSwitchCounter(); + private static NumberOfOFPorts PortcounterBean = new NumberOfOFPorts(); + private static PacketInCounter packetInCounter = new PacketInCounter(); + + public PMAgent() { + mbs = ManagementFactory.getPlatformMBeanServer(); + try { + switch_mbeanName = new ObjectName(SWITCH_BEANNAME); + port_mbeanName = new ObjectName(PORTS_BEANNAME); + pktIn_mbeanName = new ObjectName(PKTIN_BEANNAME); + } catch (MalformedObjectNameException e) { + s_logger.error("ObjectName instance creation failed for BEANAME {}", e); + + } + } + + public void registerMbeanForEFS() { + try { + if (!mbs.isRegistered(switch_mbeanName)) { + mbs.registerMBean(switchCounterBean, switch_mbeanName); + s_logger.info("Registered Mbean {} successfully", switch_mbeanName); + } + + } catch (Exception e) { + s_logger.error("Registeration failed for Mbean {} :{}", switch_mbeanName, e); + } + } + + public void registerMbeanForPorts() { + try { + if (!mbs.isRegistered(port_mbeanName)) { + mbs.registerMBean(PortcounterBean, port_mbeanName); + s_logger.info("Registered Mbean {} successfully", port_mbeanName); + } + } catch (Exception e) { + s_logger.error("Registeration failed for Mbean {} :{}", port_mbeanName, e); + } + } + + public void registerMbeanForPacketIn() { + try { + if (!mbs.isRegistered(pktIn_mbeanName)) { + mbs.registerMBean(packetInCounter,pktIn_mbeanName); + s_logger.info("Registered Mbean {} successfully",pktIn_mbeanName ); + } + } catch (Exception e) { + s_logger.error("Registeration failed for Mbean {} :{}",pktIn_mbeanName , e); + } + } + + public void connectToPMAgent(Map map) { + switchCounterBean.updateCounter(map); + } + + public void connectToPMAgentForNOOfPorts(Map map) { + PortcounterBean.updateCounter(map); + } + + public void sendPacketInCounterUpdate(Map map){ + packetInCounter.updateCounter(map); + } +} diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PacketInCounterHandler.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PacketInCounterHandler.java new file mode 100644 index 0000000000..36c8309448 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/performancecounter/PacketInCounterHandler.java @@ -0,0 +1,90 @@ +/* + * 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.fcapsapp.performancecounter; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener; +import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.HashMap; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +public class PacketInCounterHandler implements PacketProcessingListener { + private static final Logger LOG = LoggerFactory.getLogger(PacketInCounterHandler.class); + private static ConcurrentHashMap ingressPacketMap = new ConcurrentHashMap<>(); + private static HashMap packetInMap = new HashMap<>(); + private static final Integer FIRST_VALUE = 1; + private static final PMAgent pmAgent =new PMAgent(); + + @Override + public void onPacketReceived(PacketReceived notification) { + String dpnId = null; + String nodeListEgressStr, nodekey; + LOG.debug("Ingress packet notification received"); + try { + if (notification.getIngress() == null) { + if (LOG.isWarnEnabled()) { + LOG.warn("invalid PacketReceived notification"); + } + return; + } + dpnId = getDpnId(notification.getIngress().getValue().toString()); + } catch (Exception e) { + if (LOG.isWarnEnabled()) { + LOG.warn("DPN Parsing failed in onPacketReceived"); + } + } + if (dpnId != null) { + nodeListEgressStr = "dpnId_" + dpnId + "_InjectedOFMessagesSent"; + nodekey = "InjectedOFMessagesSent:" + nodeListEgressStr; + if (ingressPacketMap.containsKey(dpnId)) { + ingressPacketMap.put(dpnId,new AtomicLong(ingressPacketMap.get(dpnId).incrementAndGet())); + packetInMap.put(nodekey,""+ingressPacketMap.get(dpnId)); + } else { + ingressPacketMap.put(dpnId, new AtomicLong(FIRST_VALUE)); + packetInMap.put(nodekey,""+FIRST_VALUE); + } + connectToPMAgent(); + } else { + LOG.error("DpnId is null"); + } + } + private void connectToPMAgent(){ + pmAgent.sendPacketInCounterUpdate(packetInMap); + } + /* + * Method to extract DpnId + */ + public static String getDpnId(String id) { + String[] nodeNo = id.split(":"); + String[] dpnId = nodeNo[1].split("]"); + return dpnId[0]; + } + + public void nodeRemovedNotification(String dpnId){ + String nodeListEgressStr, nodekey; + if (dpnId != null) { + dpnId = dpnId.split(":")[1]; + LOG.debug("Dpnvalue Id {}",dpnId); + if (ingressPacketMap.containsKey(dpnId)) { + nodeListEgressStr = "dpnId_" + dpnId + "_InjectedOFMessagesSent"; + nodekey = "InjectedOFMessagesSent:" + nodeListEgressStr; + synchronized (this) { + ingressPacketMap.remove(dpnId); + packetInMap.remove(nodekey); + connectToPMAgent(); + } + LOG.debug("Node {} Removed for PacketIn counter", dpnId); + } + } else { + LOG.error("DpnId is null upon nodeRemovedNotification"); + } + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMapping.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMapping.java new file mode 100644 index 0000000000..5ea45556b7 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMapping.java @@ -0,0 +1,65 @@ +/* + * 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.fcapsapp.portinfo; + +import java.lang.String; +import java.util.HashMap; +import java.util.Map; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import javax.management.*; +import java.lang.management.ManagementFactory; + +public class PortNameMapping implements PortNameMappingMBean { + + private static final Logger LOG = LoggerFactory.getLogger(PortNameMapping.class); + + private static Map portNameToPortIdMap = new HashMap(); + + @Override + public Map getPortIdtoPortNameMap() { + return portNameToPortIdMap; + } + + @Override + public String getPortName(String portId){ + return portNameToPortIdMap.get(portId); + } + + public static void updatePortMap(String portName,String portId,String status) { + if (status.equals("ADD")){ + portNameToPortIdMap.put(portId,portName); + LOG.debug("PortId {} : portName {} added",portId,portName); + } else if(status.equals("DELETE")){ + portNameToPortIdMap.remove(portId); + LOG.debug("PortId {} : portName {} removed",portId,portName); + } + } + + public static void registerPortMappingBean() { + MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); + ObjectName mbeanName = null; + String BEANNAME = "Ports:type=PortNameMapping"; + + try { + mbeanName = new ObjectName(BEANNAME); + } catch (MalformedObjectNameException e) { + LOG.error("ObjectName instance creation failed for BEANAME {} : {}", BEANNAME, e); + + } + try { + if (!mbs.isRegistered(mbeanName)) { + mbs.registerMBean(new PortNameMapping(), mbeanName); + LOG.debug("Registered Mbean {} successfully", mbeanName); + } + + } catch (Exception e) { + LOG.error("Registeration failed for Mbean {} :{}", mbeanName, e); + } + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMappingMBean.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMappingMBean.java new file mode 100644 index 0000000000..35d210e78c --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/vpnservice/fcapsapp/portinfo/PortNameMappingMBean.java @@ -0,0 +1,16 @@ +/* + * 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.fcapsapp.portinfo; + +import java.lang.String; +import java.util.Map; + +public interface PortNameMappingMBean { + public Map getPortIdtoPortNameMap(); + public String getPortName(String portId); +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModule.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModule.java new file mode 100644 index 0000000000..903ddde3a9 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModule.java @@ -0,0 +1,28 @@ +package org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.fcaps.app.rev151211; + +import org.opendaylight.vpnservice.fcapsapp.FcapsProvider; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class FcapsAppModule extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.fcaps.app.rev151211.AbstractFcapsAppModule { + private static final Logger LOG = LoggerFactory.getLogger(FcapsAppModule.class); + public FcapsAppModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { + super(identifier, dependencyResolver); + } + + public FcapsAppModule(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.openflowplugin.app.fcaps.app.rev151211.FcapsAppModule 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() { + LOG.info("Fcaps module initialization"); + return new FcapsProvider(getDataBrokerDependency(),getNotificationAdapterDependency(),getEntityOwnershipServiceDependency()); + } + +} diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModuleFactory.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModuleFactory.java new file mode 100644 index 0000000000..16423c7632 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/yang/gen/v1/urn/opendaylight/params/xml/ns/yang/openflowplugin/app/fcaps/app/rev151211/FcapsAppModuleFactory.java @@ -0,0 +1,13 @@ +/* +* Generated file +* +* Generated from: yang module name: fcaps-app yang module local name: fcaps-app +* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator +* Generated at: Fri Feb 05 20:19:50 IST 2016 +* +* 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.openflowplugin.app.fcaps.app.rev151211; +public class FcapsAppModuleFactory extends org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.fcaps.app.rev151211.AbstractFcapsAppModuleFactory { + +} diff --git a/fcapsapplication/fcapsapplication-impl/src/main/resources/initial/73-fcaps-app.xml b/fcapsapplication/fcapsapplication-impl/src/main/resources/initial/73-fcaps-app.xml new file mode 100644 index 0000000000..65f2a4ef0f --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/resources/initial/73-fcaps-app.xml @@ -0,0 +1,50 @@ + + + + + + + + + + fcaps:fcaps-app + + fcaps-app + + + binding:binding-async-data-broker + pingpong-binding-data-broker + + + binding:binding-rpc-registry + binding-rpc-broker + + + binding:binding-new-notification-service + binding-notification-adapter + + + entity-ownership:entity-ownership-service + entity-ownership-service + + + + + + + + + urn:opendaylight:params:xml:ns:yang:openflowplugin:app:fcaps-app?module=fcaps-app&revision=2015-12-11 + + + urn:opendaylight:params:xml:ns:yang:controller:config:distributed-entity-ownership-service?module=distributed-entity-ownership-service&revision=2015-08-10 + + + + diff --git a/fcapsapplication/fcapsapplication-impl/src/main/yang/fcaps-app.yang b/fcapsapplication/fcapsapplication-impl/src/main/yang/fcaps-app.yang new file mode 100644 index 0000000000..6f775ca815 --- /dev/null +++ b/fcapsapplication/fcapsapplication-impl/src/main/yang/fcaps-app.yang @@ -0,0 +1,64 @@ +module fcaps-app { + + yang-version 1; + namespace "urn:opendaylight:params:xml:ns:yang:openflowplugin:app:fcaps-app"; + prefix "fcaps"; + + import config { prefix config; revision-date 2013-04-05; } + import opendaylight-md-sal-binding { prefix md-sal-binding; revision-date 2013-10-28; } + import opendaylight-sal-binding-broker-impl { prefix sal-broker; revision-date 2013-10-28;} + import opendaylight-entity-ownership-service { prefix eos; } + + description + "This module contains the base YANG definitions for + fcaps-manager implementation."; + + revision "2015-12-11" { + description + "Initial revision."; + } + + identity fcaps-app { + base config:module-type; + config:java-name-prefix FcapsApp; + } + + augment "/config:modules/config:module/config:configuration" { + case fcaps-app { + when "/config:modules/config:module/config:type = 'fcaps-app'"; + + container data-broker { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity md-sal-binding:binding-async-data-broker; + } + } + } + container rpc-registry { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity md-sal-binding:binding-rpc-registry; + } + } + } + container notification-adapter { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity sal-broker:binding-new-notification-service; + } + } + } + container entity-ownership-service { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity eos:entity-ownership-service; + } + } + } + } + } +} \ No newline at end of file diff --git a/fcapsapplication/fcapsapplication-jmxapi/pom.xml b/fcapsapplication/fcapsapplication-jmxapi/pom.xml new file mode 100644 index 0000000000..2d1a854d79 --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/pom.xml @@ -0,0 +1,23 @@ + + + + + org.opendaylight.vpnservice + config-parent + 0.3.0-SNAPSHOT + ../../commons/config-parent + + + 4.0.0 + org.opendaylight.vpnservice + fcapsapplication-jmxapi + ${vpnservices.version} + bundle + + diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarm.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarm.java new file mode 100644 index 0000000000..80c1da98df --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarm.java @@ -0,0 +1,65 @@ +/* + * 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.fcapsappjmx; + +import javax.management.AttributeChangeNotification; +import javax.management.Notification; +import javax.management.NotificationBroadcasterSupport; +import java.util.ArrayList; + +public class ControlPathFailureAlarm extends NotificationBroadcasterSupport implements ControlPathFailureAlarmMBean { + + ArrayList raiseAlarmObject = new ArrayList(); + ArrayList clearAlarmObject = new ArrayList(); + private long sequenceNumber = 1; + + public void setRaiseAlarmObject(ArrayList raiseAlarmObject) { + this.raiseAlarmObject = raiseAlarmObject; + + Notification notif = new AttributeChangeNotification(this, + sequenceNumber++, System.currentTimeMillis(), + "raise alarm object notified ", "raiseAlarmObject", "ArrayList", + "", this.raiseAlarmObject); + sendNotification(notif); + } + + public ArrayList getRaiseAlarmObject() { + return raiseAlarmObject; + } + + public void setClearAlarmObject(ArrayList clearAlarmObject) { + this.clearAlarmObject = clearAlarmObject; + + Notification notif = new AttributeChangeNotification(this, + sequenceNumber++, System.currentTimeMillis(), + "clear alarm object notified ", "clearAlarmObject", "ArrayList", + "", this.clearAlarmObject); + sendNotification(notif); + } + + public ArrayList getClearAlarmObject() { + return clearAlarmObject; + } + + public synchronized void raiseAlarm(String alarmName, String additionalText, String source) { + raiseAlarmObject.add(alarmName); + raiseAlarmObject.add(additionalText); + raiseAlarmObject.add(source); + setRaiseAlarmObject(raiseAlarmObject); + raiseAlarmObject.clear(); + } + + public synchronized void clearAlarm(String alarmName, String additionalText, String source) { + clearAlarmObject.add(alarmName); + clearAlarmObject.add(additionalText); + clearAlarmObject.add(source); + setClearAlarmObject(clearAlarmObject); + clearAlarmObject.clear(); + } +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarmMBean.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarmMBean.java new file mode 100644 index 0000000000..3e2637ddea --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/ControlPathFailureAlarmMBean.java @@ -0,0 +1,20 @@ +/* + * 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.fcapsappjmx; + +import java.util.ArrayList; + +public interface ControlPathFailureAlarmMBean { + public void setRaiseAlarmObject(ArrayList raiseAlarmObject); + public ArrayList getRaiseAlarmObject(); + public void setClearAlarmObject(ArrayList clearAlarmObject); + public ArrayList getClearAlarmObject(); + public void raiseAlarm(String alarmName, String additionalText, String source); + public void clearAlarm(String alarmName, String additionalText, String source); +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPorts.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPorts.java new file mode 100644 index 0000000000..2747b20579 --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPorts.java @@ -0,0 +1,25 @@ +/* + * 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.fcapsappjmx; + +import java.util.HashMap; +import java.util.Map; + +public class NumberOfOFPorts implements NumberOfOFPortsMBean { + private static Map counterCache = new HashMap(); + + @Override + public void updateCounter(Map map) { + counterCache = map; + } + + @Override + public Map retrieveCounterMap() { + return counterCache; + } +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPortsMBean.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPortsMBean.java new file mode 100644 index 0000000000..932526f7af --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFPortsMBean.java @@ -0,0 +1,18 @@ +/* + * 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.fcapsappjmx; + +import java.util.Map; + +public interface NumberOfOFPortsMBean { + //----------- + // operations + //----------- + public void updateCounter(Map map); + public Map retrieveCounterMap(); +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounter.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounter.java new file mode 100644 index 0000000000..f09a8bcaaa --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounter.java @@ -0,0 +1,25 @@ +/* + * 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.fcapsappjmx; + +import java.util.HashMap; +import java.util.Map; + +public class NumberOfOFSwitchCounter implements NumberOfOFSwitchCounterMBean { + private static Map counterCache = new HashMap(); + + @Override + public void updateCounter(Map map) { + counterCache = map; + } + + @Override + public Map retrieveCounterMap() { + return counterCache; + } +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounterMBean.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounterMBean.java new file mode 100644 index 0000000000..e1b55fd72a --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/NumberOfOFSwitchCounterMBean.java @@ -0,0 +1,18 @@ +/* + * 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.fcapsappjmx; + +import java.util.Map; + +public interface NumberOfOFSwitchCounterMBean { + //----------- + // operations + //----------- + public void updateCounter(Map map); + public Map retrieveCounterMap(); +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounter.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounter.java new file mode 100644 index 0000000000..58f5103884 --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounter.java @@ -0,0 +1,25 @@ +/* + * 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.fcapsappjmx; + +import java.util.HashMap; +import java.util.Map; + +public class PacketInCounter implements PacketInCounterMBean { + private static Map counterCache = new HashMap(); + + @Override + public void updateCounter(Map map) { + counterCache = map; + } + + @Override + public Map retrieveCounterMap() { + return counterCache; + } +} diff --git a/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounterMBean.java b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounterMBean.java new file mode 100644 index 0000000000..958e47a89c --- /dev/null +++ b/fcapsapplication/fcapsapplication-jmxapi/src/main/java/org/opendaylight/vpnservice/fcapsappjmx/PacketInCounterMBean.java @@ -0,0 +1,18 @@ +/* + * 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.fcapsappjmx; + +import java.util.Map; + +public interface PacketInCounterMBean { + //----------- + // operations + //----------- + public void updateCounter(Map map); + public Map retrieveCounterMap(); +} diff --git a/fcapsapplication/pom.xml b/fcapsapplication/pom.xml new file mode 100644 index 0000000000..c3a6b99848 --- /dev/null +++ b/fcapsapplication/pom.xml @@ -0,0 +1,49 @@ + + + + + + org.opendaylight.odlparent + odlparent + 1.7.0-SNAPSHOT + + + + org.opendaylight.vpnservice + fcapsapplication + 0.2.1-SNAPSHOT + fcapsapplication + pom + 4.0.0 + + 3.1.1 + + + fcapsapplication-jmxapi + fcapsapplication-impl + + + + + + org.apache.maven.plugins + maven-deploy-plugin + + true + + + + org.apache.maven.plugins + maven-install-plugin + + true + + + + + \ No newline at end of file diff --git a/features/pom.xml b/features/pom.xml index e2e05a02a0..dff7cecd96 100644 --- a/features/pom.xml +++ b/features/pom.xml @@ -43,7 +43,7 @@ and is available at http://www.eclipse.org/legal/epl-v10.html INTERNAL ${vpnservices.version} ${vpnservices.version} ${vpnservices.version} - + ${vpnservices.version} @@ -439,7 +439,6 @@ and is available at http://www.eclipse.org/legal/epl-v10.html INTERNAL config xml - ${project.groupId} alarmmanager @@ -455,5 +454,15 @@ and is available at http://www.eclipse.org/legal/epl-v10.html INTERNAL fcaps-api ${fcaps.manager.version} + + ${project.groupId} + fcapsapplication-jmxapi + ${fcaps.app.version} + + + ${project.groupId} + fcapsapplication-impl + ${fcaps.app.version} + diff --git a/features/src/main/features/features.xml b/features/src/main/features/features.xml index 1daa7ed362..ead3c81814 100644 --- a/features/src/main/features/features.xml +++ b/features/src/main/features/features.xml @@ -119,10 +119,15 @@ and is available at http://www.eclipse.org/legal/epl-v10.html mvn:org.opendaylight.vpnservice/vpnintent-impl/{{VERSION}} mvn:org.opendaylight.vpnservice/vpnintent-impl/{{VERSION}}/xml/config - mvn:org.opendaylight.vpnservice/fcaps-api/${fcaps.manager.version} mvn:org.opendaylight.vpnservice/alarmmanager/${fcaps.manager.version} mvn:org.opendaylight.vpnservice/countermanager/${fcaps.manager.version} - + + odl-openflowplugin-all + mvn:org.opendaylight.vpnservice/fcapsapplication-jmxapi/${fcaps.app.version} + mvn:org.opendaylight.vpnservice/fcapsapplication-impl/${fcaps.app.version} + mvn:org.opendaylight.vpnservice/fcapsapplication-impl/${fcaps.app.version}/xml/config + + diff --git a/pom.xml b/pom.xml index b35783b224..f24a35b9f8 100644 --- a/pom.xml +++ b/pom.xml @@ -37,6 +37,7 @@ and is available at http://www.eclipse.org/legal/epl-v10.html INTERNAL vpnservice-artifacts vpnintent fcapsmanager + fcapsapplication -- 2.36.6