X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=pcep%2Fimpl%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fprotocol%2Fpcep%2Fimpl%2FFiniteStateMachineTest.java;h=778b4d0dde81e0a42eb3d92930553846f58bc8da;hb=refs%2Fchanges%2F07%2F41507%2F5;hp=66b0878f03b6339503541e391eca6955bc962a47;hpb=73ffc98ac38d39dd41842b614281936bdb675078;p=bgpcep.git diff --git a/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/FiniteStateMachineTest.java b/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/FiniteStateMachineTest.java index 66b0878f03..778b4d0dde 100644 --- a/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/FiniteStateMachineTest.java +++ b/pcep/impl/src/test/java/org/opendaylight/protocol/pcep/impl/FiniteStateMachineTest.java @@ -9,250 +9,240 @@ package org.opendaylight.protocol.pcep.impl; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -import static org.mockito.Matchers.any; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import io.netty.channel.Channel; -import io.netty.channel.ChannelFuture; -import io.netty.channel.ChannelHandler; -import io.netty.channel.ChannelPipeline; -import io.netty.channel.DefaultChannelPromise; -import io.netty.util.HashedWheelTimer; + import io.netty.util.concurrent.DefaultPromise; import io.netty.util.concurrent.GlobalEventExecutor; - -import java.util.Arrays; -import java.util.List; - import org.junit.After; import org.junit.Before; import org.junit.Ignore; import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.stubbing.Answer; -import org.opendaylight.protocol.pcep.spi.PCEPErrorMapping; +import org.opendaylight.controller.config.yang.pcep.impl.Tls; +import org.opendaylight.protocol.pcep.impl.spi.Util; import org.opendaylight.protocol.pcep.spi.PCEPErrors; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Keepalive; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.KeepaliveBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Open; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.OpenBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Pcerr; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.PcerrBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Starttls; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.OpenMessage; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.keepalive.message.KeepaliveMessageBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.message.OpenMessageBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcep.error.object.ErrorObjectBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.PcerrMessageBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.pcerr.message.Errors; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.pcerr.message.ErrorsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.pcerr.message.error.type.SessionBuilder; import org.opendaylight.yangtools.yang.binding.Notification; -import com.google.common.collect.Lists; - -public class FiniteStateMachineTest { - - private DefaultPCEPSessionNegotiator serverSession; - - @Mock - private Channel clientListener; - - @Mock - private ChannelPipeline pipeline; - - private final List receivedMsgs = Lists.newArrayList(); - - private Open openmsg; - - private Keepalive kamsg; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.Open localPrefs = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder().setKeepalive( - (short) 1).build(); - this.serverSession = new DefaultPCEPSessionNegotiator(new HashedWheelTimer(), new DefaultPromise(GlobalEventExecutor.INSTANCE), this.clientListener, new SimpleSessionListener(), (short) 1, 20, localPrefs); - final ChannelFuture future = new DefaultChannelPromise(this.clientListener); - doAnswer(new Answer() { - @Override - public Object answer(final InvocationOnMock invocation) { - final Object[] args = invocation.getArguments(); - FiniteStateMachineTest.this.receivedMsgs.add((Notification) args[0]); - return future; - } - }).when(this.clientListener).writeAndFlush(any(Notification.class)); - doReturn("TestingChannel").when(this.clientListener).toString(); - doReturn(this.pipeline).when(this.clientListener).pipeline(); - doReturn(this.pipeline).when(this.pipeline).replace(any(ChannelHandler.class), any(String.class), any(ChannelHandler.class)); - doReturn(true).when(this.clientListener).isActive(); - doReturn(mock(ChannelFuture.class)).when(this.clientListener).close(); - this.openmsg = new OpenBuilder().setOpenMessage( - new OpenMessageBuilder().setOpen( - new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder().setDeadTimer( - (short) 45).setKeepalive((short) 15).build()).build()).build(); - this.kamsg = new KeepaliveBuilder().setKeepaliveMessage(new KeepaliveMessageBuilder().build()).build(); - } - - /** - * Both PCEs accept session characteristics. Also tests KeepAliveTimer and error message and when pce attempts to - * establish pce session for the 2nd time. - * - * @throws Exception - */ - @Test - public void testSessionCharsAccBoth() throws Exception { - this.serverSession.channelActive(null); - assertEquals(1, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(0) instanceof Open); - this.serverSession.handleMessage(this.openmsg); - assertEquals(2, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(1) instanceof Keepalive); - this.serverSession.handleMessage(this.kamsg); - assertEquals(this.serverSession.getState(), DefaultPCEPSessionNegotiator.State.Finished); - } - - /** - * Mock PCE does not accept session characteristics the first time. - * - * @throws Exception - */ - @Test - public void testSessionCharsAccMe() throws Exception { - this.serverSession.channelActive(null); - assertEquals(1, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(0) instanceof Open); - this.serverSession.handleMessage(this.openmsg); - assertEquals(2, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(1) instanceof Keepalive); - this.serverSession.handleMessage(createErrorMessageWOpen(PCEPErrors.NON_ACC_NEG_SESSION_CHAR)); - assertEquals(3, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(2) instanceof Open); - this.serverSession.handleMessage(this.kamsg); - assertEquals(this.serverSession.getState(), DefaultPCEPSessionNegotiator.State.Finished); - } - - private Pcerr createErrorMessageWOpen(final PCEPErrors e) { - final PCEPErrorMapping maping = PCEPErrorMapping.getInstance(); - return new PcerrBuilder().setPcerrMessage( - new PcerrMessageBuilder().setErrorType( - new SessionBuilder().setOpen( - new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.OpenBuilder().setKeepalive( - (short) 1).build()).build()).setErrors( - Arrays.asList(new ErrorsBuilder().setErrorObject( - new ErrorObjectBuilder().setType(maping.getFromErrorsEnum(e).type).setValue( - maping.getFromErrorsEnum(e).value).build()).build())).build()).build(); - } - - /** - * Sending different PCEP Message than Open in session establishment phase. - * - * @throws Exception - */ - @Test - public void testErrorOneOne() throws Exception { - this.serverSession.channelActive(null); - assertEquals(1, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(0) instanceof Open); - this.serverSession.handleMessage(this.kamsg); - for (final Notification m : this.receivedMsgs) { - if (m instanceof Pcerr) { - final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0); - assertEquals(new Short((short) 1), obj.getErrorObject().getType()); - assertEquals(new Short((short) 1), obj.getErrorObject().getValue()); - } - } - } - - /** - * KeepWaitTimer expired. - * - * @throws Exception - */ - @Test - public void testErrorOneSeven() throws Exception { - this.serverSession.channelActive(null); - assertEquals(1, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(0) instanceof Open); - this.serverSession.handleMessage(this.openmsg); - Thread.sleep(1000); - for (final Notification m : this.receivedMsgs) { - if (m instanceof Pcerr) { - final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0); - assertEquals(new Short((short) 1), obj.getErrorObject().getType()); - assertEquals(new Short((short) 7), obj.getErrorObject().getValue()); - } - } - } - - /************* Tests commented because of their long duration (tested timers) **************/ - - /** - * OpenWait timer expired. - * - * @throws InterruptedException - */ - @Test - @Ignore - public void testErrorOneTwo() throws InterruptedException { - this.serverSession.channelActive(null); - assertEquals(1, this.receivedMsgs.size()); - assertTrue(this.receivedMsgs.get(0) instanceof OpenMessage); - Thread.sleep(60 * 1000); - for (final Notification m : this.receivedMsgs) { - if (m instanceof Pcerr) { - final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0); - assertEquals(new Short((short) 1), obj.getErrorObject().getType()); - assertEquals(new Short((short) 2), obj.getErrorObject().getValue()); - } - } - } - - @Test - @Ignore - public void testUnknownMessage() throws InterruptedException { - final SimpleSessionListener client = new SimpleSessionListener(); - final PCEPSessionImpl s = new PCEPSessionImpl(new HashedWheelTimer(), client, 5, this.clientListener, this.openmsg.getOpenMessage().getOpen(), this.openmsg.getOpenMessage().getOpen()); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(1, s.unknownMessagesTimes.size()); - Thread.sleep(10000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(2, s.unknownMessagesTimes.size()); - Thread.sleep(10000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(3, s.unknownMessagesTimes.size()); - Thread.sleep(20000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(4, s.unknownMessagesTimes.size()); - Thread.sleep(30000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(3, s.unknownMessagesTimes.size()); - Thread.sleep(10000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(3, s.unknownMessagesTimes.size()); - Thread.sleep(5000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(4, s.unknownMessagesTimes.size()); - Thread.sleep(1000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - assertEquals(5, s.unknownMessagesTimes.size()); - Thread.sleep(1000); - s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); - synchronized (client) { - while (client.up) { - try { - client.wait(); - } catch (final InterruptedException e) { - e.printStackTrace(); - } - } - } - assertTrue(!client.up); - } - - @After - public void tearDown() { - } +public class FiniteStateMachineTest extends AbstractPCEPSessionTest { + + private DefaultPCEPSessionNegotiator serverSession; + private DefaultPCEPSessionNegotiator tlsSessionNegotiator; + + @Before + public void setup() { + final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.Open localPrefs = new OpenBuilder().setKeepalive( + (short) 1).build(); + this.serverSession = new DefaultPCEPSessionNegotiator(new DefaultPromise(GlobalEventExecutor.INSTANCE), + this.channel, this.listener, (short) 1, 20, localPrefs); + this.tlsSessionNegotiator = new DefaultPCEPSessionNegotiator(new DefaultPromise(GlobalEventExecutor.INSTANCE), + this.channel, this.listener, (short) 1, 20, localPrefs, new Tls()); + } + + /** + * Both PCEs accept session characteristics. Also tests KeepAliveTimer and error message and when pce attempts to + * establish pce session for the 2nd time. + * + * @throws Exception exception + */ + @Test + public void testSessionCharsAccBoth() throws Exception { + this.serverSession.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Open); + this.serverSession.handleMessage(this.openMsg); + assertEquals(2, this.msgsSend.size()); + assertTrue(this.msgsSend.get(1) instanceof Keepalive); + this.serverSession.handleMessage(this.kaMsg); + assertEquals(this.serverSession.getState(), DefaultPCEPSessionNegotiator.State.FINISHED); + } + + /** + * Establish PCEPS TLS connection with peer + */ + @Test + public void testEstablishTLS() { + final DefaultPCEPSessionNegotiator negotiator = new DefaultPCEPSessionNegotiator(new DefaultPromise(GlobalEventExecutor.INSTANCE), + this.channel, this.listener, (short) 1, 20, new OpenBuilder().setKeepalive((short) 1).build(), + SslContextFactoryTest.createTlsConfig()); + negotiator.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Starttls); + assertEquals(DefaultPCEPSessionNegotiator.State.START_TLS_WAIT, negotiator.getState()); + negotiator.handleMessage(this.startTlsMsg); + assertEquals(DefaultPCEPSessionNegotiator.State.OPEN_WAIT, negotiator.getState()); + assertEquals(2, this.msgsSend.size()); + assertTrue(this.msgsSend.get(1) instanceof Open); + negotiator.handleMessage(this.openMsg); + assertEquals(DefaultPCEPSessionNegotiator.State.KEEP_WAIT, negotiator.getState()); + } + + /** + * As Tls is not configured properly, PCE will send error PCEPErrors.NOT_POSSIBLE_WITHOUT_TLS + * + * @throws Exception exception + */ + @Test + public void testFailedToEstablishTLS() throws Exception { + this.tlsSessionNegotiator.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Starttls); + assertEquals(DefaultPCEPSessionNegotiator.State.START_TLS_WAIT, this.tlsSessionNegotiator.getState()); + this.tlsSessionNegotiator.handleMessage(this.startTlsMsg); + assertEquals(2, this.msgsSend.size()); + assertTrue(this.msgsSend.get(1) instanceof Pcerr); + final Errors obj = ((Pcerr) this.msgsSend.get(1)).getPcerrMessage().getErrors().get(0); + assertEquals(PCEPErrors.NOT_POSSIBLE_WITHOUT_TLS.getErrorType(), obj.getErrorObject().getType().shortValue()); + assertEquals(PCEPErrors.NOT_POSSIBLE_WITHOUT_TLS.getErrorValue(), obj.getErrorObject().getValue().shortValue()); + assertEquals(DefaultPCEPSessionNegotiator.State.FINISHED, this.tlsSessionNegotiator.getState()); + } + + /** + * As PCE does not receive expected message (StartTLS), error PCEPErrors.NON_STARTTLS_MSG_RCVD is send + */ + @Test + public void testTLSUnexpectedMessage() { + this.tlsSessionNegotiator.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Starttls); + assertEquals(DefaultPCEPSessionNegotiator.State.START_TLS_WAIT, this.tlsSessionNegotiator.getState()); + this.tlsSessionNegotiator.handleMessage(this.openMsg); + assertEquals(2, this.msgsSend.size()); + assertTrue(this.msgsSend.get(1) instanceof Pcerr); + final Errors obj = ((Pcerr) this.msgsSend.get(1)).getPcerrMessage().getErrors().get(0); + assertEquals(PCEPErrors.NON_STARTTLS_MSG_RCVD.getErrorType(), obj.getErrorObject().getType().shortValue()); + assertEquals(PCEPErrors.NON_STARTTLS_MSG_RCVD.getErrorValue(), obj.getErrorObject().getValue().shortValue()); + assertEquals(this.tlsSessionNegotiator.getState(), DefaultPCEPSessionNegotiator.State.FINISHED); + } + + /** + * Mock PCE does not accept session characteristics the first time. + * + * @throws Exception exception + */ + @Test + public void testSessionCharsAccMe() throws Exception { + this.serverSession.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Open); + final Open remote = (Open) this.msgsSend.get(0); + this.serverSession.handleMessage(this.openMsg); + assertEquals(2, this.msgsSend.size()); + assertTrue(this.msgsSend.get(1) instanceof Keepalive); + this.serverSession.handleMessage(Util.createErrorMessage(PCEPErrors.NON_ACC_NEG_SESSION_CHAR, remote.getOpenMessage().getOpen())); + assertEquals(3, this.msgsSend.size()); + assertTrue(this.msgsSend.get(2) instanceof Open); + this.serverSession.handleMessage(this.kaMsg); + assertEquals(this.serverSession.getState(), DefaultPCEPSessionNegotiator.State.FINISHED); + } + + /** + * Sending different PCEP Message than Open in session establishment phase. + * + * @throws Exception exception + */ + @Test + public void testErrorOneOne() throws Exception { + this.serverSession.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Open); + this.serverSession.handleMessage(this.kaMsg); + for (final Notification m : this.msgsSend) { + if (m instanceof Pcerr) { + final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0); + assertEquals(new Short((short) 1), obj.getErrorObject().getType()); + assertEquals(new Short((short) 1), obj.getErrorObject().getValue()); + } + } + } + + /** + * KeepWaitTimer expired. + * + * @throws Exception exception + */ + @Test + public void testErrorOneSeven() throws Exception { + this.serverSession.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof Open); + this.serverSession.handleMessage(this.openMsg); + Thread.sleep(1000); + for (final Notification m : this.msgsSend) { + if (m instanceof Pcerr) { + final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0); + assertEquals(new Short((short) 1), obj.getErrorObject().getType()); + assertEquals(new Short((short) 7), obj.getErrorObject().getValue()); + } + } + } + + /************* Tests commented because of their long duration (tested timers) **************/ + + /** + * OpenWait timer expired. + * + * @throws InterruptedException exception + */ + @Test + @Ignore + public void testErrorOneTwo() throws InterruptedException { + this.serverSession.channelActive(null); + assertEquals(1, this.msgsSend.size()); + assertTrue(this.msgsSend.get(0) instanceof OpenMessage); + Thread.sleep(60 * 1000); + for (final Notification m : this.msgsSend) { + if (m instanceof Pcerr) { + final Errors obj = ((Pcerr) m).getPcerrMessage().getErrors().get(0); + assertEquals(new Short((short) 1), obj.getErrorObject().getType()); + assertEquals(new Short((short) 2), obj.getErrorObject().getValue()); + } + } + } + + @Test + @Ignore + public void testUnknownMessage() throws InterruptedException { + final SimpleSessionListener client = new SimpleSessionListener(); + final PCEPSessionImpl s = new PCEPSessionImpl(client, 5, this.channel, this.openMsg.getOpenMessage().getOpen(), this.openMsg.getOpenMessage().getOpen()); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(1, s.getUnknownMessagesTimes().size()); + Thread.sleep(10000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(2, s.getUnknownMessagesTimes().size()); + Thread.sleep(10000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(3, s.getUnknownMessagesTimes().size()); + Thread.sleep(20000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(4, s.getUnknownMessagesTimes().size()); + Thread.sleep(30000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(3, s.getUnknownMessagesTimes().size()); + Thread.sleep(10000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(3, s.getUnknownMessagesTimes().size()); + Thread.sleep(5000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(4, s.getUnknownMessagesTimes().size()); + Thread.sleep(1000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + assertEquals(5, s.getUnknownMessagesTimes().size()); + Thread.sleep(1000); + s.handleMalformedMessage(PCEPErrors.CAPABILITY_NOT_SUPPORTED); + synchronized (client) { + while (client.up) { + client.wait(); + } + } + assertTrue(!client.up); + } + + @After + public void tearDown() { + } }