X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=applications%2Fforwardingrules-manager%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fopenflowplugin%2Fapplications%2Ffrm%2Fimpl%2FForwardingRulesManagerImpl.java;h=334944c215d5060c856bfeed59866f345ad7d631;hb=91ce86fabb2141e8f44fd210b6ad8b4da76ea55a;hp=c20badaf8c20105025ae1bf2a7163013a0133678;hpb=a94db42744cb59aa79eca25f110f83508b6f3af1;p=openflowplugin.git diff --git a/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/ForwardingRulesManagerImpl.java b/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/ForwardingRulesManagerImpl.java index c20badaf8c..334944c215 100644 --- a/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/ForwardingRulesManagerImpl.java +++ b/applications/forwardingrules-manager/src/main/java/org/opendaylight/openflowplugin/applications/frm/impl/ForwardingRulesManagerImpl.java @@ -1,36 +1,43 @@ -/** +/* * Copyright (c) 2014, 2017 Cisco Systems, Inc. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.openflowplugin.applications.frm.impl; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; -import com.google.common.util.concurrent.CheckedFuture; -import java.util.Objects; +import com.google.common.util.concurrent.ListenableFuture; import java.util.Optional; +import java.util.concurrent.ExecutionException; import java.util.concurrent.atomic.AtomicLong; import javax.annotation.Nonnull; - -import com.google.common.util.concurrent.Futures; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; -import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; -import org.opendaylight.controller.sal.binding.api.NotificationProviderService; -import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry; +import javax.annotation.PostConstruct; +import javax.annotation.PreDestroy; +import javax.inject.Inject; +import javax.inject.Singleton; +import org.apache.aries.blueprint.annotation.service.Reference; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.ReadTransaction; +import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry; +import org.opendaylight.mdsal.binding.api.RpcProviderService; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider; import org.opendaylight.openflowplugin.api.openflow.configuration.ConfigurationService; +import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager; import org.opendaylight.openflowplugin.applications.frm.FlowNodeReconciliation; import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesCommiter; import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager; import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesProperty; +import org.opendaylight.openflowplugin.applications.frm.NodeConfigurator; +import org.opendaylight.openflowplugin.applications.frm.nodeconfigurator.NodeConfiguratorImpl; +import org.opendaylight.openflowplugin.applications.frm.recovery.OpenflowServiceRecoveryHandler; import org.opendaylight.openflowplugin.applications.reconciliation.NotificationRegistration; import org.opendaylight.openflowplugin.applications.reconciliation.ReconciliationManager; +import org.opendaylight.serviceutils.srm.RecoverableListener; +import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow; @@ -40,6 +47,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.SalMeterService; import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.onf.bundle.service.rev170124.SalBundleService; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.arbitrator.reconcile.service.rev180227.ArbitratorReconcileService; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.app.forwardingrules.manager.config.rev160511.ForwardingRulesManagerConfig; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflowplugin.rf.state.rev170713.ResultState; import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.SalTableService; @@ -49,19 +57,20 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * forwardingrules-manager - * org.opendaylight.openflowplugin.applications.frm.impl + * forwardingrules-manager org.opendaylight.openflowplugin.applications.frm.impl * - * Manager and middle point for whole module. - * It contains ActiveNodeHolder and provide all RPC services. + *

+ * Manager and middle point for whole module. It contains ActiveNodeHolder and + * provide all RPC services. * */ +@Singleton public class ForwardingRulesManagerImpl implements ForwardingRulesManager { private static final Logger LOG = LoggerFactory.getLogger(ForwardingRulesManagerImpl.class); static final int STARTUP_LOOP_TICK = 500; static final int STARTUP_LOOP_MAX_RETRIES = 8; - private static final int FRM_RECONCILIATION_PRIORITY = Integer.getInteger("frm.reconciliation.priority", 0); + private static final int FRM_RECONCILIATION_PRIORITY = Integer.getInteger("frm.reconciliation.priority", 1); private static final String SERVICE_NAME = "FRM"; private final AtomicLong txNum = new AtomicLong(); @@ -71,9 +80,10 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { private final SalMeterService salMeterService; private final SalTableService salTableService; private final ClusterSingletonServiceProvider clusterSingletonServiceProvider; - private final NotificationProviderService notificationService; private final SalBundleService salBundleService; private final AutoCloseable configurationServiceRegistration; + private final MastershipChangeServiceManager mastershipChangeServiceManager; + private final RpcProviderService rpcProviderService; private ForwardingRulesCommiter flowListener; private ForwardingRulesCommiter groupListener; private ForwardingRulesCommiter meterListener; @@ -83,19 +93,27 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { private FlowNodeConnectorInventoryTranslatorImpl flowNodeConnectorInventoryTranslatorImpl; private DeviceMastershipManager deviceMastershipManager; private final ReconciliationManager reconciliationManager; - + private DevicesGroupRegistry devicesGroupRegistry; + private NodeConfigurator nodeConfigurator; + private final ArbitratorReconcileService arbitratorReconciliationManager; private boolean disableReconciliation; private boolean staleMarkingEnabled; private int reconciliationRetryCount; private boolean isBundleBasedReconciliationEnabled; + private final OpenflowServiceRecoveryHandler openflowServiceRecoveryHandler; + private final ServiceRecoveryRegistry serviceRecoveryRegistry; - public ForwardingRulesManagerImpl(final DataBroker dataBroker, - final RpcConsumerRegistry rpcRegistry, + @Inject + public ForwardingRulesManagerImpl(@Reference final DataBroker dataBroker, + @Reference final RpcConsumerRegistry rpcRegistry, + @Reference final RpcProviderService rpcProviderService, final ForwardingRulesManagerConfig config, - final ClusterSingletonServiceProvider clusterSingletonService, - final NotificationProviderService notificationService, - final ConfigurationService configurationService, - final ReconciliationManager reconciliationManager) { + @Reference final MastershipChangeServiceManager mastershipChangeServiceManager, + @Reference final ClusterSingletonServiceProvider clusterSingletonService, + @Reference final ConfigurationService configurationService, + @Reference final ReconciliationManager reconciliationManager, + final OpenflowServiceRecoveryHandler openflowServiceRecoveryHandler, + @Reference final ServiceRecoveryRegistry serviceRecoveryRegistry) { disableReconciliation = config.isDisableReconciliation(); staleMarkingEnabled = config.isStaleMarkingEnabled(); reconciliationRetryCount = config.getReconciliationRetryCount(); @@ -104,11 +122,11 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { this.dataService = Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!"); this.clusterSingletonServiceProvider = Preconditions.checkNotNull(clusterSingletonService, "ClusterSingletonService provider can not be null"); - this.notificationService = Preconditions.checkNotNull(notificationService, "Notification publisher configurationService is" + - " not available"); this.reconciliationManager = reconciliationManager; + this.rpcProviderService = rpcProviderService; + this.mastershipChangeServiceManager = mastershipChangeServiceManager; - Preconditions.checkArgument(rpcRegistry != null, "RpcConsumerRegistry can not be null !"); + Preconditions.checkArgument(rpcRegistry != null, "RpcProviderRegistry can not be null !"); this.salFlowService = Preconditions.checkNotNull(rpcRegistry.getRpcService(SalFlowService.class), "RPC SalFlowService not found."); @@ -120,23 +138,33 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { "RPC SalTableService not found."); this.salBundleService = Preconditions.checkNotNull(rpcRegistry.getRpcService(SalBundleService.class), "RPC SalBundlService not found."); + this.openflowServiceRecoveryHandler = Preconditions.checkNotNull(openflowServiceRecoveryHandler, + "Openflow service recovery handler cannot be null"); + this.serviceRecoveryRegistry = Preconditions.checkNotNull(serviceRecoveryRegistry, + "Service recovery registry cannot be null"); + this.arbitratorReconciliationManager = Preconditions + .checkNotNull(rpcRegistry.getRpcService(ArbitratorReconcileService.class), + "ArbitratorReconciliationManager can not be null!"); } @Override + @PostConstruct public void start() { - this.nodeListener = new FlowNodeReconciliationImpl(this,dataService, - SERVICE_NAME, FRM_RECONCILIATION_PRIORITY, ResultState.DONOTHING); + nodeConfigurator = new NodeConfiguratorImpl(); + this.devicesGroupRegistry = new DevicesGroupRegistry(); + + this.nodeListener = new FlowNodeReconciliationImpl(this, dataService, SERVICE_NAME, FRM_RECONCILIATION_PRIORITY, + ResultState.DONOTHING); if (this.isReconciliationDisabled()) { LOG.debug("Reconciliation is disabled by user"); } else { this.reconciliationNotificationRegistration = reconciliationManager.registerService(this.nodeListener); LOG.debug("Reconciliation is enabled by user and successfully registered to the reconciliation framework"); } - this.deviceMastershipManager = new DeviceMastershipManager(clusterSingletonServiceProvider, - notificationService, - this.nodeListener, - dataService); - flowNodeConnectorInventoryTranslatorImpl = new FlowNodeConnectorInventoryTranslatorImpl(this,dataService); + this.deviceMastershipManager = new DeviceMastershipManager(clusterSingletonServiceProvider, this.nodeListener, + dataService, mastershipChangeServiceManager, rpcProviderService, + new FrmReconciliationServiceImpl(this)); + flowNodeConnectorInventoryTranslatorImpl = new FlowNodeConnectorInventoryTranslatorImpl(dataService); this.flowListener = new FlowForwarder(this, dataService); this.groupListener = new GroupForwarder(this, dataService); @@ -146,6 +174,7 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { } @Override + @PreDestroy public void close() throws Exception { configurationServiceRegistration.close(); @@ -179,7 +208,7 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { } @Override - public ReadOnlyTransaction getReadTranaction() { + public ReadTransaction getReadTransaction() { return dataService.newReadOnlyTransaction(); } @@ -189,28 +218,26 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { } @Override - public boolean isNodeActive(InstanceIdentifier ident) { + public boolean isNodeActive(final InstanceIdentifier ident) { return deviceMastershipManager.isNodeActive(ident.firstKeyOf(Node.class).getId()); } @Override - public boolean checkNodeInOperationalDataStore(InstanceIdentifier ident) { + public boolean checkNodeInOperationalDataStore(final InstanceIdentifier ident) { boolean result = false; InstanceIdentifier nodeIid = ident.firstIdentifierOf(Node.class); - final ReadOnlyTransaction transaction = dataService.newReadOnlyTransaction(); - CheckedFuture, ReadFailedException> future = transaction.read(LogicalDatastoreType.OPERATIONAL, nodeIid); - try { - com.google.common.base.Optional optionalDataObject = future.checkedGet(); + try (ReadTransaction transaction = dataService.newReadOnlyTransaction()) { + ListenableFuture> future = transaction + .read(LogicalDatastoreType.OPERATIONAL, nodeIid); + Optional optionalDataObject = future.get(); if (optionalDataObject.isPresent()) { result = true; } else { - LOG.debug("{}: Failed to read {}", - Thread.currentThread().getStackTrace()[1], nodeIid); + LOG.debug("{}: Failed to read {}", Thread.currentThread().getStackTrace()[1], nodeIid); } - } catch (ReadFailedException e) { + } catch (ExecutionException | InterruptedException e) { LOG.warn("Failed to read {} ", nodeIid, e); } - transaction.close(); return result; } @@ -235,6 +262,11 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { return salTableService; } + @Override + public DevicesGroupRegistry getDevicesGroupRegistry() { + return this.devicesGroupRegistry; + } + @Override public SalBundleService getSalBundleService() { return salBundleService; @@ -260,6 +292,11 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { return tableListener; } + @Override + public ArbitratorReconcileService getArbitratorReconciliationManager() { + return arbitratorReconciliationManager; + } + @Override public boolean isReconciliationDisabled() { return disableReconciliation; @@ -275,19 +312,34 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { return reconciliationRetryCount; } + @Override + public void addRecoverableListener(final RecoverableListener recoverableListener) { + serviceRecoveryRegistry.addRecoverableListener(openflowServiceRecoveryHandler.buildServiceRegistryKey(), + recoverableListener); + } + @Override public FlowNodeConnectorInventoryTranslatorImpl getFlowNodeConnectorInventoryTranslatorImpl() { return flowNodeConnectorInventoryTranslatorImpl; } + @Override + public NodeConfigurator getNodeConfigurator() { + return nodeConfigurator; + } + + public FlowNodeReconciliation getNodeListener() { + return nodeListener; + } + @Override public boolean isBundleBasedReconciliationEnabled() { return isBundleBasedReconciliationEnabled; } @Override - public boolean isNodeOwner(InstanceIdentifier ident) { - return Objects.nonNull(ident) && deviceMastershipManager.isDeviceMastered(ident.firstKeyOf(Node.class).getId()); + public boolean isNodeOwner(final InstanceIdentifier ident) { + return ident != null && deviceMastershipManager.isDeviceMastered(ident.firstKeyOf(Node.class).getId()); } @VisibleForTesting @@ -297,7 +349,8 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { @Override public void onPropertyChanged(@Nonnull final String propertyName, @Nonnull final String propertyValue) { - Optional.ofNullable(ForwardingRulesProperty.forValue(propertyName)).ifPresent(forwardingRulesProperty -> { + final ForwardingRulesProperty forwardingRulesProperty = ForwardingRulesProperty.forValue(propertyName); + if (forwardingRulesProperty != null) { switch (forwardingRulesProperty) { case DISABLE_RECONCILIATION: disableReconciliation = Boolean.valueOf(propertyValue); @@ -306,12 +359,15 @@ public class ForwardingRulesManagerImpl implements ForwardingRulesManager { staleMarkingEnabled = Boolean.valueOf(propertyValue); break; case RECONCILIATION_RETRY_COUNT: - reconciliationRetryCount = Integer.valueOf(propertyValue); + reconciliationRetryCount = Integer.parseInt(propertyValue); break; case BUNDLE_BASED_RECONCILIATION_ENABLED: isBundleBasedReconciliationEnabled = Boolean.valueOf(propertyValue); break; + default: + LOG.warn("No forwarding rule property found."); + break; } - }); + } } }