sdx-l2/src/main/java/org/onosproject/sdxl2/SdxL2DistributedStore.java - onos-app-samples - Gitiles

 /*
  * Copyright 2016-present Open Networking Laboratory
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.onosproject.sdxl2;

 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Sets;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.apache.felix.scr.annotations.Service;
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Deactivate;
 import org.onlab.packet.VlanId;
 import org.onlab.util.KryoNamespace;
 import org.onosproject.store.primitives.DefaultDistributedSet;
 import org.onosproject.store.serializers.KryoNamespaces;
 import org.onosproject.store.service.ConsistentMap;
 import org.onosproject.store.service.DistributedPrimitive;
 import org.onosproject.store.service.Serializer;
 import org.onosproject.store.service.StorageService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;


 /**
  * SDX-L2 Store implementation backed by different distributed primitives.
  */
 @Component(immediate = true)
 @Service
 public class SdxL2DistributedStore implements SdxL2Store {

     private static Logger log = LoggerFactory.getLogger(SdxL2DistributedStore.class);

     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     private StorageService storageService;

     private Set<String> sdxL2s;

     private Map<SdxL2ConnectionPoint, String> sdxL2CPs;
     private ConsistentMap<SdxL2ConnectionPoint, String> sdxL2cps;

     private static String errorAddSdx = "It is not possible to add %s " +
             "because it exists";

     private static String errorRemoveSdx = "It is not possible to remove %s " +
             "because it does not exist";

     private static String errorAddSdxL2CPName = "It is not possible to add %s " +
             "because there is a sdxl2cp with the same name";
     private static String errorAddSdxL2CPVlans = "It is not possible to add %s " +
             "because there is a conflict with %s on the vlan ids";
     private static String errorAddSdxL2CPCP = "It is not possible to add %s " +
             "because there is a conflict with %s on the connection point";
     private static String errorAddSdxL2CPSdx = "It is not possible to add %s " +
             "because the relative sdxl2 does not exist";

     private static String errorGetSdxL2CPs = "It is not possible to list the sdxl2cps " +
             "because sdxl2 %s does not exist";

     private static String errorRemoveSdxL2CP = "It is not possible to remove %s " +
             "because it does not exist";

     private static String errorGetSdxL2CP = "It is not possible to retrieve %s " +
             "because it does not exist";

     public void initForTest() {

         this.sdxL2s = Sets.newHashSet();

         this.sdxL2CPs = new ConcurrentHashMap<SdxL2ConnectionPoint, String>();

     }

     @Activate
     public void activate() {

         KryoNamespace custom = KryoNamespace.newBuilder()
                 .register(KryoNamespaces.API)
                 .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
                 .register(new SdxL2ConnectionPointSerializer(), new Class[]{SdxL2ConnectionPoint.class})
                 .build();

         sdxL2s = new DefaultDistributedSet<>(this.storageService
                 .<String>setBuilder()
                 .withSerializer(Serializer.using(custom))
                 .withName("sdxl2s")
                 .build(), DistributedPrimitive.DEFAULT_OPERTATION_TIMEOUT_MILLIS);

         sdxL2cps = this.storageService
                 .<SdxL2ConnectionPoint, String>consistentMapBuilder()
                 .withSerializer(Serializer.using(custom))
                 .withName("sdxl2cps")
                 .build();
         sdxL2CPs = sdxL2cps.asJavaMap();

         log.info("Started");
     }

     @Deactivate
     public void deactivate() {
         log.info("Stopped");
     }

     /**
      * Creates a named SDX-L2.
      *
      * @param sdxl2 SDX-L2 name
      * @throws SdxL2Exception if SDX-L2 exists
      */
     @Override
     public void putSdxL2(String sdxl2) throws SdxL2Exception {
         boolean inserted = sdxL2s.add(sdxl2);
         if (!inserted) {
             throw new SdxL2Exception(String.format(errorAddSdx, sdxl2));
         }
     }

     /**
      * Removes a named SDX-L2.
      *
      * @param sdxl2 SDX-L2 name
      * @throws SdxL2Exception if SDX-L2 does not exist
      */
     @Override
     public void removeSdxL2(String sdxl2) throws SdxL2Exception {
         boolean removed = sdxL2s.remove(sdxl2);
         if (!removed) {
             throw new SdxL2Exception(String.format(errorRemoveSdx, sdxl2));
         }

         Set<Map.Entry<SdxL2ConnectionPoint, String>> toRemove = sdxL2CPs.entrySet().parallelStream().filter(
                 key_value -> {
                     String sdxl2Temp = key_value.getValue();
                     return sdxl2Temp.equals(sdxl2) ? true : false;
                 }).collect(Collectors.toSet());
         toRemove.forEach(key_value -> sdxL2CPs.remove(key_value.getKey()));
     }

     /**
      * Returns a set of SDX-L2 names.
      *
      * @return a set of SDX-L2 names
      */
     @Override
     public Set<String> getSdxL2s() {
         return ImmutableSet.copyOf(sdxL2s);
     }

     /**
      * Adds an SDX-L2 connection point to an SDX-L2.
      *
      * @param sdxl2 SDX-L2 name
      * @param connectionPoint the connection point object
      * @throws SdxL2Exception if it is not possible to add the SDX-L2 connection point
      */
     @Override
     public void addSdxL2ConnectionPoint(String sdxl2, SdxL2ConnectionPoint connectionPoint) throws SdxL2Exception {

         boolean exist = sdxL2s.contains(sdxl2);

         if (!exist) {
             throw new SdxL2Exception(String.format(errorAddSdxL2CPSdx, connectionPoint.name()));
         }

         Set<SdxL2ConnectionPoint> sdxl2cpsTemp = ImmutableSet.copyOf(sdxL2CPs.keySet());
         Set<SdxL2ConnectionPoint> sdxl2cpsTempByName = sdxl2cpsTemp.parallelStream().filter(
                 sdxl2cpTemp-> sdxl2cpTemp.name().equals(connectionPoint.name()
                 )
         ).collect(Collectors.toSet());

         if (sdxl2cpsTempByName.size() != 0) {
             throw new SdxL2Exception(String.format(errorAddSdxL2CPName, connectionPoint.name()));
         }


         Set<SdxL2ConnectionPoint> sdxl2cpsByCP = sdxl2cpsTemp.parallelStream().filter(
                 sdxl2cp_temp-> sdxl2cp_temp.connectPoint().equals(connectionPoint.connectPoint()
                 )
         ).collect(Collectors.toSet());

         String tempName;
         List<VlanId> vlans = connectionPoint.vlanIds();
         for (VlanId vlanId : vlans) {
             Set<SdxL2ConnectionPoint> sdxl2cpsByVlan = sdxl2cpsByCP.parallelStream().filter(
                     sdxl2cp_by_vlan -> (
                             sdxl2cp_by_vlan.vlanIds().contains(vlanId) || sdxl2cp_by_vlan.vlanIds().size() == 0
                     )).collect(Collectors.toSet());

             tempName =  sdxl2cpsByVlan.iterator().hasNext() ?  sdxl2cpsByVlan.iterator().next().name() : null;

             if (sdxl2cpsByVlan.size() != 0) {
                 throw new SdxL2Exception(String.format(errorAddSdxL2CPVlans, connectionPoint.name(), tempName));
             }

         }

         tempName =  sdxl2cpsByCP.iterator().hasNext() ? sdxl2cpsByCP.iterator().next().name() : null;

         if (sdxl2cpsByCP.size() != 0 && vlans.size() == 0) {
             throw new SdxL2Exception(String.format(errorAddSdxL2CPCP, connectionPoint.name(), tempName));
         }

         sdxL2CPs.put(connectionPoint, sdxl2);

     }

     /**
      * Returns all the SDX-L2 connection points names or the SDX-L2 2connection points names
      * that are related to an SDX-L2.
      *
      * @param sdxl2 name (optional) of the SDX-L2
      * @return a set of SDX-L2 connection points names, the result depends on the input parameter;
      * @throws SdxL2Exception if SDX-L2 is present but it does not exist
      */
     @Override
     public Set<String> getSdxL2ConnectionPoints(Optional<String> sdxl2) throws SdxL2Exception {

         if (sdxl2.isPresent()) {

             Set<Map.Entry<SdxL2ConnectionPoint, String>> toGet = sdxL2CPs.entrySet().parallelStream().filter(
                     key_value -> {
                         String sdxl2Temp = key_value.getValue();
                         return sdxl2Temp.equals(sdxl2.get()) ? true : false;
                     }).collect(Collectors.toSet());

             Iterator<String> itsdxL2s = sdxL2s.iterator();
             boolean found = false;
             while (itsdxL2s.hasNext()) {
                 if (sdxl2.get().equals(itsdxL2s.next())) {
                     found = true;
                 }
             }

             if (!found) {
                 throw new SdxL2Exception(String.format(errorGetSdxL2CPs, sdxl2.get()));
             }

             Set<String> cpsTemp = Sets.newHashSet();
             for (Map.Entry<SdxL2ConnectionPoint, String> cp : toGet) {
                 cpsTemp.add(cp.getKey().name());
             }

             return cpsTemp;
         }

         return ImmutableSet.copyOf(sdxL2CPs.keySet()).parallelStream().map(
                 SdxL2ConnectionPoint::name).collect(Collectors.toSet());

     }

     /**
      * Removes a named SDX-L2 connection point in an SDX-L2.
      *
      * @param sdxl2cp the connection point name
      * @throws SdxL2Exception if SDX-L2 connection point does not exist
      */
     @Override
     public void removeSdxL2ConnectionPoint(String sdxl2cp) throws SdxL2Exception {

         Set<SdxL2ConnectionPoint> sdxl2cpsTemp = ImmutableSet.copyOf(sdxL2CPs.keySet());
         Set<SdxL2ConnectionPoint> sdxl2cpsTempByName = sdxl2cpsTemp.parallelStream().filter(
                 sdxl2cpTemp -> sdxl2cpTemp.name().equals(sdxl2cp
                 )
         ).collect(Collectors.toSet());

         if (sdxl2cpsTempByName.size() == 0) {
             throw new SdxL2Exception(String.format(errorRemoveSdxL2CP, sdxl2cp));
         }

         for (SdxL2ConnectionPoint sdxl2cpTemp : sdxl2cpsTempByName) {
             sdxL2CPs.remove(sdxl2cpTemp);
         }

     }

     /**
      * Returns an SDX-L2 connection point in a SDX-L2.
      *
      * @param sdxl2cp the connection point name
      * @return the relative SDXL2ConnectionPoint object
      * @throws SdxL2Exception if SDX-L2 connection point does not exist
      */
     @Override
     public SdxL2ConnectionPoint getSdxL2ConnectionPoint(String sdxl2cp) throws SdxL2Exception {
         SdxL2ConnectionPoint sdxl2cpTemp = ImmutableSet.copyOf(sdxL2CPs.keySet()).parallelStream()
                 .filter(sdxl2cp_temp -> sdxl2cp_temp.name().equals(sdxl2cp)).findFirst().orElse(null);

         if (sdxl2cpTemp == null) {
             throw new SdxL2Exception(String.format(errorGetSdxL2CP, sdxl2cp));
         }

         return sdxl2cpTemp;
     }

 }
	/*
	* Copyright 2016-present Open Networking Laboratory
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.onosproject.sdxl2;

	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Sets;
	import org.apache.felix.scr.annotations.Component;
	import org.apache.felix.scr.annotations.Reference;
	import org.apache.felix.scr.annotations.ReferenceCardinality;
	import org.apache.felix.scr.annotations.Service;
	import org.apache.felix.scr.annotations.Activate;
	import org.apache.felix.scr.annotations.Deactivate;
	import org.onlab.packet.VlanId;
	import org.onlab.util.KryoNamespace;
	import org.onosproject.store.primitives.DefaultDistributedSet;
	import org.onosproject.store.serializers.KryoNamespaces;
	import org.onosproject.store.service.ConsistentMap;
	import org.onosproject.store.service.DistributedPrimitive;
	import org.onosproject.store.service.Serializer;
	import org.onosproject.store.service.StorageService;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.Set;
	import java.util.Iterator;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.stream.Collectors;


	/**
	* SDX-L2 Store implementation backed by different distributed primitives.
	*/
	@Component(immediate = true)
	@Service
	public class SdxL2DistributedStore implements SdxL2Store {

	private static Logger log = LoggerFactory.getLogger(SdxL2DistributedStore.class);

	@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
	private StorageService storageService;

	private Set<String> sdxL2s;

	private Map<SdxL2ConnectionPoint, String> sdxL2CPs;
	private ConsistentMap<SdxL2ConnectionPoint, String> sdxL2cps;

	private static String errorAddSdx = "It is not possible to add %s " +
	"because it exists";

	private static String errorRemoveSdx = "It is not possible to remove %s " +
	"because it does not exist";

	private static String errorAddSdxL2CPName = "It is not possible to add %s " +
	"because there is a sdxl2cp with the same name";
	private static String errorAddSdxL2CPVlans = "It is not possible to add %s " +
	"because there is a conflict with %s on the vlan ids";
	private static String errorAddSdxL2CPCP = "It is not possible to add %s " +
	"because there is a conflict with %s on the connection point";
	private static String errorAddSdxL2CPSdx = "It is not possible to add %s " +
	"because the relative sdxl2 does not exist";

	private static String errorGetSdxL2CPs = "It is not possible to list the sdxl2cps " +
	"because sdxl2 %s does not exist";

	private static String errorRemoveSdxL2CP = "It is not possible to remove %s " +
	"because it does not exist";

	private static String errorGetSdxL2CP = "It is not possible to retrieve %s " +
	"because it does not exist";

	public void initForTest() {

	this.sdxL2s = Sets.newHashSet();

	this.sdxL2CPs = new ConcurrentHashMap<SdxL2ConnectionPoint, String>();

	}

	@Activate
	public void activate() {

	KryoNamespace custom = KryoNamespace.newBuilder()
	.register(KryoNamespaces.API)
	.nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
	.register(new SdxL2ConnectionPointSerializer(), new Class[]{SdxL2ConnectionPoint.class})
	.build();

	sdxL2s = new DefaultDistributedSet<>(this.storageService
	.<String>setBuilder()
	.withSerializer(Serializer.using(custom))
	.withName("sdxl2s")
	.build(), DistributedPrimitive.DEFAULT_OPERTATION_TIMEOUT_MILLIS);

	sdxL2cps = this.storageService
	.<SdxL2ConnectionPoint, String>consistentMapBuilder()
	.withSerializer(Serializer.using(custom))
	.withName("sdxl2cps")
	.build();
	sdxL2CPs = sdxL2cps.asJavaMap();

	log.info("Started");
	}

	@Deactivate
	public void deactivate() {
	log.info("Stopped");
	}

	/**
	* Creates a named SDX-L2.
	*
	* @param sdxl2 SDX-L2 name
	* @throws SdxL2Exception if SDX-L2 exists
	*/
	@Override
	public void putSdxL2(String sdxl2) throws SdxL2Exception {
	boolean inserted = sdxL2s.add(sdxl2);
	if (!inserted) {
	throw new SdxL2Exception(String.format(errorAddSdx, sdxl2));
	}
	}

	/**
	* Removes a named SDX-L2.
	*
	* @param sdxl2 SDX-L2 name
	* @throws SdxL2Exception if SDX-L2 does not exist
	*/
	@Override
	public void removeSdxL2(String sdxl2) throws SdxL2Exception {
	boolean removed = sdxL2s.remove(sdxl2);
	if (!removed) {
	throw new SdxL2Exception(String.format(errorRemoveSdx, sdxl2));
	}

	Set<Map.Entry<SdxL2ConnectionPoint, String>> toRemove = sdxL2CPs.entrySet().parallelStream().filter(
	key_value -> {
	String sdxl2Temp = key_value.getValue();
	return sdxl2Temp.equals(sdxl2) ? true : false;
	}).collect(Collectors.toSet());
	toRemove.forEach(key_value -> sdxL2CPs.remove(key_value.getKey()));
	}

	/**
	* Returns a set of SDX-L2 names.
	*
	* @return a set of SDX-L2 names
	*/
	@Override
	public Set<String> getSdxL2s() {
	return ImmutableSet.copyOf(sdxL2s);
	}

	/**
	* Adds an SDX-L2 connection point to an SDX-L2.
	*
	* @param sdxl2 SDX-L2 name
	* @param connectionPoint the connection point object
	* @throws SdxL2Exception if it is not possible to add the SDX-L2 connection point
	*/
	@Override
	public void addSdxL2ConnectionPoint(String sdxl2, SdxL2ConnectionPoint connectionPoint) throws SdxL2Exception {

	boolean exist = sdxL2s.contains(sdxl2);

	if (!exist) {
	throw new SdxL2Exception(String.format(errorAddSdxL2CPSdx, connectionPoint.name()));
	}

	Set<SdxL2ConnectionPoint> sdxl2cpsTemp = ImmutableSet.copyOf(sdxL2CPs.keySet());
	Set<SdxL2ConnectionPoint> sdxl2cpsTempByName = sdxl2cpsTemp.parallelStream().filter(
	sdxl2cpTemp-> sdxl2cpTemp.name().equals(connectionPoint.name()
	)
	).collect(Collectors.toSet());

	if (sdxl2cpsTempByName.size() != 0) {
	throw new SdxL2Exception(String.format(errorAddSdxL2CPName, connectionPoint.name()));
	}


	Set<SdxL2ConnectionPoint> sdxl2cpsByCP = sdxl2cpsTemp.parallelStream().filter(
	sdxl2cp_temp-> sdxl2cp_temp.connectPoint().equals(connectionPoint.connectPoint()
	)
	).collect(Collectors.toSet());

	String tempName;
	List<VlanId> vlans = connectionPoint.vlanIds();
	for (VlanId vlanId : vlans) {
	Set<SdxL2ConnectionPoint> sdxl2cpsByVlan = sdxl2cpsByCP.parallelStream().filter(
	sdxl2cp_by_vlan -> (
	sdxl2cp_by_vlan.vlanIds().contains(vlanId) \|\| sdxl2cp_by_vlan.vlanIds().size() == 0
	)).collect(Collectors.toSet());

	tempName = sdxl2cpsByVlan.iterator().hasNext() ? sdxl2cpsByVlan.iterator().next().name() : null;

	if (sdxl2cpsByVlan.size() != 0) {
	throw new SdxL2Exception(String.format(errorAddSdxL2CPVlans, connectionPoint.name(), tempName));
	}

	}

	tempName = sdxl2cpsByCP.iterator().hasNext() ? sdxl2cpsByCP.iterator().next().name() : null;

	if (sdxl2cpsByCP.size() != 0 && vlans.size() == 0) {
	throw new SdxL2Exception(String.format(errorAddSdxL2CPCP, connectionPoint.name(), tempName));
	}

	sdxL2CPs.put(connectionPoint, sdxl2);

	}

	/**
	* Returns all the SDX-L2 connection points names or the SDX-L2 2connection points names
	* that are related to an SDX-L2.
	*
	* @param sdxl2 name (optional) of the SDX-L2
	* @return a set of SDX-L2 connection points names, the result depends on the input parameter;
	* @throws SdxL2Exception if SDX-L2 is present but it does not exist
	*/
	@Override
	public Set<String> getSdxL2ConnectionPoints(Optional<String> sdxl2) throws SdxL2Exception {

	if (sdxl2.isPresent()) {

	Set<Map.Entry<SdxL2ConnectionPoint, String>> toGet = sdxL2CPs.entrySet().parallelStream().filter(
	key_value -> {
	String sdxl2Temp = key_value.getValue();
	return sdxl2Temp.equals(sdxl2.get()) ? true : false;
	}).collect(Collectors.toSet());

	Iterator<String> itsdxL2s = sdxL2s.iterator();
	boolean found = false;
	while (itsdxL2s.hasNext()) {
	if (sdxl2.get().equals(itsdxL2s.next())) {
	found = true;
	}
	}

	if (!found) {
	throw new SdxL2Exception(String.format(errorGetSdxL2CPs, sdxl2.get()));
	}

	Set<String> cpsTemp = Sets.newHashSet();
	for (Map.Entry<SdxL2ConnectionPoint, String> cp : toGet) {
	cpsTemp.add(cp.getKey().name());
	}

	return cpsTemp;
	}

	return ImmutableSet.copyOf(sdxL2CPs.keySet()).parallelStream().map(
	SdxL2ConnectionPoint::name).collect(Collectors.toSet());

	}

	/**
	* Removes a named SDX-L2 connection point in an SDX-L2.
	*
	* @param sdxl2cp the connection point name
	* @throws SdxL2Exception if SDX-L2 connection point does not exist
	*/
	@Override
	public void removeSdxL2ConnectionPoint(String sdxl2cp) throws SdxL2Exception {

	Set<SdxL2ConnectionPoint> sdxl2cpsTemp = ImmutableSet.copyOf(sdxL2CPs.keySet());
	Set<SdxL2ConnectionPoint> sdxl2cpsTempByName = sdxl2cpsTemp.parallelStream().filter(
	sdxl2cpTemp -> sdxl2cpTemp.name().equals(sdxl2cp
	)
	).collect(Collectors.toSet());

	if (sdxl2cpsTempByName.size() == 0) {
	throw new SdxL2Exception(String.format(errorRemoveSdxL2CP, sdxl2cp));
	}

	for (SdxL2ConnectionPoint sdxl2cpTemp : sdxl2cpsTempByName) {
	sdxL2CPs.remove(sdxl2cpTemp);
	}

	}

	/**
	* Returns an SDX-L2 connection point in a SDX-L2.
	*
	* @param sdxl2cp the connection point name
	* @return the relative SDXL2ConnectionPoint object
	* @throws SdxL2Exception if SDX-L2 connection point does not exist
	*/
	@Override
	public SdxL2ConnectionPoint getSdxL2ConnectionPoint(String sdxl2cp) throws SdxL2Exception {
	SdxL2ConnectionPoint sdxl2cpTemp = ImmutableSet.copyOf(sdxL2CPs.keySet()).parallelStream()
	.filter(sdxl2cp_temp -> sdxl2cp_temp.name().equals(sdxl2cp)).findFirst().orElse(null);

	if (sdxl2cpTemp == null) {
	throw new SdxL2Exception(String.format(errorGetSdxL2CP, sdxl2cp));
	}

	return sdxl2cpTemp;
	}

	}