Detaillierte Erklärung der Mencached-Cache-Konfiguration basierend auf Nginx

[root@mid ~]# yum installiere memcached -y
#Starten Sie den Dienst[root@mid ~]# systemctl start memcached.service

#Überprüfen Sie den Startstatus, klicken Sie auf Enter und wenn ERROR erscheint, war der Start erfolgreich [root@master ~]# telnet 192.168.29.133 11211
Versuche 192.168.29.133 …
Verbunden mit 192.168.29.133.
Das Escape-Zeichen ist „^]“.

FEHLER

#Entpacken und installieren Sie libmemcached
[root@master ~]#tar -xvf libmemcached-1.0.18.tar.gz
[root@master ~]#cd libmemcached-1.0.18
#Wenn die Kompilierung einen Fehler meldet, ändern Sie den falschen Wert an der entsprechenden Position des Fehlers in clients/memflush.cc in NULL
[root@master ~]#./configure --prefix=/usr/local/libmemcached
machen && machen installieren

#Memcached entpacken und installieren
[root@master ~]#tar -zxvf memcached-3.1.5.tgz
[root@master ~]#cd memcached-3.1.5
[root@master ~]#phpize
[root@master ~]#./configure --with-libmemcached-dir=/usr/local/libmemcached --disable-memcached-sasl
[root@master ~]#make && make install

#Überprüfen Sie nach Abschluss, ob im PHP-Verzeichnis in lib/php/extensions/no-debug-zts-20170718/ eine Erweiterung memcached.so vorhanden ist

#Erweiterung zur PHP-Konfigurationsdatei hinzufügen [root@master ~]# vi /usr/local/php/etc/php.ini
Erweiterung=memcached.so

[root@master ~]# vi /usr/local/nginx/html/test.php 
<?php
phpinfo();
?>

[root@master ~]# cat /usr/local/nginx/conf/nginx.conf
Arbeiterprozesse 1;
Ereignisse {
  Arbeiterverbindungen 1024;
}
http {
  mime.types einschließen;
  Standardtyp Anwendung/Oktett-Stream;
  sendfile an;
  KeepAlive-Timeout 65;
  Server {
    hören Sie 80;
    Servername localhost;
    Standort / {
      Stamm-HTML;
      Index Index.html Index.htm;
    }
  #memcached Cache-Konfiguration, lesen ob Cache vorhanden ist, 404-Fehler melden, wenn kein Cache-Speicherort vorhanden ist /demo/ {
    setze $memcached_key $request_uri;
    add_header X-Speicherschlüssel $memcached_key;
    memcached_pass 192.168.29.133:11211;
    Standardtyp Text/HTML;
    #Gehen Sie zu einem bestimmten Ort, nachdem ein Fehler gemeldet wurde
    Fehlerseite 404 502 504 = @mymemcached;
  }
  #Konfigurieren Sie die Umschreibstrategie, um einen bestimmten PHP-Dateispeicherort auszuführen @mymemcached {
    neu schreiben .* /demo.php?key=$request_uri;
  }
    Standort ~ \.php$ {
      Stamm-HTML;
      fastcgi_pass 127.0.0.1:9000;
      fastcgi_index index.php;
      fastcgi_param SCRIPT_FILENAME $Dokumentstammsatz$fastcgi_script_name;
      fastcgi_params einschließen;
    }
  }
}

#Demo-Ordner erstellen [root@master ~] mkdir /usr/local/nginx/html/demo
#Erstellen Sie eine Testdatei [root@master ~] echo "123" >> /usr/local/nginx/html/demo/123.html

[root@master ~]# vi /usr/local/nginx/html/demo.php 
<?php
  $fn=dirname(__FILE__) . $_SERVER['REQUEST_URI'];
  wenn(file_exists($fn)){
    $data=file_get_contents($fn);
    $m=neuer Memcached();
    $server=array(
      Array('192.168.29.133',11211)
    );
    $m->addServers($server);
    $r=$m->set($_GET['Schlüssel'],$Daten);
    Header('Inhaltslänge:'.filesize($fn)."\r\n");
    Header('Inhaltstyp:Datei'."\r\n");
    Header('X-Cache:MISS:'."\r\n");
    echo $daten;
  }
  #Wenn der Demo-Ordner nicht existiert, kehren Sie zur Startseite zurück, sonst{
    Header('Standort:../index.html'."\r\n");
  }
?>

#Es ist ersichtlich, dass beim ersten Mal kein Cache im Memcache vorhanden ist und der Cache beim zweiten Mal getroffen wird [root@bak ~]# curl -I http://192.168.29.132/demo/123.html
HTTP/1.1 200 OK
Server: nginx/1.16.1
Datum: Do, 25. Juni 2020 02:23:00 GMT
Inhaltstyp: Datei
Inhaltslänge: 4
Verbindung: Keep-Alive
X-Powered-By: PHP/7.2.26
X-Cache: VERPASST:

[root@bak ~]# curl -I http://192.168.29.132/demo/123.html
HTTP/1.1 200 OK
Server: nginx/1.16.1
Datum: Do, 25. Juni 2020 02:23:01 GMT
Inhaltstyp: text/html
Inhaltslänge: 4
Verbindung: Keep-Alive
X-Speicherschlüssel: /demo/123.html
Akzeptierte Bereiche: Bytes

#Nach dem Einrichten des Cache kann beim Zugriff auf denselben Cache-Schlüssel der Cache getroffen werden, auch wenn die den Zugriff initiierenden Maschinen unterschiedlich sind [root@master ~]# curl -I http://192.168.29.138/demo/123.html
HTTP/1.1 200 OK
Server: nginx/1.16.1
Datum: Do, 25. Juni 2020 02:29:46 GMT
Inhaltstyp: text/html
Inhaltslänge: 4
Verbindung: Keep-Alive
X-Speicherschlüssel: /demo/123.html
Akzeptierte Bereiche: Bytes

<?php
/*
 +----------------------------------------------------------------------+
 | PHP Version 5 |
 +----------------------------------------------------------------------+
 | Copyright (c) 1997-2004 Die PHP-Gruppe |
 +----------------------------------------------------------------------+
 | Diese Quelldatei unterliegt der Version 3.0 der PHP-Lizenz, |
 | das mit diesem Paket in der Datei LICENSE gebündelt ist, und ist |
 | verfügbar über das World Wide Web unter der folgenden URL: |
 | http://www.php.net/license/3_0.txt. |
 | Wenn Sie keine Kopie der PHP-Lizenz erhalten haben und nicht in der Lage sind, |
 | Wenn Sie es über das Internet beziehen möchten, senden Sie bitte eine Nachricht an |
 | [email protected], damit wir Ihnen sofort eine Kopie zusenden können. |
 +----------------------------------------------------------------------+
 | Autor: Harun Yayli <harunyayli at gmail.com> |
 +----------------------------------------------------------------------+
*/
//im Memcaching gespeichertes grafisches Gadget $VERSION='$Id: memcache.php,v 1.1.2.3 2008/08/28 18:07:54 mikl Exp $';
#Benutzernamen festlegen define('ADMIN_USERNAME','admin'); 
#Passwort festlegen define('ADMIN_PASSWORD','123456'); 

definieren('DATE_FORMAT','J/m/t H:i:s');
definieren('GRAPH_SIZE',200);
definieren('MAX_ITEM_DUMP',50);

#Memcached-Hostinformationen festlegen $MEMCACHE_SERVERS[] = '192.168.29.133:11211'; 

////////// ENDE DES STANDARDKONFIGURATIONSBEREICHS ////////////////////////////////////////////////////////////

/////////////////// Passwortschutz ////////////////////////////////////////////////////////////
wenn (!isset($_SERVER['PHP_AUTH_USER']) || !isset($_SERVER['PHP_AUTH_PW']) ||
      $_SERVER['PHP_AUTH_USER'] != ADMIN_USERNAME || $_SERVER['PHP_AUTH_PW'] != ADMIN_PASSWORT) {
      Header("WWW-Authentifizierung: Basic realm=\"Memcache Login\"");
      Header("HTTP/1.0 401 Nicht autorisiert");

      Echo <<<EOB
        <html><Text>
        <h1>Abgelehnt!</h1>
        <big>Falscher Benutzername oder Passwort!</big>
        </body></html>
Ende der OB;
      Ausfahrt;
}

///////////MEMCACHE-FUNKTIONEN /////////////////////////////////////////////////////////////////////

Funktion sendMemcacheCommands($command){
  global $MEMCACHE_SERVERS;
  $Ergebnis = Array();

  foreach($MEMCACHE_SERVERS als $server){
    $strs = explodieren(':',$server);
    $host = $strs[0];
    $port = $strs[1];
    $Ergebnis[$Server] = sendMemcacheCommand($Host,$Port,$Befehl);
  }
  gibt $Ergebnis zurück;
}
Funktion sendMemcacheCommand($server,$port,$befehl){

  $s = @fsockopen($server,$port);
  wenn (!$s){
    die("Keine Verbindung möglich zu:".$server.':'.$port);
  }

  fwrite($s, $befehl."\r\n");

  $buf='';
  während ((!feof($s))) {
    $buf .= fgets($s, 256);
    if (strpos($buf,"END\r\n")!==false){ // stat sagt Ende
      brechen;
    }
    if (strpos($buf,"DELETED\r\n")!==false || strpos($buf,"NOT_FOUND\r\n")!==false){ // delete sagt diese
      brechen;
    }
    if (strpos($buf,"OK\r\n")!==false){ // flush_all sagt ok
      brechen;
    }
  }
  fclose($s);
  gibt parseMemcacheResults($buf) zurück;
}
Funktion parseMemcacheResults($str){

  $res = Array();
  $zeilen = explodieren("\r\n",$str);
  $cnt = Anzahl($Zeilen);
  für($i=0; $i< $cnt; $i++){
    $zeile = $zeilen[$i];
    $l = explodieren(' ',$Zeile,3);
    wenn (Anzahl($l)==3){
      $res[$l[0]][$l[1]]=$l[2];
      if ($l[0]=='VALUE'){ // die nächste Zeile ist der Wert
        $res[$l[0]][$l[1]] = Array();
        Liste ($flag,$size)=explodieren(' ',$l[2]);
        $res[$l[0]][$l[1]]['stat']=array('flag'=>$flag,'größe'=>$größe);
        $res[$l[0]][$l[1]]['Wert']=$Zeilen[++$i];
      }
    }elseif($line=='GELÖSCHT' || $line=='NICHT_GEFUNDEN' || $line=='OK'){
      gib $line zurück;
    }
  }
  $res zurückgeben;

}

Funktion dumpCacheSlab($server,$slabId,$limit){
  Liste($Host,$Port) = explodieren(':',$Server);
  $resp = sendMemcacheCommand($host,$port,'stats cachedump '.$slabId.' '.$limit);

  gibt $resp zurück;

}

Funktion FlushServer($server){
  Liste($Host,$Port) = explodieren(':',$Server);
  $resp = sendMemcacheCommand($host,$port,'flush_all');
  gibt $resp zurück;
}
Funktion getCacheItems(){
 $items = sendMemcacheCommands('Statistikelemente');
 $serverItems = array();
 $totalItems = Array();
 foreach ($items als $server=>$itemlist){
  $serverItems[$server] = array();
  $totalItems[$server]=0;
  wenn (!isset($itemlist['STAT'])){
    weitermachen;
  }

  $iteminfo = $itemlist['STAT'];

  foreach($iteminfo als $keyinfo=>$value){
    wenn (preg_match('/items\:(\d+?)\:(.+?)$/',$keyinfo,$matches)){
      $serverItems[$server][$matches[1]][$matches[2]] = $Wert;
      wenn ($matches[2]=='Zahl'){
        $totalItems[$server] +=$wert;
      }
    }
  }
 }
 Array zurückgeben('Elemente'=>$ServerItems,'Anzahl'=>$TotalItems);
}
Funktion getMemcacheStats($total=true){
  $resp = sendMemcacheCommands('Statistiken');
  wenn ($gesamt){
    $res = Array();
    foreach($resp als $server=>$r){
      foreach($r['STAT'] als $key=>$row){
        wenn (!isset($res[$key])){
          $res[$key]=null;
        }
        Schalter ($key){
          Fall 'pid':
            $res['pid'][$server]=$row;
            brechen;
          Fall „Betriebszeit“:
            $res['uptime'][$server]=$row;
            brechen;
          Fall 'Zeit':
            $res['Zeit'][$server]=$row;
            brechen;
          Fall 'Version':
            $res['version'][$server]=$row;
            brechen;
          Fall 'Zeigergröße':
            $res['Zeigergröße'][$server]=$row;
            brechen;
          Fall 'rusage_user':
            $res['rusage_user'][$server]=$row;
            brechen;
          Fall 'rusage_system':
            $res['rusage_system'][$server]=$row;
            brechen;
          Fall „aktuelle_Artikel“:
            $res['aktuelle_items']+=$row;
            brechen;
          Fall 'total_items':
            $res['total_items']+=$row;
            brechen;
          Fall 'Bytes':
            $res['bytes']+=$row;
            brechen;
          Fall „aktuelle_Verbindungen“:
            $res['aktuelle_Verbindungen']+=$row;
            brechen;
          Fall „total_connections“:
            $res['total_connections']+=$row;
            brechen;
          Fall 'Verbindungsstrukturen':
            $res['Verbindungsstrukturen']+=$row;
            brechen;
          Fall 'cmd_get':
            $res['cmd_get']+=$row;
            brechen;
          Fall 'cmd_set':
            $res['cmd_set']+=$row;
            brechen;
          Fall 'get_hits':
            $res['get_hits']+=$row;
            brechen;
          Fall 'get_misses':
            $res['get_misses']+=$row;
            brechen;
          Fall ‚Räumungen‘:
            $res['Räumungen']+=$row;
            brechen;
          Fall 'bytes_read':
            $res['bytes_read']+=$row;
            brechen;
          Fall „bytes_written“:
            $res['geschriebene_bytes']+=$row;
            brechen;
          Fall „limit_maxbytes“:
            $res['limit_maxbytes']+=$row;
            brechen;
          Fall 'Threads':
            $res['rusage_system'][$server]=$row;
            brechen;
        }
      }
    }
    $res zurückgeben;
  }
  gibt $resp zurück;
}

//////////////////////////////////////////////////////

//
// diese Seite nicht zwischenspeichern
//
Header("Cache-Control: kein Speichern, kein Cache, muss erneut validiert werden"); // HTTP/1.1
Header("Cache-Steuerung: Nachprüfung=0, Vorprüfung=0", false);
Header("Pragma: kein Cache"); // HTTP/1.0

Funktion Dauer($ts) {
  globale $zeit;
  $Jahre = (int)((($Zeit - $ts)/(7*86400))/52.177457);
  $rem = (int)(($Zeit - $ts) - ($Jahre * 52,177457 * 7 * 86400));
  $Wochen = (int)(($rem)/(7*86400));
  $Tage = (int)(($rem)/86400) - $Wochen*7;
  $Stunden = (int)(($rem)/3600) - $Tage*24 - $Wochen*7*24;
  $mins = (int)(($rem)/60) - $Stunden*60 - $Tage*24*60 - $Wochen*7*24*60;
  $str = '';
  wenn ($years==1) $str .= "$years Jahr, ";
  wenn ($Jahre>1) $str .= "$Jahre Jahre, ";
  if($weeks==1) $str .= "$weeks Woche, ";
  if($weeks>1) $str .= "$weeks Wochen, ";
  wenn ($days == 1) $str . = "$days Tag,";
  wenn($days>1) $str .= "$days Tage,";
  if($hours == 1) $str .= " $hours Stunde und";
  if($hours>1) $str .= " $hours Stunden und";
  if($mins == 1) $str .= " 1 Minute";
  sonst $str .= " $mins Minuten";
  gibt $str zurück;
}

// Grafiken erstellen
//
Funktion graphics_avail() {
  gibt extension_loaded('gd') zurück;
}

Funktion bsize($s) {
  für jeden (Array('','K','M','G') als $i => $k) {
    wenn ($s < 1024) abbrechen;
    $s/=1024;
  }
  sprintf("%5.1f %sBytes",$s,$k);
}

// Menüeintrag erstellen
Funktion Menüeintrag($ob,$title) {
  global $PHP_SELF;
  wenn ($ob == $_GET['op']){
    gibt "<li><a class=\"child_active\" href=\"$PHP_SELF&op=$ob\">$title</a></li> zurück";
  }
  gibt "<li><a class=\"active\" href=\"$PHP_SELF&op=$ob\">$title</a></li> zurück";
}

Funktion getHeader(){
  $header = <<<EOB
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head><title>MEMCACHE-INFO</title>
<style type="text/css"><!--
body { Hintergrund: weiß; Schriftgröße: 100,01 %; Rand: 0; Polsterung: 0; }
body,p,td,th,Eingabe,Senden { Schriftgröße:0.8em;Schriftfamilie:Arial,Helvetica,Sans-Serif; }
* HTML-Text {font-size:0.8em}
* html p {Schriftgröße:0,8em}
* html td {Schriftgröße:0,8em}
* html th {Schriftgröße:0,8em}
* HTML-Eingabe {font-size:0.8em}
* html senden {font-size:0.8em}
td { vertikale Ausrichtung: oben }
a { Farbe: schwarz; Schriftstärke: keine; Textdekoration: keine; }
a:hover { text-decoration:unterstreichen; }
div.content { padding:1em 1em 1em 1em; position:absolut; Breite:97%; z-index:100; }

h1.memcache { Hintergrund:rgb(153,153,204); Rand:0; Polsterung:0,5em 1em 0,5em 1em; }
* html h1.memcache { margin-bottom:-7px; }
h1.memcache a:hover { text-decoration:none; color:rgb(90,90,90); }
h1.memcache span.logo {
  Hintergrund: RGB (119,123,180);
  Farbe: Schwarz;
  Rahmen rechts: durchgehend schwarz 1px;
  Rahmen unten: durchgehend schwarz 1px;
  Schriftstil: kursiv;
  Schriftgröße: 1em;
  Polsterung links: 1,2em;
  Polsterung rechts: 1,2em;
  Textausrichtung: rechts;
  Anzeige:Block;
  Breite: 130px;
  }
h1.memcache span.logo span.name { Farbe: weiß; Schriftgröße: 0,7em; Polsterung: 0 0,8em 0 2em; }
h1.memcache span.nameinfo { Farbe: weiß; Anzeige: inline; Schriftgröße: 0,4em; linker Rand: 3em; }
h1.memcache div.copy { Farbe: schwarz; Schriftgröße: 0,4em; Position: absolut; rechts: 1em; }
hr.memcache {
  Hintergrund: weiß;
  Rahmen unten: durchgezogenes RGB (102,102,153) 1px;
  Rahmenstil: keiner;
  Rahmen oben: durchgezogenes RGB (102,102,153) 10px;
  Höhe: 12px;
  Rand: 0;
  Rand oben: 1px;
  Polsterung: 0;
}

ol, Menü { Rand: 1em 0 0 0; Polsterung: 0,2em; Rand links: 1em;}
ol.menu li { Anzeige: inline; Rand rechts: 0,7em; Listenstil: keine; Schriftgröße: 85 %}
ol.menu ein {
  Hintergrund: RGB (153,153,204);
  Rand: durchgezogener RGB (102,102,153) 2px;
  Farbe: weiß;
  Schriftstärke: fett;
  Rand rechts: 0em;
  Polsterung: 0,1em 0,5em 0,1em 0,5em;
  Textdekoration: keine;
  Rand links: 5px;
  }
ol.menu a.child_active {
  Hintergrund: RGB (153,153,204);
  Rand: durchgezogener RGB (102,102,153) 2px;
  Farbe: weiß;
  Schriftstärke: fett;
  Rand rechts: 0em;
  Polsterung: 0,1em 0,5em 0,1em 0,5em;
  Textdekoration: keine;
  Rahmen links: durchgehend schwarz 5px;
  Rand links: 0px;
  }
ol.menu span.active {
  Hintergrund: RGB (153,153,204);
  Rand: durchgezogener RGB (102,102,153) 2px;
  Farbe: Schwarz;
  Schriftstärke: fett;
  Rand rechts: 0em;
  Polsterung: 0,1em 0,5em 0,1em 0,5em;
  Textdekoration: keine;
  Rahmen links: durchgehend schwarz 5px;
  }
ol.menu span.inactive {
  Hintergrund: RGB (193,193,244);
  Rand: durchgezogener RGB (182,182,233) 2px;
  Farbe: weiß;
  Schriftstärke: fett;
  Rand rechts: 0em;
  Polsterung: 0,1em 0,5em 0,1em 0,5em;
  Textdekoration: keine;
  Rand links: 5px;
  }
ol.menu a:hover {
  Hintergrund: RGB (193,193,244);
  Textdekoration: keine;
  }

div.info {
  Hintergrund: RGB (204,204,204);
  Rand: durchgezogener RGB (204,204,204) 1px;
  Rand unten: 1em;
  }
div.info h2 {
  Hintergrund: RGB (204,204,204);
  Farbe: Schwarz;
  Schriftgröße: 1em;
  Rand: 0;
  Polsterung: 0,1em 1em 0,1em 1em;
  }
div.info Tabelle {
  Rand: durchgezogener RGB (204,204,204) 1px;
  Rahmenabstand: 0;
  Breite: 100 %;
  }
div.info Tabelle th {
  Hintergrund: RGB (204,204,204);
  Farbe: weiß;
  Rand: 0;
  Polsterung: 0,1em 1em 0,1em 1em;
  }
div.info Tabelle th a.sortierbar { Farbe: schwarz; }
div.info Tabelle tr.tr-0 { Hintergrund:rgb(238,238,238); }
div.info Tabelle tr.tr-1 { Hintergrund:rgb(221,221,221); }
div.info Tabelle td { padding:0,3em 1em 0,3em 1em; }
div.info-Tabelle td.td-0 { border-right:solid rgb(102,102,153) 1px; white-space:nowrap; }
div.info-Tabelle td.td-n { border-right:solid rgb(102,102,153) 1px; }
div.info Tabelle td h3 {
  Farbe: Schwarz;
  Schriftgröße: 1,1em;
  Rand links: -0,3em;
  }
.td-0 a , .td-n a, .tr-0 a , tr-1 a {
  Textdekoration: Unterstreichen;
}
div.graph { margin-bottom:1em }
div.graph h2 { Hintergrund: rgb(204,204,204);; Farbe: schwarz; Schriftgröße: 1em; Rand: 0; Polsterung: 0,1em 1em 0,1em 1em; }
div.graph-Tabelle { Rahmen: durchgezogen rgb(204,204,204) 1px; Farbe: schwarz; Schriftstärke: normal; Breite: 100 %; }
div.graph-Tabelle td.td-0 { Hintergrund:rgb(238,238,238); }
div.graph Tabelle td.td-1 { Hintergrund:rgb(221,221,221); }
div.graph-Tabelle td { padding:0,2em 1em 0,4em 1em; }

div.div1,div.div2 { Rand unten:1em; Breite:35em; }
div.div3 { position:absolut; links:40em; oben:1em; Breite:580px; }
//div.div3 { position:absolut; links:37em; oben:1em; rechts:1em; }

div.sortierung { margin:1.5em 0em 1.5em 2em }
.center { Textausrichtung:center }
.aright { position:absolut;right:1em }
.rechts { text-align:rechts }
.ok { Farbe:rgb(0,200,0); Schriftstärke:fett}
.fehlgeschlagen { Farbe: rgb(200,0,0); Schriftstärke: fett}

span.box {
  Rand: schwarz, durchgezogen 1px;
  Rahmen rechts: durchgehend schwarz 2px;
  Rahmen unten: durchgehend schwarz 2px;
  Polsterung: 0 0,5em 0 0,5em;
  Rand rechts: 1em;
}
span.green { Hintergrund: #60F060; Polsterung: 0 0,5em 0 0,5em}
span.red { Hintergrund:#D06030; Polsterung:0 0,5em 0 0,5em }

div.autneeded {
  Hintergrund: RGB (238,238,238);
  Rand: durchgezogener RGB (204,204,204) 1px;
  Farbe: RGB (200,0,0);
  Schriftgröße: 1,2em;
  Schriftstärke: fett;
  Polsterung: 2em;
  Textausrichtung: zentriert;
  }

Eingabe {
  Hintergrund: RGB (153,153,204);
  Rand: durchgezogener RGB (102,102,153) 2px;
  Farbe: weiß;
  Schriftstärke: fett;
  Rand rechts: 1em;
  Polsterung: 0,1em 0,5em 0,1em 0,5em;
  }
//-->
</Stil>
</Kopf>
<Text>
<div Klasse="Kopf">
  <h1 Klasse="memcache">
    <span class="logo"><a href="http://pecl.php.net/package/memcache" rel="external nofollow" >Memcache</a></span>
    memcache.php von Harun Yayli
  </h1>
  <hr Klasse="memcache">
</div>
<div Klasse=Inhalt>
Ende der OB;

  gibt $header zurück;
}
Funktion getFooter(){
  global $VERSION;
  $footer = '</div><!-- Basierend auf apc.php '.$VERSION.'--></body>
</html>
';

  $footer zurückgeben;

}
Funktion getMenu(){
  global $PHP_SELF;
echo "<ol Klasse=Menü>";
wenn ($_GET['op']!=4){
Echo <<<EOB
  <li><a href="$PHP_SELF&op={$_GET['op']}" rel="external nofollow" >Daten aktualisieren</a></li>
Ende der OB;
}
anders {
Echo <<<EOB
  <li><a href="$PHP_SELF&op=2}" rel="external nofollow" >Zurück</a></li>
Ende der OB;
}
Echo
  menu_entry(1,'Host-Statistiken anzeigen'),
  menu_entry(2,'Variablen');

Echo <<<EOB
  </ol>
  <br/>
Ende der OB;
}

// ZU TUN, AUTH

$_GET['op'] = !isset($_GET['op'])? '1':$_GET['op'];
$PHP_SELF = isset($_SERVER['PHP_SELF']) ? htmlentities(strip_tags($_SERVER['PHP_SELF'],'')) : '';

$PHP_SELF=$PHP_SELF.'?';
$zeit = Zeit();
// _GET bereinigen

foreach($_GET als $key=>$g){
  $_GET[$key]=htmlentities($g);
}

// einzeln ausgeben
// Wenn „Singleout“ gesetzt ist, werden nur Details für diesen Server bereitgestellt.
wenn (isset($_GET['singleout']) && $_GET['singleout']>=0 && $_GET['singleout'] <Anzahl($MEMCACHE_SERVERS)){
  $MEMCACHE_SERVERS = Array($MEMCACHE_SERVERS[$_GET['singleout']]);
}

// Bilder anzeigen
wenn (isset($_GET['IMG'])){
  $memcacheStats = getMemcacheStats();
  $memcacheStatsSingle = getMemcacheStats(false);

  wenn (!graphics_avail()) {
    Ausfahrt (0);
  }

  Funktion Füllfeld($im, $x, $y, $w, $h, $Farbe1, $Farbe2, $Text='', $Ortsindex='') {
    global $col_black;
    $x1=$x+$w-1;
    $y1=$y+$h-1;

    Bildrechteck($im, $x, $y1, $x1+1, $y+1, $col_black);
    wenn($y1>$y) bildgefülltes Rechteck($im, $x, $y, $x1, $y1, $color2);
    sonst imagefilledrectangle($im, $x, $y1, $x1, $y, $color2);
    Bildrechteck($im, $x, $y1, $x1, $y, $color1);
    wenn ($text) {
      wenn ($placeindex>0) {

        wenn ($placeindex<16)
        {
          $px=5;
          $py=$Ortsindex*12+6;
          Bildgefülltes Rechteck($im, $px+90, $py+3, $px+90-4, $py-3, $color2);
          Bildzeile($im,$x,$y+$h/2,$px+90,$py,$color2);
          Bildzeichenfolge($im,2,$px,$py-6,$text,$farbe1);

        } anders {
          wenn ($placeindex<31) {
            $px=$x+40*2;
            $py=($placeindex-15)*12+6;
          } anders {
            $px=$x+40*2+100*intval(($placeindex-15)/15);
            $py=($placeindex%15)*12+6;
          }
          Bildgefülltes Rechteck($im, $px, $py+3, $px-4, $py-3, $color2);
          Bildzeile($im,$x+$w,$y+$h/2,$px,$py,$color2);
          Bildzeichenfolge($im,2,$px+2,$py-6,$text,$farbe1);
        }
      } anders {
        Bildzeichenfolge($im,4,$x+5,$y1-16,$text,$farbe1);
      }
    }
  }

  Funktion Füllbogen($im, $centerX, $centerY, $diameter, $start, $end, $color1, $color2, $text='', $placeindex=0) {
    $r=$Durchmesser/2;
    $w=deg2rad((360+$start+($end-$start)/2)%360);

    wenn (Funktion existiert("imagefilledarc")) {
      // existiert nur, wenn GD 2.0.1 verfügbar ist
      Bildgefüllter Bogen ($im, $centerX+1, $centerY+1, $diameter, $diameter, $start, $end, $color1, IMG_ARC_PIE);
      Bildgefüllter Bogen ($im, $centerX, $centerY, $diameter, $diameter, $start, $end, $color2, IMG_ARC_PIE);
      Bildgefüllter Bogen ($im, $centerX, $centerY, $diameter, $diameter, $start, $end, $color1, IMG_ARC_NOFILL|IMG_ARC_EDGED);
    } anders {
      Bildbogen($im, $centerX, $centerY, $diameter, $diameter, $start, $end, $color2);
      Bildlinie($im, $centerX, $centerY, $centerX + cos(deg2rad($start)) * $r, $centerY + sin(deg2rad($start)) * $r, $color2);
      Bildlinie($im, $centerX, $centerY, $centerX + cos(deg2rad($start+1)) * $r, $centerY + sin(deg2rad($start)) * $r, $color2);
      Bildlinie($im, $centerX, $centerY, $centerX + cos(deg2rad($end-1)) * $r, $centerY + sin(deg2rad($end)) * $r, $color2);
      Bildlinie($im, $centerX, $centerY, $centerX + cos(deg2rad($end)) * $r, $centerY + sin(deg2rad($end)) * $r, $color2);
      Bildfüllung($im,$centerX + $r*cos($w)/2, $centerY + $r*sin($w)/2, $color2);
    }
    wenn ($text) {
      wenn ($placeindex>0) {
        Bildlinie($im, $centerX + $r*cos($w)/2, $centerY + $r*sin($w)/2, $diameter, $placeindex*12, $color1);
        Bildzeichenfolge($im,4,$Durchmesser, $Ortsindex*12,$Text,$Farbe1);

      } anders {
        Bildzeichenfolge($im,4,$centerX + $r*cos($w)/2, $centerY + $r*sin($w)/2,$text,$color1);
      }
    }
  }
  $size = GRAPH_SIZE; // Bildgröße
  $image = Bild erstellen($Größe+50, $Größe+10);

  $col_white = Bildfarbeallocate($image, 0xFF, 0xFF, 0xFF);
  $col_red = Bildfarbeallocate($image, 0xD0, 0x60, 0x30);
  $col_green = Bildfarbeallocate($image, 0x60, 0xF0, 0x60);
  $col_black = Bildfarbeallocate($image, 0, 0, 0);

  Bildfarbetransparent($Bild,$Col_White);

  Schalter ($_GET['IMG']){
    Fall 1: // Kreisdiagramm
      $tsize=$memcacheStats['limit_maxbytes'];
      $avail=$tsize-$memcacheStats['bytes'];
      $x=$y=$Größe/2;
      $Winkel_von = 0;
      $fuzz = 0,000001;

      foreach($memcacheStatsSingle als $serv=>$mcs) {
        $frei = $mcs['STAT']['limit_maxbytes']-$mcs['STAT']['bytes'];
        $verwendet = $mcs['STAT']['Bytes'];

        wenn ($free>0){
        // frei zeichnen
          $Winkel_zu = ($Frei*360)/$TGröße;
          $perc = sprintf("%.2f%%", ($frei *100) / $tsize);

          Füllbogen($Bild,$x,$y,$Größe,$Winkel_von,$Winkel_von + $Winkel_bis,$Spalte_schwarz,$Spalte_grün,$Perc);
          $Winkel_von = $Winkel_von + $Winkel_bis;
        }
        wenn ($used>0){
        // Zeichnen verwendet
          $angle_to = ($verwendet*360)/$tsize;
          $perc =sprintf("%.2f%%", ($verwendet *100) / $tsize);
          Füllbogen($Bild,$x,$y,$Größe,$Winkel_von,$Winkel_von + $Winkel_bis ,$Spalte_schwarz,$Spalte_rot, '('.$perc.')' );
          $Winkel_von = $Winkel_von + $Winkel_bis;
        }
        }

    brechen;

    Fall 2: // Treffer Fehlschlag

      : $memcacheStats['get_hits']==0) ? 1:$memcacheStats['get_hits'];
      $misses = ($memcacheStats['get_misses']==0) ? 1:$memcacheStats['get_misses'];
      $gesamt = $Treffer + $Fehlschläge;

      Füllfeld ($Bild, 30, $Größe, 50, -$Treffer*($Größe-21)/$Gesamt, $Spalte_schwarz, $Spalte_grün, Sprintf ("%.1f%%", $Treffer*100/$Gesamt));
      Füllfeld ($Bild, 130, $Größe, 50, -max (4, ($Gesamt-$Treffer) * ($Größe-21) / $Gesamt), $Col_Black, $Col_Red, Sprintf ("%.1f%%", $Fehlschläge * 100 / $Gesamt));
    brechen;

  }
  Header("Inhaltstyp: image/png");
  Bildpng($Bild);
  Ausfahrt;
}

echo getHeader();
echo getMenu();

Schalter ($_GET['op']) {

  Fall 1: // Host-Statistiken
    $phpversion = phpversion();
    $memcacheStats = getMemcacheStats();
    $memcacheStatsSingle = getMemcacheStats(false);

    Speichert die maximale Anzahl an Bytes, die in der Cachedatei gespeichert sind.
    $mem_used = $memcacheStats['bytes'];
    $mem_avail= $mem_size-$mem_used;
    $startTime = Zeit()-Array_Summe($memcacheStats['Uptime']);

    $curr_items = $memcacheStats['curr_items'];
    $total_items = $memcacheStats['total_items'];
    : $memcacheStats['get_hits']==0) ? 1:$memcacheStats['get_hits'];
    $misses = ($memcacheStats['get_misses']==0) ? 1:$memcacheStats['get_misses'];
    $sets = $memcacheStats['cmd_set'];

    $req_rate = sprintf("%.2f",($hits+$misses)/($time-$startTime));
    $Trefferrate = sprintf("%.2f",($Treffer)/($Zeit-$Startzeit));
    $miss_rate = sprintf("%.2f",($misses)/($time-$startTime));
    $set_rate = sprintf("%.2f",($sets)/($time-$startTime));

    Echo <<< EOB
    <div class="info div1"><h2>Allgemeine Cache-Informationen</h2>
    <Tabellenzellenabstand=0><tbody>
    <tr class=tr-1><td class=td-0>PHP-Version</td><td>$phpversion</td></tr>
Ende der OB;
    echo "<tr class=tr-0><td class=td-0>Memcached-Host". ((Anzahl($MEMCACHE_SERVERS)>1) ? 's':'')."</td><td>";
    $i=0;
    wenn (!isset($_GET['singleout']) && Anzahl($MEMCACHE_SERVERS)>1){
      foreach($MEMCACHE_SERVERS als $server){
         echo ($i+1).'. <a href="'.$PHP_SELF.'&singleout='.$i++.'" rel="external nofollow" >'.$server.'</a><br/>';
      }
    }
    anders{
      echo '1.'.$MEMCACHE_SERVERS[0];
    }
    wenn (isset($_GET['singleout'])){
       echo '<a href="'.$PHP_SELF.'" rel="external nofollow" >(alle Server)</a><br/>';
    }
    echo "</td></tr>\n";
    echo "<tr class=tr-1><td class=td-0>Gesamt-Memcache-Cache</td><td>".bsize($memcacheStats['limit_maxbytes'])."</td></tr>\n";

  Echo <<<EOB
    </tbody></table>
    </div>

    <div class="info div1"><h2>Memcache-Serverinformationen</h2>
Ende der OB;
    foreach($MEMCACHE_SERVERS als $server){
      echo '<Tabellenzellenabstand=0><tbody>';
      echo '<tr class=tr-1><td class=td-1>'.$server.'</td><td><a href="'.$PHP_SELF.'&server='.array_search($server,$MEMCACHE_SERVERS).'&op=6" rel="external nofollow" >[<b>Diesen Server leeren</b>]</a></td></tr>';
      echo '<tr class=tr-0><td class=td-0>Startzeit</td><td>', Datum (DATUM_FORMAT, $memcacheStatsSingle[$server]['STAT']['Zeit']-$memcacheStatsSingle[$server]['STAT']['Betriebszeit']),'</td></tr>';
      echo '<tr class=tr-1><td class=td-0>Betriebszeit</td><td>',Dauer($memcacheStatsSingle[$server]['STAT']['Zeit']-$memcacheStatsSingle[$server]['STAT']['Betriebszeit']),'</td></tr>';
      echo '<tr class=tr-0><td class=td-0>Memcached-Serverversion</td><td>'.$memcacheStatsSingle[$server]['STAT']['version'].'</td></tr>';
      echo '<tr class=tr-1><td class=td-0>Verwendete Cachegröße</td><td>',bsize($memcacheStatsSingle[$server]['STAT']['bytes']),'</td></tr>';
      echo '<tr class=tr-0><td class=td-0>Gesamt-Cachegröße</td><td>',bsize($memcacheStatsSingle[$server]['STAT']['limit_maxbytes']),'</td></tr>';
      echo '</tbody></table>';
    }
  Echo <<<EOB

    </div>
    <div class="graph div3"><h2>Host-Statusdiagramme</h2>
    <Tabellenzellenabstand=0><tbody>
Ende der OB;

  $size='Breite='.(GRAPH_SIZE+50).' Höhe='.(GRAPH_SIZE+10);
  Echo <<<EOB
    <tr>
    <td class=td-0>Cache-Nutzung</td>
    <td class=td-1>Treffer und Fehlschüsse</td>
    </tr>
Ende der OB;

  Echo
    graphics_avail() ?
       ‚<tr>‘.
       "<td class=td-0><img alt=\"\" $size src=\"$PHP_SELF&IMG=1&".(isset($_GET['singleout'])? 'singleout='.$_GET['singleout'].'&':'').."$time\"></td>".
       "<td class=td-1><img alt=\"\" $size src=\"$PHP_SELF&IMG=2&".(isset($_GET['singleout'])? 'singleout='.$_GET['singleout'].'&':'')."$time\"></td></tr>\n"
      : "",
    '<tr>',
    '<td class=td-0><span class="green box">&nbsp;</span>Kostenlos: ',bsize($mem_avail).sprintf(" (%.1f%%)",$mem_avail*100/$mem_size),"</td>\n",
    '<td class=td-1><span class="green box">&nbsp;</span>Treffer: ',$hits.sprintf(" (%.1f%%)",$hits*100/($hits+$misses)),"</td>\n",
    '</tr>',
    '<tr>',
    '<td class=td-0><span class="red box">&nbsp;</span>Verwendet: ',bsize($mem_used ).sprintf(" (%.1f%%)",$mem_used *100/$mem_size),"</td>\n",
    '<td class=td-1><span class="red box">&nbsp;</span>Fehlschläge: ',$misses.sprintf(" (%.1f%%)",$misses*100/($hits+$misses)),"</td>\n";
    Echo <<< EOB
  </tr>
  </tbody></table>
<br/>
  <div class="info"><h2>Cache-Informationen</h2>
    <Tabellenzellenabstand=0><tbody>
    <tr class=tr-0><td class=td-0>Aktuelle Artikel (insgesamt)</td><td>$curr_items ($total_items)</td></tr>
    <tr class=tr-1><td class=td-0>Treffer</td><td>{$hits}</td></tr>
    <tr class=tr-0><td class=td-0>Fehlschläge</td><td>{$misses}</td></tr>
    <tr class=tr-1><td class=td-0>Anforderungsrate (Treffer, Fehlschläge)</td><td>$req_rate Cache-Anforderungen/Sekunde</td></tr>
    <tr class=tr-0><td class=td-0>Trefferquote</td><td>$hit_rate Cache-Anfragen/Sekunde</td></tr>
    <tr class=tr-1><td class=td-0>Fehlerrate</td><td>$miss_rate Cache-Anfragen/Sekunde</td></tr>
    <tr class=tr-0><td class=td-0>Rate festlegen</td><td>$set_rate Cache-Anfragen/Sekunde</td></tr>
    </tbody></table>
    </div>

Ende der OB;

  brechen;

  Fall 2: // Variablen

    $m=0;
    $cacheItems = getCacheItems();
    $items = $cacheItems['items'];
    $totals = $cacheItems['Anzahl'];
    $maxDump = MAX_ITEM_DUMP;
    foreach($items als $server => $entries) {

    Echo <<< EOB

      <div Klasse = "info"><Tabelle Zellenabstand = 0><tbody>
      <tr><th colspan="2">$server</th></tr>
      <tr><th>Platten-ID</th><th>Info</th></tr>
Ende der OB;

      foreach($einträge als $slabId => $slab) {
        $dumpUrl = $PHP_SELF.'&op=2&server='.(array_search($server,$MEMCACHE_SERVERS)).'&dumpslab='.$slabId;
        Echo
          "<tr Klasse=tr-$m>",
          "<td class=td-0><center>",'<a href="',$dumpUrl,'" rel="external nofollow" >',$slabId,'</a>',"</center></td>",
          "<td class=td-last><b>Anzahl der Elemente:</b> ",$slab['Nummer'],'<br/><b>Alter:</b>',Dauer($Zeit-$slab['Alter']),'<br/> <b>Ausgewiesen:</b>',((isset($slab['ausgewiesen']) && $slab['ausgewiesen']==1)? 'Ja':'Nein');
          wenn ((isset($_GET['dumpslab']) && $_GET['dumpslab']==$slabId) && (isset($_GET['server']) && $_GET['server']==array_search($server,$MEMCACHE_SERVERS))){
            echo "<br/><b>Artikel: Artikel</b><br/>";
            $items = dumpCacheSlab($server,$slabId,$slab['Nummer']);
            // vielleicht hat ja jemand Lust hier eine Seitennummerierung vorzunehmen :)
            $i=1;
            foreach($items['ITEM'] als $itemKey=>$itemInfo){
              } $itemInfo = trim($itemInfo,'[ ]');

              echo '<a href="',$PHP_SELF,'&op=4&server=',(array_search($server,$MEMCACHE_SERVERS)),'&key=',base64_encode($itemKey).'" rel="external nofollow" >',$itemKey,'</a>';
              wenn ($i++ % 10 == 0) {
                echo '<br/>';
              }
              sonstwenn ($i!=$slab['zahl']+1){
                Echo ',';
              }
            }
          }

          echo "</td></tr>";
        $m=1-$m;
      }
    Echo <<<EOB
      </tbody></table>
      </div><hr/>
Ende der OB;
}
    brechen;

  brechen;

  Fall 4: //Artikeldump
    wenn (!isset($_GET['Schlüssel']) || !isset($_GET['Server'])){
      echo "Kein Schlüssel festgelegt!";
      brechen;
    }
    // Ich tue nichts, um die Gültigkeit der Schlüsselzeichenfolge zu überprüfen.
    // wahrscheinlich kann ein Exploit geschrieben werden, um alle Dateien in key=base64_encode("\n\r delete all") zu löschen.
    // jemand muss das beheben.
    $theKey = htmlentities(base64_decode($_GET['key']));

    $derserver = $MEMCACHE_SERVERS[(int)$_GET['server']];
    Liste($h,$p) = explodieren(':',$derServer);
    $r = sendMemcacheCommand($h,$p,'get '.$theKey);
    Echo <<<EOB
    <div Klasse = "info"><Tabelle Zellenabstand = 0><tbody>
      <tr><th>Server<th>Schlüssel</th><th>Wert</th><th>Löschen</th></tr>
Ende der OB;
    echo "<tr><td class=td-0>",$derServer,"</td><td class=td-0>",$derSchlüssel,
       " <br/>Flagge:",$r['WERT'][$theKey]['stat']['Flagge'],
       " <br/>Größe:", bsize($r['WERT'][$theKey]['stat']['Größe']),
       "</td><td>",chunk_split($r['WERT'][$theKey]['Wert'],40),"</td>",
       '<td><a href="',$PHP_SELF,'&op=5&server=',(int)$_GET['server'],'&key=',base64_encode($theKey)," rel="external nofollow" \">Löschen</a></td>","</tr>";
    Echo <<<EOB
      </tbody></table>
      </div><hr/>
Ende der OB;
  brechen;
  Fall 5: // Artikel löschen
    wenn (!isset($_GET['Schlüssel']) || !isset($_GET['Server'])){
      echo "Kein Schlüssel festgelegt!";
      brechen;
    }
    $theKey = htmlentities(base64_decode($_GET['key']));
    $derserver = $MEMCACHE_SERVERS[(int)$_GET['server']];
    Liste($h,$p) = explodieren(':',$derServer);
    $r = sendMemcacheCommand($h,$p,'löschen '.$theKey);
    echo 'Lösche '.$theKey.':'.$r;
  brechen;

  Fall 6: // Server leeren
    $derserver = $MEMCACHE_SERVERS[(int)$_GET['server']];
    $r = flushServer($derserver);
    echo 'Flush '.$derserver.":".$r;
  brechen;
}
echo getFooter();

?>