ovsdb/src/main/java/org/opendaylight/ovsdb/internal/ConfigurationService.java

   1 package org.opendaylight.ovsdb.internal;
   2
   3 import java.net.InetAddress;
   4 import java.util.*;
   5
   6 import org.opendaylight.ovsdb.database.OVSBridge;
   7 import org.opendaylight.ovsdb.database.OVSInstance;
   8 import org.opendaylight.ovsdb.sal.configuration.IPluginInNetworkConfigurationService;
   9 import org.opendaylight.controller.sal.core.Node;
  10 import org.opendaylight.controller.sal.core.NodeConnector;
  11 import org.opendaylight.ovsdb.database.Uuid;
  12 import org.slf4j.Logger;
  13 import org.slf4j.LoggerFactory;
  14
  15 public class ConfigurationService implements IPluginInNetworkConfigurationService
  16 {
  17     private static final Logger logger = LoggerFactory
  18             .getLogger(ConfigurationService.class);
  19
  20     IConnectionServiceInternal connectionService;
  21
  22     void init() {
  23     }
  24
  25     /**
  26      * Function called by the dependency manager when at least one dependency
  27      * become unsatisfied or when the component is shutting down because for
  28      * example bundle is being stopped.
  29      *
  30      */
  31     void destroy() {
  32     }
  33
  34     /**
  35      * Function called by dependency manager after "init ()" is called and after
  36      * the services provided by the class are registered in the service registry
  37      *
  38      */
  39     void start() {
  40     }
  41
  42     /**
  43      * Function called by the dependency manager before the services exported by
  44      * the component are unregistered, this will be followed by a "destroy ()"
  45      * calls
  46      *
  47      */
  48     void stop() {
  49     }
  50
  51     public void setConnectionServiceInternal(IConnectionServiceInternal connectionService) {
  52         this.connectionService = connectionService;
  53     }
  54
  55     public void unsetConnectionServiceInternal(IConnectionServiceInternal connectionService) {
  56         if (this.connectionService == connectionService) {
  57             this.connectionService = null;
  58         }
  59     }
  60
  61     /**
  62      * Add a new bridge
  63      * @param node Node serving this configuration service
  64      * @param bridgeConnectorIdentifier String representation of a Bridge Connector
  65      * @return Bridge Connector configurations
  66      */
  67     @Override
  68     @SuppressWarnings("unchecked")
  69     public boolean createBridgeDomain(Node node, String bridgeIdentifier) throws Throwable{
  70         try{
  71             if (connectionService == null) {
  72                 logger.error("Couldn't refer to the ConnectionService");
  73                 return false;
  74             }
  75
  76             Connection connection = connectionService.getConnection(node);
  77             String identifier = "TEST";
  78
  79             if (connection != null) {
  80                 String newBridge = "new_bridge";
  81                 String newInterface = "new_interface";
  82                 String newPort = "new_port";
  83                 String newSwitch = "new_switch";
  84
  85                 Object addSwitchRequest;
  86
  87                 OVSInstance instance = new OVSInstance();
  88                 instance.monitorOVS(connection);
  89
  90                 if(instance.getUuid() != null){
  91                     List<String> bridgeUuidPair = new ArrayList<String>();
  92                     bridgeUuidPair.add("named-uuid");
  93                     bridgeUuidPair.add(newBridge);
  94
  95                     List<Object> mutation = new ArrayList<Object>();
  96                     mutation.add("bridges");
  97                     mutation.add("insert");
  98                     mutation.add(bridgeUuidPair);
  99
 100                     List<Object> mutations = new ArrayList<Object>();
 101                     mutations.add(mutation);
 102
 103                     List<String> ovsUuidPair = new ArrayList<String>();
 104                     ovsUuidPair.add("uuid");
 105                     ovsUuidPair.add(instance.getUuid());
 106
 107                     List<Object> whereInner = new ArrayList<Object>();
 108                     whereInner.add("_uuid");
 109                     whereInner.add("==");
 110                     whereInner.add(ovsUuidPair);
 111
 112                     List<Object> where = new ArrayList<Object>();
 113                     where.add(whereInner);
 114
 115                     addSwitchRequest = new MutateRequest("Open_vSwitch", where, mutations);
 116                 }
 117                 else{
 118                     Map<String, Object> vswitchRow = new HashMap<String, Object>();
 119                     ArrayList<String> bridges = new ArrayList<String>();
 120                     bridges.add("named-uuid");
 121                     bridges.add(newBridge);
 122                     vswitchRow.put("bridges", bridges);
 123                     addSwitchRequest = new InsertRequest("insert", "Open_vSwitch", newSwitch, vswitchRow);
 124                 }
 125
 126                 Map<String, Object> bridgeRow = new HashMap<String, Object>();
 127                 bridgeRow.put("name", bridgeIdentifier);
 128                 ArrayList<String> ports = new ArrayList<String>();
 129                 ports.add("named-uuid");
 130                 ports.add(newPort);
 131                 bridgeRow.put("ports", ports);
 132                 InsertRequest addBridgeRequest = new InsertRequest("insert", "Bridge", newBridge, bridgeRow);
 133
 134                 Map<String, Object> portRow = new HashMap<String, Object>();
 135                 portRow.put("name", bridgeIdentifier);
 136                 ArrayList<String> interfaces = new ArrayList<String>();
 137                 interfaces.add("named-uuid");
 138                 interfaces.add(newInterface);
 139                 portRow.put("interfaces", interfaces);
 140                 InsertRequest addPortRequest = new InsertRequest("insert", "Port", newPort, portRow);
 141
 142                 Map<String, Object> interfaceRow = new HashMap<String, Object>();
 143                 interfaceRow.put("name", bridgeIdentifier);
 144                 interfaceRow.put("type", "internal");
 145                 InsertRequest addIntfRequest = new InsertRequest("insert", "Interface", newInterface, interfaceRow);
 146
 147                 Object[] params = {"Open_vSwitch", addSwitchRequest, addIntfRequest, addPortRequest, addBridgeRequest};
 148                 OvsdbMessage msg = new OvsdbMessage("transact", params);
 149
 150                 connection.sendMessage(msg);
 151                 connection.readResponse(Uuid[].class);
 152             }
 153         }catch(Exception e){
 154             e.printStackTrace();
 155         }
 156         return true;
 157     }
 158
 159     @Override
 160     public boolean deleteBridgeDomain(Node node, String bridgeIdentifier) {
 161         // TODO Auto-generated method stub
 162         return false;
 163     }
 164
 165     @Override
 166     public List<String> getBridgeDomains(Node node) {
 167         // TODO Auto-generated method stub
 168         return null;
 169     }
 170
 171     @Override
 172     public boolean addBridgeDomainConfig(Node node, String bridgeIdentifier, Map<String, String> config) {
 173         // TODO Auto-generated method stub
 174         return false;
 175     }
 176
 177     @Override
 178     public boolean removeBridgeDomainConfig(Node node, String bridgeIdentifier, Map<String, String> config) {
 179         // TODO Auto-generated method stub
 180         return false;
 181     }
 182
 183     @Override
 184     public Map<String, String> getBridgeDomainConfigs(Node node, String bridgeIdentifier) {
 185         // TODO Auto-generated method stub
 186         return null;
 187     }
 188
 189     @Override
 190     public boolean createBridgeConnector(Node node, String bridgeConnectorIdentifier) {
 191         // TODO Auto-generated method stub
 192         return false;
 193     }
 194
 195     @Override
 196     public boolean deleteBridgeConnector(Node node, String bridgeConnectorIdentifier) {
 197         // TODO Auto-generated method stub
 198         return false;
 199     }
 200
 201     @Override
 202     public boolean associateBridgeConnector(Node node, String bridgeIdentifier, String bridgeConnectorIdentifier) {
 203         // TODO Auto-generated method stub
 204         return false;
 205     }
 206
 207     @Override
 208     public boolean disassociateBridgeConnector(Node node, String bridgeIdentifier, String bridgeConnectorIdentifier) {
 209         // TODO Auto-generated method stub
 210         return false;
 211     }
 212
 213     @Override
 214     public boolean addBridgeConnectorConfig(Node node, String bridgeConnectorIdentifier, Map<String, String> config) {
 215         // TODO Auto-generated method stub
 216         return false;
 217     }
 218
 219     @Override
 220     public boolean removeBridgeConnectorConfig(Node node, String bridgeConnectorIdentifier, Map<String, String> config) {
 221         // TODO Auto-generated method stub
 222         return false;
 223     }
 224
 225     @Override
 226     public Map<String, String> getBridgeConnectorConfigs(Node node, String bridgeConnectorIdentifier) {
 227         // TODO Auto-generated method stub
 228         return null;
 229     }
 230     /**
 231      * Create a Bridge Domain
 232      *
 233      * @param node Node serving this configuration service
 234      * @param bridgeDomainIdentifier String representation of a Bridge Domain
 235      * @param portIdentifier String representation of a user defined Port Name
 236      */
 237     @Override
 238     @SuppressWarnings("unchecked")
 239     public boolean addPort(Node node, String bridgeIdentifier, String portIdentifier) throws Throwable{
 240         try{
 241             if (connectionService == null) {
 242                 logger.error("Couldn't refer to the ConnectionService");
 243                 return false;
 244             }
 245             Connection connection = connectionService.getConnection(node);
 246
 247             if (connection != null) {
 248                 String newBridge = "new_bridge";
 249                 String newInterface = "new_interface";
 250                 String newPort = "new_port";
 251                 String newSwitch = "new_switch";
 252
 253                 Map<String, OVSBridge> existingBridges = OVSBridge.monitorBridge(connection);
 254
 255                 OVSBridge bridge = existingBridges.get(bridgeIdentifier);
 256
 257                 List<String> portUuidPair = new ArrayList<String>();
 258                 portUuidPair.add("named-uuid");
 259                 portUuidPair.add(newPort);
 260
 261                 List<Object> mutation = new ArrayList<Object>();
 262                 mutation.add("ports");
 263                 mutation.add("insert");
 264                 mutation.add(portUuidPair);
 265                 List<Object> mutations = new ArrayList<Object>();
 266                 mutations.add(mutation);
 267
 268                 List<String> bridgeUuidPair = new ArrayList<String>();
 269                 bridgeUuidPair.add("uuid");
 270                 bridgeUuidPair.add(bridge.getUuid());
 271
 272                 List<Object> whereInner = new ArrayList<Object>();
 273                 whereInner.add("_uuid");
 274                 whereInner.add("==");
 275                 whereInner.add(bridgeUuidPair);
 276
 277                 List<Object> where = new ArrayList<Object>();
 278                 where.add(whereInner);
 279
 280                 MutateRequest mutateBridgeRequest = new MutateRequest("Bridge", where, mutations);
 281
 282                 Map<String, Object> portRow = new HashMap<String, Object>();
 283                 portRow.put("name", portIdentifier);
 284                 ArrayList<String> interfaces = new ArrayList<String>();
 285                 interfaces.add("named-uuid");
 286                 interfaces.add(newInterface);
 287                 portRow.put("interfaces", interfaces);
 288                 InsertRequest addPortRequest = new InsertRequest("insert", "Port", newPort, portRow);
 289
 290                 Map<String, Object> interfaceRow = new HashMap<String, Object>();
 291                 interfaceRow.put("name", portIdentifier);
 292                 interfaceRow.put("type", "internal");
 293                 InsertRequest addIntfRequest = new InsertRequest("insert", "Interface", newInterface, interfaceRow);
 294
 295                 Object[] params = {"Open_vSwitch", mutateBridgeRequest, addIntfRequest, addPortRequest};
 296                 OvsdbMessage msg = new OvsdbMessage("transact", params);
 297
 298                 connection.sendMessage(msg);
 299                 connection.readResponse(Uuid[].class);
 300             }
 301         }catch(Exception e){
 302             e.printStackTrace();
 303         }
 304         return true;
 305     }
 306     /**
 307      * Create a Bridge Domain
 308      *
 309      * @param node Node serving this configuration service
 310      * @param bridgeDomainIdentifier String representation of a Bridge Domain
 311      * @param portIdentifier String representation of a user defined Port Name
 312      */
 313     @Override
 314     @SuppressWarnings("unchecked")
 315     public boolean addTunnel(Node node, String bridgeIdentifier,
 316         String portidentifier, String tunnelendpoint, String tunencap)
 317                 throws Throwable{
 318         try{
 319             if (connectionService == null) {
 320                 logger.error("Couldn't refer to the ConnectionService");
 321                 return false;
 322             }
 323             Connection connection = connectionService.getConnection(node);
 324
 325             if (connection != null) {
 326                 String newBridge = "new_bridge";
 327                 String newInterface = "new_interface";
 328                 String newPort = "new_port";
 329                 String newSwitch = "new_switch";
 330
 331                 Map<String, OVSBridge> existingBridges = OVSBridge.monitorBridge(connection);
 332
 333                 OVSBridge bridge = existingBridges.get(bridgeIdentifier);
 334
 335                 List<String> portUuidPair = new ArrayList<String>();
 336                 portUuidPair.add("named-uuid");
 337                 portUuidPair.add(newPort);
 338
 339                 List<Object> mutation = new ArrayList<Object>();
 340                 mutation.add("ports");
 341                 mutation.add("insert");
 342                 mutation.add(portUuidPair);
 343                 List<Object> mutations = new ArrayList<Object>();
 344                 mutations.add(mutation);
 345
 346                 List<String> bridgeUuidPair = new ArrayList<String>();
 347                 bridgeUuidPair.add("uuid");
 348                 bridgeUuidPair.add(bridge.getUuid());
 349
 350                 List<Object> whereInner = new ArrayList<Object>();
 351                 whereInner.add("_uuid");
 352                 whereInner.add("==");
 353                 whereInner.add(bridgeUuidPair);
 354
 355                 List<Object> where = new ArrayList<Object>();
 356                 where.add(whereInner);
 357
 358                 MutateRequest mutateBridgeRequest = new MutateRequest("Bridge", where, mutations);
 359
 360                 Map<String, Object> portRow = new HashMap<String, Object>();
 361                 portRow.put("name", portidentifier);
 362                 ArrayList<String> interfaces = new ArrayList<String>();
 363                 interfaces.add("named-uuid");
 364                 interfaces.add(newInterface);
 365                 portRow.put("interfaces", interfaces);
 366                 InsertRequest addPortRequest = new InsertRequest("insert", "Port", newPort, portRow);
 367
 368                 Map<String, Object> interfaceRow = new HashMap<String, Object>();
 369                 interfaceRow.put("name", portidentifier);
 370                 interfaceRow.put("type", tunencap);
 371                 ArrayList<Object> intopt = new ArrayList<Object>();
 372                 interfaceRow.put("options", intopt);
 373                 ArrayList<Object> intoptmap = new ArrayList<Object>();
 374                 ArrayList<String> intoptep = new ArrayList<String>();
 375                 intopt.add("map");
 376                 intopt.add(intoptmap);
 377                 intoptmap.add(intoptep);
 378                 intoptep.add("remote_ip");
 379                 intoptep.add(tunnelendpoint);
 380
 381                 InsertRequest addIntfRequest = new InsertRequest("insert", "Interface",
 382                         newInterface, interfaceRow);
 383
 384                 Object[] params = {"Open_vSwitch", mutateBridgeRequest, addIntfRequest, addPortRequest};
 385                 OvsdbMessage msg = new OvsdbMessage("transact", params);
 386
 387                 connection.sendMessage(msg);
 388                 connection.readResponse(Uuid[].class);
 389             }
 390         }catch(Exception e){
 391             e.printStackTrace();
 392         }
 393         return true;
 394     }
 395
 396     @Override
 397     public Object genericConfigurationEvent(Node node, Map<String, String> config) {
 398         // TODO Auto-generated method stub
 399         return null;
 400     }
 401
 402   }