*
* @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);
((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 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;
}
}
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());
}
}
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());
+ }
+
}
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