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         return false;
 184     }
 185
 186     @Override
 187     public boolean memberExists(String name, String memberIP,String poolName){
 188         if(!this.pools.containsKey(poolName))
 189             return false;
 190
 191         return this.pools.get(poolName).poolMemberExists(new PoolMember(name, memberIP, poolName));
 192     }
 193
 194     @Override
 195     public PoolMember addPoolMember(String name, String memberIP, String poolName){
 196
 197         PoolMember pm = new PoolMember(name,memberIP,poolName);
 198
 199         cmLogger.trace("Adding pool member : "+pm.toString());
 200
 201         pools.get(poolName).addMember(pm);
 202
 203         return pm;
 204     }
 205
 206     @Override
 207     public PoolMember removePoolMember(String name, String poolName){
 208
 209         cmLogger.trace("Removing pool member : {} from pool {}",name, poolName);
 210
 211         Pool pool = pools.get(poolName);
 212
 213         PoolMember pm = pool.getMember(name);
 214
 215         pool.removeMember(name);
 216
 217         cmLogger.trace("Pool member {} removed from {} ",name,poolName);
 218
 219         return pm;
 220     }
 221
 222     @Override
 223     public Set<Pool> getAllPools(){
 224         return new HashSet<Pool>(this.pools.values());
 225     }
 226
 227     @Override
 228     public boolean poolExists(String name) {
 229         return this.pools.containsKey(name);
 230     }
 231
 232     @Override
 233     public boolean poolExists(String name, String lbMethod){
 234
 235         return pools.containsValue(new Pool(name,lbMethod));
 236     }
 237
 238     @Override
 239     public Pool createPool(String name, String lbMethod){
 240
 241         Pool newPool = new Pool(name,lbMethod);
 242
 243         cmLogger.trace("New pool created : " + newPool.toString());
 244
 245         pools.put(name, newPool);
 246
 247         return newPool;
 248     }
 249
 250     @Override
 251     public Pool deletePool(String poolName){
 252
 253         Pool pool = pools.get(poolName);
 254
 255         for(VIP vip:pool.getAllVip()){
 256
 257             vip.setPoolName(null);
 258
 259         }
 260
 261         cmLogger.trace("Pool removed : "+pool.toString());
 262
 263         pools.remove(poolName);
 264
 265         return pool;
 266     }
 267
 268     @Override
 269     public Pool getPool( String poolName){
 270         if(pools.containsKey(poolName)){
 271             return pools.get(poolName);
 272         }
 273         return null;
 274     }
 275
 276     @Override
 277     public Set<PoolMember> getAllPoolMembers(String poolName) {
 278
 279         if(pools.containsKey(poolName)){
 280             return new HashSet<PoolMember>(pools.get(poolName).getAllMembers());
 281         }
 282         return null;
 283     }
 284
 285     /* (non-Javadoc)
 286      * @see java.lang.Object#toString()
 287      */
 288     @Override
 289     public String toString() {
 290         return "ConfigManager [vips=" + vips + ", pools=" + pools + "]";
 291     }
 292 }