*/
public class NodeTablesFeatureCommitter implements SalTableListener {
- private static final Logger LOG = LoggerFactory.getLogger(NodeChangeCommiter.class);
+ private static final Logger LOG = LoggerFactory.getLogger(NodeTablesFeatureCommitter.class);
private final FlowCapableInventoryProvider manager;
public class StatListenCommitGroup extends StatAbstractListenCommit<Group, OpendaylightGroupStatisticsListener>
implements OpendaylightGroupStatisticsListener {
- private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitMeter.class);
+ private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitGroup.class);
public StatListenCommitGroup(final StatisticsManager manager, final DataBroker db,
final NotificationProviderService nps,
*
* @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
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);
}
@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);
}
}
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.CheckForNull;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
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);
- getRpcContext().registerStatCompatibilityServices();
if (!deviceState.deviceSynchronized()) {
//TODO: no necessary code for yet - it needs for initialization phase only
LOG.debug("Setup Empty TxManager {} for initialization phase", getDeviceState().getNodeId());
transactionChainManager.activateTransactionManager();
return Futures.immediateCheckedFuture(null);
}
- /* Relevant for no initial Slave-to-Master scenario in cluster */
- final ListenableFuture<Void> deviceInitialization = asyncClusterRoleChange();
- Futures.addCallback(deviceInitialization, new FutureCallback<Void>() {
-
- @Override
- public void onSuccess(@Nullable Void aVoid) {
- //No operation
- }
-
- @Override
- public void onFailure(Throwable throwable) {
- LOG.debug("Device {} init unexpected fail. Unregister RPCs", getDeviceState().getNodeId());
- MdSalRegistratorUtils.unregisterServices(getRpcContext());
- }
-
- });
-
- return deviceInitialization;
+ return asyncClusterRoleChange();
} 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));
LOG.debug("Get Initial Device {} information is successful", getDeviceState().getNodeId());
getDeviceState().setDeviceSynchronized(true);
transactionChainManager.activateTransactionManager();
+ MdSalRegistrationUtils.registerMasterServices(getRpcContext(), DeviceContextImpl.this, OfpRole.BECOMEMASTER);
+ getRpcContext().registerStatCompatibilityServices();
initialSubmitTransaction();
getDeviceState().setStatisticsPollingEnabledProp(true);
return null;
@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;
}
}
version = featuresReply.getVersion();
statPollEnabled = false;
deviceSynchronized = false;
+ role = OfpRole.BECOMESLAVE;
}
@Override
Preconditions.checkState(txChainFactory == null, "TxChainFactory survive last close.");
Preconditions.checkState(wTx == null, "We have some unexpected WriteTransaction.");
this.transactionChainManagerStatus = TransactionChainManagerStatus.WORKING;
+ this.submitIsEnabled = false;
createTxChain();
} else {
LOG.debug("Transaction is active {}", nodeId());
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.
@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());
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);
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());
+ }
+
}
final org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId storedGroupId = new org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId(groupIdValue);
final KeyedInstanceIdentifier<Group, GroupKey> groupPath = dummyNodePath.augmentation(FlowCapableNode.class).child(Group.class, new GroupKey(storedGroupId));
- verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.any(InstanceIdentifier.class));
+ verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.<InstanceIdentifier<?>> any());
verify(deviceGroupRegistry).removeMarked();
verify(deviceGroupRegistry).store(storedGroupId);
verify(deviceContext).writeToTransaction(
final KeyedInstanceIdentifier<Flow, FlowKey> flowPath = dummyNodePath.augmentation(FlowCapableNode.class)
.child(Table.class, new TableKey((short) 0))
.child(Flow.class, new FlowKey(new FlowId("openflow:21")));
- verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.any(InstanceIdentifier.class));
+ verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.<InstanceIdentifier<?>>any());
verify(deviceFlowRegistry).storeIfNecessary(FlowRegistryKeyFactory.create(flowBld.build()), (short) 0);
verify(deviceContext).writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.eq(flowPath), Matchers.any(Flow.class));
}
new org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId(meterIdValue);
final KeyedInstanceIdentifier<Meter, MeterKey> meterPath = dummyNodePath.augmentation(FlowCapableNode.class)
.child(Meter.class, new MeterKey(meterId));
- verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.any(InstanceIdentifier.class));
+ verify(deviceContext, Mockito.never()).addDeleteToTxChain(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.<InstanceIdentifier<?>>any());
verify(deviceMeterRegistry).store(meterId);
verify(deviceContext).writeToTransaction(Matchers.eq(LogicalDatastoreType.OPERATIONAL), Matchers.eq(meterPath), Matchers.any(Meter.class));
}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
-
-import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
}
@Test
public void chainTableTrunkWriteOF10Test() {
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
- GetFeaturesOutput mockedFeatures = mock(GetFeaturesOutput.class);
+ final GetFeaturesOutput mockedFeatures = mock(GetFeaturesOutput.class);
when(mockedFeatures.getTables()).thenReturn((short) 2);
when(mockedDeviceState.getFeatures()).thenReturn(mockedFeatures);
when(mockedDeviceState.getNodeInstanceIdentifier()).thenReturn(DUMMY_NODE_II);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
- RpcResult<List<MultipartReply>> mockedRpcResult = mock(RpcResult.class);
+ final RpcResult<List<MultipartReply>> mockedRpcResult = mock(RpcResult.class);
when(mockedRpcResult.isSuccessful()).thenReturn(true);
- List<RpcResult<List<MultipartReply>>> data = new ArrayList<RpcResult<List<MultipartReply>>>();
+ final List<RpcResult<List<MultipartReply>>> data = new ArrayList<RpcResult<List<MultipartReply>>>();
data.add(mockedRpcResult);
data.add(mockedRpcResult);
DeviceInitializationUtils.chainTableTrunkWriteOF10(mockedDeviceContext, Futures.immediateFuture(data));
- verify(mockedDeviceContext, times(3))
- .writeToTransaction(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(FlowCapableNode.class));
+ verify(mockedDeviceContext, times(3)).writeToTransaction(any(LogicalDatastoreType.class),
+ Matchers.<InstanceIdentifier<FlowCapableNode>> any(), any(FlowCapableNode.class));
}
@Test
public void testTranslateAndWriteReplyTypeDesc() {
final ConnectionContext connectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_3);
Mockito.when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(connectionContext);
- DeviceState deviceState = Mockito.mock(DeviceState.class);
+ final DeviceState deviceState = Mockito.mock(DeviceState.class);
Mockito.when(mockedDeviceContext.getDeviceState()).thenReturn(deviceState);
- Collection<MultipartReply> multipartReplyMessages = prepareDataforTypeDesc(mockedDeviceContext);
+ final Collection<MultipartReply> multipartReplyMessages = prepareDataforTypeDesc(mockedDeviceContext);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPDESC, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
@Test
public void translateAndWriteReplyTypeTableFeatures() {
- TableFeaturesBuilder tableFeature = new TableFeaturesBuilder();
+ final TableFeaturesBuilder tableFeature = new TableFeaturesBuilder();
tableFeature.setTableId(DUMMY_TABLE_ID);
- List<TableFeatures> tableFeatures = new ArrayList<>();
+
final List<TableFeatures> tableFeatures = new ArrayList<>();
tableFeatures.add(tableFeature.build());
- MultipartReplyTableFeatures multipartReplyTableFeatures = new MultipartReplyTableFeaturesBuilder().setTableFeatures(tableFeatures).build();
- MultipartReplyTableFeaturesCaseBuilder multipartReplyTableFeaturesCaseBuilder = new MultipartReplyTableFeaturesCaseBuilder();
+ final MultipartReplyTableFeatures multipartReplyTableFeatures = new MultipartReplyTableFeaturesBuilder().setTableFeatures(tableFeatures).build();
+ final MultipartReplyTableFeaturesCaseBuilder multipartReplyTableFeaturesCaseBuilder = new MultipartReplyTableFeaturesCaseBuilder();
multipartReplyTableFeaturesCaseBuilder.setMultipartReplyTableFeatures(multipartReplyTableFeatures);
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyTableFeaturesCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyTableFeaturesCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPTABLEFEATURES, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
.writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL),
@Test
public void translateAndWriteReplyTypeMeterFeatures() {
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
- MultipartReplyMeterFeaturesBuilder multipartReplyMeterFeaturesBuilder = new MultipartReplyMeterFeaturesBuilder();
+ final MultipartReplyMeterFeaturesBuilder multipartReplyMeterFeaturesBuilder = new MultipartReplyMeterFeaturesBuilder();
multipartReplyMeterFeaturesBuilder.setBandTypes(new MeterBandTypeBitmap(true, true));
multipartReplyMeterFeaturesBuilder.setCapabilities(new MeterFlags(true, true, true, true));
multipartReplyMeterFeaturesBuilder.setMaxMeter(DUMMY_MAX_METER);
- MultipartReplyMeterFeaturesCaseBuilder multipartReplyMeterFeaturesCaseBuilder = new MultipartReplyMeterFeaturesCaseBuilder();
+ final MultipartReplyMeterFeaturesCaseBuilder multipartReplyMeterFeaturesCaseBuilder = new MultipartReplyMeterFeaturesCaseBuilder();
multipartReplyMeterFeaturesCaseBuilder.setMultipartReplyMeterFeatures(multipartReplyMeterFeaturesBuilder.build());
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyMeterFeaturesCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyMeterFeaturesCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPMETERFEATURES, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
.writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), eq(DUMMY_NODE_II.augmentation(NodeMeterFeatures.class)), any(NodeMeterFeatures.class));
@Test
public void translateAndWriteReplyTypeGroupFeatures() {
- MultipartReplyGroupFeaturesBuilder multipartReplyGroupFeaturesBuilder = new MultipartReplyGroupFeaturesBuilder();
+ final MultipartReplyGroupFeaturesBuilder multipartReplyGroupFeaturesBuilder = new MultipartReplyGroupFeaturesBuilder();
multipartReplyGroupFeaturesBuilder.setTypes(new GroupTypes(true, true, true, true));
multipartReplyGroupFeaturesBuilder.setCapabilities(new GroupCapabilities(true, true, true, true));
- ActionType actionType = new ActionType(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
+ final ActionType actionType = new ActionType(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
multipartReplyGroupFeaturesBuilder.setActionsBitmap(Lists.newArrayList(actionType));
- MultipartReplyGroupFeatures multipartReplyGroupFeatures = multipartReplyGroupFeaturesBuilder.build();
+ final MultipartReplyGroupFeatures multipartReplyGroupFeatures = multipartReplyGroupFeaturesBuilder.build();
- MultipartReplyGroupFeaturesCaseBuilder multipartReplyGroupFeaturesCaseBuilder = new MultipartReplyGroupFeaturesCaseBuilder();
+ final MultipartReplyGroupFeaturesCaseBuilder multipartReplyGroupFeaturesCaseBuilder = new MultipartReplyGroupFeaturesCaseBuilder();
multipartReplyGroupFeaturesCaseBuilder.setMultipartReplyGroupFeatures(multipartReplyGroupFeatures);
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyGroupFeaturesCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyGroupFeaturesCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPGROUPFEATURES, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
verify(mockedDeviceContext)
@Test
public void translateAndWriteReplyTypePortDesc() {
- ConnectionContext mockedPrimaryConnectionContext = mock(ConnectionContext.class);
- FeaturesReply mockedFeatures = mock(FeaturesReply.class);
+ final ConnectionContext mockedPrimaryConnectionContext = mock(ConnectionContext.class);
+ final FeaturesReply mockedFeatures = mock(FeaturesReply.class);
when(mockedFeatures.getDatapathId()).thenReturn(new BigInteger(DUMMY_DATAPATH_ID));
when(mockedPrimaryConnectionContext.getFeatures()).thenReturn(mockedFeatures);
when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedPrimaryConnectionContext);
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
when(mockedDeviceState.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_0);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
- MessageTranslator mockedTranslator = mock(MessageTranslator.class);
+ final MessageTranslator mockedTranslator = mock(MessageTranslator.class);
when(translatorLibrary.lookupTranslator(any(TranslatorKey.class))).thenReturn(mockedTranslator);
when(mockedDeviceContext.oook()).thenReturn(translatorLibrary);
- MultipartReplyPortDescBuilder multipartReplyPortDescBuilder = new MultipartReplyPortDescBuilder();
+ final MultipartReplyPortDescBuilder multipartReplyPortDescBuilder = new MultipartReplyPortDescBuilder();
- PortsBuilder portsBuilder = new PortsBuilder();
+ final PortsBuilder portsBuilder = new PortsBuilder();
portsBuilder.setPortNo(DUMMY_PORT_NUMBER);
multipartReplyPortDescBuilder.setPorts(Lists.newArrayList(portsBuilder.build()));
- MultipartReplyPortDescCaseBuilder multipartReplyPortDescCaseBuilder = new MultipartReplyPortDescCaseBuilder();
+ final MultipartReplyPortDescCaseBuilder multipartReplyPortDescCaseBuilder = new MultipartReplyPortDescCaseBuilder();
multipartReplyPortDescCaseBuilder.setMultipartReplyPortDesc(multipartReplyPortDescBuilder.build());
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyPortDescCaseBuilder.build()).build();
- Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyPortDescCaseBuilder.build()).build();
+ final Set<MultipartReply> multipartReplyMessages = Collections.<MultipartReply>singleton(multipartReplyMessage);
OpenflowPortsUtil.init();
DeviceInitializationUtils.translateAndWriteReply(MultipartType.OFPMPPORTDESC, mockedDeviceContext, DUMMY_NODE_II, multipartReplyMessages);
- verify(mockedDeviceContext)
- .writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class), any(NodeConnector.class));
+ verify(mockedDeviceContext).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL),
+ Matchers.<InstanceIdentifier<NodeConnector>> any(), any(NodeConnector.class));
}
@Test
public void createSuccessProcessingCallbackTest() {
- DeviceState mockedDeviceState = mock(DeviceState.class);
+ final DeviceState mockedDeviceState = mock(DeviceState.class);
when(mockedDeviceContext.getDeviceState()).thenReturn(mockedDeviceState);
final ConnectionContext connectionContext = buildMockConnectionContext(OFConstants.OFP_VERSION_1_3);
- List<MultipartReply> multipartReplies = new ArrayList<>(prepareDataforTypeDesc(mockedDeviceContext));
- RpcResult<List<MultipartReply>> result = RpcResultBuilder.<List<MultipartReply>>success(multipartReplies).build();
+ final List<MultipartReply> multipartReplies = new ArrayList<>(prepareDataforTypeDesc(mockedDeviceContext));
+ final RpcResult<List<MultipartReply>> result = RpcResultBuilder.<List<MultipartReply>>success(multipartReplies).build();
ListenableFuture<RpcResult<List<MultipartReply>>> mockedRequestContextFuture = Futures.immediateFuture(result);
DeviceInitializationUtils.createSuccessProcessingCallback(MultipartType.OFPMPDESC, mockedDeviceContext, DUMMY_NODE_II, mockedRequestContextFuture);
verify(mockedDeviceContext).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), eq(DUMMY_NODE_II.augmentation(FlowCapableNode.class)), any(FlowCapableNode.class));
- RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder.<List<MultipartReply>>failed().withError(RpcError.ErrorType.PROTOCOL, "dummy error").build();
+ final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder.<List<MultipartReply>>failed().withError(RpcError.ErrorType.PROTOCOL, "dummy error").build();
mockedRequestContextFuture = Futures.immediateFuture(rpcResult);
DeviceInitializationUtils.createSuccessProcessingCallback(MultipartType.OFPMPDESC, mockedDeviceContext, DUMMY_NODE_II, mockedRequestContextFuture);
verify(mockedDeviceContext).writeToTransaction(eq(LogicalDatastoreType.OPERATIONAL), eq(DUMMY_NODE_II.augmentation(FlowCapableNode.class)), any(FlowCapableNode.class));
}
private Collection<MultipartReply> prepareDataforTypeDesc(final DeviceContext mockedDeviceContext) {
- MultipartReplyDesc multipartReplyDesc = new MultipartReplyDescBuilder().build();
+ final MultipartReplyDesc multipartReplyDesc = new MultipartReplyDescBuilder().build();
- MultipartReplyDescCaseBuilder multipartReplyDescCaseBuilder = new MultipartReplyDescCaseBuilder();
+ final MultipartReplyDescCaseBuilder multipartReplyDescCaseBuilder = new MultipartReplyDescCaseBuilder();
multipartReplyDescCaseBuilder.setMultipartReplyDesc(multipartReplyDesc);
- MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyDescCaseBuilder.build()).build();
+ final MultipartReplyMessage multipartReplyMessage = new MultipartReplyMessageBuilder().setMultipartReplyBody(multipartReplyDescCaseBuilder.build()).build();
return Collections.<MultipartReply>singleton(multipartReplyMessage);
}
- protected ConnectionContext buildMockConnectionContext(short ofpVersion) {
+ protected ConnectionContext buildMockConnectionContext(final short ofpVersion) {
when(mockFeatures.getVersion()).thenReturn(ofpVersion);
when(outboundQueueProvider.reserveEntry()).thenReturn(43L);
Mockito.doAnswer(new Answer<Void>() {
@Override
- public Void answer(InvocationOnMock invocation) throws Throwable {
+ public Void answer(final InvocationOnMock invocation) throws Throwable {
final FutureCallback<OfHeader> callBack = (FutureCallback<OfHeader>) invocation.getArguments()[2];
callBack.onSuccess(null);
return null;
when(mockedConnectionAdapter.registerOutboundQueueHandler(Matchers.<OutboundQueueHandler>any(), Matchers.anyInt(), Matchers.anyLong()))
.thenAnswer(new Answer<OutboundQueueHandlerRegistration<OutboundQueueHandler>>() {
@Override
- public OutboundQueueHandlerRegistration<OutboundQueueHandler> answer(InvocationOnMock invocation) throws Throwable {
- OutboundQueueHandler handler = (OutboundQueueHandler) invocation.getArguments()[0];
+ public OutboundQueueHandlerRegistration<OutboundQueueHandler> answer(final InvocationOnMock invocation) throws Throwable {
+ final OutboundQueueHandler handler = (OutboundQueueHandler) invocation.getArguments()[0];
handler.onConnectionQueueChanged(outboundQueueProvider);
return null;
}
package org.opendaylight.openflowplugin.impl.util;
-import static org.mockito.Mockito.any;
+import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-
import java.math.BigInteger;
import org.junit.Test;
+import org.mockito.Matchers;
import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
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(
+ Matchers.<Class<RpcService>> any(), 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());
import org.slf4j.LoggerFactory;
public final class PacketOutConvertor {
- private static final Logger LOG = LoggerFactory.getLogger(MeterConvertor.class);
+ private static final Logger LOG = LoggerFactory.getLogger(PacketOutConvertor.class);
private PacketOutConvertor() {
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());
}
Mockito.when(connectionConductor.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
// provider context - registration responder
- Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(Matchers.any(Class.class), Matchers.any(RpcService.class)))
+ Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(Matchers.<Class<RpcService>>any(), Matchers.any(RpcService.class)))
.then(new Answer<RoutedRpcRegistration<?>>() {
@Override
public RoutedRpcRegistration<?> answer(InvocationOnMock invocation) {
when(featuresOutput.getVersion()).thenReturn(OFConstants.OFP_VERSION_1_3);
when(messageDispatchService.barrier(Mockito.any(BarrierInput.class), Mockito.any(SwitchConnectionDistinguisher.class))).thenReturn(resultListenableFuture);
when(ofRpcTaskContext.getRpcPool()).thenReturn(executorService);
- when(executorService.submit(Mockito.any(Callable.class))).thenReturn(updateFlowRpcResultListenableFuture);
+ when(executorService.submit(Mockito.<Callable<RpcResult<UpdateFlowOutput>>> any())).thenReturn(updateFlowRpcResultListenableFuture);
}
@Test
public void testManageBarrier() throws Exception {
- Collection<RpcError> rpcErrors = OFRpcTaskUtil.manageBarrier(taskContext, true, connectionDistinguisher);
+ final Collection<RpcError> rpcErrors = OFRpcTaskUtil.manageBarrier(taskContext, true, connectionDistinguisher);
assertNotNull(rpcErrors);
}
@Test
public void testHookFutureNotification() throws Exception {
- AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
- OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
+ final AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
+
final OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
OFRpcTaskUtil.hookFutureNotification(addFlowInputRpcResultOFRpcTask, updateFlowRpcResultListenableFuture, notificationProviderService, notificationComposer);
}
@Test
public void testChainFutureBarrier() throws Exception {
- AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
+ final AddFlowInputBuilder flowInputBuilder = new AddFlowInputBuilder();
flowInputBuilder.setBarrier(true);
- OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
+
final OFRpcTask<AddFlowInput, RpcResult<UpdateFlowOutput>> addFlowInputRpcResultOFRpcTask = OFRpcTaskFactory.createAddFlowTask(ofRpcTaskContext, flowInputBuilder.build(), connectionDistinguisher);
OFRpcTaskUtil.chainFutureBarrier(addFlowInputRpcResultOFRpcTask, updateFlowRpcResultListenableFuture);
}
}
\ No newline at end of file
*/
package org.opendaylight.openflowplugin.openflow.md.core.sal.convertor;
+import com.google.common.collect.ImmutableList;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
-
import org.junit.Assert;
import org.junit.Test;
+import org.opendaylight.openflowplugin.openflow.md.util.OpenflowPortsUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.CopyTtlInCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GroupModInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.buckets.grouping.BucketsList;
-import com.google.common.collect.ImmutableList;
-
public class GroupConvertorTest {
/**
@Test
public void testGroupModConvertorwithallParameters() {
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupAll);
- List<Bucket> bucketList = new ArrayList<Bucket>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<Bucket> bucketList = new ArrayList<Bucket>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
int actionOrder = 0;
// Action1
- GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
+ final GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
groupActionBuilder.setGroup("005");
- GroupAction groupIdaction = groupActionBuilder.build();
- ActionBuilder actionsB = new ActionBuilder();
+ final GroupAction groupIdaction = groupActionBuilder.build();
+ final ActionBuilder actionsB = new ActionBuilder();
actionsB.setOrder(actionOrder++).setAction(new GroupActionCaseBuilder().setGroupAction(groupIdaction).build());
// Action2:
- GroupActionBuilder groupActionBuilder1 = new GroupActionBuilder();
+ final GroupActionBuilder groupActionBuilder1 = new GroupActionBuilder();
groupActionBuilder1.setGroup("006");
- GroupAction groupIdaction1 = groupActionBuilder.build();
- ActionBuilder actionsB1 = new ActionBuilder();
+ final GroupAction groupIdaction1 = groupActionBuilder.build();
+ final ActionBuilder actionsB1 = new ActionBuilder();
actionsB1.setOrder(actionOrder++).setAction(new GroupActionCaseBuilder().setGroupAction(groupIdaction1).build());
actionsList.add(actionsB.build());
actionsList.add(actionsB1.build());
- BucketsBuilder bucketsB = new BucketsBuilder();
+ final BucketsBuilder bucketsB = new BucketsBuilder();
- BucketBuilder bucketB = new BucketBuilder();
+ final BucketBuilder bucketB = new BucketBuilder();
bucketB.setWeight(10);
bucketB.setWatchPort(20L);
bucketB.setWatchGroup(22L);
bucketB.setAction(actionsList);
- Bucket bucket = bucketB.build();
+ final Bucket bucket = bucketB.build();
bucketList.add(bucket); // List of bucket
- BucketBuilder bucketB1 = new BucketBuilder();
+ final BucketBuilder bucketB1 = new BucketBuilder();
bucketB1.setWeight(50);
bucketB1.setWatchPort(60L);
bucketB1.setWatchGroup(70L);
// Action1
- CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
- CopyTtlIn copyTtl = copyTtlB.build();
- ActionBuilder actionsB2 = new ActionBuilder();
+ final CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
+ final CopyTtlIn copyTtl = copyTtlB.build();
+ final ActionBuilder actionsB2 = new ActionBuilder();
actionsB2.setOrder(actionOrder++).setAction(new CopyTtlInCaseBuilder().setCopyTtlIn(copyTtl).build());
// Action2:
- SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
+ final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
- SetMplsTtlAction setMAction = setMplsTtlActionBuilder.build();
- ActionBuilder actionsB3 = new ActionBuilder();
+ final SetMplsTtlAction setMAction = setMplsTtlActionBuilder.build();
+ final ActionBuilder actionsB3 = new ActionBuilder();
actionsB3.setOrder(actionOrder++).setAction(new SetMplsTtlActionCaseBuilder().setSetMplsTtlAction(setMAction).build());
bucketB1.setAction(actionsList);
- Bucket bucket1 = bucketB1.build(); // second bucket
+ final Bucket bucket1 = bucketB1.build(); // second bucket
bucketList.add(bucket1);
bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
- Buckets buckets = bucketsB.build();
+ final Buckets buckets = bucketsB.build();
addGroupBuilder.setBuckets(buckets);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
Assert.assertEquals(20L, (long) outAddGroupInput.getBucketsList().get(0).getWatchPort().getValue());
Assert.assertEquals((Long) 22L, outAddGroupInput.getBucketsList().get(0).getWatchGroup());
- List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
+
final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
for (int outItem = 0; outItem < outActionList.size(); outItem++) {
- Action action = outActionList
+ final Action action = outActionList
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
Assert.assertEquals((Integer) 50, outAddGroupInput.getBucketsList().get(1).getWeight());
Assert.assertEquals((long) 60, (long) outAddGroupInput.getBucketsList().get(1).getWatchPort().getValue());
Assert.assertEquals((Long) 70L, outAddGroupInput.getBucketsList().get(1).getWatchGroup());
- List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
+
final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
- Action action = outActionList1
+ final Action action = outActionList1
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
*/
@Test
public void testGroupModConvertorNoBucket() {
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupAll);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
int actionOrder = 0;
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupFf);
- List<Bucket> bucketList = new ArrayList<Bucket>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<Bucket> bucketList = new ArrayList<Bucket>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
// Action1: 005
actionsList.add(assembleActionBuilder("005", actionOrder++).build());
actionsList.add(assembleActionBuilder("006", actionOrder++).build());
// .. and mr.Bond is not coming today
- BucketsBuilder bucketsB = new BucketsBuilder();
+ final BucketsBuilder bucketsB = new BucketsBuilder();
- BucketBuilder bucketB = new BucketBuilder();
+ final BucketBuilder bucketB = new BucketBuilder();
bucketB.setAction(actionsList);
- Bucket bucket = bucketB.build();
+ final Bucket bucket = bucketB.build();
bucketList.add(bucket); // List of bucket
- BucketBuilder bucketB1 = new BucketBuilder();
+ final BucketBuilder bucketB1 = new BucketBuilder();
// Action1
actionsList1.add(assembleCopyTtlInBuilder(actionOrder++).build());
bucketB1.setAction(actionsList1);
- Bucket bucket1 = bucketB1.build(); // second bucket
+ final Bucket bucket1 = bucketB1.build(); // second bucket
bucketList.add(bucket1);
bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
- Buckets buckets = bucketsB.build();
+ final Buckets buckets = bucketsB.build();
addGroupBuilder.setBuckets(buckets);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTFF, outAddGroupInput.getType());
Assert.assertEquals(10L, outAddGroupInput.getGroupId().getValue().longValue());
- List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
+
final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
for (int outItem = 0; outItem < outActionList.size(); outItem++) {
- Action action = outActionList
+ final Action action = outActionList
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
}
}
- List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
+
final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
- Action action = outActionList1
+ final Action action = outActionList1
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 6L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
@Test
public void testGroupModConvertSortedBuckets() {
- int actionOrder = 0;
+ final int actionOrder = 0;
- ArrayList<Bucket> bucket = new ArrayList<Bucket>();
+ final ArrayList<Bucket> bucket = new ArrayList<Bucket>();
bucket.add(new BucketBuilder()
.setBucketId(new BucketId((long) 4))
.build());
- AddGroupInput input = new AddGroupInputBuilder()
+ final AddGroupInput input = new AddGroupInputBuilder()
.setGroupId(new GroupId((long) 1))
.setGroupName("Foo")
.setGroupType(GroupTypes.GroupFf)
.build())
.build();
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(input, (short) 0X4, BigInteger.valueOf(1));
+ OpenflowPortsUtil.init();
+
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(input, (short) 0X4, BigInteger.valueOf(1));
- List<BucketsList> bucketList = outAddGroupInput.getBucketsList();
+ final List<BucketsList> bucketList = outAddGroupInput.getBucketsList();
Assert.assertEquals( Long.valueOf(1), bucketList.get(0).getWatchGroup());
Assert.assertEquals( Long.valueOf(3), bucketList.get(0).getWatchPort().getValue());
/**
* @return
*/
- private static ActionBuilder assembleSetMplsTtlActionBuilder(int actionOrder) {
- SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
+ private static ActionBuilder assembleSetMplsTtlActionBuilder(final int actionOrder) {
+ final SetMplsTtlActionBuilder setMplsTtlActionBuilder = new SetMplsTtlActionBuilder();
setMplsTtlActionBuilder.setMplsTtl((short) 0X1);
- SetMplsTtlActionCaseBuilder setMplsTtlActionCaseBuilder = new SetMplsTtlActionCaseBuilder();
+ final SetMplsTtlActionCaseBuilder setMplsTtlActionCaseBuilder = new SetMplsTtlActionCaseBuilder();
setMplsTtlActionCaseBuilder.setSetMplsTtlAction(setMplsTtlActionBuilder.build());
- ActionBuilder actionsB3 = new ActionBuilder();
+ final ActionBuilder actionsB3 = new ActionBuilder();
actionsB3.setOrder(actionOrder).setAction(setMplsTtlActionCaseBuilder.build());
return actionsB3;
}
/**
* @return
*/
- private static ActionBuilder assembleCopyTtlInBuilder(int actionOrder) {
- CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
- CopyTtlInCaseBuilder copyTtlInCaseBuilder = new CopyTtlInCaseBuilder();
+ private static ActionBuilder assembleCopyTtlInBuilder(final int actionOrder) {
+ final CopyTtlInBuilder copyTtlB = new CopyTtlInBuilder();
+ final CopyTtlInCaseBuilder copyTtlInCaseBuilder = new CopyTtlInCaseBuilder();
copyTtlInCaseBuilder.setCopyTtlIn(copyTtlB.build());
- ActionBuilder actionsB2 = new ActionBuilder();
+ final ActionBuilder actionsB2 = new ActionBuilder();
actionsB2.setOrder(actionOrder).setAction(copyTtlInCaseBuilder.build());
return actionsB2;
}
* @param groupName name of group
* @return
*/
- private static ActionBuilder assembleActionBuilder(String groupName, int actionOrder) {
- GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
+ private static ActionBuilder assembleActionBuilder(final String groupName, final int actionOrder) {
+ final GroupActionBuilder groupActionBuilder = new GroupActionBuilder();
groupActionBuilder.setGroup(groupName);
- GroupActionCaseBuilder groupActionCaseBuilder = new GroupActionCaseBuilder();
+ final GroupActionCaseBuilder groupActionCaseBuilder = new GroupActionCaseBuilder();
groupActionCaseBuilder.setGroupAction(groupActionBuilder.build());
- ActionBuilder actionsBld = new ActionBuilder();
+ final ActionBuilder actionsBld = new ActionBuilder();
actionsBld.setOrder(actionOrder).setAction(groupActionCaseBuilder.build());
return actionsBld;
}
int actionOrder = 0;
- AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
+ final AddGroupInputBuilder addGroupBuilder = new AddGroupInputBuilder();
addGroupBuilder.setGroupId(new GroupId(10L));
addGroupBuilder.setGroupType(GroupTypes.GroupAll);
- List<Bucket> bucketList = new ArrayList<Bucket>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<Bucket> bucketList = new ArrayList<Bucket>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action> actionsList1 = new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action>();
// Action1
actionsList.add(assembleActionBuilder("005", actionOrder++).build());
// Action2:
actionsList.add(assembleActionBuilder("006", actionOrder++).build());
- BucketsBuilder bucketsB = new BucketsBuilder();
+ final BucketsBuilder bucketsB = new BucketsBuilder();
- BucketBuilder bucketB = new BucketBuilder();
+ final BucketBuilder bucketB = new BucketBuilder();
bucketB.setAction(actionsList);
- Bucket bucket = bucketB.build();
+ final Bucket bucket = bucketB.build();
bucketList.add(bucket); // List of bucket
- BucketBuilder bucketB1 = new BucketBuilder();
+ final BucketBuilder bucketB1 = new BucketBuilder();
// Action1
actionsList1.add(assembleCopyTtlInBuilder(actionOrder++).build());
bucketB1.setAction(actionsList);
- Bucket bucket1 = bucketB1.build(); // second bucket
+ final Bucket bucket1 = bucketB1.build(); // second bucket
bucketList.add(bucket1);
bucketsB.setBucket(bucketList);// List of bucket added to the Buckets
- Buckets buckets = bucketsB.build();
+ final Buckets buckets = bucketsB.build();
addGroupBuilder.setBuckets(buckets);
- GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
+ final GroupModInputBuilder outAddGroupInput = GroupConvertor.toGroupModInput(addGroupBuilder.build(), (short) 0X4, BigInteger.valueOf(1));
Assert.assertEquals(GroupModCommand.OFPGCADD, outAddGroupInput.getCommand());
Assert.assertEquals(GroupType.OFPGTALL, outAddGroupInput.getType());
Assert.assertEquals(10L, outAddGroupInput.getGroupId().getValue().longValue());
- List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
+
final List<Action> outActionList = outAddGroupInput.getBucketsList().get(0).getAction();
for (int outItem = 0; outItem < outActionList.size(); outItem++) {
- Action action = outActionList
+ final Action action = outActionList
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
Assert.assertEquals((Long) 5L, ((GroupActionCase) action.getActionChoice()).getGroupAction().getGroupId());
}
- List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
+
final List<Action> outActionList1 = outAddGroupInput.getBucketsList().get(1).getAction();
for (int outItem = 0; outItem < outActionList1.size(); outItem++) {
- Action action = outActionList1
+ final Action action = outActionList1
.get(outItem);
if (action.getActionChoice() instanceof GroupActionCase) {
*/
package org.opendaylight.openflowplugin.openflow.md.core.session;
+import static org.mockito.Matchers.any;
import com.google.common.util.concurrent.ListeningExecutorService;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import org.junit.After;
-import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
import org.opendaylight.openflowplugin.api.openflow.md.core.ConnectionConductor;
import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationEnqueuer;
-import org.opendaylight.openflowplugin.api.openflow.md.core.NotificationQueueWrapper;
import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionContext;
import org.opendaylight.openflowplugin.api.openflow.md.core.session.SessionManager;
import org.opendaylight.openflowplugin.api.openflow.md.core.session.SwitchSessionKeyOF;
import org.opendaylight.openflowplugin.openflow.md.core.role.OfEntityManager;
import org.opendaylight.openflowplugin.openflow.md.core.sal.ModelDrivenSwitchImpl;
import org.opendaylight.openflowplugin.openflow.md.core.sal.SalRegistrationManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutputBuilder;
-import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.RpcService;
-import static org.mockito.Matchers.any;
-
/**
* test of {@link SessionManagerOFImpl}
*/
Mockito.when(context.getNotificationEnqueuer()).thenReturn(notificationEnqueuer);
// provider context - registration responder
- Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(any(Class.class), any(RpcService.class)))
+ Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(Matchers.<Class<RpcService>> any(), any(RpcService.class)))
.then(new Answer<RoutedRpcRegistration<?>>() {
@Override
- public RoutedRpcRegistration<?> answer(InvocationOnMock invocation) {
- Object[] args = invocation.getArguments();
- RoutedRpcRegistration<RpcService> registration = Mockito.mock(RoutedRpcRegistration.class);
+ public RoutedRpcRegistration<?> answer(final InvocationOnMock invocation) {
+ final Object[] args = invocation.getArguments();
+ final RoutedRpcRegistration<RpcService> registration = Mockito.mock(RoutedRpcRegistration.class);
Mockito.when(registration.getInstance()).thenReturn((RpcService) args[1]);
return registration;
}
});
// session listener - prepare registration and notification mockery
- SalRegistrationManager sessionListener = new SalRegistrationManager();
+ final SalRegistrationManager sessionListener = new SalRegistrationManager();
sessionListener.setPublishService(notificationProviderService);
sessionListener.setRpcProviderRegistry(rpcProviderRegistry);
sessionListener.setDataService(dataService);
@Test
public void testAddSessionContext() {
// prepare mocks and values
- GetFeaturesOutputBuilder featuresBld = new GetFeaturesOutputBuilder().setDatapathId(BigInteger.valueOf(42));
+ final GetFeaturesOutputBuilder featuresBld = new GetFeaturesOutputBuilder().setDatapathId(BigInteger.valueOf(42));
featuresBld.setVersion((short) 123);
Mockito.when(context.getFeatures()).thenReturn(featuresBld.build());
Mockito.when(primaryConductor.getConnectionAdapter()).thenReturn(connectionAdapter);
connectionConductor.setQueueProcessor(queueProcessor);\r
connectionConductor.init();\r
connectionConductor\r
- .onHandshakeSuccessfull(featuresOutput, (short) 0x01);\r
+ .onHandshakeSuccessful(featuresOutput, (short) 0x01);\r
}\r
}\r
@Before
public void setupEnvironment() {
when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.any(InstanceIdentifier.class))).thenReturn(Futures.immediateCheckedFuture(Optional.of(nodes)));
+ when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<Nodes>>any())).thenReturn(Futures.immediateCheckedFuture(Optional.of(nodes)));
OpenflowPortsUtil.init();
OFSessionUtil.getSessionManager().setDataBroker(dataBroker);
*/
@Test
public void testReadNode(){
- when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.any(InstanceIdentifier.class))).thenReturn(Futures.immediateCheckedFuture(Optional.of(node)));
+ when(readOnlyTransaction.read(Mockito.any(LogicalDatastoreType.class), Mockito.<InstanceIdentifier<Node>>any())).thenReturn(Futures.immediateCheckedFuture(Optional.of(node)));
InstanceIdentifier<Node> instanceId = InstanceIdentifier.create(Node.class);
Node node = InventoryDataServiceUtil.readNode(instanceId);
assertNotNull(node);
*/
public class LearningSwitchHandlerSimpleImpl implements LearningSwitchHandler, PacketProcessingListener {
- private static final Logger LOG = LoggerFactory.getLogger(LearningSwitchHandler.class);
+ private static final Logger LOG = LoggerFactory.getLogger(LearningSwitchHandlerSimpleImpl.class);
private static final byte[] ETH_TYPE_IPV4 = new byte[] { 0x08, 0x00 };
* provides activation and deactivation of drop responder service - responds on packetIn
*/
public class DropTestRpcProvider implements AutoCloseable {
- private static final Logger LOG = LoggerFactory.getLogger(DropTestDsProvider.class);
+ private static final Logger LOG = LoggerFactory.getLogger(DropTestRpcProvider.class);
private SalFlowService flowService;
private NotificationService notificationService;
public class OpenflowPluginBulkTransactionProvider implements CommandProvider {
- private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginTestCommandProvider.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OpenflowPluginBulkTransactionProvider.class);
private DataBroker dataBroker;
private final BundleContext ctx;
private NodeBuilder testNode;
public class OpenflowpluginTestNodeConnectorNotification {
- private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginTestCommandProvider.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginTestNodeConnectorNotification.class);
private DataBroker dataBroker;
private ProviderContext pc;
public class OpenflowpluginTestTopologyNotification {
- private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginTestCommandProvider.class);
+ private static final Logger LOG = LoggerFactory.getLogger(OpenflowpluginTestTopologyNotification.class);
private DataBroker dataBroker;
private ProviderContext pc;
Code Review / openflowplugin.git / commitdiff