devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

六、企业级架构缓存篇之memcached

作者：盐析白兔 | 2024-04-10 14:58:35

赞

踩

六、企业级架构缓存篇之memcached

一、memcached概述

1、网站架构优化流程：

LNMP架构中网站应用访问流程：

浏览器 (app) → web 服务器 → 后端服务 (php) → 数据库 (mysql)

访问流程越多，访问速度越慢，出现问题的几率也越大。

网站访问流程优化思路：

① 采用高性能的负载均衡设备；

② 页面静态化；

③ 引入缓存层，如使用Redis或Memcached，来缓存频繁访问的数据；

④ 优化数据库本身。

2、mencached介绍：

许多Web应用都将数据保存到 RDBMS (关系型数据库) 中，应用服务器从中读取数据并在浏览器中显示。 但随着数据量的增大、访问的集中，就会出现RDBMS的负担加重、数据库响应恶化、 网站显示延迟等重大影响。

Memcached 是高性能的分布式内存缓存服务器，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web等应用的速度， 提高可扩展性。

Web01/Web02 => memcached（内存） => MyCAT => MySQL01/MySQL02

3、安装memcached软件：

克隆CentOS7生成一个memcached服务器，修改IP、UUID、主机名、hosts文件，关闭防火墙、selinux和NetworkManager。

(1) 架构图：

(2) 编译与安装：

  1. tar -zxf memcached-1.5.8.tar.gz
  2. cd memcached-1.5.8
  3. yum install libevent-devel -y
  4. yum -y install gcc gcc-c++ autoconf automake make
  5. ./configure --prefix=/usr/local/memcached
  6. make && make install

(3) 查看目录：

cd /usr/local/memcahced

bin：memcached 二进制程序文件

include：memcached 依赖库文件

bin/memcached -h：

-p  设置memcached监听的端口，默认为11211

-d  启动一个守护进程deamon（后台运行）

-m 分配给memcached使用的内存数量，单位是MB，默认为64M

-u  运行memcached的用户

-l   监听服务器IP地址，可以有多个地址

-c  最大运行的并发连接数，默认是1024

-P 设置保存memcached的pid文件

(4) 启动memcached软件：

bin/memcached -uroot -d ：以root用户启动memcached，后台运行

4、使用Telnet连接memcached：

(1) telnet概述：

Telnet协议是TCP/IP协议族中的一部分，是Internet远程登录服务的标准协议之一。

Telnet协议允许用户通过网络连接到远程主机，并在该主机上执行命令、访问文件、查看系统状态等。

由于Telnet协议的通信内容并未加密，存在安全风险，因此在实际应用中，Telnet通常被SSH（Secure Shell）所取代，SSH提供了加密的通信通道，更安全地实现了远程访问。

(2) 安装telnet并连接memcached：

yum install telnet -y

telnet memcachedd服务器IP memcahced服务端口

回车后看到ERROR说明已经连接上memcached，ERROR是memcached对空命令的报错。

二、memcached常用管理命令

memcached操作的是计算机的内存空间，通过内存来缓存数据，其数据结构是一个key:value的键值对。

1、set命令与get命令：

(1) set 命令：

set key flag exptime bytes

set：set命令，用于设置键值对（存储数据）。

key：键名，必须是唯一的，同名会被覆盖。

flag：数据的标识位，0代表没有特殊标识。

exptime：过期时间，0代表不过期，单位为s。

bytes：存储数据的字节数。

(2) get命令：

get key

get：get命令，用于获取键值对信息（获取数据）。

key：键名，根据提供的键名，搜索指定的数据。

如果 key 不存在，则返回空：

get key1 key2

get 命令可一次获取多个键的值：

2、add命令与replace命令：

(1) add命令：

add key flag exptime bytes

add 命令用于将 value 存储在指定的 key 中，如果 add 的 key 已经存在，则不会更新。(修改键)

set 命令则会直接覆盖旧的 key。

出现NOT_STORED代表系统中已经存在了一个键名为name的键值对。

(2) replace命令：

replace key flag exptime bytes

replace 命令用于替换已存在的 key 的 value。（修改值）

如果 key不存在，则替换失败，响应 NOT_STORED。

3、append命令与prepend命令：

(1) append命令：

append key flag exptime bytes

append 命令用于向已存在 key 的 value 尾部追加数据（尾部追加）。

定义一个key=hw，存储数据hello，然后追加一个world：

(2) prepend命令：

prepend key flag exptime bytes

prepend 命令用于向已存在 key 的 value 前面追加数据（头部追加）。

定义一个name=hema，然后追加一个it到hema的前面：

4、delete命令与flush_all命令：

(1) delete命令：

delete key

delete 命令指定用于删除已存在的key。

(2) flush_all清空命令：

flush_all [time]

time：用于在指定时间后执行清空操作

清空memcached中的所有缓存的数据，生产环境下尽量不要使用。

5、计算命令与stats命令：

(1) 计算命令：

incr key value   =>  在原有值的基础上进行自增操作

decr key value  =>  在原有值的基础上进行自减操作

(2) stats命令：

stats命令用来获取memcached的运行信息。

cmd_get => memcached运行以来get获取的次数

cmd_set => memcached运行以来set设置的次数

get_hits => 缓存命中数，对于memcached服务器非常重要的指标

① 缓存命中率：get_hits/cmd_get

如果命中率低，业务代码缓存有问题 ；命中率为0，说明缓存没有起作用 。

② 缓存穿透：数据访问经过缓存，没有获取到数据，再直接访问数据库。

③ 缓存雪崩：数据查询全部没有命中，直接访问数据库，数据压力上升。

④ 解决方案：

当数据库中的数据发生变化时，应该尽快将这些变化同步到 Memcached 中；

合理设置缓存的失效时间，并将它们分布开，确保缓存的过期事件不会集中在某个时间点，避免缓存雪崩。

6、memcached注意事项：

① memcached最大过期时间：

过期时间设置最大为30天 (30x24x60x60=2592000s)，超过后，其值无法设置进缓存；

② memcached单个key最大长度：

memcached的key的最大长度是250个字符，是memcached服务端的限制；

③ memcached单个item最大能存储：1M。

三、php安装memcached扩展

1、为什么需要扩展：

PHP默认不支持memcached连接，需要通过memcached扩展程序连接php与memcached。

PHP → mecached.so → Memcached

2、安装PHP Memcached扩展：

(1) 准备软件：

libmemcached-1.0.18.tar.gz ：php memcached 扩展的依赖库

memcached-3.1.3.tgz ：php memcached扩展

(2) 准备环境变量：

PHP扩展编译安装，需要web服务器支持phpize和php-config。

把php的bin目录配置到PATH中（web01 / web02）：

  1. echo 'export PATH=$PATH:/usr/local/php/bin' >> /etc/profile
  2. source /etc/profile

(3) 安装php memcached扩展：

安装libmemcached：

  1. tar xvf libmemcached-1.0.18.tar.gz
  2. cd libmemcached-1.0.18
  3.  
  4. #指定安装目录编译configure脚本
  5. ./configure --prefix=/usr/local/libmemcached
  6. make && make install

安装memcached.so：

  1. tar -zxf memcached-3.1.3.tgz
  2. cd memcached-3.1.3
  3.  
  4. #刚解压出来的memcached-3.1.3中没有configure脚本，需要运行phpize命令生成所需要的configure脚本
  5. /usr/local/php/bin/phpize
  6. ./configure --with-libmemcached-dir=/usr/local/libmemcached --disable-memcached-sasl
  7. make && make install

脚本安装：

  1. #!/bin/bash
  2.  
  3. echo "====================================="
  4. echo "1)安装libmemcached"
  5. echo "2)安装memcached.so"
  6. echo "====================================="
  7.  
  8. read -p "Please Input The Number 1 or 2 =>" key
  9.  
  10. libmemcached() {
  11.     echo "Start Install libmemcached ..."
  12.     sleep 1
  13.     tar -zxf /root/libmemcached-1.0.18.tar.gz
  14.     cd libmemcached-1.0.18
  15.     ./configure --prefix=/usr/local/libmemcached
  16.     make && make install
  17. }
  18.  
  19. memcached() {
  20.     echo "Start Install php memcached.so ..."
  21.     sleep 1
  22.     tar -zxf /root/memcached-3.1.3.tgz
  23.     cd memcached-3.1.3
  24.     /usr/local/php/bin/phpize
  25.     ./configure --with-libmemcached-dir=/usr/local/libmemcached --disable-memcached-sasl
  26.     make && make install
  27. }
  28.  
  29. case $key in
  30.     1)
  31.       libmemcached
  32.     ;;
  33.  
  34.     2)
  35.       memcached
  36.     ;;
  37. esac

查看是否安装扩展：

/usr/local/php/lib/php/extensions/no-debug-zts-20170708：php扩展库的存储路径

(4) 在php.ini文件中开启memcached.so扩展：

vim /usr/local/php/etc/php.ini

extension=memcached.so #在第909行添加这行扩展

设置完成后，重启php-fpm服务：

service php-fpm restart

(5) 测试PHP Memcached扩展是否安装成功 :

在/home/www/public目录下创建一个demo.php文件：

  1. <?php
  2.     phpinfo();
  3. ?>

3、使用PHP操纵Memcached服务器：

在web服务器上编写php代码，通过php的memcached扩展与memcached服务器交互。

Web01/Web02的 home/www/public 下创建一个 demo.php：

  1. <?php
  2.     $mem=new Memcached(); //创建一个对象，用于与Memcached服务器进行通信
  3.     $mem->addServer('10.1.1.20',11211); //指定Memcached服务监听的地址和端口
  4.     $mem->set('name','itheima'); //使用set方法将一个键值对存储到Memcached中
  5.     var_dump($mem->get('name')); //调试输出，输出 name这个键的内容
  6. ?>

先情况memcached内存中所有的key。

访问web服务器ip/demo.php，显示出在memcached服务器中存储的键值，说明PHP已经与memcached交互：

在memcached中可查看到name键值对。

4、memcached_tool：

(1) 作用：

用于查看memcached运行状态、有多少key(item)、内存使用了多少，以及查看缓存命中率等指标。

(2) 配置：

① 上传memcache_tools.php文件到Web服务器中的/home/www/public目录下

  1. <?php
  2. /*
  3.   +----------------------------------------------------------------------+
  4.   | PHP Version 5                                                        |
  5.   +----------------------------------------------------------------------+
  6.   | Copyright (c) 1997-2004 The PHP Group                                |
  7.   +----------------------------------------------------------------------+
  8.   | This source file is subject to version 3.0 of the PHP license,       |
  9.   | that is bundled with this package in the file LICENSE, and is        |
  10.   | available through the world-wide-web at the following url:           |
  11.   | http://www.php.net/license/3_0.txt.                                  |
  12.   | If you did not receive a copy of the PHP license and are unable to   |
  13.   | obtain it through the world-wide-web, please send a note to          |
  14.   | license@php.net so we can mail you a copy immediately.               |
  15.   +----------------------------------------------------------------------+
  16.   | Author:  Harun Yayli <harunyayli at gmail.com>                       |
  17.   +----------------------------------------------------------------------+
  18. */
  19.  
  20. $VERSION='$Id: memcache.php,v 1.1.2.3 2008/08/28 18:07:54 mikl Exp $';
  21.  
  22. define('ADMIN_USERNAME','root'); 	// Admin Username
  23. define('ADMIN_PASSWORD','123456');  	// Admin Password
  24. define('DATE_FORMAT','Y/m/d H:i:s');
  25. define('GRAPH_SIZE',200);
  26. define('MAX_ITEM_DUMP',50);
  27.  
  28. $MEMCACHE_SERVERS[] = '192.168.65.128:11211'; // add more as an array
  29.  
  30.  
  31. // END OF DEFAULT CONFIG AREA /
  32.  
  33. / Password protect 
  34. if (!isset($_SERVER['PHP_AUTH_USER']) || !isset($_SERVER['PHP_AUTH_PW']) ||
  35.            $_SERVER['PHP_AUTH_USER'] != ADMIN_USERNAME ||$_SERVER['PHP_AUTH_PW'] != ADMIN_PASSWORD) {
  36. 			Header("WWW-Authenticate: Basic realm=\"Memcache Login\"");
  37. 			Header("HTTP/1.0 401 Unauthorized");
  38.  
  39. 			echo <<<EOB
  40. 				<html><body>
  41. 				<h1>Rejected!</h1>
  42. 				<big>Wrong Username or Password!</big>
  43. 				</body></html>
  44. EOB;
  45. 			exit;
  46. }
  47.  
  48. ///MEMCACHE FUNCTIONS /
  49.  
  50. function sendMemcacheCommands($command){
  51.     global $MEMCACHE_SERVERS;
  52. 	$result = array();
  53.  
  54. 	foreach($MEMCACHE_SERVERS as $server){
  55. 		$strs = explode(':',$server);
  56. 		$host = $strs[0];
  57. 		$port = $strs[1];
  58. 		$result[$server] = sendMemcacheCommand($host,$port,$command);
  59. 	}
  60. 	return $result;
  61. }
  62. function sendMemcacheCommand($server,$port,$command){
  63.  
  64. 	$s = @fsockopen($server,$port);
  65. 	if (!$s){
  66. 		die("Cant connect to:".$server.':'.$port);
  67. 	}
  68.  
  69. 	fwrite($s, $command."\r\n");
  70.  
  71. 	$buf='';
  72. 	while ((!feof($s))) {
  73. 		$buf .= fgets($s, 256);
  74. 		if (strpos($buf,"END\r\n")!==false){ // stat says end
  75. 		    break;
  76. 		}
  77. 		if (strpos($buf,"DELETED\r\n")!==false || strpos($buf,"NOT_FOUND\r\n")!==false){ // delete says these
  78. 		    break;
  79. 		}
  80. 		if (strpos($buf,"OK\r\n")!==false){ // flush_all says ok
  81. 		    break;
  82. 		}
  83. 	}
  84.     fclose($s);
  85.     return parseMemcacheResults($buf);
  86. }
  87. function parseMemcacheResults($str){
  88.  
  89. 	$res = array();
  90. 	$lines = explode("\r\n",$str);
  91. 	$cnt = count($lines);
  92. 	for($i=0; $i< $cnt; $i++){
  93. 	    $line = $lines[$i];
  94. 		$l = explode(' ',$line,3);
  95. 		if (count($l)==3){
  96. 			$res[$l[0]][$l[1]]=$l[2];
  97. 			if ($l[0]=='VALUE'){ // next line is the value
  98. 			    $res[$l[0]][$l[1]] = array();
  99. 			    list ($flag,$size)=explode(' ',$l[2]);
  100. 			    $res[$l[0]][$l[1]]['stat']=array('flag'=>$flag,'size'=>$size);
  101. 			    $res[$l[0]][$l[1]]['value']=$lines[++$i];
  102. 			}
  103. 		}elseif($line=='DELETED' || $line=='NOT_FOUND' || $line=='OK'){
  104. 		    return $line;
  105. 		}
  106. 	}
  107. 	return $res;
  108.  
  109. }
  110.  
  111. function dumpCacheSlab($server,$slabId,$limit){
  112.     list($host,$port) = explode(':',$server);
  113.     $resp = sendMemcacheCommand($host,$port,'stats cachedump '.$slabId.' '.$limit);
  114.  
  115.    return $resp;
  116.  
  117. }
  118.  
  119. function flushServer($server){
  120.     list($host,$port) = explode(':',$server);
  121.     $resp = sendMemcacheCommand($host,$port,'flush_all');
  122.     return $resp;
  123. }
  124. function getCacheItems(){
  125.  $items = sendMemcacheCommands('stats items');
  126.  $serverItems = array();
  127.  $totalItems = array();
  128.  foreach ($items as $server=>$itemlist){
  129.     $serverItems[$server] = array();
  130.     $totalItems[$server]=0;
  131.     if (!isset($itemlist['STAT'])){
  132.         continue;
  133.     }
  134.  
  135.     $iteminfo = $itemlist['STAT'];
  136.  
  137.     foreach($iteminfo as $keyinfo=>$value){
  138.         if (preg_match('/items\:(\d+?)\:(.+?)$/',$keyinfo,$matches)){
  139.             $serverItems[$server][$matches[1]][$matches[2]] = $value;
  140.             if ($matches[2]=='number'){
  141.                 $totalItems[$server] +=$value;
  142.             }
  143.         }
  144.     }
  145.  }
  146.  return array('items'=>$serverItems,'counts'=>$totalItems);
  147. }
  148. function getMemcacheStats($total=true){
  149. 	$resp = sendMemcacheCommands('stats');
  150. 	if ($total){
  151. 		$res = array();
  152. 		foreach($resp as $server=>$r){
  153. 			foreach($r['STAT'] as $key=>$row){
  154. 				if (!isset($res[$key])){
  155. 					$res[$key]=null;
  156. 				}
  157. 				switch ($key){
  158. 					case 'pid':
  159. 						$res['pid'][$server]=$row;
  160. 						break;
  161. 					case 'uptime':
  162. 						$res['uptime'][$server]=$row;
  163. 						break;
  164. 					case 'time':
  165. 						$res['time'][$server]=$row;
  166. 						break;
  167. 					case 'version':
  168. 						$res['version'][$server]=$row;
  169. 						break;
  170. 					case 'pointer_size':
  171. 						$res['pointer_size'][$server]=$row;
  172. 						break;
  173. 					case 'rusage_user':
  174. 						$res['rusage_user'][$server]=$row;
  175. 						break;
  176. 					case 'rusage_system':
  177. 						$res['rusage_system'][$server]=$row;
  178. 						break;
  179. 					case 'curr_items':
  180. 						$res['curr_items']+=$row;
  181. 						break;
  182. 					case 'total_items':
  183. 						$res['total_items']+=$row;
  184. 						break;
  185. 					case 'bytes':
  186. 						$res['bytes']+=$row;
  187. 						break;
  188. 					case 'curr_connections':
  189. 						$res['curr_connections']+=$row;
  190. 						break;
  191. 					case 'total_connections':
  192. 						$res['total_connections']+=$row;
  193. 						break;
  194. 					case 'connection_structures':
  195. 						$res['connection_structures']+=$row;
  196. 						break;
  197. 					case 'cmd_get':
  198. 						$res['cmd_get']+=$row;
  199. 						break;
  200. 					case 'cmd_set':
  201. 						$res['cmd_set']+=$row;
  202. 						break;
  203. 					case 'get_hits':
  204. 						$res['get_hits']+=$row;
  205. 						break;
  206. 					case 'get_misses':
  207. 						$res['get_misses']+=$row;
  208. 						break;
  209. 					case 'evictions':
  210. 						$res['evictions']+=$row;
  211. 						break;
  212. 					case 'bytes_read':
  213. 						$res['bytes_read']+=$row;
  214. 						break;
  215. 					case 'bytes_written':
  216. 						$res['bytes_written']+=$row;
  217. 						break;
  218. 					case 'limit_maxbytes':
  219. 						$res['limit_maxbytes']+=$row;
  220. 						break;
  221. 					case 'threads':
  222. 						$res['rusage_system'][$server]=$row;
  223. 						break;
  224. 				}
  225. 			}
  226. 		}
  227. 		return $res;
  228. 	}
  229. 	return $resp;
  230. }
  231.  
  232. //
  233.  
  234. //
  235. // don't cache this page
  236. //
  237. header("Cache-Control: no-store, no-cache, must-revalidate");  // HTTP/1.1
  238. header("Cache-Control: post-check=0, pre-check=0", false);
  239. header("Pragma: no-cache");                                    // HTTP/1.0
  240.  
  241. function duration($ts) {
  242.     global $time;
  243.     $years = (int)((($time - $ts)/(7*86400))/52.177457);
  244.     $rem = (int)(($time-$ts)-($years * 52.177457 * 7 * 86400));
  245.     $weeks = (int)(($rem)/(7*86400));
  246.     $days = (int)(($rem)/86400) - $weeks*7;
  247.     $hours = (int)(($rem)/3600) - $days*24 - $weeks*7*24;
  248.     $mins = (int)(($rem)/60) - $hours*60 - $days*24*60 - $weeks*7*24*60;
  249.     $str = '';
  250.     if($years==1) $str .= "$years year, ";
  251.     if($years>1) $str .= "$years years, ";
  252.     if($weeks==1) $str .= "$weeks week, ";
  253.     if($weeks>1) $str .= "$weeks weeks, ";
  254.     if($days==1) $str .= "$days day,";
  255.     if($days>1) $str .= "$days days,";
  256.     if($hours == 1) $str .= " $hours hour and";
  257.     if($hours>1) $str .= " $hours hours and";
  258.     if($mins == 1) $str .= " 1 minute";
  259.     else $str .= " $mins minutes";
  260.     return $str;
  261. }
  262.  
  263. // create graphics
  264. //
  265. function graphics_avail() {
  266. 	return extension_loaded('gd');
  267. }
  268.  
  269. function bsize($s) {
  270. 	foreach (array('','K','M','G') as $i => $k) {
  271. 		if ($s < 1024) break;
  272. 		$s/=1024;
  273. 	}
  274. 	return sprintf("%5.1f %sBytes",$s,$k);
  275. }
  276.  
  277. // create menu entry
  278. function menu_entry($ob,$title) {
  279. 	global $PHP_SELF;
  280. 	if ($ob==$_GET['op']){
  281. 	    return "<li><a class=\"child_active\" href=\"$PHP_SELF&op=$ob\">$title</a></li>";
  282. 	}
  283. 	return "<li><a class=\"active\" href=\"$PHP_SELF&op=$ob\">$title</a></li>";
  284. }
  285.  
  286. function getHeader(){
  287.     $header = <<<EOB
  288. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  289. <html>
  290. <head><title>MEMCACHE INFO</title>
  291. <style type="text/css"><!--
  292. body { background:white; font-size:100.01%; margin:0; padding:0; }
  293. body,p,td,th,input,submit { font-size:0.8em;font-family:arial,helvetica,sans-serif; }
  294. * html body   {font-size:0.8em}
  295. * html p      {font-size:0.8em}
  296. * html td     {font-size:0.8em}
  297. * html th     {font-size:0.8em}
  298. * html input  {font-size:0.8em}
  299. * html submit {font-size:0.8em}
  300. td { vertical-align:top }
  301. a { color:black; font-weight:none; text-decoration:none; }
  302. a:hover { text-decoration:underline; }
  303. div.content { padding:1em 1em 1em 1em; position:absolute; width:97%; z-index:100; }
  305. h1.memcache { background:rgb(153,153,204); margin:0; padding:0.5em 1em 0.5em 1em; }
  306. * html h1.memcache { margin-bottom:-7px; }
  307. h1.memcache a:hover { text-decoration:none; color:rgb(90,90,90); }
  308. h1.memcache span.logo {
  309. 	background:rgb(119,123,180);
  310. 	color:black;
  311. 	border-right: solid black 1px;
  312. 	border-bottom: solid black 1px;
  313. 	font-style:italic;
  314. 	font-size:1em;
  315. 	padding-left:1.2em;
  316. 	padding-right:1.2em;
  317. 	text-align:right;
  318. 	display:block;
  319. 	width:130px;
  320. 	}
  321. h1.memcache span.logo span.name { color:white; font-size:0.7em; padding:0 0.8em 0 2em; }
  322. h1.memcache span.nameinfo { color:white; display:inline; font-size:0.4em; margin-left: 3em; }
  323. h1.memcache div.copy { color:black; font-size:0.4em; position:absolute; right:1em; }
  324. hr.memcache {
  325. 	background:white;
  326. 	border-bottom:solid rgb(102,102,153) 1px;
  327. 	border-style:none;
  328. 	border-top:solid rgb(102,102,153) 10px;
  329. 	height:12px;
  330. 	margin:0;
  331. 	margin-top:1px;
  332. 	padding:0;
  333. }
  335. ol,menu { margin:1em 0 0 0; padding:0.2em; margin-left:1em;}
  336. ol.menu li { display:inline; margin-right:0.7em; list-style:none; font-size:85%}
  337. ol.menu a {
  338. 	background:rgb(153,153,204);
  339. 	border:solid rgb(102,102,153) 2px;
  340. 	color:white;
  341. 	font-weight:bold;
  342. 	margin-right:0em;
  343. 	padding:0.1em 0.5em 0.1em 0.5em;
  344. 	text-decoration:none;
  345. 	margin-left: 5px;
  346. 	}
  347. ol.menu a.child_active {
  348. 	background:rgb(153,153,204);
  349. 	border:solid rgb(102,102,153) 2px;
  350. 	color:white;
  351. 	font-weight:bold;
  352. 	margin-right:0em;
  353. 	padding:0.1em 0.5em 0.1em 0.5em;
  354. 	text-decoration:none;
  355. 	border-left: solid black 5px;
  356. 	margin-left: 0px;
  357. 	}
  358. ol.menu span.active {
  359. 	background:rgb(153,153,204);
  360. 	border:solid rgb(102,102,153) 2px;
  361. 	color:black;
  362. 	font-weight:bold;
  363. 	margin-right:0em;
  364. 	padding:0.1em 0.5em 0.1em 0.5em;
  365. 	text-decoration:none;
  366. 	border-left: solid black 5px;
  367. 	}
  368. ol.menu span.inactive {
  369. 	background:rgb(193,193,244);
  370. 	border:solid rgb(182,182,233) 2px;
  371. 	color:white;
  372. 	font-weight:bold;
  373. 	margin-right:0em;
  374. 	padding:0.1em 0.5em 0.1em 0.5em;
  375. 	text-decoration:none;
  376. 	margin-left: 5px;
  377. 	}
  378. ol.menu a:hover {
  379. 	background:rgb(193,193,244);
  380. 	text-decoration:none;
  381. 	}
  384. div.info {
  385. 	background:rgb(204,204,204);
  386. 	border:solid rgb(204,204,204) 1px;
  387. 	margin-bottom:1em;
  388. 	}
  389. div.info h2 {
  390. 	background:rgb(204,204,204);
  391. 	color:black;
  392. 	font-size:1em;
  393. 	margin:0;
  394. 	padding:0.1em 1em 0.1em 1em;
  395. 	}
  396. div.info table {
  397. 	border:solid rgb(204,204,204) 1px;
  398. 	border-spacing:0;
  399. 	width:100%;
  400. 	}
  401. div.info table th {
  402. 	background:rgb(204,204,204);
  403. 	color:white;
  404. 	margin:0;
  405. 	padding:0.1em 1em 0.1em 1em;
  406. 	}
  407. div.info table th a.sortable { color:black; }
  408. div.info table tr.tr-0 { background:rgb(238,238,238); }
  409. div.info table tr.tr-1 { background:rgb(221,221,221); }
  410. div.info table td { padding:0.3em 1em 0.3em 1em; }
  411. div.info table td.td-0 { border-right:solid rgb(102,102,153) 1px; white-space:nowrap; }
  412. div.info table td.td-n { border-right:solid rgb(102,102,153) 1px; }
  413. div.info table td h3 {
  414. 	color:black;
  415. 	font-size:1.1em;
  416. 	margin-left:-0.3em;
  417. 	}
  418. .td-0 a , .td-n a, .tr-0 a , tr-1 a {
  419.     text-decoration:underline;
  420. }
  421. div.graph { margin-bottom:1em }
  422. div.graph h2 { background:rgb(204,204,204);; color:black; font-size:1em; margin:0; padding:0.1em 1em 0.1em 1em; }
  423. div.graph table { border:solid rgb(204,204,204) 1px; color:black; font-weight:normal; width:100%; }
  424. div.graph table td.td-0 { background:rgb(238,238,238); }
  425. div.graph table td.td-1 { background:rgb(221,221,221); }
  426. div.graph table td { padding:0.2em 1em 0.4em 1em; }
  428. div.div1,div.div2 { margin-bottom:1em; width:35em; }
  429. div.div3 { position:absolute; left:40em; top:1em; width:580px; }
  430. //div.div3 { position:absolute; left:37em; top:1em; right:1em; }
  432. div.sorting { margin:1.5em 0em 1.5em 2em }
  433. .center { text-align:center }
  434. .aright { position:absolute;right:1em }
  435. .right { text-align:right }
  436. .ok { color:rgb(0,200,0); font-weight:bold}
  437. .failed { color:rgb(200,0,0); font-weight:bold}
  439. span.box {
  440. 	border: black solid 1px;
  441. 	border-right:solid black 2px;
  442. 	border-bottom:solid black 2px;
  443. 	padding:0 0.5em 0 0.5em;
  444. 	margin-right:1em;
  445. }
  446. span.green { background:#60F060; padding:0 0.5em 0 0.5em}
  447. span.red { background:#D06030; padding:0 0.5em 0 0.5em }
  449. div.authneeded {
  450. 	background:rgb(238,238,238);
  451. 	border:solid rgb(204,204,204) 1px;
  452. 	color:rgb(200,0,0);
  453. 	font-size:1.2em;
  454. 	font-weight:bold;
  455. 	padding:2em;
  456. 	text-align:center;
  457. 	}
  459. input {
  460. 	background:rgb(153,153,204);
  461. 	border:solid rgb(102,102,153) 2px;
  462. 	color:white;
  463. 	font-weight:bold;
  464. 	margin-right:1em;
  465. 	padding:0.1em 0.5em 0.1em 0.5em;
  466. 	}
  467. //-->
  468. </style>
  469. </head>
  470. <body>
  471. <div class="head">
  472. 	<h1 class="memcache">
  473. 		<span class="logo"><a href="http://pecl.php.net/package/memcache">memcache</a></span>
  474. 		<span class="nameinfo">memcache.php by <a href="http://livebookmark.net">Harun Yayli</a></span>
  475. 	</h1>
  476. 	<hr class="memcache">
  477. </div>
  478. <div class=content>
  479. EOB;
  480.  
  481.     return $header;
  482. }
  483. function getFooter(){
  484.     global $VERSION;
  485.     $footer = '</div><!-- Based on apc.php '.$VERSION.'--></body>
  486. </html>
  487. ';
  488.  
  489.     return $footer;
  490.  
  491. }
  492. function getMenu(){
  493.     global $PHP_SELF;
  494. echo "<ol class=menu>";
  495. if ($_GET['op']!=4){
  496. echo <<<EOB
  497.     <li><a href="$PHP_SELF&op={$_GET['op']}">Refresh Data</a></li>
  498. EOB;
  499. }
  500. else {
  501. echo <<<EOB
  502.     <li><a href="$PHP_SELF&op=2}">Back</a></li>
  503. EOB;
  504. }
  505. echo
  506. 	menu_entry(1,'View Host Stats'),
  507. 	menu_entry(2,'Variables');
  508.  
  509. echo <<<EOB
  510. 	</ol>
  511. 	<br/>
  512. EOB;
  513. }
  514.  
  515. // TODO, AUTH
  516.  
  517. $_GET['op'] = !isset($_GET['op'])? '1':$_GET['op'];
  518. $PHP_SELF= isset($_SERVER['PHP_SELF']) ? htmlentities(strip_tags($_SERVER['PHP_SELF'],'')) : '';
  519.  
  520. $PHP_SELF=$PHP_SELF.'?';
  521. $time = time();
  522. // sanitize _GET
  523.  
  524. foreach($_GET as $key=>$g){
  525.     $_GET[$key]=htmlentities($g);
  526. }
  527.  
  528.  
  529. // singleout
  530. // when singleout is set, it only gives details for that server.
  531. if (isset($_GET['singleout']) && $_GET['singleout']>=0 && $_GET['singleout'] <count($MEMCACHE_SERVERS)){
  532.     $MEMCACHE_SERVERS = array($MEMCACHE_SERVERS[$_GET['singleout']]);
  533. }
  534.  
  535. // display images
  536. if (isset($_GET['IMG'])){
  537.     $memcacheStats = getMemcacheStats();
  538.     $memcacheStatsSingle = getMemcacheStats(false);
  539.  
  540.     if (!graphics_avail()) {
  541. 		exit(0);
  542. 	}
  543.  
  544. 	function fill_box($im, $x, $y, $w, $h, $color1, $color2,$text='',$placeindex='') {
  545. 		global $col_black;
  546. 		$x1=$x+$w-1;
  547. 		$y1=$y+$h-1;
  548.  
  549. 		imagerectangle($im, $x, $y1, $x1+1, $y+1, $col_black);
  550. 		if($y1>$y) imagefilledrectangle($im, $x, $y, $x1, $y1, $color2);
  551. 		else imagefilledrectangle($im, $x, $y1, $x1, $y, $color2);
  552. 		imagerectangle($im, $x, $y1, $x1, $y, $color1);
  553. 		if ($text) {
  554. 			if ($placeindex>0) {
  555.  
  556. 				if ($placeindex<16)
  557. 				{
  558. 					$px=5;
  559. 					$py=$placeindex*12+6;
  560. 					imagefilledrectangle($im, $px+90, $py+3, $px+90-4, $py-3, $color2);
  561. 					imageline($im,$x,$y+$h/2,$px+90,$py,$color2);
  562. 					imagestring($im,2,$px,$py-6,$text,$color1);
  563.  
  564. 				} else {
  565. 					if ($placeindex<31) {
  566. 						$px=$x+40*2;
  567. 						$py=($placeindex-15)*12+6;
  568. 					} else {
  569. 						$px=$x+40*2+100*intval(($placeindex-15)/15);
  570. 						$py=($placeindex%15)*12+6;
  571. 					}
  572. 					imagefilledrectangle($im, $px, $py+3, $px-4, $py-3, $color2);
  573. 					imageline($im,$x+$w,$y+$h/2,$px,$py,$color2);
  574. 					imagestring($im,2,$px+2,$py-6,$text,$color1);
  575. 				}
  576. 			} else {
  577. 				imagestring($im,4,$x+5,$y1-16,$text,$color1);
  578. 			}
  579. 		}
  580. 	}
  581.  
  582.  
  583.     function fill_arc($im, $centerX, $centerY, $diameter, $start, $end, $color1,$color2,$text='',$placeindex=0) {
  584. 		$r=$diameter/2;
  585. 		$w=deg2rad((360+$start+($end-$start)/2)%360);
  586.  
  587.  
  588. 		if (function_exists("imagefilledarc")) {
  589. 			// exists only if GD 2.0.1 is avaliable
  590. 			imagefilledarc($im, $centerX+1, $centerY+1, $diameter, $diameter, $start, $end, $color1, IMG_ARC_PIE);
  591. 			imagefilledarc($im, $centerX, $centerY, $diameter, $diameter, $start, $end, $color2, IMG_ARC_PIE);
  592. 			imagefilledarc($im, $centerX, $centerY, $diameter, $diameter, $start, $end, $color1, IMG_ARC_NOFILL|IMG_ARC_EDGED);
  593. 		} else {
  594. 			imagearc($im, $centerX, $centerY, $diameter, $diameter, $start, $end, $color2);
  595. 			imageline($im, $centerX, $centerY, $centerX + cos(deg2rad($start)) * $r, $centerY + sin(deg2rad($start)) * $r, $color2);
  596. 			imageline($im, $centerX, $centerY, $centerX + cos(deg2rad($start+1)) * $r, $centerY + sin(deg2rad($start)) * $r, $color2);
  597. 			imageline($im, $centerX, $centerY, $centerX + cos(deg2rad($end-1))   * $r, $centerY + sin(deg2rad($end))   * $r, $color2);
  598. 			imageline($im, $centerX, $centerY, $centerX + cos(deg2rad($end))   * $r, $centerY + sin(deg2rad($end))   * $r, $color2);
  599. 			imagefill($im,$centerX + $r*cos($w)/2, $centerY + $r*sin($w)/2, $color2);
  600. 		}
  601. 		if ($text) {
  602. 			if ($placeindex>0) {
  603. 				imageline($im,$centerX + $r*cos($w)/2, $centerY + $r*sin($w)/2,$diameter, $placeindex*12,$color1);
  604. 				imagestring($im,4,$diameter, $placeindex*12,$text,$color1);
  605.  
  606. 			} else {
  607. 				imagestring($im,4,$centerX + $r*cos($w)/2, $centerY + $r*sin($w)/2,$text,$color1);
  608. 			}
  609. 		}
  610. 	}
  611. 	$size = GRAPH_SIZE; // image size
  612. 	$image = imagecreate($size+50, $size+10);
  613.  
  614. 	$col_white = imagecolorallocate($image, 0xFF, 0xFF, 0xFF);
  615. 	$col_red   = imagecolorallocate($image, 0xD0, 0x60,  0x30);
  616. 	$col_green = imagecolorallocate($image, 0x60, 0xF0, 0x60);
  617. 	$col_black = imagecolorallocate($image,   0,   0,   0);
  618.  
  619. 	imagecolortransparent($image,$col_white);
  620.  
  621.     switch ($_GET['IMG']){
  622.         case 1: // pie chart
  623.             $tsize=$memcacheStats['limit_maxbytes'];
  624.     		$avail=$tsize-$memcacheStats['bytes'];
  625.     		$x=$y=$size/2;
  626.     		$angle_from = 0;
  627.     		$fuzz = 0.000001;
  628.  
  629.             foreach($memcacheStatsSingle as $serv=>$mcs) {
  630.     			$free = $mcs['STAT']['limit_maxbytes']-$mcs['STAT']['bytes'];
  631.     			$used = $mcs['STAT']['bytes'];
  632.  
  633.  
  634.                 if ($free>0){
  635.     			// draw free
  636.     			    $angle_to = ($free*360)/$tsize;
  637.                     $perc =sprintf("%.2f%%", ($free *100) / $tsize) ;
  638.  
  639.         			fill_arc($image,$x,$y,$size,$angle_from,$angle_from + $angle_to ,$col_black,$col_green,$perc);
  640.         			$angle_from = $angle_from + $angle_to ;
  641.                 }
  642.     			if ($used>0){
  643.     			// draw used
  644.         			$angle_to = ($used*360)/$tsize;
  645.         			$perc =sprintf("%.2f%%", ($used *100) / $tsize) ;
  646.         			fill_arc($image,$x,$y,$size,$angle_from,$angle_from + $angle_to ,$col_black,$col_red, '('.$perc.')' );
  647.                     $angle_from = $angle_from+ $angle_to ;
  648.     			}
  649.     			}
  650.  
  651.         break;
  652.  
  653.         case 2: // hit miss
  654.  
  655.             $hits = ($memcacheStats['get_hits']==0) ? 1:$memcacheStats['get_hits'];
  656.             $misses = ($memcacheStats['get_misses']==0) ? 1:$memcacheStats['get_misses'];
  657.             $total = $hits + $misses ;
  658.  
  659. 	       	fill_box($image, 30,$size,50,-$hits*($size-21)/$total,$col_black,$col_green,sprintf("%.1f%%",$hits*100/$total));
  660. 		    fill_box($image,130,$size,50,-max(4,($total-$hits)*($size-21)/$total),$col_black,$col_red,sprintf("%.1f%%",$misses*100/$total));
  661. 		break;
  662.  
  663.     }
  664.     header("Content-type: image/png");
  665. 	imagepng($image);
  666. 	exit;
  667. }
  668.  
  669. echo getHeader();
  670. echo getMenu();
  671.  
  672. switch ($_GET['op']) {
  673.  
  674.     case 1: // host stats
  675.     	$phpversion = phpversion();
  676.         $memcacheStats = getMemcacheStats();
  677.         $memcacheStatsSingle = getMemcacheStats(false);
  678.  
  679.         $mem_size = $memcacheStats['limit_maxbytes'];
  680.     	$mem_used = $memcacheStats['bytes'];
  681. 	    $mem_avail= $mem_size-$mem_used;
  682. 	    $startTime = time()-array_sum($memcacheStats['uptime']);
  683.  
  684.         $curr_items = $memcacheStats['curr_items'];
  685.         $total_items = $memcacheStats['total_items'];
  686.         $hits = ($memcacheStats['get_hits']==0) ? 1:$memcacheStats['get_hits'];
  687.         $misses = ($memcacheStats['get_misses']==0) ? 1:$memcacheStats['get_misses'];
  688.         $sets = $memcacheStats['cmd_set'];
  689.  
  690.        	$req_rate = sprintf("%.2f",($hits+$misses)/($time-$startTime));
  691. 	    $hit_rate = sprintf("%.2f",($hits)/($time-$startTime));
  692. 	    $miss_rate = sprintf("%.2f",($misses)/($time-$startTime));
  693. 	    $set_rate = sprintf("%.2f",($sets)/($time-$startTime));
  694.  
  695. 	    echo <<< EOB
  696. 		<div class="info div1"><h2>General Cache Information</h2>
  697. 		<table cellspacing=0><tbody>
  698. 		<tr class=tr-1><td class=td-0>PHP Version</td><td>$phpversion</td></tr>
  699. EOB;
  700. 		echo "<tr class=tr-0><td class=td-0>Memcached Host". ((count($MEMCACHE_SERVERS)>1) ? 's':'')."</td><td>";
  701. 		$i=0;
  702. 		if (!isset($_GET['singleout']) && count($MEMCACHE_SERVERS)>1){
  703.     		foreach($MEMCACHE_SERVERS as $server){
  704.     		      echo ($i+1).'. <a href="'.$PHP_SELF.'&singleout='.$i++.'">'.$server.'</a><br/>';
  705.     		}
  706. 		}
  707. 		else{
  708. 		    echo '1.'.$MEMCACHE_SERVERS[0];
  709. 		}
  710. 		if (isset($_GET['singleout'])){
  711. 		      echo '<a href="'.$PHP_SELF.'">(all servers)</a><br/>';
  712. 		}
  713. 		echo "</td></tr>\n";
  714. 		echo "<tr class=tr-1><td class=td-0>Total Memcache Cache</td><td>".bsize($memcacheStats['limit_maxbytes'])."</td></tr>\n";
  715.  
  716. 	echo <<<EOB
  717. 		</tbody></table>
  718. 		</div>
  720. 		<div class="info div1"><h2>Memcache Server Information</h2>
  721. EOB;
  722.         foreach($MEMCACHE_SERVERS as $server){
  723.             echo '<table cellspacing=0><tbody>';
  724.             echo '<tr class=tr-1><td class=td-1>'.$server.'</td><td><a href="'.$PHP_SELF.'&server='.array_search($server,$MEMCACHE_SERVERS).'&op=6">[<b>Flush this server</b>]</a></td></tr>';
  725.     		echo '<tr class=tr-0><td class=td-0>Start Time</td><td>',date(DATE_FORMAT,$memcacheStatsSingle[$server]['STAT']['time']-$memcacheStatsSingle[$server]['STAT']['uptime']),'</td></tr>';
  726.     		echo '<tr class=tr-1><td class=td-0>Uptime</td><td>',duration($memcacheStatsSingle[$server]['STAT']['time']-$memcacheStatsSingle[$server]['STAT']['uptime']),'</td></tr>';
  727.     		echo '<tr class=tr-0><td class=td-0>Memcached Server Version</td><td>'.$memcacheStatsSingle[$server]['STAT']['version'].'</td></tr>';
  728.     		echo '<tr class=tr-1><td class=td-0>Used Cache Size</td><td>',bsize($memcacheStatsSingle[$server]['STAT']['bytes']),'</td></tr>';
  729.     		echo '<tr class=tr-0><td class=td-0>Total Cache Size</td><td>',bsize($memcacheStatsSingle[$server]['STAT']['limit_maxbytes']),'</td></tr>';
  730.     		echo '</tbody></table>';
  731. 	   }
  732.     echo <<<EOB
  734. 		</div>
  735. 		<div class="graph div3"><h2>Host Status Diagrams</h2>
  736. 		<table cellspacing=0><tbody>
  737. EOB;
  738.  
  739. 	$size='width='.(GRAPH_SIZE+50).' height='.(GRAPH_SIZE+10);
  740. 	echo <<<EOB
  741. 		<tr>
  742. 		<td class=td-0>Cache Usage</td>
  743. 		<td class=td-1>Hits &amp; Misses</td>
  744. 		</tr>
  745. EOB;
  746.  
  747. 	echo
  748. 		graphics_avail() ?
  749. 			  '<tr>'.
  750. 			  "<td class=td-0><img alt=\"\" $size src=\"$PHP_SELF&IMG=1&".(isset($_GET['singleout'])? 'singleout='.$_GET['singleout'].'&':'')."$time\"></td>".
  751. 			  "<td class=td-1><img alt=\"\" $size src=\"$PHP_SELF&IMG=2&".(isset($_GET['singleout'])? 'singleout='.$_GET['singleout'].'&':'')."$time\"></td></tr>\n"
  752. 			: "",
  753. 		'<tr>',
  754. 		'<td class=td-0><span class="green box">&nbsp;</span>Free: ',bsize($mem_avail).sprintf(" (%.1f%%)",$mem_avail*100/$mem_size),"</td>\n",
  755. 		'<td class=td-1><span class="green box">&nbsp;</span>Hits: ',$hits.sprintf(" (%.1f%%)",$hits*100/($hits+$misses)),"</td>\n",
  756. 		'</tr>',
  757. 		'<tr>',
  758. 		'<td class=td-0><span class="red box">&nbsp;</span>Used: ',bsize($mem_used ).sprintf(" (%.1f%%)",$mem_used *100/$mem_size),"</td>\n",
  759. 		'<td class=td-1><span class="red box">&nbsp;</span>Misses: ',$misses.sprintf(" (%.1f%%)",$misses*100/($hits+$misses)),"</td>\n";
  760. 		echo <<< EOB
  761. 	</tr>
  762. 	</tbody></table>
  763. <br/>
  764. 	<div class="info"><h2>Cache Information</h2>
  765. 		<table cellspacing=0><tbody>
  766. 		<tr class=tr-0><td class=td-0>Current Items(total)</td><td>$curr_items ($total_items)</td></tr>
  767. 		<tr class=tr-1><td class=td-0>Hits</td><td>{$hits}</td></tr>
  768. 		<tr class=tr-0><td class=td-0>Misses</td><td>{$misses}</td></tr>
  769. 		<tr class=tr-1><td class=td-0>Request Rate (hits, misses)</td><td>$req_rate cache requests/second</td></tr>
  770. 		<tr class=tr-0><td class=td-0>Hit Rate</td><td>$hit_rate cache requests/second</td></tr>
  771. 		<tr class=tr-1><td class=td-0>Miss Rate</td><td>$miss_rate cache requests/second</td></tr>
  772. 		<tr class=tr-0><td class=td-0>Set Rate</td><td>$set_rate cache requests/second</td></tr>
  773. 		</tbody></table>
  774. 		</div>
  776. EOB;
  777.  
  778.     break;
  779.  
  780.     case 2: // variables
  781.  
  782. 		$m=0;
  783. 		$cacheItems= getCacheItems();
  784. 		$items = $cacheItems['items'];
  785. 		$totals = $cacheItems['counts'];
  786. 		$maxDump = MAX_ITEM_DUMP;
  787. 		foreach($items as $server => $entries) {
  788.  
  789.     	echo <<< EOB
  791. 			<div class="info"><table cellspacing=0><tbody>
  792. 			<tr><th colspan="2">$server</th></tr>
  793. 			<tr><th>Slab Id</th><th>Info</th></tr>
  794. EOB;
  795.  
  796. 			foreach($entries as $slabId => $slab) {
  797. 			    $dumpUrl = $PHP_SELF.'&op=2&server='.(array_search($server,$MEMCACHE_SERVERS)).'&dumpslab='.$slabId;
  798. 				echo
  799. 					"<tr class=tr-$m>",
  800. 					"<td class=td-0><center>",'<a href="',$dumpUrl,'">',$slabId,'</a>',"</center></td>",
  801. 					"<td class=td-last><b>Item count:</b> ",$slab['number'],'<br/><b>Age:</b>',duration($time-$slab['age']),'<br/> <b>Evicted:</b>',((isset($slab['evicted']) && $slab['evicted']==1)? 'Yes':'No');
  802. 					if ((isset($_GET['dumpslab']) && $_GET['dumpslab']==$slabId) &&  (isset($_GET['server']) && $_GET['server']==array_search($server,$MEMCACHE_SERVERS))){
  803. 					    echo "<br/><b>Items: item</b><br/>";
  804. 					    $items = dumpCacheSlab($server,$slabId,$slab['number']);
  805.                         // maybe someone likes to do a pagination here :)
  806. 					    $i=1;
  807.                         foreach($items['ITEM'] as $itemKey=>$itemInfo){
  808.                             $itemInfo = trim($itemInfo,'[ ]');
  809.  
  810.  
  811.                             echo '<a href="',$PHP_SELF,'&op=4&server=',(array_search($server,$MEMCACHE_SERVERS)),'&key=',base64_encode($itemKey).'">',$itemKey,'</a>';
  812.                             if ($i++ % 10 == 0) {
  813.                                 echo '<br/>';
  814.                             }
  815.                             elseif ($i!=$slab['number']+1){
  816.                                 echo ',';
  817.                             }
  818.                         }
  819. 					}
  820.  
  821. 					echo "</td></tr>";
  822. 				$m=1-$m;
  823. 			}
  824. 		echo <<<EOB
  825. 			</tbody></table>
  826. 			</div><hr/>
  827. EOB;
  828. }
  829. 		break;
  830.  
  831.     break;
  832.  
  833.     case 4: //item dump
  834.         if (!isset($_GET['key']) || !isset($_GET['server'])){
  835.             echo "No key set!";
  836.             break;
  837.         }
  838.         // I'm not doing anything to check the validity of the key string.
  839.         // probably an exploit can be written to delete all the files in key=base64_encode("\n\r delete all").
  840.         // somebody has to do a fix to this.
  841.         $theKey = htmlentities(base64_decode($_GET['key']));
  842.  
  843.         $theserver = $MEMCACHE_SERVERS[(int)$_GET['server']];
  844.         list($h,$p) = explode(':',$theserver);
  845.         $r = sendMemcacheCommand($h,$p,'get '.$theKey);
  846.         echo <<<EOB
  847.         <div class="info"><table cellspacing=0><tbody>
  848. 			<tr><th>Server<th>Key</th><th>Value</th><th>Delete</th></tr>
  849. EOB;
  850.         echo "<tr><td class=td-0>",$theserver,"</td><td class=td-0>",$theKey,
  851.              " <br/>flag:",$r['VALUE'][$theKey]['stat']['flag'],
  852.              " <br/>Size:",bsize($r['VALUE'][$theKey]['stat']['size']),
  853.              "</td><td>",chunk_split($r['VALUE'][$theKey]['value'],40),"</td>",
  854.              '<td><a href="',$PHP_SELF,'&op=5&server=',(int)$_GET['server'],'&key=',base64_encode($theKey),"\">Delete</a></td>","</tr>";
  855.         echo <<<EOB
  856. 			</tbody></table>
  857. 			</div><hr/>
  858. EOB;
  859.     break;
  860.     case 5: // item delete
  861.     	if (!isset($_GET['key']) || !isset($_GET['server'])){
  862. 			echo "No key set!";
  863. 			break;
  864.         }
  865.         $theKey = htmlentities(base64_decode($_GET['key']));
  866. 		$theserver = $MEMCACHE_SERVERS[(int)$_GET['server']];
  867. 		list($h,$p) = explode(':',$theserver);
  868.         $r = sendMemcacheCommand($h,$p,'delete '.$theKey);
  869.         echo 'Deleting '.$theKey.':'.$r;
  870. 	break;
  871.  
  872.    case 6: // flush server
  873.         $theserver = $MEMCACHE_SERVERS[(int)$_GET['server']];
  874.         $r = flushServer($theserver);
  875.         echo 'Flush  '.$theserver.":".$r;
  876.    break;
  877. }
  878. echo getFooter();
  879.  
  880. ?>

② 在memcache_tools.php文件中设置memcached服务器地址与相关信息：

  1. ADMIN_USERNAME root #22行，登录memcache_tool的默认用户名
  2. ADMIN_PASSWORD 123456 #23行，登录memcache_tool的默认密码
  3. $MEMCACHE_SERVERS[] ='Memcached服务器地址:11211' #配置memcached服务器地址和端口

登录后可查看memcached服务器的相关信息：

memcached中存储的键值对：

5、Memcached缓存失效机制：

(1) Lazy Expiration（惰性过期）

在Memcached中，惰性过期是一种节省CPU资源的策略。Memcached不会在后台主动检查每个键是否过期，而是当客户端尝试获取一个键时，Memcached会检查该键的过期时间戳，如果该键已经过期，那么它不会被返回给客户端，并从缓存中删除。

(2) Least Recently Used（LRU 替换策略）

LRU策略是一种常用的缓存替换策略，当Memcached的内存空间不足以存储新数据时，它根据数据项最后一次被访问的时间来做出决策。即最近最少使用的数据项将被删除，并将其空间分配给新的记录。

四、session入库

1、为什么需要session入库：

由于负载均衡需要对用户的请求进行分发操作，每个服务器有自己的Session文件存储，如果用户的请求被分发到了之前没有处理过该用户的服务器，那么该服务器就无法找到对应的Session数据，从而导致Session失效。

解决方案：

① 使用负载均衡算法：如Nginx的ip_hash算法，确保来自同一用户的请求总是被分发到同一台服务器上。

② 把Session入库：将所有服务器的Session数据集中存储在一个共享的位置，例如数据库或分布式缓存系统。这样，无论用户的请求被分发到哪个服务器，都可以从共享的位置获取到Session数据。

2、DSShop商城系统中的Session入库：

(1) 修改lB负载均衡器配置文件：

先注释掉在第五节配置过的ip_hash，使负载均衡算法为轮询。

(2) 需要配置session入库的文件：

在需要进行登录操作的界面配置session入库。

home文件夹：用户的前端界面，用户登录；

admin文件夹：管理员的后端界面，管理员登录。

(3) 修改文件：

① 前台：修改/home/下的config.php

vim /home/www/application/home/config.php

添加驱动方式和memcached服务器地址：

查看前端界面的session缓存：

前端界面登录信息的session缓存：

② 后台：修改/admin/下的config.php

vim /home/www/application/admin/config.php

修改方式与前台类似：

● 后台除了修改/admin/config.php文件之外，还需要修改总的配置文件，才能使session共享。

vim /home/www/application/config.php

登录后台：

后台登录信息的session缓存：

五、memcached单机多实例：

在一台机器上运行多个memcached实例，每个memcached设置单独的端口号。

/usr/local/memcached/bin /memcached -uroot -d -p 11211

/usr/local/memcached/bin /memcached -uroot -d -p 11212

/usr/local/memcached/bin /memcached -uroot -d -p 11213

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/399351
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号