import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
/**
 * Issue notification to the specified list of Uris
 * @param value - Notification to issue
 * @param uris - Uris to issue the notification to
 */
static protected void issueNotification(Value value, Collection<Uri> uris) {
    Long notificationId = NotificationInfo.next();
    Notify notif = new NotifyBuilder()
            .setNotificationId(new NotificationId(notificationId))
            .setTimestamp(BigInteger.valueOf(System.currentTimeMillis()))
            .setValue(value)
            .build();

    for(Uri uri : uris) {
        if (uri!=null && uri.getValue().startsWith("http") &&
                (HTTPClientPool.instance() != null)) {
                try {
                    HTTPClientPool.instance().getWorker().getQueue().put(
                        new AbstractMap.SimpleEntry<Uri,Notification>(
                                uri,
                                notif));
                } catch (InterruptedException e) {
                	ErrorLog.logError(e.getStackTrace());
                } catch (Exception ee) {
                	ErrorLog.logError(ee.getMessage(),ee.getStackTrace());
                }
            }
    }
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
private NotificationInvoker(final NotificationListener listener) {
    delegate = listener;
    final Map<Class<? extends Notification>, InvokerContext> builder = new HashMap<>();
    for(final TypeToken<?> ifaceToken : TypeToken.of(listener.getClass()).getTypes().interfaces()) {
        final Class<?> iface = ifaceToken.getRawType();
        if(NotificationListener.class.isAssignableFrom(iface) && BindingReflections.isBindingClass(iface)) {
            @SuppressWarnings("unchecked")
            final Class<? extends NotificationListener> listenerType = (Class<? extends NotificationListener>) iface;
            final NotificationListenerInvoker invoker = NotificationListenerInvoker.from(listenerType);
            for(final Class<? extends Notification> type : getNotificationTypes(listenerType)) {
                builder.put(type, new InvokerContext(BindingReflections.findQName(type) , invoker));
            }
        }
    }
    invokers = ImmutableMap.copyOf(builder);
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public Set<Class<? extends Notification>> getNotificationClasses(final Set<SchemaPath> interested) {
    final Set<Class<? extends Notification>> result = new HashSet<>();
    final Set<NotificationDefinition> knownNotifications = runtimeContext().getSchemaContext().getNotifications();
    for (final NotificationDefinition notification : knownNotifications) {
        if (interested.contains(notification.getPath())) {
            try {
                result.add((Class<? extends Notification>) runtimeContext().getClassForSchema(notification));
            } catch (final IllegalStateException e) {
                // Ignore
                LOG.warn("Class for {} is currently not known.", notification.getPath(), e);
            }
        }
    }
    return result;
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Before
public void setUp() {
    this.ctx = ServiceLoaderBGPExtensionProviderContext.getSingletonInstance();
    final MessageRegistry msgRegistry = this.ctx.getMessageRegistry();
    this.parser = new AbstractBmpPerPeerMessageParser<Builder<?>>(msgRegistry) {
        @Override
        public Notification parseMessageBody(final ByteBuf bytes) {
            return null;
        }

        @Override
        public int getBmpMessageType() {
            return 0;
        }
    };
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
private org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev171207.peer.down.data
        .Notification parseBgpNotificationMessage(final ByteBuf bytes) throws BmpDeserializationException {
    final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev171207.peer.down.data
            .NotificationBuilder notificationCBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params
            .xml.ns.yang.bmp.message.rev171207.peer.down.data.NotificationBuilder();

    final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev171207.peer.down.data
            .notification.NotificationBuilder notificationBuilder = new org.opendaylight.yang.gen.v1.urn
            .opendaylight.params.xml.ns.yang.bmp.message.rev171207.peer.down.data.notification
            .NotificationBuilder();
    try {
        final Notification not = this.msgRegistry.parseMessage(bytes, null);
        requireNonNull(not, "Notify message may not be null.");
        Preconditions.checkArgument(not instanceof NotifyMessage,
                "An instance of NotifyMessage is required");
        notificationBuilder.fieldsFrom((NotifyMessage) not);
        notificationCBuilder.setNotification(notificationBuilder.build());
    } catch (final BGPDocumentedException | BGPParsingException e) {
        throw new BmpDeserializationException("Error while parsing BGP Notification message.", e);
    }

    return notificationCBuilder.build();
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Test
public void testSimpleMessageRegistry() throws Exception {
    final MessageRegistry msgRegistry = this.ctx.getMessageRegistry();

    final byte[] msgBytes = {
        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
        (byte) 0x00, (byte) 0x13, (byte) 0x00
    };
    final Notification msg = mock(Notification.class);
    doReturn(Notification.class).when(msg).getImplementedInterface();

    final ByteBuf buffer = Unpooled.buffer(msgBytes.length);
    msgRegistry.serializeMessage(msg, buffer);
    msgRegistry.parseMessage(Unpooled.wrappedBuffer(msgBytes), CONSTRAINT);
    verify(this.activator.msgParser, times(1)).parseMessageBody(Mockito.any(ByteBuf.class), Mockito.anyInt(),
        Mockito.any(PeerSpecificParserConstraint.class));
    verify(this.activator.msgSerializer, times(1)).serializeMessage(Mockito.any(Notification.class), Mockito.any(ByteBuf.class));
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Override
public Notification parseMessageBody(final ByteBuf bytes) throws BmpDeserializationException {
    final InitiationMessageBuilder initiationBuilder = new InitiationMessageBuilder();
    final TlvsBuilder tlvsBuilder = new TlvsBuilder();
    tlvsBuilder.setStringInformation(ImmutableList.of());
    parseTlvs(tlvsBuilder, bytes);

    if (tlvsBuilder.getDescriptionTlv() == null || tlvsBuilder.getDescriptionTlv().getDescription() == null) {
        throw new BmpDeserializationException("Inclusion of sysDescr TLV is mandatory.");
    }
    if (tlvsBuilder.getNameTlv() == null || tlvsBuilder.getNameTlv().getName() == null) {
        throw new BmpDeserializationException("Inclusion of sysName TLV is mandatory.");
    }

    return initiationBuilder.setTlvs(tlvsBuilder.build()).build();
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Override
public void serializeMessageBody(final Notification message, final ByteBuf buffer) {
    super.serializeMessageBody(message, buffer);
    Preconditions.checkArgument(message instanceof PeerUpNotification,
        "An instance of Peer Up notification is required");
    final PeerUpNotification peerUp = (PeerUpNotification) message;

    if (peerUp.getLocalAddress().getIpv4Address() != null) {
        buffer.writeZero(Ipv6Util.IPV6_LENGTH - Ipv4Util.IP4_LENGTH);
        ByteBufWriteUtil.writeIpv4Address(peerUp.getLocalAddress().getIpv4Address(), buffer);
    } else {
        ByteBufWriteUtil.writeIpv6Address(peerUp.getLocalAddress().getIpv6Address(), buffer);
    }
    ByteBufWriteUtil.writeUnsignedShort(peerUp.getLocalPort().getValue(), buffer);
    ByteBufWriteUtil.writeUnsignedShort(peerUp.getRemotePort().getValue(), buffer);

    this.msgRegistry.serializeMessage(new OpenBuilder(peerUp.getSentOpen()).build(), buffer);
    this.msgRegistry.serializeMessage(new OpenBuilder(peerUp.getReceivedOpen()).build(), buffer);
    serializeTlvs(peerUp.getInformation(), buffer);
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Override
public Notification parseMessageBody(final ByteBuf bytes) throws BmpDeserializationException {
    final RouteMonitoringMessageBuilder routeMonitor = new RouteMonitoringMessageBuilder()
            .setPeerHeader(parsePerPeerHeader(bytes));
    try {
        final Notification message = this.msgRegistry.parseMessage(bytes, null);
        requireNonNull(message, "UpdateMessage may not be null");
        Preconditions.checkArgument(message instanceof UpdateMessage,
                "An instance of UpdateMessage is required");
        final UpdateMessage updateMessage = (UpdateMessage) message;
        final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bmp.message.rev171207.route
                .monitoring.message.Update update = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml
                .ns.yang.bmp.message.rev171207.route.monitoring.message.UpdateBuilder(updateMessage).build();
        routeMonitor.setUpdate(update);
    } catch (final BGPDocumentedException | BGPParsingException e) {
        throw new BmpDeserializationException("Error while parsing Update Message.", e);
    }

    return routeMonitor.build();
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Before
public void setUp() {
    MockitoAnnotations.initMocks(this);
    this.messages = Lists.newArrayList();
    this.session = new BmpMockSession(1, 1, 1);
    this.channel = Mockito.mock(Channel.class);
    Mockito.doReturn(REMOTE_ADDRESS).when(this.channel).remoteAddress();
    Mockito.doReturn(LOCAL_ADDRESS).when(this.channel).localAddress();
    final ChannelPipeline pipeline = Mockito.mock(ChannelPipeline.class);
    Mockito.doReturn(pipeline).when(this.channel).pipeline();
    Mockito.doAnswer(invocation -> {
        messages.add((Notification) invocation.getArguments()[0]);
        return null;
    }).when(this.channel).writeAndFlush(Mockito.any());
    final ChannelFuture channelFuture = Mockito.mock(ChannelFuture.class);
    Mockito.doReturn(null).when(channelFuture).addListener(Mockito.any());
    Mockito.doReturn(channelFuture).when(this.channel).closeFuture();
    Mockito.doReturn(channelFuture).when(this.channel).close();
    this.context = Mockito.mock(ChannelHandlerContext.class);
    Mockito.doReturn(this.channel).when(this.context).channel();
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
/**
 * 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);
    checkEquals(()-> {
        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());
            }
        }
    });
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
/**
 * 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);
    checkEquals(() -> {
        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());
            }
        }
    });
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
/**
 * OpenWait timer expired.
 *
 * @throws InterruptedException exception
 */
@Test
public void testErrorOneTwo() throws Exception {
    this.serverSession.channelActive(null);
    assertEquals(1, this.msgsSend.size());
    assertTrue(this.msgsSend.get(0) instanceof OpenMessage);
    checkEquals(() -> {
        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());
            }
        }
    });
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
/**
 * Serializes BGP Notification message.
 *
 * @param msg to be serialized
 * @param bytes ByteBuf where the message will be serialized
 */
@Override
public void serializeMessage(final Notification msg, final ByteBuf bytes) {
    Preconditions.checkArgument(msg instanceof Notify, "Message needs to be of type Notify");
    final Notify ntf = (Notify) msg;

    final ByteBuf msgBody = Unpooled.buffer();
    msgBody.writeByte(ntf.getErrorCode());
    msgBody.writeByte(ntf.getErrorSubcode());
    final byte[] data = ntf.getData();
    if (data != null) {
        msgBody.writeBytes(data);
    }
    LOG.trace("Notification message serialized to: {}", ByteBufUtil.hexDump(msgBody));
    MessageUtil.formatMessage(TYPE, msgBody, bytes);
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Test
public void testNoAs4BytesCapability() {
    this.clientSession.channelActive(null);
    assertEquals(1, this.receivedMsgs.size());
    assertTrue(this.receivedMsgs.get(0) instanceof Open);

    final List<BgpParameters> tlvs = Lists.newArrayList();
    final List<OptionalCapabilities> capas = Lists.newArrayList();
    capas.add(new OptionalCapabilitiesBuilder().setCParameters(new CParametersBuilder().addAugmentation(CParameters1.class,
        new CParameters1Builder().setMultiprotocolCapability(new MultiprotocolCapabilityBuilder()
            .setAfi(this.ipv4tt.getAfi()).setSafi(this.ipv4tt.getSafi()).build()).build()).build()).build());
    capas.add(new OptionalCapabilitiesBuilder().setCParameters(BgpExtendedMessageUtil.EXTENDED_MESSAGE_CAPABILITY).build());
    tlvs.add(new BgpParametersBuilder().setOptionalCapabilities(capas).build());
    // Open Message without advertised four-octet AS Number capability
    this.clientSession.handleMessage(new OpenBuilder().setMyAsNumber(30).setHoldTimer(1).setVersion(
        new ProtocolVersion((short) 4)).setBgpParameters(tlvs).setBgpIdentifier(new Ipv4Address("1.1.1.2")).build());
    assertEquals(2, this.receivedMsgs.size());
    assertTrue(this.receivedMsgs.get(1) instanceof Notify);
    final Notification m = this.receivedMsgs.get(this.receivedMsgs.size() - 1);
    assertEquals(BGPError.UNSUPPORTED_CAPABILITY, BGPError.forValue(((Notify) m).getErrorCode(), ((Notify) m).getErrorSubcode()));
    assertNotNull(((Notify) m).getData());
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
/**
 * Primary Constructor.
 *
 * @param startSignal - Latch start signal
 * @param blockingNotificationQueue - Blocking Queue assigned to the worker
 */
public HTTPNotifier(CountDownLatch startSignal,
        BlockingQueue<AbstractMap.SimpleEntry<Uri,Notification>> blockingNotificationQueue) {
    this.run = false;
    this.startSignal = startSignal;
    this.blockingNotificationQueue = blockingNotificationQueue;
    handler = new BasicResponseHandler();
    this.api = new DpnAPI2(ZMQClientPool.getInstance().getWorker());
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
private void notifyAllListeners(final Set<SchemaPath> added) {
    final Iterator<ListenerRegistration<NotificationInterestListener>> listeners = interestListeners.iterator();
    if(listeners.hasNext()) {
        final Set<Class<? extends Notification>> baEvent = translate(added);
        while(listeners.hasNext()) {
            final NotificationInterestListener listenerRef = listeners.next().getInstance();
            try {
                notifyListener(listenerRef,baEvent);
            } catch (final Exception e) {
                LOG.warn("Unhandled exception during invoking listener {}",e, listenerRef);
            }
        }
    }
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Override
public <T extends Notification> ListenerRegistration<NotificationListener<T>> registerNotificationListener(
        final Class<T> type, final NotificationListener<T> listener) {

    final FunctionalNotificationListenerAdapter<T> adapter = new FunctionalNotificationListenerAdapter<>(codec, type, listener);
    final SchemaPath domType = SchemaPath.create(true, BindingReflections.findQName(type));
    final ListenerRegistration<?> domReg = domService.registerNotificationListener(adapter, domType);
    return new AbstractListenerRegistration<NotificationListener<T>>(listener) {
        @Override
        protected void removeRegistration() {
            domReg.close();
        }

    };
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Override
public Iterable<NotificationListenerRegistration<?>> load(final Class<?> key) {
    final Set<NotificationListenerRegistration<?>> regs = new HashSet<>();

    for (final Class<?> type : getNotificationTypes(key)) {
        @SuppressWarnings("unchecked")
        final Collection<NotificationListenerRegistration<?>> l = typeToListeners.get((Class<? extends Notification>) type);
        if (l != null) {
            regs.addAll(l);
        }
    }

    return ImmutableSet.copyOf(regs);
}
 

import org.opendaylight.yangtools.yang.binding.Notification; //导入依赖的package包/类
@Override
public void publish(final Notification notification) {
    try {
        notificationPublishService.putNotification(notification);
    } catch (InterruptedException e) {
        LOG.error("Notification publication was interupted: "  + e);
    }
}