@Override public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data, boolean createMissingParents) { delegate.put(store, path, data, createMissingParents); }
/** * Create/Write * @param addIID iid * @param data new data * @param logicalDatastoreType op vs config * @param <U> return value */ public <U extends org.opendaylight.yangtools.yang.binding.DataObject> void create // writePut (InstanceIdentifier<U> addIID, U data, LogicalDatastoreType logicalDatastoreType) { writeTx.put(logicalDatastoreType, addIID, data, true); }
private <U extends org.opendaylight.yangtools.yang.binding.DataObject> void writePutTransaction( InstanceIdentifier<U> addIID, U data, LogicalDatastoreType logicalDatastoreType, String errMsg) { WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); writeTx.put(logicalDatastoreType, addIID, data, true); Futures.addCallback(writeTx.submit(), new FutureCallback<Void>() { public void onSuccess(Void result) { } public void onFailure(Throwable throwable) { LOG.error("Transaction failed:", throwable); } }); }
static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.put(datastoreType, path, data, true); Futures.addCallback(tx.submit(), callback); }
private <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.put(datastoreType, path, data, true); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); try { futures.get(); } catch (InterruptedException | ExecutionException e) { LOG.error("Error writing VPN instance to ID info to datastore (path, data) : ({}, {})", path, data); throw new RuntimeException(e.getMessage()); } }
static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.put(datastoreType, path, data, true); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); try { futures.get(); } catch (InterruptedException | ExecutionException e) { LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data); throw new RuntimeException(e.getMessage()); } }
public static <T extends DataObject> void write(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.put(datastoreType, path, data, true); tx.submit(); }
@Override public void onSessionStarted(Session session) { final InstanceIdentifier<Session> sessionPath = SESSIONS_INSTANCE_IDENTIFIER.child(Session.class, session.getKey()); runTransaction((tx) -> tx.put(LogicalDatastoreType.OPERATIONAL, sessionPath, session)); }
private void addBaseEndpointMappings(AddressEndpointKey addrEpKey, UniqueId portId, WriteTransaction wTx) { BaseEndpointByPort baseEndpointByPort = MappingFactory.createBaseEndpointByPort(addrEpKey, portId); wTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.baseEndpointByPortIid(portId), baseEndpointByPort, true); PortByBaseEndpoint portByBaseEndpoint = MappingFactory.createPortByBaseEndpoint(portId, addrEpKey); wTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.portByBaseEndpointIid(new PortByBaseEndpointKey( portByBaseEndpoint.getKey())), portByBaseEndpoint, true); }
public void updateDeviceData(boolean up, NetconfDeviceCapabilities capabilities) { final Node data = buildDataForNetconfNode(up, capabilities); final WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); logger.trace("{}: Update device state transaction {} merging operational data started.", id, writeTx.getIdentifier()); writeTx.put(LogicalDatastoreType.OPERATIONAL, id.getTopologyBindingPath(), data); logger.trace("{}: Update device state transaction {} merging operational data ended.", id, writeTx.getIdentifier()); commitTransaction(writeTx, "update"); }
public static Uuid createContext(Uuid cid, final WriteTransaction wx) { ContextBuilder builder = new ContextBuilder(); builder.setContextId(cid); builder.setResource(new LinkedList<Resource>()); /* DO NOT submit because this might be just one step in a sequence of write operations */ wx.put(LogicalDatastoreType.OPERATIONAL, getContextIID(cid), builder.build()); return cid; }
private void persistStaleGroup(StaleGroup staleGroup, InstanceIdentifier<FlowCapableNode> nodeIdent){ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.put(LogicalDatastoreType.CONFIGURATION, getStaleGroupInstanceIdentifier(staleGroup, nodeIdent), staleGroup, false); CheckedFuture<Void, TransactionCommitFailedException> submitFuture = writeTransaction.submit(); handleStaleGroupResultFuture(submitFuture); }
public void setDeviceAsFailed(Throwable throwable) { String reason = (throwable != null && throwable.getMessage() != null) ? throwable.getMessage() : UNKNOWN_REASON; final NetconfNode netconfNode = new NetconfNodeBuilder().setConnectionStatus(ConnectionStatus.UnableToConnect).setConnectedMessage(reason).build(); final Node data = getNodeIdBuilder(id).addAugmentation(NetconfNode.class, netconfNode).build(); final WriteTransaction writeTx = txChain.newWriteOnlyTransaction(); logger.trace("{}: Setting device state as failed {} putting operational data started.", id, writeTx.getIdentifier()); writeTx.put(LogicalDatastoreType.OPERATIONAL, id.getTopologyBindingPath(), data); logger.trace("{}: Setting device state as failed {} putting operational data ended.", id, writeTx.getIdentifier()); commitTransaction(writeTx, "update-failed-device"); }
private static void writeConfiguration(final DataBroker dataBroker, final Topology topology) { final KeyedInstanceIdentifier<Topology, TopologyKey> topologyIId = InstanceIdentifier.create(NetworkTopology.class).child(Topology.class, topology.getKey()); final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction(); wTx.put(LogicalDatastoreType.CONFIGURATION, topologyIId, topology, true); wTx.submit(); }
@Deprecated private void addProviderPhysicalNetworkMapping(TenantId tenantId, L2FloodDomainId l2FdId, String segmentationId, WriteTransaction wTx) { org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.provider.physical.networks.as.l2.flood.domains.ProviderPhysicalNetworkAsL2FloodDomain provNetAsL2Fd = new org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.provider.physical.networks.as.l2.flood.domains.ProviderPhysicalNetworkAsL2FloodDomainBuilder().setTenantId( tenantId) .setL2FloodDomainId(new L2FloodDomainId(l2FdId.getValue())) .setSegmentationId(segmentationId) .build(); wTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.providerPhysicalNetworkAsL2FloodDomainIid(tenantId, l2FdId), provNetAsL2Fd); }
private void writeProviderNamedSelectorToEpg(SelectorName providerSelector, ContractId contractId, EpgKeyDto epgKey, WriteTransaction wTx) { ProviderNamedSelector providerNamedSelector = new ProviderNamedSelectorBuilder().setName(providerSelector) .setContract(ImmutableList.of(contractId)) .build(); wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.providerNamedSelectorIid(epgKey.getTenantId(), epgKey.getEpgId(), providerNamedSelector.getName()), providerNamedSelector, true); }
private void writeConsumerNamedSelectorToEpg(SelectorName consumerSelector, ContractId contractId, EpgKeyDto epgKey, WriteTransaction wTx) { ConsumerNamedSelector consumerNamedSelector = new ConsumerNamedSelectorBuilder().setName(consumerSelector) .setContract(ImmutableList.of(contractId)) .build(); wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.consumerNamedSelectorIid(epgKey.getTenantId(), epgKey.getEpgId(), consumerNamedSelector.getName()), consumerNamedSelector, true); }
private void putCount(final long count) { final WriteTransaction wTx = this.chain.newWriteOnlyTransaction(); Counter counter = new CounterBuilder().setId(this.counterId).setCount(count).build(); wTx.put(LogicalDatastoreType.OPERATIONAL, this.counterInstanceId, counter); wTx.submit(); }
private void addProviderPhysicalNetworkMapping(TenantId tenantId, ContextId ctxId, String segmentationId, WriteTransaction wTx) { ProviderPhysicalNetworkAsL2FloodDomain provNetAsL2Fd = new ProviderPhysicalNetworkAsL2FloodDomainBuilder().setTenantId( tenantId) .setL2FloodDomainId(ctxId) .setSegmentationId(segmentationId) .build(); wTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.providerPhysicalNetworkAsL2FloodDomainIid(tenantId, ctxId), provNetAsL2Fd); }
private boolean setSfcTableOffset(short tableidSfcIngress, short tableidSfcEgress) { SfcOfRendererConfig sfcOfRendererConfig = new SfcOfRendererConfigBuilder() .setSfcOfTableOffset(tableidSfcIngress).setSfcOfAppEgressTableOffset(tableidSfcEgress).build(); WriteTransaction wTx = dataBroker.newWriteOnlyTransaction(); wTx.put(LogicalDatastoreType.CONFIGURATION, SfcIidFactory.sfcOfRendererConfigIid(), sfcOfRendererConfig); return DataStoreHelper.submitToDs(wTx); }