@Override public <T extends DataObject> CheckedFuture<Optional<T>, ReadFailedException> read(final LogicalDatastoreType store, final InstanceIdentifier<T> path) { return delegate.read(store, path); }
@Override public void delete(final LogicalDatastoreType store, final InstanceIdentifier<?> path) { delegate.delete(store, path); } }
@Override public void putOperationalData(final InstanceIdentifier<? extends DataObject> path, final DataObject data) { final boolean previouslyRemoved = posponedRemovedOperational.remove(path); @SuppressWarnings({ "rawtypes", "unchecked" }) final InstanceIdentifier<DataObject> castedPath = (InstanceIdentifier) path; if(previouslyRemoved) { delegate.put(LogicalDatastoreType.OPERATIONAL, castedPath, data,true); } else { delegate.merge(LogicalDatastoreType.OPERATIONAL, castedPath, data,true); } }
private void initializeTopology(LogicalDatastoreType type) { ReadWriteTransaction transaction = db.newReadWriteTransaction(); InstanceIdentifier<NetworkTopology> path = InstanceIdentifier.create(NetworkTopology.class); CheckedFuture<Optional<NetworkTopology>, ReadFailedException> topology = transaction.read(type,path); try { if (!topology.get().isPresent()) { NetworkTopologyBuilder ntb = new NetworkTopologyBuilder(); transaction.put(type,path,ntb.build()); transaction.submit(); } else { transaction.cancel(); } } catch (InterruptedException | ExecutionException e) { LOG.error("Error initializing ovsdb topology", e); } }
@Override public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path, final T data, final boolean createMissingParents) { delegate.put(store, path, data, createMissingParents); }
private void unlock(final String lockName, final InstanceIdentifier<Lock> lockInstanceIdentifier) { ReadWriteTransaction tx = broker.newReadWriteTransaction(); Optional<Lock> result = Optional.absent(); try { result = tx.read(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier).get(); if (!result.isPresent()) { LOG.info("{} is already unlocked", lockName); return; } tx.delete(LogicalDatastoreType.OPERATIONAL, lockInstanceIdentifier); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); futures.get(); } catch (Exception e) { LOG.error("In unlock unable to unlock due to {}", e.getMessage()); } }
@Override public ListenableFuture<Void> apply(Optional<InterfaceMonitorEntry> optEntry) throws Exception { if(optEntry.isPresent()) { InterfaceMonitorEntry entry = optEntry.get(); List<Long> monitorIds = entry.getMonitorIds(); monitorIds.remove(monitorId); InterfaceMonitorEntry newEntry = new InterfaceMonitorEntryBuilder(entry) .setKey(new InterfaceMonitorEntryKey(interfaceName)).setMonitorIds(monitorIds).build(); tx.put(LogicalDatastoreType.OPERATIONAL, getInterfaceMonitorMapId(interfaceName), newEntry, CREATE_MISSING_PARENT); return tx.submit(); } else { LOG.warn("No Interface map entry found {} to remove monitorId {}", interfaceName, monitorId); tx.cancel(); return Futures.immediateFuture(null); } } });
@Override public ListenableFuture<Void> apply(List<Void> readyToSubmit) { return rwTx.submit(); } });
@Override public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path, final T data) { delegate.merge(store, path, data); }
@Override public ListenableFuture<Void> apply(final Optional<StreamRecord> streamRulesRecord) throws Exception { List<StreamList> streamRulesLists = new ArrayList<StreamList>(); if (streamRulesRecord.isPresent()) { streamRulesLists = streamRulesRecord.get().getStreamList(); } Iterator<StreamList> iterator = streamRulesLists.iterator(); while (iterator.hasNext()) { StreamList configObject = iterator.next(); if (configObject.getConfigID().equalsIgnoreCase(confID)) { tx.delete(LogicalDatastoreType.CONFIGURATION, streamRecordId.child(StreamList.class, configObject.getKey())); } } return tx.submit(); } });
@Override public ListenableFuture<Void> apply(Optional<MonitoringState> optState) throws Exception { if(optState.isPresent()) { MonitoringState state = optState.get(); if(isValidStatus.apply(state.getStatus())) { MonitoringState updatedState = new MonitoringStateBuilder().setMonitorKey(monitorKey) .setStatus(newStatus).build(); tx.merge(LogicalDatastoreType.OPERATIONAL, getMonitorStateId(monitorKey), updatedState); } else { LOG.warn("Invalid Monitoring status {}, cannot be updated to {} for monitorId {}" , state.getStatus(), newStatus, monitorId); } } else { LOG.warn("No associated monitoring state data available to update the status to {} for {}", newStatus, monitorId); } return tx.submit(); } });
@Override public void applyOperation(final ReadWriteTransaction transaction) { Optional<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node> nodeOptional = Optional.absent(); try { nodeOptional = transaction.read(LogicalDatastoreType.OPERATIONAL, node).checkedGet(); } catch (ReadFailedException e) { LOG.warn("Error occured when trying to read NodeConnector: {}", e.getMessage()); LOG.debug("Error occured when trying to read NodeConnector.. ", e); } if (nodeOptional.isPresent()) { TopologyManagerUtil.removeAffectedLinks(terminationPointId, transaction, II_TO_TOPOLOGY); transaction.delete(LogicalDatastoreType.OPERATIONAL, iiToTopologyTerminationPoint); } } });
public void updateDeviceState(final boolean up, final Set<QName> capabilities) { final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node data = buildDataForDeviceState( up, capabilities, id); final ReadWriteTransaction transaction = txChain.newReadWriteTransaction(); logger.trace("{}: Update device state transaction {} merging operational data started.", id, transaction.getIdentifier()); transaction.put(LogicalDatastoreType.OPERATIONAL, id.getBindingPath(), data); logger.trace("{}: Update device state transaction {} merging operational data ended.", id, transaction.getIdentifier()); commitTransaction(transaction, "update"); }
@Override public void close() { readWriteTransaction.cancel(); } }
private void initializeTZNode(DataBroker db) { ReadWriteTransaction transaction = db.newReadWriteTransaction(); InstanceIdentifier<TransportZones> path = InstanceIdentifier.create(TransportZones.class); CheckedFuture<Optional<TransportZones>, ReadFailedException> tzones = transaction.read(LogicalDatastoreType.CONFIGURATION,path); try { if (!tzones.get().isPresent()) { TransportZonesBuilder tzb = new TransportZonesBuilder(); transaction.put(LogicalDatastoreType.CONFIGURATION,path,tzb.build()); transaction.submit(); } else { transaction.cancel(); } } catch (Exception e) { LOG.error("Error initializing TransportZones {}",e); } }
@Override public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path, final T data) { delegate.put(store, path, data); }
public CheckedFuture<Void, TransactionCommitFailedException> submit() { return readWriteTransaction.submit(); }
@Override public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path, final T data, final boolean createMissingParents) { delegate.merge(store, path, data, createMissingParents); }
@Override public ListenableFuture<Void> apply( final Optional<AlertFieldValueRuleRecord> alertFieldValueRuleRecord) throws Exception { List<StreamAlertFieldValueRuleList> streamAlertRuleList = new ArrayList<StreamAlertFieldValueRuleList>(); if (alertFieldValueRuleRecord.isPresent()) { streamAlertRuleList = alertFieldValueRuleRecord.get().getStreamAlertFieldValueRuleList(); StreamAlertFieldValueRuleList configObject = null; Iterator<StreamAlertFieldValueRuleList> iterator = streamAlertRuleList.iterator(); while (iterator.hasNext()) { configObject = iterator.next(); if (configObject.getConfigID().equalsIgnoreCase(configID)) { tx.delete(LogicalDatastoreType.CONFIGURATION, alertFieldValueRuleRecordId.child( StreamAlertFieldValueRuleList.class, configObject.getKey())); } } } return tx.submit(); }