Eucalyptus-2.0-Setup: neuca-0.12.patch

File neuca-0.12.patch, 32.1 kB (added by ibaldin, 8 years ago)

NEuca 0.12 patch for Eucalyptus 2.0.0 - 2.0.2

  • cluster/handlers.c

     
    235235        if (!rc && *outInst) { 
    236236          len = sizeof(ncInstance); 
    237237          rc = write(filedes[1], &len, sizeof(int)); 
     238#ifdef EUCA_N 
     239          (*outInst)->userDataDict=NULL; 
     240#endif 
    238241          rc = write(filedes[1], *outInst, sizeof(ncInstance)); 
    239242          rc = 0; 
    240243        } else { 
     
    257260          for (i=0; i<len; i++) { 
    258261            ncInstance *inst; 
    259262            inst = (*ncOutInsts)[i]; 
     263#ifdef EUCA_N 
     264            inst->userDataDict=NULL; 
     265#endif 
    260266            rc = write(filedes[1], inst, sizeof(ncInstance)); 
    261267          } 
    262268          rc = 0; 
  • cluster/Makefile

     
    1717SCLIBS=../storage/storage.o  
    1818VNLIBS=../net/vnetwork.o ../util/misc.o 
    1919WSSECLIBS=../util/euca_axis.o ../util/euca_auth.o 
    20 CC_LIBS         = ${LIBS} -lcurl 
     20CC_LIBS         = ${LIBS} -lcurl -laprutil-1 -L$(INIPARSER_HOME)/lib -liniparser 
    2121 
     22INCLUDES += -I$(INIPARSER_HOME)/include 
     23CFLAGS += -DEUCA_N 
     24 
    2225all: server client 
    2326 
    2427build: all 
  • CHANGELOG.NEuca

     
     1*Tue Dec 28 2010 RENCI (ibaldin@renci.org) 
     2    * Fixed the NC bug 
     3    * Updated gen_XXX templates to ensure proper NIC detection order 
     4*Fri Sep 24 2010 RENCI (ibaldin@renci.org) 
     5    * Introduced patches to the node controller to parser user-data 
     6from runInstances() and create required bridges and VLAN interfaces 
     7to attach additional VM interfaces into them 
     8    * Modified gen_XXX Perl scripts that generate templates for 
     9libvirsh to take on an 'extra-interfaces' parameter that adds additional 
     10interface definitions into the templates. 
     11 
  • node/handlers.c

     
    8787#include <storage.h> 
    8888#include <eucalyptus.h> 
    8989 
     90#ifdef EUCA_N 
     91#include <iniparser.h> 
     92#endif 
     93 
    9094#define MONITORING_PERIOD (5) 
    9195 
    9296/* used by lower level handlers */ 
    9397sem *hyp_sem;   /* semaphore for serializing domain creation */ 
    9498sem *inst_sem;  /* guarding access to global instance structs */ 
    9599sem *addkey_sem;        /* guarding access to global instance structs */ 
     100#ifdef EUCA_N 
     101sem *euca_n_sem; /* serialize bridge maintenance */ 
     102dictionary *bridge_counts; 
     103#define GUEST_XML_BRIDGE "GUEST_ETH%dBRIDGE" 
     104#define EXTRA_INTERFACES "extra-interfaces" 
     105#endif 
    96106 
    97107bunchOfInstances *global_instances = NULL;  
    98108 
     
    377387                        char *brname, 
    378388                        int use_virtio_net, 
    379389                        int use_virtio_root, 
     390#ifdef EUCA_N 
     391                        dictionary *dict, 
     392#endif 
    380393                        char **xml) 
    381394{ 
    382395    char buf [MAX_PATH]; 
     
    395408    if (params->disk > 0) { /* TODO: get this info from scMakeImage */ 
    396409        strncat (buf, " --ephemeral", MAX_PATH); 
    397410    } 
     411#ifdef EUCA_N 
     412    unsigned int extra_i; 
     413    if (!dictionary_get_uint(dict, EXTRA_INTERFACES, &extra_i)) { 
     414      logprintfl(EUCAINFO, "EUCA_N: no extra interfaces specified for %s, skipping\n", instanceId); 
     415      extra_i = 0; 
     416    } else { 
     417      char extra_interfaces_string[100]; 
     418      snprintf(extra_interfaces_string, 100, " --extra-interfaces %d", extra_i); 
     419      strncat(buf, extra_interfaces_string, MAX_PATH); 
     420    } 
     421        
     422#endif 
    398423    * xml = system_output (buf); 
    399424    if ( ( * xml ) == NULL ) { 
    400425        logprintfl (EUCAFATAL, "%s: %s\n", gen_libvirt_cmd_path, strerror (errno)); 
     
    413438    replace_string (xml, "MEMORY", buf); 
    414439    snprintf(buf, CHAR_BUFFER_SIZE, "%d", params->cores); 
    415440    replace_string (xml, "VCPUS", buf); 
     441 
     442#ifdef EUCA_N 
     443    if (extra_i) { 
     444      char bridge_field_name[30]; 
     445      for(; extra_i >= 1; extra_i-- )  { 
     446        snprintf(bridge_field_name, 30, GUEST_XML_BRIDGE, extra_i); 
     447        replace_string(xml, bridge_field_name, dictionary_get(dict, bridge_field_name, "EUCA-N-unspecified")); 
     448      } 
     449    } 
     450#endif 
    416451     
    417452    return 0; 
    418453} 
     
    490525                logprintfl (EUCAINFO, "stopping the network (vlan=%d)\n", (instance->ncnet).vlan); 
    491526                vnetStopNetwork (nc_state.vnetconfig, (instance->ncnet).vlan, NULL, NULL); 
    492527            } 
     528#ifdef EUCA_N 
     529            /* remove the bridges this instance was on */ 
     530            cleanup_instance_bridges(instance); 
     531#endif 
    493532            change_state (instance, TEARDOWN); /* TEARDOWN = no more resources */ 
    494533            instance->terminationTime = time (NULL); 
    495534        } 
     
    530569    } 
    531570    logprintfl (EUCAINFO, "network started for instance %s\n", instance->instanceId); 
    532571     
     572#ifdef EUCA_N 
     573    attach_instance_bridges(instance); 
     574#endif 
    533575    error = scMakeInstanceImage (nc_state.home,  
    534576                                 instance->userId,  
    535577                                 instance->imageId, instance->imageURL,  
     
    566608                              brname, 
    567609                              nc_state.config_use_virtio_net, 
    568610                              nc_state.config_use_virtio_root, 
     611#ifdef EUCA_N 
     612                              instance->userDataDict, 
     613#endif 
    569614                              &xml); 
    570615 
    571616    if (brname) free(brname); 
     
    682727                        logprintfl (EUCAWARN, "WARNING: failed to recover Eucalyptus metadata of running domain %s, ignoring it\n", dom_name); 
    683728                        continue; 
    684729                } 
     730#ifdef EUCA_N 
     731                /* restore userData dictionary */ 
     732                ck_instance_dict(instance); 
     733                /* restore bridge counts */ 
     734                sem_p(euca_n_sem); 
     735                restore_bridge_counts(instance); 
     736                sem_v(euca_n_sem); 
     737#endif 
    685738 
    686739                change_state (instance, info.state);                     
    687740                sem_p (inst_sem); 
     
    785838        hyp_sem = sem_alloc (1, "mutex"); 
    786839        inst_sem = sem_alloc (1, "mutex"); 
    787840        addkey_sem = sem_alloc (1, "mutex"); 
     841#ifdef EUCA_N 
     842        euca_n_sem = sem_alloc(1, "mutex"); 
     843#endif 
    788844        if (!hyp_sem || !inst_sem) { 
    789845                logprintfl (EUCAFATAL, "failed to create and initialize a semaphore\n"); 
    790846                return ERROR_FATAL; 
     
    847903                return ERROR_FATAL; 
    848904        } 
    849905 
     906#ifdef EUCA_N 
     907        bridge_counts = dictionary_new(0); 
     908#endif 
    850909        /* adopt running instances */ 
    851910        adopt_instances(); 
    852911 
     
    12251284    return retval; 
    12261285} 
    12271286 
     1287#ifdef EUCA_N 
     1288 
     1289#define EUCA_N_VLAN "vlan" 
     1290#define EUCA_N_PHYS "phys" 
     1291int attach_instance_bridges(ncInstance *instance) { 
     1292 
     1293        if (!instance->userDataDict)  
     1294                return -1; 
     1295 
     1296        logprintfl(EUCAINFO, "EUCA_N: attaching bridges to instance %s\n", instance->instanceId); 
     1297        /* find all the guest interface definitions */ 
     1298        unsigned int i=1, tmp_count;  
     1299        unsigned char done = 0; 
     1300        char key_name[1024]; 
     1301        char if_name[10]; 
     1302        char xml_br_name[30]; 
     1303        while(!done) { 
     1304                snprintf(if_name, 10, "eth%d", i); 
     1305                snprintf(xml_br_name, 30, GUEST_XML_BRIDGE, i); 
     1306                snprintf(key_name, 1024, "interfaces:%s", if_name); 
     1307                logprintfl(EUCAINFO, "EUCA_N: attach checking for if %s in instance %s\n", if_name, instance->instanceId); 
     1308                char *int_info = iniparser_getstring(instance->userDataDict, key_name, NULL); 
     1309                if (int_info) { 
     1310                        int cause = 0; 
     1311                        euca_n_intf_def *intf_def = allocate_intf_def(int_info, &cause); 
     1312                        char bridge_name[20]; 
     1313                        if (!intf_def) { 
     1314                                logprintfl(EUCAWARN, "EUCA_N: unable to parse interface information %s cause %d, skipping\n", int_info, cause); 
     1315                                i++; 
     1316                                free_intf_def(intf_def); 
     1317                                continue; 
     1318                        } 
     1319                        if (!strncmp(intf_def->i_type, EUCA_N_VLAN, strlen(EUCA_N_VLAN))) { 
     1320                                gen_vlan_bridge_name(intf_def->host_if, intf_def->tag, bridge_name); 
     1321                                sem_p(euca_n_sem); 
     1322                                if (inc_bridge_count(bridge_name) == 1) 
     1323                                        if (attach_bridge_vlan(nc_state.vnetconfig, intf_def->host_if, intf_def->tag)) { 
     1324                                                logprintfl(EUCAWARN, "EUCA_N: unable to create vlan bridge %s\n", bridge_name); 
     1325                                        } 
     1326                                dictionary_set(instance->userDataDict, xml_br_name, bridge_name); 
     1327                                logprintfl(EUCAINFO, "EUCA_N: bridge %s has count %d\n", bridge_name, ck_bridge_count(bridge_name)); 
     1328                                sem_v(euca_n_sem); 
     1329                        } 
     1330                        else if (!strncmp(intf_def->i_type, EUCA_N_PHYS, strlen(EUCA_N_PHYS))) { 
     1331                                gen_phys_bridge_name(intf_def->host_if, bridge_name); 
     1332                                sem_p(euca_n_sem); 
     1333                                if (inc_bridge_count(bridge_name) == 1) 
     1334                                        if (attach_bridge_phys(nc_state.vnetconfig, intf_def->host_if)) { 
     1335                                                logprintfl(EUCAWARN, "EUCA_N: unable to create phys bridge %s\n", bridge_name); 
     1336                                        } 
     1337                                dictionary_set(instance->userDataDict, xml_br_name, bridge_name); 
     1338                                logprintfl(EUCAINFO, "EUCA_N: bridge %s has count %d\n", bridge_name, ck_bridge_count(bridge_name)); 
     1339                                sem_v(euca_n_sem); 
     1340                        } else 
     1341                                logprintfl(EUCAWARN, "EUCA_N: unable to parse interface information %s\n", int_info); 
     1342                        free_intf_def(intf_def); 
     1343                } else { 
     1344                        logprintfl(EUCAINFO, "EUCA_N: interface %s not in config file, stopping here\n", if_name); 
     1345                        done = 1; 
     1346                } 
     1347                i++; 
     1348        } 
     1349        dictionary_set_uint(instance->userDataDict, EXTRA_INTERFACES, i-2); 
     1350        return 0; 
     1351} 
     1352 
     1353int cleanup_instance_bridges(ncInstance *instance) { 
     1354 
     1355        if (!instance->userDataDict)  
     1356                return -1; 
     1357 
     1358        logprintfl(EUCAINFO, "EUCA_N: cleaning up bridges for instance %s\n", instance->instanceId); 
     1359 
     1360        /* find all the guest interface definitions */ 
     1361        unsigned int i=1, tmp_count;  
     1362        unsigned char done = 0; 
     1363        char key_name[1024]; 
     1364        char if_name[10]; 
     1365        while(!done) { 
     1366                snprintf(if_name, 10, "eth%d", i); 
     1367                snprintf(key_name, 1024, "interfaces:%s", if_name); 
     1368                logprintfl(EUCAINFO, "EUCA_N: cleanup checking for if %s in instance %s\n", if_name, instance->instanceId); 
     1369                char *int_info = iniparser_getstring(instance->userDataDict, key_name, NULL); 
     1370                if (int_info) { 
     1371                        int cause = 0; 
     1372                        euca_n_intf_def *intf_def = allocate_intf_def(int_info, &cause); 
     1373                        char bridge_name[20]; 
     1374                        if (!intf_def) { 
     1375                                logprintfl(EUCAWARN, "EUCA_N: unable to parse interface information %s cause %d, skipping\n", int_info, cause); 
     1376                                i++; 
     1377                                free_intf_def(intf_def); 
     1378                                continue; 
     1379                        } 
     1380                        if (!strncmp(intf_def->i_type, EUCA_N_VLAN, strlen(EUCA_N_VLAN))) { 
     1381                                gen_vlan_bridge_name(intf_def->host_if, intf_def->tag, bridge_name); 
     1382                                sem_p(euca_n_sem); 
     1383                                if (dec_bridge_count(bridge_name) == 0) 
     1384                                        if (detach_bridge_vlan(nc_state.vnetconfig, intf_def->host_if, intf_def->tag)) { 
     1385                                                logprintfl(EUCAWARN, "EUCA_N: unable to remove vlan bridge %s\n", bridge_name); 
     1386                                        } 
     1387                                logprintfl(EUCAINFO, "EUCA_N: bridge %s has count %d\n", bridge_name, ck_bridge_count(bridge_name)); 
     1388                                sem_v(euca_n_sem); 
     1389                        } 
     1390                        else if (!strncmp(intf_def->i_type, EUCA_N_PHYS, strlen(EUCA_N_PHYS))) { 
     1391                                gen_phys_bridge_name(intf_def->host_if, bridge_name); 
     1392                                sem_p(euca_n_sem); 
     1393                                if (dec_bridge_count(bridge_name) == 0) 
     1394                                        if (detach_bridge_phys(nc_state.vnetconfig, intf_def->host_if)) { 
     1395                                                logprintfl(EUCAWARN, "EUCA_N: unable to remove phys bridge %s\n", bridge_name); 
     1396                                        } 
     1397                                logprintfl(EUCAINFO, "EUCA_N: bridge %s has count %d\n", bridge_name, ck_bridge_count(bridge_name)); 
     1398                                sem_v(euca_n_sem); 
     1399                        } else 
     1400                                logprintfl(EUCAWARN, "EUCA_N: unable to parse interface information %s\n", int_info); 
     1401                        free_intf_def(intf_def); 
     1402                } else { 
     1403                        logprintfl(EUCAINFO, "EUCA_N: interface %s not in config file, stopping here\n", if_name); 
     1404                        done = 1; 
     1405                } 
     1406                i++; 
     1407        } 
     1408        return 0; 
     1409} 
     1410 
     1411int restore_bridge_counts(ncInstance *instance) { 
     1412 
     1413        if (!instance->userDataDict)  
     1414                return -1; 
     1415 
     1416        logprintfl(EUCAINFO, "EUCA_N: updating bridge counts for instance %s\n", instance->instanceId); 
     1417        /* find all the guest interface definitions */ 
     1418        unsigned int i=1, tmp_count;  
     1419        unsigned char done = 0; 
     1420        char key_name[1024]; 
     1421        char if_name[10]; 
     1422        while(!done) { 
     1423                snprintf(if_name, 10, "eth%d", i); 
     1424                snprintf(key_name, 1024, "interfaces:%s", if_name); 
     1425                logprintfl(EUCAINFO, "EUCA_N: restore checking for if %s in instance %s\n", if_name, instance->instanceId); 
     1426                char *int_info = iniparser_getstring(instance->userDataDict, key_name, NULL); 
     1427                if (int_info) { 
     1428                        int cause = 0; 
     1429                        euca_n_intf_def *intf_def = allocate_intf_def(int_info, &cause); 
     1430                        char bridge_name[20]; 
     1431                        if (!intf_def) { 
     1432                                logprintfl(EUCAWARN, "EUCA_N: unable to parse interface information %s cause %d, skipping\n", int_info, cause); 
     1433                                i++; 
     1434                                free_intf_def(intf_def); 
     1435                                continue; 
     1436                        } 
     1437                        if (!strncmp(intf_def->i_type, EUCA_N_VLAN, strlen(EUCA_N_VLAN))) { 
     1438                                gen_vlan_bridge_name(intf_def->host_if, intf_def->tag, bridge_name); 
     1439                                inc_bridge_count(bridge_name); 
     1440                                logprintfl(EUCAINFO, "EUCA_N: bridge %s has count %d\n", bridge_name, ck_bridge_count(bridge_name)); 
     1441                        } 
     1442                        else if (!strncmp(intf_def->i_type, EUCA_N_PHYS, strlen(EUCA_N_PHYS))) { 
     1443                                gen_phys_bridge_name(intf_def->host_if, bridge_name); 
     1444                                inc_bridge_count(bridge_name); 
     1445                                logprintfl(EUCAINFO, "EUCA_N: bridge %s has count %d\n", bridge_name, ck_bridge_count(bridge_name)); 
     1446                        } else 
     1447                                logprintfl(EUCAWARN, "EUCA_N: unable to parse interface information %s\n", int_info); 
     1448                        free_intf_def(intf_def); 
     1449                } else { 
     1450                        logprintfl(EUCAINFO, "EUCA_N: interface %s not in config file, stopping here\n", if_name); 
     1451                        done = 1; 
     1452                } 
     1453                i++; 
     1454        } 
     1455        return 0; 
     1456} 
     1457 
     1458unsigned int inc_bridge_count(char *brname) { 
     1459        unsigned int tmp; 
     1460 
     1461        if (dictionary_get_uint(bridge_counts, brname, &tmp)) 
     1462                tmp++; 
     1463        else 
     1464                tmp = 1; 
     1465        dictionary_set_uint(bridge_counts, brname, tmp); 
     1466        return tmp; 
     1467} 
     1468 
     1469unsigned int dec_bridge_count(char *brname) { 
     1470        unsigned int tmp; 
     1471 
     1472        if (dictionary_get_uint(bridge_counts, brname, &tmp)) { 
     1473                if (tmp > 0) tmp--; 
     1474                dictionary_set_uint(bridge_counts, brname, tmp); 
     1475        } else { 
     1476                tmp = 0; 
     1477                dictionary_unset(bridge_counts, brname); 
     1478        } 
     1479        return tmp; 
     1480} 
     1481 
     1482unsigned int ck_bridge_count(char *brname) { 
     1483        unsigned int tmp; 
     1484 
     1485        if (dictionary_get_uint(bridge_counts, brname, &tmp))  
     1486                return tmp; 
     1487        else  
     1488                return 0; 
     1489} 
     1490 
     1491#endif 
  • node/handlers.h

     
    219219                                char *brname, 
    220220                                int use_virtio_net, 
    221221                                int use_virtio_root, 
     222#ifdef EUCA_N 
     223                                dictionary *dict, 
     224#endif 
    222225                                char **xml); 
    223226void * monitoring_thread(       void *arg); 
    224227void * startup_thread(          void *arg); 
     
    244247        long long sizeMb; // diskPath size 
    245248}; 
    246249 
     250#ifdef EUCA_N 
     251int attach_instance_bridges(ncInstance *); 
     252int cleanup_instance_bridges(ncInstance *); 
     253int restore_bridge_counts(ncInstance *); 
     254unsigned int inc_bridge_count(char *bridge); 
     255unsigned int dec_bridge_count(char *bridge); 
     256unsigned int ck_bridge_count(char *bridge); 
     257 
     258void euca_n_create_vlan_bridge(char *bridge, char *ifc, unsigned int tag); 
     259void euca_n_create_phy_bridge(char *bridge, char *ifc); 
     260void euca_n_rem_vlan_bridge(char *bridge, char *ifc, unsigned int tag); 
     261void euca_n_rem_phy_bridge(char *bridge, char *ifc); 
     262 
     263#endif 
     264 
    247265#endif /* INCLUDE */ 
    248266 
  • node/Makefile

     
    1212SERVICE_NAME=EucalyptusNC 
    1313CLIENT=NCclient 
    1414#WSDL2C=$(AXIS2C_HOME)/bin/tools/wsdl2c/WSDL2C.sh 
    15 NC_LIBS                 = $(LIBS) -lvirt -lcurl -lssl 
     15NC_LIBS                 = $(LIBS) -lvirt -lcurl -lssl -laprutil-1 -L$(INIPARSER_HOME)/lib -liniparser 
    1616NC_HANDLERS=handlers_xen.o handlers_kvm.o handlers_default.o 
    1717 
     18INCLUDES += -I$(INIPARSER_HOME)/include 
     19CFLAGS += -DEUCA_N 
     20 
    1821all: server client clientlib test_nc test 
    1922 
    2023build: all 
  • net/vnetwork.c

     
    24562456  } 
    24572457  return(ret); 
    24582458} 
     2459 
     2460#ifdef EUCA_N 
     2461int count_bridge_interfaces(char *brname) { 
     2462  char file[MAX_PATH]; 
     2463 
     2464  if (!brname || check_device(brname)) { 
     2465    return(1); 
     2466  } 
     2467  snprintf(file, MAX_PATH, "/sys/class/net/%s/brif/", brname); 
     2468  return count_dir_entries(file); 
     2469} 
     2470 
     2471int gen_vlan_bridge_name(char *host_if, unsigned int tag, char ret_brname[20]) { 
     2472 
     2473  if (!host_if || !ret_brname) 
     2474    return -1; 
     2475 
     2476  snprintf(ret_brname, 20, "brv-%s-%d", host_if, tag); 
     2477  return 0; 
     2478} 
     2479 
     2480int attach_bridge_vlan(vnetConfig *vnetconfig, char *host_if, unsigned int tag) { 
     2481  char brname[20]; 
     2482  char vlanifname[20]; 
     2483  char cmd[MAX_PATH]; 
     2484  int rc = 0; 
     2485 
     2486  if(gen_vlan_bridge_name(host_if, tag, brname)) { 
     2487    logprintfl(EUCAERROR, "EUCA_N: unable to generate bridge name\n"); 
     2488    return 0; 
     2489  } 
     2490 
     2491  snprintf(vlanifname, 20, "%s.%d", host_if, tag); 
     2492  logprintfl(EUCAINFO, "EUCA_N: attaching bridge %s and vlan interface %s\n", brname, vlanifname); 
     2493 
     2494  if (!check_bridge(brname)) { 
     2495    logprintfl(EUCAINFO, "EUCA_N: bridge %s exists, nothing to do\n", brname); 
     2496    return 0; 
     2497  } 
     2498 
     2499  /* create vlan interface, bring up, create bridge, add vlan, bring bridge up */ 
     2500  if (check_device(vlanifname)) { 
     2501    snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s up", vnetconfig->eucahome, host_if) ; 
     2502    logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2503    rc = system(cmd); 
     2504    snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap vconfig add %s %d", vnetconfig->eucahome, host_if, tag); 
     2505    logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2506    rc = system(cmd); 
     2507    if (rc != 0) { 
     2508      // failed to create vlan tagged device 
     2509      logprintfl(EUCAERROR, "EUCA_N: cannot create new vlan device %s.%d\n", host_if, tag); 
     2510      return(1); 
     2511     } 
     2512  } else  
     2513    logprintfl(EUCAINFO, "EUCA_N: vlan interface %s exists, continuing\n", vlanifname); 
     2514 
     2515  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl addbr %s", vnetconfig->eucahome, brname); 
     2516  rc = system(cmd); 
     2517  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2518  if (rc) { 
     2519    logprintfl(EUCAERROR, "EUCA_N: could not create new bridge %s\n", brname); 
     2520    return(1); 
     2521  } 
     2522 
     2523  // add if to bridge 
     2524  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl addif %s %s", vnetconfig->eucahome, brname, vlanifname); 
     2525  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2526  rc = system(cmd); 
     2527 
     2528  // bring br up 
     2529  if (check_deviceup(brname)) { 
     2530    snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s up", vnetconfig->eucahome, brname); 
     2531    logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2532    rc = system(cmd); 
     2533  } 
     2534 
     2535  // bring if up 
     2536  if (check_deviceup(vlanifname)) { 
     2537    snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s up", vnetconfig->eucahome, vlanifname); 
     2538    logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2539    rc = system(cmd); 
     2540  } 
     2541  return 0; 
     2542} 
     2543 
     2544int gen_phys_bridge_name(char *host_if, char ret_brname[20]) { 
     2545 
     2546  if (!ret_brname || !host_if) 
     2547    return -1; 
     2548 
     2549  snprintf(ret_brname, 20, "brp-%s", host_if); 
     2550  return 0; 
     2551} 
     2552 
     2553int attach_bridge_phys(vnetConfig *vnetconfig, char *host_if) { 
     2554  char brname[20]; 
     2555  char cmd[MAX_PATH]; 
     2556  int rc = 0; 
     2557 
     2558  if(gen_phys_bridge_name(host_if, brname)) { 
     2559    logprintfl(EUCAERROR, "EUCA_N: unable to generate bridge name\n"); 
     2560    return 0; 
     2561  } 
     2562 
     2563  logprintfl(EUCAINFO, "EUCA_N: attaching bridge %s\n", brname); 
     2564 
     2565  if (!check_bridge(brname)) { 
     2566    logprintfl(EUCAINFO, "EUCA_N: bridge %s exists, nothing to do\n", brname); 
     2567    return 0; 
     2568  } 
     2569 
     2570  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl addbr %s", vnetconfig->eucahome, brname); 
     2571  rc = system(cmd); 
     2572  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2573  if (rc) { 
     2574    logprintfl(EUCAERROR, "EUCA_N: could not create new bridge %s\n", brname); 
     2575    return(1); 
     2576  } 
     2577 
     2578  // add if to bridge 
     2579  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl addif %s %s", vnetconfig->eucahome, brname, host_if); 
     2580  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2581  rc = system(cmd); 
     2582 
     2583  // bring br up 
     2584  if (check_deviceup(brname)) { 
     2585    snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s up", vnetconfig->eucahome, brname); 
     2586    logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2587    rc = system(cmd); 
     2588  } 
     2589 
     2590  if (check_deviceup(host_if)) { 
     2591    snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s up", vnetconfig->eucahome, host_if); 
     2592    logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2593    rc = system(cmd); 
     2594  } 
     2595  return 0; 
     2596} 
     2597 
     2598int detach_bridge_vlan(vnetConfig *vnetconfig, char *host_if, unsigned int tag) { 
     2599  char brname[20]; 
     2600  char vlanifname[20]; 
     2601  char cmd[MAX_PATH]; 
     2602  int rc = 0; 
     2603 
     2604  if (gen_vlan_bridge_name(host_if, tag, brname)) { 
     2605    logprintfl(EUCAERROR, "EUCA_N: unable to generate vlan bridge name\n"); 
     2606    return -1; 
     2607  } 
     2608 
     2609  snprintf(vlanifname, 20, "%s.%d", host_if, tag); 
     2610 
     2611  logprintfl(EUCAINFO, "EUCA_N: detaching bridge %s and vlan interface %s\n", brname, vlanifname); 
     2612 
     2613  if (check_bridge(brname)) { 
     2614    logprintfl(EUCAINFO, "EUCA_N: bridge %s does not exist, nothing to do\n", brname); 
     2615    return 0; 
     2616  } 
     2617 
     2618  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s down", vnetconfig->eucahome, vlanifname); 
     2619  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2620  rc = system(cmd); 
     2621 
     2622  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s down", vnetconfig->eucahome, brname); 
     2623  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2624  rc = system(cmd); 
     2625 
     2626  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl delif %s %s", vnetconfig->eucahome, brname, vlanifname); 
     2627  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2628  rc = system(cmd); 
     2629 
     2630  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap vconfig rem %s", vnetconfig->eucahome, vlanifname); 
     2631  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2632  rc = system(cmd); 
     2633 
     2634  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl delbr %s", vnetconfig->eucahome, brname); 
     2635  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2636  rc = system(cmd); 
     2637 
     2638  return 0; 
     2639} 
     2640 
     2641int detach_bridge_phys(vnetConfig *vnetconfig, char *host_if) { 
     2642  char brname[20]; 
     2643  char cmd[MAX_PATH]; 
     2644  int rc = 0; 
     2645 
     2646  if (gen_phys_bridge_name(host_if, brname)) { 
     2647    logprintfl(EUCAERROR, "EUCA_N: unable to generate physical bridge name\n"); 
     2648    return -1; 
     2649  } 
     2650  logprintfl(EUCAINFO, "EUCA_N: detaching bridge %s\n", brname); 
     2651 
     2652  if (check_bridge(brname)) { 
     2653    logprintfl(EUCAINFO, "EUCA_N: bridge %s does not exist, nothing to do\n", brname); 
     2654    return 0; 
     2655  } 
     2656 
     2657  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap ip link set dev %s down", vnetconfig->eucahome, brname); 
     2658  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2659  rc = system(cmd); 
     2660 
     2661  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl delif %s %s", vnetconfig->eucahome, brname, host_if); 
     2662  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2663  rc = system(cmd); 
     2664 
     2665  snprintf(cmd, MAX_PATH, "%s/usr/lib/eucalyptus/euca_rootwrap brctl delbr %s", vnetconfig->eucahome, brname); 
     2666  logprintfl(EUCAINFO, "EUCA_N: executing %s\n", cmd); 
     2667  rc = system(cmd); 
     2668 
     2669  return 0; 
     2670} 
     2671 
     2672#endif 
  • net/vnetwork.h

     
    223223int check_tablerule(vnetConfig *vnetconfig, char *table, char *rule); 
    224224int check_isip(char *ip); 
    225225 
     226#ifdef EUCA_N 
     227int count_bridge_interfaces(char *brname); 
     228int attach_bridge_vlan(vnetConfig *vnetconfig, char *host_if, unsigned int tag); 
     229int attach_bridge_phys(vnetConfig *vnetconfig, char *host_if); 
     230int detach_bridge_vlan(vnetConfig *vnetconfig, char *host_if, unsigned int tag); 
     231int detach_bridge_phys(vnetConfig *vnetconfig, char *host_if); 
     232int gen_vlan_bridge_name(char *host_if, unsigned int tag, char ret_brname[20]); 
     233int gen_phys_bridge_name(char *host_if, char ret_brname[20]); 
    226234#endif 
     235 
     236#endif 
  • net/Makefile

     
    33# 
    44 
    55include ../Makedefs 
     6CFLAGS += -DEUCA_N 
    67 
    78all: vnetwork.o 
    89 
  • tools/gen_libvirt_xml

     
    7676our $use_ephemeral = 0; 
    7777 
    7878# deal with command-line parameters 
     79our $extra_interfaces = 0; 
     80 
    7981GetOptions('ramdisk'        => sub { $use_ramdisk = 1; }, 
    80            'ephemeral'      => sub { $use_ephemeral = 1; } 
     82           'ephemeral'      => sub { $use_ephemeral = 1; }, 
     83# EUCA_N 
     84           'extra-interfaces=i' =>  \$extra_interfaces 
    8185                   ) or exit (1); 
    8286 
    8387print <<EOF; 
     
    124128            <mac address='PRIVMACADDR'/> 
    125129            <script path='/etc/xen/scripts/vif-bridge'/> 
    126130        </interface> 
     131EOF 
     132# EUCA_N 
     133my $ifcount; 
     134my $bridgename; 
     135for ($ifcount = 1; $ifcount <= $extra_interfaces; $ifcount++) { 
     136        $bridgename="GUEST_ETH".$ifcount."BRIDGE"; 
     137        print <<EOF; 
     138        <interface type='bridge'> 
     139                <source bridge='$bridgename'/> 
     140                <script path='/etc/xen/scripts/vif-bridge'/> 
     141        </interface> 
     142EOF 
     143} 
     144print <<EOF; 
    127145    </devices> 
    128146</domain> 
    129147EOF 
  • tools/gen_kvm_libvirt_xml

     
    8585    $local_kvm="kvm"; 
    8686} 
    8787 
     88our $extra_interfaces=0; 
     89 
    8890# deal with command-line parameters 
    8991GetOptions('ramdisk'        => sub { $use_ramdisk = 1; }, 
    9092           'ephemeral'      => sub { }, # option ignored  
    9193           'virtionet'      => sub { $use_virtio_net = 1; }, 
    9294           'virtioroot'      => sub { $use_virtio_root = 1; }, 
     95# EUCA_N 
     96           'extra-interfaces=i' =>  \$extra_interfaces 
    9397                   ) or exit (1); 
    9498 
    9599print <<EOF; 
     
    155159EOF 
    156160} 
    157161 
     162# EUCA_N 
     163my $ifcount; 
     164my $bridgename; 
     165for ($ifcount = 1; $ifcount <= $extra_interfaces; $ifcount++) { 
     166        $bridgename="GUEST_ETH".$ifcount."BRIDGE"; 
     167        print <<EOF; 
     168        <interface type='bridge'> 
     169                <source bridge='$bridgename'/> 
     170                <model type='e1000'/> 
     171        </interface> 
     172EOF 
     173} 
     174 
    158175print <<EOF; 
    159176        <serial type="file"> 
    160177            <source path='BASEPATH/console.log'/> 
  • util/misc.h

     
    201201char * strduplc (const char * s); 
    202202char * xpath_content (const char * xml, const char * xpath); 
    203203 
     204#ifdef EUCA_N 
     205int count_dir_entries(char *dir); 
    204206#endif 
     207#endif 
  • util/data.c

     
    6363#include <string.h>  
    6464#include "data.h" 
    6565 
     66#ifdef EUCA_N 
     67#include <sys/types.h> 
     68#include <regex.h> 
     69#include <apr-1.0/apr_base64.h> 
     70#include <iniparser.h> 
     71#endif 
     72 
    6673int allocate_virtualMachine(virtualMachine *out, const virtualMachine *in) 
    6774{ 
    6875  if (out != NULL) { 
     
    129136 
    130137    if (userData) { 
    131138        strncpy(inst->userData, userData, CHAR_BUFFER_SIZE*10); 
     139#ifdef EUCA_N 
     140        ck_instance_dict(inst); 
     141#endif 
    132142    } 
    133143 
    134144    if (launchIndex) { 
     
    206216    * instp = NULL; 
    207217    if (!inst) return; 
    208218 
     219#if EUCA_N 
     220    if (inst->userDataDict) 
     221        iniparser_freedict(inst->userDataDict); 
     222    inst->userDataDict = NULL; 
     223#endif 
    209224    free (inst); 
    210225} 
    211226 
     
    410425     
    411426    return v; 
    412427} 
     428 
     429#ifdef EUCA_N 
     430/* check if instance has a userData dictionary, create one if not */ 
     431void ck_instance_dict(ncInstance *instance) { 
     432  if (instance->userDataDict)  
     433    return; 
     434  if (instance->userData) { 
     435    char *decoded = (char*)calloc(apr_base64_decode_len(instance->userData) + 1, sizeof(char)); 
     436    apr_base64_decode(decoded, instance->userData); 
     437    instance->userDataDict = iniparser_load_string(decoded); 
     438    free(decoded); 
     439  } 
     440} 
     441 
     442euca_n_intf_def *allocate_intf_def(char *field, int *cause) { 
     443 
     444  regmatch_t regm[10]; 
     445 
     446  regex_t intf_regex2, intf_regex3, intf_regex4; 
     447 
     448  if (regcomp(&intf_regex2, "^\\s*([[:alpha:]]+):([[:alnum:]]+)\\s*$", REG_EXTENDED))  { 
     449    if (cause) *cause = 1; 
     450    return NULL; 
     451  } 
     452 
     453  if (regcomp(&intf_regex3, "^\\s*([[:alpha:]]+):([[:alnum:]]+):([[:alnum:]\\./]+)\\s*$", REG_EXTENDED))  { 
     454    if (cause) *cause = 1; 
     455    return NULL; 
     456  } 
     457 
     458  if (regcomp(&intf_regex4, "^\\s*([[:alpha:]]+):([[:alnum:]]+):([[:alnum:]\\./]+):([[:digit:]\\./]+)\\s*$", REG_EXTENDED))  { 
     459    if (cause) *cause = 1; 
     460    return NULL; 
     461  } 
     462 
     463  /* do regex match */ 
     464  if (regexec(&intf_regex4, field, 10, regm, 0) == REG_NOMATCH) 
     465    if (regexec(&intf_regex3, field, 10, regm, 0) == REG_NOMATCH)  
     466      if (regexec(&intf_regex2, field, 10, regm, 0) == REG_NOMATCH) { 
     467        if (cause) *cause = 2; 
     468        return NULL; 
     469  } 
     470 
     471  euca_n_intf_def *intf_def = allocate_empty_intf_def(); 
     472  if (!intf_def) { 
     473    if (cause) *cause = 3; 
     474    return NULL; 
     475  } 
     476 
     477  /* copy from regex match */ 
     478  if (regm[1].rm_so != -1) { 
     479    intf_def->i_type = calloc(regm[1].rm_eo - regm[1].rm_so + 1, sizeof(char)); 
     480    strncpy(intf_def->i_type, field + regm[1].rm_so, regm[1].rm_eo - regm[1].rm_so); 
     481  } 
     482 
     483  if (regm[2].rm_so != -1) { 
     484    intf_def->host_if = calloc(regm[2].rm_eo - regm[2].rm_so + 1, sizeof(char)); 
     485    strncpy(intf_def->host_if, field + regm[2].rm_so, regm[2].rm_eo - regm[2].rm_so); 
     486  } 
     487 
     488  int ip_group = 3; 
     489  if (!strncmp(intf_def->i_type, "vlan", strlen("vlan"))) { 
     490    ip_group = 4; 
     491    /* match VLAN tag */ 
     492    if (regm[3].rm_so == -1) { 
     493      free_intf_def(intf_def); 
     494      if (cause) *cause = 4; 
     495      return NULL; 
     496    } 
     497    intf_def->tag = atoi(field + regm[3].rm_so); 
     498  } 
     499 
     500  if (regm[ip_group].rm_so != -1) { 
     501    intf_def->ip = calloc(regm[ip_group].rm_eo - regm[ip_group].rm_so + 1, sizeof(char)); 
     502    strncpy(intf_def->ip, field + regm[ip_group].rm_so, regm[ip_group].rm_eo - regm[ip_group].rm_so); 
     503  } 
     504 
     505  return intf_def; 
     506} 
     507 
     508euca_n_intf_def *allocate_empty_intf_def() { 
     509  return calloc(sizeof(euca_n_intf_def), sizeof(char)); 
     510} 
     511 
     512void free_intf_def(euca_n_intf_def *i) { 
     513  if (!i) 
     514    return; 
     515  if (i->i_type) 
     516    free(i->i_type); 
     517 
     518  if (i->host_if) 
     519    free(i->host_if); 
     520  
     521  if (i->ip) 
     522    free(i->ip); 
     523} 
     524 
     525#endif 
  • util/data.h

     
    6363#include <pthread.h> 
    6464#include "eucalyptus.h" 
    6565 
     66#ifdef EUCA_N 
     67#include <dictionary.h> 
     68#endif 
     69 
    6670#define CHAR_BUFFER_SIZE 512 
    6771#define BIG_CHAR_BUFFER_SIZE 1024 
    6872 
     
    138142    /* updated by NC upon Attach/DetachVolume */ 
    139143    ncVolume volumes[EUCA_MAX_VOLUMES]; 
    140144    int volumesSize; 
     145#ifdef EUCA_N 
     146    dictionary *userDataDict; 
     147#endif 
    141148} ncInstance; 
    142149 
    143150typedef struct ncResource_t { 
     
    194201ncVolume *  add_volume (ncInstance * instance, char *volumeId, char *remoteDev, char *localDev, char *localDevReal, char *stateName); 
    195202ncVolume * free_volume (ncInstance * instance, char *volumeId, char *remoteDev, char *localDev); 
    196203 
     204#ifdef EUCA_N 
     205void ck_instance_dict(ncInstance *instance); 
     206 
     207typedef struct euca_n_intf_def_t { 
     208    char *i_type; 
     209    char *host_if; 
     210    unsigned int tag;  
     211    char *ip; 
     212} euca_n_intf_def; 
     213 
     214euca_n_intf_def *allocate_intf_def(char *field, int *cause); 
     215euca_n_intf_def *allocate_empty_intf_def(); 
     216void free_intf_def(euca_n_intf_def *); 
    197217#endif 
    198218 
     219#endif 
     220 
  • util/misc.c

     
    8080#include <sys/time.h> // gettimeofday 
    8181#include <limits.h> 
    8282 
     83#ifdef EUCA_N 
     84#include <stddef.h> 
     85#endif 
    8386int verify_helpers(char **helpers, char **helpers_path, int LASTHELPER) { 
    8487  int i, done, rc, j; 
    8588  char *tok, *toka, *path, *helper, file[MAX_PATH], *save, *savea; 
     
    15821585 
    15831586    return ret; 
    15841587} 
     1588 
     1589#ifdef EUCA_N 
     1590int count_dir_entries(char *dir) { 
     1591  DIR *od = opendir(dir); 
     1592 
     1593  if (!od) 
     1594    return -1; 
     1595 
     1596  int len = offsetof(struct dirent, d_name) + pathconf(dir, _PC_NAME_MAX) + 1; 
     1597  struct dirent *entry = calloc(len, sizeof(char)); 
     1598  struct dirent *res; 
     1599 
     1600  unsigned int count = 0; 
     1601  while(!readdir_r(od, entry, &res)) { 
     1602    if (res == NULL) { 
     1603      free(entry); 
     1604      return count - 2; 
     1605    } 
     1606    count++; 
     1607  } 
     1608   
     1609  free(entry); 
     1610  return -1; 
     1611} 
     1612#endif 
  • util/Makefile

     
    22#  
    33# 
    44 
     5 
    56include ../Makedefs 
    67 
     8INCLUDES += -I$(INIPARSER_HOME)/include 
     9CFLAGS += -DEUCA_N 
     10 
    711all: misc.o data.o euca_auth.o euca_axis.o ipc.o euca_rootwrap euca_mountwrap 
    812 
    913build: all