sThread
[ class tree: sThread ] [ index: sThread ] [ all elements ]

Source for file memcached.php

Documentation is available at memcached.php

  1. <?php
  2. /**
  3.  * sThread MEMCACHED module
  4.  * 
  5.  * memcached에 stat 명령을 전송하여 결과값을 확인한다.
  6.  *
  7.  * stat명령의 결과에서 다음을 체크한다.
  8.  *
  9.  * <ol>
  10.  *     <li>첫라인이 <i>STAT pid</i>로 시작하는지 확인</li>
  11.  *     <li>마지막 라인이 <i>END</i>인지 확인</li>
  12.  *     <li><i>ERROR</i> 문자열이 있을 경우 확인</li>
  13.  * </ol>
  14.  *
  15.  * 이 프로토콜은 binary data 전송을 지원하지 않는다.
  16.  *
  17.  * @category    Network
  18.  * @package     sThread
  19.  * @subpackage  sThread_Module
  20.  * @author      JoungKyun.Kim <http://oops.org>
  21.  * @copyright   (c) 2015 OOPS.ORG
  22.  * @license     BSD License
  23.  * @version     $Id$
  24.  * @link        http://pear.oops.org/package/sThread
  25.  * @filesource
  26.  */
  27.  
  28. /**
  29.  * MEMCACHED module Class
  30.  * 
  31.  * memcached에 stat 명령을 전송하여 결과값을 확인한다.
  32.  *
  33.  * Memcached 모듈에 사용할 수 있는 모듈 option은 다음과 같다.
  34.  *
  35.  * <ul>
  36.  *     <li><b>query:</b>    쿼리 문자열</li>
  37.  * </ul>
  38.  *
  39.  * 예제:
  40.  * <code>
  41.  *   sThread::execute ('domain.com:11211|query=>get foo', 2, 'tcp');
  42.  * </code>
  43.  *
  44.  * query를 따로 지정하지 않았을 경우에는 stat명령을 실행하고
  45.  * 그 결과에서 다음을 체크한다.
  46.  *
  47.  * <ol>
  48.  *     <li>첫라인이 <i>STAT pid</i>로 시작하는지 확인</li>
  49.  *     <li>마지막 라인이 <i>END</i>인지 확인</li>
  50.  *     <li><i>ERROR</i> 문자열이 있을 경우 확인</li>
  51.  * </ol>
  52.  *
  53.  * 이 프로토콜은 binary data 전송을 지원하지 않는다.
  54.  *
  55.  * @category    Network
  56.  * @package     sThread
  57.  * @subpackage  sThread_Module
  58.  * @author      JoungKyun.Kim <http://oops.org>
  59.  * @copyright   (c) 2015 OOPS.ORG
  60.  * @license     BSD License
  61.  * @link        http://pear.oops.org/package/sThread
  62.  */
  63.     // {{{ Base properteis
  64.     /**#@+
  65.      * @access public
  66.      */
  67.     /**
  68.      * 이 변수의 값이 true로 셋팅이 되면, clear_session
  69.      * method를 만들어 줘야 한다. 반대로 false 상태에서는
  70.      * clear_session method가 존재하지 않아도 상관이 없다.
  71.      *
  72.      * @var bool 
  73.      */
  74.     static public $clearsession;
  75.     /**
  76.      * MEMCACHE 모듈이 사용하는 protocol
  77.      * @var string 
  78.      */
  79.     static public $protocol;
  80.     /**
  81.      * MEMCACHED 모듈이 사용하는 기본 포트 번호
  82.      * @var int 
  83.      */
  84.     static public $port;
  85.  
  86.     const MEMCACHED_REQUEST  1;
  87.     const MEMCACHED_RESPONSE 2;
  88.     const MEMCACHED_QUIT     3;
  89.     const MEMCACHED_CLOSE    4;
  90.     /**#@-*/
  91.     // }}}
  92.  
  93.     // {{{ (void) sThread_MEMCACHED::__construct (void)
  94.     /**
  95.      * Class OOP 형식 초기화 메소드
  96.      * @access public
  97.      * @return sThread_MEMCACHED 
  98.      */
  99.     function __construct ({
  100.         self::init ();
  101.         $this->clearsession = &self::$clearsession;
  102.         $this->port         = &self::$port;
  103.         $this->protocol     = &self::$protocol;
  104.     }
  105.     // }}}
  106.  
  107.     // {{{ (void) sThread_MEMCACHED::init (void)
  108.     /**
  109.      * memcached 모듈을 초기화 한다.
  110.      *
  111.      * @access public
  112.      * @return void 
  113.      */
  114.     function init ({
  115.         self::$clearsession false;
  116.         self::$port         11211;
  117.         self::$protocol     'tcp';
  118.     }
  119.     // }}}
  120.  
  121.     // {{{ (int) sThread_MEMCACHED::check_buf_status ($status)
  122.     /**
  123.      * 현재 상태가 event read 상태인지 event write 상태인지
  124.      * 를 판단한다.
  125.      *
  126.      * @access public
  127.      * @return int 
  128.      * @param  int    현재 status
  129.      */
  130.     function check_buf_status ($status{
  131.         switch ($status{
  132.             case :
  133.             case self::MEMCACHED_REQUEST :
  134.                 return Vari::EVENT_READY_SEND;
  135.                 break;
  136.             case self::MEMCACHED_RESPONSE :
  137.                 return Vari::EVENT_READY_RECV;
  138.                 break;
  139.             case self::MEMCACHED_QUIT:
  140.                 return Vari::EVENT_READY_SEND;
  141.                 break;
  142.             case self::MEMCACHED_CLOSE :
  143.                 return Vari::EVENT_READY_CLOSE;
  144.                 break;
  145.             default :
  146.                 return Vari::EVENT_UNKNOWN;
  147.         }
  148.     }
  149.     // }}}
  150.  
  151.     // {{{ (string) sThread_MEMCACHED::call_status ($status, $call = false)
  152.     /**
  153.      * 현재의 status(integer) 또는 현재 status의 handler 이름을
  154.      * 반환한다.
  155.      *
  156.      * @access public
  157.      * @return int|string
  158.      * @param  int        현재 status
  159.      * @param  boolean    true로 설정했을 경우 현재 status의 handler
  160.      *                     이름을 반환한다.
  161.      */
  162.     function call_status ($status$call false{
  163.         switch ($status{
  164.             case self::MEMCACHED_REQUEST :
  165.                 $r 'MEMCACHED_REQUEST';
  166.                 break;
  167.             case self::MEMCACHED_RESPONSE :
  168.                 $r 'MEMCACHED_RESPONSE';
  169.                 break;
  170.             case self::MEMCACHED_QUIT :
  171.                 $r 'MEMCACHED_QUIT';
  172.                 break;
  173.             default:
  174.                 $r Vari::EVENT_UNKNOWN;
  175.         }
  176.  
  177.         if $call !== false && $r !== Vari::EVENT_UNKNOWN )
  178.             $r strtolower ($r);
  179.  
  180.         return $r;
  181.     }
  182.     // }}}
  183.  
  184.     // {{{ (boolean) sThread_MEMCACHED::change_status (&$sess, $key)
  185.     /**
  186.      * 세션의 상태를 단계로 변경한다.
  187.      *
  188.      * @access public
  189.      * @param  boolean  변경한 상태가 마지막 단계일 경우 false를
  190.      *                   반환한다.
  191.      * @param  stdClass sThread 세션 변수 reference
  192.      * @param  int      세션 키
  193.      */
  194.     function change_status (&$sess$key{
  195.         ++$sess->status[$key];
  196.  
  197.         if $sess->status[$key=== self::MEMCACHED_CLOSE )
  198.             return false;
  199.  
  200.         return true;
  201.     }
  202.     // }}}
  203.  
  204.     // {{{ (void) sThread_MEMCACHED::set_last_status (&$sess, $key)
  205.     /**
  206.      * 세션의 상태를 마지막 단계로 변경한다.
  207.      *
  208.      * @access public
  209.      * @param  stdClass sThread 세션 변수 reference
  210.      * @param  int      세션 키
  211.      */
  212.     function set_last_status (&$sess$key{
  213.         $sess->status[$keyself::MEMCACHED_CLOSE;
  214.     }
  215.     // }}}
  216.  
  217.     // {{{ (boolean) sThread_MEMCACHED::clear_session ($key) {
  218.     /**
  219.      * session에서 사용한 변수(self::$sess)의 값을 정리한다.
  220.      *
  221.      * self::$clearsession == false 일 경우, clear_session method
  222.      * 는 존재하지 않아도 된다.
  223.      *
  224.      * @access public
  225.      * @return void 
  226.      * @param  int    세션 키
  227.      */
  228.     function clear_session ($key{
  229.         return;
  230.     }
  231.     // }}}
  232.  
  233.     /*
  234.      * Handler 정의
  235.      *
  236.      * Handler는 call_status 메소드에 정의된 값들 중
  237.      * Vari::EVENT_UNKNOWN를 제외한 모든 status의 constant string을
  238.      * 소문자로해서 만들어야 한다.
  239.      *
  240.      * Handler 이름은 sThread_MODULE::call_status 메소드를
  241.      * 통해서 구할 수 있다.
  242.      *
  243.      * handler는 다음의 구조를 가지며, 실제로 전송을 하거나 받는
  244.      * 것은 libevent가 한다.
  245.      *
  246.      * write handler:
  247.      *       handler_name (&$ses, $key)
  248.      *
  249.      *       write handler는 실제로 전송을 하지 않고 전송할
  250.      *       데이터를 생성해서 반환만 한다.
  251.      *
  252.      * read handler:
  253.      *       handler_name (&$sess, $key, $recv) 
  254.      *
  255.      *       read handler의 반환값은 다음과 같이 지정을 해야 한다.
  256.      *
  257.      *       true  => 모든 전송이 완료
  258.      *       false => 전송 받을 것이 남아 있음
  259.      *       null  => 전송 중 에러 발생
  260.      *
  261.      *       이 의미는 sThread가 read handler에서 결과값에 따라
  262.      *       true는 다음 단계로 전환을 하고, false는 현 status를
  263.      *       유지하며, null의 경우 connection을 종료를 한다.
  264.      */
  265.  
  266.     // {{{ (string) sThread_MEMCACHED::memcached_request (&$sess, $key)
  267.     /**
  268.      * stat 명령을 반환
  269.      *
  270.      * @access public
  271.      * @return void 
  272.      * @param  stdClass 세션 object
  273.      * @param  int      세션 키
  274.      */
  275.     function memcached_request (&$sess$key{
  276.         $opt $sess->opt[$key];
  277.  
  278.         if $opt->query )
  279.             return $opt->query "\r\n";
  280.  
  281.         return "stats\r\n";
  282.     }
  283.     // }}}
  284.  
  285.     // {{{ (boolean) sThread_MEMCACHED::memcached_response (&$sess, $key, $recv)
  286.     /**
  287.      * 서버의 응답을 확인
  288.      *
  289.      * <ol>
  290.      *     <li>첫라인이 <i>STAT pid</i>로 시작하지 않으면 오류 처리</li>
  291.      *     <li>마지막 라인이 <i>END<i>이면 정상 처리</li>
  292.      *     <li><i>ERROR</i> 문자열이 있을 경우 오류 처리</li>
  293.      * </ol>
  294.      *
  295.      * @access public
  296.      * @return bool|null
  297.      * @param  stdClass 세션 object
  298.      * @param  int      세션 키
  299.      * @param  mixed  read callback에서 전송받은 누적 데이터
  300.      */
  301.     function memcached_response (&$sess$key$recv{
  302.         if $recv )
  303.             return false;
  304.  
  305.         list ($host$port$type$sess->addr[$key];
  306.         $sess->recv[$key.= $recv;
  307.  
  308.         $opt $sess->opt[$key];
  309.         print_r ($opt);
  310.  
  311.         if empty ($opt->query|| $opt->query == 'stat' {
  312.             if strncmp ($sess->recv[$key]'STAT pid '9) ) {
  313.                 Vari::$res->status[$keyarray (
  314.                     "{$host}:{$port}",
  315.                     false,
  316.                     'Protocol error: Invalid response'
  317.                 );
  318.                 return null;
  319.             }
  320.         }
  321.  
  322.         if preg_match ('/(END|ERROR)$/'trim ($sess->recv[$key])) )
  323.             return false;
  324.  
  325.         if preg_match ('/ERROR$/'trim ($sess->recv[$key])) ) {
  326.             Vari::$res->status[$keyarray (
  327.                 "{$host}:{$port}",
  328.                 false,
  329.                 'Protocol error: Protocol Error'
  330.             );
  331.             return null;
  332.         }
  333.  
  334.         if Vari::$result === true )
  335.             $sess->data[$key$sess->recv[$key];
  336.  
  337.         unset ($sess->recv[$key]);
  338.         return true;
  339.     }
  340.     // }}}
  341.  
  342.     // {{{ (string) sThread_MEMCACHED::memcached_quit (&$sess, $key)
  343.     /**
  344.      * 종료 쿼리 반환
  345.      *
  346.      * @access public
  347.      * @return void 
  348.      * @param  stdClass 세션 object
  349.      * @param  int      세션 키
  350.      */
  351.     function memcached_quit (&$sess$key{
  352.         return "quit\r\n";
  353.     }
  354.     // }}}
  355. }
  356.  
  357. ?>

Documentation generated on Tue, 14 May 2019 02:00:32 +0900 by phpDocumentor 1.4.4