public static <T extends DataObject> CheckedFuture<Void, TransactionCommitFailedException> delete(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> obj) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.delete(datastoreType, obj); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); return futures; }
public void registerDataChangeListener() { final DataTreeIdentifier<T> configDataTreeIdentifier = new DataTreeIdentifier<>( LogicalDatastoreType.CONFIGURATION, path); final DataTreeIdentifier<T> operDataTreeIdentifier = new DataTreeIdentifier<>( LogicalDatastoreType.OPERATIONAL, path); configRegistration = broker.registerDataTreeChangeListener(configDataTreeIdentifier, this); operRegistration = broker.registerDataTreeChangeListener(operDataTreeIdentifier, this); }
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(); }
private ListenableFuture<Void> writeTableOffset(OfOverlayConfig ofc) { WriteTransaction wTx = dataBroker.newWriteOnlyTransaction(); wTx.merge(LogicalDatastoreType.CONFIGURATION, configIid, ofc, true); return wTx.submit(); }
@Override public <T extends DataObject> ListenableFuture<Void> writeConfiguration(final T data, final InstanceIdentifier<T> identifier) { final ReadWriteTransaction wTx = this.dataBroker.newReadWriteTransaction(); wTx.put(LogicalDatastoreType.CONFIGURATION, identifier, data); return wTx.submit(); }
@Override public ReadOnlyTransaction newReadOnlyTransaction() { return delegate().newReadOnlyTransaction(); }
<T extends DataObject> ListenableFuture<Optional<T>> readOperationalData(final InstanceIdentifier<T> id) { try (final ReadOnlyTransaction t = chain.newReadOnlyTransaction()) { return t.read(LogicalDatastoreType.OPERATIONAL, id); } }
@Override public <T extends DataObject, L extends DataTreeChangeListener<T>> ListenerRegistration<L> registerDataTreeChangeListener(DataTreeIdentifier<T> treeId, L listener) { return delegate().registerDataTreeChangeListener(treeId, listener); }
@Override public ReadWriteTransaction newReadWriteTransaction() { return delegate().newReadWriteTransaction(); }
static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.delete(datastoreType, path); tx.submit(); }
static <T extends DataObject> void update(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.merge(datastoreType, path, data, true); tx.submit(); }
public static <T extends DataObject> CheckedFuture<Void, TransactionCommitFailedException> write(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.put(datastoreType, path, data, true); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); return futures; }
/** * Registers this instance as OPERATIONAL datastore listener via provided dataBroker * @param dataBroker data broker * @return listener registration */ ListenerRegistration<OperationalDatastoreListener<T>> registerOnChanges(DataBroker dataBroker) { DataTreeIdentifier<T> id = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, instanceIdentifier); return dataBroker.registerDataTreeChangeListener(id, this); }
@Override public <T extends DataObject> ListenableFuture<Void> removeConfiguration( final InstanceIdentifier<T> identifier) { final WriteTransaction wTx = this.dataBroker.newWriteOnlyTransaction(); wTx.delete(LogicalDatastoreType.CONFIGURATION, identifier); return wTx.submit(); } }
public static <T extends DataObject> CheckedFuture<Void, TransactionCommitFailedException> update(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.merge(datastoreType, path, data, true); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); return futures; }
public TsdrTargetDescDataStoreChangeHandler(DataBroker dataBroker) { this.dataBroker = dataBroker; dcReg = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, TARGET_IID), this); }
static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.delete(datastoreType, path); tx.submit(); }
private <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) { WriteTransaction tx = broker.newWriteOnlyTransaction(); tx.merge(datastoreType, path, data, true); tx.submit(); }
public TsdrConfigDataStoreChangeHandler(DataBroker dataBroker) { this.dataBroker = dataBroker; dcReg = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, CONFIG_IID), this); }
public Onem2mDatastoreListener(DataBroker dataBroker) { this.dataBroker = dataBroker; dcReg = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, RESOURCE_IID), this); }