Examples with Keepalive org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Keepalive used on opensource projects

Example 1 with Keepalive

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Keepalive in project bgpcep by opendaylight.

the class ParserTest method testKeepAliveMsg.

@Test
public void testKeepAliveMsg() throws BGPParsingException, BGPDocumentedException {
    final Notification keepAlive = new KeepaliveBuilder().build();
    final ByteBuf buffer = Unpooled.buffer();
    ParserTest.reg.serializeMessage(keepAlive, buffer);
    assertArrayEquals(KEEPALIVE_BMSG, ByteArray.getAllBytes(buffer));
    final Notification m = ParserTest.reg.parseMessage(Unpooled.copiedBuffer(ByteArray.getAllBytes(buffer)), null);
    assertThat(m, instanceOf(Keepalive.class));
}

Example 2 with Keepalive

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Keepalive in project bgpcep by opendaylight.

the class AbstractBGPSessionNegotiator method handleMessage.

synchronized void handleMessage(final Notification msg) {
    LOG.debug("Channel {} handling message in state {}, msg: {}", this.channel, this.state, msg);
    switch(this.state) {
        case FINISHED:
            sendMessage(buildErrorNotify(BGPError.FSM_ERROR));
            return;
        case IDLE:
            // executed
            if (msg instanceof Open) {
                startNegotiation();
                handleOpen((Open) msg);
                return;
            }
            sendMessage(buildErrorNotify(BGPError.FSM_ERROR));
            break;
        case OPEN_CONFIRM:
            if (msg instanceof Keepalive) {
                negotiationSuccessful();
                LOG.info("BGP Session with peer {} established successfully.", this.channel);
            } else if (msg instanceof Notify) {
                final Notify ntf = (Notify) msg;
                negotiationFailed(new BGPDocumentedException("Peer refusal", BGPError.forValue(ntf.getErrorCode(), ntf.getErrorSubcode())));
            }
            this.state = State.FINISHED;
            return;
        case OPEN_SENT:
            if (msg instanceof Open) {
                handleOpen((Open) msg);
                return;
            }
            break;
        default:
            break;
    }
    // Catch-all for unexpected message
    LOG.warn("Channel {} state {} unexpected message {}", this.channel, this.state, msg);
    sendMessage(buildErrorNotify(BGPError.FSM_ERROR));
    negotiationFailed(new BGPDocumentedException("Unexpected message channel: " + this.channel + ", state: " + this.state + ", message: " + msg, BGPError.FSM_ERROR));
    this.state = State.FINISHED;
}

Example 3 with Keepalive

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Keepalive in project bgpcep by opendaylight.

the class BGPSessionImpl method handleMessage.

/**
 * Handles incoming message based on their type.
 *
 * @param msg incoming message
 */
void handleMessage(final Notification msg) {
    // synchronize on listener and then on this object to ensure correct order of locking
    synchronized (this.listener) {
        synchronized (this) {
            if (this.state == State.IDLE) {
                return;
            }
            try {
                // Update last reception time
                this.lastMessageReceivedAt = System.nanoTime();
                if (msg instanceof Open) {
                    // Open messages should not be present here
                    terminate(new BGPDocumentedException(null, BGPError.FSM_ERROR));
                } else if (msg instanceof Notify) {
                    final Notify notify = (Notify) msg;
                    // Notifications are handled internally
                    LOG.info("Session closed because Notification message received: {} / {}, data={}", notify.getErrorCode(), notify.getErrorSubcode(), notify.getData() != null ? ByteBufUtil.hexDump(notify.getData()) : null);
                    notifyTerminationReasonAndCloseWithoutMessage(notify.getErrorCode(), notify.getErrorSubcode());
                } else if (msg instanceof Keepalive) {
                    // Keepalives are handled internally
                    LOG.trace("Received KeepAlive message.");
                    this.kaCounter++;
                    if (this.kaCounter >= 2) {
                        this.sync.kaReceived();
                    }
                } else if (msg instanceof RouteRefresh) {
                    this.listener.onMessage(this, msg);
                } else if (msg instanceof Update) {
                    this.listener.onMessage(this, msg);
                    this.sync.updReceived((Update) msg);
                } else {
                    LOG.warn("Ignoring unhandled message: {}.", msg.getClass());
                }
                this.sessionState.messageReceived(msg);
            } catch (final BGPDocumentedException e) {
                terminate(e);
            }
        }
    }
}

Example 4 with Keepalive

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Keepalive in project bgpcep by opendaylight.

the class EventBusRegistration method sendMessage.

private static void sendMessage(final BGPSessionListener listener, final Notification message) {
    if (BGPMock.CONNECTION_LOST_MAGIC_MSG.equals(message)) {
        listener.onSessionTerminated(null, new BGPTerminationReason(BGPError.CEASE));
    } else if (message instanceof Open) {
        final Set<BgpTableType> tts = new HashSet<>();
        final List<AddressFamilies> addPathCapabilitiesList = new ArrayList<>();
        for (final BgpParameters param : ((Open) message).getBgpParameters()) {
            for (final OptionalCapabilities capa : param.getOptionalCapabilities()) {
                final CParameters cParam = capa.getCParameters();
                final CParameters1 aug = cParam.augmentation(CParameters1.class);
                if (aug == null) {
                    continue;
                }
                if (aug.getMultiprotocolCapability() != null) {
                    final MultiprotocolCapability p = aug.getMultiprotocolCapability();
                    LOG.debug("Adding open parameter {}", p);
                    final BgpTableType type = new BgpTableTypeImpl(p.getAfi(), p.getSafi());
                    tts.add(type);
                } else if (aug.getAddPathCapability() != null) {
                    final AddPathCapability addPathCap = aug.getAddPathCapability();
                    addPathCapabilitiesList.addAll(addPathCap.getAddressFamilies());
                }
            }
        }
        listener.onSessionUp(new MockBGPSession(tts, addPathCapabilitiesList));
    } else if (!(message instanceof Keepalive)) {
        try {
            listener.onMessage(new MockBGPSession(), message);
        } catch (BGPDocumentedException e) {
            LOG.warn("Exception encountered while handling message", e);
        }
    }
}

Example 5 with Keepalive

use of org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev181109.Keepalive in project bgpcep by opendaylight.

the class PCEPOpenObjectParser method parseObject.

@Override
public Object parseObject(final ObjectHeader header, final ByteBuf bytes) throws PCEPDeserializerException {
    checkArgument(bytes != null && bytes.isReadable(), "Array of bytes is mandatory. Cannot be null or empty.");
    final int versionValue = ByteArray.copyBitsRange(bytes.readByte(), VERSION_SF_OFFSET, VERSION_SF_LENGTH);
    final short keepalive = bytes.readUnsignedByte();
    final short deadTimer = bytes.readUnsignedByte();
    final Uint8 sessionId = ByteBufUtils.readUint8(bytes);
    final TlvsBuilder tbuilder = new TlvsBuilder();
    parseTlvs(tbuilder, bytes.slice());
    final OpenBuilder builder = new OpenBuilder().setVersion(new ProtocolVersion(Uint8.valueOf(versionValue))).setProcessingRule(header.getProcessingRule()).setIgnore(header.getIgnore()).setKeepalive(Uint8.valueOf(keepalive)).setSessionId(sessionId).setTlvs(tbuilder.build());
    if (keepalive == 0) {
        builder.setDeadTimer(Uint8.ZERO);
    } else {
        builder.setDeadTimer(Uint8.valueOf(deadTimer));
    }
    final Open obj = builder.build();
    if (versionValue != PCEP_VERSION) {
        // TODO: Should we move this check into the negotiator
        LOG.debug("Unsupported PCEP version {}", versionValue);
        return new UnknownObject(PCEPErrors.PCEP_VERSION_NOT_SUPPORTED, obj);
    }
    return obj;
}