Changeset 1064 in svn


Ignore:
Timestamp:
2012-07-27T18:37:37+02:00 (3 years ago)
Author:
Xuefer
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.