X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/31bfa073530d5b1154c51c5f5f24269a7399409a..c5aa7b7c598d419a5cefb614b922563d31e4942e:/src/surf/surf_routing.c

diff --git a/src/surf/surf_routing.c b/src/surf/surf_routing.c
index 3cf2818419..eaa3f87228 100644
--- a/src/surf/surf_routing.c
+++ b/src/surf/surf_routing.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2009, 2010. The SimGrid Team. 
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -86,6 +86,8 @@ static void generic_set_bypassroute(routing_component_t rc, const char* src, con
 /* ************************************************************************** */
 /* *************** GENERIC BUSINESS METHODS (declarations) ****************** */
 
+static xbt_dict_t generic_get_onelink_routes (void);
+static int generic_is_router (const char *name);
 static route_extended_t generic_get_bypassroute(routing_component_t rc, const char* src, const char* dst);
 
 /* ************************************************************************** */
@@ -111,16 +113,35 @@ static xbt_dynar_t link_list = NULL; /* temporary store of current list link of
 /**
  * \brief Add a "host" to the network element list
  */
-static void  parse_S_host(void) {
+static void  parse_S_host(char* host_id) {
   if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_BASE;
-  xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,A_surfxml_host_id),
-      "Reading a host, processing unit \"%s\" already exist",A_surfxml_host_id);
+  xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,host_id),
+      "Reading a host, processing unit \"%s\" already exist",host_id);
   xbt_assert1(current_routing->set_processing_unit,
       "no defined method \"set_processing_unit\" in \"%s\"",current_routing->name);
-  (*(current_routing->set_processing_unit))(current_routing,A_surfxml_host_id);
-  xbt_dict_set(global_routing->where_network_elements,A_surfxml_host_id,(void*)current_routing,NULL); 
+  (*(current_routing->set_processing_unit))(current_routing,host_id);
+  xbt_dict_set(global_routing->where_network_elements,host_id,(void*)current_routing,NULL);
 }
 
+/*
+ * \brief Add a host to the network element list from XML
+ */
+static void parse_S_host_XML(void)
+{
+	parse_S_host(A_surfxml_host_id);
+}
+
+/*
+ * \brief Add a host to the network element list from lua script
+ */
+static void parse_S_host_lua(char *host_id)
+{
+	parse_S_host(host_id);
+}
+/*
+ *
+ */
+
 /**
  * \brief Add a "router" to the network element list
  */
@@ -132,21 +153,40 @@ static void parse_S_router(void) {
       "no defined method \"set_processing_unit\" in \"%s\"",current_routing->name);
   (*(current_routing->set_processing_unit))(current_routing,A_surfxml_router_id);
   xbt_dict_set(global_routing->where_network_elements,A_surfxml_router_id,(void*)current_routing,NULL); 
+  #ifdef HAVE_TRACING
+    TRACE_surf_host_declaration (A_surfxml_router_id, 0);
+  #endif
 }
 
 /**
  * \brief Set the endponints for a route
  */
-static void parse_S_route_new_and_endpoints(void) {
+static void parse_S_route_new_and_endpoints(char *src_id,char *dst_id) {
   if( src != NULL && dst != NULL && link_list != NULL )
-    THROW2(arg_error,0,"Route between %s to %s can not be defined",A_surfxml_route_src,A_surfxml_route_dst);
-  src = A_surfxml_route_src;
-  dst = A_surfxml_route_dst;
+    THROW2(arg_error,0,"Route between %s to %s can not be defined",src_id,dst_id);
+  src = src_id;
+  dst = dst_id;
   xbt_assert2(strlen(src)>0||strlen(dst)>0,
       "Some limits are null in the route between \"%s\" and \"%s\"",src,dst);
   link_list = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
 }
 
+/**
+ * \breif Set the endpoints for a route from XML
+ */
+static void parse_S_route_new_and_endpoints_XML(void)
+{
+	parse_S_route_new_and_endpoints(A_surfxml_route_src,A_surfxml_route_dst);
+}
+
+/**
+ * \breif Set the endpoints for a route from lua
+ */
+static void parse_S_route_new_and_endpoints_lua(char *id_src,char *id_dst)
+{
+	parse_S_route_new_and_endpoints(id_src,id_dst);
+}
+
 /**
  * \brief Set the endponints and gateways for a ASroute
  */
@@ -180,12 +220,29 @@ static void parse_S_bypassRoute_new_and_endpoints(void) {
 /**
  * \brief Set a new link on the actual list of link for a route or ASroute
  */
-static void parse_E_link_c_ctn_new_elem(void) {
+static void parse_E_link_ctn_new_elem(char *link_id) {
   char *val;
-  val = xbt_strdup(A_surfxml_link_c_ctn_id);
+  val = xbt_strdup(link_id);
   xbt_dynar_push(link_list, &val);
 }
 
+/**
+ * \brief Set a new link on the actual list of link for a route or ASroute from XML
+ */
+
+static void parse_E_link_ctn_new_elem_XML(void)
+{
+	parse_E_link_ctn_new_elem(A_surfxml_link_ctn_id);
+}
+
+/**
+ * \brief Set a new link on the actual list of link for a route or ASroute from lua
+ */
+static void parse_E_link_c_ctn_new_elem_lua(char *link_id) {
+
+	parse_E_link_ctn_new_elem(link_id);
+}
+
 /**
  * \brief Store the route by calling the set_route function of the current routing component
  */
@@ -246,13 +303,13 @@ static void parse_E_bypassRoute_store_route(void) {
 /**
  * \brief Make a new routing component
  *
- * Detect the routing model type of the routing component, make the new structure and
+ * make the new structure and
  * set the parsing functions to allows parsing the part of the routing tree
  */
-static void parse_S_AS(void) { 
+static void parse_S_AS(char* AS_id,char* AS_routing) {
   routing_component_t new_routing;
   model_type_t model = NULL;
-  char* wanted = A_surfxml_AS_routing;
+  char* wanted = AS_routing;
   int cpt;
   /* seach the routing model */
   for (cpt=0;routing_models[cpt].name;cpt++)
@@ -271,7 +328,7 @@ static void parse_S_AS(void) {
   new_routing = (routing_component_t)(*(model->create))();
   new_routing->routing = model;
   new_routing->hierarchy = SURF_ROUTING_NULL;
-  new_routing->name = xbt_strdup(A_surfxml_AS_id);
+  new_routing->name = xbt_strdup(AS_id);
   new_routing->routing_sons = xbt_dict_new();
   //INFO2("Routing %s for AS %s",A_surfxml_AS_routing,A_surfxml_AS_id);
   
@@ -283,16 +340,16 @@ static void parse_S_AS(void) {
     
   } else if( current_routing != NULL && global_routing->root != NULL ) { 
     
-    xbt_assert1(!xbt_dict_get_or_null(current_routing->routing_sons,A_surfxml_AS_id),
-           "The AS \"%s\" already exist",A_surfxml_AS_id);
+    xbt_assert1(!xbt_dict_get_or_null(current_routing->routing_sons,AS_id),
+           "The AS \"%s\" already exist",AS_id);
      /* it is a part of the tree */
     new_routing->routing_father = current_routing;
     /* set the father behavior */
     if( current_routing->hierarchy == SURF_ROUTING_NULL ) current_routing->hierarchy = SURF_ROUTING_RECURSIVE;
     /* add to the sons dictionary */
-    xbt_dict_set(current_routing->routing_sons,A_surfxml_AS_id,(void*)new_routing,NULL);
+    xbt_dict_set(current_routing->routing_sons,AS_id,(void*)new_routing,NULL);
     /* add to the father element list */
-    (*(current_routing->set_autonomous_system))(current_routing,A_surfxml_AS_id);
+    (*(current_routing->set_autonomous_system))(current_routing,AS_id);
     /* unload the prev parse rules */
     (*(current_routing->routing->unload))();
     
@@ -305,16 +362,33 @@ static void parse_S_AS(void) {
   current_routing = new_routing;
 }
 
+/*
+ * Detect the routing model type of the routing component from XML platforms
+ */
+static void parse_S_AS_XML(void)
+{
+	parse_S_AS(A_surfxml_AS_id,A_surfxml_AS_routing);
+}
+
+/*
+ * define the routing model type of routing component from lua script
+ */
+static void parse_S_AS_lua(char* id,char* mode)
+{
+	parse_S_AS(id,mode);
+}
+
+
 /**
  * \brief Finish the creation of a new routing component
  *
  * When you finish to read the routing component, other structures must be created. 
  * the "end" method allow to do that for any routing model type
  */
-static void parse_E_AS(void) {
+static void parse_E_AS(char *AS_id) {
 
   if( current_routing == NULL ) {
-    THROW1(arg_error,0,"Close AS(%s), that never open",A_surfxml_AS_id);
+    THROW1(arg_error,0,"Close AS(%s), that never open",AS_id);
   } else {
       xbt_assert1(!xbt_dict_get_or_null(global_routing->where_network_elements,current_routing->name),
           "The AS \"%s\" already exist",current_routing->name);
@@ -327,6 +401,22 @@ static void parse_E_AS(void) {
   }
 }
 
+/*
+ * \brief Finish the creation of a new routing component from XML
+ */
+static void parse_E_AS_XML(void)
+{
+	parse_E_AS(A_surfxml_AS_id);
+}
+
+/*
+ * \brief Finish the creation of a new routing component from lua
+ */
+static void parse_E_AS_lua(char *id)
+{
+	parse_E_AS(id);
+}
+
 /* Aux Business methods */
 
 /**
@@ -428,7 +518,7 @@ static route_extended_t _get_route(const char* src,const char* dst) {
      
   xbt_assert0(src&&dst,"bad parameters for \"_get_route\" method");
   
-  route_extended_t e_route, e_route_cnt, e_route_src, e_route_dst;
+  route_extended_t e_route, e_route_cnt, e_route_src=NULL, e_route_dst=NULL;
   
   xbt_dynar_t elem_father_list = elements_father(src,dst);
   
@@ -581,14 +671,14 @@ static void finalize(void) {
   xbt_free(global_routing);
 }
 
-static void get_onelink_routes(void)
+static xbt_dict_t get_onelink_routes(void)
 {
-	xbt_die("get_onelink_routes function not implemented yet!!!");
+	xbt_die("global \"get_onelink_routes\" function not implemented yet");
 }
 
 static int is_router(const char *name)
 {
-	xbt_die("is_router function not implemented yet!!!");
+	xbt_die("global \"is_router\" function not implemented yet");
 }
 
 /**
@@ -603,6 +693,8 @@ void routing_model_create(size_t size_of_links, void* loopback) {
   global_routing->where_network_elements = xbt_dict_new();
   global_routing->root = NULL;
   global_routing->get_route = get_route;
+  global_routing->get_onelink_routes = get_onelink_routes;
+  global_routing->is_router = is_router;
   global_routing->finalize = finalize;
   global_routing->loopback = loopback;
   global_routing->size_of_link = size_of_links;
@@ -612,21 +704,21 @@ void routing_model_create(size_t size_of_links, void* loopback) {
   current_routing = NULL;
 
   /* parse generic elements */
-  surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host);
+  surfxml_add_callback(STag_surfxml_host_cb_list, &parse_S_host_XML);
   surfxml_add_callback(STag_surfxml_router_cb_list, &parse_S_router);
 
-  surfxml_add_callback(STag_surfxml_route_cb_list, &parse_S_route_new_and_endpoints);
+  surfxml_add_callback(STag_surfxml_route_cb_list, &parse_S_route_new_and_endpoints_XML);
   surfxml_add_callback(STag_surfxml_ASroute_cb_list, &parse_S_ASroute_new_and_endpoints);
   surfxml_add_callback(STag_surfxml_bypassRoute_cb_list, &parse_S_bypassRoute_new_and_endpoints);
   
-  surfxml_add_callback(ETag_surfxml_link_c_ctn_cb_list, &parse_E_link_c_ctn_new_elem);
+  surfxml_add_callback(ETag_surfxml_link_ctn_cb_list, &parse_E_link_ctn_new_elem_XML);
   
   surfxml_add_callback(ETag_surfxml_route_cb_list, &parse_E_route_store_route);
   surfxml_add_callback(ETag_surfxml_ASroute_cb_list, &parse_E_ASroute_store_route);
   surfxml_add_callback(ETag_surfxml_bypassRoute_cb_list, &parse_E_bypassRoute_store_route);
   
-  surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS);
-  surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS);
+  surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS_XML);
+  surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS_XML);
 
   surfxml_add_callback(STag_surfxml_cluster_cb_list, &routing_full_parse_Scluster);
 
@@ -648,6 +740,15 @@ typedef struct {
 } s_routing_component_full_t,*routing_component_full_t;
 
 /* Business methods */
+static xbt_dict_t full_get_onelink_routes(void)
+{
+  xbt_die("\"full_get_onelink_routes\" function not implemented yet");
+}
+
+static int full_is_router(const char *name)
+{
+  xbt_die("\"full_is_router\" function not implemented yet");
+}
 
 static route_extended_t full_get_route(routing_component_t rc, const char* src,const char* dst) {
   xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name);
@@ -709,6 +810,8 @@ static void* model_full_create(void) {
   new_component->generic_routing.set_ASroute = generic_set_ASroute;
   new_component->generic_routing.set_bypassroute = generic_set_bypassroute;
   new_component->generic_routing.get_route = full_get_route;
+  new_component->generic_routing.get_onelink_routes = full_get_onelink_routes;
+  new_component->generic_routing.is_router = full_is_router;
   new_component->generic_routing.get_bypass_route = generic_get_bypassroute;
   new_component->generic_routing.finalize = full_finalize;
   new_component->to_index = xbt_dict_new();
@@ -807,6 +910,15 @@ typedef struct {
 } s_routing_component_floyd_t,*routing_component_floyd_t;
 
 /* Business methods */
+static xbt_dict_t floyd_get_onelink_routes(void)
+{
+  xbt_die("\"floyd_get_onelink_routes\" function not implemented yet");
+}
+
+static int floyd_is_router(const char *name)
+{
+  xbt_die("\"floyd_is_router\" function not implemented yet");
+}
 
 static route_extended_t floyd_get_route(routing_component_t rc, const char* src,const char* dst) {
   xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name);
@@ -829,7 +941,7 @@ static route_extended_t floyd_get_route(routing_component_t rc, const char* src,
   int first = 1;
   int pred = *dst_id;
   int prev_pred = 0;
-  char *gw_src,*gw_dst, *prev_gw_src,*prev_gw_dst, *first_gw;
+  char *gw_src=NULL,*gw_dst=NULL, *prev_gw_src,*prev_gw_dst, *first_gw=NULL;
   unsigned int cpt;
   void* link;
   xbt_dynar_t links;
@@ -907,6 +1019,8 @@ static void* model_floyd_create(void) {
   new_component->generic_routing.set_ASroute = generic_set_ASroute;
   new_component->generic_routing.set_bypassroute = generic_set_bypassroute;
   new_component->generic_routing.get_route = floyd_get_route;
+  new_component->generic_routing.get_onelink_routes = floyd_get_onelink_routes;
+  new_component->generic_routing.is_router = floyd_is_router;
   new_component->generic_routing.get_bypass_route = generic_get_bypassroute;
   new_component->generic_routing.finalize = floyd_finalize;
   new_component->to_index = xbt_dict_new();
@@ -1155,6 +1269,15 @@ static void add_loopback_dijkstra(routing_component_dijkstra_t rc) {
 }
 
 /* Business methods */
+static xbt_dict_t dijkstra_get_onelink_routes(void)
+{
+  xbt_die("\"dijkstra_get_onelink_routes\" function not implemented yet");
+}
+
+static int dijkstra_is_router(const char *name)
+{
+  xbt_die("\"dijkstra_is_router\" function not implemented yet");
+}
 
 static route_extended_t dijkstra_get_route(routing_component_t rc, const char* src,const char* dst) {
   xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name);
@@ -1279,7 +1402,7 @@ static route_extended_t dijkstra_get_route(routing_component_t rc, const char* s
   }
   
   /* compose route path with links */
-  char *gw_src,*gw_dst, *prev_gw_src,*prev_gw_dst, *first_gw;
+  char *gw_src=NULL,*gw_dst=NULL, *prev_gw_src,*prev_gw_dst, *first_gw=NULL;
   
   for(v = dst_node_id; v != src_node_id; v = pred_arr[v]) {
     xbt_node_t node_pred_v = xbt_dynar_get_as(nodes, pred_arr[v], xbt_node_t);
@@ -1361,6 +1484,8 @@ static void* model_dijkstra_both_create(int cached) {
   new_component->generic_routing.set_ASroute = generic_set_ASroute;
   new_component->generic_routing.set_bypassroute = generic_set_bypassroute;
   new_component->generic_routing.get_route = dijkstra_get_route;
+  new_component->generic_routing.get_onelink_routes = dijkstra_get_onelink_routes;
+  new_component->generic_routing.is_router = dijkstra_is_router;
   new_component->generic_routing.get_bypass_route = generic_get_bypassroute;
   new_component->generic_routing.finalize = dijkstra_finalize;
   new_component->cached = cached;
@@ -1535,7 +1660,7 @@ static void model_rulebased_set_ASroute(routing_component_t rc, const char* src,
 }
 
 static void model_rulebased_set_bypassroute(routing_component_t rc, const char* src, const char* dst, route_extended_t e_route) {
-  xbt_die("bypass routing not support for Route-Based model");
+  xbt_die("bypass routing not supported for Route-Based model");
 }
 
 #define BUFFER_SIZE 4096  /* result buffer size */
@@ -1603,6 +1728,16 @@ static char* remplace(char* value, const char** src_list, int src_size, const ch
   return xbt_strdup(result_result);
 }
 
+static xbt_dict_t rulebased_get_onelink_routes(void)
+{
+  xbt_die("\"rulebased_get_onelink_routes\" function not implemented yet");
+}
+
+static int rulebased_is_router(const char *name)
+{
+  xbt_die("\"rulebased_is_router\" function not implemented yet");
+}
+
 /* Business methods */
 static route_extended_t rulebased_get_route(routing_component_t rc, const char* src,const char* dst) {
   xbt_assert1(rc&&src&&dst, "Invalid params for \"get_route\" function at AS \"%s\"",rc->name);
@@ -1705,6 +1840,8 @@ static void* model_rulebased_create(void) {
   new_component->generic_routing.set_route = model_rulebased_set_route;
   new_component->generic_routing.set_ASroute = model_rulebased_set_ASroute;
   new_component->generic_routing.set_bypassroute = model_rulebased_set_bypassroute;
+  new_component->generic_routing.get_onelink_routes = rulebased_get_onelink_routes;
+  new_component->generic_routing.is_router = rulebased_is_router;
   new_component->generic_routing.get_route = rulebased_get_route;
   new_component->generic_routing.get_bypass_route = NULL; //rulebased_get_bypass_route;
   new_component->generic_routing.finalize = rulebased_finalize;
@@ -1736,6 +1873,12 @@ typedef struct {
 } s_routing_component_none_t,*routing_component_none_t;
 
 /* Business methods */
+static xbt_dict_t none_get_onelink_routes(void){
+  return NULL;
+}
+static int none_is_router(const char *name){
+  return -1;
+}
 static route_extended_t none_get_route(routing_component_t rc, const char* src,const char* dst){
   return NULL;
 }
@@ -1758,6 +1901,8 @@ static void* model_none_create(void) {
   new_component->generic_routing.set_ASroute = NULL;
   new_component->generic_routing.set_bypassroute = NULL;
   new_component->generic_routing.get_route = none_get_route;
+  new_component->generic_routing.get_onelink_routes = none_get_onelink_routes;
+  new_component->generic_routing.is_router = none_is_router;
   new_component->generic_routing.get_bypass_route = none_get_bypass_route;
   new_component->generic_routing.finalize = none_finalize;
   return new_component;
@@ -1828,7 +1973,7 @@ static void generic_set_processing_unit(routing_component_t rc, const char* name
           modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE])
     _to_index = ((routing_component_dijkstra_t)rc)->to_index;
   
-  else xbt_die("\"generic_set_processing_unit\" not support");
+  else xbt_die("\"generic_set_processing_unit\" not supported");
   *id = xbt_dict_length(_to_index);
   xbt_dict_set(_to_index,name,id,xbt_free);
 }
@@ -1848,7 +1993,7 @@ static void generic_set_autonomous_system(routing_component_t rc, const char* na
           modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE])
     _to_index = ((routing_component_dijkstra_t)rc)->to_index;
   
-  else xbt_die("\"generic_set_autonomous_system\" not support");
+  else xbt_die("\"generic_set_autonomous_system\" not supported");
   *id = xbt_dict_length(_to_index);
   xbt_dict_set(_to_index,name,id,xbt_free);
 }
@@ -1874,7 +2019,7 @@ static void generic_set_route(routing_component_t rc, const char* src, const cha
     _parse_routes = ((routing_component_dijkstra_t)rc)->parse_routes;
     _to_index = ((routing_component_dijkstra_t)rc)->to_index;
   
-  } else xbt_die("\"generic_set_route\" not support");
+  } else xbt_die("\"generic_set_route\" not supported");
 
   src_id = xbt_dict_get_or_null(_to_index, src);
   dst_id = xbt_dict_get_or_null(_to_index, dst);
@@ -1911,7 +2056,7 @@ static void generic_set_ASroute(routing_component_t rc, const char* src, const c
     _parse_routes = ((routing_component_dijkstra_t)rc)->parse_routes;
     _to_index = ((routing_component_dijkstra_t)rc)->to_index;
   
-  } else xbt_die("\"generic_set_route\" not support");
+  } else xbt_die("\"generic_set_route\" not supported");
   
   src_id = xbt_dict_get_or_null(_to_index, src);
   dst_id = xbt_dict_get_or_null(_to_index, dst);
@@ -1939,7 +2084,7 @@ static void generic_set_bypassroute(routing_component_t rc, const char* src, con
   } else if(modeltype==&routing_models[SURF_MODEL_DIJKSTRA]||
           modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE]) {
     dict_bypassRoutes = ((routing_component_dijkstra_t)rc)->bypassRoutes;
-  } else xbt_die("\"generic_set_bypassroute\" not support");
+  } else xbt_die("\"generic_set_bypassroute\" not supported");
   route_name = bprintf("%s#%s",src,dst);
   xbt_assert2(xbt_dynar_length(e_route->generic_route.link_list)>0, "Invalid count of links, must be greater than zero (%s,%s)",src,dst);
   xbt_assert4(!xbt_dict_get_or_null(dict_bypassRoutes,route_name),
@@ -1956,6 +2101,16 @@ static void generic_set_bypassroute(routing_component_t rc, const char* src, con
 /* ************************************************************************** */
 /* *********************** GENERIC BUSINESS METHODS ************************* */
 
+static xbt_dict_t generic_get_onelink_routes (void)
+{
+  xbt_die("\"generic_get_onelink_routes\" not implemented yet");
+}
+
+static int generic_is_router (const char *name)
+{
+  xbt_die("\"generic_is_router\" not implemented yet");
+}
+
 static route_extended_t generic_get_bypassroute(routing_component_t rc, const char* src, const char* dst) {
   model_type_t modeltype = rc->routing;
   xbt_dict_t dict_bypassRoutes;
@@ -1967,7 +2122,7 @@ static route_extended_t generic_get_bypassroute(routing_component_t rc, const ch
   } else if(modeltype==&routing_models[SURF_MODEL_DIJKSTRA]||
           modeltype==&routing_models[SURF_MODEL_DIJKSTRACACHE]) {
     dict_bypassRoutes = ((routing_component_dijkstra_t)rc)->bypassRoutes;
-  } else xbt_die("\"generic_set_bypassroute\" not support");
+  } else xbt_die("\"generic_get_bypassroute\" not supported");
  
 
   routing_component_t src_as, dst_as;
@@ -2372,19 +2527,19 @@ static void routing_full_parse_Scluster(void)
 	SURFXML_START_TAG(route);
 
 	DEBUG1("<link:ctn\tid=\"%s_link_$1src\"/>",cluster_id);
-	SURFXML_BUFFER_SET(link_c_ctn_id, bprintf("%s_link_$1src",cluster_id));
-	SURFXML_START_TAG(link_c_ctn);
-	SURFXML_END_TAG(link_c_ctn);
+	SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1src",cluster_id));
+	SURFXML_START_TAG(link_ctn);
+	SURFXML_END_TAG(link_ctn);
 
 	DEBUG1("<link:ctn\tid=\"%s_backbone\"/>",cluster_id);
-	SURFXML_BUFFER_SET(link_c_ctn_id, bprintf("%s_backbone",cluster_id));
-	SURFXML_START_TAG(link_c_ctn);
-	SURFXML_END_TAG(link_c_ctn);
+	SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_backbone",cluster_id));
+	SURFXML_START_TAG(link_ctn);
+	SURFXML_END_TAG(link_ctn);
 
 	DEBUG1("<link:ctn\tid=\"%s_link_$1dst\"/>",cluster_id);
-	SURFXML_BUFFER_SET(link_c_ctn_id, bprintf("%s_link_$1dst",cluster_id));
-	SURFXML_START_TAG(link_c_ctn);
-	SURFXML_END_TAG(link_c_ctn);
+	SURFXML_BUFFER_SET(link_ctn_id, bprintf("%s_link_$1dst",cluster_id));
+	SURFXML_START_TAG(link_ctn);
+	SURFXML_END_TAG(link_ctn);
 
 	DEBUG0("</route>");
 	SURFXML_END_TAG(route);
@@ -2395,3 +2550,56 @@ static void routing_full_parse_Scluster(void)
 
 	surfxml_bufferstack_pop(1);
 }
+
+/*
+ * New methods to init the routing model component from the lua script
+ */
+
+/*
+ * calling parse_S_AS_lua with lua values
+ */
+void routing_AS_init(const char* AS_id,const char* AS_routing)
+{
+	parse_S_AS_lua((char*)AS_id,(char*)AS_routing);
+}
+
+/*
+ * calling parse_E_AS_lua to fisnish the creation of routing component
+ */
+void routing_AS_end(const char *AS_id)
+{
+	parse_E_AS_lua((char*)AS_id);
+}
+
+/*
+ * add a host to the network element list
+ */
+
+void routing_add_host(const char* host_id)
+{
+	parse_S_host_lua((char*)host_id);
+}
+
+/*
+ * Set a new link on the actual list of link for a route or ASroute
+ */
+void routing_add_link(const char* link_id)
+{
+	parse_E_link_c_ctn_new_elem_lua((char*)link_id);
+}
+
+/*
+ *Set the endpoints for a route
+ */
+void routing_set_route(const char* src_id,const char *dst_id)
+{
+	parse_S_route_new_and_endpoints_lua((char*)src_id,(char*)dst_id);
+}
+
+/*
+ * Store the route by calling parse_E_route_store_route
+ */
+void routing_store_route(void)
+{
+	parse_E_route_store_route();
+}