*/\r
package org.opendaylight.nemo.user.tenantmanager;\r
\r
-import java.util.HashMap;\r
-import java.util.Map;\r
-import java.util.concurrent.ExecutionException;\r
-\r
+import com.google.common.base.Function;\r
+import com.google.common.base.Optional;\r
+import com.google.common.collect.Maps;\r
+import com.google.common.util.concurrent.CheckedFuture;\r
+import com.google.common.util.concurrent.FutureCallback;\r
+import com.google.common.util.concurrent.Futures;\r
+import com.google.common.util.concurrent.ListenableFuture;\r
import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserRoleName;\r
+import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.RegisterUserInput;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.Users;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Objects;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.Operations;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateDefinitions;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.TemplateInstances;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.objects.*;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.Operation;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.operations.OperationKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstance;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.instances.TemplateInstanceKey;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.User;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserBuilder;\r
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.users.UserKey;\r
import org.slf4j.Logger;\r
import org.slf4j.LoggerFactory;\r
\r
-import com.google.common.base.Function;\r
-import com.google.common.base.Optional;\r
-import com.google.common.collect.Maps;\r
-import com.google.common.util.concurrent.CheckedFuture;\r
-import com.google.common.util.concurrent.FutureCallback;\r
-import com.google.common.util.concurrent.Futures;\r
-import com.google.common.util.concurrent.ListenableFuture;\r
+import java.util.HashMap;\r
+import java.util.Map;\r
+import java.util.concurrent.ExecutionException;\r
\r
/**\r
* Created by z00293636 on 2015/8/29.\r
private static final Logger LOG = LoggerFactory.getLogger(TenantManage.class);\r
private DataBroker dataBroker;\r
private User user;\r
+ private Map<UserId, Map<NodeId, Node>> userNodeMap = new HashMap<UserId, Map<NodeId, Node>>();\r
+ private Map<UserId, Map<ConnectionId, Connection>> userConnectionMap = new HashMap<UserId, Map<ConnectionId, Connection>>();\r
+ private Map<UserId, Map<FlowId, Flow>> userFlowMap = new HashMap<UserId, Map<FlowId, Flow>>();\r
+ private Map<UserId, Map<OperationId, Operation>> userOperationMap = new HashMap<UserId, Map<OperationId, Operation>>();\r
+ private Map<UserId, Map<TemplateName, TemplateDefinition>> userTemplateDefinitionMap = new HashMap<UserId, Map<TemplateName, TemplateDefinition>>();\r
+ private Map<UserId, Map<TemplateInstanceId, TemplateInstance>> userTemplateInstanceMap = new HashMap<UserId, Map<TemplateInstanceId, TemplateInstance>>();\r
+ private Map<UserId, Map<String, String>> userDeleteIntent = new HashMap<UserId, Map<String, String>>();\r
+ private Map<UserId, Map<String, String>> userNameIdMap = new HashMap<UserId, Map<String, String>>();\r
\r
- public TenantManage(DataBroker dataBroker)\r
- {\r
+ public TenantManage(DataBroker dataBroker){\r
this.dataBroker = dataBroker;\r
}\r
\r
}).or(new HashMap<UserId, User>());\r
}\r
\r
- public void fetchVNSpace(UserId userId)\r
- {\r
+ public void fetchVNSpace(UserId userId){\r
final Map<UserId, User> users = getUsers();\r
setUser((users != null) ? users.get(userId) : null);\r
}\r
\r
}\r
});\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * create a space to store all information in one transaction\r
+ */\r
+ public void transactionHandling(UserId userId){\r
+ writeDataStore(userId);\r
+ deleteDataStore(userId);\r
+\r
+ userNodeMap.clear();\r
+ userConnectionMap.clear();\r
+ userFlowMap.clear();\r
+ userOperationMap.clear();\r
+ userTemplateDefinitionMap.clear();\r
+ userTemplateInstanceMap.clear();\r
+ userDeleteIntent.clear();\r
+ }\r
+\r
+ /**\r
+ * store and get all user node in one transaction into map\r
+ * @param userId\r
+ */\r
+ public void setNode(UserId userId, NodeId nodeId, Node node){\r
+ if (userNodeMap.containsKey(userId)){\r
+ Map<NodeId, Node> nodeMap = userNodeMap.get(userId);\r
+ nodeMap.put(nodeId, node);\r
+ }\r
+ else {\r
+ Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();\r
+ nodeMap.put(nodeId,node);\r
+ userNodeMap.put(userId,nodeMap);\r
+ }\r
+ setUserNameIdMap(userId, node.getNodeName().getValue(),nodeId.getValue());\r
+ }\r
+\r
+ public Map<NodeId, Node> getNode(UserId userId){\r
+ if (!userNodeMap.isEmpty()){\r
+ return userNodeMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ public void setConnection(UserId userId, ConnectionId connectionId, Connection connection){\r
+ if (userConnectionMap.containsKey(userId)){\r
+ Map<ConnectionId, Connection> connectionMap = userConnectionMap.get(userId);\r
+ connectionMap.put(connectionId,connection);\r
+ }\r
+ else {\r
+ Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();\r
+ connectionMap.put(connectionId,connection);\r
+ userConnectionMap.put(userId,connectionMap);\r
+ }\r
+ setUserNameIdMap(userId, connection.getConnectionName().getValue(),connectionId.getValue());\r
+ }\r
+\r
+ public Map<ConnectionId, Connection> getConnection(UserId userId){\r
+ if (!userConnectionMap.isEmpty()){\r
+ return userConnectionMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ public void setFlow(UserId userId, FlowId flowId, Flow flow){\r
+ if (userFlowMap.containsKey(userId)){\r
+ Map<FlowId,Flow> flowMap = userFlowMap.get(userId);\r
+ flowMap.put(flowId,flow);\r
+ }\r
+ else {\r
+ Map<FlowId,Flow> flowMap = new HashMap<FlowId, Flow>();\r
+ flowMap.put(flowId,flow);\r
+ userFlowMap.put(userId,flowMap);\r
+ }\r
+ setUserNameIdMap(userId,flow.getFlowName().getValue(),flowId.getValue());\r
+ }\r
+\r
+ public Map<FlowId,Flow> getFlow(UserId userId){\r
+ if (!userFlowMap.isEmpty()){\r
+ return userFlowMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ public void setOperation(UserId userId, OperationId operationId, Operation operation){\r
+ if (userOperationMap.containsKey(userId)){\r
+ Map<OperationId, Operation> operationMap = userOperationMap.get(userId);\r
+ operationMap.put(operationId,operation);\r
+ }\r
+ else {\r
+ Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();\r
+ operationMap.put(operationId,operation);\r
+ userOperationMap.put(userId,operationMap);\r
+ }\r
+ setUserNameIdMap(userId,operation.getOperationName().getValue(),operationId.getValue());\r
+ }\r
+\r
+ public Map<OperationId, Operation> getOperation(UserId userId){\r
+ if (!userOperationMap.isEmpty()){\r
+ return userOperationMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ public void setTemplateDefinition(UserId userId,TemplateName templateName, TemplateDefinition definition){\r
+ if (userTemplateDefinitionMap.containsKey(userId)){\r
+ Map<TemplateName, TemplateDefinition> definitionMap = userTemplateDefinitionMap.get(userId);\r
+ definitionMap.put(templateName,definition);\r
+ }\r
+ else {\r
+ Map<TemplateName, TemplateDefinition> definitionMap = new HashMap<TemplateName, TemplateDefinition>();\r
+ definitionMap.put(templateName,definition);\r
+ userTemplateDefinitionMap.put(userId,definitionMap);\r
+ }\r
+ }\r
+\r
+ public Map<TemplateName, TemplateDefinition> getTempalteDefinition(UserId userId){\r
+ if (!userTemplateDefinitionMap.isEmpty()){\r
+ return userTemplateDefinitionMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ public void setUserTemplateInstance(UserId userId, TemplateInstanceId instanceId, TemplateInstance instance){\r
+ if (userTemplateInstanceMap.containsKey(userId)){\r
+ Map<TemplateInstanceId, TemplateInstance> instanceMap = userTemplateInstanceMap.get(userId);\r
+ instanceMap.put(instanceId,instance);\r
+ }\r
+ else {\r
+ Map<TemplateInstanceId, TemplateInstance> instanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();\r
+ instanceMap.put(instanceId,instance);\r
+ userTemplateInstanceMap.put(userId,instanceMap);\r
+ }\r
+ }\r
+\r
+ public Map<TemplateInstanceId, TemplateInstance> getTemplateInstance(UserId userId){\r
+ if (!userTemplateInstanceMap.isEmpty()){\r
+ return userTemplateInstanceMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ /**\r
+ * store all intent need to be deleted in the data store\r
+ * @param userId\r
+ * @param type\r
+ * @param objectId\r
+ */\r
+ public void setUserDeleteIntent(UserId userId, String type, String objectId){\r
+ if (userDeleteIntent.containsKey(userId)){\r
+ Map<String, String> deleteObject = userDeleteIntent.get(userId);\r
+ deleteObject.put(objectId,type);\r
+ }\r
+ else {\r
+ Map<String, String> deleteObject = new HashMap<String, String>();\r
+ deleteObject.put(objectId,type);\r
+ userDeleteIntent.put(userId, deleteObject);\r
+ }\r
+ }\r
+\r
+ /**\r
+ * store all name-id map\r
+ * @param userId\r
+ * @param name\r
+ * @param objectId\r
+ */\r
+ public void setUserNameIdMap(UserId userId, String name, String objectId){\r
+ if (userNameIdMap.containsKey(userId)){\r
+ Map<String, String> map = userNameIdMap.get(userId);\r
+ map.put(name,objectId);\r
+ }\r
+ else {\r
+ Map<String, String> nameIdMap = new HashMap<String, String>();\r
+ nameIdMap.put(name, objectId);\r
+ userNameIdMap.put(userId, nameIdMap);\r
+ }\r
+ }\r
+\r
+ public Map<String, String> getUserNameIdMap(UserId userId){\r
+ if (!userNameIdMap.isEmpty()){\r
+ return userNameIdMap.get(userId);\r
+ }\r
+ else {\r
+ return null;\r
+ }\r
+ }\r
+\r
+ public String getObjectId(UserId userId, String name){\r
+ if (userNameIdMap.containsKey(userId)){\r
+ if (userNameIdMap.get(userId).containsKey(name)){\r
+ return userNameIdMap.get(userId).get(name);\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
+ public String getName(UserId userId, String objectId){\r
+ if (userNameIdMap.containsKey(userId)){\r
+ for (String name : userNameIdMap.get(userId).keySet()){\r
+ if (objectId.equals(userNameIdMap.get(userId).get(name))){\r
+ return name;\r
+ }\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+\r
+ /**\r
+ * get all information stored in data store\r
+ */\r
+\r
+ public Map<NodeId, Node> getNodeDataStore(UserId userId){\r
+ Map<NodeId, Node> nodeMap = new HashMap<NodeId, Node>();\r
+ fetchVNSpace(userId);\r
+ User user1 = getUser();\r
+ if (user1.getObjects()!=null){\r
+ if (user1.getObjects().getNode()!=null){\r
+ for (Node node : user1.getObjects().getNode()){\r
+ nodeMap.put(node.getNodeId(),node);\r
+ }\r
+ }\r
+ }\r
+ return nodeMap.isEmpty()?null:nodeMap;\r
+ }\r
+\r
+ public Map<ConnectionId, Connection> getConnectionDataStore(UserId userId){\r
+ Map<ConnectionId, Connection> connectionMap = new HashMap<ConnectionId, Connection>();\r
+ fetchVNSpace(userId);\r
+ User user1 = getUser();\r
+ if (user1.getObjects()!=null){\r
+ if (user1.getObjects().getConnection()!=null){\r
+ for (Connection connection : user1.getObjects().getConnection()){\r
+ connectionMap.put(connection.getConnectionId(),connection);\r
+ }\r
+ }\r
+ }\r
+ return connectionMap.isEmpty()?null:connectionMap;\r
+ }\r
+\r
+ public Map<FlowId, Flow> getFlowDataStore(UserId userId){\r
+ Map<FlowId, Flow> flowMap = new HashMap<FlowId, Flow>();\r
+ fetchVNSpace(userId);\r
+ User user1 = getUser();\r
+ if (user1.getObjects()!=null){\r
+ if (user1.getObjects().getFlow()!=null){\r
+ for (Flow flow : user1.getObjects().getFlow()){\r
+ flowMap.put(flow.getFlowId(),flow);\r
+ }\r
+ }\r
+ }\r
+ return flowMap.isEmpty()?null:flowMap;\r
+ }\r
+\r
+ public Map<OperationId, Operation> getOperationDataStore(UserId userId){\r
+ Map<OperationId, Operation> operationMap = new HashMap<OperationId, Operation>();\r
+ fetchVNSpace(userId);\r
+ User user1 = getUser();\r
+ if (user1.getOperations()!=null){\r
+ if (user1.getOperations().getOperation()!=null){\r
+ for (Operation operation : user1.getOperations().getOperation()){\r
+ operationMap.put(operation.getOperationId(),operation);\r
+ }\r
+ }\r
+ }\r
+ return operationMap.isEmpty()?null:operationMap;\r
+ }\r
+\r
+ public Map<TemplateName, TemplateDefinition> getDefinitionDataStore(UserId userId){\r
+ Map<TemplateName, TemplateDefinition> definitionMap = new HashMap<TemplateName, TemplateDefinition>();\r
+ fetchVNSpace(userId);\r
+ User user1 = getUser();\r
+ if (user1.getTemplateDefinitions()!=null){\r
+ if (user1.getTemplateDefinitions().getTemplateDefinition()!=null){\r
+ for (TemplateDefinition definition : user1.getTemplateDefinitions().getTemplateDefinition()){\r
+ definitionMap.put(definition.getTemplateName(),definition);\r
+ }\r
+ }\r
+ }\r
+ return definitionMap.isEmpty()?null:definitionMap;\r
+ }\r
+\r
+ public Map<TemplateInstanceId, TemplateInstance> getInstanceDataStore(UserId userId){\r
+ Map<TemplateInstanceId, TemplateInstance> instanceMap = new HashMap<TemplateInstanceId, TemplateInstance>();\r
+ fetchVNSpace(userId);\r
+ User user1 = getUser();\r
+ if (user1.getTemplateInstances()!=null){\r
+ if (user1.getTemplateInstances().getTemplateInstance()!=null){\r
+ for (TemplateInstance instance : user1.getTemplateInstances().getTemplateInstance()){\r
+ instanceMap.put(instance.getTemplateInstanceId(),instance);\r
+ }\r
+ }\r
+ }\r
+ return instanceMap.isEmpty()?null:instanceMap;\r
+ }\r
+\r
+ /**\r
+ * write all information in one transaction into data store\r
+ */\r
+ private void writeDataStore(UserId userId){\r
+\r
+ UserKey userKey = new UserKey(userId);\r
+ if (getNode(userId)!=null){\r
+ for (NodeId nodeId : getNode(userId).keySet()){\r
+ NodeKey nodeKey = new NodeKey(nodeId);\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Node> nodeid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Node.class,nodeKey).build();\r
+ t.put(LogicalDatastoreType.CONFIGURATION, nodeid, getNode(userId).get(nodeId),true);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not write node instance", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+\r
+ }\r
+ if (getConnection(userId)!=null){\r
+ for (ConnectionId connectionId : getConnection(userId).keySet()){\r
+ ConnectionKey connectionKey = new ConnectionKey(connectionId);\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Connection> connectionid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Connection.class,connectionKey).build();\r
+ t.put(LogicalDatastoreType.CONFIGURATION, connectionid, getConnection(userId).get(connectionId),true);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not write connection instance", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+ if (getFlow(userId)!=null){\r
+ for (FlowId flowId : getFlow(userId).keySet()){\r
+ FlowKey flowKey = new FlowKey(flowId);\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Flow> flowid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Flow.class,flowKey).build();\r
+ t.put(LogicalDatastoreType.CONFIGURATION, flowid, getFlow(userId).get(flowId),true);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not write endpoint base container", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+ if (getOperation(userId)!=null){\r
+ for (OperationId operationId : getOperation(userId).keySet()){\r
+ OperationKey operationKey = new OperationKey(operationId);\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Operation> operationid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Operations.class).child(Operation.class,operationKey).build();\r
+ t.put(LogicalDatastoreType.CONFIGURATION, operationid, getOperation(userId).get(operationId),true);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not write endpoint base container", t);\r
+ }\r
+\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+\r
+ }\r
+ });\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+ if (getTempalteDefinition(userId)!=null){\r
+ for (TemplateName templateName : getTempalteDefinition(userId).keySet()){\r
+ TemplateDefinitionKey key = new TemplateDefinitionKey(templateName);\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<TemplateDefinition> templateDefinitionId = InstanceIdentifier.builder(Users.class).child(User.class, userKey)\r
+ .child(TemplateDefinitions.class).child(TemplateDefinition.class, key)\r
+ .build();\r
+ t.put(LogicalDatastoreType.CONFIGURATION, templateDefinitionId, getTempalteDefinition(userId).get(templateName),true);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not write endpoint base container", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+ if (getTemplateInstance(userId)!=null){\r
+ for (TemplateInstanceId instanceId : getTemplateInstance(userId).keySet()){\r
+ TemplateInstanceKey key = new TemplateInstanceKey(instanceId);\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<TemplateInstance> templateDefinitionId = InstanceIdentifier.builder(Users.class).child(User.class, userKey)\r
+ .child(TemplateInstances.class).child(TemplateInstance.class, key)\r
+ .build();\r
+ t.put(LogicalDatastoreType.CONFIGURATION, templateDefinitionId, getTemplateInstance(userId).get(instanceId),true);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not write endpoint base container", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ try {\r
+ f.get();\r
+ } catch (InterruptedException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ } catch (ExecutionException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * delete intent in data store\r
+ * @param userId\r
+ */\r
+ private void deleteDataStore(UserId userId){\r
+ if (userDeleteIntent.get(userId)!=null){\r
+ Map<String, String> deleteObject = userDeleteIntent.get(userId);\r
+\r
+ for (String objectId : deleteObject.keySet()){\r
+ if (deleteObject.get(objectId).equals(NEMOConstants.node)){\r
+ UserKey userKey = new UserKey(userId);\r
+ NodeKey nodeKey = new NodeKey(new NodeId(objectId));\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Node> nodeid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Node.class,nodeKey).build();\r
+ t.delete(LogicalDatastoreType.CONFIGURATION, nodeid);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not delete node instance", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ }\r
+ if (deleteObject.get(objectId).equals(NEMOConstants.connection)){\r
+ UserKey userKey = new UserKey(userId);\r
+ ConnectionKey connectionKey = new ConnectionKey(new ConnectionId(objectId));\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Connection> connectionid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Connection.class,connectionKey).build();\r
+ t.delete(LogicalDatastoreType.CONFIGURATION, connectionid);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not delete connection instance", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ }\r
+ if (deleteObject.get(objectId).equals(NEMOConstants.flow)){\r
+ UserKey userKey = new UserKey(userId);\r
+ FlowKey flowKey = new FlowKey(new FlowId(objectId));\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Flow> flowid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Objects.class).child(Flow.class,flowKey).build();\r
+ t.delete(LogicalDatastoreType.CONFIGURATION, flowid);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not delete flow instance", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ }\r
+ if (deleteObject.get(objectId).equals(NEMOConstants.operation)){\r
+ UserKey userKey = new UserKey(userId);\r
+ OperationKey operationKey = new OperationKey(new OperationId(objectId));\r
+ WriteTransaction t = dataBroker.newWriteOnlyTransaction();\r
+ InstanceIdentifier<Operation> operationid = InstanceIdentifier.builder(Users.class).child(User.class, userKey).child(Operations.class).child(Operation.class,operationKey).build();\r
+ t.delete(LogicalDatastoreType.CONFIGURATION, operationid);\r
+ CheckedFuture<Void, TransactionCommitFailedException> f = t.submit();\r
+ Futures.addCallback(f, new FutureCallback<Void>() {\r
+ @Override\r
+ public void onFailure(Throwable t) {\r
+ LOG.error("Could not delete operation instance", t);\r
+ }\r
+ @Override\r
+ public void onSuccess(Void result) {\r
+ }\r
+ });\r
+ }\r
+ }\r
}\r
}\r
}\r
Code Review / nemo.git / blobdiff