opendaylight/adsal/samples/loadbalancer/src/main/java/org/opendaylight/controller/samples/loadbalancer/ConfigManager.java

   1 /*
   2  * Copyright IBM Corporation, 2013.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.samples.loadbalancer;
   9
  10 import java.util.HashMap;
  11 import java.util.HashSet;
  12 import java.util.Set;
  13
  14 import org.opendaylight.controller.samples.loadbalancer.entities.Pool;
  15 import org.opendaylight.controller.samples.loadbalancer.entities.PoolMember;
  16 import org.opendaylight.controller.samples.loadbalancer.entities.VIP;
  17 import org.slf4j.Logger;
  18 import org.slf4j.LoggerFactory;
  19
  20 /**
  21  * This class represents a configuration manager for the Load Balancer service.
  22  * This class is responsible for managing(store/update/delete) the load balancer
  23  * configuration that it receives through REST APIs or from any other applications
  24  * present in the controller.
  25  *
  26  */
  27 public class ConfigManager implements IConfigManager{
  28
  29     /*
  30      * Logger instance
  31      */
  32     private static final Logger cmLogger = LoggerFactory.getLogger(ConfigManager.class);
  33
  34     /*
  35      * All the available VIPs
  36      */
  37     private HashMap<String,VIP> vips = new HashMap<String,VIP>();
  38
  39     /*
  40      * All the available Pools
  41      */
  42     private HashMap<String,Pool> pools = new HashMap<String,Pool>();
  43
  44     public ConfigManager(){
  45     }
  46
  47     @Override
  48     public boolean vipExists(String name) {
  49         return this.vips.containsKey(name);
  50     }
  51
  52     @Override
  53     public boolean vipExists(VIP vip){
  54         if(vip.getName()==null){
  55             if(!vips.containsValue(vip)){
  56                 return false;
  57             }
  58         }else{
  59             if(!vips.containsKey(vip.getName())){
  60                 if(!vips.containsValue(vip)){
  61                     return false;
  62                 }
  63             }
  64         }
  65         return true;
  66     }
  67
  68     @Override
  69     public boolean vipExists(String name,String ip,String protocol,short protocolPort,String poolName){
  70
  71         VIP vip = new VIP(name,ip,protocol,protocolPort,poolName);
  72
  73         //Check VIP with the same name
  74
  75         if(!vips.containsKey(name)){
  76             //Check VIP with the same ip, protocol and protocolPort
  77             if(!vips.containsValue(vip)){
  78
  79                 //if you reach here, means this VIP don't exist
  80                 return false;
  81             }
  82         }
  83
  84         //Yeah, i have it.
  85         return true;
  86     }
  87
  88     @Override
  89     public Set<VIP> getAllVIPs(){
  90         return new HashSet<VIP>(this.vips.values());
  91     }
  92
  93     public VIP getVIPWithPoolName(VIP vip){
  94         cmLogger.trace("Search a VIP with name:{}",vip);
  95         for(VIP vipTemp: this.vips.values()){
  96             if(vipTemp.equals(vip)){
  97
  98                 cmLogger.trace("Found VIP with pool detail : {}",vipTemp);
  99                 return vipTemp;
 100             }
 101         }
 102
 103         cmLogger.trace("VIP with pool detail not found ");
 104         return null;
 105     }
 106
 107     @Override
 108     public VIP createVIP(String name,String ip,String protocol,short protocolPort,String poolName){
 109
 110         cmLogger.trace("Create VIP with the following details :[ name : "+name
 111                                                                     +" ip : "+ip
 112                                                                     +" protocol : "+protocol
 113                                                                     +" protocol_port : "+protocolPort
 114                                                                     +" pool name : "+poolName);
 115
 116         VIP vip = new VIP(name,ip,protocol,protocolPort,poolName);
 117
 118         if(poolName !=null && !poolName.isEmpty()){
 119             if(pools.containsKey(poolName)){
 120                 pools.get(poolName).addVIP(vip);
 121             }
 122         }
 123
 124         vip.setStatus(LBConst.STATUS_ACTIVE);
 125         this.vips.put(name, vip);
 126
 127         cmLogger.trace("New VIP created : "+vip.toString());
 128         return vip;
 129     }
 130
 131     @Override
 132     public String getVIPAttachedPool(String name) {
 133         return this.vips.get(name).getPoolName();
 134     }
 135
 136     @Override
 137     public VIP updateVIP(String name, String poolName){
 138
 139         cmLogger.trace("Updating VIP : "+name+" pool name  to "+poolName);
 140
 141         if(vips.containsKey(name)){
 142             VIP vip = vips.get(name);
 143             if(vip.getPoolName() == null){
 144                 vip.setPoolName(poolName);
 145                 cmLogger.error("VIP is now attached to the pool : {}",vip.toString());
 146                 return vip;
 147             }
 148             cmLogger.error("VIP is already attached to one pool : {}",vip.toString());
 149         }
 150         cmLogger.error("VIP with name: "+name+" does not exist");
 151         return null;
 152     }
 153
 154     @Override
 155     public VIP deleteVIP(String name){
 156
 157         cmLogger.trace("Deleting VIP : "+name);
 158
 159         VIP vip = vips.get(name);
 160
 161         String poolName = vip.getPoolName();
 162
 163         if(poolName != null){
 164             if(pools.containsKey(poolName)){
 165                 Pool pool = pools.get(poolName);
 166                 pool.removeVIP(vip.getName());
 167             }
 168         }
 169
 170         cmLogger.trace("VIP removed : "+vip.toString());
 171
 172         vips.remove(vip.getName());
 173
 174         return vip;
 175     }
 176
 177     @Override
 178     public boolean memberExists(String name, String poolName) {
 179         if (this.pools.containsKey(poolName)) {
 180             if (this.pools.get(poolName).getMember(name) != null) {
 181                 return true;
 182             }
 183         }
 184         return false;
 185     }
 186
 187     @Override
 188     public boolean memberExists(String name, String memberIP,String poolName) {
 189         if (!this.pools.containsKey(poolName)) {
 190             return false;
 191         }
 192
 193         return this.pools.get(poolName).poolMemberExists(new PoolMember(name, memberIP, poolName));
 194     }
 195
 196     @Override
 197     public PoolMember addPoolMember(String name, String memberIP, String poolName){
 198
 199         PoolMember pm = new PoolMember(name,memberIP,poolName);
 200
 201         cmLogger.trace("Adding pool member : "+pm.toString());
 202
 203         pools.get(poolName).addMember(pm);
 204
 205         return pm;
 206     }
 207
 208     @Override
 209     public PoolMember removePoolMember(String name, String poolName){
 210
 211         cmLogger.trace("Removing pool member : {} from pool {}",name, poolName);
 212
 213         Pool pool = pools.get(poolName);
 214
 215         PoolMember pm = pool.getMember(name);
 216
 217         pool.removeMember(name);
 218
 219         cmLogger.trace("Pool member {} removed from {} ",name,poolName);
 220
 221         return pm;
 222     }
 223
 224     @Override
 225     public Set<Pool> getAllPools(){
 226         return new HashSet<Pool>(this.pools.values());
 227     }
 228
 229     @Override
 230     public boolean poolExists(String name) {
 231         return this.pools.containsKey(name);
 232     }
 233
 234     @Override
 235     public boolean poolExists(String name, String lbMethod){
 236
 237         return pools.containsValue(new Pool(name,lbMethod));
 238     }
 239
 240     @Override
 241     public Pool createPool(String name, String lbMethod){
 242
 243         Pool newPool = new Pool(name,lbMethod);
 244
 245         cmLogger.trace("New pool created : " + newPool.toString());
 246
 247         pools.put(name, newPool);
 248
 249         return newPool;
 250     }
 251
 252     @Override
 253     public Pool deletePool(String poolName){
 254
 255         Pool pool = pools.get(poolName);
 256
 257         for(VIP vip:pool.getAllVip()){
 258
 259             vip.setPoolName(null);
 260
 261         }
 262
 263         cmLogger.trace("Pool removed : "+pool.toString());
 264
 265         pools.remove(poolName);
 266
 267         return pool;
 268     }
 269
 270     @Override
 271     public Pool getPool( String poolName){
 272         if(pools.containsKey(poolName)){
 273             return pools.get(poolName);
 274         }
 275         return null;
 276     }
 277
 278     @Override
 279     public Set<PoolMember> getAllPoolMembers(String poolName) {
 280
 281         if(pools.containsKey(poolName)){
 282             return new HashSet<PoolMember>(pools.get(poolName).getAllMembers());
 283         }
 284         return null;
 285     }
 286
 287     /* (non-Javadoc)
 288      * @see java.lang.Object#toString()
 289      */
 290     @Override
 291     public String toString() {
 292         return "ConfigManager [vips=" + vips + ", pools=" + pools + "]";
 293     }
 294 }