PHPGangsta - Der praktische PHP Blog

Wer von euch kennt solchen Code:

if ($handle = opendir('/path/to/files')) {
    while (false !== ($file = readdir($handle))) {
        echo "$file\n";
    }
    closedir($handle);
}

So wird es häufig gemacht, aber hier wird natürlich nur ein Verzeichnis durchsucht und keine Unterordner betrachtet. Und häufig schleichen sich dort auch Fehler ein, beispielsweise wenn man im obigen Beispiel nur

while ($file = readdir($handle)) {

schreibt. Es gibt aber noch eine Menge anderer Möglichkeiten, die ich hier einmal vorstellen und vergleichen möchte. Danach stelle ich noch einige Testergebnisse vor, um die verschiedenen Möglichkeiten zu vergleichen sowie Vor- und Nachteile aufzuzeigen.

Hier erstmal das Script mit den einzelnen Funktionen:

$method = 'dirRead';

echo "mem before:".memory_get_peak_usage(true)."\n";
echo "Starting $method()\n";
clearstatcache();
$startTime = microtime(true);
$allFiles = DirectoryParser::$method('C:/Temp');
echo "Zeit: ".(microtime(true) - $startTime)." sec\n";
echo "mem after:".memory_get_peak_usage(true)."\n";
echo count($allFiles)."\n\n";

class DirectoryParser
{
	public static function createTestFolders($dir) {
		for($i=0; $i<10000; $i++) {
			@mkdir($dir.'/'.$i);
			for ($u=0; $u<10; $u++) {
				touch($dir.'/'.$i.'/'.rand(10000, 999999).'.txt');
			}
		}
	}

	public static function dirRead($dir, &$fileinfo = array()) {
		if ($handle = dir($dir)) {
			while (false !== ($file = $handle->read())) {
				if (!is_dir($dir.'/'.$file)) {
					$fileinfo[] = array($file, filesize($dir.'/'.$file));
				} elseif (is_dir($dir.'/'.$file) && $file != '.' && $file != '..') {
					self::dirRead($dir.'/'.$file, $fileinfo);
				}
			}
			$handle->close();
		}
		return $fileinfo;
	}

	public static function find($dir) {
		if (substr(php_uname(), 0, 7) == "Windows") {
			foreach (explode("\n",` cd "$dir" && dir /S /B /A-D `) as $fullFilename) {
				if ($fullFilename != '') {
					$fileinfo[] = array($fullFilename, filesize($fullFilename));
				}
			}
		} else {
			foreach (explode("\n",` cd $dir && find -maxdepth 3 -type f ! -name ".*" -printf "%f\r%s\n" `) as $fileInfos) {
				if ($fileInfos != '') {
					$fileinfo[] = explode("\r", $fileInfos);
				}
			}
		}
		return $fileinfo;
	}

	public static function glob($dir, &$fileinfo = array()) {
		foreach (glob($dir.'/*') as $file) {
			if (is_dir($file)) {
				self::glob($file, $fileinfo);
			} else {
				$fileinfo[] = array(basename($file), filesize($file));
			}
		}
		return $fileinfo;
	}

	public static function scandir($outerDir){
		$dirs = array_diff(scandir($outerDir), array(".", ".."));
		$fileArray = array();
		foreach ($dirs as $d) {
			if (is_dir($outerDir."/".$d)) {
				$fileArray = array_merge($fileArray, self::scandir($outerDir."/".$d));
			} else {
				$fileArray[] = array($d, filesize($outerDir."/".$d));
			}
		}
		return $fileArray;
	}

	public static function opendir($dir, &$fileinfo = array()) {
		if ($handle = opendir($dir)) {
			while (false !== ($file = readdir($handle))) {
				if (!is_dir($dir.'/'.$file)) {
					$fileinfo[] = array($file, filesize($dir.'/'.$file));
				} elseif (is_dir($dir.'/'.$file) && $file != '.' && $file != '..') {
					self::opendir($dir.'/'.$file, $fileinfo);
				}
			}
			closedir($handle);
		}
		return $fileinfo;
	}

	public static function directoryIterator($dir) {
		$iterator = new RecursiveDirectoryIterator($dir);
		foreach(new RecursiveIteratorIterator($iterator, RecursiveIteratorIterator::CHILD_FIRST) as $file) {
			if (false == $file->isDir()) {
				$fileinfo[] = array($file->getFilename(), $file->getSize());
			}
		}
		return $fileinfo;
	}
}

Man wählt also in Zeile 1 eine Methode, stellt in Zeile 7 den Pfad korrekt ein, und lässt das Script laufen. Falls man ein Testverzeichnis erstellen möchte mit 100.000 Dateien, kann man die Methode createTestFolders nutzen.

Bei allen Methoden, die Verzeichnisse durchsuchen und Dateien auslesen (z.B. um die Größe festzustellen) muss man darauf achten, nicht zuviele „offene Filehandles“ zu haben, denn viele Betriebssysteme haben da festgelegte Grenzen, wieviele offene Dateien ein Prozess haben darf.

Unter Linux findet man das beispielsweise heraus mit

$ cat /proc/sys/fs/file-max
184665
$ sysctl fs.file-max
fs.file-max = 184665

Leider weiß ich nicht, wie man die maximale Anzahl an gleichzeitigen FileDescriptors („open files“) eines laufenden Prozesses herausfindet, deshalb habe ich in der unten stehenden Tabelle nur die Gesamtanzahl der Filesystem-Events unter Windows 7 rausgeschrieben (herausgefunden mit dem Process Monitor). Wieviele davon jeweils gleichzeitig geöffnet waren konnte ich nicht herausfinden. Wer weiß Bescheid?

Des weiteren habe ich die Laufzeit protokolliert und auch die Algorithmen einmal einzeln laufen lassen, um den maximalen Speicherverbrauch herauszufinden.

Die Messungen habe ich mit meiner normalen SATA2 Festplatte gemacht, das untersuchte Verzeichnis hat 90.499 Dateien, die meisten davon 0 Byte groß und insgesamt über 10078 Unterordner verteilt.

Interessanterweise sind die Ergebnisse unter Linux deutlich anders gewesen.

• Einmal habe ich einen Ubuntu 9.10 Server genommen, mit SSD, aber leider relativ schwacher CPU. PHP 5.2.10

• Den selben Ubuntu Server, aber mit PHP 5.3.1

• Einmal einen Debian-Server mit QuadCore, Raid1 SATA2 und PHP 5.2.11

Verstehen tue ich einige Ergebnisse noch nicht, zum Beispiel warum die find-Methode auf dem Debian-Server nur 2 Sekunden benötigt, wohingehen sie unter Ubuntu jeweils > 2 Minuten dauert. Das selbe beim DirectoryIterator. Komisch. Außerdem scheint PHP 5.3 ordentlich an Geschwindigkeit zugelegt zu haben gegenüber 5.2.

Falls jemand von euch weiß, wie man die Anzahl der FilesystemEvents (inotify?) unter Linux herausbekommen kann, oder die Anzahl der maximalen gleichzeitigen Filehandles (sowas wie lsof -p PID, nur das Maximum während eines Programmdurchlaufs), bitte in den Kommentaren melden.

Ich überlege auch, ob es sich lohnt, diese Tests mal auf einem NFS-Laufwerk im Netzwerk zu machen, das könnte man evtl. auch mal brauchen.

(Die Tabellen wollte ich übrigens mal ausprobieren, sind mit dem WordPress-Addon WP-Table Reloaded erstellt worden)

Die WordPress Mediathek wächst und wächst, ab und zu sind auch recht große Screenshots dabei oder gar Bilder der Digitalkamera, die häufig sehr groß sind und Metadaten enthalten.

Mit dem Service Smush.it von Yahoo kann man sehr einfach seine Bilder optimieren lassen. Man lädt die zu optimierenden Bilder hoch und erhält eine Auswertung, wieviel Prozent Smush.it sparen konnte (wohlgemerkt ohne die Bildqualität zu verschlechtern, es werden nur Metadaten entfernt sowie die Farbpalette angepasst usw.) und man kann die Bilder dann als zip-Datei herunterladen. Laut FAQ verwendet Smush.it intern aktuell ImageMagick, pngcrush, jpegtran und gifsicle und wählt das beste Ergebnis.

Der Service bietet auch eine API an. Um uns Bloggern das Leben einfacher zu machen gibt es das WordPress-Plugin WP-Smush.it, welches automatisch alle neuen Bilder, die man in die Mediathek hochlädt durch Smush.it optimieren kann. Auch bereits vorhandene Bilder kann man mit einem Klick optimieren.

Im Durchschnitt erhält man dabei Größenoptimierungen von 5-40%, also durchaus akzeptabel, und es passiert im Hindergrund, man muss nicht extra mit Bildprogrammen rumhampeln oder mit Konsolenprogrammen wie optiPNG und Konsorten hantieren.

Ein Problem hatte ich jedoch: Meine Mediathek enthielt bereits 121 Bilder. Da ich nicht 121 Mal den „Smush.it now“ Link in der Mediathek klicken wollte, habe ich mir ein kleines Script geschrieben was das für mich erledigt.

Vorgehensweise ist wie folgt: Ich brauche zuerst alle IDs der Bilder, die ich komprimieren kann, denn ein Aufruf zum Optimieren sieht so aus:

https://www.phpgangsta.de/wp-admin/admin.php?action=wp_smushit_manual&attachment_ID=34

Ich möchte also 121 mal diese URL aufrufen, jeweils mit den passenden IDs. Die IDs hole ich mir eben schnell via phpMyAdmin aus der Datenbank mit dem Query:

SELECT ID FROM `wp_posts` WHERE `post_type` = 'attachment' AND `post_mime_type` LIKE 'image/%'

Das Ergebnis exportiere ich als csv-Datei, sodass ich eine Datei erhalte in der jede Zeile exakt eine ID enthält.

Um die entsprechende WordPress-Plugin-URL aufzurufen werde ich Zend_Http_Client verwenden. Sieht dann so aus:

<?php
$ids = file('ids.txt');

include 'Zend/Loader/Autoloader.php';
$autoloader = Zend_Loader_Autoloader::getInstance();

$client = new Zend_Http_Client();
// Zu Debugzwecken möchte ich das Ergebnis in lesbarer Form, sonst kommt evtl. gzip zurück
$client->setHeaders(array(
    'Accept-encoding' => ''
));
// Timeout erhöhen, 10 Sekunden reichen nicht aus.
$client->setConfig(array('timeout' => 60));
$client->setCookieJar();

// Erste Anfrage: einloggen und eine Session starten (Cookie wird in den CookieJar gepackt und bei den folgenden Requests immer mitgesendet)
$client->setUri('https://www.phpgangsta.de/wp-login.php');
$client->setParameterPost('log', 'MeinAdministratorName');
$client->setParameterPost('pwd', 'MeinAdministratorPasswort');
$client->setParameterPost('rememberme', 'forever');
$client->setParameterPost('wp-submit', 'Anmelden');
$client->setParameterPost('redirect_to', 'https://www.phpgangsta.de/wp-admin/');
$client->setParameterPost('testcookie', '1');
$response = $client->request(Zend_Http_Client::POST);

foreach ($ids as $id) {
	$id = trim($id);
	$client->setUri('https://www.phpgangsta.de/wp-admin/admin.php?action=wp_smushit_manual&attachment_ID='.$id);
	$response = $client->request(Zend_Http_Client::GET);
	echo 'finished'.$id."\n";
}

echo "finished";

Zuerst müssen wir uns natürlich einloggen und speichern das Cookie im CookieJar. Erst danach können wir die URLs in einer Schleife aufrufen.

War eine schöne kurze Übung und garantiert interessanter und schneller als 121 Mal einen Link anzuklicken, wobei man zwischen jedem Klick 3-20 Sekunden warten muss, je nach Bildgröße.

Inspiriert durch Stefan Wienströers Artikel auf SteviesWebsite möchte ich hier dazu aufrufen, den Rekord für das „kleinste Blog System der Welt“ zu brechen! Es geht darum eine Blogsoftware zu schreiben mit möglichst wenig Code. Stefan hat es mit 894 Byte geschafft, ein ganz rudimentäres CMS zu schreiben (das aber nicht ganz unten stehenden Regeln erfüllt).

Die folgenden Regeln werden definiert, damit auch alle Projekte den selben Funktionsumfang bieten:

1. Die öffentlich sichtbare Seite muss alle Blogartikel in chronologischer Reihenfolge auflisten
2. Jeder Artikel hat eine Überschrift, einen Artikeltext und eine Zeitangabe der Erstellung
3. Es gibt einen passwortgeschützten Admin-Bereich, wo man neue Artikel erstellen kann
4. Es muss kein gültiger HTML-Code sein, aber die Webseite muss im Firefox ≥ 3.5 darstellbar und nutzbar sein
5. Es kann jede PHP Version ≥ 5.2 genutzt werden, es dürfen keine besonderen Extensions vorausgesetzt werden
6. Es dürfen Short-Open-Tags genutzt werden
7. Die Speicherung der Artikel soll in einer Datei stattfinden
8. Es dürfen alle Tricks genutzt werden um kurzen Code zu schreiben: Weglassen von Umbrüchen und Leerzeichen, kurze Variablennamen usw. Es geht nicht um Lesbarkeit, sondern um Funktion und kleinen Code!
9. Der SourceCode muss veröffentlicht werden (natürlich 😉 ), evtl. mit Erklärungen falls der Code unlesbar ist 😉
10. Es ist möglich, seinen Code zu verbessern und mehrere Lösungen einzusenden

Die Aktion endet am 07.03.2010, ihr habt also 4 Wochen Zeit. Um teilzunehmen erstellt in eurem Blog einen Artikel mit einem Link zu dieser Aktion. Damit ich euren Rekord mit aufnehmen kann in die Liste benötige ich einen Trackback, einen Kommentar oder eine Email. Der SourceCode muss natürlich öffentlich zugänglich und herunterladbar sein, damit jeder das Ergebnis überprüfen kann.

Ich bin sehr gespannt wo die Grenze liegt, wenn man es wirklich drauf anlegt!

————————————-

Aktuelle Rekorde:
Weiterlesen »

Hier ein kleiner Tip für euch: Schaut euch mal diese Online IDE von CodeRun an. Dort kann man PHP-Code online im Browser schreiben und auch Laufen lassen. Wenn man dort ein entsprechendes Paket gekauft hat kann man direkt aus der IDE auch Deployen.

Falls man seine Quelltexte veröffentlichen möchte kann man einen Permalink erstellen und andere teilhaben lassen.

Für die tägliche Arbeit an großen Projekten eher nicht zu gebrauchen, aber für kleine Testscripte oder die Zusammenarbeit mit anderen einen Blick wert.

http://www.coderun.com/ide

Um das Zend Framework in der Webhosting-Umgebung bei 1und1 ans Laufen zu bekommen, gibt es ein paar Kleinigkeiten zu beachten:

Als erstes muss man bei 1und1 in der .htaccess-Datei angeben welche PHP-Version man benutzen möchte. Dies macht man mit der Zeile

AddType x-mapp-php5 .php

Außerdem muß man noch die folgenden 2 Zeilen hinzufügen, sonst erhält man einen 500er Fehler:

Options -MultiViews
RewriteBase /

Die RewriteBase gilt es natürlich anzupassen falls das Projekt über einen anderen Pfad erreicht werden muss.

Da PHP bei 1und1 als CGI läuft, muß man für die HTTP-Authentifizierung auch noch einen kleinen Workaround einbauen:

RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

Damit wird die Authentifizierungsinformation in die Variable $_SERVER[‚REDIRECT_HTTP_AUTHORIZATION‘] geschrieben. Das sieht dann ungefähr so aus:

echo $_SERVER['REDIRECT_HTTP_AUTHORIZATION'];
//  Basic: d2lraTpwZWRpYQ==

Das ist die Base64-Darstellung von „Username:Passwort“.

Die entgültige .htaccess sieht dann so aus:

AddType x-mapp-php5 .php
Options -MultiViews

RewriteEngine On
RewriteBase /

# workaround for 1und1 php cgi mode
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ index.php [NC,L]

Und so kommt man an Username + Passwort heran:

if (isset($_SERVER['REDIRECT_HTTP_AUTHORIZATION'])) {
 list($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']) = explode(':' , base64_decode(substr($_SERVER['REDIRECT_HTTP_AUTHORIZATION'], 6)));
}