private static final Logger LOG = LoggerFactory.getLogger(PolicyWriterUtil.class);
static boolean writeClassMaps(final Set<ClassMap> classMapEntries, final NodeId nodeId, final DataBroker mountpoint) {
+ boolean result = true;
if (classMapEntries == null || classMapEntries.isEmpty()) {
return true;
}
for (ClassMap entry : classMapEntries) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier<ClassMap> classMapIid = classMapInstanceIdentifier(entry);
- writeMergeTransaction(writeTransaction, classMapIid, entry);
+ netconfWrite(mountpoint, classMapIid, entry);
// Check
- final java.util.Optional<ReadOnlyTransaction> optionalTransaction =
- NetconfTransactionCreator.netconfReadOnlyTransaction(mountpoint);
- if (!optionalTransaction.isPresent()) {
- LOG.warn("Failed to create read-only transaction, mountpoint: {}", mountpoint);
- return false;
+ final java.util.Optional<ClassMap> checkCreated = java.util.Optional.ofNullable(netconfRead(mountpoint, classMapIid));
+ if (checkCreated.isPresent()) {
+ LOG.trace("Created class-map {} on node {}", entry.getName(), nodeId.getValue());
}
- final ReadOnlyTransaction readTransaction = optionalTransaction.get();
- if (checkWritten(readTransaction, classMapIid) == null) {
- return false;
+ else {
+ LOG.warn("Failed to create class-map {} on node {}", entry.getName(), nodeId.getValue());
+ result = false;
}
- LOG.trace("Created class-map {} on node {}", entry.getName(), nodeId.getValue());
}
- return true;
+ return result;
}
static boolean removeClassMaps(final Set<ClassMap> classMapEntries, final NodeId nodeId, final DataBroker mountpoint) {
return true;
}
for (ClassMap entry : classMapEntries) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier<ClassMap> classMapIid = classMapInstanceIdentifier(entry);
- deleteTransaction(writeTransaction, classMapIid);
+ netconfDeleteIfPresent(mountpoint, classMapIid);
// Check
- final java.util.Optional<ReadOnlyTransaction> optionalReadTransaction =
- NetconfTransactionCreator.netconfReadOnlyTransaction(mountpoint);
- if (!optionalReadTransaction.isPresent()) {
- LOG.warn("Failed to create read-only transaction, mountpoint: {}", mountpoint);
- return false;
+ final java.util.Optional<ClassMap> checkCreated = java.util.Optional.ofNullable(netconfRead(mountpoint, classMapIid));
+ if (checkCreated.isPresent()) {
+ LOG.warn("Failed to remove class-map {} on node {}", entry.getName(), nodeId.getValue());
+ result = false;
+ }
+ else {
+ LOG.trace("Class-map {} removed from node {}", entry.getName(), nodeId.getValue());
}
- final ReadOnlyTransaction readTransaction = optionalReadTransaction.get();
- result = checkRemoved(readTransaction, classMapIid);
- LOG.trace("Class-map {} removed from node {}", entry.getName(), nodeId.getValue());
}
return result;
}
static boolean writePolicyMap(final String policyMapName, final Set<Class> policyMapEntries, NodeId nodeId,
final DataBroker mountpoint) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final PolicyMap policyMap = PolicyManagerUtil.createPolicyMap(policyMapName, policyMapEntries);
final InstanceIdentifier<PolicyMap> policyMapIid = policyMapInstanceIdentifier(policyMapName);
- writeMergeTransaction(writeTransaction, policyMapIid, policyMap);
+ netconfWrite(mountpoint, policyMapIid, policyMap);
// Check
- final java.util.Optional<ReadOnlyTransaction> optionalReadTransaction =
- NetconfTransactionCreator.netconfReadOnlyTransaction(mountpoint);
- if (!optionalReadTransaction.isPresent()) {
- LOG.warn("Failed to create read-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final ReadOnlyTransaction readTransaction = optionalReadTransaction.get();
- if (checkWritten(readTransaction, policyMapIid) == null) {
+ if (netconfRead(mountpoint, policyMapIid) == null) {
+ LOG.warn("Failed to create policy-map {} on node {}", policyMap.getName(), nodeId.getValue());
return false;
}
LOG.trace("Created policy-map {} on node {}", policyMap.getName(), nodeId.getValue());
if (policyMapEntries == null || policyMapEntries.isEmpty()) {
return true;
}
+ boolean result = true;
for (Class entry : policyMapEntries) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier policyMapEntryIid = policyMapEntryInstanceIdentifier(policyMapName, entry.getName());
- if (deleteTransaction(writeTransaction, policyMapEntryIid)) {
- LOG.trace("Policy map entry {} removed from node {}", entry.getName(), nodeId.getValue());
+ if (netconfDeleteIfPresent(mountpoint, policyMapEntryIid)) {
+ LOG.trace("Policy-map entry {} removed from node {}", entry.getName(), nodeId.getValue());
+ }
+ else {
+ LOG.warn("Failed to remove policy-map entry {} from node {}", entry.getName(), nodeId.getValue());
+ result = false;
}
}
- return true;
+ return result;
}
static boolean writeInterface(final String policyMapName, final String interfaceName, final NodeId nodeId,
final DataBroker mountpoint) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final ServicePolicy servicePolicy = PolicyManagerUtil.createServicePolicy(policyMapName, Direction.Input);
final InstanceIdentifier<ServicePolicy> servicePolicyIid = interfaceInstanceIdentifier(interfaceName);
- writeMergeTransaction(writeTransaction, servicePolicyIid, servicePolicy);
- LOG.trace("Service-policy interface {}, bound to policy-map {} created on node {}",
- interfaceName, policyMapName, nodeId.getValue());
- return true;
+ if (netconfWrite(mountpoint, servicePolicyIid, servicePolicy)) {
+ LOG.trace("Service-policy interface {}, bound to policy-map {} created on node {}",
+ interfaceName, policyMapName, nodeId.getValue());
+ return true;
+ }
+ else {
+ LOG.warn("Failed to write service-policy interface {} to policy-map {} on node {}",
+ interfaceName, policyMapName, nodeId.getValue());
+ return false;
+ }
}
static boolean writeRemote(final Set<ServiceFfName> remoteForwarders, final NodeId nodeId,
if (remoteForwarders == null || remoteForwarders.isEmpty()) {
return true;
}
+ boolean result = true;
for (ServiceFfName forwarder : remoteForwarders) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier<ServiceFfName> forwarderIid = remoteSffInstanceIdentifier(forwarder);
- writeMergeTransaction(writeTransaction, forwarderIid, forwarder);
- LOG.trace("Remote forwarder {} created on node {}", forwarder.getName(), nodeId.getValue());
+ if (netconfWrite(mountpoint, forwarderIid, forwarder)) {
+ LOG.trace("Remote forwarder {} created on node {}", forwarder.getName(), nodeId.getValue());
+ }
+ else {
+ LOG.warn("Failed to create remote forwarder {} on node {}", forwarder.getName(), nodeId.getValue());
+ result = false;
+ }
}
- return true;
+ return result;
}
static boolean removeRemote(final Set<ServiceFfName> remoteForwarders, final NodeId nodeId,
if (remoteForwarders == null || remoteForwarders.isEmpty()) {
return true;
}
+ boolean result = true;
for (ServiceFfName forwarder : remoteForwarders) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier<ServiceFfName> forwarderIid = remoteSffInstanceIdentifier(forwarder);
- deleteTransaction(writeTransaction, forwarderIid);
- LOG.trace("Remote forwarder {} removed from node {}", forwarder.getName(), nodeId.getValue());
+ if (netconfDeleteIfPresent(mountpoint, forwarderIid)) {
+ LOG.trace("Remote forwarder {} removed from node {}", forwarder.getName(), nodeId.getValue());
+ }
+ else {
+ LOG.warn("Failed to remove forwarder {} from node {}", forwarder.getName(), nodeId.getValue());
+ result = false;
+ }
}
- return true;
+ return result;
}
static boolean writeServicePaths(final Set<ServiceChain> serviceChains, final NodeId nodeId,
final DataBroker mountpoint) {
+ boolean result = true;
for (org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChain serviceChain : serviceChains) {
for (ServicePath entry : serviceChain.getServicePath()) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier<ServicePath> servicePathIid = servicePathInstanceIdentifier(entry.getKey());
- writeMergeTransaction(writeTransaction, servicePathIid, entry);
- LOG.trace("Service path with ID: {} created on node {}", entry.getServicePathId(), nodeId.getValue());
+ if (netconfWrite(mountpoint, servicePathIid, entry)) {
+ LOG.trace("Service-path with ID: {} created on node {}", entry.getServicePathId(), nodeId.getValue());
+ }
+ else {
+ LOG.warn("Failed to create service-path with ID: {} on node {}", entry.getServicePathId(), nodeId.getValue());
+ result = false;
+ }
}
}
- return true;
+ return result;
}
static boolean removeServicePaths(final Set<ServiceChain> serviceChains, final NodeId nodeId,
if (serviceChains == null || serviceChains.isEmpty()) {
return true;
}
+ boolean result = true;
for (ServiceChain chain : serviceChains) {
List<ServicePath> servicePaths = chain.getServicePath();
if (servicePaths == null || servicePaths.isEmpty()) {
continue;
}
for (ServicePath servicePath : servicePaths) {
- final java.util.Optional<WriteTransaction> optionalWriteTransaction =
- NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
- if (!optionalWriteTransaction.isPresent()) {
- LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
- return false;
- }
- final WriteTransaction writeTransaction = optionalWriteTransaction.get();
final InstanceIdentifier<ServicePath> servicePathIid = servicePathInstanceIdentifier(servicePath.getKey());
- if (deleteTransaction(writeTransaction, servicePathIid)) {
+ if (netconfDeleteIfPresent(mountpoint, servicePathIid)) {
LOG.trace("Service-path with ID: {} removed from node {}", servicePath.getServicePathId(),
nodeId.getValue());
}
+ else {
+ LOG.warn("Failed to remove service-path with ID: {} from node {}", servicePath.getServicePathId(),
+ nodeId.getValue());
+ result = false;
+ }
}
}
- return true;
+ return result;
}
private static InstanceIdentifier<ClassMap> classMapInstanceIdentifier(final ClassMap classMap) {
.child(ServicePath.class, key).build();
}
- private static <U extends DataObject> void writeMergeTransaction(final WriteTransaction transaction,
- final InstanceIdentifier<U> addIID,
- final U data) {
+ private static <U extends DataObject> boolean netconfWrite(final DataBroker mountpoint,
+ final InstanceIdentifier<U> addIID,
+ final U data) {
+ final java.util.Optional<WriteTransaction> optionalWriteTransaction =
+ NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
+ if (!optionalWriteTransaction.isPresent()) {
+ LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
+ return false;
+ }
+ final WriteTransaction transaction = optionalWriteTransaction.get();
try {
transaction.merge(LogicalDatastoreType.CONFIGURATION, addIID, data);
final CheckedFuture<Void, TransactionCommitFailedException> submitFuture = transaction.submit();
submitFuture.checkedGet();
+ return true;
} catch (TransactionCommitFailedException e) {
LOG.error("Write transaction failed to {}", e.getMessage());
} catch (Exception e) {
LOG.error("Failed to .. {}", e.getMessage());
}
+ return false;
}
- private static <U extends DataObject> boolean deleteTransaction(final WriteTransaction transaction,
- final InstanceIdentifier<U> addIID) {
+ private static <U extends DataObject> boolean netconfDeleteIfPresent(final DataBroker mountpoint,
+ final InstanceIdentifier<U> deleteIID) {
+ if (netconfRead(mountpoint, deleteIID) == null) {
+ LOG.trace("Remove action called on non-existing element, skipping. Iid was: {}, data provider: {} ",
+ deleteIID, mountpoint);
+ return true;
+ }
+ final java.util.Optional<WriteTransaction> optionalWriteTransaction =
+ NetconfTransactionCreator.netconfWriteOnlyTransaction(mountpoint);
+ if (!optionalWriteTransaction.isPresent()) {
+ LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
+ return false;
+ }
+ final WriteTransaction transaction = optionalWriteTransaction.get();
try {
- transaction.delete(LogicalDatastoreType.CONFIGURATION, addIID);
+ transaction.delete(LogicalDatastoreType.CONFIGURATION, deleteIID);
final CheckedFuture<Void, TransactionCommitFailedException> submitFuture = transaction.submit();
submitFuture.checkedGet();
return true;
} catch (TransactionCommitFailedException e) {
LOG.error("Write transaction failed to {}", e.getMessage());
- return false;
} catch (Exception e) {
LOG.error("Failed to .. {}", e.getMessage());
- return false;
}
+ return false;
}
- private static <U extends DataObject> U checkWritten(final ReadOnlyTransaction transaction,
- final InstanceIdentifier<U> readIID) {
- for (int attempt = 1; attempt <= 5; attempt++) {
- try {
- final CheckedFuture<Optional<U>, ReadFailedException> submitFuture =
- transaction.read(LogicalDatastoreType.CONFIGURATION, readIID);
- final Optional<U> optional = submitFuture.checkedGet();
- if (optional != null && optional.isPresent()) {
- transaction.close(); // Release lock
- return optional.get();
- } else {
- // Could take some time until specific configuration appears on device, try to read a few times
- Thread.sleep(2000L);
- }
- } catch (InterruptedException i) {
- LOG.error("Thread interrupted while waiting ... {} ", i);
- } catch (ReadFailedException e) {
- LOG.warn("Read transaction failed to {} ", e);
- } catch (Exception e) {
- LOG.error("Failed to .. {}", e.getMessage());
- }
+ private static <U extends DataObject> U netconfRead(final DataBroker mountpoint,
+ final InstanceIdentifier<U> readIID) {
+ final java.util.Optional<ReadOnlyTransaction> optionalReadTransaction =
+ NetconfTransactionCreator.netconfReadOnlyTransaction(mountpoint);
+ if (!optionalReadTransaction.isPresent()) {
+ LOG.warn("Failed to create write-only transaction, mountpoint: {}", mountpoint);
+ return null;
}
- return null;
- }
-
- private static <U extends DataObject> boolean checkRemoved(final ReadOnlyTransaction transaction,
- final InstanceIdentifier<U> readIID) {
- for (int attempt = 1; attempt <= 5; attempt++) {
- try {
- final CheckedFuture<Optional<U>, ReadFailedException> submitFuture =
- transaction.read(LogicalDatastoreType.CONFIGURATION, readIID);
- final Optional<U> optional = submitFuture.checkedGet();
- if (optional != null && optional.isPresent()) {
- // Could take some time until specific configuration is removed from the device
- Thread.sleep(2000L);
- } else {
- transaction.close(); // Release lock
- return true;
- }
- } catch (InterruptedException i) {
- LOG.error("Thread interrupted while waiting ... {} ", i);
- } catch (ReadFailedException e) {
- LOG.warn("Read transaction failed to {} ", e);
- } catch (Exception e) {
- LOG.error("Failed to .. {}", e.getMessage());
+ final ReadOnlyTransaction transaction = optionalReadTransaction.get();
+ try {
+ final CheckedFuture<Optional<U>, ReadFailedException> submitFuture =
+ transaction.read(LogicalDatastoreType.CONFIGURATION, readIID);
+ final Optional<U> optional = submitFuture.checkedGet();
+ if (optional != null && optional.isPresent()) {
+ transaction.close(); // Release lock
+ return optional.get();
}
+ } catch (ReadFailedException e) {
+ LOG.warn("Read transaction failed to {} ", e);
+ } catch (Exception e) {
+ LOG.error("Failed to .. {}", e.getMessage());
}
- return false;
- }
+ return null;
+ }
}
package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.writer;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
-import java.util.List;
import java.util.Set;
-
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.Class;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.ClassBuilder;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.ServicePathBuilder;
-import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.Local;
-import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.LocalBuilder;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfName;
import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
Assert.assertTrue(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
- PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(null);
Assert.assertFalse(PolicyWriterUtil.writeClassMaps(classMapEntries, NODE_ID, dataBroker));
}
LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
classMapEntries.add(new ClassMapBuilder().setName("unit-classMapEntry-name").build());
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
+ PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction"))
+ .toReturn(java.util.Optional.empty());
Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
LOG.debug("scenario: succeed with one entry, available writeOnlyTransaction, available readOnlyTransaction");
PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfReadOnlyTransaction")).toReturn(rTxOptional);
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(null);
Mockito.when(rTx.read(Mockito.eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<ClassMap>>any()))
.thenReturn(Futures.immediateCheckedFuture(Optional.absent()));
Assert.assertTrue(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
- PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkRemoved")).toReturn(false);
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
Assert.assertFalse(PolicyWriterUtil.removeClassMaps(classMapEntries, NODE_ID, dataBroker));
}
Assert.assertTrue(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->null");
- PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "checkWritten")).toReturn(null);
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(null);
Assert.assertFalse(PolicyWriterUtil.writePolicyMap(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
}
LOG.debug("scenario: fail with one entry, no writeOnlyTransaction");
classEntries.add(new ClassBuilder().setName(new ClassNameType("unit-classMapEntry-name")).build());
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
Assert.assertFalse(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, no readOnlyTransaction");
PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
-
- //TODO: fix - failed remove transacion shall render whole operation as failed
- LOG.debug("scenario: fail with one entry, available writeOnlyTransaction, available readOnlyTransaction, check->false");
- PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "deleteTransaction")).toReturn(false);
- Assert.assertTrue(PolicyWriterUtil.removePolicyMapEntries(POLICY_MAP_NAME, classEntries, NODE_ID, dataBroker));
}
@Test
final String interfaceName = "unit-interface-1";
Assert.assertFalse(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
- LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
+ LOG.debug("scenario: fail - available writeOnlyTransaction, no submit future");
PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
- Assert.assertTrue(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
+ Assert.assertFalse(PolicyWriterUtil.writeInterface(POLICY_MAP_NAME, interfaceName, NODE_ID, dataBroker));
LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
final Set<ServiceFfName> remotes = Collections.singleton(new ServiceFfNameBuilder().build());
Assert.assertFalse(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
- LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
+ LOG.debug("scenario: fail - available writeOnlyTransaction, no submit future");
PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
- Assert.assertTrue(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
+ Assert.assertFalse(PolicyWriterUtil.writeRemote(remotes, NODE_ID, dataBroker));
LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
.build());
Assert.assertFalse(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
- LOG.debug("scenario: succeed - available writeOnlyTransaction, no submit future");
+ LOG.debug("scenario: fail - available writeOnlyTransaction, no submit future");
PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
- Assert.assertTrue(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
+ Assert.assertFalse(PolicyWriterUtil.writeServicePaths(serviceChains, NODE_ID, dataBroker));
LOG.debug("scenario: succeed - available writeOnlyTransaction, available future");
Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
Assert.assertTrue(PolicyWriterUtil.removeServicePaths(Collections.emptySet(), NODE_ID, dataBroker));
LOG.debug("scenario: fail with service path present, no writeOnlyTransaction");
+ PowerMockito.stub(PowerMockito.method(PolicyWriterUtil.class, "netconfRead")).toReturn(new ClassBuilder().build());
final Set<ServiceChain> serviceChains = Collections.singleton(new ServiceChainBuilder()
.setServicePath(Collections.singletonList(new ServicePathBuilder()
.setServicePathId(42L)
LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, no submit future");
PowerMockito.stub(PowerMockito.method(NetconfTransactionCreator.class, "netconfWriteOnlyTransaction")).toReturn(wTxOptional);
- Assert.assertTrue(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
+ Assert.assertFalse(PolicyWriterUtil.removeServicePaths(serviceChains, NODE_ID, dataBroker));
LOG.debug("scenario: fail with service path present, available writeOnlyTransaction, available future");
Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
Code Review / groupbasedpolicy.git / commitdiff