(bug 48294) API: Fix chunk upload async mode

[mediawiki.git] / maintenance / locking / LockServerDaemon.php

<?php
/**
 * Simple lock server daemon that accepts lock/unlock requests.
 *
 * This code should not require MediaWiki setup or PHP files.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 * http://www.gnu.org/copyleft/gpl.html
 *
 * @file
 * @ingroup LockManager Maintenance
 */

if ( PHP_SAPI !== 'cli' ) {
        die( "This is not a valid entry point.\n" );
}
error_reporting( E_ALL );

// Run the server...
set_time_limit( 0 );
LockServerDaemon::init(
        getopt( '', array(
                'address:', 'port:', 'authKey:',
                'lockTimeout::', 'maxClients::', 'maxBacklog::', 'maxLocks::',
        ) )
)->main();

/**
 * Simple lock server daemon that accepts lock/unlock requests
 *
 * @ingroup LockManager Maintenance
 */
class LockServerDaemon {
        /** @var resource */
        protected $sock; // socket to listen/accept on
        /** @var Array */
        protected $sessions = array(); // (session => resource)
        /** @var Array */
        protected $deadSessions = array(); // (session => UNIX timestamp)

        /** @var LockHolder */
        protected $lockHolder;

        protected $address; // string IP address
        protected $port; // integer
        protected $authKey; // string key
        protected $lockTimeout; // integer number of seconds
        protected $maxBacklog; // integer
        protected $maxClients; // integer

        protected $startTime; // integer UNIX timestamp
        protected $ticks = 0; // integer counter

        /* @var LockServerDaemon */
        protected static $instance = null;

        /**
         * @params $config Array
         * @param array $config
         * @throws Exception
         * @return LockServerDaemon
         */
        public static function init( array $config ) {
                if ( self::$instance ) {
                        throw new Exception( 'LockServer already initialized.' );
                }
                foreach ( array( 'address', 'port', 'authKey' ) as $par ) {
                        if ( !isset( $config[$par] ) ) {
                                die( "Usage: php LockServerDaemon.php " .
                                        "--address <address> --port <port> --authKey <key> " .
                                        "[--lockTimeout <seconds>] " .
                                        "[--maxLocks <integer>] [--maxClients <integer>] [--maxBacklog <integer>]\n"
                                );
                        }
                }
                self::$instance = new self( $config );
                return self::$instance;
        }

        /**
         * @params $config Array
         */
        protected function __construct( array $config ) {
                // Required parameters...
                $this->address = $config['address'];
                $this->port = $config['port'];
                $this->authKey = $config['authKey'];
                // Parameters with defaults...
                $this->lockTimeout = isset( $config['lockTimeout'] )
                        ? (int)$config['lockTimeout']
                        : 60;
                $this->maxClients = isset( $config['maxClients'] )
                        ? (int)$config['maxClients']
                        : 1000; // less than default FD_SETSIZE
                $this->maxBacklog = isset( $config['maxBacklog'] )
                        ? (int)$config['maxBacklog']
                        : 100;
                $maxLocks = isset( $config['maxLocks'] )
                        ? (int)$config['maxLocks']
                        : 10000;

                $this->lockHolder = new LockHolder( $maxLocks );
        }

        /**
         * @throws Exception
         * @return void
         */
        protected function setupServerSocket() {
                if ( !function_exists( 'socket_create' ) ) {
                        throw new Exception( "PHP sockets extension missing from PHP CLI mode." );
                }
                $sock = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );
                if ( $sock === false ) {
                        throw new Exception( "socket_create(): " . socket_strerror( socket_last_error() ) );
                }
                socket_set_option( $sock, SOL_SOCKET, SO_REUSEADDR, 1 ); // bypass 2MLS
                socket_set_nonblock( $sock ); // don't block on accept()
                if ( socket_bind( $sock, $this->address, $this->port ) === false ) {
                        throw new Exception( "socket_bind(): " .
                                socket_strerror( socket_last_error( $sock ) ) );
                } elseif ( socket_listen( $sock, $this->maxBacklog ) === false ) {
                        throw new Exception( "socket_listen(): " .
                                socket_strerror( socket_last_error( $sock ) ) );
                }
                $this->sock = $sock;
                $this->startTime = time();
        }

        /**
         * Entry-point function that listens to the server socket, accepts
         * new clients, and recieves/responds to requests to lock resources.
         */
        public function main() {
                $this->setupServerSocket(); // setup listening socket
                $socketArray = new SocketArray(); // sockets being serviced
                $socketArray->addSocket( $this->sock ); // add listening socket
                do {
                        list( $read, $write ) = $socketArray->socketsForSelect();
                        if ( socket_select( $read, $write, $except = NULL, NULL ) < 1 ) {
                                continue; // wait
                        }
                        // Check if there is a client trying to connect...
                        if ( in_array( $this->sock, $read ) && $socketArray->size() < $this->maxClients ) {
                                $newSock = socket_accept( $this->sock );
                                if ( $newSock ) {
                                        socket_set_option( $newSock, SOL_SOCKET, SO_KEEPALIVE, 1 );
                                        socket_set_nonblock( $newSock ); // don't block on read()/write()
                                        $socketArray->addSocket( $newSock );
                                }
                        }
                        // Loop through all the clients that have data to read...
                        foreach ( $read as $read_sock ) {
                                if ( $read_sock === $this->sock ) {
                                        continue; // skip listening socket
                                }
                                // Avoids PHP_NORMAL_READ per https://bugs.php.net/bug.php?id=33471
                                $data = socket_read( $read_sock, 65535 );
                                // Check if the client is disconnected
                                if ( $data === false || $data === '' ) {
                                        $socketArray->closeSocket( $read_sock );
                                        $this->recordDeadSocket( $read_sock ); // remove session
                                // Check if we reached the end of a message
                                } elseif ( substr( $data, -1 ) === "\n" ) {
                                        // Newline is the last char (given ping-pong message usage)
                                        $cmd = $socketArray->readRcvBuffer( $read_sock ) . $data;
                                        // Perform the requested command...
                                        $response = $this->doCommand( rtrim( $cmd ), $read_sock );
                                        // Send the response to the client...
                                        $socketArray->appendSndBuffer( $read_sock, $response . "\n" );
                                // Otherwise, we just have more message data to append
                                } elseif ( !$socketArray->appendRcvBuffer( $read_sock, $data ) ) {
                                        $socketArray->closeSocket( $read_sock ); // too big
                                        $this->recordDeadSocket( $read_sock ); // remove session
                                }
                        }
                        // Loop through all the clients that have data to write...
                        foreach ( $write as $write_sock ) {
                                $bytes = socket_write( $write_sock, $socketArray->readSndBuffer( $write_sock ) );
                                // Check if the client is disconnected
                                if ( $bytes === false ) {
                                        $socketArray->closeSocket( $write_sock );
                                        $this->recordDeadSocket( $write_sock ); // remove session
                                // Otherwise, truncate these bytes from the start of the write buffer
                                } else {
                                        $socketArray->consumeSndBuffer( $write_sock, $bytes );
                                }
                        }
                        // Prune dead locks every few socket events...
                        if ( ++$this->ticks >= 9 ) {
                                $this->ticks = 0;
                                $this->purgeExpiredLocks();
                        }
                } while ( true );
        }

        /**
         * @param $data string
         * @param $sourceSock resource
         * @return string
         */
        protected function doCommand( $data, $sourceSock ) {
                $cmdArr = $this->getCommand( $data );
                if ( is_string( $cmdArr ) ) {
                        return $cmdArr; // error
                }
                list( $function, $session, $type, $resources ) = $cmdArr;
                // On first command, track the session => sock correspondence
                if ( !isset( $this->sessions[$session] ) ) {
                        $this->sessions[$session] = $sourceSock;
                        unset( $this->deadSessions[$session] ); // renew if dead
                }
                if ( $function === 'ACQUIRE' ) {
                        return $this->lockHolder->lock( $session, $type, $resources );
                } elseif ( $function === 'RELEASE' ) {
                        return $this->lockHolder->unlock( $session, $type, $resources );
                } elseif ( $function === 'RELEASE_ALL' ) {
                        return $this->lockHolder->release( $session );
                } elseif ( $function === 'STAT' ) {
                        return $this->stat();
                }
                return 'INTERNAL_ERROR';
        }

        /**
         * @param $data string
         * @return Array
         */
        protected function getCommand( $data ) {
                $m = explode( ':', $data ); // <session, key, command, type, values>
                if ( count( $m ) == 5 ) {
                        list( $session, $key, $command, $type, $values ) = $m;
                        $goodKey = hash_hmac( 'sha1',
                                "{$session}\n{$command}\n{$type}\n{$values}", $this->authKey );
                        if ( $goodKey !== $key ) {
                                return 'BAD_KEY';
                        } elseif ( strlen( $session ) !== 32 ) {
                                return 'BAD_SESSION';
                        }
                        $values = explode( '|', $values );
                        if ( $command === 'ACQUIRE' ) {
                                $needsLockArgs = true;
                        } elseif ( $command === 'RELEASE' ) {
                                $needsLockArgs = true;
                        } elseif ( $command === 'RELEASE_ALL' ) {
                                $needsLockArgs = false;
                        } elseif ( $command === 'STAT' ) {
                                $needsLockArgs = false;
                        } else {
                                return 'BAD_COMMAND';
                        }
                        if ( $needsLockArgs ) {
                                if ( $type !== 'SH' && $type !== 'EX' ) {
                                        return 'BAD_TYPE';
                                }
                                foreach ( $values as $value ) {
                                        if ( strlen( $value ) !== 31 ) {
                                                return 'BAD_FORMAT';
                                        }
                                }
                        }
                        return array( $command, $session, $type, $values );
                }
                return 'BAD_FORMAT';
        }

        /**
         * Remove a socket's corresponding session from tracking and
         * store it in the dead session tracking if it still has locks.
         *
         * @param $socket resource
         * @return bool
         */
        protected function recordDeadSocket( $socket ) {
                $session = array_search( $socket, $this->sessions );
                if ( $session !== false ) {
                        unset( $this->sessions[$session] );
                        // Record recently killed sessions that still have locks
                        if ( $this->lockHolder->sessionHasLocks( $session ) ) {
                                $this->deadSessions[$session] = time();
                        }
                        return true;
                }
                return false;
        }

        /**
         * Clear locks for sessions that have been dead for a while
         *
         * @return integer Number of sessions purged
         */
        protected function purgeExpiredLocks() {
                $count = 0;
                $now = time();
                foreach ( $this->deadSessions as $session => $timestamp ) {
                        if ( ( $now - $timestamp ) > $this->lockTimeout ) {
                                $this->lockHolder->release( $session );
                                unset( $this->deadSessions[$session] );
                                ++$count;
                        }
                }
                return $count;
        }

        /**
         * Get the current timestamp and memory usage
         *
         * @return string
         */
        protected function stat() {
                return ( time() - $this->startTime ) . ':' . memory_get_usage();
        }
}

/**
 * LockServerDaemon helper class that keeps track socket states
 */
class SocketArray {
        /* @var Array */
        protected $clients = array(); // array of client sockets
        /* @var Array */
        protected $rBuffers = array(); // corresponding socket read buffers
        /* @var Array */
        protected $wBuffers = array(); // corresponding socket write buffers

        const BUFFER_SIZE = 65535;

        /**
         * @return Array (list of sockets to read, list of sockets to write)
         */
        public function socketsForSelect() {
                $rSockets = array();
                $wSockets = array();
                foreach ( $this->clients as $key => $socket ) {
                        if ( $this->wBuffers[$key] !== '' ) {
                                $wSockets[] = $socket; // wait for writing to unblock
                        } else {
                                $rSockets[] = $socket; // wait for reading to unblock
                        }
                }
                return array( $rSockets, $wSockets );
        }

        /**
         * @return integer Number of client sockets
         */
        public function size() {
                return count( $this->clients );
        }

        /**
         * @param $sock resource
         * @return bool
         */
        public function addSocket( $sock ) {
                $this->clients[] = $sock;
                $this->rBuffers[] = '';
                $this->wBuffers[] = '';
                return true;
        }

        /**
         * @param $sock resource
         * @return bool
         */
        public function closeSocket( $sock ) {
                $key = array_search( $sock, $this->clients );
                if ( $key === false ) {
                        return false;
                }
                socket_close( $sock );
                unset( $this->clients[$key] );
                unset( $this->rBuffers[$key] );
                unset( $this->wBuffers[$key] );
                return true;
        }

        /**
         * @param $sock resource
         * @param $data string
         * @return bool
         */
        public function appendRcvBuffer( $sock, $data ) {
                $key = array_search( $sock, $this->clients );
                if ( $key === false ) {
                        return false;
                } elseif ( ( strlen( $this->rBuffers[$key] ) + strlen( $data ) ) > self::BUFFER_SIZE ) {
                        return false;
                }
                $this->rBuffers[$key] .= $data;
                return true;
        }

        /**
         * @param $sock resource
         * @return string|bool
         */
        public function readRcvBuffer( $sock ) {
                $key = array_search( $sock, $this->clients );
                if ( $key === false ) {
                        return false;
                }
                $data = $this->rBuffers[$key];
                $this->rBuffers[$key] = ''; // consume data
                return $data;
        }

        /**
         * @param $sock resource
         * @param $data string
         * @return bool
         */
        public function appendSndBuffer( $sock, $data ) {
                $key = array_search( $sock, $this->clients );
                if ( $key === false ) {
                        return false;
                } elseif ( ( strlen( $this->wBuffers[$key] ) + strlen( $data ) ) > self::BUFFER_SIZE ) {
                        return false;
                }
                $this->wBuffers[$key] .= $data;
                return true;
        }

        /**
         * @param $sock resource
         * @return bool
         */
        public function readSndBuffer( $sock ) {
                $key = array_search( $sock, $this->clients );
                if ( $key === false ) {
                        return false;
                }
                return $this->wBuffers[$key];
        }

        /**
         * @param $sock resource
         * @param $bytes integer
         * @return bool
         */
        public function consumeSndBuffer( $sock, $bytes ) {
                $key = array_search( $sock, $this->clients );
                if ( $key === false ) {
                        return false;
                }
                $this->wBuffers[$key] = (string)substr( $this->wBuffers[$key], $bytes );
                return true;
        }
}

/**
 * LockServerDaemon helper class that keeps track of the locks
 */
class LockHolder {
        /** @var Array */
        protected $shLocks = array(); // (key => session => 1)
        /** @var Array */
        protected $exLocks = array(); // (key => session)

        /** @var Array */
        protected $sessionIndexSh = array(); // (session => key => 1)
        /** @var Array */
        protected $sessionIndexEx = array(); // (session => key => 1)
        protected $lockCount = 0; // integer

        protected $maxLocks; // integer

        /**
         * @params $maxLocks integer Maximum number of locks to allow
         */
        public function __construct( $maxLocks ) {
                $this->maxLocks = $maxLocks;
        }

        /**
         * @param $session string
         * @return bool
         */
        public function sessionHasLocks( $session ) {
                return isset( $this->sessionIndexSh[$session] )
                        || isset( $this->sessionIndexEx[$session] );
        }

        /**
         * @param $session string
         * @param $type string
         * @param $keys Array
         * @return string
         */
        public function lock( $session, $type, array $keys ) {
                if ( ( $this->lockCount + count( $keys ) ) > $this->maxLocks ) {
                        return 'TOO_MANY_LOCKS';
                }
                if ( $type === 'SH' ) {
                        // Check if any keys are already write-locked...
                        foreach ( $keys as $key ) {
                                if ( isset( $this->exLocks[$key] ) && $this->exLocks[$key] !== $session ) {
                                        return 'CANT_ACQUIRE';
                                }
                        }
                        // Acquire the read-locks...
                        foreach ( $keys as $key ) {
                                $this->set_sh_lock( $key, $session );
                        }
                        return 'ACQUIRED';
                } elseif ( $type === 'EX' ) {
                        // Check if any keys are already read-locked or write-locked...
                        foreach ( $keys as $key ) {
                                if ( isset( $this->exLocks[$key] ) && $this->exLocks[$key] !== $session ) {
                                        return 'CANT_ACQUIRE';
                                }
                                if ( isset( $this->shLocks[$key] ) ) {
                                        foreach ( $this->shLocks[$key] as $otherSession => $x ) {
                                                if ( $otherSession !== $session ) {
                                                        return 'CANT_ACQUIRE';
                                                }
                                        }
                                }
                        }
                        // Acquire the write-locks...
                        foreach ( $keys as $key ) {
                                $this->set_ex_lock( $key, $session );
                        }
                        return 'ACQUIRED';
                }
                return 'INTERNAL_ERROR';
        }

        /**
         * @param $session string
         * @param $type string
         * @param $keys Array
         * @return string
         */
        public function unlock( $session, $type, array $keys ) {
                if ( $type === 'SH' ) {
                        foreach ( $keys as $key ) {
                                $this->unset_sh_lock( $key, $session );
                        }
                        return 'RELEASED';
                } elseif ( $type === 'EX' ) {
                        foreach ( $keys as $key ) {
                                $this->unset_ex_lock( $key, $session );
                        }
                        return 'RELEASED';
                }
                return 'INTERNAL_ERROR';
        }

        /**
         * @param $session string
         * @return string
         */
        public function release( $session ) {
                if ( isset( $this->sessionIndexSh[$session] ) ) {
                        foreach ( $this->sessionIndexSh[$session] as $key => $x ) {
                                $this->unset_sh_lock( $key, $session );
                        }
                }
                if ( isset( $this->sessionIndexEx[$session] ) ) {
                        foreach ( $this->sessionIndexEx[$session] as $key => $x ) {
                                $this->unset_ex_lock( $key, $session );
                        }
                }
                return 'RELEASED_ALL';
        }

        /**
         * @param $key string
         * @param $session string
         * @return void
         */
        protected function set_sh_lock( $key, $session ) {
                if ( !isset( $this->shLocks[$key][$session] ) ) {
                        $this->shLocks[$key][$session] = 1;
                        $this->sessionIndexSh[$session][$key] = 1;
                        ++$this->lockCount; // we are adding a lock
                }
        }

        /**
         * @param $key string
         * @param $session string
         * @return void
         */
        protected function set_ex_lock( $key, $session ) {
                if ( !isset( $this->exLocks[$key][$session] ) ) {
                        $this->exLocks[$key] = $session;
                        $this->sessionIndexEx[$session][$key] = 1;
                        ++$this->lockCount; // we are adding a lock
                }
        }

        /**
         * @param $key string
         * @param $session string
         * @return void
         */
        protected function unset_sh_lock( $key, $session ) {
                if ( isset( $this->shLocks[$key][$session] ) ) {
                        unset( $this->shLocks[$key][$session] );
                        if ( !count( $this->shLocks[$key] ) ) {
                                unset( $this->shLocks[$key] );
                        }
                        unset( $this->sessionIndexSh[$session][$key] );
                        if ( !count( $this->sessionIndexSh[$session] ) ) {
                                unset( $this->sessionIndexSh[$session] );
                        }
                        --$this->lockCount;
                }
        }

        /**
         * @param $key string
         * @param $session string
         * @return void
         */
        protected function unset_ex_lock( $key, $session ) {
                if ( isset( $this->exLocks[$key] ) && $this->exLocks[$key] === $session ) {
                        unset( $this->exLocks[$key] );
                        unset( $this->sessionIndexEx[$session][$key] );
                        if ( !count( $this->sessionIndexEx[$session] ) ) {
                                unset( $this->sessionIndexEx[$session] );
                        }
                        --$this->lockCount;
                }
        }
}