Changeset 1064 for trunk


Ignore:
Timestamp:
2012-07-27T18:37:37+02:00 (2 years ago)
Author:
moo
Message:

adds xcache_enable_cache api. re-implements disable on crash

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/ChangeLog

    r1039 r1064  
    33======== 
    44 * chg: proto array xcache_clear_cache(int type, [ int id = -1 ]). -1 means all cache splits 
     5 * new: proto array xcache_enable_cache(int type, [ int id = -1, [ bool enable = true ] ]) 
    56 
    67Ini Settings Changes 
  • trunk/NEWS

    r1039 r1064  
    44 * adds warning for misconfiguration 
    55 * auto disable caching on crash 
     6 * updated api 
    67 * uses extension to load XCache. load via zend_extension is unsupported 
    78 * updated XCache admin page 
  • trunk/htdocs/cacher/cacher-zh-simplified.lang.php

    r1063 r1064  
    1818        'Normal' 
    1919        => '正常', 
    20         'Compiling(%s)' 
    21         => '编译中(%s)', 
     20        'Compiling' 
     21        => '编译中', 
     22        'Disabled' 
     23        => '禁用', 
     24        'Disable' 
     25        => '禁用', 
     26        'Enable' 
     27        => '启用', 
    2228        'Modify' 
    2329        => '修改', 
  • trunk/htdocs/cacher/cacher-zh-traditional.lang.php

    r1063 r1064  
    1818        'Normal' 
    1919        => '正常', 
    20         'Compiling(%s)' 
    21         => '編譯中(%s)', 
     20        'Compiling' 
     21        => '編譯中', 
     22        'Disabled' 
     23        => '禁用', 
     24        'Disable' 
     25        => '禁用', 
     26        'Enable' 
     27        => '啟用', 
    2228        'Modify' 
    2329        => '修改', 
  • trunk/htdocs/cacher/cacher.php

    r1058 r1064  
    158158$_GET['type'] = $type = (int) $_GET['type']; 
    159159 
    160 // {{{ process clear 
    161 function processClear() 
     160// {{{ process clear, enable, disable 
     161function processAction() 
    162162{ 
    163163    $type = isset($_POST['type']) ? $_POST['type'] : null; 
     
    168168        $cacheid = (int) (isset($_POST['cacheid']) ? $_POST['cacheid'] : 0); 
    169169        if (isset($_POST['clearcache'])) { 
    170             $count = xcache_count($type); 
    171             if ($cacheid >= 0) { 
    172                 for ($cacheid = 0; $cacheid < $count; $cacheid ++) { 
    173                     xcache_clear_cache($type, $cacheid); 
    174                 } 
    175             } 
    176             else { 
    177                 xcache_clear_cache($type); 
    178             } 
    179         } 
    180     } 
    181 } 
    182 processClear(); 
     170            xcache_clear_cache($type, $cacheid); 
     171        } 
     172        if (isset($_POST['enable'])) { 
     173            xcache_enable_cache($type, $cacheid); 
     174        } 
     175        if (isset($_POST['disable'])) { 
     176            xcache_enable_cache($type, $cacheid, false); 
     177        } 
     178    } 
     179} 
     180processAction(); 
    183181// }}} 
    184182// {{{ load info/list 
     
    207205    $total['gc'] = null; 
    208206    $total['istotal'] = true; 
     207    unset($total['compiling']); 
    209208    $cacheinfos[] = $total; 
    210209} 
  • trunk/htdocs/cacher/cacher.tpl.php

    r1063 r1064  
    5555    $numkeys = explode(',', 'slots,size,avail,hits,updates,skips,ooms,errors,cached,deleted'); 
    5656    $l_clear = _('Clear'); 
     57    $l_disabled = _('Disabled'); 
     58    $l_disable = _('Disable'); 
     59    $l_enable = _('Enable'); 
     60    $l_compiling = _('Compiling'); 
     61    $l_normal = _('Normal'); 
    5762    $l_clear_confirm = _('Sure to clear?'); 
    5863    foreach ($cacheinfos as $i => $ci) { 
     
    9297        } 
    9398        else { 
    94             if ($ci['type'] == $type_php) { 
    95             $ci['status'] = $ci['compiling'] ? sprintf(_('Compiling(%s)'), age($ci['compiling'])) : _('Normal'); 
     99            if ($ci['disabled']) { 
     100                $ci['status'] = $l_disabled 
     101                    . sprintf("(%s)", age($ci['disabled'])); 
     102            } 
     103            else if ($ci['type'] == $type_php) { 
     104                $ci['status'] = $ci['compiling'] 
     105                    ? $l_compiling . sprintf("(%s)", age($ci['compiling'])) 
     106                    : $l_normal; 
    96107            } 
    97108            else { 
     
    100111            $ci['can_readonly'] = $ci['can_readonly'] ? 'yes' : 'no'; 
    101112        } 
     113        $enabledisable = $ci['disabled'] ? 'enable' : 'disable'; 
     114        $l_enabledisable = $ci['disabled'] ? $l_enable : $l_disable; 
    102115        echo <<<EOS 
    103116        <th>{$ci['cache_name']}</th> 
     
    117130                    /><input type="hidden" name="cacheid" value="{$ci['cacheid']}" 
    118131                    /><input type="submit" name="clearcache" value="{$l_clear}" class="submit" onclick="return confirm('{$l_clear_confirm}');" 
     132                    /><input type="submit" name="{$enabledisable}" value="{$l_enabledisable}" class="submit" 
    119133                /></div 
    120134            ></form 
  • trunk/mod_cacher/xc_cacher.c

    r1063 r1064  
    6969 
    7070    time_t     compiling; 
     71    time_t     disabled; 
    7172    zend_ulong updates; 
    7273    zend_ulong hits; 
     
    131132 
    132133typedef enum { XC_TYPE_PHP, XC_TYPE_VAR } xc_entry_type_t; 
    133  
    134 /* TODO */ 
    135 static inline zend_bool xc_cache_disabled() 
    136 { 
    137     return 0; 
    138 } 
    139 /* }}} */ 
    140134 
    141135/* any function in *_unlocked is only safe be called within locked (single thread access) area */ 
     
    501495{ 
    502496    TRACE("interval %lu, %lu %lu", (zend_ulong) XG(request_time), (zend_ulong) cache->cached->last_gc_expires, gc_interval); 
    503     if (XG(request_time) >= cache->cached->last_gc_expires + (time_t) gc_interval) { 
     497    if (!cache->cached->disabled && XG(request_time) >= cache->cached->last_gc_expires + (time_t) gc_interval) { 
    504498        ENTER_LOCK(cache) { 
    505499            if (XG(request_time) >= cache->cached->last_gc_expires + (time_t) gc_interval) { 
     
    563557static XC_CACHE_APPLY_FUNC(xc_gc_deletes_one) /* {{{ */ 
    564558{ 
    565     if (cache->cached->deletes && XG(request_time) - cache->cached->last_gc_deletes > xc_deletes_gc_interval) { 
     559    if (!cache->cached->disabled && cache->cached->deletes && XG(request_time) - cache->cached->last_gc_deletes > xc_deletes_gc_interval) { 
    566560        ENTER_LOCK(cache) { 
    567561            if (cache->cached->deletes && XG(request_time) - cache->cached->last_gc_deletes > xc_deletes_gc_interval) { 
     
    614608    add_assoc_long_ex(return_value, ZEND_STRS("slots"),     cache->hentry->size); 
    615609    add_assoc_long_ex(return_value, ZEND_STRS("compiling"), cached->compiling); 
     610    add_assoc_long_ex(return_value, ZEND_STRS("disabled"),  cached->disabled); 
    616611    add_assoc_long_ex(return_value, ZEND_STRS("updates"),   cached->updates); 
    617612    add_assoc_long_ex(return_value, ZEND_STRS("misses"),    cached->updates); /* deprecated */ 
     
    20492044    xc_sandboxed_compiler_t sandboxed_compiler; 
    20502045 
     2046    if (cache->cached->disabled) { 
     2047        return old_compile_file(h, type TSRMLS_CC); 
     2048    } 
    20512049    /* stale skips precheck */ 
    2052     if (XG(request_time) - cache->cached->compiling < 30) { 
     2050    if (cache->cached->disabled || XG(request_time) - cache->cached->compiling < 30) { 
    20532051        cache->cached->skips ++; 
    20542052        return old_compile_file(h, type TSRMLS_CC); 
     
    21702168     || strstr(PG(include_path), "://") != NULL 
    21712169#endif 
    2172      || xc_cache_disabled() 
    21732170     ) { 
    21742171        TRACE("%s", "cacher not enabled"); 
     
    24812478static void xc_request_shutdown(TSRMLS_D) /* {{{ */ 
    24822479{ 
    2483     if (!xc_cache_disabled()) { 
    2484         xc_entry_unholds(TSRMLS_C); 
    2485         xc_gc_expires_php(TSRMLS_C); 
    2486         xc_gc_expires_var(TSRMLS_C); 
    2487         xc_gc_deletes(TSRMLS_C); 
    2488     } 
     2480    xc_entry_unholds(TSRMLS_C); 
     2481    xc_gc_expires_php(TSRMLS_C); 
     2482    xc_gc_expires_var(TSRMLS_C); 
     2483    xc_gc_deletes(TSRMLS_C); 
    24892484#ifdef ZEND_ENGINE_2 
    24902485    zend_llist_destroy(&XG(gc_op_arrays)); 
     
    26082603} /* }}} */ 
    26092604/* {{{ xcache_admin_operate */ 
    2610 typedef enum { XC_OP_COUNT, XC_OP_INFO, XC_OP_LIST, XC_OP_CLEAR } xcache_op_type; 
     2605typedef enum { XC_OP_COUNT, XC_OP_INFO, XC_OP_LIST, XC_OP_CLEAR, XC_OP_ENABLE } xcache_op_type; 
    26112606static void xcache_admin_operate(xcache_op_type optype, INTERNAL_FUNCTION_PARAMETERS) 
    26122607{ 
     
    26152610    xc_cache_t *caches, *cache; 
    26162611    long id = 0; 
     2612    zend_bool enable = 1; 
    26172613 
    26182614    xcache_admin_auth_check(TSRMLS_C); 
    26192615 
    2620     if (!xc_initized || xc_cache_disabled()) { 
     2616    if (!xc_initized) { 
    26212617        RETURN_NULL(); 
    26222618    } 
     
    26282624            } 
    26292625            break; 
     2626 
    26302627        case XC_OP_CLEAR: 
    26312628            id = -1; 
     
    26342631            } 
    26352632            break; 
     2633 
     2634        case XC_OP_ENABLE: 
     2635            id = -1; 
     2636            if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|lb", &type, &id, &enable) == FAILURE) { 
     2637                return; 
     2638            } 
     2639            break; 
     2640 
    26362641        default: 
    26372642            if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &type, &id) == FAILURE) { 
     
    26992704            break; 
    27002705 
     2706        case XC_OP_ENABLE: 
     2707            if (!caches || id < -1 || id >= size) { 
     2708                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cache not exists"); 
     2709                RETURN_FALSE; 
     2710            } 
     2711 
     2712            if (id == -1) { 
     2713                for (id = 0; id < size; ++id) { 
     2714                    caches[id].cached->disabled = !enable ? XG(request_time) : 0; 
     2715                } 
     2716            } 
     2717            else { 
     2718                caches[id].cached->disabled = !enable ? XG(request_time) : 0; 
     2719            } 
     2720 
     2721            break; 
     2722 
    27012723        default: 
    27022724            assert(0); 
     
    27322754} 
    27332755/* }}} */ 
    2734  
    2735 #define VAR_DISABLED_WARNING() do { \ 
     2756/* {{{ proto array xcache_enable_cache(int type, [ int id = -1, [ bool enable = true ] ]) 
     2757   Enable or disable cache by id on specified cache type */ 
     2758PHP_FUNCTION(xcache_enable_cache) 
     2759{ 
     2760    xcache_admin_operate(XC_OP_ENABLE, INTERNAL_FUNCTION_PARAM_PASSTHRU); 
     2761} 
     2762/* }}} */ 
     2763 
     2764#define VAR_CACHE_NOT_INITIALIZED() do { \ 
    27362765        php_error_docref(NULL TSRMLS_CC, E_WARNING, "XCache var cache was not initialized properly. Check php log for actual reason"); \ 
    27372766} while (0) 
     
    27762805    zval *name; 
    27772806 
    2778     if (!xc_var_caches || xc_cache_disabled()) { 
    2779         VAR_DISABLED_WARNING(); 
     2807    if (!xc_var_caches) { 
     2808        VAR_CACHE_NOT_INITIALIZED(); 
    27802809        RETURN_NULL(); 
    27812810    } 
     
    27862815    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC); 
    27872816    cache = &xc_var_caches[entry_hash.cacheid]; 
     2817 
     2818    if (cache->cached->disabled) { 
     2819        RETURN_NULL(); 
     2820    } 
    27882821 
    27892822    ENTER_LOCK(cache) { 
     
    28102843    zval *value; 
    28112844 
    2812     if (!xc_var_caches || xc_cache_disabled()) { 
    2813         VAR_DISABLED_WARNING(); 
     2845    if (!xc_var_caches) { 
     2846        VAR_CACHE_NOT_INITIALIZED(); 
    28142847        RETURN_NULL(); 
    28152848    } 
     
    28322865    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC); 
    28332866    cache = &xc_var_caches[entry_hash.cacheid]; 
     2867 
     2868    if (cache->cached->disabled) { 
     2869        RETURN_NULL(); 
     2870    } 
    28342871 
    28352872    ENTER_LOCK(cache) { 
     
    28522889    zval *name; 
    28532890 
    2854     if (!xc_var_caches || xc_cache_disabled()) { 
    2855         VAR_DISABLED_WARNING(); 
     2891    if (!xc_var_caches) { 
     2892        VAR_CACHE_NOT_INITIALIZED(); 
    28562893        RETURN_FALSE; 
    28572894    } 
     
    28622899    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC); 
    28632900    cache = &xc_var_caches[entry_hash.cacheid]; 
     2901 
     2902    if (cache->cached->disabled) { 
     2903        RETURN_FALSE; 
     2904    } 
    28642905 
    28652906    ENTER_LOCK(cache) { 
     
    28862927    zval *name; 
    28872928 
    2888     if (!xc_var_caches || xc_cache_disabled()) { 
    2889         VAR_DISABLED_WARNING(); 
     2929    if (!xc_var_caches) { 
     2930        VAR_CACHE_NOT_INITIALIZED(); 
    28902931        RETURN_FALSE; 
    28912932    } 
     
    28962937    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC); 
    28972938    cache = &xc_var_caches[entry_hash.cacheid]; 
     2939 
     2940    if (cache->cached->disabled) { 
     2941        RETURN_FALSE; 
     2942    } 
    28982943 
    28992944    ENTER_LOCK(cache) { 
     
    29162961    int i, iend; 
    29172962 
    2918     if (!xc_var_caches || xc_cache_disabled()) { 
    2919         VAR_DISABLED_WARNING(); 
     2963    if (!xc_var_caches) { 
     2964        VAR_CACHE_NOT_INITIALIZED(); 
    29202965        RETURN_FALSE; 
    29212966    } 
     
    29272972    for (i = 0, iend = xc_var_hcache.size; i < iend; i ++) { 
    29282973        xc_cache_t *cache = &xc_var_caches[i]; 
     2974        if (cache->cached->disabled) { 
     2975            continue; 
     2976        } 
     2977 
    29292978        ENTER_LOCK(cache) { 
    29302979            int entryslotid, jend; 
     
    29523001    zval oldzval; 
    29533002 
    2954     if (!xc_var_caches || xc_cache_disabled()) { 
    2955         VAR_DISABLED_WARNING(); 
     3003    if (!xc_var_caches) { 
     3004        VAR_CACHE_NOT_INITIALIZED(); 
    29563005        RETURN_NULL(); 
    29573006    } 
     
    29693018    xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC); 
    29703019    cache = &xc_var_caches[entry_hash.cacheid]; 
     3020 
     3021    if (cache->cached->disabled) { 
     3022        RETURN_NULL(); 
     3023    } 
    29713024 
    29723025    ENTER_LOCK(cache) { 
     
    30343087    PHP_FE(xcache_list,              NULL) 
    30353088    PHP_FE(xcache_clear_cache,       NULL) 
     3089    PHP_FE(xcache_enable_cache,      NULL) 
    30363090    PHP_FE(xcache_get,               NULL) 
    30373091    PHP_FE(xcache_set,               NULL) 
     
    33603414} 
    33613415/* }}} */ 
     3416void xc_cacher_disable() /* {{{ */ 
     3417{ 
     3418    time_t now = time(NULL); 
     3419    size_t i; 
     3420 
     3421    if (xc_php_caches) { 
     3422        for (i = 0; i < xc_php_hcache.size; i ++) { 
     3423            if (xc_php_caches[i].cached) { 
     3424                xc_php_caches[i].cached->disabled = now; 
     3425            } 
     3426        } 
     3427    } 
     3428 
     3429    if (xc_var_caches) { 
     3430        for (i = 0; i < xc_var_hcache.size; i ++) { 
     3431            if (xc_var_caches[i].cached) { 
     3432                xc_var_caches[i].cached->disabled = now; 
     3433            } 
     3434        } 
     3435    } 
     3436} 
     3437/* }}} */ 
  • trunk/mod_cacher/xc_cacher.h

    r1044 r1064  
    77 
    88int xc_cacher_startup_module(); 
    9 int xc_cacher_disable(); 
     9void xc_cacher_disable(); 
    1010 
    1111#endif /* XC_CACHER_H_1CADCD7E46ABC70014D0766CE97B9741 */ 
Note: See TracChangeset for help on using the changeset viewer.