Veriable über verschiedene Instanzen/Sessions hin verwenden

[LlvS]

Hey,

gibt es eine Möglichkeit eine Variable so zu deklarieren, dass sie über mehrere gleichzeitig laufende Scripts hinweg nutzbar ist?

Also User A ruft eine Datei XYZ.php auf, dort wird eine Flag gesetzt solange die Datei verarbeitet wird z.B. 30 Sekunden, User B ruft während der Laufzeit von XYZ.php eine Datei ZYX.php auf und erhält auf Grund der gesetzten Flag eine Fehlermeldung.

Natürlich wäre es möglich, das Ganze über eine Textdatei oder eine Datenbank zu lösen, ich frag mich aber ob es eine Variante mit Superglobals oder ähnlichem gibt.

---
Um Fragen vorzubeugen der Anwendungsfall:
Ich "missbrauche" PHPUnit und Selenium um einen Browser zu steuern und dort einige Sachen zu machen. Das ganze ist durch eine crontab getriggert und läuft ohne zeitliches Limit. Nun möchte ich verhindern, dass 2 Webbrowser-Instanzen parallel geladen werden, mir also die SessionID der Selenium-Instanz Superglobal abspeichern und diese Variable im Konstruktor auslesen. Stellt der 2. Aufruf fest, dass bereis eine Insanz läuft, soll durch werfen und catchen einer definierten Exception die Verarbeitung abgebrochen werden und 5 Minuten später der nächste Versuch unternommen werden.

Vielen Dank für eure Hilfe

Sven

[wahsaga]

Das wäre wohl ein Fall für Shared Memory. PHP: Shared Memory - Manual

[LlvS]

Vielen Dank für die Antwort. Das hört sich interessant an.

Hast du eine Ahnung, wie sich dieser Shared Memory verhält, wenn das Script unsauber abbricht. Wird der Speicher freigegeben, wenn keine Intanzen des Interpreters laufen oder ist dies auf Dauer belegt?

[LlvS]

-.- - Shared Memory Handler

Ich hätte als erstes lesen sollen:
"Note: Versions of Windows previous to Windows 2000 do not support shared memory."

Nun gut, der Server läuft leider auf Windows XP. Vielleicht kann jemand dennoch was mit meiner Implementierung anfagen.

<?
    if(!function_exists('ftok') ) {
        function ftok($filename = "", $proj = "") {
            if(empty($filename) || !file_exists($filename)) {
                return -1;
            } else {
                $filename = $filename . (string) $proj;
                for($key = array(); sizeof($key) < strlen($filename); $key[] = ord(substr($filename, sizeof($key), 1)));
                return dechex(array_sum($key));
            }
        }
    }
    
    /***
     * "static" class to handle the SharedMemory-functions
     */
    abstract class SharedMemoryHandler {
        const PARAM_PROJECT_NAME = 't'; // constant so you can overwrite it in extending classes
        
        public static final function open($nID, $chrFlag, $nPermission, $nSize) {
            $nID = shmop_open($nKey, $chrFlag, $nPermission, $nSize);
            if (!shmop_open($nKey, $chrFlag, $nPermission, $nSize)) {
                throw new Exception('Unable to open shared memory with data:' . print_r(array(
                    'key' => $nKey,
                    'flag' => $chrFlag,
                    'permission' => $nPermission,
                    'size' => $nSize
                ), true));
            }
            return $nID;
        }
        
        /***
         * Uses a filename, f.e. the calling file (__FILE__) to create the ID.
         * The same file will always create the same ID. 
         */
        public static final function openByFilename($strFilename, $chrFlag, $nPermission, $nSize) {
            return self::open(ftok($strFilename, self::PARAM_PROJECT_NAME), $chrFlag, $nPermission, $nSize);
        }
        
        /***
         * Creates the shared memory segment and writes the data into it
         * @return array('ID', 'size') The ID and the byte-size of the written data.
         */
        public static final function openAndWriteByFilename($strFilename, $strData, $chrFlag = 'c', $nPermission = 0700) {
            $nID = self::openByFilenameAsKey($nID, $chrFlag, $nPermission, strlen(base64_encode($strData)));
            $nSize = self::write($nID, $strData);
            return array(
                'ID' => $nID,
                'size' => $nSize
            );
        }
        
        public static final function getSize($nID) {
            return shmop_size($nID);
        }
        
        /***
         * reads the segment
         * @param $nID The ID of the segment.
         * @param $nStart IF given THEN the first offset to read ELSE offset 0.
         * @param $nCount IF given THEN the number of bytes to read ELSE all the bytes
         * @return STRING the segment
         */
        public static final function read($nID, $nStart = 0, $nCount = null) {
            if (!isset($nCount))
                $nCount = self::getSize($nID) - $nStart;
            return base64_decode(shmop_read($nID, $nStart, $nCount));
        }
        
        /***
         * Uses a filename, f.e. the calling file (__FILE__) to create the ID and reads the segment.
         * The same file will always create the same ID.
         * @param $strFilename The name of the file.
         * @param $nStart IF given THEN the first offset to read ELSE offset 0.
         * @param $nCount IF given THEN the number of bytes to read ELSE all the bytes
         * @return STRING the segment
         */
        public static final function readByFilename($strFilename, $nStart = 0, $nCount = null) {
            return self::read(ftok($strFilename, self::PARAM_PROJECT_NAME), $nStart, $nCount);
        }
        
        public static final function write($nID, $strData, $nOffset = 0) {
            return shmop_write($nID, base64_encode($strData), $nOffset);
        }
        
        /***
         * Uses a filename, f.e. the calling file (__FILE__) to create the ID and writes data to the segment.
         * The same file will always create the same ID.
         */
        public static final function writeByFilename($strFilename, $strData, $nOffset = 0) {
            return self::write(ftok($strFilename, self::PARAM_PROJECT_NAME), $strData, $nOffset);
        }
        
        public static final function delete($nID) {
            return shmop_delete($nID);
        }
        
        public static final function deleteByFilename($strFilename) {
            return shmop_delete(ftok($strFilename, self::PARAM_PROJECT_NAME));
        }
        
        public static final function close($nID) {
            return shmop_close($nID);
        }
        
        public static final function closeByFilename($strFilename) {
            return self::close(ftok($strFilename, self::PARAM_PROJECT_NAME));
        }
        
        public static final function deleteAndClose($nID) {
            if(self::delete($nID)) {
                return self::close($nID);
            } else {
                return false;
            }
        }
        
        public static final function deleteAndCloseByFilename($strFilename) {
            if(self::deleteByFilename($strFilename)) {
                return self::closeByFilename($strFilename);
            } else {
                return false;
            }
        }
        
        public static final function exists($nID) {
            $nID = self::open($nID, 'n', 0700, 1);
            if ($nID !== false) {
                self::deleteAndClose($nID);
                return false;
            }
            return true;
        }
        
        public static final function existsByFilename($strFilename) {
            $nID = self::openByFilename($strFilename, 'n', 0700, 1);
            if ($nID !== false) {
                self::deleteAndClose($strFilename);
                return false;
            }
            return true;
        }
    }
    
?>

edit: Die ist noch nicht debuggt, exist wird einen Fehler erzeugen, da die Exception nicht gefangen ist sondern auf den Rückgabewert geprüft wird...

[h3ll]

Windows XP kam nach Windows 2000 raus.

Davon abgesehen ist Windows XP kein Server-Betriebssystem. Warum tut man sowas?

Darüber hinaus ist Windows XP auch noch tot. Man sollte Leichen nicht unnötig am Leben erhalten.

[LlvS]

Stimmt, warum stehen die Funktionen dann nicht zur Verfügung. Muss man diese irgendwie in der ini aktivieren? Hmmmm.

Weil der Rechner über war, ne Windows XP Lizenz existiert, Server drauf laufen die Windows benötigen...

[fireweasel]

Stimmt, warum stehen die Funktionen dann nicht zur Verfügung. Muss man diese irgendwie in der ini aktivieren?

Ja.
Die Binaries von php.net sind mit shmop-Support compiliert, aber du musst dir die Mühe machen, in deiner php.ini vorm entsprechenden Eintrag das Semikolon zu entfernen. Er im Auslieferungszustand auskommentiert:

;...
;extension=php_shmop.dll
; ...

Davon abgesehen ist Windows XP kein Server-Betriebssystem.

Windows XP steht für eine große Familie von Betriebssystemen. Es sind auch Server-Betriebssysteme darunter (ich kenne zumindest keine Itanium-basierten End-User-Geräte) und viele Varianten laufen sowohl als Client- als auch als Server-OS (so groß sind die Unterschiede zum "echten" Server-OS Windows 2003 nicht).

Warum tut man sowas?

Warum benutzen Menschen unpassende Software (wie bspw. PHP als Script-Sprache ... )? Vermutlich aus Gewohnheit, dem Unwillen, etwas anderes|Neues zu lernen, oder auch weil gerade nichts Besseres greifbar war.

Darüber hinaus ist Windows XP auch noch tot.

Für die Verwendung als PHP-Script-"Server" ist das ausschlaggebende Argument, dass Windows XP seit PHP 5.5.0 (2013-06-20) nicht mehr als Plattform unterstützt wird. (Das war vor dem "Lebensende" von XP). Somit gibts keine aktuellen PHP-Versionen mehr, die darauf laufen. Ältere PHP-Versionen, die das noch tun, haben viele lustige Sicherheitslücken.

[LlvS]

Vielen Dank für deine Antwort. Hat mir weiter geholfen.

Warum tut man sowas?

Warum benutzen Menschen unpassende Software (wie bspw. PHP als Script-Sprache ... )? Vermutlich aus Gewohnheit, dem Unwillen, etwas anderes|Neues zu lernen, oder auch weil gerade nichts Besseres greifbar war.

Hier kommt es doch auf die Rahmenbedingungen an. Eine rein Umgebung die nur um zu funktionieren unzählige Ressourcen frist, ist nicht immer die beste. Oder würdet ihr euch auch gegen BASH als Scriptsprache ausprechen?

Oder auch weil oftmals versucht wird mit Kanonen auf Spatzen zu schießen. Auch, wenn du mich nicht kennst, glaube mir, dass ich ein paar Sprachen programmieren kann, mein Ansatz aber ist, ein Problem möglichst effizient zu lösen und für manche Sachen reicht eine Scriptsprache halt vollkommen aus. Aber ja, es kommt dazu, dass PHP meine Heimatsprache ist.

Für die Verwendung als PHP-Script-"Server" ist das ausschlaggebende Argument, dass Windows XP seit PHP 5.5.0 (2013-06-20) nicht mehr als Plattform unterstützt wird. (Das war vor dem "Lebensende" von XP). Somit gibts keine aktuellen PHP-Versionen mehr, die darauf laufen. Ältere PHP-Versionen, die das noch tun, haben viele lustige Sicherheitslücken.

Nun handelt es sich um eine reine Intranetlösung in einem klitzelkleinen Unternehmen. Der Rechner stand als ausgemusterter Rechner zur Verfügung. Wie gesagt ist ein Windowsserver notwendig auf grund bestimmter Software, also warum nicht diesen Rechner und die dazugehörige BS-Lizenz nutzen anstatt für teuer Geld einen weiteren Server daneben zu stellen.