nemo-impl/src/main/java/org/opendaylight/nemo/user/tenantmanager/TenantManage.java

   1 /*\r
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.nemo.user.tenantmanager;\r
   9 \r
  10 import com.google.common.base.Function;\r
  11 import com.google.common.base.Optional;\r
  12 import com.google.common.collect.Maps;\r
  13 import com.google.common.util.concurrent.CheckedFuture;\r
  14 import com.google.common.util.concurrent.FutureCallback;\r
  15 import com.google.common.util.concurrent.Futures;\r
  16 import com.google.common.util.concurrent.ListenableFuture;\r
  17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
  18 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
  20 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;\r
  21 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.RegisterUserInput;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Operations;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateDefinitions;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateInstances;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.*;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.Operation;\r
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.OperationKey;\r
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;\r
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey;\r
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstance;\r
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceKey;\r
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;\r
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserBuilder;\r
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;\r
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.user.rev151010.UserRoles;\r
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.user.rev151010.user.roles.UserRole;\r
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
  42 import org.slf4j.Logger;\r
  43 import org.slf4j.LoggerFactory;\r
  44 \r
  45 import java.util.HashMap;\r
  46 import java.util.Map;\r
  47 import java.util.concurrent.ExecutionException;\r
  48 \r
  49 /**\r
  50  * Created by z00293636 on 2015/8/29.\r
  51  */\r
  52 \r
  53 /* maintain tenant information, including how many tenants are active, their information */\r
  54 public class TenantManage {\r
  55     private static final Logger LOG = LoggerFactory.getLogger(TenantManage.class);\r
  56     private DataBroker dataBroker;\r
  57     private User user;\r
  58     private Map<UserId, Map<NodeId, Node>> userNodeMap = new HashMap<UserId, Map<NodeId, Node>>();\r
  59     private Map<UserId, Map<ConnectionId, Connection>> userConnectionMap = new HashMap<UserId, Map<ConnectionId, Connection>>();\r
  60     private Map<UserId, Map<FlowId, Flow>> userFlowMap = new HashMap<UserId, Map<FlowId, Flow>>();\r
  61     private Map<UserId, Map<OperationId, Operation>> userOperationMap = new HashMap<UserId, Map<OperationId, Operation>>();\r
  62     private Map<UserId, Map<TemplateName, TemplateDefinition>> userTemplateDefinitionMap = new HashMap<UserId, Map<TemplateName, TemplateDefinition>>();\r
  63     private Map<UserId, Map<TemplateInstanceId, TemplateInstance>> userTemplateInstanceMap = new HashMap<UserId, Map<TemplateInstanceId, TemplateInstance>>();\r
  64     private Map<UserId, Map<String, String>> userDeleteIntent = new HashMap<UserId, Map<String, String>>();\r
  65     private Map<UserId, Map<String, String>> userNameIdMap = new HashMap<UserId, Map<String, String>>();\r
  66 \r
  67     public TenantManage(DataBroker dataBroker){\r
  68         this.dataBroker = dataBroker;\r
  69     }\r
  70 \r
  71     private void setUser(User user)\r
  72     {\r
  73         this.user = user;\r
  74     }\r
  75 \r
  76     public User getUser()\r
  77     {\r
  78         return user;\r
  79     }\r
  80 \r
  81     /**\r
  82      *\r
  83      * @return null if an error was encountered, or an empty map if there was no\r
  84      *         error but no data was retrieved.\r
  85      */\r
  86     public Map<UserRoleName, UserRole> getUserRoles() {\r
  87 \r
  88         InstanceIdentifier<UserRoles> userRolesInsId = InstanceIdentifier.builder(UserRoles.class).build();\r
  89         ListenableFuture<Optional<UserRoles>> userRolesFuture = this.dataBroker.newReadOnlyTransaction().read(\r
  90                 LogicalDatastoreType.CONFIGURATION, userRolesInsId);\r
  91 \r
  92         final Optional<UserRoles> userRolesOpt;\r
  93         try {\r
  94             // TODO: consider time out here?\r
  95             userRolesOpt = userRolesFuture.get();\r
  96         } catch (InterruptedException e) {\r
  97             LOG.error("Cannot read role information.", e);\r
  98             return null;\r
  99         } catch (ExecutionException e) {\r
 100             LOG.error("Cannot read role information.", e);\r
 101             return null;\r
 102         }\r
 103 \r
 104         // TODO: change to Java 8 lambda expressions\r
 105         return userRolesOpt.transform(new Function<UserRoles, Map<UserRoleName, UserRole>>() {\r
 106             @Override\r
 107             public Map<UserRoleName, UserRole> apply(UserRoles input) {\r
 108                 return Maps.uniqueIndex(input.getUserRole(), new Function<UserRole, UserRoleName>() {\r
 109                     @Override\r
 110                     public UserRoleName apply(UserRole role) {\r
 111                         return role.getRoleName();\r
 112                     }\r
 113                 });\r
 114             }\r
 115         }).or(new HashMap<UserRoleName, UserRole>());\r
 116     }\r
 117 \r
 118     /**\r
 119     *\r
 120     * @return null if an error was encountered, or an empty map if there was no\r
 121     *         error but no data was retrieved.\r
 122     */\r
 123     public Map<UserId, User> getUsers() {\r
 124         InstanceIdentifier<Users> usersInsId = InstanceIdentifier.builder(Users.class).build();\r
 125         ListenableFuture<Optional<Users>> usersFuture = dataBroker.newReadOnlyTransaction().read(\r
 126                 LogicalDatastoreType.CONFIGURATION, usersInsId);\r
 127 \r
 128         final Optional<Users> usersOpt;\r
 129         try {\r
 130             // TODO: consider time out here?\r
 131             usersOpt = usersFuture.get();\r
 132         } catch (InterruptedException e) {\r
 133             LOG.error("Cannot read user information.", e);\r
 134             return null;\r
 135         } catch (ExecutionException e) {\r
 136             LOG.error("Cannot read user information.", e);\r
 137             return null;\r
 138         }\r
 139 \r
 140         // TODO: change to Java 8 lambda expressions\r
 141         return usersOpt.transform(new Function<Users, Map<UserId, User>>() {\r
 142             @Override\r
 143             public Map<UserId, User> apply(Users input) {\r
 144                 return Maps.uniqueIndex(input.getUser(), new Function<User, UserId>() {\r
 145                     @Override\r
 146                     public UserId apply(User user) {\r
 147                         return user.getUserId();\r
 148                     }\r
 149                 });\r
 150             }\r
 151         }).or(new HashMap<UserId, User>());\r
 152     }\r
 153 \r
 154     public void fetchVNSpace(UserId userId){\r
 155         final Map<UserId, User> users = getUsers();\r
 156         setUser((users != null) ? users.get(userId) : null);\r
 157     }\r
 158 \r
 159     public void addUser(RegisterUserInput registerUserInput){\r
 160         WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 161         if (registerUserInput.getUserId() != null)\r
 162         {\r
 163             User user = new UserBuilder(registerUserInput).build();\r
 164             UserKey userKey = new UserKey(registerUserInput.getUserId());\r
 165 \r
 166             InstanceIdentifier<User> userid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).build();\r
 167 \r
 168             t.put(LogicalDatastoreType.CONFIGURATION, userid, user,true);\r
 169             CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 170             Futures.addCallback(f, new FutureCallback<Void>() {\r
 171                 @Override\r
 172                 public void onFailure(Throwable t) {\r
 173                     LOG.error("Could not write endpoint base container", t);\r
 174                 }\r
 175 \r
 176                 @Override\r
 177                 public void onSuccess(Void result) {\r
 178 \r
 179                 }\r
 180             });\r
 181             try {\r
 182                 f.get();\r
 183             } catch (InterruptedException e) {\r
 184                 // TODO Auto-generated catch block\r
 185                 LOG.error("Exception:",e);\r
 186             } catch (ExecutionException e) {\r
 187                 // TODO Auto-generated catch block\r
 188                 LOG.error("Exception:",e);\r
 189             }\r
 190         }\r
 191     }\r
 192 \r
 193     /**\r
 194      * create a space to store all information in one transaction\r
 195      */\r
 196     public void transactionHandling(UserId userId){\r
 197         writeDataStore(userId);\r
 198         deleteDataStore(userId);\r
 199 \r
 200         userNodeMap.clear();\r
 201         userConnectionMap.clear();\r
 202         userFlowMap.clear();\r
 203         userOperationMap.clear();\r
 204         userTemplateDefinitionMap.clear();\r
 205         userTemplateInstanceMap.clear();\r
 206         userDeleteIntent.clear();\r
 207     }\r
 208 \r
 209     /**\r
 210      * store and get all user node in one transaction into map\r
 211      * @param userId\r
 212      */\r
 213     public void setNode(UserId userId, NodeId nodeId, Node node){\r
 214         if (userNodeMap.containsKey(userId)){\r
 215             Map<NodeId, Node> nodeMap = userNodeMap.get(userId);\r
 216             nodeMap.put(nodeId, node);\r
 217         }\r
 218         else {\r
 219             Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();\r
 220             nodeMap.put(nodeId,node);\r
 221             userNodeMap.put(userId,nodeMap);\r
 222         }\r
 223         setUserNameIdMap(userId, node.getNodeName().getValue(),nodeId.getValue());\r
 224     }\r
 225 \r
 226     public Map<NodeId, Node> getNode(UserId userId){\r
 227         if (!userNodeMap.isEmpty()){\r
 228             return userNodeMap.get(userId);\r
 229         }\r
 230         else {\r
 231             return null;\r
 232         }\r
 233     }\r
 234 \r
 235     public void setConnection(UserId userId, ConnectionId connectionId, Connection connection){\r
 236         if (userConnectionMap.containsKey(userId)){\r
 237             Map<ConnectionId, Connection> connectionMap = userConnectionMap.get(userId);\r
 238             connectionMap.put(connectionId,connection);\r
 239         }\r
 240         else {\r
 241             Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();\r
 242             connectionMap.put(connectionId,connection);\r
 243             userConnectionMap.put(userId,connectionMap);\r
 244         }\r
 245         setUserNameIdMap(userId, connection.getConnectionName().getValue(),connectionId.getValue());\r
 246     }\r
 247 \r
 248     public Map<ConnectionId, Connection> getConnection(UserId userId){\r
 249         if (!userConnectionMap.isEmpty()){\r
 250             return userConnectionMap.get(userId);\r
 251         }\r
 252         else {\r
 253             return null;\r
 254         }\r
 255     }\r
 256 \r
 257     public void setFlow(UserId userId, FlowId flowId, Flow flow){\r
 258         if (userFlowMap.containsKey(userId)){\r
 259             Map<FlowId,Flow> flowMap = userFlowMap.get(userId);\r
 260             flowMap.put(flowId,flow);\r
 261         }\r
 262         else {\r
 263             Map<FlowId,Flow> flowMap = new HashMap<FlowId, Flow>();\r
 264             flowMap.put(flowId,flow);\r
 265             userFlowMap.put(userId,flowMap);\r
 266         }\r
 267         setUserNameIdMap(userId,flow.getFlowName().getValue(),flowId.getValue());\r
 268     }\r
 269 \r
 270     public Map<FlowId,Flow> getFlow(UserId userId){\r
 271         if (!userFlowMap.isEmpty()){\r
 272             return userFlowMap.get(userId);\r
 273         }\r
 274         else {\r
 275             return null;\r
 276         }\r
 277     }\r
 278 \r
 279     public void setOperation(UserId userId, OperationId operationId, Operation operation){\r
 280         if (userOperationMap.containsKey(userId)){\r
 281             Map<OperationId, Operation> operationMap = userOperationMap.get(userId);\r
 282             operationMap.put(operationId,operation);\r
 283         }\r
 284         else {\r
 285             Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();\r
 286             operationMap.put(operationId,operation);\r
 287             userOperationMap.put(userId,operationMap);\r
 288         }\r
 289         setUserNameIdMap(userId,operation.getOperationName().getValue(),operationId.getValue());\r
 290     }\r
 291 \r
 292     public Map<OperationId, Operation> getOperation(UserId userId){\r
 293         if (!userOperationMap.isEmpty()){\r
 294             return userOperationMap.get(userId);\r
 295         }\r
 296         else {\r
 297             return null;\r
 298         }\r
 299     }\r
 300 \r
 301     public void setTemplateDefinition(UserId userId,TemplateName templateName, TemplateDefinition definition){\r
 302         if (userTemplateDefinitionMap.containsKey(userId)){\r
 303             Map<TemplateName, TemplateDefinition> definitionMap = userTemplateDefinitionMap.get(userId);\r
 304             definitionMap.put(templateName,definition);\r
 305         }\r
 306         else {\r
 307             Map<TemplateName, TemplateDefinition> definitionMap = new HashMap<TemplateName, TemplateDefinition>();\r
 308             definitionMap.put(templateName,definition);\r
 309             userTemplateDefinitionMap.put(userId,definitionMap);\r
 310         }\r
 311     }\r
 312 \r
 313     public Map<TemplateName, TemplateDefinition> getTempalteDefinition(UserId userId){\r
 314         if (!userTemplateDefinitionMap.isEmpty()){\r
 315             return userTemplateDefinitionMap.get(userId);\r
 316         }\r
 317         else {\r
 318             return null;\r
 319         }\r
 320     }\r
 321 \r
 322     public void setUserTemplateInstance(UserId userId, TemplateInstanceId instanceId, TemplateInstance instance){\r
 323         if (userTemplateInstanceMap.containsKey(userId)){\r
 324             Map<TemplateInstanceId, TemplateInstance> instanceMap = userTemplateInstanceMap.get(userId);\r
 325             instanceMap.put(instanceId,instance);\r
 326         }\r
 327         else {\r
 328             Map<TemplateInstanceId, TemplateInstance> instanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();\r
 329             instanceMap.put(instanceId,instance);\r
 330             userTemplateInstanceMap.put(userId,instanceMap);\r
 331         }\r
 332     }\r
 333 \r
 334     public Map<TemplateInstanceId, TemplateInstance> getTemplateInstance(UserId userId){\r
 335         if (!userTemplateInstanceMap.isEmpty()){\r
 336             return userTemplateInstanceMap.get(userId);\r
 337         }\r
 338         else {\r
 339             return null;\r
 340         }\r
 341     }\r
 342 \r
 343     /**\r
 344      * store all intent need to be deleted in the data store\r
 345      * @param userId\r
 346      * @param type\r
 347      * @param objectId\r
 348      */\r
 349     public void setUserDeleteIntent(UserId userId, String type, String objectId){\r
 350         if (userDeleteIntent.containsKey(userId)){\r
 351             Map<String, String> deleteObject = userDeleteIntent.get(userId);\r
 352             deleteObject.put(objectId,type);\r
 353         }\r
 354         else {\r
 355             Map<String, String> deleteObject = new HashMap<String, String>();\r
 356             deleteObject.put(objectId,type);\r
 357             userDeleteIntent.put(userId, deleteObject);\r
 358         }\r
 359     }\r
 360 \r
 361     /**\r
 362      * store all name-id map\r
 363      * @param userId\r
 364      * @param name\r
 365      * @param objectId\r
 366      */\r
 367     public void setUserNameIdMap(UserId userId, String name, String objectId){\r
 368         if (userNameIdMap.containsKey(userId)){\r
 369             Map<String, String> map = userNameIdMap.get(userId);\r
 370             map.put(name,objectId);\r
 371         }\r
 372         else {\r
 373             Map<String, String> nameIdMap = new HashMap<String, String>();\r
 374             nameIdMap.put(name, objectId);\r
 375             userNameIdMap.put(userId, nameIdMap);\r
 376         }\r
 377     }\r
 378 \r
 379     public Map<String, String> getUserNameIdMap(UserId userId){\r
 380         if (!userNameIdMap.isEmpty()){\r
 381             return userNameIdMap.get(userId);\r
 382         }\r
 383         else {\r
 384             return null;\r
 385         }\r
 386     }\r
 387 \r
 388     public String getObjectId(UserId userId, String name){\r
 389         if (userNameIdMap.containsKey(userId)){\r
 390             if (userNameIdMap.get(userId).containsKey(name)){\r
 391                 return userNameIdMap.get(userId).get(name);\r
 392             }\r
 393         }\r
 394         return null;\r
 395     }\r
 396 \r
 397     public String getName(UserId userId, String objectId){\r
 398         if (userNameIdMap.containsKey(userId)){\r
 399             for (String name : userNameIdMap.get(userId).keySet()){\r
 400                 if (objectId.equals(userNameIdMap.get(userId).get(name))){\r
 401                     return name;\r
 402                 }\r
 403             }\r
 404         }\r
 405         return null;\r
 406     }\r
 407 \r
 408     /**\r
 409      * get all information stored in data store\r
 410      */\r
 411 \r
 412     public Map<NodeId, Node> getNodeDataStore(UserId userId){\r
 413         Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();\r
 414         fetchVNSpace(userId);\r
 415         User user1 = getUser();\r
 416         if (user1.getObjects()!=null){\r
 417             if (user1.getObjects().getNode()!=null){\r
 418                 for (Node node : user1.getObjects().getNode()){\r
 419                     nodeMap.put(node.getNodeId(),node);\r
 420                 }\r
 421             }\r
 422         }\r
 423         return nodeMap.isEmpty()?null:nodeMap;\r
 424     }\r
 425 \r
 426     public Map<ConnectionId, Connection> getConnectionDataStore(UserId userId){\r
 427         Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();\r
 428         fetchVNSpace(userId);\r
 429         User user1 = getUser();\r
 430         if (user1.getObjects()!=null){\r
 431             if (user1.getObjects().getConnection()!=null){\r
 432                 for (Connection connection : user1.getObjects().getConnection()){\r
 433                     connectionMap.put(connection.getConnectionId(),connection);\r
 434                 }\r
 435             }\r
 436         }\r
 437         return connectionMap.isEmpty()?null:connectionMap;\r
 438     }\r
 439 \r
 440     public Map<FlowId, Flow> getFlowDataStore(UserId userId){\r
 441         Map<FlowId, Flow> flowMap = new HashMap<FlowId, Flow>();\r
 442         fetchVNSpace(userId);\r
 443         User user1 = getUser();\r
 444         if (user1.getObjects()!=null){\r
 445             if (user1.getObjects().getFlow()!=null){\r
 446                 for (Flow flow : user1.getObjects().getFlow()){\r
 447                     flowMap.put(flow.getFlowId(),flow);\r
 448                 }\r
 449             }\r
 450         }\r
 451         return flowMap.isEmpty()?null:flowMap;\r
 452     }\r
 453 \r
 454     public Map<OperationId, Operation> getOperationDataStore(UserId userId){\r
 455         Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();\r
 456         fetchVNSpace(userId);\r
 457         User user1 = getUser();\r
 458         if (user1.getOperations()!=null){\r
 459             if (user1.getOperations().getOperation()!=null){\r
 460                 for (Operation operation : user1.getOperations().getOperation()){\r
 461                     operationMap.put(operation.getOperationId(),operation);\r
 462                 }\r
 463             }\r
 464         }\r
 465         return operationMap.isEmpty()?null:operationMap;\r
 466     }\r
 467 \r
 468     public Map<TemplateName, TemplateDefinition> getDefinitionDataStore(UserId userId){\r
 469         Map<TemplateName, TemplateDefinition> definitionMap = new HashMap<TemplateName, TemplateDefinition>();\r
 470         fetchVNSpace(userId);\r
 471         User user1 = getUser();\r
 472         if (user1.getTemplateDefinitions()!=null){\r
 473             if (user1.getTemplateDefinitions().getTemplateDefinition()!=null){\r
 474                 for (TemplateDefinition definition : user1.getTemplateDefinitions().getTemplateDefinition()){\r
 475                     definitionMap.put(definition.getTemplateName(),definition);\r
 476                 }\r
 477             }\r
 478         }\r
 479         return definitionMap.isEmpty()?null:definitionMap;\r
 480     }\r
 481 \r
 482     public Map<TemplateInstanceId, TemplateInstance> getInstanceDataStore(UserId userId){\r
 483         Map<TemplateInstanceId, TemplateInstance> instanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();\r
 484         fetchVNSpace(userId);\r
 485         User user1 = getUser();\r
 486         if (user1.getTemplateInstances()!=null){\r
 487             if (user1.getTemplateInstances().getTemplateInstance()!=null){\r
 488                 for (TemplateInstance instance : user1.getTemplateInstances().getTemplateInstance()){\r
 489                     instanceMap.put(instance.getTemplateInstanceId(),instance);\r
 490                 }\r
 491             }\r
 492         }\r
 493         return instanceMap.isEmpty()?null:instanceMap;\r
 494     }\r
 495 \r
 496     /**\r
 497      * write all information in one transaction into data store\r
 498      */\r
 499     private void writeDataStore(UserId userId){\r
 500 \r
 501         UserKey userKey = new UserKey(userId);\r
 502         if (getNode(userId)!=null){\r
 503             for (NodeId nodeId : getNode(userId).keySet()){\r
 504                 NodeKey nodeKey = new NodeKey(nodeId);\r
 505                 WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 506                 InstanceIdentifier<Node> nodeid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Node.class,nodeKey).build();\r
 507                 t.put(LogicalDatastoreType.CONFIGURATION, nodeid, getNode(userId).get(nodeId),true);\r
 508                 CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 509                 Futures.addCallback(f, new FutureCallback<Void>() {\r
 510                     @Override\r
 511                     public void onFailure(Throwable t) {\r
 512                         LOG.error("Could not write node instance", t);\r
 513                     }\r
 514                     @Override\r
 515                     public void onSuccess(Void result) {\r
 516                     }\r
 517                 });\r
 518                 try {\r
 519                     f.get();\r
 520                 } catch (InterruptedException e) {\r
 521                     // TODO Auto-generated catch block\r
 522                     LOG.error("Exception:",e);\r
 523                 } catch (ExecutionException e) {\r
 524                     // TODO Auto-generated catch block\r
 525                     LOG.error("Exception:",e);\r
 526                 }\r
 527             }\r
 528 \r
 529         }\r
 530         if (getConnection(userId)!=null){\r
 531            for (ConnectionId connectionId : getConnection(userId).keySet()){\r
 532                 ConnectionKey connectionKey = new ConnectionKey(connectionId);\r
 533                WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 534                 InstanceIdentifier<Connection> connectionid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Connection.class,connectionKey).build();\r
 535                 t.put(LogicalDatastoreType.CONFIGURATION, connectionid, getConnection(userId).get(connectionId),true);\r
 536                 CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 537                 Futures.addCallback(f, new FutureCallback<Void>() {\r
 538                     @Override\r
 539                     public void onFailure(Throwable t) {\r
 540                         LOG.error("Could not write connection instance", t);\r
 541                     }\r
 542                     @Override\r
 543                     public void onSuccess(Void result) {\r
 544                     }\r
 545                 });\r
 546                try {\r
 547                    f.get();\r
 548                } catch (InterruptedException e) {\r
 549                    // TODO Auto-generated catch block\r
 550                    LOG.error("Exception:",e);\r
 551                } catch (ExecutionException e) {\r
 552                    // TODO Auto-generated catch block\r
 553                    LOG.error("Exception:",e);\r
 554                }\r
 555            }\r
 556         }\r
 557         if (getFlow(userId)!=null){\r
 558            for (FlowId flowId : getFlow(userId).keySet()){\r
 559                 FlowKey flowKey = new FlowKey(flowId);\r
 560                WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 561                 InstanceIdentifier<Flow> flowid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Flow.class,flowKey).build();\r
 562                 t.put(LogicalDatastoreType.CONFIGURATION, flowid, getFlow(userId).get(flowId),true);\r
 563                 CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 564                 Futures.addCallback(f, new FutureCallback<Void>() {\r
 565                     @Override\r
 566                     public void onFailure(Throwable t) {\r
 567                         LOG.error("Could not write endpoint base container", t);\r
 568                     }\r
 569                     @Override\r
 570                     public void onSuccess(Void result) {\r
 571                     }\r
 572                 });\r
 573                try {\r
 574                    f.get();\r
 575                } catch (InterruptedException e) {\r
 576                    // TODO Auto-generated catch block\r
 577                    LOG.error("Exception:",e);\r
 578                } catch (ExecutionException e) {\r
 579                    // TODO Auto-generated catch block\r
 580                    LOG.error("Exception:",e);\r
 581                }\r
 582            }\r
 583         }\r
 584         if (getOperation(userId)!=null){\r
 585             for (OperationId operationId : getOperation(userId).keySet()){\r
 586                 OperationKey operationKey = new OperationKey(operationId);\r
 587                 WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 588                 InstanceIdentifier<Operation> operationid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Operations.class).child(Operation.class,operationKey).build();\r
 589                 t.put(LogicalDatastoreType.CONFIGURATION, operationid, getOperation(userId).get(operationId),true);\r
 590                 CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 591                 Futures.addCallback(f, new FutureCallback<Void>() {\r
 592                     @Override\r
 593                     public void onFailure(Throwable t) {\r
 594                         LOG.error("Could not write endpoint base container", t);\r
 595                     }\r
 596 \r
 597                     @Override\r
 598                     public void onSuccess(Void result) {\r
 599 \r
 600                     }\r
 601                 });\r
 602                 try {\r
 603                     f.get();\r
 604                 } catch (InterruptedException e) {\r
 605                     // TODO Auto-generated catch block\r
 606                     LOG.error("Exception:",e);\r
 607                 } catch (ExecutionException e) {\r
 608                     // TODO Auto-generated catch block\r
 609                     LOG.error("Exception:",e);\r
 610                 }\r
 611             }\r
 612         }\r
 613         if (getTempalteDefinition(userId)!=null){\r
 614             for (TemplateName templateName : getTempalteDefinition(userId).keySet()){\r
 615                 TemplateDefinitionKey key = new TemplateDefinitionKey(templateName);\r
 616                 WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 617                 InstanceIdentifier<TemplateDefinition> templateDefinitionId = InstanceIdentifier.builder(Users.class).child(User.class, userKey)\r
 618                         .child(TemplateDefinitions.class).child(TemplateDefinition.class, key)\r
 619                         .build();\r
 620                 t.put(LogicalDatastoreType.CONFIGURATION, templateDefinitionId, getTempalteDefinition(userId).get(templateName),true);\r
 621                 CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 622                 Futures.addCallback(f, new FutureCallback<Void>() {\r
 623                     @Override\r
 624                     public void onFailure(Throwable t) {\r
 625                         LOG.error("Could not write endpoint base container", t);\r
 626                     }\r
 627                     @Override\r
 628                     public void onSuccess(Void result) {\r
 629                     }\r
 630                 });\r
 631                 try {\r
 632                     f.get();\r
 633                 } catch (InterruptedException e) {\r
 634                     // TODO Auto-generated catch block\r
 635                     LOG.error("Exception:",e);\r
 636                 } catch (ExecutionException e) {\r
 637                     // TODO Auto-generated catch block\r
 638                     LOG.error("Exception:",e);\r
 639                 }\r
 640             }\r
 641         }\r
 642         if (getTemplateInstance(userId)!=null){\r
 643           for (TemplateInstanceId instanceId : getTemplateInstance(userId).keySet()){\r
 644                 TemplateInstanceKey key = new TemplateInstanceKey(instanceId);\r
 645                 WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 646                 InstanceIdentifier<TemplateInstance> templateDefinitionId = InstanceIdentifier.builder(Users.class).child(User.class, userKey)\r
 647                         .child(TemplateInstances.class).child(TemplateInstance.class, key)\r
 648                         .build();\r
 649                 t.put(LogicalDatastoreType.CONFIGURATION, templateDefinitionId, getTemplateInstance(userId).get(instanceId),true);\r
 650                 CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 651                 Futures.addCallback(f, new FutureCallback<Void>() {\r
 652                     @Override\r
 653                     public void onFailure(Throwable t) {\r
 654                         LOG.error("Could not write endpoint base container", t);\r
 655                     }\r
 656                     @Override\r
 657                     public void onSuccess(Void result) {\r
 658                     }\r
 659                 });\r
 660               try {\r
 661                   f.get();\r
 662               } catch (InterruptedException e) {\r
 663                   // TODO Auto-generated catch block\r
 664                   LOG.error("Exception:",e);\r
 665               } catch (ExecutionException e) {\r
 666                   // TODO Auto-generated catch block\r
 667                   LOG.error("Exception:",e);\r
 668               }\r
 669           }\r
 670         }\r
 671     }\r
 672 \r
 673     /**\r
 674      * delete intent in data store\r
 675      * @param userId\r
 676      */\r
 677     private void deleteDataStore(UserId userId){\r
 678         if (userDeleteIntent.get(userId)!=null){\r
 679             Map<String, String> deleteObject = userDeleteIntent.get(userId);\r
 680 \r
 681             for (String objectId : deleteObject.keySet()){\r
 682                 if (deleteObject.get(objectId).equals(NEMOConstants.node)){\r
 683                     UserKey userKey = new UserKey(userId);\r
 684                     NodeKey nodeKey = new NodeKey(new NodeId(objectId));\r
 685                     WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 686                     InstanceIdentifier<Node> nodeid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Node.class,nodeKey).build();\r
 687                     t.delete(LogicalDatastoreType.CONFIGURATION, nodeid);\r
 688                     CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 689                     Futures.addCallback(f, new FutureCallback<Void>() {\r
 690                         @Override\r
 691                         public void onFailure(Throwable t) {\r
 692                             LOG.error("Could not delete node instance", t);\r
 693                         }\r
 694                         @Override\r
 695                         public void onSuccess(Void result) {\r
 696                         }\r
 697                     });\r
 698                 }\r
 699                 if (deleteObject.get(objectId).equals(NEMOConstants.connection)){\r
 700                     UserKey userKey = new UserKey(userId);\r
 701                     ConnectionKey connectionKey = new ConnectionKey(new ConnectionId(objectId));\r
 702                     WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 703                     InstanceIdentifier<Connection> connectionid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Connection.class,connectionKey).build();\r
 704                     t.delete(LogicalDatastoreType.CONFIGURATION, connectionid);\r
 705                     CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 706                     Futures.addCallback(f, new FutureCallback<Void>() {\r
 707                         @Override\r
 708                         public void onFailure(Throwable t) {\r
 709                             LOG.error("Could not delete connection instance", t);\r
 710                         }\r
 711                         @Override\r
 712                         public void onSuccess(Void result) {\r
 713                         }\r
 714                     });\r
 715                 }\r
 716                 if (deleteObject.get(objectId).equals(NEMOConstants.flow)){\r
 717                     UserKey userKey = new UserKey(userId);\r
 718                     FlowKey flowKey = new FlowKey(new FlowId(objectId));\r
 719                     WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 720                     InstanceIdentifier<Flow> flowid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Flow.class,flowKey).build();\r
 721                     t.delete(LogicalDatastoreType.CONFIGURATION, flowid);\r
 722                     CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 723                     Futures.addCallback(f, new FutureCallback<Void>() {\r
 724                         @Override\r
 725                         public void onFailure(Throwable t) {\r
 726                             LOG.error("Could not delete flow instance", t);\r
 727                         }\r
 728                         @Override\r
 729                         public void onSuccess(Void result) {\r
 730                         }\r
 731                     });\r
 732                 }\r
 733                 if (deleteObject.get(objectId).equals(NEMOConstants.operation)){\r
 734                     UserKey userKey = new UserKey(userId);\r
 735                     OperationKey operationKey = new OperationKey(new OperationId(objectId));\r
 736                     WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
 737                     InstanceIdentifier<Operation> operationid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Operations.class).child(Operation.class,operationKey).build();\r
 738                     t.delete(LogicalDatastoreType.CONFIGURATION, operationid);\r
 739                     CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
 740                     Futures.addCallback(f, new FutureCallback<Void>() {\r
 741                         @Override\r
 742                         public void onFailure(Throwable t) {\r
 743                             LOG.error("Could not delete operation instance", t);\r
 744                         }\r
 745                         @Override\r
 746                         public void onSuccess(Void result) {\r
 747                         }\r
 748                     });\r
 749                 }\r
 750             }\r
 751         }\r
 752     }\r
 753 }\r