Java DataBroker类代码示例

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Override
public void onSessionInitiated(ProviderContext session) {
    LOG.info("HelloProvider Session Initiated");
    db = session.getSALService(DataBroker.class);
    helloService = session.addRpcImplementation(HelloService.class, this);

    initializeDataTree(db);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
/**
 * Initialization function.
 * @param db - Data Broker
 * @param tenant - Tenant
 */
protected void init(DataBroker db, Tenant tenant) {
    this.db = db;
    this.tenantId = tenant.getTenantId();
    FpcMobility mobility = tenant.getFpcMobility();
    if (mobility != null){
    	for(Contexts cntx : (mobility.getContexts() == null) ? Collections.<Contexts>emptyList() : mobility.getContexts()){
    		try{
    			LOG.info("Loading Context {} from Storage for Tenant {}", mobility.getContexts(), tenantId);
    			addContext(cntx);
    		} catch (Exception e){
    			LOG.error("PortManager - Error during Context load for Tenant {} / Mobility {}", mobility.getContexts(), tenantId);
    			ErrorLog.logError(e.getStackTrace());
    		}
    	}
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
/**
 * Initialization function.
 * @param db - Data Broker
 * @param tenant - Tenant
 */
protected void init(DataBroker db, Tenant tenant) {
    this.db = db;
    this.tenantId = tenant.getTenantId();

    // Load Stored DPNs from the Tenant
    FpcTopology topo = tenant.getFpcTopology();
    if (topo != null) {
         for (Dpns dpns : (topo.getDpns() == null) ? Collections.<Dpns>emptyList() : topo.getDpns()) {
            try {
                LOG.info("Loading DPN {} from Storage for Tenant {}", tenantId, dpns.getDpnId());
                addDpn(dpns);
            } catch (Exception e) {
                LOG.error("DpnResourceManager - Error during DPN load for Tenant {} / DPN {} ", tenantId,
                        dpns.getDpnId());
                ErrorLog.logError(e.getStackTrace());
            }
        }
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
/**
 * Initialization function.
 * @param db - Data Broker
 * @param tenantMgr - Tenant Manager the Assignment Manager is bound to
 */
public void init(DataBroker db,
                TenantManager tenantMgr) {
    accessAndRoleToDpnGroups = new HashMap<PeerIpAcessRoleKey, Set<String>>();
    dpnGroupsToDpns = new HashMap<String, Set<String>>();
    remoteIpAddressToDpnGroups = new HashMap<PeerIpAcessRoleKey, Set<String>>();
    super.init(db, tenantMgr.getTenant());

    // Load Stored DPNs
    if (tenantMgr.getTenant().getFpcTopology() != null) {
        for (DpnGroups group : (tenantMgr.getTenant().getFpcTopology().getDpnGroups() == null) ?
                Collections.<DpnGroups>emptyList() : tenantMgr.getTenant().getFpcTopology().getDpnGroups()) {
            try {
                loadDpnGroup(group);
            } catch (Exception e) {
                LOG.error("DpnAssignmentMgr - Error during DPN load for " + group.getDpnGroupId());
                ErrorLog.logError(e.getStackTrace());
            }
        }
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
private void retrieveInitialAppConfig(final DataBroker dataBroker) {
    LOG.debug("{}: Got DataBroker instance - reading app config {}", logName(), bindingContext.appConfigPath);

    setDependencyDesc("Initial app config " + bindingContext.appConfigBindingClass.getSimpleName());

    // We register a DTCL to get updates and also read the app config data from the data store. If
    // the app config data is present then both the read and initial DTCN update will return it. If the
    // the data isn't present, we won't get an initial DTCN update so the read will indicate the data
    // isn't present.

    DataTreeIdentifier<DataObject> dataTreeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
            bindingContext.appConfigPath);
    appConfigChangeListenerReg = dataBroker.registerDataTreeChangeListener(dataTreeId,
            (ClusteredDataTreeChangeListener<DataObject>) this::onAppConfigChanged);

    readInitialAppConfig(dataBroker);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Test
public void testSeparateWrites() throws InterruptedException, TimeoutException, ExecutionException {

    DataBroker dataBroker = testContext.getDataBroker();

    final SettableFuture<AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject>> eventFuture =
            SettableFuture.create();
    dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, DEEP_WILDCARDED_PATH,
        dataChangeEvent -> eventFuture.set(dataChangeEvent), DataChangeScope.SUBTREE);

    final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
    transaction.put(LogicalDatastoreType.OPERATIONAL, NODE_0_CWU_PATH, CWU, true);
    transaction.put(LogicalDatastoreType.OPERATIONAL, NODE_0_LVU_PATH, LVU, true);
    transaction.put(LogicalDatastoreType.OPERATIONAL, NODE_1_LVU_PATH, LVU, true);
    transaction.submit().get(5, TimeUnit.SECONDS);

    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = eventFuture.get(1000, TimeUnit.MILLISECONDS);

    validateEvent(event);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Test
public void deleteChildListenParent() throws InterruptedException, ExecutionException, TimeoutException {
    DataBroker dataBroker = testContext.getDataBroker();
    final WriteTransaction initTx = dataBroker.newWriteOnlyTransaction();

    initTx.put(LogicalDatastoreType.OPERATIONAL, LIST11_PATH, createList11(), true);
    initTx.submit().get(5, TimeUnit.SECONDS);

    final SettableFuture<AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject>> event = SettableFuture.create();
    dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, LIST11_PATH,
        change -> event.set(change), DataChangeScope.SUBTREE);

    final WriteTransaction deleteTx = dataBroker.newWriteOnlyTransaction();
    deleteTx.delete(LogicalDatastoreType.OPERATIONAL, LIST11_PATH.augmentation(List11SimpleAugment.class));
    deleteTx.submit().get(5, TimeUnit.SECONDS);

    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> receivedEvent = event.get();
    assertFalse(receivedEvent.getRemovedPaths().contains(TLL_COMPLEX_AUGMENT_PATH));
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    NotificationPattern notificationPattern = new NotificationPattern("value1");
    eventSourceServiceMock = mock(EventSourceService.class);
    eventSourceTopologyMock = mock(EventSourceTopology.class);
    dataBrokerMock = mock(DataBroker.class);
    doReturn(eventSourceServiceMock).when(eventSourceTopologyMock).getEventSourceService();
    doReturn(dataBrokerMock).when(eventSourceTopologyMock).getDataBroker();

    WriteTransaction writeTransactionMock = mock(WriteTransaction.class);
    doReturn(writeTransactionMock).when(dataBrokerMock).newWriteOnlyTransaction();
    doNothing().when(writeTransactionMock).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(DataObject.class),eq(true));
    CheckedFuture checkedFutureWriteMock = mock(CheckedFuture.class);
    doReturn(checkedFutureWriteMock).when(writeTransactionMock).submit();

    ReadOnlyTransaction readOnlyTransactionMock = mock(ReadOnlyTransaction.class);
    doReturn(readOnlyTransactionMock).when(dataBrokerMock).newReadOnlyTransaction();
    CheckedFuture checkedFutureReadMock = mock(CheckedFuture.class);
    doReturn(checkedFutureReadMock).when(readOnlyTransactionMock).read(LogicalDatastoreType.OPERATIONAL, EventSourceTopology.EVENT_SOURCE_TOPOLOGY_PATH);
    eventSourceTopic = EventSourceTopic.create(notificationPattern, "nodeIdPattern1", eventSourceTopologyMock);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testDataTreeChangeListener() throws Exception {
    DataBroker dataBroker = getDataBroker();

    DataTreeChangeListener<ListItem> listener = mock(DataTreeChangeListener.class);
    InstanceIdentifier<ListItem> wildCard = InstanceIdentifier.builder(ListenerTest.class)
            .child(ListItem.class).build();
    ListenerRegistration<DataTreeChangeListener<ListItem>> reg = dataBroker.registerDataTreeChangeListener(
            new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, wildCard), listener);

    final ListItem item = writeListItem();

    ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);

    verify(listener, timeout(100)).onDataTreeChanged(captor.capture());

    Collection<DataTreeModification<ListItem>> mods = captor.getValue();
    assertEquals("ListItem", item, mods.iterator().next().getRootNode().getDataAfter());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@SuppressWarnings({ "checkstyle:IllegalCatch", "checkstyle:IllegalThrows" })
public DataBroker getDataBroker() throws RuntimeException {
    try {
        // This is a little bit "upside down" - in the future,
        // we should probably put what is in AbstractDataBrokerTest
        // into this DataBrokerTestModule, and make AbstractDataBrokerTest
        // use it, instead of the way around it currently is (the opposite);
        // this is just for historical reasons... and works for now.
        ConstantSchemaAbstractDataBrokerTest dataBrokerTest
            = new ConstantSchemaAbstractDataBrokerTest(useMTDataTreeChangeListenerExecutor);
        dataBrokerTest.setup();
        return dataBrokerTest.getDataBroker();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Test
public void testToasterInitOnStartUp() throws Exception {
    DataBroker broker = getDataBroker();

    ReadOnlyTransaction readTx = broker.newReadOnlyTransaction();
    Optional<Toaster> optional = readTx.read(LogicalDatastoreType.OPERATIONAL, TOASTER_IID).get();
    assertNotNull(optional);
    assertTrue("Operational toaster not present", optional.isPresent());

    Toaster toasterData = optional.get();

    assertEquals(Toaster.ToasterStatus.Up, toasterData.getToasterStatus());
    assertEquals(new DisplayString("Opendaylight"), toasterData.getToasterManufacturer());
    assertEquals(new DisplayString("Model 1 - Binding Aware"), toasterData.getToasterModelNumber());

    Optional<Toaster> configToaster = readTx.read(LogicalDatastoreType.CONFIGURATION, TOASTER_IID).get();
    assertFalse("Didn't expect config data for toaster.", configToaster.isPresent());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
static void unbindService(DataBroker dataBroker, final String vpnInterfaceName, boolean isInterfaceStateDown,
        JobCoordinator jobCoordinator) {
    if (!isInterfaceStateDown) {
        jobCoordinator.enqueueJob(vpnInterfaceName,
            () -> {
                WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
                writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
                        InterfaceUtils.buildServiceId(vpnInterfaceName,
                                ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
                                        NwConstants.L3VPN_SERVICE_INDEX)));

                List<ListenableFuture<Void>> futures = new ArrayList<>();
                futures.add(writeTxn.submit());
                return futures;
            });
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Nonnull
public static List<BigInteger> getDpnsForRouter(DataBroker dataBroker, String routerUuid) {
    InstanceIdentifier id = InstanceIdentifier.builder(NeutronRouterDpns.class)
        .child(RouterDpnList.class, new RouterDpnListKey(routerUuid)).build();
    Optional<RouterDpnList> routerDpnListData =
            SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
                    LogicalDatastoreType.OPERATIONAL, id);
    List<BigInteger> dpns = new ArrayList<>();
    if (routerDpnListData.isPresent()) {
        List<DpnVpninterfacesList> dpnVpninterfacesList = routerDpnListData.get().getDpnVpninterfacesList();
        for (DpnVpninterfacesList dpnVpnInterface : dpnVpninterfacesList) {
            dpns.add(dpnVpnInterface.getDpnId());
        }
    }
    return dpns;
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
@Inject
public QosAlertManager(final DataBroker dataBroker,
        final OpendaylightDirectStatisticsService odlDirectStatisticsService, final QosalertConfig defaultConfig,
        final QosNeutronUtils qosNeutronUtils, final QosEosHandler qosEosHandler,
        final INeutronVpnManager neutronVpnManager) {

    LOG.debug("{} created",  getClass().getSimpleName());
    this.dataBroker = dataBroker;
    this.odlDirectStatisticsService = odlDirectStatisticsService;
    this.defaultConfig = defaultConfig;
    this.qosNeutronUtils = qosNeutronUtils;
    this.qosEosHandler = qosEosHandler;
    this.neutronVpnManager = neutronVpnManager;
    LOG.debug("QosAlert default config poll alertEnabled:{} threshold:{} pollInterval:{}",
            defaultConfig.isQosAlertEnabled(), defaultConfig.getQosDropPacketThreshold(),
            defaultConfig.getQosAlertPollInterval());
    getDefaultConfig();
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入依赖的package包/类
public static ElanInstance createElanInstanceForTheFirstPodInTheNetwork(String networkNS, String nodeIp,
                                             org.opendaylight.yang.gen.v1.urn.opendaylight.coe.northbound.pod
                                                     .rev170611.pod_attributes.Interface podInterface,
                                             WriteTransaction wrtConfigTxn, DataBroker dataBroker) {
    String elanInstanceName = buildElanInstanceName(nodeIp, networkNS);
    InstanceIdentifier<ElanInstance> id = createElanInstanceIdentifier(elanInstanceName);
    Optional<ElanInstance> existingElanInstance = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
            id);
    if (existingElanInstance.isPresent()) {
        return existingElanInstance.get();
    }
    Class<? extends SegmentTypeBase> segmentType = getSegmentTypeFromNetwork(podInterface);
    String segmentationId = String.valueOf(podInterface.getSegmentationId());
    //FIXME String physicalNetworkName = ??
    // TODO external network support not added currently
    Boolean isExternal = false;
    ElanInstance elanInstance = CoeUtils.buildElanInstance(elanInstanceName, segmentType,
            segmentationId, isExternal);
    wrtConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, elanInstance);
    LOG.info("ELAN instance created for the first pod in the network {}", podInterface.getUid());
    return elanInstance;
}