}
public void close() {
- if(registration != null) {
+ if (registration != null) {
LOG.info("closing netconf tree listener");
registration.close();
}
}
private void onAddedNodes(@Nonnull Collection<Node> added) throws ReadFailedException {
- if(added.isEmpty()) return;
+ if (added.isEmpty()) return;
LOG.debug("found {} added XR nodes", added.size());
final ReadWriteTransaction topoTx = dataBroker.newReadWriteTransaction();
try {
KeyedInstanceIdentifier<Node, NodeKey> id = mountIds.get(key);
Optional<MountPoint> mountPoint = mountService.getMountPoint(id);
- if(mountPoint.isPresent()) {
+ if (mountPoint.isPresent()) {
DataBroker deviceBroker = mountPoint.get().getService(DataBroker.class).get();
LOG.debug(deviceBroker.toString());
List<OwnedNodeEdgePoint> tps;
private Stream<InterfaceConfiguration> ports(ReadOnlyTransaction tx) throws ReadFailedException {
Optional<InterfaceConfigurations> interfaces = tx.read(LogicalDatastoreType.OPERATIONAL, InterfaceHelper.getInterfaceConfigurationsId()).checkedGet();
- if(interfaces.isPresent()) {
+ if (interfaces.isPresent()) {
return interfaces.get().getInterfaceConfiguration().stream();
}
}
private static Optional<GNRPBwpFlow> convert(Optional<? extends GNRPBwpFlow> input) {
- if(input.isPresent()) {
+ if (input.isPresent()) {
return Optional.of(input.get());
}
.map(nadg -> nadg.collect(x -> x::getLpSpec))
.collect(Collectors.toList());
- for(NullAwareDatastoreGetter<LpSpec> lpSpecNadg : lpSpecNadgs) {
+ for (NullAwareDatastoreGetter<LpSpec> lpSpecNadg : lpSpecNadgs) {
NullAwareDatastoreGetter<AdapterSpec1> adapterSpecNadg = lpSpecNadg
.collect(x -> x::getAdapterSpec)
.collect(x -> x::getAugmentation, AdapterSpec1.class);
}
public boolean isQosEnabled() {
- for(BandwidthProfileComposition bandwidthProfileComposition : bandwidthProfiles) {
- if(bandwidthProfileComposition.hasAnyProfileDefined()) {
+ for (BandwidthProfileComposition bandwidthProfileComposition : bandwidthProfiles) {
+ if (bandwidthProfileComposition.hasAnyProfileDefined()) {
return true;
}
}
}
public BandwidthProfileHelper addPolicyMap(String fcName, BandwidthProfileComposition.BwpDirection direction, BandwidthProfileComposition.BwpApplicability applicability) {
- if(bandwidthProfiles.size() > 0) {
+ if (bandwidthProfiles.size() > 0) {
Optional<GNRPBwpFlow> bwProfileOptional = bandwidthProfiles.stream().findFirst().get().get(direction, applicability);
if (bwProfileOptional.isPresent()) {
public static InterfaceName getInterfaceName(ServicePort port) {
String interfaceName = port.getTp().getValue();
- if(interfaceName.contains(":")) {
+ if (interfaceName.contains(":")) {
interfaceName = interfaceName.split(":")[1];
}
.setActive(new InterfaceActive("act"))
.setShutdown(Boolean.FALSE);
- if(mtus.isPresent()) {
+ if (mtus.isPresent()) {
configurationBuilder.setMtus(mtus.get());
}
- if(setL2Transport) {
+ if (setL2Transport) {
setL2Configuration(configurationBuilder);
}
TopologyId topologyId = port.getTopology();
Optional<Node> nodeOpt = MdsalUtils.readOptional(dataBroker, LogicalDatastoreType.CONFIGURATION, getNodeIid(nodeId,topologyId));
- if(nodeOpt.isPresent()) {
+ if (nodeOpt.isPresent()) {
LoopbackAugmentation la = nodeOpt.get().getAugmentation(LoopbackAugmentation.class);
- if (la != null){
+ if (la != null) {
loopback = la.getLoopbackAddress().getIpv4Address().getValue();
}
}
return DEFAULT_LOOPBACK;
}
- public static InstanceIdentifier<Node> getNodeIid(NodeId nodeId, TopologyId topologyId){
+ public static InstanceIdentifier<Node> getNodeIid(NodeId nodeId, TopologyId topologyId) {
InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(NetworkTopology.class)
.child(Topology.class, new TopologyKey(topologyId))
.child(Node.class, new NodeKey(nodeId))
public static Mtus generateMtus(List<Long> mtuValues, CiscoIosXrString owner) {
List<Mtu> mtus = new LinkedList<>();
- for(Long mtuValue : mtuValues) {
+ for (Long mtuValue : mtuValues) {
mtus.add(generateMtu(mtuValue, owner));
}
String outerName = getOuterName(serviceId);
ServicePort port = null;
ServicePort neighbor = null;
- for(EndPoint endPoint: endPoints){
- if(port==null){
+ for (EndPoint endPoint: endPoints) {
+ if (port==null) {
port = ServicePort.toServicePort(endPoint, NETCONF_TOPOLODY_NAME);
} else {
neighbor = ServicePort.toServicePort(endPoint, NETCONF_TOPOLODY_NAME);
* @param serviceId old service id
* @return new service id
*/
- private String replaceForbidenCharacters(String serviceId){
+ private String replaceForbidenCharacters(String serviceId) {
return serviceId.replace(":","_");
}
}
private L2vpnLocalConnectActivator localActivator;
private L2vpnP2pConnectActivator p2pActivator;
- public XrDriverBuilder(DataBroker dataBroker, MountPointService mountPointService){
+ public XrDriverBuilder(DataBroker dataBroker, MountPointService mountPointService) {
this.dataBroker = dataBroker;
this.mountPointService = mountPointService;
}
return 0;
}
- private void handleEndpoints(BiConsumer<List<EndPoint>,AbstractL2vpnActivator> action){
+ private void handleEndpoints(BiConsumer<List<EndPoint>,AbstractL2vpnActivator> action) {
endPoints.forEach(endPoint -> connectWithAllNeighbors(action,endPoint,endPoints));
}
- private void connectWithAllNeighbors(BiConsumer<List<EndPoint>,AbstractL2vpnActivator> action, EndPoint endPoint, List<EndPoint> neighbors){
+ private void connectWithAllNeighbors(BiConsumer<List<EndPoint>,AbstractL2vpnActivator> action, EndPoint endPoint, List<EndPoint> neighbors) {
neighbors.stream()
.filter(neighbor -> !neighbor.equals(endPoint))
.forEach(neighbor -> activateNeighbors(action,endPoint,neighbor));
private void activateNeighbors(BiConsumer<List<EndPoint>,AbstractL2vpnActivator> action, EndPoint portA, EndPoint portZ) {
List<EndPoint> endPointsToActivate = Arrays.asList(portA,portZ);
- if(SipHandler.isTheSameDevice(portA.getEndpoint().getServiceInterfacePoint(),portZ.getEndpoint().getServiceInterfacePoint())){
- if(bridgeActivatedPairs==null){
+ if (SipHandler.isTheSameDevice(portA.getEndpoint().getServiceInterfacePoint(),portZ.getEndpoint().getServiceInterfacePoint())) {
+ if (bridgeActivatedPairs==null) {
bridgeActivatedPairs = new ArrayList<>();
}
- if(isPairActivated(portA,portZ)){
+ if (isPairActivated(portA,portZ)) {
return;
}
action.accept(endPointsToActivate, localActivator);
}
}
- private boolean isPairActivated(EndPoint a, EndPoint z){
+ private boolean isPairActivated(EndPoint a, EndPoint z) {
return bridgeActivatedPairs.stream()
.anyMatch( entry -> {
- if( (entry.getKey().equals(a) && entry.getValue().equals(z))
- || (entry.getKey().equals(z) && entry.getValue().equals(a))){
+ if ( (entry.getKey().equals(a) && entry.getValue().equals(z))
+ || (entry.getKey().equals(z) && entry.getValue().equals(a))) {
return true;
}
return false;
when(adapterSpec1.getNrpConnAdaptSpecAttrs()).thenReturn(connAdaptSpecAttrs);
when(adapterSpec1.getNrpEvcEndpointConnAdaptSpecAttrs()).thenReturn(evcAttrs);
- if(ingressDefaultBwp.isPresent()) {
+ if (ingressDefaultBwp.isPresent()) {
when(connAdaptSpecAttrs.getIngressBwpFlow()).thenReturn(ingressDefaultBwp.get());
}
- if(egressDefaultBwp.isPresent()) {
+ if (egressDefaultBwp.isPresent()) {
when(connAdaptSpecAttrs.getEgressBwpFlow()).thenReturn(egressDefaultBwp.get());
}
- if(ingressEvcBwp.isPresent()) {
+ if (ingressEvcBwp.isPresent()) {
when(evcAttrs.getIngressBwpFlow()).thenReturn(ingressEvcBwp.get());
}
- if(egressEvcBwp.isPresent()) {
+ if (egressEvcBwp.isPresent()) {
when(evcAttrs.getEgressBwpFlow()).thenReturn(egressEvcBwp.get());
}
when(terminationSpec.getAugmentation(TerminationSpec1.class)).thenReturn(terminationSpec1);
when(terminationSpec1.getNrpUniTerminationAttrs()).thenReturn(nrpUniTerminationAttrs);
- if(ingressUniBwp.isPresent()) {
+ if (ingressUniBwp.isPresent()) {
when(nrpUniTerminationAttrs.getIngressBwpUni()).thenReturn(ingressUniBwp.get());
}
- if(egressUniBwp.isPresent()) {
+ if (egressUniBwp.isPresent()) {
when(nrpUniTerminationAttrs.getEgressBwpUni()).thenReturn(egressUniBwp.get());
}
private static String portNumber = "8080";
@Before
- public void setUp(){
+ public void setUp() {
broker = getDataBroker();
}
@After
- public void clean(){
+ public void clean() {
deleteNode(LoopbackUtils.getNodeIid(new NodeId(nodeName),new TopologyId(topoName)));
}
@Test
- public void testLoopbackAddress(){
+ public void testLoopbackAddress() {
//given
ServicePort port = L2vpnTestUtils.port(topoName, nodeName, portNumber);
createAndPersistNode(true);
}
@Test
- public void testAbsenceOfLoopbackAddress(){
+ public void testAbsenceOfLoopbackAddress() {
//given
ServicePort port = L2vpnTestUtils.port(topoName, nodeName, portNumber);
createAndPersistNode(false);
assertEquals(LoopbackUtils.getDefaultLoopback(),ipv4AddressNoZone.getValue());
}
- private void createAndPersistNode(boolean ifLoopbackAddress){
+ private void createAndPersistNode(boolean ifLoopbackAddress) {
NodeId nodeId = new NodeId(nodeName);
Node node = createNode(nodeId,ifLoopbackAddress);
InstanceIdentifier<Node> nodeIid = writeNode(node);
}
- private Node createNode(NodeId nodeId,boolean ifLoopbackAddress){
+ private Node createNode(NodeId nodeId,boolean ifLoopbackAddress) {
NodeBuilder nodeBuilder = new NodeBuilder();
NodeId nodeIdTopo = new NodeId(topoName);
nodeBuilder.setNodeId(nodeId);
- if(ifLoopbackAddress){
+ if (ifLoopbackAddress) {
Ipv4Address ipv4Address = new Ipv4Address(loopbackAddress);
IpAddress ipAddress = new IpAddress(ipv4Address);
LoopbackAugmentationBuilder loopbackAugmentationBuilder = new LoopbackAugmentationBuilder();
return nodeBuilder.build();
}
- private InstanceIdentifier<Node> writeNode(Node node){
+ private InstanceIdentifier<Node> writeNode(Node node) {
InstanceIdentifier<Node> nodeInstanceId = LoopbackUtils.getNodeIid(node.getNodeId(),new TopologyId(topoName));
WriteTransaction transaction = broker.newWriteOnlyTransaction();
return null;
}
- private void deleteNode(InstanceIdentifier<Node> nodeIid){
+ private void deleteNode(InstanceIdentifier<Node> nodeIid) {
WriteTransaction transaction = broker.newWriteOnlyTransaction();
transaction.delete(LogicalDatastoreType.CONFIGURATION, nodeIid);
try {
private String serviceId = "serviceId";
@Before
- public void setUp(){
+ public void setUp() {
//given
DataBroker broker = getDataBroker();
optBroker = Optional.of(broker);
}
@Test
- public void testActivateAndDeactivate(){
+ public void testActivateAndDeactivate() {
//when
activate();
L2vpnTestUtils.checkDeactivated(optBroker,portNo1);
}
- private void deactivate(){
+ private void deactivate() {
try {
l2VpnLocalConnectActivator.deactivate(endPoints,serviceId);
} catch (TransactionCommitFailedException e) {
}
}
- private void activate(){
+ private void activate() {
LOG.debug("activate L2VPN");
try {
l2VpnLocalConnectActivator.activate(endPoints,serviceId);
}
private void checkL2vpnTree(CheckedFuture<Optional<L2vpn>, ReadFailedException> driverL2vpn) throws InterruptedException, ExecutionException {
- if (driverL2vpn.get().isPresent()){
+ if (driverL2vpn.get().isPresent()) {
L2vpn l2vpn = driverL2vpn.get().get();
L2vpnTestUtils.checkL2vpn(l2vpn);
}
private void checkInterfaceConfigurationTree(CheckedFuture<Optional<InterfaceConfigurations>, ReadFailedException> driverInterfaceConfigurations) throws InterruptedException, ExecutionException{
- if (driverInterfaceConfigurations.get().isPresent()){
+ if (driverInterfaceConfigurations.get().isPresent()) {
InterfaceConfigurations interfaceConfigurations = driverInterfaceConfigurations.get().get();
L2vpnTestUtils.checkInterfaceConfigurations(interfaceConfigurations);
private List<EndPoint> endPoints;
@Before
- public void setUp(){
+ public void setUp() {
//given
DataBroker broker = getDataBroker();
optBroker = Optional.of(broker);
}
@Test
- public void testActivateAndDeactivate(){
+ public void testActivateAndDeactivate() {
//when
try {
l2VpnP2PConnectActivator.activate(endPoints,serviceId);
L2vpnTestUtils.checkDeactivated(optBroker,portNo1);
}
- private void deactivate(){
+ private void deactivate() {
//when
try {
l2VpnP2PConnectActivator.deactivate(endPoints,serviceId);
}
private void checkL2vpnTree(CheckedFuture<Optional<L2vpn>, ReadFailedException> driverL2vpn) throws InterruptedException, ExecutionException{
- if (driverL2vpn.get().isPresent()){
+ if (driverL2vpn.get().isPresent()) {
L2vpn l2vpn = driverL2vpn.get().get();
L2vpnTestUtils.checkL2vpn(l2vpn);
}
private void checkInterfaceConfigurationTree(CheckedFuture<Optional<InterfaceConfigurations>, ReadFailedException> driverInterfaceConfigurations) throws InterruptedException, ExecutionException{
- if (driverInterfaceConfigurations.get().isPresent()){
+ if (driverInterfaceConfigurations.get().isPresent()) {
InterfaceConfigurations interfaceConfigurations = driverInterfaceConfigurations.get().get();
L2vpnTestUtils.checkInterfaceConfigurations(interfaceConfigurations);
*/
public class L2vpnTestUtils {
- public static MountPointService getMockedMountPointService(Optional<DataBroker> optBroker){
+ public static MountPointService getMockedMountPointService(Optional<DataBroker> optBroker) {
PowerMockito.mockStatic(MountPointHelper.class);
PowerMockito.when(MountPointHelper.getDataBroker(Mockito.anyObject(),Mockito.anyString())).thenReturn(optBroker);
return Mockito.mock(MountPointService.class);
}
- public static void checkL2vpn(L2vpn l2vpn){
+ public static void checkL2vpn(L2vpn l2vpn) {
assertNotNull(l2vpn);
assertNotNull(l2vpn.getDatabase());
assertNotNull(l2vpn.getDatabase().getXconnectGroups());
}
- public static void checkXConnectGroup(XconnectGroup xconnectGroup, String outerName){
+ public static void checkXConnectGroup(XconnectGroup xconnectGroup, String outerName) {
assertNotNull(xconnectGroup);
assertEquals(outerName,xconnectGroup.getName().getValue());
assertNotNull(xconnectGroup.getP2pXconnects());
assertNotNull(xconnectGroup.getP2pXconnects().getP2pXconnect());
}
- public static void checkP2pXconnect(P2pXconnect p2pXconnect, String innerName){
+ public static void checkP2pXconnect(P2pXconnect p2pXconnect, String innerName) {
assertNotNull(p2pXconnect);
assertEquals(innerName,p2pXconnect.getName().getValue());
assertNotNull(p2pXconnect.getAttachmentCircuits());
assertNotNull(p2pXconnect.getPseudowires().getPseudowire());
}
- public static void checkAttachmentCircuit(AttachmentCircuit attachmentCircuit, String port){
+ public static void checkAttachmentCircuit(AttachmentCircuit attachmentCircuit, String port) {
assertTrue(attachmentCircuit.isEnable());
assertEquals(port,attachmentCircuit.getName().getValue());
}
- public static void checkPseudowire(Pseudowire pseudowire){
+ public static void checkPseudowire(Pseudowire pseudowire) {
assertNotNull(pseudowire);
assertNotNull(pseudowire.getPseudowireId());
assertNotNull(pseudowire.getNeighbor());
assertNotNull(pseudowire.getNeighbor().get(0));
}
- public static void checkNeighbor(Neighbor neighbor){
+ public static void checkNeighbor(Neighbor neighbor) {
assertNotNull(neighbor);
assertNotNull(neighbor.getXmlClass());
assertNotNull(neighbor.getNeighbor());
assertNotNull(neighbor.getMplsStaticLabels());
}
- public static void checkMplsStaticLabels(MplsStaticLabels mplsStaticLabels){
+ public static void checkMplsStaticLabels(MplsStaticLabels mplsStaticLabels) {
assertNotNull(mplsStaticLabels);
assertNotNull(mplsStaticLabels.getLocalStaticLabel());
assertNotNull(mplsStaticLabels.getRemoteStaticLabel());
}
- public static void checkInterfaceConfigurations(InterfaceConfigurations interfaceConfigurations){
+ public static void checkInterfaceConfigurations(InterfaceConfigurations interfaceConfigurations) {
assertNotNull(interfaceConfigurations);
assertNotNull(interfaceConfigurations.getInterfaceConfiguration());
}
- public static void checkInterfaceConfiguration(InterfaceConfiguration interfaceConfiguration, String portNo, boolean mtu){
+ public static void checkInterfaceConfiguration(InterfaceConfiguration interfaceConfiguration, String portNo, boolean mtu) {
assertNotNull(interfaceConfiguration);
assertNotNull(interfaceConfiguration.getActive());
assertNotNull(interfaceConfiguration.getInterfaceModeNonPhysical());
assertEquals(portNo,interfaceConfiguration.getInterfaceName().getValue());
assertTrue(interfaceConfiguration.isShutdown());
- if(mtu){
+ if (mtu) {
assertNotNull(interfaceConfiguration.getMtus());
assertNotNull(interfaceConfiguration.getMtus().getMtu());
}
}
- public static void checkMtu(Mtu mtu, Long mtuValue){
+ public static void checkMtu(Mtu mtu, Long mtuValue) {
assertEquals(mtuValue,mtu.getMtu());
assertNotNull(mtu.getOwner());
}
}
private static void checkL2vpnDeactivation(CheckedFuture<Optional<L2vpn>, ReadFailedException>driverL2vpn) throws ExecutionException, InterruptedException {
- if (driverL2vpn.get().isPresent()){
+ if (driverL2vpn.get().isPresent()) {
L2vpn l2vpn = driverL2vpn.get().get();
L2vpnTestUtils.checkL2vpn(l2vpn);
}
private static void checkInterfaceConfigurationDeactivation(CheckedFuture<Optional<InterfaceConfigurations>, ReadFailedException> driverInterfaceConfigurations, String deactivatedPort) throws InterruptedException, ExecutionException{
- if (driverInterfaceConfigurations.get().isPresent()){
+ if (driverInterfaceConfigurations.get().isPresent()) {
InterfaceConfigurations interfaceConfigurations = driverInterfaceConfigurations.get().get();
L2vpnTestUtils.checkInterfaceConfigurations(interfaceConfigurations);
}
}
- public static List<EndPoint> mockEndpoints(String device1Name, String device2Name, String portNo1, String portNo2){
+ public static List<EndPoint> mockEndpoints(String device1Name, String device2Name, String portNo1, String portNo2) {
List<EndPoint> endPoints = new ArrayList<>();
endPoints.add(mockEndPoint("sip:"+device1Name+":"+portNo1));
endPoints.add(mockEndPoint("sip:"+device2Name+":"+portNo2));
return endPoints;
}
- private static EndPoint mockEndPoint(String portName){
+ private static EndPoint mockEndPoint(String portName) {
ConnectivityServiceEndPoint connectivityServiceEndPoint = mock(ConnectivityServiceEndPoint.class);
NrpConnectivityServiceEndPointAttrs attrs = mock(NrpConnectivityServiceEndPointAttrs.class);
//UNI port mock
}
public void setListUnis(int amount, String ipAddress) {
- for(int i=0; i<amount; i++){
+ for (int i=0; i<amount; i++) {
final UniAugmentation uniAug = mock(UniAugmentation.class);
final IpAddress ipAddr = mock(IpAddress.class);
final Ipv4Address ip4 = mock(Ipv4Address.class);
}
private void verifyTx() {
- if(tx == null) throw new IllegalStateException("Top perform write operation read write transaction is needed");
+ if (tx == null) throw new IllegalStateException("Top perform write operation read write transaction is needed");
}
/**
InstanceIdentifier<OwnedNodeEdgePoint> nepIdent = node(nodeId).child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(new Uuid(nepId)));
try {
Optional<OwnedNodeEdgePoint> opt = tx.read(LogicalDatastoreType.OPERATIONAL, nepIdent).checkedGet();
- if(opt.isPresent()) {
+ if (opt.isPresent()) {
tx.delete(LogicalDatastoreType.OPERATIONAL,nepIdent);
- if(removeSips){
+ if (removeSips) {
List<Uuid> sips = opt.get().getMappedServiceInterfacePoint();
removeSips(sips == null ? null : sips.stream());
}
public void removeSips(Stream<Uuid> uuids) {
verifyTx();
- if(uuids == null) return ;
+ if (uuids == null) return ;
uuids.forEach(sip -> {
LOG.debug("removing ServiceInterfacePoint with id {}", sip);
tx.delete(LogicalDatastoreType.OPERATIONAL, ctx().child(ServiceInterfacePoint.class, new ServiceInterfacePointKey(sip)));
public void removeNode(String nodeId, boolean removeSips) {
verifyTx();
- if(removeSips) {
+ if (removeSips) {
try {
Optional<Node> opt = tx.read(LogicalDatastoreType.OPERATIONAL, node(nodeId)).checkedGet();
- if(opt.isPresent()) {
+ if (opt.isPresent()) {
removeSips(opt.get().getOwnedNodeEdgePoint().stream().flatMap(nep -> nep.getMappedServiceInterfacePoint() == null ?
Stream.empty() : nep.getMappedServiceInterfacePoint().stream()
));
tx.delete(LogicalDatastoreType.OPERATIONAL, node(nodeId));
}
- public void updateAbstractNep(OwnedNodeEdgePoint nep){
+ public void updateAbstractNep(OwnedNodeEdgePoint nep) {
verifyTx();
InstanceIdentifier<OwnedNodeEdgePoint> nodeIdent = abstractNode().child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nep.getUuid()));
tx.merge(LogicalDatastoreType.OPERATIONAL, nodeIdent, nep);
}
- public void deleteAbstractNep(OwnedNodeEdgePoint nep){
+ public void deleteAbstractNep(OwnedNodeEdgePoint nep) {
verifyTx();
InstanceIdentifier<OwnedNodeEdgePoint> nodeIdent = abstractNode().child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nep.getUuid()));
tx.delete(LogicalDatastoreType.OPERATIONAL, nodeIdent);
* Created by marek.ryznar@amartus.com.
*/
public class ResourceNotAvailableException extends ResourceActivatorException {
- public ResourceNotAvailableException(){
+ public ResourceNotAvailableException() {
super();
}
- public ResourceNotAvailableException(String message){
+ public ResourceNotAvailableException(String message) {
super(message);
}
}
//defines cTag VLAN ID
private Long vlanId=null;
- public ServicePort(TopologyId topoId, NodeId nodeId, TpId tpId){
+ public ServicePort(TopologyId topoId, NodeId nodeId, TpId tpId) {
this.topoId = topoId;
this.nodeId = nodeId;
this.tpId = tpId;
this.vlanId = vlanId;
}
- public static ServicePort toServicePort(EndPoint endPoint, String topologyName){
+ public static ServicePort toServicePort(EndPoint endPoint, String topologyName) {
Uuid sip = endPoint.getEndpoint().getServiceInterfacePoint();
TopologyId topologyId = new TopologyId(topologyName);
NodeId nodeId = new NodeId(SipHandler.getDeviceName(sip));
TpId tpId = new TpId(SipHandler.getPortName(sip));
ServicePort servicePort = new ServicePort(topologyId,nodeId,tpId);
- if(hasVlan(endPoint)){
+ if (hasVlan(endPoint)) {
servicePort.setVlanId(Long.valueOf(getVlan(endPoint)));
}
return servicePort;
}
- public static boolean hasVlan(EndPoint endPoint){
- if( (endPoint.getAttrs() != null)
+ public static boolean hasVlan(EndPoint endPoint) {
+ if ( (endPoint.getAttrs() != null)
&& (endPoint.getAttrs().getNrpCarrierEthConnectivityEndPointResource() != null) ) {
NrpCarrierEthConnectivityEndPointResource attr =
endPoint.getAttrs().getNrpCarrierEthConnectivityEndPointResource();
if ( (attr.getCeVlanIdListAndUntag() != null)
- && !(attr.getCeVlanIdListAndUntag().getVlanId().isEmpty()) ){
+ && !(attr.getCeVlanIdListAndUntag().getVlanId().isEmpty()) ) {
return true;
} else {
return false;
}
}
- private static int getVlan(EndPoint endPoint){
+ private static int getVlan(EndPoint endPoint) {
return endPoint.getAttrs().getNrpCarrierEthConnectivityEndPointResource()
.getCeVlanIdListAndUntag().getVlanId().get(0).getVlanId().getValue().intValue();
}
- public String getInterfaceName(){
+ public String getInterfaceName() {
TpId tpId = this.getTp();
Matcher matcher = interface_name_pattern.matcher(tpId.getValue());
return matcher.find() ? matcher.group() : default_interface_name;
private final DataBroker dataBroker;
- public AbstractNodeHandler(DataBroker dataBroker){
+ public AbstractNodeHandler(DataBroker dataBroker) {
Objects.requireNonNull(dataBroker);
this.dataBroker = dataBroker;
}
- public void init(){
+ public void init() {
registration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, NRP_TOPOLOGY_SYSTEM_IID), this);
}
- public void close(){
- if (registration!=null){
+ public void close() {
+ if (registration!=null) {
registration.close();
}
}
OwnedNodeEdgePoint b = (OwnedNodeEdgePoint) dataObjectModificationNep.getDataBefore();
OwnedNodeEdgePoint a = (OwnedNodeEdgePoint) dataObjectModificationNep.getDataAfter();
- if(b != null) {
- if(a == null) return true;
- if(hasSip(b)) {
+ if (b != null) {
+ if (a == null) return true;
+ if (hasSip(b)) {
return ! hasSip(a);
}
}
return false;
}
- private boolean checkIfUpdated(DataObjectModification dataObjectModificationNep){
+ private boolean checkIfUpdated(DataObjectModification dataObjectModificationNep) {
OwnedNodeEdgePoint before = (OwnedNodeEdgePoint) dataObjectModificationNep.getDataBefore();
OwnedNodeEdgePoint after = (OwnedNodeEdgePoint) dataObjectModificationNep.getDataAfter();
- if(after == null) return false;
+ if (after == null) return false;
//added
- if(before == null) {
+ if (before == null) {
return hasSip(after);
}
//updated
* @return result
*/
public Result activate() {
- if(drivers.isEmpty()) throw new IllegalStateException("at least one driver required");
+ if (drivers.isEmpty()) throw new IllegalStateException("at least one driver required");
sortDrivers();
try {
for (ActivationDriver d: drivers) {
* @return result
*/
public Result deactivate() {
- if(drivers.isEmpty()) throw new IllegalStateException("at least one driver required");
+ if (drivers.isEmpty()) throw new IllegalStateException("at least one driver required");
sortDrivers();
try {
for (ActivationDriver d: drivers) {
return message;
}
- public static Result success(){
+ public static Result success() {
return new Result(true, Optional.empty(), Optional.empty());
}
- public static Result fail(String message, Throwable cause){
+ public static Result fail(String message, Throwable cause) {
return new Result(false, Optional.of(message), Optional.of(cause));
}
}
Optional<? extends DataObject> context = result.checkedGet();
- if(! context.isPresent()) {
+ if (! context.isPresent()) {
LOG.info("initialize Presto NRP context");
Context ctx = new ContextBuilder()
.setUuid(new Uuid(PRESTO_CTX))
ConnectivityService cs =
nrpDao.getConnectivityService(serviceId);
- if(cs == null) {
+ if (cs == null) {
return RpcResultBuilder
.<DeleteConnectivityServiceOutput>failed()
.withError(RpcError.ErrorType.APPLICATION, MessageFormat.format("Service {0} does not exist", input.getServiceIdOrName()))
Uuid nodeId = c.getContainerNode();
return c.getConnectionEndPoint().stream().map(cep -> {
Optional<org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.connectivity.rev170712.connectivity.service.EndPoint> optEndPoint = Optional.empty();
- if(cs.getEndPoint() != null){
+ if (cs.getEndPoint() != null) {
optEndPoint = cs.getEndPoint().stream()
.filter(endPoint1 -> endPoint1.getServiceInterfacePoint().getValue().contains(cep.getServerNodeEdgePoint().getValue()))
.findFirst();
public DecompositionAction(List<EndPoint> endpoints, DataBroker broker) {
Objects.requireNonNull(endpoints);
Objects.requireNonNull(broker);
- if(endpoints.size() < 2) throw new IllegalArgumentException("there should be at least two endpoints defined");
+ if (endpoints.size() < 2) throw new IllegalArgumentException("there should be at least two endpoints defined");
this.endpoints = endpoints;
this.broker = broker;
}
assert vertexes.size() > 1;
- if(vertexes.size() > 2) throw new IllegalStateException("currently only point to point is supported");
+ if (vertexes.size() > 2) throw new IllegalStateException("currently only point to point is supported");
GraphPath<Vertex, DefaultEdge> path = DijkstraShortestPath.findPathBetween(graph, vertexes.get(0), vertexes.get(1));
- if(path == null) return null;
+ if (path == null) return null;
return path.getVertexList().stream().collect(Collectors.groupingBy(v -> v.getNodeUuid()))
.entrySet().stream().map(e -> {
}
private void connected(Graph<Vertex, DefaultEdge> graph, List<Vertex> vertices) {
- for(int i = 0; i < vertices.size(); ++i) {
+ for (int i = 0; i < vertices.size(); ++i) {
Vertex f = vertices.get(i);
//its OK if the vertex is added in internal loop nothing will happen
graph.addVertex(f);
- for(int j = i + 1; j < vertices.size(); ++j) {
+ for (int j = i + 1; j < vertices.size(); ++j) {
Vertex t = vertices.get(j);
graph.addVertex(t);
graph.addEdge(f,t);
connected(graph, vertices);
});
- if(topo.getLink() != null) {
+ if (topo.getLink() != null) {
topo.getLink().stream()
.filter(l -> l.getState() != null && OperationalState.Enabled == l.getState().getOperationalState())
.forEach(l -> {
Uuid nodeUuid = n.getUuid();
return n.getOwnedNodeEdgePoint().stream().map(nep -> {
List<Uuid> sips = nep.getMappedServiceInterfacePoint();
- if(sips == null || sips.isEmpty()) {
+ if (sips == null || sips.isEmpty()) {
return new Vertex(nodeUuid, nep.getUuid(), null);
}
- if(sips.size() > 1) LOG.warn("NodeEdgePoint {} have multiple ServiceInterfacePoint mapped, selecting first one", nep.getUuid());
+ if (sips.size() > 1) LOG.warn("NodeEdgePoint {} have multiple ServiceInterfacePoint mapped, selecting first one", nep.getUuid());
return new Vertex(nodeUuid, nep.getUuid(), sips.get(0));
});
@Override
public int compareTo(Vertex o) {
- if(o == null) return -1;
+ if (o == null) return -1;
return uuid.getValue().compareTo(o.uuid.getValue());
}
.child(Node.class, new NodeKey(nodeId))
.child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepId))
).checkedGet();
- if(!nep.isPresent()) return withError("NEP with id {0} for node {1} not found", nepId, nodeId);
+ if (!nep.isPresent()) return withError("NEP with id {0} for node {1} not found", nepId, nodeId);
Uuid sipId = new Uuid("sip:" + nepId.getValue());
List<Uuid> sips = nep.get().getMappedServiceInterfacePoint();
- if(sips != null && !sips.isEmpty()) return withError("sip for NEP with id {0} for node {1} already defined", nepId, nodeId);
+ if (sips != null && !sips.isEmpty()) return withError("sip for NEP with id {0} for node {1} already defined", nepId, nodeId);
NrpDao nrpDao = new NrpDao(tx);
LayerProtocol1 lp = null;
- if(sipType instanceof InniSpec) {
+ if (sipType instanceof InniSpec) {
org.opendaylight.yang.gen.v1.urn.odl.unimgr.yang.unimgr.ext.rev700101.add.sip.input.sip.type.inni.spec.InniSpec spec = ((InniSpec) sipType).getInniSpec();
- if(spec != null) lp = new LayerProtocol1Builder()
+ if (spec != null) lp = new LayerProtocol1Builder()
.setNrpCarrierEthInniNResource(new NrpCarrierEthInniNResourceBuilder(spec).build()).build();
} else if (sipType instanceof EnniSpec) {
org.opendaylight.yang.gen.v1.urn.odl.unimgr.yang.unimgr.ext.rev700101.add.sip.input.sip.type.enni.spec.EnniSpec spec = ((EnniSpec) sipType).getEnniSpec();
- if(spec != null) lp = new LayerProtocol1Builder()
+ if (spec != null) lp = new LayerProtocol1Builder()
.setNrpCarrierEthEnniNResource(new NrpCarrierEthEnniNResourceBuilder(spec).build()).build();
- } else if(sipType instanceof UniSpec) {
+ } else if (sipType instanceof UniSpec) {
org.opendaylight.yang.gen.v1.urn.odl.unimgr.yang.unimgr.ext.rev700101.add.sip.input.sip.type.uni.spec.UniSpec spec = ((UniSpec) sipType).getUniSpec();
- if(spec != null) lp = new LayerProtocol1Builder()
+ if (spec != null) lp = new LayerProtocol1Builder()
.setNrpCarrierEthUniNResource(new NrpCarrierEthUniNResourceBuilder(spec).build()).build();
}
private static RpcResult<Void> withError(String error, Object ... params) {
RpcResultBuilder<Void> failed = RpcResultBuilder.<Void>failed();
- if(error != null) {
- if(params.length > 0) {
+ if (error != null) {
+ if (params.length > 0) {
error = MessageFormat.format(error, params);
}
failed.withError(RpcError.ErrorType.APPLICATION, error);
return condition;
}
- private static boolean checkForNetconfCapability(Node node, String netconf_capability){
+ private static boolean checkForNetconfCapability(Node node, String netconf_capability) {
NetconfNode netconf = node.getAugmentation(NetconfNode.class);
- if(netconf == null) return false;
- if(netconf.getAvailableCapabilities() == null) return false;
- if(netconf.getAvailableCapabilities().getAvailableCapability() == null) return false;
+ if (netconf == null) return false;
+ if (netconf.getAvailableCapabilities() == null) return false;
+ if (netconf.getAvailableCapabilities().getAvailableCapability() == null) return false;
return netconf
.getAvailableCapabilities()
boolean isSupporting = isSupporting(capability);
result = (mode == Capability.Mode.AND ? result && isSupporting: result || isSupporting);
- if(result ^ (mode == Capability.Mode.AND)) {
+ if (result ^ (mode == Capability.Mode.AND)) {
break;
}
}
Optional<C> dataCollectionOptional = dataOptional.isPresent() ? Optional.ofNullable(function.apply(dataOptional.get()).get()) : Optional.empty();
- if(dataCollectionOptional.isPresent()) {
+ if (dataCollectionOptional.isPresent()) {
dataCollectionOptional.get().forEach(dataObject -> result.add(new NullAwareDatastoreGetter<R>(dataObject)));
}
}
private void logDataOptionalStatus(Function <?, ?> function) {
- if(dataOptional.isPresent()) {
+ if (dataOptional.isPresent()) {
LOG.trace("Before collection of: " + function.toString() + ", currently collected data is non-null: " + dataOptional.get().toString());
} else {
LOG.debug("Null value encountered during collection of: " + function.toString());
*/
public class SipHandler {
- public static String getDeviceName(Uuid sip){
+ public static String getDeviceName(Uuid sip) {
String[] sipTab = sip.getValue().split(":");
return sipTab[sipTab.length-2];
}
- public static String getPortName(Uuid sip){
+ public static String getPortName(Uuid sip) {
String[] sipTab = sip.getValue().split(":");
return sipTab[sipTab.length-1];
}
- public static boolean isTheSameDevice(Uuid sip1, Uuid sip2){
+ public static boolean isTheSameDevice(Uuid sip1, Uuid sip2) {
return getDeviceName(sip1).equals(getDeviceName(sip2));
}
}
@SuppressWarnings("unchecked")
@Before
- public void setUp(){
+ public void setUp() {
PowerMockito.mockStatic(MdsalUtils.class);
PowerMockito.mockStatic(EvcUtils.class);
PowerMockito.mockStatic(OvsdbUtils.class);
private DataBroker dataBroker;
@Before
- public void setUp(){
+ public void setUp() {
PowerMockito.mockStatic(MdsalUtils.class);
PowerMockito.mockStatic(EvcUtils.class);
PowerMockito.mockStatic(OvsdbUtils.class);
private DataBroker dataBroker;
@Before
- public void setUp(){
+ public void setUp() {
PowerMockito.mockStatic(UniUtils.class);
PowerMockito.mockStatic(MdsalUtils.class);
PowerMockito.mockStatic(EvcUtils.class);
}
@SuppressWarnings("unchecked")
- private void verifyExecute(int getUniTimes, int deleteTimes, int readNodeTimes, int updateEvcTime){
+ private void verifyExecute(int getUniTimes, int deleteTimes, int readNodeTimes, int updateEvcTime) {
evcUpdateCommand.execute();
PowerMockito.verifyStatic(times(getUniTimes));
UnimgrMapper.getUniIid(any(DataBroker.class), any(IpAddress.class),
@SuppressWarnings("unchecked")
@Before
- public void setUp(){
+ public void setUp() {
PowerMockito.mockStatic(UniUtils.class);
PowerMockito.mockStatic(OvsdbUtils.class);
PowerMockito.mockStatic(MdsalUtils.class);
}
@SuppressWarnings("unchecked")
- private void verifyExecute(int qosTimes, int bridgeTimes, int updateNodeTime, int updateIIDTimes){
+ private void verifyExecute(int qosTimes, int bridgeTimes, int updateNodeTime, int updateIIDTimes) {
uniAddCommand.execute();
PowerMockito.verifyStatic(times(qosTimes));
OvsdbUtils.createQoSForOvsdbNode(any(DataBroker.class), any(UniAugmentation.class));
private Node uniNode;
@Before
- public void setUp(){
+ public void setUp() {
PowerMockito.mockStatic(UniUtils.class);
PowerMockito.mockStatic(OvsdbUtils.class);
PowerMockito.mockStatic(MdsalUtils.class);
private Node uniNode;
@Before
- public void setUp(){
+ public void setUp() {
PowerMockito.mockStatic(UniUtils.class);
PowerMockito.mockStatic(MdsalUtils.class);
PowerMockito.mockStatic(OvsdbUtils.class);
verifyExecute(2, 2);
}
- private void verifyExecute(int qosTimes, int updateNodeTime){
+ private void verifyExecute(int qosTimes, int updateNodeTime) {
uniUpdateCommand.execute();
PowerMockito.verifyStatic(times(qosTimes));
OvsdbUtils.createQoSForOvsdbNode(any(DataBroker.class), any(UniAugmentation.class));
private static final int init_neps_count = 4;
@Before
- public void setUp(){
+ public void setUp() {
//given
dataBroker = getDataBroker();
}
@Test
- public void testNodeAddition(){
+ public void testNodeAddition() {
//when
performNrpDaoAction(addNode,null);
}
@Test
- public void testNepAddition(){
+ public void testNepAddition() {
//given
String newNepName = "newNep";
performNrpDaoAction(addNode,null);
}
@Test
- public void testNepUpdate(){
+ public void testNepUpdate() {
//given
performNrpDaoAction(addNode,null);
}
@Test
- public void testNodeRemoval(){
+ public void testNodeRemoval() {
//given
performNrpDaoAction(addNode,null);
}
@Test
- public void testNepRemoval(){
+ public void testNepRemoval() {
//given
performNrpDaoAction(addNode,null);
String nepNameToRemove = testNepName+"0";
BiConsumer<NrpDao,String> addNode = (dao,nepId) -> dao.createSystemNode(testSystemNodeName,createTestOwnedNodeEdgePointList());
BiConsumer<NrpDao,OwnedNodeEdgePoint> update = (dao,nep) -> dao.updateNep(testSystemNodeName,nep);
- private <T extends Object> void performNrpDaoAction(BiConsumer<NrpDao,T> action, T attr){
+ private <T extends Object> void performNrpDaoAction(BiConsumer<NrpDao,T> action, T attr) {
ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
nrpDao = new NrpDao(tx);
action.accept(nrpDao,attr);
tx.submit();
}
- private List<OwnedNodeEdgePoint> createTestOwnedNodeEdgePointList(){
+ private List<OwnedNodeEdgePoint> createTestOwnedNodeEdgePointList() {
return IntStream.range(0,init_neps_count).
mapToObj(i -> createNep(testNepName + i, TerminationDirection.Bidirectional))
.collect(Collectors.toList());
}
- private OwnedNodeEdgePoint createNep(String nepName, TerminationDirection td){
+ private OwnedNodeEdgePoint createNep(String nepName, TerminationDirection td) {
return createNep(nepName, true, td);
}
- private OwnedNodeEdgePoint createNep(String nepName, boolean associateSip, TerminationDirection td){
+ private OwnedNodeEdgePoint createNep(String nepName, boolean associateSip, TerminationDirection td) {
Uuid uuid = new Uuid(nepName);
OwnedNodeEdgePointBuilder builder = new OwnedNodeEdgePointBuilder()
.setKey(new OwnedNodeEdgePointKey(uuid))
.setUuid(uuid);
// TODO donaldh .setTerminationDirection(td);
- if(associateSip) builder.setMappedServiceInterfacePoint(Arrays.asList(new Uuid(sipPrefix + nepName)));
+ if (associateSip) builder.setMappedServiceInterfacePoint(Arrays.asList(new Uuid(sipPrefix + nepName)));
return builder.build();
}
- private Node getAbstractNode(){
+ private Node getAbstractNode() {
ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction();
try {
Optional<Node> opt =
(Optional<Node>) tx.read(LogicalDatastoreType.OPERATIONAL,NRP_ABSTRACT_NODE_IID).checkedGet();
- if(opt.isPresent()){
+ if (opt.isPresent()) {
return opt.get();
} else {
return null;
protected Node n(ReadWriteTransaction tx, boolean addSips, String node, String ... endpoints) {
NrpDao nrpDao = new NrpDao(tx);
- if(addSips) Arrays.stream(endpoints).map(e -> new ServiceInterfacePointBuilder()
+ if (addSips) Arrays.stream(endpoints).map(e -> new ServiceInterfacePointBuilder()
.setUuid(new Uuid("sip:" + e))
.build())
.forEach(nrpDao::addSip);
return nrpDao.createSystemNode(node, Arrays.stream(endpoints)
.map(e-> {
OwnedNodeEdgePointBuilder builder = new OwnedNodeEdgePointBuilder().setUuid(new Uuid(e));
- if(addSips) {
+ if (addSips) {
builder.setMappedServiceInterfacePoint(Collections.singletonList(new Uuid("sip:"+e)));
}
return builder.build();
.setContainerNode(new Uuid(nodeUuid))
.setConnectionEndPoint(ceps(neps));
- if(!route.isEmpty()) {
+ if (!route.isEmpty()) {
builder.setRoute(Collections.singletonList(new RouteBuilder()
.setConnectionEndPoint(route)
.setLocalId("route")
boolean hasSip = nep.getMappedServiceInterfacePoint().get(0).getValue().equals("sip:" + nepId);
ServiceInterfacePoint sip = nrpDao.getSip("sip:" + nepId);
assertTrue(hasSip && sip != null);
- if(verifySip != null) verifySip.accept(sip);
+ if (verifySip != null) verifySip.accept(sip);
}
.setNepId(new Uuid(nepId))
.setNodeId(new Uuid(nodeId));
- if(type == null) return sipBuilder.build();
+ if (type == null) return sipBuilder.build();
switch (type) {
case uni: sipBuilder.setSipType(
FcPort mockedFcPort = mock(FcPort.class);
StringBuilder nodeIdBuilder = new StringBuilder(DEVICE_ID);
- if(nodeNo > 0) {
+ if (nodeNo > 0) {
nodeIdBuilder.append("_").append(Integer.toString(nodeNo));
}
Optional<Node> mockedNodeOptional = mockNode();
List<AvailableCapability> netconfCapabilityList = new ArrayList<>();
- if(withNetconfCapabilities) {
+ if (withNetconfCapabilities) {
netconfCapabilityList = Arrays.asList(createAvailableCapability(NetconfConstants.CAPABILITY_IOX_L2VPN),
createAvailableCapability(NetconfConstants.CAPABILITY_IOX_IFMGR),
createAvailableCapability(NetconfConstants.CAPABILITY_IOX_ASR9K_POLICYMGR));
return mockedNodeOptional;
}
- private static AvailableCapability createAvailableCapability(String name){
+ private static AvailableCapability createAvailableCapability(String name) {
AvailableCapabilityBuilder availableCapabilityBuilder = new AvailableCapabilityBuilder();
availableCapabilityBuilder.setCapability(name);
return availableCapabilityBuilder.build();
*/
int getCeVlanId() throws ResourceNotAvailableException {
- if( (endPoint.getAttrs() != null) && (endPoint.getAttrs().getNrpCarrierEthConnectivityEndPointResource() != null) ) {
+ if ( (endPoint.getAttrs() != null) && (endPoint.getAttrs().getNrpCarrierEthConnectivityEndPointResource() != null) ) {
NrpCarrierEthConnectivityEndPointResource attr = endPoint.getAttrs().getNrpCarrierEthConnectivityEndPointResource();
- if( (attr.getCeVlanIdListAndUntag()!=null) && !(attr.getCeVlanIdListAndUntag().getVlanId().isEmpty()) ){
+ if ( (attr.getCeVlanIdListAndUntag()!=null) && !(attr.getCeVlanIdListAndUntag().getVlanId().isEmpty()) ) {
//for now we support only one CE VLAN
return attr.getCeVlanIdListAndUntag().getVlanId().get(0).getVlanId().getValue().intValue();
} else {
private Map<String, String> createPortMap(List<NullAwareDatastoreGetter<Node>> nodes) {
Map<String, String> portMap = new HashMap<>();
for (NullAwareDatastoreGetter<Node> node : nodes) {
- if (node.get().isPresent()){
+ if (node.get().isPresent()) {
for (NodeConnector nodeConnector : node.get().get().getNodeConnector()) {
String ofName = nodeConnector.getId().getValue();
FlowCapableNodeConnector flowCapableNodeConnector = nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
return portMap;
}
- protected static String getPortName(String sip){
+ protected static String getPortName(String sip) {
String[] tab = sip.split(":");
return tab[tab.length-1];
}
private OvsActivator activator;
- public OvsDriver(DataBroker dataBroker){
+ public OvsDriver(DataBroker dataBroker) {
activator = new OvsActivator(dataBroker);
}
* @author jakub.niezgoda@amartus.com
*/
public class VlanNotSetException extends ResourceNotAvailableException {
- public VlanNotSetException(String message){
+ public VlanNotSetException(String message) {
super(message);
}
}
\ No newline at end of file
* @author marek.ryznar@amartus.com
*/
public class VlanPoolExhaustedException extends ResourceNotAvailableException {
- public VlanPoolExhaustedException(String message){
+ public VlanPoolExhaustedException(String message) {
super(message);
}
}
\ No newline at end of file
private static final Logger LOG = LoggerFactory.getLogger(DataObjectModificationQualifier.class);
private CapabilitiesService capabilitiesService;
- public DataObjectModificationQualifier(DataBroker dataBroker){
+ public DataObjectModificationQualifier(DataBroker dataBroker) {
capabilitiesService = new CapabilitiesService(dataBroker);
}
private Function<Node,Boolean> isOvs = node -> capabilitiesService.node(node).isSupporting(AND, OVSDB);
- protected void checkNodes(List<DataObjectModification> nodes, Map<TerminationPoint,String> toAddMap, Map<TerminationPoint,String> toUpdateMap, Map<TerminationPoint,String> toDeleteMap){
+ protected void checkNodes(List<DataObjectModification> nodes, Map<TerminationPoint,String> toAddMap, Map<TerminationPoint,String> toUpdateMap, Map<TerminationPoint,String> toDeleteMap) {
Node n;
- for(DataObjectModification node: nodes){
- switch(node.getModificationType()){
+ for (DataObjectModification node: nodes) {
+ switch(node.getModificationType()) {
//new ovs node
case WRITE :{
n = (Node) node.getDataAfter();
- if(!isOvs.apply(n) || n.getTerminationPoint()==null)
+ if (!isOvs.apply(n) || n.getTerminationPoint()==null)
break;
String bridgeName = n.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue();
n.getTerminationPoint().forEach(tp -> toAddMap.put(tp,bridgeName));
//whole ovs-node eg. s1 deleted
case DELETE:{
n = (Node) node.getDataBefore();
- if(!isOvs.apply(n) || n.getTerminationPoint()==null)
+ if (!isOvs.apply(n) || n.getTerminationPoint()==null)
break;
String bridgeName = n.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue();
n.getTerminationPoint().forEach(tp -> toDeleteMap.put(tp,bridgeName));
}
}
- private void checkTerminationPoints(DataObjectModification node, Map<TerminationPoint,String> toAddMap, Map<TerminationPoint,String> toUpdateMap, Map<TerminationPoint,String> toDeleteMap){
+ private void checkTerminationPoints(DataObjectModification node, Map<TerminationPoint,String> toAddMap, Map<TerminationPoint,String> toUpdateMap, Map<TerminationPoint,String> toDeleteMap) {
Node n = (Node) node.getDataAfter();
- if(!isOvs.apply(n))
+ if (!isOvs.apply(n))
return ;
String bridgeName = n.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue();
Collection<DataObjectModification<? extends DataObject>> modifiedChildren = node.getModifiedChildren();
TerminationPoint terminationPoint;
- for(DataObjectModification tp: modifiedChildren) {
- if(!tp.getDataType().equals(TerminationPoint.class))
+ for (DataObjectModification tp: modifiedChildren) {
+ if (!tp.getDataType().equals(TerminationPoint.class))
continue;
switch (tp.getModificationType()) {
//new port added eg. s1-eth7
registerOvsdbTreeListener();
}
- private void registerOvsdbTreeListener(){
+ private void registerOvsdbTreeListener() {
InstanceIdentifier<Node> nodeId = OVSDB_TOPO_IID.child(Node.class);
registration = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, nodeId), this);
}
}
});
- if(registration != null) {
+ if (registration != null) {
LOG.info("closing netconf tree listener");
registration.close();
}
.forEach(entry -> {
String nepId = OVS_NODE + DELIMETER + getFullPortName(entry.getValue(), entry.getKey().getTpId().getValue());
OwnedNodeEdgePoint nep;
- if(dao.hasSip(nepId)){
+ if (dao.hasSip(nepId)) {
nep = createNep(nepId);
dao.updateNep(OVS_NODE,nep);
} else {
newNeps.forEach(nep -> addEndpoint(dao,nep.getKey().getUuid().getValue()));
};
- private void executeDbAction(BiConsumer<Map<TerminationPoint,String>,NrpDao> action,Map<TerminationPoint,String> map){
- if(map.isEmpty())
+ private void executeDbAction(BiConsumer<Map<TerminationPoint,String>,NrpDao> action,Map<TerminationPoint,String> map) {
+ if (map.isEmpty())
return ;
final ReadWriteTransaction topoTx = dataBroker.newReadWriteTransaction();
NrpDao dao = new NrpDao(topoTx);
});
}
- private String getFullPortName(String switchName, String portName){
+ private String getFullPortName(String switchName, String portName) {
return switchName + DELIMETER + portName;
}
.build();
}
- private OwnedNodeEdgePoint createNep(String nepId){
+ private OwnedNodeEdgePoint createNep(String nepId) {
OwnedNodeEdgePointBuilder tpBuilder = new OwnedNodeEdgePointBuilder();
Uuid tpId = new Uuid(OVS_NODE + DELIMETER + nepId);
return tpBuilder
.build();
}
- private List<OwnedNodeEdgePoint> getNewNeps(Map<TerminationPoint,String> toAddMap){
+ private List<OwnedNodeEdgePoint> getNewNeps(Map<TerminationPoint,String> toAddMap) {
return toAddMap.entrySet().stream()
.map(entry -> createNep(getFullPortName(entry.getValue(),entry.getKey().getTpId().getValue())) )
.collect(Collectors.toList());
}
//TODO: write better implementation
- private boolean isNep(TerminationPoint terminationPoint){
+ private boolean isNep(TerminationPoint terminationPoint) {
OvsdbTerminationPointAugmentation ovsdbTerminationPoint = terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class);
- if( ovsdbTerminationPoint==null || (ovsdbTerminationPoint.getInterfaceType()!=null && ovsdbTerminationPoint.getInterfaceType().equals(InterfaceTypeInternal.class))) {
+ if ( ovsdbTerminationPoint==null || (ovsdbTerminationPoint.getInterfaceType()!=null && ovsdbTerminationPoint.getInterfaceType().equals(InterfaceTypeInternal.class))) {
return false;
}
- if( ovsdbTerminationPoint.getOfport() == null )
+ if ( ovsdbTerminationPoint.getOfport() == null )
return false;
String ofPortNumber = ovsdbTerminationPoint.getOfport().toString();
deleteTransaction.submit().checkedGet();
}
- private InstanceIdentifier<Table> getTableIid(NodeKey nodeKey, TableKey tableKey){
+ private InstanceIdentifier<Table> getTableIid(NodeKey nodeKey, TableKey tableKey) {
return InstanceIdentifier.builder(Nodes.class)
.child(Node.class, nodeKey)
.augmentation(FlowCapableNode.class)
.build();
}
- private InstanceIdentifier<Flow> getFlowIid(Flow flow){
+ private InstanceIdentifier<Flow> getFlowIid(Flow flow) {
return tableInstanceId.child(Flow.class, flow.getKey());
}
}
* @throws ResourceNotAvailableException if node for the specified port name was not found
*/
public Node readNode(String portName) throws ResourceNotAvailableException {
- for(NullAwareDatastoreGetter<Node> node : readNodes()) {
- if(node.get().isPresent()){
- for(NodeConnector nodeConnector:node.get().get().getNodeConnector()) {
+ for (NullAwareDatastoreGetter<Node> node : readNodes()) {
+ if (node.get().isPresent()) {
+ for (NodeConnector nodeConnector:node.get().get().getNodeConnector()) {
FlowCapableNodeConnector flowCapableNodeConnector
= nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
if (portName.equals(flowCapableNodeConnector.getName())) {
public Node readNodeOF(String ofportName) throws ResourceNotAvailableException {
String ofNodeName = ofportName.split(":")[0]+":"+ofportName.split(":")[1];
Nodes nodes = readOpenFLowTopology(dataBroker);
- if(nodes != null){
- for(Node node: nodes.getNode()){
- if(node.getId().getValue().equals(ofNodeName)){
+ if (nodes != null) {
+ for (Node node: nodes.getNode()) {
+ if (node.getId().getValue().equals(ofNodeName)) {
return node;
}
}
return InstanceIdentifier.builder(Nodes.class).build();
}
- public static Nodes readOpenFLowTopology(DataBroker dataBroker){
+ public static Nodes readOpenFLowTopology(DataBroker dataBroker) {
InstanceIdentifier instanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
return (Nodes) MdsalUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION,instanceIdentifier);
}
if (flow.getInstructions() != null &&
!flow.getInstructions().getInstruction().isEmpty())
{
- for(Instruction instruction : flow.getInstructions().getInstruction()) {
+ for (Instruction instruction : flow.getInstructions().getInstruction()) {
ApplyActionsCase applyActionsCase = (ApplyActionsCase) instruction.getInstruction();
ApplyActions applyActions = applyActionsCase.getApplyActions();
List<Action> actions = applyActions.getAction();
}
private void checkActions(List<Action> actions) {
- for( Action action:actions ) {
+ for ( Action action:actions ) {
org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.Action concreteAction = action.getAction();
- if( concreteAction instanceof SetField ) {
+ if ( concreteAction instanceof SetField ) {
SetField setField = (SetField) concreteAction;
- if( setField.getVlanMatch() != null ) {
+ if ( setField.getVlanMatch() != null ) {
Integer vid = getVlanFromMatch(setField.getVlanMatch());
- if( vid != null && !usedVlans.contains(vid)) {
+ if ( vid != null && !usedVlans.contains(vid)) {
usedVlans.add(vid);
}
}
public class DataStoreTestUtils {
private static final Logger LOG = LoggerFactory.getLogger(DataStoreTestUtils.class);
- public static <T extends DataObject> T read(InstanceIdentifier instanceIdentifier, DataBroker dataBroker){
+ public static <T extends DataObject> T read(InstanceIdentifier instanceIdentifier, DataBroker dataBroker) {
return read(instanceIdentifier,dataBroker,LogicalDatastoreType.OPERATIONAL);
}
- public static <T extends DataObject> T readConfig(InstanceIdentifier instanceIdentifier, DataBroker dataBroker){
+ public static <T extends DataObject> T readConfig(InstanceIdentifier instanceIdentifier, DataBroker dataBroker) {
return read(instanceIdentifier,dataBroker,LogicalDatastoreType.CONFIGURATION);
}
- public static <T extends DataObject> void write(T object, InstanceIdentifier<T> instanceIdentifier, DataBroker dataBroker){
+ public static <T extends DataObject> void write(T object, InstanceIdentifier<T> instanceIdentifier, DataBroker dataBroker) {
ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
transaction.put(LogicalDatastoreType.OPERATIONAL,instanceIdentifier,object,true);
});
}
- public static void delete(InstanceIdentifier instanceIdentifier, DataBroker dataBroker){
+ public static void delete(InstanceIdentifier instanceIdentifier, DataBroker dataBroker) {
ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();
transaction.delete(LogicalDatastoreType.OPERATIONAL, instanceIdentifier);
});
}
- private static <T extends DataObject> T read(InstanceIdentifier instanceIdentifier, DataBroker dataBroker, LogicalDatastoreType type){
+ private static <T extends DataObject> T read(InstanceIdentifier instanceIdentifier, DataBroker dataBroker, LogicalDatastoreType type) {
ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
try {
Optional<T> opt = (Optional<T>) transaction.read(type,instanceIdentifier).checkedGet();
- if (opt.isPresent()){
+ if (opt.isPresent()) {
return opt.get();
} else {
fail("Could not find object");
/**
* Creates flow topology with link nodes (Links between ovs).
*/
- public static void createFlowTopology(DataBroker dataBroker, List<Link> links){
+ public static void createFlowTopology(DataBroker dataBroker, List<Link> links) {
TopologyBuilder topologyBuilder = new TopologyBuilder();
topologyBuilder.setTopologyId(flowTopologyId);
topologyBuilder.setLink(links);
DataStoreTestUtils.write(topology,FLOW_TOPO_IID,dataBroker);
}
- public static Link createLink(String sourceNode, Long sourcePort, String destNode, Long destPort){
+ public static Link createLink(String sourceNode, Long sourcePort, String destNode, Long destPort) {
LinkBuilder linkBuilder = new LinkBuilder();
String sourcePortName = prefix + sourceNode + ":" + sourcePort.toString();
String destPortName = prefix + destNode + ":" + destPort;
*/
public class OpenFlowTopologyTestUtils {
- public static void createOpenFlowNodes(List<Node> nodeList, DataBroker dataBroker){
+ public static void createOpenFlowNodes(List<Node> nodeList, DataBroker dataBroker) {
NodesBuilder nodesBuilder = new NodesBuilder();
nodesBuilder.setNode(nodeList);
Nodes nodes = nodesBuilder.build();
DataStoreTestUtils.write(nodes,nodesIId,dataBroker);
}
- public static org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node createOpenFlowNode(String oFName, List<NodeConnector> nodeConnectorList){
+ public static org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node createOpenFlowNode(String oFName, List<NodeConnector> nodeConnectorList) {
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder =
new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder();
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId nodeId =
return nodeBuilder.build();
}
- public static NodeConnector createNodeConnector(String ofBridgeName, Long portNumber, String ovsdbPortName){
+ public static NodeConnector createNodeConnector(String ofBridgeName, Long portNumber, String ovsdbPortName) {
NodeConnectorBuilder nodeConnectorBuilder = new NodeConnectorBuilder();
String ofPortName = ofBridgeName + ":" + portNumber.toString();
NodeConnectorId nodeConnectorId = new NodeConnectorId(ofPortName);
return nodeConnectorBuilder.build();
}
- private static FlowCapableNodeConnector createFlowCapableNodeConnector(String ovsdbName, Long portNumber){
+ private static FlowCapableNodeConnector createFlowCapableNodeConnector(String ovsdbName, Long portNumber) {
FlowCapableNodeConnectorBuilder flowCapableNodeConnectorBuilder = new FlowCapableNodeConnectorBuilder();
flowCapableNodeConnectorBuilder.setName(ovsdbName);
flowCapableNodeConnectorBuilder.setPortNumber(new PortNumberUni(portNumber));
return flowCapableNodeConnectorBuilder.build();
}
- public static FlowCapableNode createFlowCapableNode(){
+ public static FlowCapableNode createFlowCapableNode() {
FlowCapableNodeBuilder flowCapableNodeBuilder = new FlowCapableNodeBuilder();
flowCapableNodeBuilder.setTable(createOfTable());
return flowCapableNodeBuilder.build();
}
- private static List<Table> createOfTable(){
+ private static List<Table> createOfTable() {
List<Table> tables = new ArrayList<>();
TableBuilder tableBuilder = new TableBuilder();
tableBuilder.setId(Short.valueOf("0"));
return tables;
}
- public static InstanceIdentifier<NodeConnector> getNodeConnectorInstanceIdentifier(String ofBridgeName, String nodeConnectorId){
+ public static InstanceIdentifier<NodeConnector> getNodeConnectorInstanceIdentifier(String ofBridgeName, String nodeConnectorId) {
return InstanceIdentifier.builder(Nodes.class)
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class,
new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey(
/**
* Ovsdb topology initializator.
*/
- public static void createOvsdbTopology(DataBroker dataBroker){
+ public static void createOvsdbTopology(DataBroker dataBroker) {
TopologyBuilder topologyBuilder = new TopologyBuilder();
topologyBuilder.setTopologyId(ovsdbTopologyId);
Topology topology = topologyBuilder.build();
DataStoreTestUtils.write(topology,ovsdbTopology, dataBroker);
}
- public static void writeBridge(Node node, DataBroker dataBroker){
+ public static void writeBridge(Node node, DataBroker dataBroker) {
InstanceIdentifier bridgeIid = getNodeInstanceIdentifier(node.getNodeId());
DataStoreTestUtils.write(node,bridgeIid,dataBroker);
}
- public static Node createBridge(String nodeId, List<TerminationPoint> tps){
+ public static Node createBridge(String nodeId, List<TerminationPoint> tps) {
NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setNodeId(new NodeId(nodeId));
nodeBuilder.setTerminationPoint(tps);
return nodeBuilder.build();
}
- public static InstanceIdentifier getNodeInstanceIdentifier(NodeId nodeId){
+ public static InstanceIdentifier getNodeInstanceIdentifier(NodeId nodeId) {
return InstanceIdentifier
.builder(NetworkTopology.class)
.child(Topology.class,
.build();
}
- public static InstanceIdentifier getPortInstanceIdentifier(String nodeName, String portName){
+ public static InstanceIdentifier getPortInstanceIdentifier(String nodeName, String portName) {
return getNodeInstanceIdentifier(new NodeId(nodeName))
.child(TerminationPoint.class,
new TerminationPointKey(new TpId(portName)));
}
- private static OvsdbBridgeAugmentation createOvsdbBridgeAugmentation(String ovsdbBridgeName){
+ private static OvsdbBridgeAugmentation createOvsdbBridgeAugmentation(String ovsdbBridgeName) {
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(ovsdbBridgeName));
return ovsdbBridgeAugmentationBuilder.build();
List<String> of2InterwitchPorts = Arrays.asList("openflow:5:3", "openflow:5:4");
@Before
- public void setUp(){
+ public void setUp() {
//given
dataBroker = getDataBroker();
ovsActivator = new OvsActivator(dataBroker);
}
@Test
- public void testActivate(){
+ public void testActivate() {
//given
List<EndPoint> endPoints = prepareEndpoints();
assertFalse(hasVlanFlows);
};
- private boolean hasVlanMatch(Flow flow){
- if(flow.getMatch().getVlanMatch().getVlanId().getVlanId().getValue().equals(expectedVlanId)){
+ private boolean hasVlanMatch(Flow flow) {
+ if (flow.getMatch().getVlanMatch().getVlanId().getVlanId().getValue().equals(expectedVlanId)) {
return true;
}
return false;
}
- private void checkTable(Nodes nodes, BiConsumer<Table,List<String>> checkTable){
+ private void checkTable(Nodes nodes, BiConsumer<Table,List<String>> checkTable) {
nodes.getNode()
.forEach(node -> {
try {
Table t = OpenFlowUtils.getTable(node);
- if(node.getKey().getId().getValue().equals(ofPort1Name)){
+ if (node.getKey().getId().getValue().equals(ofPort1Name)) {
checkTable.accept(t,of1InterwitchPorts);
- } else if(node.getKey().getId().getValue().equals(ofPort2Name)){
+ } else if (node.getKey().getId().getValue().equals(ofPort2Name)) {
checkTable.accept(t,of2InterwitchPorts);
}
} catch (ResourceNotAvailableException e) {
});
}
- private List<EndPoint> prepareEndpoints(){
+ private List<EndPoint> prepareEndpoints() {
List<EndPoint> endPoints = new ArrayList<>();
endPoints.add(mockEndPoint(port1Name));
endPoints.add(mockEndPoint(port2Name));
return endPoints;
}
- private EndPoint mockEndPoint(String portName){
+ private EndPoint mockEndPoint(String portName) {
ConnectivityServiceEndPoint connectivityServiceEndPoint = mock(ConnectivityServiceEndPoint.class);
NrpConnectivityServiceEndPointAttrs attrs = mock(NrpConnectivityServiceEndPointAttrs.class);
//UNI port mock
/**
* Add 5 ovsdb bridges and suitable openflow nodes
*/
- private void initTopologies(){
+ private void initTopologies() {
List<Node> bridges = new ArrayList<>();
List<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> ofNodes = new ArrayList<>();
bridges.add(createBridge("s1",5));
OpenFlowTopologyTestUtils.createOpenFlowNodes(ofNodes,dataBroker);
}
- private Node createBridge(String name, int portCount){
+ private Node createBridge(String name, int portCount) {
List<TerminationPoint> tps = new ArrayList<>();
IntStream.range(1,portCount+1)
.forEach(i -> tps.add(OvsdbTopologyTestUtils.createTerminationPoint(name+"-eth"+i,Long.valueOf(i))));
return OvsdbTopologyTestUtils.createBridge(name, tps);
}
- private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node createOpenFlowNode(Node node){
+ private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node createOpenFlowNode(Node node) {
String ovsdbName = node.getKey().getNodeId().getValue();
String ofBridgeName = getOfName(ovsdbName);
return OpenFlowTopologyTestUtils.createOpenFlowNode(ofBridgeName,nodeConnectors);
}
- private String getOfName(String ovsdbName){
+ private String getOfName(String ovsdbName) {
String bridgeNumber = ovsdbName.substring(1,ovsdbName.length());
return "openflow:"+bridgeNumber;
}
- public static Nodes readOpenFLowTopology(DataBroker dataBroker){
+ public static Nodes readOpenFLowTopology(DataBroker dataBroker) {
InstanceIdentifier instanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
return (Nodes) MdsalUtils.read(dataBroker,LogicalDatastoreType.CONFIGURATION,instanceIdentifier);
}
/**
* @return List of links between ovswitches
*/
- private static List<Link> getLinkList(){
+ private static List<Link> getLinkList() {
List<Link> linkList = new ArrayList<>();
//openflow nodes
private static int initialBridgePortCount = 3;
@Before
- public void setUp(){
+ public void setUp() {
//given
dataBroker = getDataBroker();
helper = new TopologyDataHandlerTestUtils(dataBroker);
}
@Test
- public void testBridgeAddition(){
+ public void testBridgeAddition() {
//when
helper.createTestBridge();
}
@Test
- public void testPortAddition(){
+ public void testPortAddition() {
//given
String newPortName = "br1-eth4";
Long ofPortNumber = 4L;
}
@Test
- public void testBridgeRemoval(){
+ public void testBridgeRemoval() {
//given
helper.createTestBridge();
Node ovsNode = helper.readOvsNode();
}
@Test
- public void testPortRemoval(){
+ public void testPortRemoval() {
//given
String fullPortNameToRemove = bridgeName+tp1Name;
//helper.createTestBridge();
&& ownedNep.getUuid().getValue().equals(ovs_nep_prefix + nepName)
);
- private void checkNeps(Node node,String ... neps){
+ private void checkNeps(Node node,String ... neps) {
Arrays.stream(neps)
.forEach(nep -> assertTrue(checkNep.apply(node,nep)));
}
(sips, nep) -> sips.stream()
.anyMatch(sip -> sip.getUuid().getValue().equals(sip_prefix + ovs_nep_prefix + nep));
- private void checkSips(List<ServiceInterfacePoint> sips, String ... neps){
+ private void checkSips(List<ServiceInterfacePoint> sips, String ... neps) {
Arrays.stream(neps)
.forEach(nep -> assertTrue(checkSip.apply(sips,nep)));
}
- private List<Link> getLinkList(){
+ private List<Link> getLinkList() {
List<Link> linkList = new ArrayList<>();
//For testing purposes only - can't be find anywhere else in DataStore
private final DataBroker dataBroker;
- protected TopologyDataHandlerTestUtils(DataBroker dataBroker){
+ protected TopologyDataHandlerTestUtils(DataBroker dataBroker) {
this.dataBroker = dataBroker;
}
* 2. tp2 - nep
* 3. tp3 - not nep, becouse it is connected to other switch
*/
- public void createTestBridge(){
+ public void createTestBridge() {
List<TerminationPoint> tps = new LinkedList<>();
tps.add(OvsdbTopologyTestUtils.createTerminationPoint(tp1Name,tp1OFport));
DataStoreTestUtils.write(node,instanceIdentifier,dataBroker);
}
- protected void deleteTestBridge(){
+ protected void deleteTestBridge() {
InstanceIdentifier instanceIdentifier = OvsdbTopologyTestUtils.getNodeInstanceIdentifier(new NodeId(bridgeName));
DataStoreTestUtils.delete(instanceIdentifier,dataBroker);
}
- protected void deletePort(String port){
+ protected void deletePort(String port) {
InstanceIdentifier<TerminationPoint> tpIid = OvsdbTopologyTestUtils.getPortInstanceIdentifier(bridgeName,port);
DataStoreTestUtils.delete(tpIid,dataBroker);
}
- protected void addPort(String bridgeName, String portName, Long ofNumber){
+ protected void addPort(String bridgeName, String portName, Long ofNumber) {
String bridgeId = bridgeName;
//openflow init
NodeConnector nodeConnector = OpenFlowTopologyTestUtils.createNodeConnector(ofBridgeName,ofNumber,portName);
* 2. id:"openflow:1:2", name: "br1-eth2", portNumber: "2"
* 3. id:"openflow:1:3", name: "br1-eth3", portNumber: "3"
*/
- protected void createOpenFlowNodes(){
+ protected void createOpenFlowNodes() {
NodesBuilder nodesBuilder = new NodesBuilder();
List<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeList = new ArrayList<>();
nodeList.add(createOpenFlowNode(ofBridgeName));
transaction.submit();
}
- private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node createOpenFlowNode(String oFName){
+ private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node createOpenFlowNode(String oFName) {
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder nodeBuilder =
new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder();
org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId nodeId =
return nodeBuilder.build();
}
- private NodeConnector createNodeConnector(String ofBridgeName, Long portNumber, String ovsdbPortName){
+ private NodeConnector createNodeConnector(String ofBridgeName, Long portNumber, String ovsdbPortName) {
NodeConnectorBuilder nodeConnectorBuilder = new NodeConnectorBuilder();
String ofPortName = ofBridgeName + ":" + portNumber.toString();
NodeConnectorId nodeConnectorId = new NodeConnectorId(ofPortName);
return nodeConnectorBuilder.build();
}
- private FlowCapableNodeConnector createFlowCapableNodeConnector(String ovsdbName, Long portNumber){
+ private FlowCapableNodeConnector createFlowCapableNodeConnector(String ovsdbName, Long portNumber) {
FlowCapableNodeConnectorBuilder flowCapableNodeConnectorBuilder = new FlowCapableNodeConnectorBuilder();
flowCapableNodeConnectorBuilder.setName(ovsdbName);
flowCapableNodeConnectorBuilder.setPortNumber(new PortNumberUni(portNumber));
return flowCapableNodeConnectorBuilder.build();
}
- protected void createPrestoSystemTopology(){
+ protected void createPrestoSystemTopology() {
NrpInitializer nrpInitializer = new NrpInitializer(dataBroker);
try {
nrpInitializer.init();
}
}
- protected org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.topology.rev170712.topology.Node readOvsNode(){
+ protected org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.topology.rev170712.topology.Node readOvsNode() {
return DataStoreTestUtils.read(getNodeIid(),dataBroker);
}
- protected List<org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.common.rev170712.context.attrs.ServiceInterfacePoint> readSips(){
+ protected List<org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.common.rev170712.context.attrs.ServiceInterfacePoint> readSips() {
ReadWriteTransaction readWriteTransaction = dataBroker.newReadWriteTransaction();
try {
Optional<Context> opt = readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Context.class)).checkedGet();
- if(opt.isPresent()){
+ if (opt.isPresent()) {
return opt.get().getServiceInterfacePoint();
} else {
fail("There are no sips.");
return null;
}
- private static InstanceIdentifier getNodeIid(){
+ private static InstanceIdentifier getNodeIid() {
return getTopoIid()
.child(org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.topology.rev170712.topology.Node.class,
new org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.topology.rev170712.topology.NodeKey(new Uuid(ovsNodeId)));
}
- private static InstanceIdentifier getTopoIid(){
+ private static InstanceIdentifier getTopoIid() {
return InstanceIdentifier.create(Context.class)
.augmentation(Context1.class)
.child(org.opendaylight.yang.gen.v1.urn.mef.yang.tapi.topology.rev170712.topology.context.Topology.class,
Code Review / unimgr.git / commitdiff