Source for file Session.php

  1. <?php
  2.  
  3. /**
  4.  * Custom Session for work with Memcache
  5.  *
  6.  * @package Session
  7.  * @use core_view_classes_Memcache_Memcache
  8.  *
  9.  */
  10.  
  11. if (0 > version_compare(PHP_VERSION, '5')) {
  12.     die('This file was generated for PHP 5');
  13. }
  14.  
  15. /**
  16.  * include core_view_classes_Memcache_Memcache
  17.  *
  18.  */
  19. require_once(CFG_BASE_ROOT . '/core/view/classes/Memcache/Memcache.php');
  20.  
  21. /* user defined includes */
  22. // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FBC-includes begin
  23. // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FBC-includes end
  24.  
  25. /* user defined constants */
  26. // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FBC-constants begin
  27. // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FBC-constants end
  28.  
  29. /**
  30.  * Custom Session for work with Memcache
  31.  *
  32.  * @package Session
  33.  * @use core_view_classes_Memcache_Memcache
  34.  *
  35.  * @access public
  36.  */
  37. class core_view_classes_Session 
  38. {
  39.     // --- ASSOCIATIONS ---
  40.  
  41.  
  42.     // --- ATTRIBUTES ---
  43.  
  44.     /**
  45.      * The instance of the class Memcache
  46.      *
  47.      * @access private
  48.      * @var Memcache 
  49.      */
  50.     private static $MC = null;
  51.  
  52.     /**
  53.      * The session expiration time
  54.      *
  55.      * @access private
  56.      * @var int 
  57.      */
  58.     private static $sessionTime = 1440;
  59.  
  60.     /**
  61.      * Unique ID as a prefix for session key
  62.      *
  63.      * @access private
  64.      * @var string 
  65.      */
  66.     private static $keyPrefix = '';
  67.  
  68.     /**
  69.      * The waiting timeout unlocking session
  70.      *
  71.      * @access private
  72.      * @var int 
  73.      */
  74.     private static $sleepTime = 100000;
  75.  
  76.     /**
  77.      * The session_key_lock expiration time
  78.      *
  79.      * @access private
  80.      * @var int 
  81.      */
  82.     private static $lockTime = 10;
  83.  
  84.     /**
  85.      * The level of compression
  86.      *
  87.      * @access private
  88.      * @var int 
  89.      */
  90.     private static $gzSize = 300;
  91.  
  92.     /**
  93.      * The variable to store the CAS token in
  94.      *
  95.      * @access private
  96.      * @var int 
  97.      */
  98.     private static $version = null;
  99.  
  100.     /**
  101.      * The session key after prepare
  102.      *
  103.      * @access public
  104.      * @var string 
  105.      */
  106.     public static $session_key = '';
  107.  
  108.     // --- OPERATIONS ---
  109.  
  110.     /**
  111.      * Create a new instance of the class Memcache
  112.      *
  113.      * @access public
  114.      * @param  string host The hostname of the memcache server
  115.      * @param  string port The port on which memcache is running
  116.      * @param  string mPrefix Unique ID as a prefix for memcache key
  117.      * @param  string sPrefix Unique ID as a prefix for session key
  118.      */
  119.     public static function Init($host, $port, $mPrefix, $sPrefix) {
  120.         // section -64--88-1--106--4b532b66:12d287c133d:-8000:0000000000001FE8 begin
  121.         
  122.         self::$MC = new core_view_classes_Memcache_Memcache($host, $port, $mPrefix);
  123.         self::$MC->lockTime = self::$lockTime;
  124.         
  125.         self::$keyPrefix = $sPrefix;
  126.         
  127.         self::WriteLog(__FUNCTION__, var_export(array($host, $port, $mPrefix, $sPrefix), true));
  128.         
  129.         // section -64--88-1--106--4b532b66:12d287c133d:-8000:0000000000001FE8 end
  130.     }
  131.  
  132.     /**
  133.      * Reads the requested session data
  134.      *
  135.      * @access public
  136.      * @param  string key Unique session ID
  137.      * @param  boolean withLock Read session with lock as default value
  138.      * @return string 
  139.      */
  140.     public static function Read($key, $withLock = true) {
  141.         $returnValue = (string) '';
  142.  
  143.         // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FC0 begin
  144.         
  145.         self::WriteLog(__FUNCTION__, $key.', '. $withLock.', version - '.self::$version);
  146.         
  147.         if ($withLock) {
  148.             self::$session_key = self::PrepareKey($key);
  149.             while (!self::$MC->Lock(self::$session_key, self::$version)) {
  150.                 usleep(self::$sleepTime);
  151.             }
  152.         }
  153.  
  154.         $returnValue = self::$MC->get($key);
  155.  
  156.         if ($returnValue) {
  157.             if (@$tmp = gzuncompress($returnValue)) {
  158.                 $returnValue = $tmp;
  159.             }
  160.         }
  161.         
  162.         // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FC0 end
  163.  
  164.         return (string) $returnValue;
  165.     }
  166.  
  167.     /**
  168.      * Writes the provided session data with the requested key
  169.      *
  170.      * @access public
  171.      * @param  string key Unique session ID
  172.      * @param  value The value to store
  173.      * @return boolean 
  174.      */
  175.     public static function Write($key, $value) {
  176.         $returnValue = (bool) false;
  177.  
  178.         // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FC2 begin
  179.         
  180.         self::WriteLog(__FUNCTION__, $key.', '. var_export($value, true).', version - '.self::$version);
  181.  
  182.         $session_key = self::PrepareKey($key);
  183.         if (self::$MC->CheckLock($session_key, self::$version)) {
  184.             if (mb_strlen($value)>self::$gzSize) {
  185.                 $value = gzcompress($value, 6);
  186.             }
  187.             $returnValue = self::$MC->set($key, $value, self::$sessionTime);
  188.             self::$MC->Unlock($session_key);
  189.         }
  190.         
  191.         // section -64--88-1--106--58e7bf35:12d1e1d4191:-8000:0000000000001FC2 end
  192.  
  193.         return (bool) $returnValue;
  194.     }
  195.  
  196.     /**
  197.      * Destroys the requested session
  198.      *
  199.      * @access public
  200.      * @param  string key Unique session ID
  201.      * @return mixed 
  202.      */
  203.     public static function Destroy($key) {
  204.         // section -64--88-1--106--44318241:12d1e485c5b:-8000:0000000000001FCC begin
  205.         
  206.         self::WriteLog(__FUNCTION__, $key.', '. $key.', version - '.self::$version);
  207.         
  208.         $session_key = self::PrepareKey($key);
  209.         if (self::$MC->CheckLock($session_key, self::$version)) {
  210.             $returnValue = self::$MC->delete($key);
  211.             self::$MC->Unlock($session_key);
  212.         }
  213.         
  214.         // section -64--88-1--106--44318241:12d1e485c5b:-8000:0000000000001FCC end
  215.     }
  216.  
  217.     /**
  218.      * Make new key for lock session
  219.      *
  220.      * @access public
  221.      * @param  string key Unique session ID
  222.      * @return string Return a new key with prefix
  223.      */
  224.     public static function PrepareKey($key) {
  225.         $returnValue = (string) '';
  226.  
  227.         // section -64--88-1--106--1adfd58c:12d2c271cbb:-8000:000000000000200F begin
  228.  
  229.         $returnValue = md5(self::$keyPrefix . $key);
  230.         
  231.         self::WriteLog(__FUNCTION__, $returnValue);
  232.  
  233.         // section -64--88-1--106--1adfd58c:12d2c271cbb:-8000:000000000000200F end
  234.  
  235.         return (string) $returnValue;
  236.     }
  237.  
  238.     /**
  239.      * Write a text to the log file
  240.      *
  241.      * @access protected
  242.      * @param  string name The function name
  243.      * @param  string text The string that is to be written
  244.      * @return mixed 
  245.      */
  246.     protected static function WriteLog($name, $text = '') {
  247.         // section -64--88-1--106-42af027e:12d32ad9c50:-8000:0000000000002029 begin
  248.         
  249.         Logs::Write(__CLASS__, $name, $text);
  250.         
  251.         // section -64--88-1--106-42af027e:12d32ad9c50:-8000:0000000000002029 end
  252.     }
  253.  
  254.     /**
  255.      * Prolong expiration time
  256.      *
  257.      * @access public
  258.      * @param  int time Prolong time in second
  259.      * @return boolean 
  260.      */
  261.     public static function Prolong($time = 10) {
  262.         $returnValue = (bool) false;
  263.  
  264.         // section -64--88-1--106-3b746a61:12de6c64a8f:-8000:00000000000023F6 begin
  265.         
  266.         if (self::$MC->CheckLock(self::$session_key, self::$version)) {
  267.             $returnValue = self::$MC->ProlongLock(self::$session_key, self::$version, $time);
  268.         }
  269.         
  270.         // section -64--88-1--106-3b746a61:12de6c64a8f:-8000:00000000000023F6 end
  271.  
  272.         return (bool) $returnValue;
  273.     }
  274.  
  275.     /**
  276.      * Create a new instance of the class Memcache
  277.      *
  278.      * @access private
  279.      * @return mixed 
  280.      */
  281.     private function __construct() {
  282.         // section -64--88-1--106--7edefe2a:12de72d82df:-8000:000000000000218E begin
  283.         // section -64--88-1--106--7edefe2a:12de72d82df:-8000:000000000000218E end
  284.     }
  285.  
  286. } /* end of class core_view_classes_Session */
  287.  
  288. ?>

Documentation generated on Thu, 03 Mar 2011 20:14:16 +0300 by phpDocumentor 1.4.3