Java DataBroker.newWriteOnlyTransaction方法代码示例

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包/类
/**
 * Remove from MDSAL all those VrfEntries in a VPN that have an specific RouteOrigin.
 *
 * @param broker dataBroker service reference
 * @param rd Route Distinguisher
 * @param origin Origin of the Routes to be removed (see {@link RouteOrigin})
 */
public static void removeVrfEntriesByOrigin(DataBroker broker, String rd, RouteOrigin origin) {
    InstanceIdentifier<VrfTables> vpnVrfTableIid =
        InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
    Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
    if (vrfTablesOpc.isPresent()) {
        VrfTables vrfTables = vrfTablesOpc.get();
        WriteTransaction tx = broker.newWriteOnlyTransaction();
        for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
            if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
                tx.delete(LogicalDatastoreType.CONFIGURATION,
                        vpnVrfTableIid.child(VrfEntry.class, vrfEntry.getKey()));
            }
        }
        tx.submit();
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
public void populateL3Vpns(DataBroker broker, List<L3VpnComposite> vpns)
    throws TransactionCommitFailedException {
    for (L3VpnComposite vpn : vpns) {
        VpnInstance vpnInstance = new VpnInstanceBuilder().setVpnId(vpn.vpnOpData.getVpnId())
            .setVpnInstanceName(vpn.vpnOpData.getVpnInstanceName())
            .setVrfId(vpn.vpnOpData.getVrfId())
            .build();
        WriteTransaction writeTx1 = broker.newWriteOnlyTransaction();
        writeTx1.merge(LogicalDatastoreType.CONFIGURATION,
                      VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpn.vpnCfgData.getVpnInstanceName()),
                      vpnInstance, true);
        writeTx1.submit().checkedGet();
        WriteTransaction writeTx2 = broker.newWriteOnlyTransaction();
        writeTx2.merge(LogicalDatastoreType.OPERATIONAL,
                      VpnUtil.getVpnInstanceOpDataIdentifier(vpn.vpnOpData.getVrfId()), vpn.vpnOpData, true);
        writeTx2.submit().checkedGet();
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
public static void populateIvpnLinks(DataBroker broker2, List<InterVpnLinkDataComposite> ivpnLinks)
    throws TransactionCommitFailedException {

    for (InterVpnLinkDataComposite ivpnLink : ivpnLinks) {
        WriteTransaction writeTx1 = broker2.newWriteOnlyTransaction();
        writeTx1.merge(LogicalDatastoreType.CONFIGURATION,
                      InterVpnLinkUtil.getInterVpnLinkPath(ivpnLink.getInterVpnLinkName()),
                      ivpnLink.getInterVpnLinkConfig());
        writeTx1.submit().checkedGet();
        WriteTransaction writeTx2 = broker2.newWriteOnlyTransaction();
        writeTx2.merge(LogicalDatastoreType.OPERATIONAL,
                       InterVpnLinkUtil.getInterVpnLinkStateIid(ivpnLink.getInterVpnLinkName()),
                       ivpnLink.getInterVpnLinkState());
        writeTx2.submit().checkedGet();
    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
public static void cleanIvpnLinks(DataBroker broker2, InterVpnLinkDataComposite... ivpnLinks)
    throws TransactionCommitFailedException {

    for (InterVpnLinkDataComposite ivpnLink : ivpnLinks) {
        WriteTransaction writeTx1 = broker2.newWriteOnlyTransaction();
        writeTx1.delete(LogicalDatastoreType.OPERATIONAL,
                        InterVpnLinkUtil.getInterVpnLinkStateIid(ivpnLink.getInterVpnLinkName()));
        writeTx1.submit().checkedGet();

        WriteTransaction writeTx2 = broker2.newWriteOnlyTransaction();
        writeTx2.delete(LogicalDatastoreType.CONFIGURATION,
                        InterVpnLinkUtil.getInterVpnLinkPath(ivpnLink.getInterVpnLinkName()));
        writeTx2.submit().checkedGet();

    }
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
private void initializeDataTree(DataBroker db) {
    LOG.info("Preparing to initialize the greeting registry");
    WriteTransaction transaction = db.newWriteOnlyTransaction();
    InstanceIdentifier<GreetingRegistry> iid = InstanceIdentifier.create(GreetingRegistry.class);
    GreetingRegistry greetingRegistry = new GreetingRegistryBuilder()
            .build();
    transaction.put(LogicalDatastoreType.OPERATIONAL, iid, greetingRegistry);
    CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
    Futures.addCallback(future, new LoggingFuturesCallBack<>("Failed to create greeting registry", LOG));
}
 

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

    DataBroker dataBroker = testContext.getDataBroker();
    WriteTransaction fooTx = dataBroker.newWriteOnlyTransaction();
    WriteTransaction barTx = dataBroker.newWriteOnlyTransaction();

    fooTx.put(LogicalDatastoreType.OPERATIONAL, FOO_PATH, new TopLevelListBuilder().setKey(FOO_KEY).build());
    barTx.put(LogicalDatastoreType.OPERATIONAL, BAR_PATH, new TopLevelListBuilder().setKey(BAR_KEY).build());

    fooTx.submit().get(5, TimeUnit.SECONDS);
    barTx.submit().get(5, TimeUnit.SECONDS);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
@Test
public void testWriteByReplace() 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 cwuTx = dataBroker.newWriteOnlyTransaction();
    cwuTx.put(LogicalDatastoreType.OPERATIONAL, NODE_0_CWU_PATH, CWU, true);
    cwuTx.submit().get(5, TimeUnit.SECONDS);

    assertFalse(eventFuture.isDone());

    final WriteTransaction lvuTx = dataBroker.newWriteOnlyTransaction();

    TreeComplexUsesAugment tcua = new TreeComplexUsesAugmentBuilder()
            .setListViaUses(Collections.singletonList(LVU)).build();

    lvuTx.put(LogicalDatastoreType.OPERATIONAL, NODE_0_TCU_PATH, tcua, true);
    lvuTx.put(LogicalDatastoreType.OPERATIONAL, NODE_1_LVU_PATH, LVU, true);
    lvuTx.submit().get(5, TimeUnit.SECONDS);

    validateEvent(eventFuture.get(1000, TimeUnit.MILLISECONDS));
}
 

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

    DataBroker dataBroker = testContext.getDataBroker();

    // We wrote initial state NODE_0_FLOW
    final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
    transaction.put(LogicalDatastoreType.OPERATIONAL, NODE_0_LVU_PATH, LVU, true);
    transaction.submit().get(5, TimeUnit.SECONDS);

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

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

    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event = eventFuture.get(1000, TimeUnit.MILLISECONDS);
    assertNotNull(event);
    // Data change should contains NODE_1 Flow - which was added
    assertTrue(event.getCreatedData().containsKey(NODE_1_LVU_PATH));
    // Data change must not containe NODE_0 Flow which was replaced with same value.
    assertFalse(event.getUpdatedData().containsKey(NODE_0_LVU_PATH));
}
 

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

    final SettableFuture<AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject>> event = SettableFuture.create();
    DataBroker dataBroker = testContext.getDataBroker();
    ListenerRegistration<org.opendaylight.controller.md.sal.binding.api.DataChangeListener> dclRegistration =
            dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, AUGMENT_WILDCARDED_PATH,
                change -> event.set(change), DataChangeScope.SUBTREE);

    final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();

    TopLevelList tll = new TopLevelListBuilder() //
            .setKey(TLL_KEY) //
            .addAugmentation(TreeComplexUsesAugment.class, treeComplexUsesAugment("one")).build();
    transaction.put(LogicalDatastoreType.OPERATIONAL, TLL_INSTANCE_ID_BA, tll, true);
    transaction.submit().get(5, TimeUnit.SECONDS);

    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> receivedEvent = event.get(1000, TimeUnit.MILLISECONDS);
    assertTrue(receivedEvent.getCreatedData().containsKey(AUGMENT_TLL_PATH));

    dclRegistration.close();

    final WriteTransaction transaction2 = dataBroker.newWriteOnlyTransaction();
    transaction2.put(LogicalDatastoreType.OPERATIONAL, AUGMENT_TLL_PATH, treeComplexUsesAugment("two"));
    transaction2.submit().get(5, TimeUnit.SECONDS);

    TreeComplexUsesAugment readedAug = dataBroker.newReadOnlyTransaction().read(
            LogicalDatastoreType.OPERATIONAL, AUGMENT_TLL_PATH).checkedGet(5, TimeUnit.SECONDS).get();
    assertEquals("two", readedAug.getContainerWithUses().getLeafFromGrouping());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
/**
 * The scenario tests writing parent node, which also contains child items
 * and then reading child directly, by specifying path to the child.
 * Expected behaviour is child is returned.
 */
@Test
public void writeParentReadChild() throws Exception {

    DataBroker dataBroker = testContext.getDataBroker();
    final WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();

    List11 list11 = new List11Builder() //
            .setKey(LIST11_KEY) //
            .setAttrStr("primary")
            .build();

    List1 list1 = new List1Builder().setKey(LIST1_KEY).setList11(ImmutableList.of(list11)).build();

    transaction.put(LogicalDatastoreType.OPERATIONAL, LIST1_INSTANCE_ID_BA, list1, true);
    transaction.submit().get(5, TimeUnit.SECONDS);

    Optional<List1> readList1 = dataBroker.newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
            LIST1_INSTANCE_ID_BA).checkedGet(1000, TimeUnit.MILLISECONDS);
    assertTrue(readList1.isPresent());

    Optional<? extends DataObject> readList11 = dataBroker.newReadOnlyTransaction().read(
            LogicalDatastoreType.OPERATIONAL, LIST11_INSTANCE_ID_BA).checkedGet(5, TimeUnit.SECONDS);
    assertNotNull("Readed flow should not be null.",readList11);
    assertTrue(readList11.isPresent());
    assertEquals(list11, readList11.get());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
private static <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
                                                      InstanceIdentifier<T> path, T data, DataBroker broker,
                                                      FutureCallback<Void> callback) {
    WriteTransaction tx = broker.newWriteOnlyTransaction();
    tx.put(datastoreType, path, data, WriteTransaction.CREATE_MISSING_PARENTS);
    Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
public static void installRouterGwFlows(DataBroker dataBroker, IVpnManager vpnManager, Routers router,
        BigInteger primarySwitchId, int addOrRemove) {
    WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
    List<ExternalIps> externalIps = router.getExternalIps();
    List<String> externalIpsSting = new ArrayList<>();

    if (externalIps.isEmpty()) {
        LOG.error("installRouterGwFlows: setupRouterGwFlows no externalIP present");
        return;
    }
    for (ExternalIps externalIp : externalIps) {
        externalIpsSting.add(externalIp.getIpAddress());
    }
    Uuid subnetVpnName = externalIps.get(0).getSubnetId();
    if (addOrRemove == NwConstants.ADD_FLOW) {
        vpnManager.addRouterGwMacFlow(router.getRouterName(), router.getExtGwMacAddress(), primarySwitchId,
                router.getNetworkId(), subnetVpnName.getValue(), writeTx);
        vpnManager.addArpResponderFlowsToExternalNetworkIps(router.getRouterName(), externalIpsSting,
                router.getExtGwMacAddress(), primarySwitchId,
                router.getNetworkId(), writeTx);
    } else {
        vpnManager.removeRouterGwMacFlow(router.getRouterName(), router.getExtGwMacAddress(), primarySwitchId,
                router.getNetworkId(), subnetVpnName.getValue(), writeTx);
        vpnManager.removeArpResponderFlowsToExternalNetworkIps(router.getRouterName(), externalIpsSting,
                router.getExtGwMacAddress(), primarySwitchId,
                router.getNetworkId(), writeTx);
    }
    writeTx.submit();
}
 

import org.opendaylight.controller.md.sal.binding.api.DataBroker; //导入方法依赖的package包/类
public static void removeVrfEntries(DataBroker broker, String rd, List<VrfEntry> vrfEntries) {
    InstanceIdentifier<VrfTables> vpnVrfTableIid =
        InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
    WriteTransaction tx = broker.newWriteOnlyTransaction();
    for (VrfEntry vrfEntry : vrfEntries) {
        tx.delete(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid.child(VrfEntry.class, vrfEntry.getKey()));
    }
    tx.submit();
}