nemo-impl/src/main/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateDefinitionLang.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.vnspacemanager.languagestyle.updateintentlang;\r
   9 \r
  10 import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
  11 import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
  12 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;\r
  13 import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.GetDefinitions;\r
  14 import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateTemplateDefinition;\r
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.hosts.PhysicalHost;\r
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;\r
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostId;\r
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostName;\r
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionBuilder;\r
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey;\r
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNode;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNodeBuilder;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNodeKey;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItemBuilder;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItemKey;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValueBuilder;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.*;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValuesBuilder;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.*;\r
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.ParameterValuesBuilder;\r
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegment;\r
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegmentBuilder;\r
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegmentKey;\r
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.ConditionParameterTargetValueBuilder;\r
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.Action;\r
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.ActionBuilder;\r
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.ActionKey;\r
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.AbstractIntentsBuilder;\r
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameter;\r
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameterBuilder;\r
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameterKey;\r
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractObjectsBuilder;\r
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractOperationsBuilder;\r
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.*;\r
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperation;\r
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperationBuilder;\r
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperationKey;\r
  49 \r
  50 import java.util.*;\r
  51 \r
  52 /**\r
  53  * Created by z00293636 on 2015/12/7.\r
  54  */\r
  55 public class UpdateTemplateDefinitionLang {\r
  56     private UpdateTemplateDefinition definition;\r
  57     private Map<NodeName, AbstractNode> abstractNodes;\r
  58     private Map<ConnectionName, AbstractConnection> abstractConnections;\r
  59     private Map<FlowName, AbstractFlow> abstractFlows;\r
  60     private Map<OperationName, AbstractOperation> abstractOperations;\r
  61     private GetDefinitions getDefinitions;\r
  62 \r
  63     public UpdateTemplateDefinitionLang(DataBroker dataBroker, TenantManage tenantManage){\r
  64         definition = new UpdateTemplateDefinition(dataBroker,tenantManage);\r
  65         abstractNodes = new HashMap<NodeName, AbstractNode>();\r
  66         abstractConnections = new HashMap<ConnectionName, AbstractConnection>();\r
  67         abstractFlows = new HashMap<FlowName, AbstractFlow>();\r
  68         abstractOperations = new HashMap<OperationName, AbstractOperation>();\r
  69         getDefinitions = new GetDefinitions(dataBroker);\r
  70     }\r
  71 \r
  72     public String templateDefinitionLang(UserId userId, String templateName, LinkedHashMap<String, String> parameters){\r
  73         TemplateDefinitionBuilder builder = new TemplateDefinitionBuilder();\r
  74         builder.setKey(new TemplateDefinitionKey(new TemplateName(templateName)))\r
  75                 .setTemplateName(new TemplateName(templateName));\r
  76 \r
  77         List<TemplateParameter> templateParameters = new LinkedList<TemplateParameter>();\r
  78         for (String value : parameters.keySet()){\r
  79             TemplateParameterBuilder parameterBuilder = new TemplateParameterBuilder();\r
  80             parameterBuilder.setKey(new TemplateParameterKey(new ParameterName(value)))\r
  81                             .setParameterName(new ParameterName(value));\r
  82 \r
  83             if (parameters.get(value).equals(NEMOConstants.string)){\r
  84                 parameterBuilder.setParameterValueType(TemplateParameter.ParameterValueType.String);\r
  85             }\r
  86             else if (parameters.get(value).equals(NEMOConstants.integer)){\r
  87                 parameterBuilder.setParameterValueType(TemplateParameter.ParameterValueType.Int);\r
  88             }\r
  89             else if (parameters.get(value).equals(NEMOConstants.range)){\r
  90                 parameterBuilder.setParameterValueType(TemplateParameter.ParameterValueType.Range);\r
  91             }\r
  92             templateParameters.add(parameterBuilder.build());\r
  93         }\r
  94         builder.setTemplateParameter(templateParameters);\r
  95 \r
  96         AbstractIntentsBuilder intentsBuilder = new AbstractIntentsBuilder();\r
  97         AbstractObjectsBuilder objectsBuilder = new AbstractObjectsBuilder();\r
  98         if (!abstractNodes.isEmpty()){\r
  99             List<AbstractNode> abstractNodeList = new LinkedList<AbstractNode>();\r
 100             for (AbstractNode node : abstractNodes.values()){\r
 101                 abstractNodeList.add(node);\r
 102             }\r
 103             objectsBuilder.setAbstractNode(abstractNodeList);\r
 104         }else {\r
 105             objectsBuilder.setAbstractNode(null);\r
 106         }\r
 107 \r
 108         if (!abstractConnections.isEmpty()){\r
 109             List<AbstractConnection> abstractConnectionList = new LinkedList<AbstractConnection>();\r
 110             for (AbstractConnection connection : abstractConnections.values()){\r
 111                 abstractConnectionList.add(connection);\r
 112             }\r
 113             objectsBuilder.setAbstractConnection(abstractConnectionList);\r
 114         }else {\r
 115             objectsBuilder.setAbstractConnection(null);\r
 116         }\r
 117 \r
 118         if (!abstractFlows.isEmpty()){\r
 119             List<AbstractFlow> abstractFlowList = new ArrayList<AbstractFlow>();\r
 120             for (AbstractFlow flow : abstractFlows.values()){\r
 121                 abstractFlowList.add(flow);\r
 122             }\r
 123             objectsBuilder.setAbstractFlow(abstractFlowList);\r
 124         }else {\r
 125             objectsBuilder.setAbstractFlow(null);\r
 126         }\r
 127 \r
 128         AbstractOperationsBuilder operationsBuilder = new AbstractOperationsBuilder();\r
 129         if (!abstractOperations.isEmpty()){\r
 130             List<AbstractOperation> abstractOperationList = new LinkedList<AbstractOperation>();\r
 131             for (AbstractOperation operation : abstractOperations.values()){\r
 132                 abstractOperationList.add(operation);\r
 133             }\r
 134             operationsBuilder.setAbstractOperation(abstractOperationList);\r
 135         }else {\r
 136             operationsBuilder.setAbstractOperation(null);\r
 137         }\r
 138 \r
 139         intentsBuilder.setAbstractObjects(objectsBuilder.build())\r
 140                       .setAbstractOperations(operationsBuilder.build());\r
 141         builder.setAbstractIntents(intentsBuilder.build());\r
 142 \r
 143         return definition.checkTemplateDefinition(userId,builder.build());\r
 144     }\r
 145 \r
 146     public String createAbstractNode(String name, String type, List<String> subnodes, LinkedHashMap<String, LinkedHashMap<String,String>> propertyList){\r
 147         AbstractNodeBuilder nodeBuilder = new AbstractNodeBuilder();\r
 148         NodeId nodeId = null;\r
 149         if (type.equals(NEMOConstants.host)){\r
 150             Map<PhysicalHostName, PhysicalHost> physicalHostMap = getDefinitions.getPhysicalHost();\r
 151             if (physicalHostMap.containsKey(new PhysicalHostName(name))){\r
 152                 PhysicalHostId physicalHostId = physicalHostMap.get(new PhysicalHostName(name)).getHostId();\r
 153                 nodeBuilder.setKey(new AbstractNodeKey(new AbstractNodeKey(new NodeId(physicalHostId.getValue()))))\r
 154                         .setNodeId(new NodeId(physicalHostId.getValue()));\r
 155             }\r
 156             else {\r
 157                 return "The host " + name + " is not exist in physical network.";\r
 158             }\r
 159         }\r
 160         else {\r
 161             nodeId = new NodeId(UUID.randomUUID().toString());\r
 162         }\r
 163 \r
 164         nodeBuilder.setKey(new AbstractNodeKey(nodeId));\r
 165         nodeBuilder.setNodeId(nodeId);\r
 166         nodeBuilder.setNodeName(new NodeName(name));\r
 167         nodeBuilder.setNodeType(new NodeType(type));\r
 168 \r
 169         if (!subnodes.isEmpty()){\r
 170             if (abstractNodes.isEmpty()){\r
 171                 return "There are no nodes.";\r
 172             }\r
 173             else {\r
 174                 List<SubNode> subNodeList = new LinkedList<SubNode>();\r
 175                 Long order = 0L;\r
 176                 for (String nodeName : subnodes){\r
 177                     if (!abstractNodes.containsKey(new NodeName(nodeName))){\r
 178                         return "The subnode " + nodeName + " is not exist.";\r
 179                     }\r
 180                     else {\r
 181                         SubNodeBuilder subNodeBuilder = new SubNodeBuilder();\r
 182                         subNodeBuilder.setKey(new SubNodeKey(abstractNodes.get(new NodeName(nodeName)).getNodeId()))\r
 183                                         .setNodeId(abstractNodes.get(new NodeName(nodeName)).getNodeId())\r
 184                                         .setOrder(order);\r
 185                         order++;\r
 186                         subNodeList.add(subNodeBuilder.build());\r
 187                     }\r
 188                 }\r
 189                 nodeBuilder.setSubNode(subNodeList);\r
 190             }\r
 191         }\r
 192 \r
 193         if (!propertyList.isEmpty()){\r
 194             List<Property> properties = new LinkedList<Property>();\r
 195             for (String propertyName : propertyList.keySet()){\r
 196                 PropertyBuilder builder = new PropertyBuilder();\r
 197                 builder.setKey(new PropertyKey(new PropertyName(propertyName)))\r
 198                         .setPropertyName(new PropertyName(propertyName));\r
 199 \r
 200                 Map<String, String> values = propertyList.get(propertyName);\r
 201                 PropertyValuesBuilder valuesBuilder = new PropertyValuesBuilder();\r
 202                 List<StringValue> stringValues = new LinkedList<StringValue>();\r
 203                 List<IntValue> intValues = new LinkedList<IntValue>();\r
 204                 RangeValue rangeValue = null;\r
 205                 Long order = 0L;\r
 206                 for (String value : values.keySet()){\r
 207                     if (values.get(value).equals(NEMOConstants.string)){\r
 208                         StringValueBuilder stringValueBuilder = new StringValueBuilder();\r
 209                         stringValueBuilder.setKey(new StringValueKey(order,value))\r
 210                                           .setOrder(order)\r
 211                                           .setValue(value);\r
 212                         order ++;\r
 213                         stringValues.add(stringValueBuilder.build());\r
 214                     }\r
 215                     if (values.get(value).equals(NEMOConstants.integer)){\r
 216                         IntValueBuilder intValueBuilder = new IntValueBuilder();\r
 217                         intValueBuilder.setKey(new IntValueKey(order, Long.parseLong(value)))\r
 218                                         .setOrder(order)\r
 219                                         .setValue(Long.parseLong(value));\r
 220                         order ++;\r
 221                         intValues.add(intValueBuilder.build());\r
 222                     }\r
 223                     if (values.get(value).equals(NEMOConstants.range)){\r
 224                         String[] range = value.split(",");\r
 225                         RangeValueBuilder rangeValueBuilder = new RangeValueBuilder();\r
 226                         if (Long.parseLong(range[0])<Long.parseLong(range[1])){\r
 227                             rangeValueBuilder.setMin(Long.parseLong(range[0]));\r
 228                             rangeValueBuilder.setMax(Long.parseLong(range[1]));\r
 229                         }\r
 230                         else{\r
 231                             rangeValueBuilder.setMin(Long.parseLong(range[1]));\r
 232                             rangeValueBuilder.setMax(Long.parseLong(range[0]));\r
 233                         }\r
 234                         rangeValue = rangeValueBuilder.build();\r
 235                     }\r
 236                 }\r
 237                 valuesBuilder.setStringValue(stringValues.isEmpty()?null:stringValues)\r
 238                              .setIntValue(intValues.isEmpty()?null:intValues)\r
 239                              .setRangeValue(rangeValue);\r
 240                 builder.setPropertyValues(valuesBuilder.build());\r
 241                 properties.add(builder.build());\r
 242             }\r
 243             nodeBuilder.setProperty(properties);\r
 244         }\r
 245         abstractNodes.put(new NodeName(name),nodeBuilder.build());\r
 246         return null;\r
 247     }\r
 248 \r
 249     public String createAbstractConnection(String name, String type, List<String> endnodes, LinkedHashMap<String, LinkedHashMap<String,String>> propertyList){\r
 250         AbstractConnectionBuilder connectionBuilder = new AbstractConnectionBuilder();\r
 251         ConnectionId connectionId = new ConnectionId(UUID.randomUUID().toString());\r
 252         connectionBuilder.setKey(new AbstractConnectionKey(connectionId))\r
 253                          .setConnectionId(connectionId)\r
 254                          .setConnectionName(new ConnectionName(name))\r
 255                          .setConnectionType(new ConnectionType(type));\r
 256 \r
 257         List<EndNode> endNodeList = new LinkedList<EndNode>();\r
 258         if (abstractNodes.isEmpty()){\r
 259             return "There are nodes exist.";\r
 260         }\r
 261         else {\r
 262             long order = 0L;\r
 263             for (String endNode : endnodes){\r
 264                 if (!abstractNodes.containsKey(new NodeName(endNode))){\r
 265                     return "The endnode " + endNode + " is not exit.";\r
 266                 }\r
 267                 else {\r
 268                     EndNodeBuilder endNodeBuilder = new EndNodeBuilder();\r
 269                     endNodeBuilder.setKey(new EndNodeKey(abstractNodes.get(new NodeName(endNode)).getNodeId()))\r
 270                                   .setNodeId(abstractNodes.get(new NodeName(endNode)).getNodeId())\r
 271                                   .setOrder(order);\r
 272                     order++;\r
 273                     endNodeList.add(endNodeBuilder.build());\r
 274                 }\r
 275             }\r
 276         }\r
 277         connectionBuilder.setEndNode(endNodeList.isEmpty()?null:endNodeList);\r
 278 \r
 279         if (!propertyList.isEmpty()){\r
 280             List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property> properties = new LinkedList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.Property>();\r
 281             for (String propertyName : propertyList.keySet()){\r
 282                 org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.PropertyBuilder builder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.PropertyBuilder();\r
 283                 builder.setKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.PropertyKey(new PropertyName(propertyName)))\r
 284                         .setPropertyName(new PropertyName(propertyName));\r
 285 \r
 286                 Map<String, String> values = propertyList.get(propertyName);\r
 287                 PropertyValuesBuilder valuesBuilder = new PropertyValuesBuilder();\r
 288                 List<StringValue> stringValues = new LinkedList<StringValue>();\r
 289                 List<IntValue> intValues = new LinkedList<IntValue>();\r
 290                 RangeValue rangeValue = null;\r
 291                 Long order = 0L;\r
 292                 for (String value : values.keySet()){\r
 293                     if (values.get(value).equals(NEMOConstants.string)){\r
 294                         StringValueBuilder stringValueBuilder = new StringValueBuilder();\r
 295                         stringValueBuilder.setKey(new StringValueKey(order,value))\r
 296                                 .setOrder(order)\r
 297                                 .setValue(value);\r
 298                         order ++;\r
 299                         stringValues.add(stringValueBuilder.build());\r
 300                     }\r
 301                     if (values.get(value).equals(NEMOConstants.integer)){\r
 302                         IntValueBuilder intValueBuilder = new IntValueBuilder();\r
 303                         intValueBuilder.setKey(new IntValueKey(order, Long.parseLong(value)))\r
 304                                 .setOrder(order)\r
 305                                 .setValue(Long.parseLong(value));\r
 306                         order ++;\r
 307                         intValues.add(intValueBuilder.build());\r
 308                     }\r
 309                     if (values.get(value).equals(NEMOConstants.range)){\r
 310                         String[] range = value.split(",");\r
 311                         RangeValueBuilder rangeValueBuilder = new RangeValueBuilder();\r
 312                         if (Long.parseLong(range[0])<Long.parseLong(range[1])){\r
 313                             rangeValueBuilder.setMin(Long.parseLong(range[0]));\r
 314                             rangeValueBuilder.setMax(Long.parseLong(range[1]));\r
 315                         }\r
 316                         else{\r
 317                             rangeValueBuilder.setMin(Long.parseLong(range[1]));\r
 318                             rangeValueBuilder.setMax(Long.parseLong(range[0]));\r
 319                         }\r
 320                         rangeValue = rangeValueBuilder.build();\r
 321                     }\r
 322                 }\r
 323                 valuesBuilder.setStringValue(stringValues.isEmpty()?null:stringValues)\r
 324                         .setIntValue(intValues.isEmpty()?null:intValues)\r
 325                         .setRangeValue(rangeValue);\r
 326                 builder.setPropertyValues(valuesBuilder.build());\r
 327                 properties.add(builder.build());\r
 328             }\r
 329             connectionBuilder.setProperty(properties);\r
 330         }\r
 331         abstractConnections.put(new ConnectionName(name),connectionBuilder.build());\r
 332         return null;\r
 333     }\r
 334 \r
 335     public String createAbstractFlow(String name,LinkedHashMap<String,LinkedHashMap<String,String>> matches,LinkedHashMap<String,LinkedHashMap<String,String>> propertyList){\r
 336         AbstractFlowBuilder flowBuilder = new AbstractFlowBuilder();\r
 337         FlowId flowId = new FlowId(UUID.randomUUID().toString());\r
 338         flowBuilder.setKey(new AbstractFlowKey(flowId))\r
 339                    .setFlowId(flowId)\r
 340                    .setFlowName(new FlowName(name));\r
 341 \r
 342         List<MatchItem> matchItemList = new LinkedList<MatchItem>();\r
 343         for (String matchName : matches.keySet()){\r
 344             MatchItemBuilder matchItemBuilder = new MatchItemBuilder();\r
 345             matchItemBuilder.setKey(new MatchItemKey(new MatchItemName(matchName)))\r
 346                             .setMatchItemName(new MatchItemName(matchName));\r
 347 \r
 348             MatchItemValueBuilder valueBuilder = new MatchItemValueBuilder();\r
 349             Map<String, String> values = matches.get(matchName);\r
 350             for (String value : values.keySet()){\r
 351                 if (values.get(value).equals(NEMOConstants.string)){\r
 352                     valueBuilder.setStringValue(value);\r
 353                 }\r
 354                 if (values.get(value).equals(NEMOConstants.integer)){\r
 355                     valueBuilder.setIntValue(Long.parseLong(value));\r
 356                 }\r
 357                 if (values.get(value).equals(NEMOConstants.range)){\r
 358                     String[] range = value.split(",");\r
 359                     org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.match.item.value.RangeValueBuilder rangeValueBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.match.item.value.RangeValueBuilder();\r
 360                     rangeValueBuilder.setMax(Long.parseLong(range[0]) > Long.parseLong(range[1]) ? Long.parseLong(range[0]) : Long.parseLong(range[1]));\r
 361                     rangeValueBuilder.setMin(Long.parseLong(range[0])<Long.parseLong(range[1])?Long.parseLong(range[0]):Long.parseLong(range[1]));\r
 362                     valueBuilder.setRangeValue(rangeValueBuilder.build());\r
 363                 }\r
 364             }\r
 365             matchItemBuilder.setMatchItemValue(valueBuilder.build());\r
 366             matchItemList.add(matchItemBuilder.build());\r
 367         }\r
 368         flowBuilder.setMatchItem(matchItemList);\r
 369 \r
 370         //todo check property\r
 371 \r
 372         abstractFlows.put(new FlowName(name), flowBuilder.build());\r
 373         return null;\r
 374     }\r
 375 \r
 376     public String createAbstractOperation(String name, String target, String priority, LinkedHashMap<String,LinkedHashMap<String,String>> conditions,LinkedHashMap<String,LinkedHashMap<String,String>>actions){\r
 377         AbstractOperationBuilder operationBuilder = new AbstractOperationBuilder();\r
 378         OperationId operationId = new OperationId(UUID.randomUUID().toString());\r
 379         operationBuilder.setKey(new AbstractOperationKey(operationId))\r
 380                         .setOperationId(operationId)\r
 381                         .setOperationName(new OperationName(name))\r
 382                         .setPriority(Long.parseLong(priority));\r
 383         if (abstractNodes.containsKey(new NodeName(target))){\r
 384             operationBuilder.setTargetObject(abstractNodes.get(new NodeName(target)).getNodeId());\r
 385         }\r
 386         else if (abstractConnections.containsKey(new ConnectionName(target))){\r
 387             operationBuilder.setTargetObject(abstractConnections.get(new ConnectionName(target)).getConnectionId());\r
 388         }\r
 389         else if (abstractFlows.containsKey(new FlowName(target))){\r
 390             operationBuilder.setTargetObject(abstractFlows.get(new FlowName(target)).getFlowId());\r
 391         }\r
 392 \r
 393         if (!conditions.isEmpty()){\r
 394             List<ConditionSegment> conditionSegmentList = new LinkedList<ConditionSegment>();\r
 395             long order = 0;\r
 396             for (String conditionName : conditions.keySet()){\r
 397                 String[] condition = conditionName.split(NEMOConstants.comma);\r
 398                 ConditionSegmentBuilder conditionSegmentBuilder = new ConditionSegmentBuilder();\r
 399                 ConditionSegmentId conditionSegmentId = new ConditionSegmentId(UUID.randomUUID().toString());\r
 400                 conditionSegmentBuilder.setKey(new ConditionSegmentKey(conditionSegmentId))\r
 401                                        .setConditionSegmentId(conditionSegmentId)\r
 402                                        .setOrder(order);\r
 403                 String preRelationOperator = condition[0];\r
 404                 if (preRelationOperator == null){\r
 405                     conditionSegmentBuilder.setPrecursorRelationOperator(ConditionSegment.PrecursorRelationOperator.None);\r
 406                 }\r
 407                 else if (preRelationOperator.equals(NEMOConstants.not)){\r
 408                     conditionSegmentBuilder.setPrecursorRelationOperator(ConditionSegment.PrecursorRelationOperator.Not);\r
 409                 }\r
 410                 else if (preRelationOperator.equals(NEMOConstants.and)){\r
 411                     conditionSegmentBuilder.setPrecursorRelationOperator(ConditionSegment.PrecursorRelationOperator.And);\r
 412                 }\r
 413                 else if (preRelationOperator.equals(NEMOConstants.or)){\r
 414                     conditionSegmentBuilder.setPrecursorRelationOperator(ConditionSegment.PrecursorRelationOperator.Or);\r
 415                 }\r
 416 \r
 417                 String condtionName = condition[1];\r
 418                 conditionSegmentBuilder.setConditionParameterName(new ConditionParameterName(condtionName));\r
 419 \r
 420                 String matchPattern = condition[2];\r
 421                 if (matchPattern.equals(NEMOConstants.equal)){\r
 422                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.Equal);\r
 423                 }\r
 424                 else if (matchPattern.equals(NEMOConstants.not_equal)){\r
 425                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.NotEqual);\r
 426                 }\r
 427                 else if (matchPattern.equals(NEMOConstants.greater_than)){\r
 428                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.GreaterThan);\r
 429                 }\r
 430                 else if (matchPattern.equals(NEMOConstants.less_than)){\r
 431                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.LessThan);\r
 432                 }\r
 433                 else if (matchPattern.equals(NEMOConstants.not_less_than)){\r
 434                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.NotLessThan);\r
 435                 }\r
 436                 else if (matchPattern.equals(NEMOConstants.not_greater_than)){\r
 437                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.NotGreaterThan);\r
 438                 }\r
 439                 else if (matchPattern.equals(NEMOConstants.between)){\r
 440                     conditionSegmentBuilder.setConditionParameterMatchPattern(ConditionSegment.ConditionParameterMatchPattern.Between);\r
 441                 }\r
 442 \r
 443                 Map<String, String> targetValue = conditions.get(conditionName);\r
 444                 ConditionParameterTargetValueBuilder valueBuilder = new ConditionParameterTargetValueBuilder();\r
 445                 for (String value : targetValue.keySet()){\r
 446                     if (targetValue.get(value).equals(NEMOConstants.string)){\r
 447                         valueBuilder.setStringValue(value);\r
 448                     }\r
 449                     else if (targetValue.get(value).equals(NEMOConstants.integer)){\r
 450                         valueBuilder.setIntValue(Long.parseLong(value));\r
 451                     }\r
 452                     else if (targetValue.get(value).equals(NEMOConstants.range)){\r
 453                         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.condition.parameter.target.value.RangeValueBuilder rangeValueBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.condition.parameter.target.value.RangeValueBuilder();\r
 454                         String[] values = value.split(NEMOConstants.comma);\r
 455                         rangeValueBuilder.setMax(Long.parseLong(values[0])>Long.parseLong(values[1])?Long.parseLong(values[0]):Long.parseLong(values[1]))\r
 456                                          .setMin(Long.parseLong(values[0])<Long.parseLong(values[1])?Long.parseLong(values[0]):Long.parseLong(values[1]));\r
 457                         valueBuilder.setRangeValue(rangeValueBuilder.build());\r
 458                     }\r
 459                 }\r
 460                 conditionSegmentBuilder.setConditionParameterTargetValue(valueBuilder.build());\r
 461                 order ++;\r
 462                 conditionSegmentList.add(conditionSegmentBuilder.build());\r
 463             }\r
 464             operationBuilder.setConditionSegment(conditionSegmentList);\r
 465         }\r
 466 \r
 467         if (!actions.isEmpty()){\r
 468             List<Action> actionList = new LinkedList<Action>();\r
 469             Long order = 0L;\r
 470             for (String actionName : actions.keySet()){\r
 471                 ActionBuilder actionBuilder = new ActionBuilder();\r
 472                 actionBuilder.setKey(new ActionKey(new ActionName(actionName)))\r
 473                              .setActionName(new ActionName(actionName))\r
 474                              .setOrder(order);\r
 475 \r
 476                 Map<String, String> parameters = actions.get(actionName);\r
 477                 if (parameters!=null){\r
 478                     ParameterValuesBuilder parameterValuesBuilder = new ParameterValuesBuilder();\r
 479                     Long valueOrder = 0L;\r
 480                     List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue> stringValues = new LinkedList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValue>();\r
 481                     List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.IntValue> intValues = new LinkedList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.IntValue>();\r
 482                     org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.RangeValue rangeValue = null;\r
 483 \r
 484                     for (String value : parameters.keySet()){\r
 485                         if (parameters.get(value).equals(NEMOConstants.string)){\r
 486                             org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValueBuilder valueBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValueBuilder();\r
 487                             valueBuilder.setKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.StringValueKey(valueOrder,value))\r
 488                                     .setValue(value)\r
 489                                     .setOrder(valueOrder);\r
 490                             valueOrder++;\r
 491                             stringValues.add(valueBuilder.build());\r
 492                         }\r
 493                         if (parameters.get(value).equals(NEMOConstants.integer)){\r
 494                             org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.IntValueBuilder valueBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.IntValueBuilder();\r
 495                             valueBuilder.setKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.IntValueKey(order,Long.parseLong(value)))\r
 496                                     .setValue(Long.parseLong(value))\r
 497                                     .setOrder(valueOrder);\r
 498                             valueOrder++;\r
 499                             intValues.add(valueBuilder.build());\r
 500                         }\r
 501                         if (parameters.get(value).equals(NEMOConstants.range)){\r
 502                             org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.RangeValueBuilder rangeValueBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.parameter.values.RangeValueBuilder();\r
 503                             String[] range = value.split(",");\r
 504                             valueOrder++;\r
 505                             rangeValueBuilder.setMax(Long.parseLong(range[0])>Long.parseLong(range[1])?Long.parseLong(range[0]):Long.parseLong(range[1]));\r
 506                         }\r
 507                     }\r
 508                     if ((!stringValues.isEmpty()&&intValues.isEmpty()&&rangeValue==null)\r
 509                             ||(stringValues.isEmpty()&&!intValues.isEmpty()&&rangeValue==null)\r
 510                             ||stringValues.isEmpty()&&intValues.isEmpty()&&rangeValue!=null){\r
 511                         parameterValuesBuilder.setStringValue(stringValues.isEmpty()?null:stringValues)\r
 512                                 .setIntValue(intValues.isEmpty()?null:intValues)\r
 513                                 .setRangeValue(rangeValue);\r
 514                         actionBuilder.setParameterValues(parameterValuesBuilder.build());\r
 515                     }\r
 516                     else {\r
 517                         return "The action values are not consistent.";\r
 518                     }\r
 519                 }\r
 520                 actionList.add(actionBuilder.build());\r
 521             }\r
 522             operationBuilder.setAction(actionList);\r
 523         }\r
 524         abstractOperations.put(new OperationName(name),operationBuilder.build());\r
 525         return null;\r
 526     }\r
 527 }\r