@Override public void close() throws Exception { // When we close this service we need to shutdown our executor! executor.shutdown(); if (dataProvider != null) { WriteTransaction tx = dataProvider.newWriteOnlyTransaction(); LOG.info(" Transaction written"); tx.delete(LogicalDatastoreType.CONFIGURATION, alertMessageCountRuleRecordId); } }
@Override public List<ListenableFuture<Void>> call() throws Exception { List<ListenableFuture<Void>> futures = new ArrayList<>() ; logger.debug("Invoking Tunnel Monitor Worker tzone = {} enabled {}",tzone,enabled ); WriteTransaction t = dataBroker.newWriteOnlyTransaction(); toggleTunnelMonitoring(hwVteps,enabled,tzone,t,exists); futures.add(t.submit()); return futures; }
@Override public void merge(LogicalDatastoreType type, InstanceIdentifier<DataObject> id, DataObject data, FutureCallback<Object> callback) { if (dataProvider == null) { LOG.error("Data Service is not initialized!"); return; } writeTransaction = dataProvider.newWriteOnlyTransaction(); writeTransaction.merge(type, id, data); Futures.addCallback(writeTransaction.submit(), callback); }
public static List<ListenableFuture<Void>> deleteHwVtepsTunnels(DataBroker dataBroker, IdManagerService idManagerService, List<DPNTEPsInfo> delDpnList, List<HwVtep> cfgdHwVteps, TransportZone originalTZone) { List<ListenableFuture<Void>> futures = new ArrayList<>(); WriteTransaction t = dataBroker.newWriteOnlyTransaction(); if (delDpnList != null || cfgdHwVteps != null) tunnelsDeletion(delDpnList, cfgdHwVteps, originalTZone, idManagerService, futures, t, dataBroker); futures.add(t.submit()); return futures; }
protected boolean addMd(S neutronObject) { try { final WriteTransaction tx = getDataBroker().newWriteOnlyTransaction(); addMd(neutronObject, tx); return true; } catch (InterruptedException | ExecutionException e) { LOGGER.warn("Transaction failed", e); } return false; }
private <T extends DataObject> void syncDelete(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) { WriteTransaction tx = dataBroker.newWriteOnlyTransaction(); tx.delete(datastoreType, path); CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit(); try { futures.get(); } catch (InterruptedException | ExecutionException e) { LOG.error("Error deleting from datastore (path) : ({})", path); throw new RuntimeException(e.getMessage()); } }
public static <T extends DataObject> void syncWrite(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(); 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 syncWrite(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(); try { futures.get(); } catch (InterruptedException | ExecutionException e) { LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data); throw new RuntimeException(e.getMessage()); } }
protected void initializeConfigContext() throws Exception { m_contexts = new LinkedList<>(); WriteTransaction wx = dataBroker.newWriteOnlyTransaction(); m_contexts.add(ManualMapsUtils.createContext(wx)); wx.submit().get(); }
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 deactivated() { WriteTransaction transaction = dataBroker.newWriteOnlyTransaction(); transaction.delete(LogicalDatastoreType.OPERATIONAL, fcIid); try { transaction.submit().checkedGet(); LOG.debug("Forwarding construct activation state information deleted successfully"); } catch (TransactionCommitFailedException e) { LOG.warn("Error during forwarding construct activation state information deletion", e); } }
protected void createDefaultContext() throws InterruptedException, ExecutionException, TransactionCommitFailedException { WriteTransaction wx = m_dataBroker.newWriteOnlyTransaction(); ResourcepoolUtils.createContext(ResourcepoolUtils.DEFAULT_CONTEXT, wx); wx.submit().get(); }
protected void clearConfigContext() throws Exception { WriteTransaction wx = dataBroker.newWriteOnlyTransaction(); for (Uuid context : m_contexts) { ManualMapsUtils.deleteContext(context, wx); } wx.submit().get(); }
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 delData(String secKey) { LowwatermarkKey seclwmKey = new LowwatermarkKey(secKey); InstanceIdentifier<Lowwatermark> secLwmId = InstanceIdentifier.builder(LWM.class).child(Lowwatermark.class, seclwmKey).toInstance(); WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.delete(LogicalDatastoreType.OPERATIONAL, secLwmId); writeTransaction.commit(); LOG.debug("Data Store Entry is deleted for key ", secKey); }
@Override public void instructionRemoved() { final WriteTransaction t = ProgrammingServiceImpl.this.dataProvider.newWriteOnlyTransaction(); t.delete(LogicalDatastoreType.OPERATIONAL, ProgrammingServiceImpl.this.qid.child( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.programming.rev150720.instruction.queue.Instruction.class, new InstructionKey(this.builder.getId()))); t.submit(); } }
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(); }
public void removeVrf(int vrf) { WriteTransaction trans = databroker.newWriteOnlyTransaction(); String vrfId = createVrfId(vrf); InstanceIdentifier<Vrf> vrfIId = deviceIId.augmentation(FabricCapableDevice.class) .child(Config.class).child(Vrf.class, new VrfKey(vrfId)); trans.delete(LogicalDatastoreType.OPERATIONAL, vrfIId); MdSalUtils.wrapperSubmit(trans, executor); }
protected void createDefaultIrd() throws InterruptedException, ExecutionException { WriteTransaction wx = m_dataBroker.newWriteOnlyTransaction(); IrdInstanceConfigurationBuilder builder = new IrdInstanceConfigurationBuilder(); builder.setEntryContext(ResourcepoolUtils.getDefaultContextIID()) .setInstanceId(new ResourceId(SimpleIrdUtils.DEFAULT_IRD_RESOURCE)); InstanceIdentifier<IrdInstanceConfiguration> iicIID = SimpleIrdUtils.getInstanceConfigurationIID(new ResourceId(SimpleIrdUtils.DEFAULT_IRD_RESOURCE)); wx.put(LogicalDatastoreType.CONFIGURATION, iicIID, builder.build()); wx.submit().get(); LOG.info("Create default IRD context for SimpleIrd"); }
private static CheckedFuture<Void, TransactionCommitFailedException> initializeNetworkInstance(final DataBroker dataBroker, final InstanceIdentifier<NetworkInstance> networkInstance) { final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction(); wTx.merge(LogicalDatastoreType.CONFIGURATION, networkInstance, new NetworkInstanceBuilder().setName(networkInstance.firstKeyOf(NetworkInstance.class).getName()).setProtocols(new ProtocolsBuilder().build()).build()); return wTx.submit(); }