* @param isStatisticsRpcEnabled
*/
void setIsStatisticsRpcEnabled(boolean isStatisticsRpcEnabled);
+
+ void setBarrierCountLimit(int barrierCountLimit);
+
+ void setBarrierInterval(long barrierTimeoutLimit);
+
+ void setEchoReplyTimeout(long echoReplyTimeout);
}
*
* @param connectionContext
*/
- void addAuxiliaryConenctionContext(ConnectionContext connectionContext);
+ void addAuxiliaryConnectionContext(ConnectionContext connectionContext);
/**
* Method removes auxiliary connection context from this context representing single device connection.
*
* @param connectionContext
*/
- void removeAuxiliaryConenctionContext(ConnectionContext connectionContext);
+ void removeAuxiliaryConnectionContext(ConnectionContext connectionContext);
/**
* @param featureOutput obtained
* @param version negotiated
*/
- void onHandshakeSuccessfull(GetFeaturesOutput featureOutput, Short version);
+ void onHandshakeSuccessful(GetFeaturesOutput featureOutput, Short version);
/**
* This method is called when handshake fails for some reason. It allows
<switch-features-mandatory>false</switch-features-mandatory>
<global-notification-quota>64000</global-notification-quota>
<is-statistics-polling-off>false</is-statistics-polling-off>
+ <barrier-interval-timeout-limit>500</barrier-interval-timeout-limit>
+ <barrier-count-limit>25600</barrier-count-limit>
+ <echo-reply-timeout>2000</echo-reply-timeout>
</module>
</modules>
private final int rpcRequestsQuota;
private final long globalNotificationQuota;
+ private long barrierInterval;
+ private int barrierCountLimit;
+ private long echoReplyTimeout;
private DeviceManager deviceManager;
private RoleManager roleManager;
private RpcManager rpcManager;
this.entityOwnershipService = entityOwnershipService;
}
+ @Override
+ public void setBarrierCountLimit(int barrierCountLimit) {
+ this.barrierCountLimit = barrierCountLimit;
+ }
+
+ @Override
+ public void setBarrierInterval(long barrierTimeoutLimit) {
+ this.barrierInterval = barrierTimeoutLimit;
+ }
+
+ @Override
+ public void setEchoReplyTimeout(long echoReplyTimeout) {
+ this.echoReplyTimeout = echoReplyTimeout;
+ }
+
+
@Override
public void setSwitchFeaturesMandatory(final boolean switchFeaturesMandatory) {
this.switchFeaturesMandatory = switchFeaturesMandatory;
// TODO: rewrite later!
OFSessionUtil.getSessionManager().setExtensionConverterProvider(extensionConverterManager);
- connectionManager = new ConnectionManagerImpl();
+ connectionManager = new ConnectionManagerImpl(echoReplyTimeout);
registerMXBean(messageIntelligenceAgency);
- deviceManager = new DeviceManagerImpl(dataBroker, messageIntelligenceAgency, globalNotificationQuota, switchFeaturesMandatory);
+ deviceManager = new DeviceManagerImpl(dataBroker, messageIntelligenceAgency, globalNotificationQuota,
+ switchFeaturesMandatory, barrierInterval, barrierCountLimit);
((ExtensionConverterProviderKeeper) deviceManager).setExtensionConverterProvider(extensionConverterManager);
- roleManager = new RoleManagerImpl(entityOwnershipService, dataBroker, switchFeaturesMandatory);
+ roleManager = new RoleManagerImpl(entityOwnershipService, dataBroker);
statisticsManager = new StatisticsManagerImpl(rpcProviderRegistry, isStatisticsPollingOff);
rpcManager = new RpcManagerImpl(rpcProviderRegistry, rpcRequestsQuota);
private static final int HELLO_LIMIT = 20;
private final boolean bitmapNegotiationEnabled = true;
private DeviceConnectedHandler deviceConnectedHandler;
+ private final long echoReplyTimeout;
+
+ public ConnectionManagerImpl(long echoReplyTimeout) {
+ this.echoReplyTimeout = echoReplyTimeout;
+ }
+
@Override
public void onSwitchConnected(final ConnectionAdapter connectionAdapter) {
new OpenflowProtocolListenerInitialImpl(connectionContext, handshakeContext);
connectionAdapter.setMessageListener(ofMessageListener);
- final SystemNotificationsListener systemListener = new SystemNotificationsListenerImpl(connectionContext);
+ final SystemNotificationsListener systemListener = new SystemNotificationsListenerImpl(connectionContext, echoReplyTimeout);
connectionAdapter.setSystemListener(systemListener);
LOG.trace("connection ballet finished");
}
@Override
- public void onHandshakeSuccessfull(final GetFeaturesOutput featureOutput, final Short version) {
+ public void onHandshakeSuccessful(final GetFeaturesOutput featureOutput, final Short version) {
LOG.debug("handshake succeeded: {}", connectionContext.getConnectionAdapter().getRemoteAddress());
closeHandshakeContext();
connectionContext.changeStateToWorking();
handshakeContext.close();
} catch (final Exception e) {
LOG.warn("Closing handshake context failed: {}", e.getMessage());
- LOG.debug("Detail in hanshake context close:", e);
+ LOG.debug("Detail in handshake context close:", e);
}
}
private static final Logger LOG = LoggerFactory.getLogger(SystemNotificationsListenerImpl.class);
@VisibleForTesting
static final long MAX_ECHO_REPLY_TIMEOUT = 2000;
+ private final long echoReplyTimeout;
- public SystemNotificationsListenerImpl(@Nonnull final ConnectionContext connectionContext) {
+ public SystemNotificationsListenerImpl(@Nonnull final ConnectionContext connectionContext, long echoReplyTimeout) {
this.connectionContext = Preconditions.checkNotNull(connectionContext);
+ this.echoReplyTimeout = echoReplyTimeout;
}
@Override
if (ConnectionContext.CONNECTION_STATE.WORKING.equals(connectionContext.getConnectionState())) {
FeaturesReply features = connectionContext.getFeatures();
- LOG.debug(
- "first idle state occured, node={}|auxId={}",
- remoteAddress, features.getAuxiliaryId());
+ LOG.debug("Switch Idle state occured, node={}|auxId={}", remoteAddress, features.getAuxiliaryId());
connectionContext.changeStateToTimeouting();
EchoInputBuilder builder = new EchoInputBuilder();
builder.setVersion(features.getVersion());
Xid xid = new Xid(0L);
builder.setXid(xid.getValue());
- Future<RpcResult<EchoOutput>> echoReplyFuture = connectionContext.getConnectionAdapter()
- .echo(builder.build());
+ Future<RpcResult<EchoOutput>> echoReplyFuture = connectionContext.getConnectionAdapter().echo(builder.build());
try {
- RpcResult<EchoOutput> echoReplyValue = echoReplyFuture.get(MAX_ECHO_REPLY_TIMEOUT, TimeUnit.MILLISECONDS);
+ RpcResult<EchoOutput> echoReplyValue = echoReplyFuture.get(echoReplyTimeout, TimeUnit.MILLISECONDS);
if (echoReplyValue.isSuccessful()) {
connectionContext.changeStateToWorking();
shouldBeDisconnected = false;
} else {
- for (RpcError replyError : echoReplyValue
- .getErrors()) {
+ for (RpcError replyError : echoReplyValue.getErrors()) {
Throwable cause = replyError.getCause();
- LOG.warn("while receiving echoReply [{}] in TIMEOUTING state {} ",
- remoteAddress,
- cause.getMessage());
- LOG.trace("while receiving echoReply [{}] in TIMEOUTING state ..", remoteAddress, cause);
+ if (LOG.isWarnEnabled()) {
+ LOG.warn("Received EchoReply from [{}] in TIMEOUTING state, Error:{}", remoteAddress, cause.getMessage());
+ }
+
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received EchoReply from [{}] in TIMEOUTING state, Error:{}", remoteAddress, cause);
+ }
+
}
}
} catch (Exception e) {
- LOG.warn("while waiting for echoReply in TIMEOUTING state: {}", e.getMessage());
- LOG.trace("while waiting for echoReply in TIMEOUTING state ..", remoteAddress, e);
+ if (LOG.isWarnEnabled()) {
+ LOG.warn("Exception while waiting for echoReply from [{}] in TIMEOUTING state: {}", remoteAddress, e.getMessage());
+ }
+
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Exception while waiting for echoReply from [{}] in TIMEOUTING state: {}", remoteAddress, e);
+ }
+
}
}
if (shouldBeDisconnected) {
import org.opendaylight.openflowplugin.impl.registry.group.DeviceGroupRegistryImpl;
import org.opendaylight.openflowplugin.impl.registry.meter.DeviceMeterRegistryImpl;
import org.opendaylight.openflowplugin.impl.util.DeviceInitializationUtils;
-import org.opendaylight.openflowplugin.impl.util.MdSalRegistratorUtils;
+import org.opendaylight.openflowplugin.impl.util.MdSalRegistrationUtils;
import org.opendaylight.openflowplugin.openflow.md.core.session.SwitchConnectionCookieOFImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.experimenter.message.service.rev151020.ExperimenterMessageFromDevBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
private ExtensionConverterProvider extensionConverterProvider;
private final boolean switchFeaturesMandatory;
- private StatisticsContext statCtx;
+ private StatisticsContext statisticsContext;
@VisibleForTesting
}
@Override
- public void addAuxiliaryConenctionContext(final ConnectionContext connectionContext) {
+ public void addAuxiliaryConnectionContext(final ConnectionContext connectionContext) {
final SwitchConnectionDistinguisher connectionDistinguisher = createConnectionDistinguisher(connectionContext);
auxiliaryConnectionContexts.put(connectionDistinguisher, connectionContext);
}
}
@Override
- public void removeAuxiliaryConenctionContext(final ConnectionContext connectionContext) {
- // TODO Auto-generated method stub
+ public void removeAuxiliaryConnectionContext(final ConnectionContext connectionContext) {
+ final SwitchConnectionDistinguisher connectionDistinguisher = createConnectionDistinguisher(connectionContext);
+ if (null != connectionDistinguisher) {
+ auxiliaryConnectionContexts.remove(connectionDistinguisher);
+ }
}
@Override
return Futures.immediateFuture(null);
}
if (OfpRole.BECOMEMASTER.equals(role)) {
- MdSalRegistratorUtils.registerMasterServices(getRpcContext(), DeviceContextImpl.this, role);
+ MdSalRegistrationUtils.registerMasterServices(getRpcContext(), DeviceContextImpl.this, role);
getRpcContext().registerStatCompatibilityServices();
if (!deviceState.deviceSynchronized()) {
//TODO: no necessary code for yet - it needs for initialization phase only
@Override
public void onFailure(Throwable throwable) {
LOG.debug("Device {} init unexpected fail. Unregister RPCs", getDeviceState().getNodeId());
- MdSalRegistratorUtils.unregisterServices(getRpcContext());
+ MdSalRegistrationUtils.unregisterServices(getRpcContext());
}
});
} else if (OfpRole.BECOMESLAVE.equals(role)) {
if (null != rpcContext) {
- MdSalRegistratorUtils.registerSlaveServices(rpcContext, role);
+ MdSalRegistrationUtils.registerSlaveServices(rpcContext, role);
}
return transactionChainManager.deactivateTransactionManager();
} else {
LOG.warn("Unknown OFCluster Role {} for Node {}", role, deviceState.getNodeId());
if (null != rpcContext) {
- MdSalRegistratorUtils.unregisterServices(rpcContext);
+ MdSalRegistrationUtils.unregisterServices(rpcContext);
}
return transactionChainManager.deactivateTransactionManager();
}
* all possible MultipartTypes for polling in StatTypeList
*/
private ListenableFuture<Void> asyncClusterRoleChange() {
- if (statCtx == null) {
+ if (statisticsContext == null) {
final String errMsg = String.format("DeviceCtx %s is up but we are missing StatisticsContext", deviceState.getNodeId());
LOG.warn(errMsg);
return Futures.immediateFailedFuture(new IllegalStateException(errMsg));
@Override
public void onSuccess(final Void result) {
- LOG.info("TxChain {} was shutdown successfull.", getDeviceState().getNodeId());
+ LOG.info("TxChain {} was shutdown successful.", getDeviceState().getNodeId());
tearDownClean();
}
}
@Override
- public void setNotificationService(final NotificationService notificationServiceParam) {
- notificationService = notificationServiceParam;
+ public void setNotificationService(final NotificationService notificationService) {
+ this.notificationService = notificationService;
}
@Override
@Override
public void setStatisticsContext(final StatisticsContext statisticsContext) {
- this.statCtx = statisticsContext;
+ this.statisticsContext = statisticsContext;
}
@Override
public StatisticsContext getStatisticsContext() {
- return statCtx;
+ return statisticsContext;
}
}
private static final long TICK_DURATION = 10; // 0.5 sec.
private final long globalNotificationQuota;
private final boolean switchFeaturesMandatory;
+
private ScheduledThreadPoolExecutor spyPool;
private final int spyRate = 10;
private final ConcurrentMap<NodeId, DeviceContext> deviceContexts = new ConcurrentHashMap<>();
private final MessageIntelligenceAgency messageIntelligenceAgency;
- private final long barrierNanos = TimeUnit.MILLISECONDS.toNanos(500);
- private final int maxQueueDepth = 25600;
+ private final long barrierIntervalNanos;
+ private final int barrierCountLimit;
private ExtensionConverterProvider extensionConverterProvider;
public DeviceManagerImpl(@Nonnull final DataBroker dataBroker,
@Nonnull final MessageIntelligenceAgency messageIntelligenceAgency,
- final long globalNotificationQuota, final boolean switchFeaturesMandatory) {
+ final long globalNotificationQuota, final boolean switchFeaturesMandatory,
+ final long barrierInterval, final int barrierCountLimit) {
this.switchFeaturesMandatory = switchFeaturesMandatory;
this.globalNotificationQuota = globalNotificationQuota;
this.dataBroker = Preconditions.checkNotNull(dataBroker);
}
this.messageIntelligenceAgency = messageIntelligenceAgency;
+ this.barrierIntervalNanos = TimeUnit.MILLISECONDS.toNanos(barrierInterval);
+ this.barrierCountLimit = barrierCountLimit;
}
connectionContext.setOutboundQueueProvider(outboundQueueProvider);
final OutboundQueueHandlerRegistration<OutboundQueueProvider> outboundQueueHandlerRegistration =
- connectionAdapter.registerOutboundQueueHandler(outboundQueueProvider, maxQueueDepth, barrierNanos);
+ connectionAdapter.registerOutboundQueueHandler(outboundQueueProvider, barrierCountLimit, barrierIntervalNanos);
connectionContext.setOutboundQueueHandleRegistration(outboundQueueHandlerRegistration);
final DeviceState deviceState = createDeviceState(connectionContext);
version = featuresReply.getVersion();
statPollEnabled = false;
deviceSynchronized = false;
+ role = OfpRole.BECOMESLAVE;
}
@Override
private final EntityOwnershipService entityOwnershipService;
private EntityOwnershipCandidateRegistration entityOwnershipCandidateRegistration;
+ private EntityOwnershipCandidateRegistration txEntityOwnershipCandidateRegistration;
+
private final DeviceContext deviceContext;
- private final Entity entity;
- private SalRoleService salRoleService;
- private EntityOwnershipCandidateRegistration txEntityOwnershipCandidateRegistration;
+ private final Entity entity;
private final Entity txEntity;
+ private SalRoleService salRoleService;
+
private final Semaphore mainCandidateGuard = new Semaphore(1, true);
private final Semaphore txCandidateGuard = new Semaphore(1, true);
public RoleContextImpl(final DeviceContext deviceContext, final EntityOwnershipService entityOwnershipService,
- final Entity entity, final Entity txEnitity) {
+ final Entity entity, final Entity txEntity) {
this.entityOwnershipService = Preconditions.checkNotNull(entityOwnershipService);
this.deviceContext = Preconditions.checkNotNull(deviceContext);
this.entity = Preconditions.checkNotNull(entity);
- this.txEntity = Preconditions.checkNotNull(txEnitity);
-
+ this.txEntity = Preconditions.checkNotNull(txEntity);
salRoleService = new SalRoleServiceImpl(this, deviceContext);
}
LOG.trace("onRoleChanged method call for Entity {}", entity);
if (!isDeviceConnected()) {
- // this can happen as after the disconnect, we still get a last messsage from EntityOwnershipService.
+ // this can happen as after the disconnect, we still get a last message from EntityOwnershipService.
LOG.info("Device {} is disconnected from this node. Hence not attempting a role change.",
deviceContext.getPrimaryConnectionContext().getNodeId());
LOG.debug("SetRole cancelled for entity [{}], reason = device disconnected.", entity);
}
private ListenableFuture<Void> sendRoleChangeToDevice(final OfpRole newRole, final AsyncFunction<RpcResult<SetRoleOutput>, Void> function) {
- LOG.debug("Send new Role {} to Device {}", newRole, deviceContext.getDeviceState().getNodeId());
+ LOG.debug("Send new role {} to device {}", newRole, deviceContext.getDeviceState().getNodeId());
final Future<RpcResult<SetRoleOutput>> setRoleOutputFuture;
if (deviceContext.getDeviceState().getFeatures().getVersion() < OFConstants.OFP_VERSION_1_3) {
LOG.debug("Device OF version {} not support ROLE", deviceContext.getDeviceState().getFeatures().getVersion());
@Override
public void run(final Timeout timeout) throws Exception {
if (!setRoleOutputFuture.isDone()) {
- LOG.info("New Role {} was not propagated to device {} during 10 sec. Close connection immediately.",
+ LOG.info("New role {} was not propagated to device {} during 10 sec. Close connection immediately.",
newRole, deviceContext.getDeviceState().getNodeId());
deviceContext.close();
}
private final ConcurrentMap<Entity, RoleContext> txContexts = new ConcurrentHashMap<>();
private final EntityOwnershipListenerRegistration entityOwnershipListenerRegistration;
private final EntityOwnershipListenerRegistration txEntityOwnershipListenerRegistration;
- private final boolean switchFeaturesMandatory;
- public RoleManagerImpl(final EntityOwnershipService entityOwnershipService, final DataBroker dataBroker, final boolean switchFeaturesMandatory) {
+ public RoleManagerImpl(final EntityOwnershipService entityOwnershipService, final DataBroker dataBroker) {
this.entityOwnershipService = Preconditions.checkNotNull(entityOwnershipService);
this.dataBroker = Preconditions.checkNotNull(dataBroker);
- this.switchFeaturesMandatory = switchFeaturesMandatory;
this.entityOwnershipListenerRegistration = Preconditions.checkNotNull(entityOwnershipService.registerListener(RoleManager.ENTITY_TYPE, this));
this.txEntityOwnershipListenerRegistration = Preconditions.checkNotNull(entityOwnershipService.registerListener(TX_ENTITY_TYPE, this));
- LOG.debug("Registering OpenflowOwnershipListener listening to all entity ownership changes");
+ LOG.debug("Register OpenflowOwnershipListener to all entity ownership changes");
}
@Override
@Override
public void onDeviceContextLevelUp(@CheckForNull final DeviceContext deviceContext) throws Exception {
- LOG.debug("RoleManager called for device:{}", deviceContext.getPrimaryConnectionContext().getNodeId());
+ LOG.trace("Role manager called for device:{}", deviceContext.getPrimaryConnectionContext().getNodeId());
final RoleContext roleContext = new RoleContextImpl(deviceContext, entityOwnershipService,
makeEntity(deviceContext.getDeviceState().getNodeId()),
makeTxEntity(deviceContext.getDeviceState().getNodeId()));
- Verify.verify(contexts.putIfAbsent(roleContext.getEntity(), roleContext) == null, "RoleCtx for master Node {} is still not closed.", deviceContext.getDeviceState().getNodeId());
+ Verify.verify(contexts.putIfAbsent(roleContext.getEntity(), roleContext) == null, "Role context for master Node {} is still not closed.", deviceContext.getDeviceState().getNodeId());
Verify.verify(!txContexts.containsKey(roleContext.getTxEntity()),
- "RoleCtx for master Node {} is still not closed. TxEntity was not unregistered yet.", deviceContext.getDeviceState().getNodeId());
+ "Role context for master Node {} is still not closed. TxEntity was not unregistered yet.", deviceContext.getDeviceState().getNodeId());
// if the device context gets closed (mostly on connection close), we would need to cleanup
deviceContext.addDeviceContextClosedHandler(this);
@Override
public void onDeviceContextClosed(final DeviceContext deviceContext) {
final NodeId nodeId = deviceContext.getDeviceState().getNodeId();
- LOG.debug("onDeviceContextClosed for node {}", nodeId);
+ LOG.trace("onDeviceContextClosed for node {}", nodeId);
final Entity entity = makeEntity(nodeId);
final RoleContext roleContext = contexts.get(entity);
if (roleContext != null) {
// TODO : is there a chance to have TxEntity ?
}
} else {
- LOG.warn("EntityOwnershipService doesn't return state for entity: {} in close proces", entity);
+ LOG.warn("EntityOwnershipService doesn't return state for entity: {} in close process", entity);
}
roleContext.close();
}
Futures.addCallback(removeDeviceFromOperDS(roleContext), new FutureCallback<Void>() {
@Override
public void onSuccess(@Nullable final Void aVoid) {
- LOG.debug("Freeing roleContext slot for device: {}", roleContext.getDeviceState().getNodeId());
+ LOG.debug("Removing context for device: {}", roleContext.getDeviceState().getNodeId());
contexts.remove(ownershipChange.getEntity(), roleContext);
roleContext.suspendTxCandidate();
}
@Override
public void onFailure(final Throwable throwable) {
- LOG.warn("NOT freeing roleContext slot for device: {}, {}", roleContext.getDeviceState()
+ LOG.warn("Removing role context for device: {}, but {}", roleContext.getDeviceState()
.getNodeId(), throwable.getMessage());
contexts.remove(ownershipChange.getEntity(), roleContext);
roleContext.suspendTxCandidate();
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
-import org.opendaylight.openflowplugin.impl.util.MdSalRegistratorUtils;
+import org.opendaylight.openflowplugin.impl.util.MdSalRegistrationUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.slf4j.Logger;
@Override
public void registerStatCompatibilityServices() {
if (isStatisticsRpcEnabled) {
- MdSalRegistratorUtils.registerStatCompatibilityServices(RpcContextImpl.this, deviceContext,
+ MdSalRegistrationUtils.registerStatCompatibilityServices(RpcContextImpl.this, deviceContext,
notificationPublishService, new AtomicLong());
}
}
LOG.trace("Device queue {} at capacity", this);
return null;
} else {
- LOG.info("Acquired semaphore for {}, available permits:{} ", deviceContext.getDeviceState().getNodeId(), tracker.availablePermits());
+ LOG.trace("Acquired semaphore for {}, available permits:{} ", deviceContext.getDeviceState().getNodeId(), tracker.availablePermits());
}
final Long xid = deviceContext.reservedXidForDeviceMessage();
import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceInitializationPhaseHandler;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcManager;
-import org.opendaylight.openflowplugin.impl.util.MdSalRegistratorUtils;
+import org.opendaylight.openflowplugin.impl.util.MdSalRegistrationUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
import org.slf4j.Logger;
final RpcContext rpcContext = new RpcContextImpl(deviceContext.getMessageSpy(), rpcProviderRegistry,
deviceContext, maxRequestsQuota, isStatisticsRpcEnabled, notificationPublishService);
- Verify.verify(contexts.putIfAbsent(deviceContext, rpcContext) == null, "RpcCtx still not closed for node {}", nodeId);
+ Verify.verify(contexts.putIfAbsent(deviceContext, rpcContext) == null, "RPC context still not closed for node {}", nodeId);
deviceContext.addDeviceContextClosedHandler(this);
if (OfpRole.BECOMEMASTER.equals(ofpRole)) {
- LOG.info("Registering Openflow RPCs for node:{}, role:{}", nodeId, ofpRole);
- MdSalRegistratorUtils.registerMasterServices(rpcContext, deviceContext, ofpRole);
+ LOG.info("Registering Openflow RPCs services for node:{}, role:{}", nodeId, ofpRole);
+ MdSalRegistrationUtils.registerMasterServices(rpcContext, deviceContext, ofpRole);
} else if(OfpRole.BECOMESLAVE.equals(ofpRole)) {
// if slave, we need to de-register rpcs if any have been registered, in case of master to slave
- LOG.info("Unregistering RPC registration (if any) for slave role for node:{}", deviceContext.getDeviceState().getNodeId());
- MdSalRegistratorUtils.registerSlaveServices(rpcContext, ofpRole);
+ LOG.info("Unregister RPC services (if any) for slave role for node:{}", deviceContext.getDeviceState().getNodeId());
+ MdSalRegistrationUtils.registerSlaveServices(rpcContext, ofpRole);
} else {
// if we don't know role, we need to unregister rpcs if any have been registered
- LOG.info("Unregistering RPC registration (if any) for slave role for node:{}", deviceContext.getDeviceState().getNodeId());
- MdSalRegistratorUtils.unregisterServices(rpcContext);
+ LOG.info("Unregister RPC services (if any) for slave role for node:{}", deviceContext.getDeviceState().getNodeId());
+ MdSalRegistrationUtils.unregisterServices(rpcContext);
}
// finish device initialization cycle back to DeviceManager
public void onDeviceContextClosed(final DeviceContext deviceContext) {
final RpcContext removedContext = contexts.remove(deviceContext);
if (removedContext != null) {
- LOG.info("Unregistering rpcs for device context closure");
+ LOG.info("Unregister RPCs services for device context closure");
removedContext.close();
}
}
public void onSuccess(final Boolean statisticsGathered) {
if (statisticsGathered) {
//there are some statistics on device worth gathering
- contexts.put(deviceContext, statisticsContext);
final TimeCounter timeCounter = new TimeCounter();
deviceContext.getDeviceState().setStatisticsPollingEnabledProp(true);
scheduleNextPolling(deviceContext, statisticsContext, timeCounter);
}
deviceContext.getDeviceState().setDeviceSynchronized(true);
} else {
- final String deviceAdress = deviceContext.getPrimaryConnectionContext().getConnectionAdapter().getRemoteAddress().toString();
- LOG.info("Statistics for device {} could not be gathered. Closing its device context.", deviceAdress);
+ final String deviceAddress = deviceContext.getPrimaryConnectionContext().getConnectionAdapter().getRemoteAddress().toString();
+ LOG.info("Statistics for device {} could not be gathered. Closing its device context.", deviceAddress);
deviceContext.close();
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.SalTableService;
-public class MdSalRegistratorUtils {
+public class MdSalRegistrationUtils {
//TODO: Make one register and one unregister method for all services
//NOBODY
};
- private MdSalRegistratorUtils() {
+ private MdSalRegistrationUtils() {
throw new IllegalStateException();
}
}
/**
- * Method unregisters all services in first step. So we don't need to call {@link MdSalRegistratorUtils#unregisterServices(RpcContext)}
+ * Method unregisters all services in first step. So we don't need to call {@link MdSalRegistrationUtils#unregisterServices(RpcContext)}
* directly before by change role from {@link OfpRole#BECOMEMASTER} to {@link OfpRole#BECOMESLAVE}.
* Method registers {@link SalEchoService} in next step only because we would like to have SalEchoService as local service for all apps
* to be able actively check connection status for slave connection too.
private static final Logger LOG = LoggerFactory.getLogger(OpenFlowProviderModule.class);
- public OpenFlowProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ public OpenFlowProviderModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
super(identifier, dependencyResolver);
}
- public OpenFlowProviderModule(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.config.openflow.plugin.impl.rev150327.OpenFlowProviderModule oldModule, java.lang.AutoCloseable oldInstance) {
+ public OpenFlowProviderModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.config.openflow.plugin.impl.rev150327.OpenFlowProviderModule oldModule, final java.lang.AutoCloseable oldInstance) {
super(identifier, dependencyResolver, oldModule, oldInstance);
}
public java.lang.AutoCloseable createInstance() {
LOG.info("Initializing new OFP southbound.");
OpenflowPortsUtil.init();
- OpenFlowPluginProvider openflowPluginProvider = new OpenFlowPluginProviderImpl(getRpcRequestsQuota(), getGlobalNotificationQuota());
+ final OpenFlowPluginProvider openflowPluginProvider = new OpenFlowPluginProviderImpl(getRpcRequestsQuota(), getGlobalNotificationQuota());
openflowPluginProvider.setSwitchConnectionProviders(getOpenflowSwitchConnectionProviderDependency());
openflowPluginProvider.setDataBroker(getDataBrokerDependency());
openflowPluginProvider.setIsStatisticsPollingOff(getIsStatisticsPollingOff());
openflowPluginProvider.setEntityOwnershipService(getEntityOwnershipServiceDependency());
openflowPluginProvider.setIsStatisticsRpcEnabled(getIsStatisticsRpcEnabled());
+ openflowPluginProvider.setBarrierCountLimit(getBarrierCountLimit().getValue());
+ openflowPluginProvider.setBarrierInterval(getBarrierIntervalTimeoutLimit().getValue());
+ openflowPluginProvider.setEchoReplyTimeout(getEchoReplyTimeout().getValue());
openflowPluginProvider.initialize();
+ LOG.info("Configured values, StatisticsPollingOff:{}, SwitchFeaturesMandatory:{}, BarrierCountLimit:{}, BarrierTimeoutLimit:{}, EchoReplyTimeout:{}",
+ getIsStatisticsPollingOff(), getSwitchFeaturesMandatory(), getBarrierCountLimit().getValue(),
+ getBarrierIntervalTimeoutLimit().getValue(), getEchoReplyTimeout().getValue());
+
+
return openflowPluginProvider;
}
"Second openflow plugin implementation.";
}
+ typedef non-zero-uint32-type {
+ type uint32 {
+ range "1..max";
+ }
+ }
+
+ typedef non-zero-uint16-type {
+ type uint16 {
+ range "1..max";
+ }
+ }
+
identity openflow-plugin-provider-impl {
base config:module-type;
config:provided-service openflow-provider:openflow-provider;
type boolean;
default "false";
}
+ leaf barrier-interval-timeout-limit {
+ type non-zero-uint32-type;
+ default 500;
+ }
+ leaf barrier-count-limit {
+ type non-zero-uint16-type;
+ default 25600;
+ }
+ leaf echo-reply-timeout {
+ type non-zero-uint32-type;
+ default 2000;
+ }
}
}
@Captor
private ArgumentCaptor<OpenflowProtocolListener> ofpListenerAC;
+ private final static int ECHO_REPLY_TIMEOUT = 500;
+
/**
* before each test method
*/
@Before
public void setUp() {
- connectionManagerImpl = new ConnectionManagerImpl();
+ connectionManagerImpl = new ConnectionManagerImpl(ECHO_REPLY_TIMEOUT);
connectionManagerImpl.setDeviceConnectedHandler(deviceConnectedHandler);
final InetSocketAddress deviceAddress = InetSocketAddress.createUnresolved("yahoo", 42);
Mockito.when(connection.getRemoteAddress()).thenReturn(deviceAddress);
@Test
public void testOnHandshakeSuccessfull() throws Exception {
- handshakeListener.onHandshakeSuccessfull(features, version);
+ handshakeListener.onHandshakeSuccessful(features, version);
Mockito.verify(connectionContextSpy).changeStateToWorking();
Mockito.verify(connectionContextSpy).setFeatures(Matchers.any(FeaturesReply.class));
Mockito.verify(connectionContextSpy).setNodeId(nodeIdCaptor.capture());
public class SystemNotificationsListenerImplTest {
public static final int SAFE_TIMEOUT = 1000;
+ private final static int ECHO_REPLY_TIMEOUT = 2000;
@Mock
private org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter connectionAdapter;
@Mock
Mockito.when(connectionContext.getConnectionAdapter()).thenReturn(connectionAdapter);
Mockito.when(connectionContext.getFeatures()).thenReturn(features);
- systemNotificationsListener = new SystemNotificationsListenerImpl(connectionContext);
+ systemNotificationsListener = new SystemNotificationsListenerImpl(connectionContext, ECHO_REPLY_TIMEOUT);
}
@After
private ConnectionContext addDummyAuxiliaryConnectionContext() {
ConnectionContext mockedConnectionContext = prepareConnectionContext();
- deviceContext.addAuxiliaryConenctionContext(mockedConnectionContext);
+ deviceContext.addAuxiliaryConnectionContext(mockedConnectionContext);
return mockedConnectionContext;
}
when(deviceState.getNodeId()).thenReturn(dummyNodeId);
ConnectionContext mockedAuxiliaryConnectionContext = prepareConnectionContext();
- deviceContext.addAuxiliaryConenctionContext(mockedAuxiliaryConnectionContext);
+ deviceContext.addAuxiliaryConnectionContext(mockedAuxiliaryConnectionContext);
DeviceContextClosedHandler mockedDeviceContextClosedHandler = mock(DeviceContextClosedHandler.class);
deviceContext.addDeviceContextClosedHandler(mockedDeviceContextClosedHandler);
when(deviceState.isValid()).thenReturn(true);
private static final Long DUMMY_MAX_METER = 544L;
private static final String DUMMY_DATAPATH_ID = "44";
private static final Long DUMMY_PORT_NUMBER = 21L;
+ private static final int barrierCountLimit = 25600;
+ private static final int barrierIntervalNanos = 500;
@Mock
CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
final MessageIntelligenceAgency mockedMessageIntelligenceAgency = mock(MessageIntelligenceAgency.class);
final DeviceManagerImpl deviceManager = new DeviceManagerImpl(mockedDataBroker, mockedMessageIntelligenceAgency,
- TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA, false);
+ TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA, false, barrierIntervalNanos, barrierCountLimit);
+
deviceManager.setDeviceInitializationPhaseHandler(deviceInitPhaseHandler);
return deviceManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.features.reply.PhyPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.features.reply.PhyPortBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
/**
* openflowplugin-impl
Assert.assertEquals(expetedResult.getPhyPort(), getFeatures.getPhyPort());
}
+ @Test
+ public void testIsValid_initialValue(){
+ Assert.assertFalse(deviceState.isValid());
+ }
+
+ @Test
+ public void testDeviceSynchronized_initialValue(){
+ Assert.assertFalse(deviceState.deviceSynchronized());
+ }
+
+ @Test
+ public void testStatPollEnabled_initialValue(){
+ Assert.assertFalse(deviceState.isStatisticsPollingEnabled());
+ }
+
+ @Test
+ public void testRole_initialValue(){
+ Assert.assertFalse(deviceState.getRole().equals(OfpRole.BECOMEMASTER));
+ Assert.assertFalse(deviceState.getRole().equals(OfpRole.NOCHANGE));
+ }
+
+ @Test
+ public void testStatistics_initialValue(){
+ Assert.assertFalse(deviceState.isFlowStatisticsAvailable());
+ Assert.assertFalse(deviceState.isPortStatisticsAvailable());
+ Assert.assertFalse(deviceState.isQueueStatisticsAvailable());
+ Assert.assertFalse(deviceState.isTableStatisticsAvailable());
+ }
+
+ @Test
+ public void testMeterAndGroupAvailable_initialValue(){
+ Assert.assertFalse(deviceState.isGroupAvailable());
+ Assert.assertFalse(deviceState.isMetersAvailable());
+ }
+
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.role.service.rev150727.OfpRole;
import org.opendaylight.yangtools.yang.binding.RpcService;
-public class MdSalRegistratorUtilsTest {
+public class MdSalRegistrationUtilsTest {
/**
- * Number of currently registrated services (can be changed) in {@link MdSalRegistratorUtils#registerMasterServices
+ * Number of currently registrated services (can be changed) in {@link MdSalRegistrationUtils#registerServices
* (RpcContext, DeviceContext)}
*/
private static final int NUMBER_OF_RPC_SERVICE_REGISTRATION = 11;
when(mockedFeatures.getDatapathId()).thenReturn(mockedDataPathId);
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedConnectionContext);
- MdSalRegistratorUtils.registerMasterServices(mockedRpcContext,mockedDeviceContext, OfpRole.BECOMEMASTER);
- verify(mockedRpcContext, times(NUMBER_OF_RPC_SERVICE_REGISTRATION)).registerRpcServiceImplementation(any
- (RpcService.class.getClass()), any(RpcService.class));
+ MdSalRegistrationUtils.registerMasterServices(mockedRpcContext,mockedDeviceContext, OfpRole.BECOMEMASTER);
+ verify(mockedRpcContext, times(NUMBER_OF_RPC_SERVICE_REGISTRATION)).registerRpcServiceImplementation(
+ any(RpcService.class.getClass()), any(RpcService.class));
}
}
}
@Override
- public void onHandshakeSuccessfull(GetFeaturesOutput featureOutput,
- Short negotiatedVersion) {
+ public void onHandshakeSuccessful(GetFeaturesOutput featureOutput,
+ Short negotiatedVersion) {
postHandshakeBasic(featureOutput, negotiatedVersion);
}
featureOutput.getAuxiliaryId());
LOG.trace("handshake SETTLED: version={}, datapathId={}, auxiliaryId={}",
version, featureOutput.getDatapathId(), featureOutput.getAuxiliaryId());
- handshakeListener.onHandshakeSuccessfull(featureOutput, proposedVersion);
+ handshakeListener.onHandshakeSuccessful(featureOutput, proposedVersion);
} else {
// handshake failed
LOG.warn("issuing disconnect during handshake [{}]", connectionAdapter.getRemoteAddress());
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(resultFeatures.getResult(), version);
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(resultFeatures.getResult(), version);
}
/**
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(resultFeatures.getResult(), version);
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(resultFeatures.getResult(), version);
}
/**
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessful(
Matchers.any(GetFeaturesOutput.class), Matchers.anyShort());
}
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessful(
Matchers.any(GetFeaturesOutput.class), Matchers.anyShort());
}
handshakeManager.shake(createHelloMessage(expVersion, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), expVersion);
}
handshakeManager.shake(createHelloMessage(expVersion, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), expVersion);
}
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), version);
}
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), version);
}
handshakeManager.shake(createHelloMessage(expVersion, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), expVersion);
}
handshakeManager.shake(createHelloMessage(expVersion, helloXid).build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), expVersion);
}
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessful(
Matchers.any(GetFeaturesOutput.class), Matchers.anyShort());
}
handshakeManager.shake(createHelloMessage(version, helloXid).build());
- Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessful(
Matchers.any(GetFeaturesOutput.class), Matchers.anyShort());
}
handshakeManager.shake(helloMessage.build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), version);
}
handshakeManager.shake(helloMessage.build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), version);
}
handshakeManager.shake(helloMessage.build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), version);
}
handshakeManager.shake(helloMessage.build());
- Mockito.verify(handshakeListener).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener).onHandshakeSuccessful(
resultFeatures.getResult(), version);
}
handshakeManager.shake(helloMessage.build());
- Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessful(
Matchers.any(GetFeaturesOutput.class), Matchers.anyShort());
}
handshakeManager.shake(helloMessage.build());
- Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessfull(
+ Mockito.verify(handshakeListener, Mockito.never()).onHandshakeSuccessful(
Matchers.any(GetFeaturesOutput.class), Matchers.anyShort());
}
connectionConductor.setQueueProcessor(queueProcessor);\r
connectionConductor.init();\r
connectionConductor\r
- .onHandshakeSuccessfull(featuresOutput, (short) 0x01);\r
+ .onHandshakeSuccessful(featuresOutput, (short) 0x01);\r
}\r
}\r