pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/PCEPSessionImpl.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.pcep.impl;
   9
  10 import io.netty.channel.Channel;
  11
  12 import java.io.IOException;
  13 import java.util.ArrayList;
  14 import java.util.Date;
  15 import java.util.LinkedList;
  16 import java.util.List;
  17 import java.util.Queue;
  18 import java.util.Timer;
  19 import java.util.TimerTask;
  20
  21 import org.opendaylight.protocol.framework.DeserializerException;
  22 import org.opendaylight.protocol.framework.DocumentedException;
  23 import org.opendaylight.protocol.framework.ProtocolMessage;
  24 import org.opendaylight.protocol.framework.ProtocolMessageFactory;
  25 import org.opendaylight.protocol.framework.ProtocolSession;
  26 import org.opendaylight.protocol.framework.SessionParent;
  27 import org.opendaylight.protocol.pcep.PCEPCloseTermination;
  28 import org.opendaylight.protocol.pcep.PCEPConnection;
  29 import org.opendaylight.protocol.pcep.PCEPDeserializerException;
  30 import org.opendaylight.protocol.pcep.PCEPErrorTermination;
  31 import org.opendaylight.protocol.pcep.PCEPErrors;
  32 import org.opendaylight.protocol.pcep.PCEPMessage;
  33 import org.opendaylight.protocol.pcep.PCEPSession;
  34 import org.opendaylight.protocol.pcep.PCEPSessionListener;
  35 import org.opendaylight.protocol.pcep.PCEPSessionPreferences;
  36 import org.opendaylight.protocol.pcep.PCEPSessionProposalChecker;
  37 import org.opendaylight.protocol.pcep.PCEPTlv;
  38 import org.opendaylight.protocol.pcep.impl.message.PCEPRawMessage;
  39 import org.opendaylight.protocol.pcep.message.PCEPCloseMessage;
  40 import org.opendaylight.protocol.pcep.message.PCEPErrorMessage;
  41 import org.opendaylight.protocol.pcep.message.PCEPKeepAliveMessage;
  42 import org.opendaylight.protocol.pcep.message.PCEPOpenMessage;
  43 import org.opendaylight.protocol.pcep.object.PCEPCloseObject;
  44 import org.opendaylight.protocol.pcep.object.PCEPCloseObject.Reason;
  45 import org.opendaylight.protocol.pcep.object.PCEPErrorObject;
  46 import org.opendaylight.protocol.pcep.object.PCEPOpenObject;
  47 import org.opendaylight.protocol.pcep.tlv.NodeIdentifierTlv;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 /**
  52  * Implementation of PCEPSession. (Not final for testing.)
  53  */
  54 class PCEPSessionImpl implements PCEPSession, ProtocolSession, PCEPSessionRuntimeMXBean {
  55
  56         /**
  57          * KeepAlive Timer is to be scheduled periodically, each time it starts, it sends KeepAlive Message.
  58          */
  59         private class KeepAliveTimer extends TimerTask {
  60                 private final PCEPSessionImpl parent;
  61
  62                 public KeepAliveTimer(final PCEPSessionImpl parent) {
  63                         this.parent = parent;
  64                 }
  65
  66                 @Override
  67                 public void run() {
  68                         this.parent.handleKeepaliveTimer();
  69                 }
  70         }
  71
  72         /**
  73          * DeadTimer is to be scheduled periodically, when it expires, it closes PCEP session.
  74          */
  75         private class DeadTimer extends TimerTask {
  76                 private final PCEPSessionImpl parent;
  77
  78                 public DeadTimer(final PCEPSessionImpl parent) {
  79                         this.parent = parent;
  80                 }
  81
  82                 @Override
  83                 public void run() {
  84                         this.parent.handleDeadtimer();
  85                 }
  86         }
  87
  88         /**
  89          * OpenWaitTimer runs just once, but can be rescheduled or canceled before expiration. When it expires, it sends an
  90          * error message (1, 2)
  91          */
  92         private class OpenWaitTimer extends TimerTask {
  93
  94                 private final PCEPSessionImpl parent;
  95
  96                 public OpenWaitTimer(final PCEPSessionImpl parent) {
  97                         this.parent = parent;
  98                 }
  99
 100                 @Override
 101                 public void run() {
 102                         this.parent.handleOpenWait();
 103                 }
 104         }
 105
 106         /**
 107          * KeepWaitTimer runs just once, but can be rescheduled or canceled before expiration. When it expires, it sends an
 108          * error message (1, 7)
 109          */
 110         private class KeepWaitTimer extends TimerTask {
 111
 112                 private final PCEPSessionImpl parent;
 113
 114                 public KeepWaitTimer(final PCEPSessionImpl parent) {
 115                         this.parent = parent;
 116                 }
 117
 118                 @Override
 119                 public void run() {
 120                         this.parent.handleKeepWait();
 121                 }
 122         }
 123
 124         /**
 125          * Possible states for Finite State Machine
 126          */
 127         private enum State {
 128                 IDLE, OPEN_WAIT, KEEP_WAIT, UP
 129         }
 130
 131         /**
 132          * In seconds.
 133          */
 134         public static final int OPEN_WAIT_TIMER_VALUE = 60;
 135
 136         public static final int KEEP_WAIT_TIMER_VALUE = 60;
 137
 138         public int KEEP_ALIVE_TIMER_VALUE = 3;
 139
 140         public int DEAD_TIMER_VALUE = 4 * this.KEEP_ALIVE_TIMER_VALUE;
 141
 142         /**
 143          * Actual state of the FSM.
 144          */
 145         private State state;
 146
 147         private OpenWaitTimer openWaitTimer;
 148
 149         private KeepWaitTimer keepWaitTimer;
 150
 151         /**
 152          * System.nanoTime value about when was sent the last message Protected to be updated also in tests.
 153          */
 154         protected long lastMessageSentAt;
 155
 156         /**
 157          * System.nanoTime value about when was received the last message
 158          */
 159         private long lastMessageReceivedAt;
 160
 161         private boolean localOK = false;
 162
 163         private boolean remoteOK = false;
 164
 165         private boolean openRetry = false;
 166
 167         private final int sessionId;
 168
 169         /**
 170          * Protected for testing.
 171          */
 172         protected int maxUnknownMessages = 5;
 173
 174         protected final Queue<Long> unknownMessagesTimes = new LinkedList<Long>();
 175
 176         private final PCEPSessionListener listener;
 177
 178         private PCEPSessionProposalChecker checker = null;
 179
 180         /**
 181          * Open Object with session characteristics that were accepted by another PCE (sent from this session).
 182          */
 183         private PCEPOpenObject localOpen = null;
 184
 185         /**
 186          * Open Object with session characteristics for this session (sent from another PCE).
 187          */
 188         private PCEPOpenObject remoteOpen = null;
 189
 190         private static final Logger logger = LoggerFactory.getLogger(PCEPSessionImpl.class);
 191
 192         /**
 193          * Timer object grouping FSM Timers
 194          */
 195         private final Timer stateTimer;
 196
 197         private final SessionParent parent;
 198
 199         private final PCEPMessageFactory factory;
 200
 201         private int sentMsgCount = 0;
 202
 203         private int receivedMsgCount = 0;
 204
 205         private final String peerAddress;
 206
 207         private final Channel channel;
 208
 209         PCEPSessionImpl(final SessionParent parent, final Timer timer, final PCEPConnection connection, final PCEPMessageFactory factory,
 210                         final int maxUnknownMessages, final int sessionId, final Channel channel) {
 211                 this.state = State.IDLE;
 212                 this.listener = connection.getListener();
 213                 this.checker = connection.getProposalChecker();
 214                 this.sessionId = sessionId;
 215                 this.localOpen = connection.getProposal().getOpenObject();
 216                 this.peerAddress = connection.getPeerAddress().getHostString();
 217                 this.stateTimer = timer;
 218                 this.parent = parent;
 219                 this.factory = factory;
 220                 this.channel = channel;
 221                 if (this.maxUnknownMessages != 0) {
 222                         this.maxUnknownMessages = maxUnknownMessages;
 223                 }
 224         }
 225
 226         @Override
 227         public void startSession() {
 228                 logger.debug("Session started.");
 229                 this.sendMessage(new PCEPOpenMessage(this.localOpen));
 230                 this.restartOpenWait();
 231                 this.changeState(State.OPEN_WAIT);
 232         }
 233
 234         /**
 235          * OpenWait timer can be canceled or rescheduled before its expiration. When it expires, it sends particular
 236          * PCEPErrorMessage and closes PCEP session.
 237          */
 238         private synchronized void handleOpenWait() {
 239                 if (this.state != State.IDLE) {
 240                         this.terminate(PCEPErrors.NO_OPEN_BEFORE_EXP_OPENWAIT); // 1, 1
 241                 }
 242         }
 243
 244         /**
 245          * KeepWait timer can be canceled or rescheduled before its expiration. When it expires, it sends particular
 246          * PCEPErrorMessage and closes PCEP session.
 247          */
 248         private synchronized void handleKeepWait() {
 249                 if (this.state != State.IDLE) {
 250                         this.terminate(PCEPErrors.NO_MSG_BEFORE_EXP_KEEPWAIT); // 1, 7
 251                 }
 252         }
 253
 254         /**
 255          * If DeadTimer expires, the session ends. If a message (whichever) was received during this period, the DeadTimer
 256          * will be rescheduled by DEAD_TIMER_VALUE + the time that has passed from the start of the DeadTimer to the time at
 257          * which the message was received. If the session was closed by the time this method starts to execute (the session
 258          * state will become IDLE), that rescheduling won't occur.
 259          */
 260         private synchronized void handleDeadtimer() {
 261                 final long ct = System.nanoTime();
 262
 263                 final long nextDead = (long) (this.lastMessageReceivedAt + this.DEAD_TIMER_VALUE * 1E9);
 264
 265                 if (this.state != State.IDLE) {
 266                         if (ct >= nextDead) {
 267                                 logger.debug("DeadTimer expired. " + new Date());
 268                                 this.terminate(Reason.EXP_DEADTIMER);
 269                                 return;
 270                         }
 271
 272                         this.stateTimer.schedule(new DeadTimer(this), (long) ((nextDead - ct) / 1E6));
 273                 }
 274         }
 275
 276         /**
 277          * If KeepAlive Timer expires, sends KeepAlive message. If a message (whichever) was send during this period, the
 278          * KeepAlive Timer will be rescheduled by KEEP_ALIVE_TIMER_VALUE + the time that has passed from the start of the
 279          * KeepAlive timer to the time at which the message was sent. If the session was closed by the time this method
 280          * starts to execute (the session state will become IDLE), that rescheduling won't occur.
 281          */
 282         private synchronized void handleKeepaliveTimer() {
 283                 final long ct = System.nanoTime();
 284
 285                 long nextKeepalive = (long) (this.lastMessageSentAt + this.KEEP_ALIVE_TIMER_VALUE * 1E9);
 286
 287                 if (this.state != State.IDLE) {
 288                         if (ct >= nextKeepalive) {
 289                                 this.sendMessage(new PCEPKeepAliveMessage());
 290                                 nextKeepalive = (long) (this.lastMessageSentAt + this.KEEP_ALIVE_TIMER_VALUE * 1E9);
 291                         }
 292
 293                         this.stateTimer.schedule(new KeepAliveTimer(this), (long) ((nextKeepalive - ct) / 1E6));
 294                 }
 295         }
 296
 297         private void changeState(final State finalState) {
 298                 switch (finalState) {
 299                 case IDLE:
 300                         logger.debug("Changed to state: " + State.IDLE);
 301                         this.state = State.IDLE;
 302                         return;
 303                 case OPEN_WAIT:
 304                         logger.debug("Changed to state: " + State.OPEN_WAIT);
 305                         if (this.state == State.UP) {
 306                                 throw new IllegalArgumentException("Cannot change state from " + this.state + " to " + State.OPEN_WAIT);
 307                         }
 308                         this.state = State.OPEN_WAIT;
 309                         return;
 310                 case KEEP_WAIT:
 311                         logger.debug("Changed to state: " + State.KEEP_WAIT);
 312                         if (this.state == State.UP || this.state == State.IDLE) {
 313                                 throw new IllegalArgumentException("Cannot change state from " + this.state + " to " + State.KEEP_WAIT);
 314                         }
 315                         this.state = State.KEEP_WAIT;
 316                         return;
 317                 case UP:
 318                         logger.debug("Changed to state: " + State.UP);
 319                         if (this.state == State.IDLE || this.state == State.UP) {
 320                                 throw new IllegalArgumentException("Cannot change state from " + this.state + " to " + State.UP);
 321                         }
 322                         this.state = State.UP;
 323                         return;
 324                 }
 325         }
 326
 327         private void restartOpenWait() {
 328                 if (this.state == State.OPEN_WAIT && this.openWaitTimer != null) {
 329                         this.openWaitTimer.cancel();
 330                 }
 331                 this.openWaitTimer = new OpenWaitTimer(this);
 332                 this.stateTimer.schedule(this.openWaitTimer, OPEN_WAIT_TIMER_VALUE * 1000);
 333         }
 334
 335         private void restartKeepWaitTimer() {
 336                 if (this.state == State.KEEP_WAIT && this.keepWaitTimer != null) {
 337                         this.keepWaitTimer.cancel();
 338                 }
 339                 this.keepWaitTimer = new KeepWaitTimer(this);
 340                 this.stateTimer.schedule(this.keepWaitTimer, KEEP_WAIT_TIMER_VALUE * 1000);
 341         }
 342
 343         /**
 344          * Makes a callback to check if the session characteristics that FSM received, are acceptable.
 345          *
 346          * @param keepAliveTimerValue
 347          * @param deadTimerValue
 348          * @param tlvs
 349          * @return
 350          */
 351         private boolean checkSessionCharacteristics(final PCEPOpenObject openObj) {
 352                 return this.checker.checkSessionCharacteristics(new PCEPSessionPreferences(openObj));
 353         }
 354
 355         private PCEPOpenObject getNewProposal() {
 356                 return this.checker.getNewProposal(new PCEPSessionPreferences(this.localOpen)).getOpenObject();
 357         }
 358
 359         /**
 360          * Sends message to serialization.
 361          *
 362          * @param msg to be sent
 363          */
 364         @Override
 365         public void sendMessage(final PCEPMessage msg) {
 366                 try {
 367                         this.channel.writeAndFlush(msg);
 368                         this.lastMessageSentAt = System.nanoTime();
 369                         if (!(msg instanceof PCEPKeepAliveMessage)) {
 370                                 logger.debug("Sent message: " + msg);
 371                         }
 372                         this.sentMsgCount++;
 373                 } catch (final Exception e) {
 374                         logger.warn("Message {} was not sent.", msg, e);
 375                 }
 376         }
 377
 378         /**
 379          * Closes PCEP session without sending a Close message, as the channel is no longer active. Notify parent about
 380          * this.
 381          *
 382          * @param reason reason, why it was terminated
 383          */
 384         @Override
 385         public void close() {
 386                 logger.trace("Closing session: {}", this);
 387                 this.changeState(State.IDLE);
 388                 this.parent.onSessionClosed(this);
 389         }
 390
 391         /**
 392          * Closes PCEP session, cancels all timers, returns to state Idle, sends the Close Message. KeepAlive and DeadTimer
 393          * are cancelled if the state of the session changes to IDLE. This method is used to close the PCEP session from
 394          * inside the session or from the listener, therefore the parent of this session should be informed.
 395          */
 396         @Override
 397         public synchronized void close(final PCEPCloseObject.Reason reason) {
 398                 logger.debug("Closing session: {}", this);
 399                 this.sendMessage(new PCEPCloseMessage(new PCEPCloseObject(reason)));
 400                 this.changeState(State.IDLE);
 401                 this.parent.onSessionClosed(this);
 402         }
 403
 404         private void terminate(final PCEPCloseObject.Reason reason) {
 405                 this.listener.onSessionTerminated(this, new PCEPCloseTermination(reason));
 406                 this.sendMessage(new PCEPCloseMessage(new PCEPCloseObject(reason)));
 407                 this.close();
 408         }
 409
 410         private void terminate(final PCEPErrors error) {
 411                 this.listener.onSessionTerminated(this, new PCEPErrorTermination(error));
 412                 this.sendErrorMessage(error);
 413                 this.close();
 414         }
 415
 416         @Override
 417         public void endOfInput() {
 418                 if (this.state != State.IDLE) {
 419                         this.listener.onSessionDown(this, null, new IOException("End of input detected. Close the session."));
 420                 }
 421         }
 422
 423         @Override
 424         public int maximumMessageSize() {
 425                 return 65535;
 426         }
 427
 428         private void sendErrorMessage(final PCEPErrors value) {
 429                 this.sendErrorMessage(value, null);
 430         }
 431
 432         /**
 433          * Sends PCEP Error Message with one PCEPError and Open Object.
 434          *
 435          * @param value
 436          * @param open
 437          */
 438         private void sendErrorMessage(final PCEPErrors value, final PCEPOpenObject open) {
 439                 final PCEPErrorObject error = new PCEPErrorObject(value);
 440                 final List<PCEPErrorObject> errors = new ArrayList<PCEPErrorObject>();
 441                 errors.add(error);
 442                 this.sendMessage(new PCEPErrorMessage(open, errors, null));
 443         }
 444
 445         @Override
 446         public void handleMalformedMessage(final DeserializerException e) {
 447                 // FIXME rewrite
 448
 449         }
 450
 451         @Override
 452         public void handleMalformedMessage(final DocumentedException e) {
 453                 // FIXME rewrite
 454
 455         }
 456
 457         /**
 458          * The fact, that a message is malformed, comes from parser. In case of unrecognized message a particular error is
 459          * sent (CAPABILITY_NOT_SUPPORTED) and the method checks if the MAX_UNKNOWN_MSG per minute wasn't overstepped.
 460          * Second, any other error occurred that is specified by rfc. In this case, the an error message is generated and
 461          * sent.
 462          *
 463          * @param error documented error in RFC5440 or draft
 464          */
 465         public void handleMalformedMessage(final PCEPErrors error) {
 466                 final long ct = System.nanoTime();
 467                 this.sendErrorMessage(error);
 468                 if (error == PCEPErrors.CAPABILITY_NOT_SUPPORTED) {
 469                         this.unknownMessagesTimes.add(ct);
 470                         while (ct - this.unknownMessagesTimes.peek() > 60 * 1E9) {
 471                                 this.unknownMessagesTimes.poll();
 472                         }
 473                         if (this.unknownMessagesTimes.size() > this.maxUnknownMessages) {
 474                                 this.terminate(Reason.TOO_MANY_UNKNOWN_MSG);
 475                         }
 476                 }
 477         }
 478
 479         /**
 480          * In case of syntactic error or some parsing error, the session needs to be closed with the Reason: malformed
 481          * message. The user needs to be notified about this error.
 482          *
 483          * @param e exception that was thrown from parser
 484          */
 485         public void handleMalformedMessage(final Exception e) {
 486                 logger.warn("PCEP byte stream corruption detected", e);
 487                 this.terminate(Reason.MALFORMED_MSG);
 488         }
 489
 490         /**
 491          * Open message should be handled only if the FSM is in OPEN_WAIT state.
 492          *
 493          * @param msg
 494          */
 495         private void handleOpenMessage(final PCEPOpenMessage msg) {
 496                 this.remoteOpen = msg.getOpenObject();
 497                 logger.debug("Received message: " + msg.toString());
 498                 if (this.state != State.OPEN_WAIT) {
 499                         this.sendErrorMessage(PCEPErrors.ATTEMPT_2ND_SESSION);
 500                         return;
 501                 }
 502                 final Boolean result = this.checkSessionCharacteristics(this.remoteOpen);
 503                 if (result == null) {
 504                         this.terminate(PCEPErrors.NON_ACC_NON_NEG_SESSION_CHAR); // 1, 3
 505                         return;
 506                 } else if (result) {
 507                         this.DEAD_TIMER_VALUE = this.remoteOpen.getDeadTimerValue();
 508                         this.KEEP_ALIVE_TIMER_VALUE = this.remoteOpen.getKeepAliveTimerValue();
 509                         logger.debug("Session chars are acceptable. Overwriting: deadtimer: " + this.DEAD_TIMER_VALUE + "keepalive: "
 510                                         + this.KEEP_ALIVE_TIMER_VALUE);
 511                         this.remoteOK = true;
 512                         this.openWaitTimer.cancel();
 513                         this.sendMessage(new PCEPKeepAliveMessage());
 514                         // if the timer is not disabled
 515                         if (this.KEEP_ALIVE_TIMER_VALUE != 0) {
 516                                 this.stateTimer.schedule(new KeepAliveTimer(this), this.KEEP_ALIVE_TIMER_VALUE * 1000);
 517                         }
 518                         if (this.localOK) {
 519                                 // if the timer is not disabled
 520                                 if (this.DEAD_TIMER_VALUE != 0) {
 521                                         this.stateTimer.schedule(new DeadTimer(this), this.DEAD_TIMER_VALUE * 1000);
 522                                 }
 523                                 this.changeState(State.UP);
 524                                 this.listener.onSessionUp(this, this.localOpen, this.remoteOpen);
 525                         } else {
 526                                 this.restartKeepWaitTimer();
 527                                 this.changeState(State.KEEP_WAIT);
 528                         }
 529                         return;
 530                 } else if (!result) {
 531                         this.localOpen = this.getNewProposal();
 532                         if (this.openRetry) {
 533                                 this.terminate(PCEPErrors.SECOND_OPEN_MSG); // 1, 5
 534                         } else {
 535                                 this.openRetry = true;
 536                                 this.sendErrorMessage(PCEPErrors.NON_ACC_NEG_SESSION_CHAR, this.localOpen); // 1, 4
 537                                 if (this.localOK) {
 538                                         this.restartOpenWait();
 539                                         this.changeState(State.OPEN_WAIT);
 540                                 } else {
 541                                         this.restartKeepWaitTimer();
 542                                         this.changeState(State.KEEP_WAIT);
 543                                 }
 544                         }
 545                 }
 546         }
 547
 548         /**
 549          * Error message should be handled in FSM if its state is KEEP_WAIT, otherwise it is just passed to session listener
 550          * for handling.
 551          *
 552          * @param msg
 553          */
 554         private void handleErrorMessage(final PCEPErrorMessage msg) {
 555                 this.remoteOpen = msg.getOpenObject();
 556                 final Boolean result = this.checkSessionCharacteristics(this.remoteOpen);
 557                 if (result == null || !result) {
 558                         this.terminate(PCEPErrors.PCERR_NON_ACC_SESSION_CHAR); // 1, 6
 559                         return;
 560                 } else {
 561                         this.KEEP_ALIVE_TIMER_VALUE = this.remoteOpen.getKeepAliveTimerValue();
 562                         this.DEAD_TIMER_VALUE = this.remoteOpen.getDeadTimerValue();
 563                         logger.debug("New values for keepalive: " + this.remoteOpen.getKeepAliveTimerValue() + " deadtimer "
 564                                         + this.remoteOpen.getDeadTimerValue());
 565                         this.sendMessage(new PCEPOpenMessage(this.remoteOpen));
 566                         if (this.remoteOK) {
 567                                 this.restartKeepWaitTimer();
 568                                 this.changeState(State.KEEP_WAIT);
 569                         } else {
 570                                 this.keepWaitTimer.cancel();
 571                                 this.restartOpenWait();
 572                                 this.changeState(State.OPEN_WAIT);
 573                         }
 574                 }
 575         }
 576
 577         /**
 578          * KeepAlive message should be explicitly parsed in FSM when its state is KEEP_WAIT. Otherwise is handled by the
 579          * KeepAliveTimer or it's invalid.
 580          */
 581         private void handleKeepAliveMessage() {
 582                 if (this.state == State.KEEP_WAIT) {
 583                         this.localOK = true;
 584                         this.keepWaitTimer.cancel();
 585                         if (this.remoteOK) {
 586                                 if (this.DEAD_TIMER_VALUE != 0) {
 587                                         this.stateTimer.schedule(new DeadTimer(this), this.DEAD_TIMER_VALUE * 1000);
 588                                 }
 589                                 this.changeState(State.UP);
 590                                 this.listener.onSessionUp(this, this.localOpen, this.remoteOpen);
 591                         } else {
 592                                 this.restartOpenWait();
 593                                 this.changeState(State.OPEN_WAIT);
 594                         }
 595                 }
 596         }
 597
 598         /**
 599          * Handles incoming message. If the session is up, it notifies the user. The user is notified about every message
 600          * except KeepAlive.
 601          *
 602          * @param msg incoming message
 603          */
 604         @Override
 605         public void handleMessage(final ProtocolMessage msg) {
 606                 // Update last reception time
 607                 final PCEPMessage pcepMsg = (PCEPMessage) msg;
 608
 609                 this.lastMessageReceivedAt = System.nanoTime();
 610                 this.receivedMsgCount++;
 611
 612                 if (pcepMsg instanceof PCEPRawMessage) {
 613                         List<PCEPMessage> msgs;
 614                         try {
 615                                 msgs = PCEPMessageValidator.getValidator(((PCEPRawMessage) pcepMsg).getMsgType()).validate(
 616                                                 ((PCEPRawMessage) pcepMsg).getAllObjects());
 617                                 for (final PCEPMessage tmpMsg : msgs) {
 618                                         this.handleMessage(tmpMsg);
 619                                 }
 620                         } catch (final PCEPDeserializerException e) {
 621                                 logger.error("Malformed message, terminating. ", e);
 622                                 this.terminate(Reason.MALFORMED_MSG);
 623                         }
 624                         return;
 625                 }
 626
 627                 // Keepalives are handled internally
 628                 if (pcepMsg instanceof PCEPKeepAliveMessage) {
 629                         this.handleKeepAliveMessage();
 630                         return;
 631                 }
 632
 633                 // Open messages are handled internally
 634                 if (pcepMsg instanceof PCEPOpenMessage) {
 635                         this.handleOpenMessage((PCEPOpenMessage) pcepMsg);
 636                         return;
 637                 }
 638
 639                 /*
 640                  * During initial handshake we handle all the messages.
 641                  */
 642                 if (this.state != State.UP) {
 643                         /*
 644                          * In KEEP_WAIT, an Error message is a valid thing to see, because
 645                          * it is used in negotiation.
 646                          */
 647                         if (pcepMsg instanceof PCEPErrorMessage && this.state == State.KEEP_WAIT
 648                                         && ((PCEPErrorMessage) pcepMsg).getOpenObject() != null) {
 649                                 this.handleErrorMessage((PCEPErrorMessage) pcepMsg);
 650                                 return;
 651                         }
 652
 653                         /*
 654                          * OPEN and KEEPALIVE messages are handled at the top. ERROR
 655                          * messages are handled in the specific case of KEEP_WAIT above, so
 656                          * anything else is invalid here.
 657                          */
 658                         this.terminate(PCEPErrors.NON_OR_INVALID_OPEN_MSG);
 659                         return;
 660                 }
 661
 662                 /*
 663                  * Session is up, we are reporting all messages to user. One notable
 664                  * exception is CLOSE message, which needs to be converted into a
 665                  * session DOWN event.
 666                  */
 667                 if (pcepMsg instanceof PCEPCloseMessage) {
 668                         this.close();
 669                         return;
 670                 }
 671                 this.listener.onMessage(this, pcepMsg);
 672         }
 673
 674         @Override
 675         public ProtocolMessageFactory getMessageFactory() {
 676                 return this.factory;
 677         }
 678
 679         /**
 680          * @return the sentMsgCount
 681          */
 682
 683         @Override
 684         public Integer getSentMsgCount() {
 685                 return this.sentMsgCount;
 686         }
 687
 688         /**
 689          * @return the receivedMsgCount
 690          */
 691
 692         @Override
 693         public Integer getReceivedMsgCount() {
 694                 return this.receivedMsgCount;
 695         }
 696
 697         @Override
 698         public Integer getDeadTimerValue() {
 699                 return this.DEAD_TIMER_VALUE;
 700         }
 701
 702         @Override
 703         public Integer getKeepAliveTimerValue() {
 704                 return this.KEEP_ALIVE_TIMER_VALUE;
 705         }
 706
 707         @Override
 708         public String getPeerAddress() {
 709                 return this.peerAddress;
 710         }
 711
 712         @Override
 713         public void tearDown() throws IOException {
 714                 this.close();
 715         }
 716
 717         @Override
 718         public String getNodeIdentifier() {
 719                 if (!this.remoteOpen.getTlvs().isEmpty()) {
 720                         final PCEPTlv tlv = this.remoteOpen.getTlvs().iterator().next();
 721                         if (tlv != null && tlv instanceof NodeIdentifierTlv) {
 722                                 return tlv.toString();
 723                         }
 724                 }
 725                 return "";
 726         }
 727
 728         @Override
 729         public String toString() {
 730                 final StringBuilder builder = new StringBuilder();
 731                 builder.append("PCEPSessionImpl [state=");
 732                 builder.append(this.state);
 733                 builder.append(", localOK=");
 734                 builder.append(this.localOK);
 735                 builder.append(", remoteOK=");
 736                 builder.append(this.remoteOK);
 737                 builder.append(", openRetry=");
 738                 builder.append(this.openRetry);
 739                 builder.append(", sessionId=");
 740                 builder.append(this.sessionId);
 741                 builder.append(", checker=");
 742                 builder.append(this.checker);
 743                 builder.append(", localOpen=");
 744                 builder.append(this.localOpen);
 745                 builder.append(", remoteOpen=");
 746                 builder.append(this.remoteOpen);
 747                 builder.append("]");
 748                 return builder.toString();
 749         }
 750 }