Changeset 551

Show
Ignore:
Timestamp:
02/20/07 14:31:48 (2 years ago)
Author:
hollow
Message:

cleanup vg methods: unify add/remove/list; cleanup list handling

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/vcd/methods.c

    r544 r551  
    9797        MREGISTER("vg.list",      m_vg_list); 
    9898        MREGISTER("vg.remove",    m_vg_remove); 
    99         MREGISTER("vg.vx.add",    m_vg_vx_add); 
    100         MREGISTER("vg.vx.list",   m_vg_vx_list); 
    101         MREGISTER("vg.vx.remove", m_vg_vx_remove); 
    10299        MREGISTER("vg.vx.start",  m_vg_vx_start); 
    103100        MREGISTER("vg.vx.stop",   m_vg_vx_stop); 
  • trunk/src/vcd/methods.h

    r544 r551  
    140140MPROTO(m_vg_list); 
    141141MPROTO(m_vg_remove); 
    142 MPROTO(m_vg_vx_add); 
    143 MPROTO(m_vg_vx_list); 
    144 MPROTO(m_vg_vx_remove); 
    145142MPROTO(m_vg_vx_start); 
    146143MPROTO(m_vg_vx_stop); 
  • trunk/src/vcd/methods/Makefile.am

    r544 r551  
    3535       vg/vg_list.c \ 
    3636       vg/vg_remove.c \ 
    37        vg/vg_vx_add.c \ 
    38        vg/vg_vx_list.c \ 
    39        vg/vg_vx_remove.c \ 
    4037       vg/vg_vx_start.c \ 
    4138       vg/vg_vx_stop.c 
  • trunk/src/vcd/methods/vg/vg_add.c

    r536 r551  
    2929 
    3030        xmlrpc_value *params; 
    31         char *group
     31        char *group, *name
    3232        int gid, rc; 
     33        xid_t xid; 
    3334 
    3435        params = method_init(env, p, c, VCD_CAP_AUTH, 0); 
     
    3637 
    3738        xmlrpc_decompose_value(env, params, 
    38                         "{s:s,*}", 
    39                         "groupname", &group); 
     39                        "{s:s,s:s,*}", 
     40                        "group", &group, 
     41                        "name", &name); 
    4042        method_return_if_fault(env); 
    4143 
    42         if (!validate_groupname(group)) 
     44        if (!validate_group(group)) 
    4345                method_return_faultf(env, MEINVAL, 
    44                                 "invalid groupname value: %s", group); 
     46                                "invalid group value: %s", group); 
    4547 
    4648        if (str_equal(group, "all")) 
    4749                return xmlrpc_nil_new(env); 
    4850 
    49         rc = vxdb_prepare(&dbr, 
    50                 "SELECT gid FROM groups ORDER BY gid DESC LIMIT 1"); 
     51        if (!(gid = vxdb_getgid(group))) { 
     52                rc = vxdb_prepare(&dbr, 
     53                                "SELECT gid FROM groups ORDER BY gid DESC LIMIT 1"); 
    5154 
    52         if (rc == VXDB_OK && vxdb_step(dbr) == VXDB_ROW) 
    53                 gid = vxdb_column_int(dbr, 0) + 1; 
    54         else 
    55                 gid = 1; 
     55               if (rc == VXDB_OK && vxdb_step(dbr) == VXDB_ROW) 
     56                       gid = vxdb_column_int(dbr, 0) + 1; 
     57               else 
     58                       gid = 1; 
    5659 
    57         vxdb_finalize(dbr); 
     60               vxdb_finalize(dbr); 
    5861 
    59         rc = vxdb_exec( 
    60                         "INSERT INTO groups (gid, name) " 
    61                         "VALUES (%d, '%s')", 
    62                         gid, group); 
     62               rc = vxdb_exec( 
     63                               "INSERT INTO groups (gid, name) " 
     64                               "VALUES (%d, '%s')", 
     65                               gid, group); 
    6366 
    64         if (rc != VXDB_OK) 
    65                 method_return_vxdb_fault(env); 
     67                if (rc != VXDB_OK) 
     68                        method_return_vxdb_fault(env); 
     69        } 
     70 
     71        if (!str_isempty(name)) { 
     72                if (!validate_name(name)) 
     73                        method_return_faultf(env, MEINVAL, 
     74                                        "invalid name value: %s", name); 
     75 
     76                if (!(xid = vxdb_getxid(name))) 
     77                        method_return_fault(env, MENOVPS); 
     78 
     79                rc = vxdb_exec( 
     80                                "INSERT INTO xid_gid_map (xid, gid) " 
     81                                "VALUES (%d, %d)", 
     82                                xid, gid); 
     83 
     84                if (rc != VXDB_OK) 
     85                        method_return_vxdb_fault(env); 
     86        } 
    6687 
    6788        return xmlrpc_nil_new(env); 
  • trunk/src/vcd/methods/vg/vg_list.c

    r536 r551  
    1818#include "auth.h" 
    1919#include "methods.h" 
     20#include "validate.h" 
    2021#include "vxdb.h" 
    2122 
    2223#include <lucid/log.h> 
     24#include <lucid/str.h> 
    2325 
    2426xmlrpc_value *m_vg_list(xmlrpc_env *env, xmlrpc_value *p, void *c) 
     
    2628        LOG_TRACEME 
    2729 
    28         xmlrpc_value *response = NULL; 
    29         int rc; 
     30        xmlrpc_value *params, *response = NULL; 
     31        char *group; 
     32        int rc, gid; 
    3033 
    31         method_init(env, p, c, VCD_CAP_AUTH, 0); 
     34        params = method_init(env, p, c, VCD_CAP_AUTH, 0); 
    3235        method_return_if_fault(env); 
    3336 
    34         rc = vxdb_prepare(&dbr, 
    35                         "SELECT name,gid FROM groups ORDER BY gid ASC"); 
     37        xmlrpc_decompose_value(env, params, 
     38                        "{s:s,*}", 
     39                        "group", &group); 
     40        method_return_if_fault(env); 
     41 
     42        if (str_isempty(group)) { 
     43                rc = vxdb_prepare(&dbr, 
     44                                "SELECT name FROM groups ORDER BY name ASC"); 
     45        } 
     46 
     47        else { 
     48                if (!validate_group(group)) 
     49                        method_return_faultf(env, MEINVAL, 
     50                                        "invalid group value: %s", group); 
     51 
     52                if (!(gid = vxdb_getgid(group))) 
     53                        method_return_fault(env, MENOVG); 
     54 
     55                rc = vxdb_prepare(&dbr, 
     56                                "SELECT xid_name_map.name FROM xid_name_map " 
     57                                "INNER JOIN xid_gid_map " 
     58                                "ON xid_name_map.xid = xid_gid_map.xid " 
     59                                "WHERE xid_gid_map.gid = %d " 
     60                                "ORDER BY xid_name_map.name ASC", 
     61                                gid); 
     62        } 
    3663 
    3764        if (rc != VXDB_OK) 
     
    4168 
    4269        vxdb_foreach_step(rc, dbr) 
    43                 xmlrpc_array_append_item(env, response, xmlrpc_build_value(env, 
    44                                 "{s:s,s:i}", 
    45                                 "groupname", vxdb_column_text(dbr, 0), 
    46                                 "gid",       vxdb_column_int(dbr, 1))); 
     70                xmlrpc_array_append_item(env, response, 
     71                                xmlrpc_build_value(env, "s", vxdb_column_text(dbr, 0))); 
    4772 
    4873        if (rc != VXDB_DONE) 
  • trunk/src/vcd/methods/vg/vg_remove.c

    r540 r551  
    2929 
    3030        xmlrpc_value *params; 
    31         char *group; 
     31        char *name, *group; 
    3232        int gid, rc; 
     33        xid_t xid; 
    3334 
    3435        params = method_init(env, p, c, VCD_CAP_AUTH, 0); 
     
    3637 
    3738        xmlrpc_decompose_value(env, params, 
    38                         "{s:s,*}", 
    39                         "groupname", &group); 
     39                        "{s:s,s:s,*}", 
     40                        "group", &group, 
     41                        "name", &name); 
    4042        method_return_if_fault(env); 
    4143 
    42         if (!validate_groupname(group)) 
     44        if (!validate_group(group)) 
    4345                method_return_faultf(env, MEINVAL, 
    44                                 "invalid groupname value: %s", group); 
     46                                "invalid group value: %s", group); 
    4547 
    4648        if (str_equal(group, "all")) 
     
    5153                method_return_fault(env, MENOVG); 
    5254 
    53         rc = vxdb_exec( 
    54                 "BEGIN EXCLUSIVE TRANSACTION;" 
    55                 "DELETE FROM xid_gid_map WHERE gid = %d;" 
    56                 "DELETE FROM groups WHERE gid = %d;" 
    57                 "COMMIT TRANSACTION;", 
    58                 gid, gid); 
     55        if (!str_isempty(name)) { 
     56                if (!validate_name(name)) 
     57                        method_return_faultf(env, MEINVAL, 
     58                                        "invalid name value: %s", name); 
     59 
     60                if (!(xid = vxdb_getxid(name))) 
     61                        method_return_fault(env, MENOVPS); 
     62 
     63                rc = vxdb_exec( 
     64                                "INSERT INTO xid_gid_map (xid, gid) " 
     65                                "VALUES (%d, %d)", 
     66                                xid, gid); 
     67        } 
     68 
     69        else { 
     70                rc = vxdb_exec( 
     71                        "BEGIN EXCLUSIVE TRANSACTION;" 
     72                        "DELETE FROM xid_gid_map WHERE gid = %d;" 
     73                        "DELETE FROM groups WHERE gid = %d;" 
     74                        "COMMIT TRANSACTION;", 
     75                        gid, gid); 
     76        } 
    5977 
    6078        if (rc != VXDB_OK) 
  • trunk/src/vcd/methods/vg/vg_vx_start.c

    r544 r551  
    4040        char *group; 
    4141        int rc, gid; 
    42         xn_list_t _xns, *xns = &_xns, *st; 
    43         list_t *pos; 
     42        xn_list_t _xns, *xns = &_xns, *pos; 
    4443 
    4544        params = method_init(env, p, c, VCD_CAP_INIT, 0); 
     
    4847        xmlrpc_decompose_value(env, params, 
    4948                        "{s:s,*}", 
    50                         "groupname", &group); 
     49                        "group", &group); 
    5150        method_return_if_fault(env); 
    5251 
    53         if (!validate_groupname(group)) 
     52        if (!validate_group(group)) 
    5453                method_return_faultf(env, MEINVAL, 
    55                                 "invalid groupname value: %s", group); 
     54                                "invalid group value: %s", group); 
    5655 
    57         if (str_equal(group, "all")) { 
     56        if (str_equal(group, "all")) 
    5857                rc = vxdb_prepare(&dbr, 
    59                         "SELECT xid,name FROM xid_name_map ORDER BY xid ASC"); 
    60  
    61                 if (rc != VXDB_OK) 
    62                         method_return_vxdb_fault(env); 
    63         } 
     58                                "SELECT xid,name FROM xid_name_map"); 
    6459 
    6560        else { 
     
    6863 
    6964                rc = vxdb_prepare(&dbr, 
    70                         "SELECT xid_name_map.xid,xid_name_map.name " 
    71                         "FROM xid_name_map " 
     65                        "SELECT xid_name_map.xid,xid_name_map.name FROM xid_name_map " 
    7266                        "INNER JOIN xid_gid_map " 
    7367                        "ON xid_name_map.xid = xid_gid_map.xid " 
    74                         "WHERE xid_gid_map.gid = %d " 
    75                         "ORDER BY xid_name_map.xid ASC", 
     68                        "WHERE xid_gid_map.gid = %d", 
    7669                        gid); 
     70        } 
    7771 
    78                 if (rc != VXDB_OK) 
    79                         method_return_vxdb_fault(env); 
    80         } 
     72        if (rc != VXDB_OK) 
     73                method_return_vxdb_fault(env); 
    8174 
    8275        INIT_LIST_HEAD(&(xns->list)); 
    8376 
    8477        vxdb_foreach_step(rc, dbr) { 
    85                 xn_list_t *new = mem_alloc(sizeof(xn_list_t)); 
     78                LIST_NODE_ALLOC(xn_list_t, new); 
     79 
    8680                new->xid  = vxdb_column_int(dbr, 0); 
    8781                new->name = str_dup(vxdb_column_text(dbr, 1)); 
     82 
    8883                list_add(&(new->list), &(xns->list)); 
    8984        } 
     
    9489        vxdb_finalize(dbr); 
    9590 
    96         list_for_each(pos, &(xns->list)) { 
    97                 st = list_entry(pos, xn_list_t, list); 
    98  
    99                 if (vx_info(st->xid, NULL) == -1) { 
     91        list_for_each_entry(pos, &(xns->list), list) { 
     92                if (vx_info(pos->xid, NULL) == -1) { 
    10093                        if (errno == ESRCH) { 
    101                                 /* vserver is stopped, let's start it */ 
    102                                 params = xmlrpc_build_value(env, 
    103                                                 "{s:s}", 
    104                                                 "name", st->name); 
    105  
     94                                params = xmlrpc_build_value(env, "{s:s}", "name", pos->name); 
    10695                                m_vx_start(env, params, METHOD_INTERNAL); 
    10796                        } 
  • trunk/src/vcd/methods/vg/vg_vx_stop.c

    r544 r551  
    4040        char *group; 
    4141        int rc, gid; 
    42         xn_list_t _xns, *xns = &_xns, *st; 
    43         list_t *pos; 
     42        xn_list_t _xns, *xns = &_xns, *pos; 
    4443 
    4544        params = method_init(env, p, c, VCD_CAP_INIT, 0); 
     
    4847        xmlrpc_decompose_value(env, params, 
    4948                        "{s:s,*}", 
    50                         "groupname", &group); 
     49                        "group", &group); 
    5150        method_return_if_fault(env); 
    5251 
    53         if (!validate_groupname(group)) 
     52        if (!validate_group(group)) 
    5453                method_return_faultf(env, MEINVAL, 
    55                                 "invalid groupname value: %s", group); 
     54                                "invalid group value: %s", group); 
    5655 
    57         if (str_equal(group, "all")) { 
     56        if (str_equal(group, "all")) 
    5857                rc = vxdb_prepare(&dbr, 
    59                         "SELECT xid,name FROM xid_name_map ORDER BY xid ASC"); 
    60  
    61                 if (rc != VXDB_OK) 
    62                         method_return_vxdb_fault(env); 
    63         } 
     58                        "SELECT xid,name FROM xid_name_map"); 
    6459 
    6560        else { 
     
    6863 
    6964                rc = vxdb_prepare(&dbr, 
    70                         "SELECT xid_name_map.xid,xid_name_map.name " 
    71                         "FROM xid_name_map " 
     65                        "SELECT xid_name_map.xid,xid_name_map.name FROM xid_name_map " 
    7266                        "INNER JOIN xid_gid_map " 
    7367                        "ON xid_name_map.xid = xid_gid_map.xid " 
    74                         "WHERE xid_gid_map.gid = %d " 
    75                         "ORDER BY xid_name_map.xid ASC", 
     68                        "WHERE xid_gid_map.gid = %d", 
    7669                        gid); 
     70        } 
    7771 
    78                 if (rc != VXDB_OK) 
    79                         method_return_vxdb_fault(env); 
    80         } 
     72        if (rc != VXDB_OK) 
     73                method_return_vxdb_fault(env); 
    8174 
    8275        INIT_LIST_HEAD(&(xns->list)); 
    8376 
    8477        vxdb_foreach_step(rc, dbr) { 
    85                 xn_list_t *new = mem_alloc(sizeof(xn_list_t)); 
     78                LIST_NODE_ALLOC(xn_list_t, new); 
     79 
    8680                new->xid  = vxdb_column_int(dbr, 0); 
    8781                new->name = str_dup(vxdb_column_text(dbr, 1)); 
     82 
    8883                list_add(&(new->list), &(xns->list)); 
    8984        } 
     
    9489        vxdb_finalize(dbr); 
    9590 
    96         list_for_each(pos, &(xns->list)) { 
    97                 st = list_entry(pos, xn_list_t, list); 
    98  
    99                 if (vx_info(st->xid, NULL) == 0) { 
    100                         /* vserver is running, let's stop it */ 
    101                         params = xmlrpc_build_value(env, 
    102                                         "{s:s}", 
    103                                         "name", st->name); 
    104  
     91        list_for_each_entry(pos, &(xns->list), list) { 
     92                if (vx_info(pos->xid, NULL) == 0) { 
     93                        params = xmlrpc_build_value(env, "{s:s}", "name", pos->name); 
    10594                        m_vx_stop(env, params, METHOD_INTERNAL); 
    10695                } 
  • trunk/src/vcd/validate.c

    r534 r551  
    7070} 
    7171 
    72 int validate_groupname(const char *groupname
     72int validate_group(const char *group
    7373{ 
    7474        LOG_TRACEME 
    75         return !(str_isempty(groupname) || !str_isalnum(groupname)); 
     75        return !(str_isempty(group) || !str_isalnum(group)); 
    7676} 
    7777 
  • trunk/src/vcd/validate.h

    r534 r551  
    3434int validate_password(const char *password); 
    3535 
    36 int validate_groupname(const char *groupname); 
     36int validate_group(const char *group); 
    3737 
    3838int validate_vcd_cap(const char *bcap); 
  • trunk/src/vcd/vxdb.c

    r534 r551  
    559559} 
    560560 
    561 int vxdb_getgid(const char *groupname
     561int vxdb_getgid(const char *group
    562562{ 
    563563        LOG_TRACEME 
     
    565565        int rc, gid; 
    566566 
    567         if (!validate_groupname(groupname)) 
     567        if (!validate_group(group)) 
    568568                return 0; 
    569569 
    570570        rc = vxdb_prepare(&dbr, 
    571                 "SELECT gid FROM groups WHERE name = '%s'", groupname); 
     571                "SELECT gid FROM groups WHERE name = '%s'", group); 
    572572 
    573573        if (rc == VXDB_OK && vxdb_step(dbr) == VXDB_ROW)