verigraph/src/it/polito/verigraph/solver/Scenario.java

   1 /*******************************************************************************
   2  * Copyright (c) 2017 Politecnico di Torino and others.
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Apache License, Version 2.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *******************************************************************************/
   9 package it.polito.verigraph.solver;
  10
  11 import java.io.IOException;
  12 import java.math.BigInteger;
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.LinkedHashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.regex.Matcher;
  19 import java.util.regex.Pattern;
  20 import com.fasterxml.jackson.core.JsonGenerationException;
  21 import com.fasterxml.jackson.databind.JsonMappingException;
  22 import com.fasterxml.jackson.databind.JsonNode;
  23 import com.fasterxml.jackson.databind.ObjectMapper;
  24 import it.polito.verigraph.exception.DataNotFoundException;
  25 import it.polito.verigraph.model.Graph;
  26 import it.polito.verigraph.model.Node;
  27 import it.polito.verigraph.service.VerigraphLogger;
  28
  29 public class Scenario {
  30     Graph graph;
  31     List<String> path=new ArrayList<String>();
  32     public static VerigraphLogger vlogger = VerigraphLogger.getVerigraphlogger();
  33     Map<String, Map<String, String>> chn=new HashMap<String, Map<String, String>>();
  34     Map<String, Map<String, String>> routing=new HashMap<String, Map<String, String>>();
  35     //configurations node:
  36     Map<String, Map<String, String>> config_obj=new HashMap<String, Map<String, String>>();
  37     Map<String,List<String>> config_array=new HashMap<String, List<String>>();
  38     //utility for netcontext:
  39     List<String> nodes_names=new ArrayList<String>();
  40     List<String> nodes_types=new ArrayList<String>();
  41     List<String> nodes_addresses=new ArrayList<String>();
  42
  43     public Scenario(Graph graph, List<String> s) {
  44
  45         this.graph=graph;
  46         this.path=s;
  47     }
  48
  49     @SuppressWarnings("unchecked")
  50     public void createScenario() {
  51         List<Node> nodes=new ArrayList<Node>();
  52
  53         //nodes list creation
  54         for(String s : path){
  55             Node n=graph.searchNodeByName(s);
  56             if(n==null){
  57                 vlogger.logger.info("The node "+n.getName()+" is not present in the graph");
  58                 //System.out.println("The node "+n.getName()+" is not present in the graph");
  59             }
  60             else{
  61                 nodes.add(n);
  62             }
  63         }
  64
  65         //for each node a map is created in order to insert the map in chn
  66         for(int i=0; i<nodes.size(); i++){
  67             String name=nodes.get(i).getName();
  68             nodes_names.add(name);
  69             String type=nodes.get(i).getFunctional_type().toLowerCase();
  70             nodes_types.add(type);
  71             nodes_addresses.add("ip_"+name);
  72             JsonNode configuration=nodes.get(i).getConfiguration().getConfiguration();
  73             //fill chn
  74             Map<String, String> nodo=new HashMap<String, String>();
  75             nodo.put("address", "ip_" + name);
  76             nodo.put("functional_type", type);
  77             chn.put(name, nodo);
  78             //fill routing
  79             Map<String, String> route=new HashMap<String, String>();
  80             for(int k=i-1; ; k--){
  81                 if(k==-1)
  82                     break;
  83                 else{
  84                     String ip_dest="ip_"+nodes.get(k).getName();
  85                     String next_hop=nodes.get(i-1).getName();
  86                     route.put(ip_dest, next_hop);
  87                 }
  88             }
  89             for(int j=i+1; j<nodes.size(); j++){
  90                 String ip_dest="ip_"+nodes.get(j).getName();
  91                 String next_hop=nodes.get(i+1).getName();
  92                 route.put(ip_dest, next_hop);
  93             }
  94             routing.put(name, route);
  95             //fill configuration
  96             setConfiguration(name, type, configuration, config_obj, config_array);
  97         }
  98     }
  99
 100     @SuppressWarnings("unchecked")
 101     private void setConfiguration(String name, String type, JsonNode configuration,
 102             Map<String, Map<String, String>> config_obj2, Map<String, List<String>> config_array2) {
 103         String empty="[]";
 104         switch(type.toUpperCase()){
 105         case "FIREWALL":{
 106             Map<String, String> map=new LinkedHashMap();
 107
 108             if(!configuration.toString().equals(empty)){
 109                 ObjectMapper mapper=new ObjectMapper();
 110                 Map<String, String> map_tmp=new LinkedHashMap();
 111                 String input;
 112                 Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 113                 if(matcher.find()){
 114                     input=matcher.group(1);
 115                 }else
 116                     input=configuration.toString();
 117                 Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 118                 List<String> list = new ArrayList<String>();
 119                 Matcher match= pattern.matcher(input);
 120                 while (match.find()) {
 121                     list.add(match.group());
 122                 }
 123                 try{
 124                     for(String string : list){
 125                         map.putAll(mapper.readValue(string, LinkedHashMap.class));
 126                     }
 127
 128                 }catch(JsonGenerationException e) {
 129                     e.printStackTrace();
 130                 } catch (JsonMappingException e) {
 131                     e.printStackTrace();
 132                 } catch (IOException e) {
 133                     e.printStackTrace();
 134                 }
 135             }
 136             else{
 137                 vlogger.logger.info("Firewall "+name+" empty");
 138             }
 139             config_obj.put(name, map);
 140             break;
 141         }
 142         case "ANTISPAM":{
 143             List<String> source=new ArrayList<String>();
 144
 145             if(!configuration.toString().equals(empty)){
 146                 ObjectMapper mapper=new ObjectMapper();
 147                 try {
 148                     source = mapper.readValue(configuration.toString(), ArrayList.class);
 149                 } catch (JsonGenerationException e) {
 150                     e.printStackTrace();
 151                 } catch (JsonMappingException e) {
 152                     e.printStackTrace();
 153                 } catch (IOException e) {
 154                     e.printStackTrace();
 155                 }
 156             }
 157             else{
 158                 vlogger.logger.info("Antispam "+name+" empty");
 159             }
 160             config_array.put(name, source);
 161             break;
 162         }
 163         case "CACHE":{
 164             List<String> resource=new ArrayList<String>();
 165             if(!configuration.toString().equals(empty)){
 166                 ObjectMapper mapper=new ObjectMapper();
 167                 try {
 168                     List<String> list_tmp=new ArrayList<String>();
 169                     list_tmp = mapper.readValue(configuration.toString(), ArrayList.class);
 170                     if(list_tmp!=null){
 171                         for(String s : list_tmp){
 172                             resource.add("ip_"+s);
 173                         }
 174                     }
 175                 } catch (JsonGenerationException e) {
 176                     e.printStackTrace();
 177                 } catch (JsonMappingException e) {
 178                     e.printStackTrace();
 179                 } catch (IOException e) {
 180                     e.printStackTrace();
 181                 }
 182             }
 183             else{
 184                 vlogger.logger.info("Cache "+name+ " empty");
 185             }
 186             config_array.put(name, resource);
 187             break;
 188         }
 189         case "DPI":{
 190             List<String> notAllowed=new ArrayList<String>();
 191
 192             if(!configuration.toString().equals(empty)){
 193                 ObjectMapper mapper=new ObjectMapper();
 194                 try {
 195                     notAllowed = mapper.readValue(configuration.toString(), ArrayList.class);
 196                 } catch (JsonGenerationException e) {
 197                     e.printStackTrace();
 198                 } catch (JsonMappingException e) {
 199                     e.printStackTrace();
 200                 } catch (IOException e) {
 201                     e.printStackTrace();
 202                 }
 203             }
 204             else{
 205                 vlogger.logger.info("Dpi "+name+ " empty");
 206             }
 207             config_array.put(name, notAllowed);
 208             break;
 209         }
 210         case "ENDHOST":{
 211             Map<String, String> map=new LinkedHashMap();
 212             if(!configuration.toString().equals(empty)){
 213                 ObjectMapper mapper=new ObjectMapper();
 214                 Map<String, String> map_tmp=new LinkedHashMap();
 215                 String input;
 216                 Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 217                 if(matcher.find()){
 218                     input=matcher.group(1);
 219                 }else
 220                     input=configuration.toString();
 221                 try{
 222                     map=mapper.readValue(input, java.util.LinkedHashMap.class);
 223                     String ip=map.get("destination");
 224                     if(ip!=null){
 225                         map.put("destination", "ip_"+ip);
 226                     }
 227                 }catch(JsonGenerationException e) {
 228                     e.printStackTrace();
 229                 } catch (JsonMappingException e) {
 230                     e.printStackTrace();
 231                 } catch (IOException e) {
 232                     e.printStackTrace();
 233                 }
 234             }
 235             else{
 236                 vlogger.logger.info("Endhost "+name+ " empty");
 237             }
 238             config_obj.put(name, map);
 239             break;
 240         }
 241         case "ENDPOINT":{
 242             Map<String, String> map=new LinkedHashMap();
 243             config_obj.put(name, map);
 244             break;
 245         }
 246         case "FIELDMODIFIER":{
 247             Map<String, String> map=new LinkedHashMap();
 248
 249             if(!configuration.toString().equals(empty)){
 250                 ObjectMapper mapper=new ObjectMapper();
 251
 252                 if(!configuration.toString().isEmpty()){
 253                     String input;
 254                     Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 255                     if(matcher.find()){
 256                         input=matcher.group(1);
 257                     }else
 258                         input=configuration.toString();
 259
 260                     Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 261                     List<String> list = new ArrayList<String>();
 262                     Matcher match= pattern.matcher(input);
 263                     while (match.find()) {
 264                         list.add(match.group());
 265                     }
 266
 267                     try{
 268                         for(String string : list){
 269                             map.putAll(mapper.readValue(string, LinkedHashMap.class));
 270                         }
 271                     }catch(JsonGenerationException e) {
 272                         e.printStackTrace();
 273                     } catch (JsonMappingException e) {
 274                         e.printStackTrace();
 275                     } catch (IOException e) {
 276                         e.printStackTrace();
 277                     }
 278                 }
 279             }
 280             else{
 281                 vlogger.logger.info("Fieldmodifier "+name+ " empty");
 282             }
 283             config_obj.put(name, map);
 284             break;
 285         }
 286         case "MAILCLIENT":{
 287             Map<String, String> map=new LinkedHashMap();
 288             ObjectMapper mapper=new ObjectMapper();
 289             String input;
 290             Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 291             if(matcher.find()){
 292                 input=matcher.group(1);
 293             }else
 294                 input=configuration.toString();
 295             Map<String, String> map_tmp=new LinkedHashMap();
 296             Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 297             List<String> list = new ArrayList<String>();
 298             Matcher match= pattern.matcher(input);
 299             while (match.find()) {
 300                 list.add(match.group());
 301             }
 302             try{
 303                 for(String string : list){
 304                     map.putAll(mapper.readValue(string, LinkedHashMap.class));
 305                 }
 306                 String ip=map.get("mailserver");
 307                 if(ip!=null){
 308                     map.put("mailserver", "ip_"+ip);
 309                     if(!path.contains(ip)){
 310                         if(!nodes_addresses.contains("ip_"+ip))
 311                             nodes_addresses.add("ip_"+ip);
 312                     }
 313                 }
 314             }catch(JsonGenerationException e) {
 315                 e.printStackTrace();
 316             } catch (JsonMappingException e) {
 317                 e.printStackTrace();
 318             } catch (IOException e) {
 319                 e.printStackTrace();
 320             }
 321             config_obj.put(name, map);
 322             break;
 323         }
 324         case "MAILSERVER":{
 325             Map<String, String> map=new LinkedHashMap();
 326             if(!configuration.toString().equals(empty)){
 327                 ObjectMapper mapper=new ObjectMapper();
 328                 String input;
 329                 Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 330                 if(matcher.find()){
 331                     input=matcher.group(1);
 332                 }else
 333                     input=configuration.toString();
 334
 335                 Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 336                 List<String> list = new ArrayList<String>();
 337                 Matcher match= pattern.matcher(input);
 338                 while (match.find()) {
 339                     list.add(match.group());
 340                 }
 341                 try{
 342                     for(String string : list){
 343                         /*only one object*/
 344                         map.putAll(mapper.readValue(string, LinkedHashMap.class));
 345                     }
 346                 }catch(JsonGenerationException e) {
 347                     e.printStackTrace();
 348                 } catch (JsonMappingException e) {
 349                     e.printStackTrace();
 350                 } catch (IOException e) {
 351                     e.printStackTrace();
 352                 }
 353             }
 354             else{
 355                 vlogger.logger.info("Mailserver "+name+ " empty");
 356             }
 357             config_obj.put(name, map);
 358             break;
 359         }
 360         case "NAT":{
 361             List<String> source=new ArrayList<String>();
 362             if(!configuration.toString().equals(empty)){
 363                 ObjectMapper mapper=new ObjectMapper();
 364                 List<String> list=new ArrayList<String>();
 365                 try {
 366                     list = mapper.readValue(configuration.toString(), ArrayList.class);
 367                     if(!list.isEmpty()){
 368                         for(String s : list){
 369                             source.add("ip_"+s);
 370                         }
 371                     }
 372                 } catch (JsonGenerationException e) {
 373                     e.printStackTrace();
 374                 } catch (JsonMappingException e) {
 375                     e.printStackTrace();
 376                 } catch (IOException e) {
 377                     e.printStackTrace();
 378                 }
 379             }
 380             else{
 381                 vlogger.logger.info("Nat "+name+ " empty");
 382             }
 383             config_array.put(name, source);
 384             break;
 385         }
 386         case "VPNACCESS":{
 387             ObjectMapper mapper=new ObjectMapper();
 388             Map<String, String> map=new LinkedHashMap();
 389             String input;
 390             Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 391             if(matcher.find()){
 392                 input=matcher.group(1);
 393             }else
 394                 input=configuration.toString();
 395             Map<String, String> map_tmp=new LinkedHashMap();
 396             Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 397             List<String> list = new ArrayList<String>();
 398             Matcher match= pattern.matcher(input);
 399             while (match.find()) {
 400                 list.add(match.group());
 401             }
 402             try{
 403                 for(String string : list){
 404                     map.putAll(mapper.readValue(string, LinkedHashMap.class));
 405                 }
 406                 String ip=map.get("vpnexit");
 407                 if(ip!=null){
 408                     map.put("vpnexit", "ip_"+ip);
 409                     if(!path.contains(ip)){
 410                         if(!nodes_addresses.contains("ip_"+ip))
 411                             nodes_addresses.add("ip_"+ip);
 412                     }
 413                 }
 414             }catch(JsonGenerationException e) {
 415                 e.printStackTrace();
 416             } catch (JsonMappingException e) {
 417                 e.printStackTrace();
 418             } catch (IOException e) {
 419                 e.printStackTrace();
 420             }
 421             config_obj.put(name, map);
 422             break;
 423         }
 424         case "VPNEXIT":{
 425             ObjectMapper mapper=new ObjectMapper();
 426             Map<String, String> map=new LinkedHashMap();
 427             String input;
 428             Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 429             if(matcher.find()){
 430                 input=matcher.group(1);
 431             }else
 432                 input=configuration.toString();
 433             Map<String, String> map_tmp=new LinkedHashMap();
 434             Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 435             List<String> list = new ArrayList<String>();
 436             Matcher match= pattern.matcher(input);
 437             while (match.find()) {
 438                 list.add(match.group());
 439             }
 440             try{
 441                 for(String string : list){
 442                     /*only 1 string */
 443                     map_tmp.putAll(mapper.readValue(string, LinkedHashMap.class));
 444                 }
 445                 String ip=map.get("vpnaccess");
 446                 if(ip!=null){
 447                     map.put("vpnaccess", "ip_"+ip);
 448                     if(!path.contains(ip)){
 449                         if(!nodes_addresses.contains("ip_"+ip))
 450                             nodes_addresses.add("ip_"+ip);
 451                     }
 452                 }
 453             }catch(JsonGenerationException e) {
 454                 e.printStackTrace();
 455             } catch (JsonMappingException e) {
 456                 e.printStackTrace();
 457             } catch (IOException e) {
 458                 e.printStackTrace();
 459             }
 460             config_obj.put(name, map);
 461             break;
 462         }
 463         case "WEBCLIENT":{
 464             Map<String, String> map=new LinkedHashMap();
 465             ObjectMapper mapper=new ObjectMapper();
 466             String input;
 467             Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 468             if(matcher.find()){
 469                 input=matcher.group(1);
 470             }else
 471                 input=configuration.toString();
 472
 473             Pattern pattern=Pattern.compile("\\{([^\\}]*)\\}");
 474             List<String> list = new ArrayList<String>();
 475             Matcher match= pattern.matcher(input);
 476             while (match.find()) {
 477                 list.add(match.group());
 478             }
 479             try{
 480                 for(String string : list){
 481                     /*only 1 string */
 482                     map.putAll(mapper.readValue(string, LinkedHashMap.class));
 483                 }
 484             }catch(JsonGenerationException e) {
 485                 e.printStackTrace();
 486             } catch (JsonMappingException e) {
 487                 e.printStackTrace();
 488             } catch (IOException e) {
 489                 e.printStackTrace();
 490             }
 491             config_obj.put(name, map);
 492             break;
 493         }
 494         case "WEBSERVER":{
 495             Map<String, String> map=new LinkedHashMap();
 496             if(!configuration.toString().equals(empty)){
 497                 ObjectMapper mapper=new ObjectMapper();
 498                 if(configuration.toString().equals(empty)){
 499                     break;
 500                 }else{
 501                     String input;
 502                     Matcher matcher = Pattern.compile("\\[([^\\]]*)\\]").matcher(configuration.toString());
 503                     if(matcher.find()){
 504                         input=matcher.group(1);
 505                     }else
 506                         input=configuration.toString();
 507                     try{
 508                         /*readValue reads only 1 value of 1 object*/
 509                         map=mapper.readValue(input, java.util.LinkedHashMap.class);
 510                     }catch(JsonGenerationException e) {
 511                         e.printStackTrace();
 512                     } catch (JsonMappingException e) {
 513                         e.printStackTrace();
 514                     } catch (IOException e) {
 515                         e.printStackTrace();
 516                     }
 517                 }
 518             }
 519             else{
 520                 vlogger.logger.info("Webserver "+name+ " empty");
 521             }
 522             config_obj.put(name, map);
 523             break;
 524         }
 525         default:{
 526             throw new DataNotFoundException("The type "+type+ " is not valid");
 527         }
 528         }
 529     }
 530
 531     private void checkConfiguration(List<String> source) {
 532         for(int i=0; i<source.size(); i++){
 533             if(!path.contains(source.get(i))){
 534                 if(!nodes_addresses.contains("ip_"+source.get(i)))
 535                     nodes_addresses.add("ip_"+source.get(i));
 536             }
 537         }
 538     }
 539
 540     private void checkConfiguration(Map<String, String> map) {
 541         Map<String, String> m=new HashMap<String, String>();
 542         for(Map.Entry<String, String> a : map.entrySet()){
 543             if(a.getKey()!=null){
 544                 if(!path.contains(a.getKey())){
 545                     if(!nodes_addresses.contains("ip_"+a.getKey()))
 546                         nodes_addresses.add("ip_"+a.getKey());
 547                 }
 548             }
 549             if(a.getValue()!=null){
 550                 if(!path.contains(a.getValue())){
 551                     if(!nodes_addresses.contains("ip_"+a.getValue()))
 552                         nodes_addresses.add("ip_"+a.getValue());
 553                 }
 554             }
 555         }
 556     }
 557 }