@Override public void close() { delegate.close(); } }
/** * Close this datastore transaction. */ @Override public void close() { ReadOnlyTransaction tx = transaction; transaction = null; if (tx != null) { tx.close(); } } }
/** * Close the MD-SAL DS transaction. */ @Override public void close() { if (localTx != null) { localTx.close(); } } }
@Override public void onFailure(final Throwable t) { rTx.close(); } };
@Override public void onFailure(final Throwable t) { LOG.error("Can not notify existing nodes", t); tx.close(); }
@Override public void onSuccess(@Nullable final Optional<?> result) { rTx.close(); }
@Override public void onFailure(Throwable t) { readOnlyTx.close(); // We may have gotten the app config via the data tree change listener so only retry if not. if(readingInitialAppConfig.get()) { LOG.warn("{}: Read of app config {} failed - retrying", logName(), bindingContext.appConfigBindingClass.getName(), t); readInitialAppConfig(dataBroker); } } });
/** * {@inheritDoc} */ @Override public void cancelTransaction() { ReadOnlyTransaction tx = transaction; if (tx != null) { transaction = null; readSpecific.clear(); tx.close(); } }
@Override public void onSuccess(Optional<DataObject> possibleAppConfig) { LOG.debug("{}: Read of app config {} succeeded: {}", logName(), bindingContext.appConfigBindingClass.getName(), possibleAppConfig); readOnlyTx.close(); setInitialAppConfig(possibleAppConfig); }
@VisibleForTesting L2FloodDomain readL2FloodDomain(L2FloodDomainId l2fId, TenantId tenantId) { ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); InstanceIdentifier<L2FloodDomain> iid = IidFactory.l2FloodDomainIid(tenantId, l2fId); Optional<L2FloodDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx); if (!l2Op.isPresent()) { LOG.error("Couldn't find L2 Flood Domain {} which belongs to Tenant {}", l2fId, tenantId); rTx.close(); return null; } return l2Op.get(); }
@VisibleForTesting L3Context readL3ContextInstance(TenantId tenantId, L3ContextId l3cId) { ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); InstanceIdentifier<L3Context> iid = IidFactory.l3ContextIid(tenantId, l3cId); Optional<L3Context> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx); if (!l2Op.isPresent()) { LOG.error("Couldn't find L3 Context Domain {} which belongs to Tenant {}", l3cId, tenantId); rTx.close(); return null; } return l2Op.get(); }
@VisibleForTesting L2BridgeDomain readL2BridgeDomainInstance(TenantId tenantId, L2BridgeDomainId l2bId) { ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); InstanceIdentifier<L2BridgeDomain> iid = IidFactory.l2BridgeDomainIid(tenantId, l2bId); Optional<L2BridgeDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx); if (!l2Op.isPresent()) { LOG.error("Couldn't find L2 Brdge Domain {} which belongs to Tenant {}", l2bId, tenantId); rTx.close(); return null; } return l2Op.get(); }
public EndpointGroup readEndpointGroup(EndpointGroupId epgId, TenantId tenantId) { ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); InstanceIdentifier<EndpointGroup> iid = IidFactory.endpointGroupIid(tenantId, epgId); Optional<EndpointGroup> epgOp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx); if (!epgOp.isPresent()) { LOG.warn("Couldn't find EPG {} which belongs to Tenant {}", epgId, tenantId); rTx.close(); return null; } return epgOp.get(); }
public Subnet readSubnet(SubnetId subnetId, TenantId tenantId) { ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction(); InstanceIdentifier<Subnet> iid = IidFactory.subnetIid(tenantId, subnetId); Optional<Subnet> subnetOp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx); if (!subnetOp.isPresent()) { LOG.warn("Couldn't find Subnet {} which belongs to Tenant {}", subnetId, tenantId); rTx.close(); return null; } return subnetOp.get(); }
private Optional<OfOverlayConfig> readConfig() { final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); Optional<OfOverlayConfig> config = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, configIid, rTx); rTx.close(); return config; }
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { ReadOnlyTransaction tx = broker.newReadOnlyTransaction(); Optional<T> result = Optional.absent(); try { result = tx.read(datastoreType, path).get(); } catch (InterruptedException | ExecutionException e) { LOG.warn("Error reading data from path {} in datastore {}", path, datastoreType, e); } finally { tx.close(); } return result; }
public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { ReadOnlyTransaction tx = broker.newReadOnlyTransaction(); Optional<T> result = Optional.absent(); try { result = tx.read(datastoreType, path).get(); } catch (Exception e) { throw new RuntimeException(e); } finally { tx.close(); } return result; }
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { ReadOnlyTransaction tx = dataService.newReadOnlyTransaction(); Optional<T> result = Optional.absent(); try { result = tx.read(datastoreType, path).get(); } catch (Exception e) { throw new RuntimeException(e); } tx.close(); return result; } }
private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { ReadOnlyTransaction tx = serviceProvider.getDataBroker().newReadOnlyTransaction(); Optional<T> result = Optional.absent(); try { result = tx.read(datastoreType, path).get(); } catch (Exception e) { throw new RuntimeException(e); } finally { tx.close(); } return result; }
public <T extends DataObject> Optional<T> read2(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) throws ReadFailedException { ReadOnlyTransaction tx = broker.newReadOnlyTransaction(); try { CheckedFuture<Optional<T>, ReadFailedException> checkedFuture = tx.read(datastoreType, path); return checkedFuture.checkedGet(); } finally { tx.close(); } }