gerrit.opnfv Code Review - onosfw.git/blob

   1 package org.onosproject.provider.pcep.tunnel.impl;
   2
   3 import java.util.Collection;
   4 import java.util.Collections;
   5 import java.util.HashSet;
   6 import java.util.Set;
   7 import java.util.concurrent.ConcurrentHashMap;
   8
   9 import org.apache.felix.scr.annotations.Activate;
  10 import org.apache.felix.scr.annotations.Deactivate;
  11 import org.onlab.packet.IpAddress;
  12 import org.onosproject.pcep.controller.PccId;
  13 import org.onosproject.pcep.controller.PcepClient;
  14 import org.onosproject.pcep.controller.PcepClientController;
  15 import org.onosproject.pcep.controller.PcepClientListener;
  16 import org.onosproject.pcep.controller.PcepEventListener;
  17 import org.onosproject.pcep.controller.driver.PcepAgent;
  18 import org.onosproject.pcepio.protocol.PcepMessage;
  19 import org.onosproject.pcepio.protocol.PcepVersion;
  20
  21 import com.google.common.collect.Sets;
  22
  23 public class PcepClientControllerAdapter implements PcepClientController {
  24
  25     protected ConcurrentHashMap<PccId, PcepClient> connectedClients =
  26             new ConcurrentHashMap<PccId, PcepClient>();
  27
  28     protected PcepClientAgent agent = new PcepClientAgent();
  29     protected Set<PcepClientListener> pcepClientListener = new HashSet<>();
  30
  31     protected Set<PcepEventListener> pcepEventListener = Sets.newHashSet();
  32
  33     @Activate
  34     public void activate() {
  35     }
  36
  37     @Deactivate
  38     public void deactivate() {
  39     }
  40
  41     @Override
  42     public Collection<PcepClient> getClients() {
  43         return connectedClients.values();
  44     }
  45
  46     @Override
  47     public PcepClient getClient(PccId pccId) {
  48         //return connectedClients.get(pccIpAddress);
  49         PcepClientAdapter pc = new PcepClientAdapter();
  50         pc.init(PccId.pccId(IpAddress.valueOf(0xac000001)), PcepVersion.PCEP_1);
  51         return pc;
  52     }
  53
  54     @Override
  55     public void addListener(PcepClientListener listener) {
  56         if (!pcepClientListener.contains(listener)) {
  57             this.pcepClientListener.add(listener);
  58         }
  59     }
  60
  61     @Override
  62     public void removeListener(PcepClientListener listener) {
  63         this.pcepClientListener.remove(listener);
  64     }
  65
  66     @Override
  67     public void addEventListener(PcepEventListener listener) {
  68         pcepEventListener.add(listener);
  69     }
  70
  71     @Override
  72     public void removeEventListener(PcepEventListener listener) {
  73         pcepEventListener.remove(listener);
  74     }
  75
  76     @Override
  77     public void writeMessage(PccId pccId, PcepMessage msg) {
  78         this.getClient(pccId).sendMessage(msg);
  79     }
  80
  81     @Override
  82     public void processClientMessage(PccId pccId, PcepMessage msg) {
  83
  84         PcepClient pc = getClient(pccId);
  85
  86         switch (msg.getType()) {
  87         case NONE:
  88             break;
  89         case OPEN:
  90             break;
  91         case KEEP_ALIVE:
  92             //log.debug("Sending Keep Alive Message  to {" + pccIpAddress.toString() + "}");
  93             pc.sendMessage(Collections.singletonList(pc.factory().buildKeepaliveMsg().build()));
  94             break;
  95         case PATH_COMPUTATION_REQUEST:
  96             break;
  97         case PATH_COMPUTATION_REPLY:
  98             break;
  99         case NOTIFICATION:
 100             break;
 101         case ERROR:
 102             break;
 103         case CLOSE:
 104             //log.debug("Sending Close Message  to { }", pccIpAddress.toString());
 105             pc.sendMessage(Collections.singletonList(pc.factory().buildCloseMsg().build()));
 106             break;
 107         case REPORT:
 108             for (PcepEventListener l : pcepEventListener) {
 109                 l.handleMessage(pccId, msg);
 110             }
 111             break;
 112         case UPDATE:
 113             for (PcepEventListener l : pcepEventListener) {
 114                 l.handleMessage(pccId, msg);
 115             }
 116             break;
 117         case INITIATE:
 118             for (PcepEventListener l : pcepEventListener) {
 119                 l.handleMessage(pccId, msg);
 120             }
 121             break;
 122         case LABEL_UPDATE:
 123             break;
 124         case MAX:
 125             break;
 126         case END:
 127             break;
 128         default:
 129             break;
 130         }
 131     }
 132
 133     @Override
 134     public void closeConnectedClients() {
 135         PcepClient pc;
 136         for (PccId id : connectedClients.keySet()) {
 137             pc = getClient(id);
 138             pc.disconnectClient();
 139         }
 140     }
 141
 142     /**
 143      * Implementation of an Pcep Agent which is responsible for
 144      * keeping track of connected clients and the state in which
 145      * they are.
 146      */
 147     public class PcepClientAgent implements PcepAgent {
 148
 149         @Override
 150         public boolean addConnectedClient(PccId pccId, PcepClient pc) {
 151
 152             if (connectedClients.get(pccId) != null) {
 153                 return false;
 154             } else {
 155                 connectedClients.put(pccId, pc);
 156                 for (PcepClientListener l : pcepClientListener) {
 157                     l.clientConnected(pccId);
 158                 }
 159                 return true;
 160             }
 161         }
 162
 163         @Override
 164         public boolean validActivation(PccId pccId) {
 165             if (connectedClients.get(pccId) == null) {
 166                 //log.error("Trying to activate client but is not in "
 167                 //        + "connected switches: pccIp {}. Aborting ..", pccIpAddress.toString());
 168                 return false;
 169             }
 170
 171             return true;
 172         }
 173
 174         @Override
 175         public void removeConnectedClient(PccId pccId) {
 176             connectedClients.remove(pccId);
 177             for (PcepClientListener l : pcepClientListener) {
 178                 //log.warn("removal for {}", pccIpAddress.toString());
 179                 l.clientDisconnected(pccId);
 180             }
 181         }
 182
 183         @Override
 184         public void processPcepMessage(PccId pccId, PcepMessage m) {
 185             processClientMessage(pccId, m);
 186         }
 187     }
 188
 189 }