import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
@Test
public void testNotifSubscription3() throws InterruptedException {
    final CountDownLatch latch = new CountDownLatch(1);
    final TwoLevelListChanged testData = createTestData();

    final TestNotifListener testNotifListener = new TestNotifListener(latch);
    final ListenerRegistration<TestNotifListener> listenerRegistration = getNotificationService()
            .registerNotificationListener(testNotifListener);
    assertNotSame(NotificationPublishService.REJECTED,
            getNotificationPublishService().offerNotification(testData, 5, TimeUnit.SECONDS));

    latch.await();
    assertTrue(testNotifListener.getReceivedNotifications().size() == 1);
    assertEquals(testData, testNotifListener.getReceivedNotifications().get(0));

    listenerRegistration.close();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
private static AutoCloseable createHeliumAdapter(final NotificationPublishService publishService,
        final NotificationService listenService) {
    if (listenService instanceof BindingDOMNotificationServiceAdapter
            && publishService instanceof BindingDOMNotificationPublishServiceAdapter) {
        final BindingDOMNotificationPublishServiceAdapter castedPublish =
                (BindingDOMNotificationPublishServiceAdapter) publishService;
        final BindingDOMNotificationServiceAdapter castedListen =
                (BindingDOMNotificationServiceAdapter) listenService;
        final DOMNotificationPublishService domPublishService = castedPublish.getDomPublishService();
        if (domPublishService instanceof DOMNotificationSubscriptionListenerRegistry) {
            final DOMNotificationSubscriptionListenerRegistry subsRegistry =
                    (DOMNotificationSubscriptionListenerRegistry) domPublishService;
            return new HeliumNotificationProviderServiceWithInterestListeners(castedPublish, castedListen,
                    subsRegistry);
        }
    }
    return new HeliumNotificationProviderServiceAdapter(publishService, listenService);
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
@Inject
public InterVpnLinkListener(final DataBroker dataBroker, final IdManagerService idManager,
                            final IMdsalApiManager mdsalManager, final IBgpManager bgpManager,
                            final IFibManager fibManager, final NotificationPublishService notifService,
                            final IVpnLinkService interVpnLinkService,
                            final InterVpnLinkLocator interVpnLinkLocator,
                            final VpnFootprintService vpnFootprintService,
                            final VpnOpDataSyncer vpnOpDataSyncer,
                            final JobCoordinator jobCoordinator,
                            final InterVpnLinkCache interVpnLinkCache) {
    this.dataBroker = dataBroker;
    this.idManager = idManager;
    this.mdsalManager = mdsalManager;
    this.bgpManager = bgpManager;
    this.fibManager = fibManager;
    this.notificationsService = notifService;
    this.ivpnLinkService = interVpnLinkService;
    this.ivpnLinkLocator = interVpnLinkLocator;
    this.vpnFootprintService = vpnFootprintService;
    this.vpnOpDataSyncer = vpnOpDataSyncer;
    this.jobCoordinator = jobCoordinator;
    this.interVpnLinkCache = interVpnLinkCache;
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
@Inject
public NeutronvpnManager(
        final DataBroker dataBroker, final NotificationPublishService notiPublishService,
        final NeutronvpnNatManager vpnNatMgr, final VpnRpcService vpnRpcSrv, final IElanService elanService,
        final NeutronFloatingToFixedIpMappingChangeListener neutronFloatingToFixedIpMappingChangeListener,
        final NeutronvpnConfig neutronvpnConfig, final IVpnManager vpnManager,
        final JobCoordinator jobCoordinator, final NeutronvpnUtils neutronvpnUtils) {
    this.dataBroker = dataBroker;
    this.managedNewTransactionRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
    nvpnNatManager = vpnNatMgr;
    notificationPublishService = notiPublishService;
    vpnRpcService = vpnRpcSrv;
    this.elanService = elanService;
    floatingIpMapListener = neutronFloatingToFixedIpMappingChangeListener;
    this.neutronvpnConfig = neutronvpnConfig;
    neutronEvpnManager = new NeutronEvpnManager(dataBroker, this, neutronvpnUtils);
    neutronEvpnUtils = new NeutronEvpnUtils(dataBroker, vpnManager, jobCoordinator);
    this.jobCoordinator = jobCoordinator;
    this.neutronvpnUtils = neutronvpnUtils;

    configureFeatures();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
/**
 * Primary Constructor which initializes the common services of the plugin.
 *
 * @param db - Data Broker
 * @param activationService - Activation Service
 * @param monitorService - Monitoring Service
 * @param notificationService - Notification Service
 * @param conf - Fpc Configuration
 */
public FpcagentServiceBase(DataBroker db,
		ActivationThreadPool activationService,
        MonitorWorker monitorService,
        NotificationPublishService notificationService,
        FpcConfig conf) {
    this.db = db;
    this.activationService = activationService;
    this.monitorService = monitorService;
    this.notificationService = notificationService;
    this.TARGET_READ_LIMIT = conf.getTargetReadLimit().intValue();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
/**
 * Default Constructor.
 *
 * @param dataBroker - Data Broker
 * @param notificationService - Notification Service
 * @param monitorService - Monitor Service
 * @param activationService - Activation Service
 */
public FpcServiceImpl(DataBroker dataBroker,
        NotificationPublishService notificationService,
        MonitorThreadPool monitorService,
        ActivationThreadPool activationService) {
    this.dataBroker = dataBroker;
    this.notificationService = notificationService;
    this.activationService = activationService;
    this.monitorService = monitorService;
    load();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public AbstractNtfbenchProducer(final NotificationPublishService publishService, final int iterations,
        final int payloadSize) {
    this.publishService = publishService;
    this.iterations = iterations;

    final List<Payload> listVals = new ArrayList<>();
    for (int i = 0; i < payloadSize; i++) {
        listVals.add(new PayloadBuilder().setId(i).build());
    }

    ntf = new NtfbenchBuilder().setPayload(listVals).build();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
@Override
public ListenableFuture<?> offerNotification(final Notification notification) {
    ListenableFuture<?> offerResult = domPublishService.offerNotification(toDomNotification(notification));
    return DOMNotificationPublishService.REJECTED.equals(offerResult)
            ? NotificationPublishService.REJECTED
            : offerResult;
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public void start() {
    checkState(controllerRoot == null, "Binding Aware Broker was already started.");
    LOG.info("Starting Binding Aware Broker: {}", identifier);

    controllerRoot = new RootSalInstance(getRpcProviderRegistry(), getNotificationBroker());

    final ImmutableClassToInstanceMap.Builder<BindingAwareService> consBuilder = ImmutableClassToInstanceMap
            .builder();

    consBuilder.put(NotificationService.class, getRoot());
    consBuilder.put(RpcConsumerRegistry.class, getRoot());
    if (dataBroker != null) {
        consBuilder.put(DataBroker.class, dataBroker);
    }
    consBuilder.put(MountPointService.class, mountService);

    supportedConsumerServices = consBuilder.build();
    final ImmutableClassToInstanceMap.Builder<BindingAwareService> provBuilder = ImmutableClassToInstanceMap
            .builder();
    provBuilder.putAll(supportedConsumerServices).put(NotificationProviderService.class, getRoot())
            .put(RpcProviderRegistry.class, getRoot());
    if (notificationPublishService != null) {
        provBuilder.put(NotificationPublishService.class, notificationPublishService);
    }

    supportedProviderServices = provBuilder.build();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public MdsalLowLevelTestProvider(final RpcProviderRegistry rpcRegistry,
                                 final DOMRpcProviderService domRpcService,
                                 final ClusterSingletonServiceProvider singletonService,
                                 final SchemaService schemaService,
                                 final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer,
                                 final NotificationPublishService notificationPublishService,
                                 final NotificationService notificationService,
                                 final DOMDataBroker domDataBroker,
                                 final DOMDataTreeService domDataTreeService,
                                 final DistributedShardFactory distributedShardFactory,
                                 final DistributedDataStoreInterface configDataStore,
                                 final ActorSystemProvider actorSystemProvider) {
    this.rpcRegistry = rpcRegistry;
    this.domRpcService = domRpcService;
    this.singletonService = singletonService;
    this.schemaService = schemaService;
    this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
    this.notificationPublishService = notificationPublishService;
    this.notificationService = notificationService;
    this.domDataBroker = domDataBroker;
    this.domDataTreeService = domDataTreeService;
    this.distributedShardFactory = distributedShardFactory;
    this.configDataStore = configDataStore;
    this.actorSystem = actorSystemProvider.getActorSystem();

    this.prefixLeaderHandler = new PrefixLeaderHandler(domDataTreeService, bindingNormalizedNodeSerializer);

    domDataTreeChangeService =
            (DOMDataTreeChangeService) domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);

    registration = rpcRegistry.addRpcImplementation(OdlMdsalLowlevelControlService.class, this);

    prefixShardHandler = new PrefixShardHandler(distributedShardFactory, domDataTreeService,
            bindingNormalizedNodeSerializer);
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public PublishNotificationsTask(final NotificationPublishService notificationPublishService,
                                final String notificationId, final long secondsToTake, final long maxPerSecond) {
    Preconditions.checkNotNull(notificationPublishService);
    Preconditions.checkNotNull(notificationId);
    Preconditions.checkArgument(secondsToTake > 0);
    Preconditions.checkArgument(maxPerSecond > 0);

    this.notificationPublishService = notificationPublishService;
    this.notificationId = notificationId;
    this.timeToTake = secondsToTake * SECOND_AS_NANO;
    this.delay = SECOND_AS_NANO / maxPerSecond;

    LOG.debug("Delay : {}", delay);
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
@Before
public void setupToaster() {
    toaster = new OpendaylightToaster();
    toaster.setDataBroker(getDataBroker());
    toaster.init();

    // We'll mock the NotificationProviderService.
    NotificationPublishService mockNotification = mock(NotificationPublishService.class);
    toaster.setNotificationProvider(mockNotification);
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
@Inject
public VpnFootprintService(final DataBroker dataBroker, final IFibManager fibManager,
        final NotificationPublishService notificationPublishService, final VpnOpDataSyncer vpnOpDataSyncer) {
    this.dataBroker = dataBroker;
    this.fibManager = fibManager;
    this.vpnOpDataSyncer = vpnOpDataSyncer;
    this.notificationPublishService = notificationPublishService;
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public InstructionSchedulerFactoryImpl(
        final DataBroker dataProvider,
        final RpcProviderRegistry rpcProviderRegistry,
        final NotificationPublishService notifs,
        final Timer timer,
        final ClusterSingletonServiceProvider cssp,
        final BundleContext bundleContext) {
    this.dataProvider = requireNonNull(dataProvider);
    this.notifs = requireNonNull(notifs);
    this.timer = requireNonNull(timer);
    this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
    this.bundleContext = requireNonNull(bundleContext);
    this.cssp = requireNonNull(cssp);
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
ProgrammingServiceImpl(final DataBroker dataProvider, final NotificationPublishService notifs,
        final ListeningExecutorService executor, final RpcProviderRegistry rpcProviderRegistry,
        final ClusterSingletonServiceProvider cssp, final Timer timer, final String instructionId) {
    this.dataProvider = requireNonNull(dataProvider);
    this.instructionId = requireNonNull(instructionId);
    this.notifs = requireNonNull(notifs);
    this.executor = requireNonNull(executor);
    this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
    this.timer = requireNonNull(timer);
    this.qid = KeyedInstanceIdentifier.builder(InstructionsQueue.class,
            new InstructionsQueueKey(this.instructionId)).build();
    this.sgi = ServiceGroupIdentifier.create(this.instructionId + "-service-group");
    LOG.info("Creating Programming Service {}.", this.sgi.getValue());
    this.csspReg = cssp.registerClusterSingletonService(this);
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
NotificationPublishService getMockedNotificationService() throws InterruptedException {
    final NotificationPublishService mockedNotificationService = mock(NotificationPublishService.class);

    doAnswer(invocation -> {
        final Object notif = invocation.getArguments()[0];
        assertTrue(Notification.class.isAssignableFrom(notif.getClass()));
        MockedNotificationServiceWrapper.this.publishedNotifications.add((Notification) notif);
        return null;
    }).when(mockedNotificationService).putNotification(any(Notification.class));
    return mockedNotificationService;
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public ShimSwitchConnectionHandlerImpl(ZeroMQBaseConnector connector,
        NotificationPublishService _notificationProviderService) {
    coreConnector = connector;
    supportedProtocol = null;
    supportedProtocols = new ArrayList<>();
    mapListeners = new HashMap<>();
    mapFeatures = new HashMap<>();
    notificationProviderService = _notificationProviderService;
    swFeaturesUtil = SwitchFeaturesUtil.getInstance();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public ShimMessageListener(ZeroMQBaseConnector connector, ConnectionAdapter switchConnection, ShimRelay _shimRelay,
        ShimSwitchConnectionHandlerImpl handler, NotificationPublishService _notificationProviderService) {
    this.coreConnector = connector;
    this.switchConnection = switchConnection;
    this.shimRelay = _shimRelay;
    this.connectionHandler = handler;
    notificationProviderService = _notificationProviderService;

    messageTranslators = new ConcurrentHashMap<>();

    addMessageTranslator(ErrorMessage.class, OF10, new ErrorV10Translator());
    addMessageTranslator(ErrorMessage.class, OF13, new ErrorTranslator());
    addMessageTranslator(FlowRemovedMessage.class, OF10, new FlowRemovedTranslator());
    addMessageTranslator(FlowRemovedMessage.class, OF13, new FlowRemovedTranslator());
    addMessageTranslator(PacketInMessage.class, OF10, new PacketInV10Translator());
    addMessageTranslator(PacketInMessage.class, OF13, new PacketInTranslator());
    addMessageTranslator(PortStatusMessage.class, OF10, new PortStatusMessageToNodeConnectorUpdatedTranslator());
    addMessageTranslator(PortStatusMessage.class, OF13, new PortStatusMessageToNodeConnectorUpdatedTranslator());
    addMessageTranslator(MultipartReplyMessage.class, OF13,
            new MultiPartReplyPortToNodeConnectorUpdatedTranslator());
    addMessageTranslator(MultipartReplyMessage.class, OF10, new MultiPartMessageDescToNodeUpdatedTranslator());
    addMessageTranslator(MultipartReplyMessage.class, OF13, new MultiPartMessageDescToNodeUpdatedTranslator());
    addMessageTranslator(ExperimenterMessage.class, OF10, new ExperimenterTranslator());
    addMessageTranslator(MultipartReplyMessage.class, OF10, new MultipartReplyTranslator());
    addMessageTranslator(MultipartReplyMessage.class, OF13, new MultipartReplyTranslator());
    addMessageTranslator(MultipartReplyMessage.class, OF13,
            new MultipartReplyTableFeaturesToTableUpdatedTranslator());
    addMessageTranslator(GetFeaturesOutput.class, OF10, new FeaturesV10ToNodeConnectorUpdatedTranslator());
    addMessageTranslator(NotificationQueueWrapper.class, OF10, new NotificationPlainTranslator());
    addMessageTranslator(NotificationQueueWrapper.class, OF13, new NotificationPlainTranslator());
    sc = new SessionContextOFImpl();
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public NetideProvider(String _coreAddress, int _corePort, ConnectionConfiguration connectionConfiguration,
        NotificationPublishService _notificationProviderService) {
    coreAddress = _coreAddress;
    corePort = _corePort;
    conf = connectionConfiguration;
    notificationProviderService = _notificationProviderService;
}
 

import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; //导入依赖的package包/类
public NtfbenchmarkProvider(final NotificationService listenServiceDependency,
        final NotificationPublishService publishServiceDependency) {
    LOG.debug("NtfbenchmarkProvider Constructor");
    listenService = listenServiceDependency;
    publishService = publishServiceDependency;
}