MediaWiki  1.28.0
MemcachedClient.php
Go to the documentation of this file.
1 <?php
2 // @codingStandardsIgnoreFile It's an external lib and it isn't. Let's not bother.
71 
72 // {{{ class MemcachedClient
80  // {{{ properties
81  // {{{ public
82 
83  // {{{ constants
84  // {{{ flags
85 
89  const SERIALIZED = 1;
90 
94  const COMPRESSED = 2;
95 
99  const INTVAL = 4;
100 
101  // }}}
102 
106  const COMPRESSION_SAVINGS = 0.20;
107 
108  // }}}
109 
116  public $stats;
117 
118  // }}}
119  // {{{ private
120 
127  public $_cache_sock;
128 
135  public $_debug;
136 
143  public $_host_dead;
144 
151  public $_have_zlib;
152 
160 
168 
175  public $_persistent;
176 
184 
191  public $_servers;
192 
199  public $_buckets;
200 
208 
215  public $_active;
216 
224 
232 
237 
242 
246  private $_logger;
247 
248  // }}}
249  // }}}
250  // {{{ methods
251  // {{{ public functions
252  // {{{ memcached()
253 
261  public function __construct( $args ) {
262  $this->set_servers( isset( $args['servers'] ) ? $args['servers'] : array() );
263  $this->_debug = isset( $args['debug'] ) ? $args['debug'] : false;
264  $this->stats = array();
265  $this->_compress_threshold = isset( $args['compress_threshold'] ) ? $args['compress_threshold'] : 0;
266  $this->_persistent = isset( $args['persistent'] ) ? $args['persistent'] : false;
267  $this->_compress_enable = true;
268  $this->_have_zlib = function_exists( 'gzcompress' );
269 
270  $this->_cache_sock = array();
271  $this->_host_dead = array();
272 
273  $this->_timeout_seconds = 0;
274  $this->_timeout_microseconds = isset( $args['timeout'] ) ? $args['timeout'] : 500000;
275 
276  $this->_connect_timeout = isset( $args['connect_timeout'] ) ? $args['connect_timeout'] : 0.1;
277  $this->_connect_attempts = 2;
278 
279  $this->_logger = isset( $args['logger'] ) ? $args['logger'] : new NullLogger();
280  }
281 
282  // }}}
283  // {{{ add()
284 
299  public function add( $key, $val, $exp = 0 ) {
300  return $this->_set( 'add', $key, $val, $exp );
301  }
302 
303  // }}}
304  // {{{ decr()
305 
314  public function decr( $key, $amt = 1 ) {
315  return $this->_incrdecr( 'decr', $key, $amt );
316  }
317 
318  // }}}
319  // {{{ delete()
320 
329  public function delete( $key, $time = 0 ) {
330  if ( !$this->_active ) {
331  return false;
332  }
333 
334  $sock = $this->get_sock( $key );
335  if ( !is_resource( $sock ) ) {
336  return false;
337  }
338 
339  $key = is_array( $key ) ? $key[1] : $key;
340 
341  if ( isset( $this->stats['delete'] ) ) {
342  $this->stats['delete']++;
343  } else {
344  $this->stats['delete'] = 1;
345  }
346  $cmd = "delete $key $time\r\n";
347  if ( !$this->_fwrite( $sock, $cmd ) ) {
348  return false;
349  }
350  $res = $this->_fgets( $sock );
351 
352  if ( $this->_debug ) {
353  $this->_debugprint( sprintf( "MemCache: delete %s (%s)", $key, $res ) );
354  }
355 
356  if ( $res == "DELETED" || $res == "NOT_FOUND" ) {
357  return true;
358  }
359 
360  return false;
361  }
362 
371  public function touch( $key, $time = 0 ) {
372  if ( !$this->_active ) {
373  return false;
374  }
375 
376  $sock = $this->get_sock( $key );
377  if ( !is_resource( $sock ) ) {
378  return false;
379  }
380 
381  $key = is_array( $key ) ? $key[1] : $key;
382 
383  if ( isset( $this->stats['touch'] ) ) {
384  $this->stats['touch']++;
385  } else {
386  $this->stats['touch'] = 1;
387  }
388  $cmd = "touch $key $time\r\n";
389  if ( !$this->_fwrite( $sock, $cmd ) ) {
390  return false;
391  }
392  $res = $this->_fgets( $sock );
393 
394  if ( $this->_debug ) {
395  $this->_debugprint( sprintf( "MemCache: touch %s (%s)", $key, $res ) );
396  }
397 
398  if ( $res == "TOUCHED" ) {
399  return true;
400  }
401 
402  return false;
403  }
404 
410  public function lock( $key, $timeout = 0 ) {
411  /* stub */
412  return true;
413  }
414 
419  public function unlock( $key ) {
420  /* stub */
421  return true;
422  }
423 
424  // }}}
425  // {{{ disconnect_all()
426 
430  public function disconnect_all() {
431  foreach ( $this->_cache_sock as $sock ) {
432  fclose( $sock );
433  }
434 
435  $this->_cache_sock = array();
436  }
437 
438  // }}}
439  // {{{ enable_compress()
440 
446  public function enable_compress( $enable ) {
447  $this->_compress_enable = $enable;
448  }
449 
450  // }}}
451  // {{{ forget_dead_hosts()
452 
456  public function forget_dead_hosts() {
457  $this->_host_dead = array();
458  }
459 
460  // }}}
461  // {{{ get()
462 
471  public function get( $key, &$casToken = null ) {
472 
473  if ( $this->_debug ) {
474  $this->_debugprint( "get($key)" );
475  }
476 
477  if ( !is_array( $key ) && strval( $key ) === '' ) {
478  $this->_debugprint( "Skipping key which equals to an empty string" );
479  return false;
480  }
481 
482  if ( !$this->_active ) {
483  return false;
484  }
485 
486  $sock = $this->get_sock( $key );
487 
488  if ( !is_resource( $sock ) ) {
489  return false;
490  }
491 
492  $key = is_array( $key ) ? $key[1] : $key;
493  if ( isset( $this->stats['get'] ) ) {
494  $this->stats['get']++;
495  } else {
496  $this->stats['get'] = 1;
497  }
498 
499  $cmd = "gets $key\r\n";
500  if ( !$this->_fwrite( $sock, $cmd ) ) {
501  return false;
502  }
503 
504  $val = array();
505  $this->_load_items( $sock, $val, $casToken );
506 
507  if ( $this->_debug ) {
508  foreach ( $val as $k => $v ) {
509  $this->_debugprint( sprintf( "MemCache: sock %s got %s", serialize( $sock ), $k ) );
510  }
511  }
512 
513  $value = false;
514  if ( isset( $val[$key] ) ) {
515  $value = $val[$key];
516  }
517  return $value;
518  }
519 
520  // }}}
521  // {{{ get_multi()
522 
530  public function get_multi( $keys ) {
531  if ( !$this->_active ) {
532  return array();
533  }
534 
535  if ( isset( $this->stats['get_multi'] ) ) {
536  $this->stats['get_multi']++;
537  } else {
538  $this->stats['get_multi'] = 1;
539  }
540  $sock_keys = array();
541  $socks = array();
542  foreach ( $keys as $key ) {
543  $sock = $this->get_sock( $key );
544  if ( !is_resource( $sock ) ) {
545  continue;
546  }
547  $key = is_array( $key ) ? $key[1] : $key;
548  if ( !isset( $sock_keys[$sock] ) ) {
549  $sock_keys[intval( $sock )] = array();
550  $socks[] = $sock;
551  }
552  $sock_keys[intval( $sock )][] = $key;
553  }
554 
555  $gather = array();
556  // Send out the requests
557  foreach ( $socks as $sock ) {
558  $cmd = 'gets';
559  foreach ( $sock_keys[intval( $sock )] as $key ) {
560  $cmd .= ' ' . $key;
561  }
562  $cmd .= "\r\n";
563 
564  if ( $this->_fwrite( $sock, $cmd ) ) {
565  $gather[] = $sock;
566  }
567  }
568 
569  // Parse responses
570  $val = array();
571  foreach ( $gather as $sock ) {
572  $this->_load_items( $sock, $val, $casToken );
573  }
574 
575  if ( $this->_debug ) {
576  foreach ( $val as $k => $v ) {
577  $this->_debugprint( sprintf( "MemCache: got %s", $k ) );
578  }
579  }
580 
581  return $val;
582  }
583 
584  // }}}
585  // {{{ incr()
586 
597  public function incr( $key, $amt = 1 ) {
598  return $this->_incrdecr( 'incr', $key, $amt );
599  }
600 
601  // }}}
602  // {{{ replace()
603 
617  public function replace( $key, $value, $exp = 0 ) {
618  return $this->_set( 'replace', $key, $value, $exp );
619  }
620 
621  // }}}
622  // {{{ run_command()
623 
633  public function run_command( $sock, $cmd ) {
634  if ( !is_resource( $sock ) ) {
635  return array();
636  }
637 
638  if ( !$this->_fwrite( $sock, $cmd ) ) {
639  return array();
640  }
641 
642  $ret = array();
643  while ( true ) {
644  $res = $this->_fgets( $sock );
645  $ret[] = $res;
646  if ( preg_match( '/^END/', $res ) ) {
647  break;
648  }
649  if ( strlen( $res ) == 0 ) {
650  break;
651  }
652  }
653  return $ret;
654  }
655 
656  // }}}
657  // {{{ set()
658 
673  public function set( $key, $value, $exp = 0 ) {
674  return $this->_set( 'set', $key, $value, $exp );
675  }
676 
677  // }}}
678  // {{{ cas()
679 
695  public function cas( $casToken, $key, $value, $exp = 0 ) {
696  return $this->_set( 'cas', $key, $value, $exp, $casToken );
697  }
698 
699  // }}}
700  // {{{ set_compress_threshold()
701 
707  public function set_compress_threshold( $thresh ) {
708  $this->_compress_threshold = $thresh;
709  }
710 
711  // }}}
712  // {{{ set_debug()
713 
720  public function set_debug( $dbg ) {
721  $this->_debug = $dbg;
722  }
723 
724  // }}}
725  // {{{ set_servers()
726 
733  public function set_servers( $list ) {
734  $this->_servers = $list;
735  $this->_active = count( $list );
736  $this->_buckets = null;
737  $this->_bucketcount = 0;
738 
739  $this->_single_sock = null;
740  if ( $this->_active == 1 ) {
741  $this->_single_sock = $this->_servers[0];
742  }
743  }
744 
751  public function set_timeout( $seconds, $microseconds ) {
752  $this->_timeout_seconds = $seconds;
753  $this->_timeout_microseconds = $microseconds;
754  }
755 
756  // }}}
757  // }}}
758  // {{{ private methods
759  // {{{ _close_sock()
760 
768  function _close_sock( $sock ) {
769  $host = array_search( $sock, $this->_cache_sock );
770  fclose( $this->_cache_sock[$host] );
771  unset( $this->_cache_sock[$host] );
772  }
773 
774  // }}}
775  // {{{ _connect_sock()
776 
786  function _connect_sock( &$sock, $host ) {
787  list( $ip, $port ) = preg_split( '/:(?=\d)/', $host );
788  $sock = false;
789  $timeout = $this->_connect_timeout;
790  $errno = $errstr = null;
791  for ( $i = 0; !$sock && $i < $this->_connect_attempts; $i++ ) {
792  MediaWiki\suppressWarnings();
793  if ( $this->_persistent == 1 ) {
794  $sock = pfsockopen( $ip, $port, $errno, $errstr, $timeout );
795  } else {
796  $sock = fsockopen( $ip, $port, $errno, $errstr, $timeout );
797  }
798  MediaWiki\restoreWarnings();
799  }
800  if ( !$sock ) {
801  $this->_error_log( "Error connecting to $host: $errstr" );
802  $this->_dead_host( $host );
803  return false;
804  }
805 
806  // Initialise timeout
807  stream_set_timeout( $sock, $this->_timeout_seconds, $this->_timeout_microseconds );
808 
809  // If the connection was persistent, flush the read buffer in case there
810  // was a previous incomplete request on this connection
811  if ( $this->_persistent ) {
812  $this->_flush_read_buffer( $sock );
813  }
814  return true;
815  }
816 
817  // }}}
818  // {{{ _dead_sock()
819 
827  function _dead_sock( $sock ) {
828  $host = array_search( $sock, $this->_cache_sock );
829  $this->_dead_host( $host );
830  }
831 
835  function _dead_host( $host ) {
836  $ip = explode( ':', $host )[0];
837  $this->_host_dead[$ip] = time() + 30 + intval( rand( 0, 10 ) );
838  $this->_host_dead[$host] = $this->_host_dead[$ip];
839  unset( $this->_cache_sock[$host] );
840  }
841 
842  // }}}
843  // {{{ get_sock()
844 
853  function get_sock( $key ) {
854  if ( !$this->_active ) {
855  return false;
856  }
857 
858  if ( $this->_single_sock !== null ) {
859  return $this->sock_to_host( $this->_single_sock );
860  }
861 
862  $hv = is_array( $key ) ? intval( $key[0] ) : $this->_hashfunc( $key );
863  if ( $this->_buckets === null ) {
864  $bu = array();
865  foreach ( $this->_servers as $v ) {
866  if ( is_array( $v ) ) {
867  for ( $i = 0; $i < $v[1]; $i++ ) {
868  $bu[] = $v[0];
869  }
870  } else {
871  $bu[] = $v;
872  }
873  }
874  $this->_buckets = $bu;
875  $this->_bucketcount = count( $bu );
876  }
877 
878  $realkey = is_array( $key ) ? $key[1] : $key;
879  for ( $tries = 0; $tries < 20; $tries++ ) {
880  $host = $this->_buckets[$hv % $this->_bucketcount];
881  $sock = $this->sock_to_host( $host );
882  if ( is_resource( $sock ) ) {
883  return $sock;
884  }
885  $hv = $this->_hashfunc( $hv . $realkey );
886  }
887 
888  return false;
889  }
890 
891  // }}}
892  // {{{ _hashfunc()
893 
902  function _hashfunc( $key ) {
903  # Hash function must be in [0,0x7ffffff]
904  # We take the first 31 bits of the MD5 hash, which unlike the hash
905  # function used in a previous version of this client, works
906  return hexdec( substr( md5( $key ), 0, 8 ) ) & 0x7fffffff;
907  }
908 
909  // }}}
910  // {{{ _incrdecr()
911 
922  function _incrdecr( $cmd, $key, $amt = 1 ) {
923  if ( !$this->_active ) {
924  return null;
925  }
926 
927  $sock = $this->get_sock( $key );
928  if ( !is_resource( $sock ) ) {
929  return null;
930  }
931 
932  $key = is_array( $key ) ? $key[1] : $key;
933  if ( isset( $this->stats[$cmd] ) ) {
934  $this->stats[$cmd]++;
935  } else {
936  $this->stats[$cmd] = 1;
937  }
938  if ( !$this->_fwrite( $sock, "$cmd $key $amt\r\n" ) ) {
939  return null;
940  }
941 
942  $line = $this->_fgets( $sock );
943  $match = array();
944  if ( !preg_match( '/^(\d+)/', $line, $match ) ) {
945  return null;
946  }
947  return $match[1];
948  }
949 
950  // }}}
951  // {{{ _load_items()
952 
963  function _load_items( $sock, &$ret, &$casToken = null ) {
964  $results = array();
965 
966  while ( 1 ) {
967  $decl = $this->_fgets( $sock );
968 
969  if ( $decl === false ) {
970  /*
971  * If nothing can be read, something is wrong because we know exactly when
972  * to stop reading (right after "END") and we return right after that.
973  */
974  return false;
975  } elseif ( preg_match( '/^VALUE (\S+) (\d+) (\d+) (\d+)$/', $decl, $match ) ) {
976  /*
977  * Read all data returned. This can be either one or multiple values.
978  * Save all that data (in an array) to be processed later: we'll first
979  * want to continue reading until "END" before doing anything else,
980  * to make sure that we don't leave our client in a state where it's
981  * output is not yet fully read.
982  */
983  $results[] = array(
984  $match[1], // rkey
985  $match[2], // flags
986  $match[3], // len
987  $match[4], // casToken
988  $this->_fread( $sock, $match[3] + 2 ), // data
989  );
990  } elseif ( $decl == "END" ) {
991  if ( count( $results ) == 0 ) {
992  return false;
993  }
994 
999  foreach ( $results as $vars ) {
1000  list( $rkey, $flags, $len, $casToken, $data ) = $vars;
1001 
1002  if ( $data === false || substr( $data, -2 ) !== "\r\n" ) {
1003  $this->_handle_error( $sock,
1004  'line ending missing from data block from $1' );
1005  return false;
1006  }
1007  $data = substr( $data, 0, -2 );
1008  $ret[$rkey] = $data;
1009 
1010  if ( $this->_have_zlib && $flags & self::COMPRESSED ) {
1011  $ret[$rkey] = gzuncompress( $ret[$rkey] );
1012  }
1013 
1014  /*
1015  * This unserialize is the exact reason that we only want to
1016  * process data after having read until "END" (instead of doing
1017  * this right away): "unserialize" can trigger outside code:
1018  * in the event that $ret[$rkey] is a serialized object,
1019  * unserializing it will trigger __wakeup() if present. If that
1020  * function attempted to read from memcached (while we did not
1021  * yet read "END"), these 2 calls would collide.
1022  */
1023  if ( $flags & self::SERIALIZED ) {
1024  $ret[$rkey] = unserialize( $ret[$rkey] );
1025  } elseif ( $flags & self::INTVAL ) {
1026  $ret[$rkey] = intval( $ret[$rkey] );
1027  }
1028  }
1029 
1030  return true;
1031  } else {
1032  $this->_handle_error( $sock, 'Error parsing response from $1' );
1033  return false;
1034  }
1035  }
1036  }
1037 
1038  // }}}
1039  // {{{ _set()
1040 
1057  function _set( $cmd, $key, $val, $exp, $casToken = null ) {
1058  if ( !$this->_active ) {
1059  return false;
1060  }
1061 
1062  $sock = $this->get_sock( $key );
1063  if ( !is_resource( $sock ) ) {
1064  return false;
1065  }
1066 
1067  if ( isset( $this->stats[$cmd] ) ) {
1068  $this->stats[$cmd]++;
1069  } else {
1070  $this->stats[$cmd] = 1;
1071  }
1072 
1073  $flags = 0;
1074 
1075  if ( is_int( $val ) ) {
1076  $flags |= self::INTVAL;
1077  } elseif ( !is_scalar( $val ) ) {
1078  $val = serialize( $val );
1079  $flags |= self::SERIALIZED;
1080  if ( $this->_debug ) {
1081  $this->_debugprint( sprintf( "client: serializing data as it is not scalar" ) );
1082  }
1083  }
1084 
1085  $len = strlen( $val );
1086 
1087  if ( $this->_have_zlib && $this->_compress_enable
1088  && $this->_compress_threshold && $len >= $this->_compress_threshold
1089  ) {
1090  $c_val = gzcompress( $val, 9 );
1091  $c_len = strlen( $c_val );
1092 
1093  if ( $c_len < $len * ( 1 - self::COMPRESSION_SAVINGS ) ) {
1094  if ( $this->_debug ) {
1095  $this->_debugprint( sprintf( "client: compressing data; was %d bytes is now %d bytes", $len, $c_len ) );
1096  }
1097  $val = $c_val;
1098  $len = $c_len;
1099  $flags |= self::COMPRESSED;
1100  }
1101  }
1102 
1103  $command = "$cmd $key $flags $exp $len";
1104  if ( $casToken ) {
1105  $command .= " $casToken";
1106  }
1107 
1108  if ( !$this->_fwrite( $sock, "$command\r\n$val\r\n" ) ) {
1109  return false;
1110  }
1111 
1112  $line = $this->_fgets( $sock );
1113 
1114  if ( $this->_debug ) {
1115  $this->_debugprint( sprintf( "%s %s (%s)", $cmd, $key, $line ) );
1116  }
1117  if ( $line == "STORED" ) {
1118  return true;
1119  }
1120  return false;
1121  }
1122 
1123  // }}}
1124  // {{{ sock_to_host()
1125 
1134  function sock_to_host( $host ) {
1135  if ( isset( $this->_cache_sock[$host] ) ) {
1136  return $this->_cache_sock[$host];
1137  }
1138 
1139  $sock = null;
1140  $now = time();
1141  list( $ip, /* $port */) = explode( ':', $host );
1142  if ( isset( $this->_host_dead[$host] ) && $this->_host_dead[$host] > $now ||
1143  isset( $this->_host_dead[$ip] ) && $this->_host_dead[$ip] > $now
1144  ) {
1145  return null;
1146  }
1147 
1148  if ( !$this->_connect_sock( $sock, $host ) ) {
1149  return null;
1150  }
1151 
1152  // Do not buffer writes
1153  stream_set_write_buffer( $sock, 0 );
1154 
1155  $this->_cache_sock[$host] = $sock;
1156 
1157  return $this->_cache_sock[$host];
1158  }
1159 
1163  function _debugprint( $text ) {
1164  $this->_logger->debug( $text );
1165  }
1166 
1170  function _error_log( $text ) {
1171  $this->_logger->error( "Memcached error: $text" );
1172  }
1173 
1181  function _fwrite( $sock, $buf ) {
1182  $bytesWritten = 0;
1183  $bufSize = strlen( $buf );
1184  while ( $bytesWritten < $bufSize ) {
1185  $result = fwrite( $sock, $buf );
1186  $data = stream_get_meta_data( $sock );
1187  if ( $data['timed_out'] ) {
1188  $this->_handle_error( $sock, 'timeout writing to $1' );
1189  return false;
1190  }
1191  // Contrary to the documentation, fwrite() returns zero on error in PHP 5.3.
1192  if ( $result === false || $result === 0 ) {
1193  $this->_handle_error( $sock, 'error writing to $1' );
1194  return false;
1195  }
1196  $bytesWritten += $result;
1197  }
1198 
1199  return true;
1200  }
1201 
1208  function _handle_error( $sock, $msg ) {
1209  $peer = stream_socket_get_name( $sock, true );
1210  if ( strval( $peer ) === '' ) {
1211  $peer = array_search( $sock, $this->_cache_sock );
1212  if ( $peer === false ) {
1213  $peer = '[unknown host]';
1214  }
1215  }
1216  $msg = str_replace( '$1', $peer, $msg );
1217  $this->_error_log( "$msg" );
1218  $this->_dead_sock( $sock );
1219  }
1220 
1229  function _fread( $sock, $len ) {
1230  $buf = '';
1231  while ( $len > 0 ) {
1232  $result = fread( $sock, $len );
1233  $data = stream_get_meta_data( $sock );
1234  if ( $data['timed_out'] ) {
1235  $this->_handle_error( $sock, 'timeout reading from $1' );
1236  return false;
1237  }
1238  if ( $result === false ) {
1239  $this->_handle_error( $sock, 'error reading buffer from $1' );
1240  return false;
1241  }
1242  if ( $result === '' ) {
1243  // This will happen if the remote end of the socket is shut down
1244  $this->_handle_error( $sock, 'unexpected end of file reading from $1' );
1245  return false;
1246  }
1247  $len -= strlen( $result );
1248  $buf .= $result;
1249  }
1250  return $buf;
1251  }
1252 
1260  function _fgets( $sock ) {
1261  $result = fgets( $sock );
1262  // fgets() may return a partial line if there is a select timeout after
1263  // a successful recv(), so we have to check for a timeout even if we
1264  // got a string response.
1265  $data = stream_get_meta_data( $sock );
1266  if ( $data['timed_out'] ) {
1267  $this->_handle_error( $sock, 'timeout reading line from $1' );
1268  return false;
1269  }
1270  if ( $result === false ) {
1271  $this->_handle_error( $sock, 'error reading line from $1' );
1272  return false;
1273  }
1274  if ( substr( $result, -2 ) === "\r\n" ) {
1275  $result = substr( $result, 0, -2 );
1276  } elseif ( substr( $result, -1 ) === "\n" ) {
1277  $result = substr( $result, 0, -1 );
1278  } else {
1279  $this->_handle_error( $sock, 'line ending missing in response from $1' );
1280  return false;
1281  }
1282  return $result;
1283  }
1284 
1289  function _flush_read_buffer( $f ) {
1290  if ( !is_resource( $f ) ) {
1291  return;
1292  }
1293  $r = array( $f );
1294  $w = null;
1295  $e = null;
1296  $n = stream_select( $r, $w, $e, 0, 0 );
1297  while ( $n == 1 && !feof( $f ) ) {
1298  fread( $f, 1024 );
1299  $r = array( $f );
1300  $w = null;
1301  $e = null;
1302  $n = stream_select( $r, $w, $e, 0, 0 );
1303  }
1304  }
1305 
1306  // }}}
1307  // }}}
1308  // }}}
1309 }
1310 
1311 // }}}
set_servers($list)
Set the server list to distribute key gets and puts between.
set_timeout($seconds, $microseconds)
Sets the timeout for new connections.
_fwrite($sock, $buf)
Write to a stream.
deferred txt A few of the database updates required by various functions here can be deferred until after the result page is displayed to the user For updating the view updating the linked to tables after a etc PHP does not yet have any way to tell the server to actually return and disconnect while still running these but it might have such a feature in the future We handle these by creating a deferred update object and putting those objects on a global list
Definition: deferred.txt:11
lock($key, $timeout=0)
the array() calling protocol came about after MediaWiki 1.4rc1.
_handle_error($sock, $msg)
Handle an I/O error.
array $stats
Command statistics.
get_sock($key)
get_sock
memcached client class implemented using (p)fsockopen()
get_multi($keys)
Get multiple keys from the server(s)
array $_host_dead
Dead hosts, assoc array, 'host'=>'unixtime when ok to check again'.
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses & $ret
Definition: hooks.txt:1936
Apache License January AND DISTRIBUTION Definitions License shall mean the terms and conditions for use
div flags Integer display flags(NO_ACTION_LINK, NO_EXTRA_USER_LINKS) 'LogException'returning false will NOT prevent logging $e
Definition: hooks.txt:2102
$command
Definition: cdb.php:65
const INTVAL
Flag: indicates data is an integer.
$value
incr($key, $amt=1)
Increments $key (optionally) by $amt.
_load_items($sock, &$ret, &$casToken=null)
Load items into $ret from $sock.
it s the revision text itself In either if gzip is the revision text is gzipped $flags
Definition: hooks.txt:2703
forget_dead_hosts()
Forget about all of the dead hosts.
$_connect_timeout
Connect timeout in seconds.
_dead_sock($sock)
Marks a host as dead until 30-40 seconds in the future.
disconnect_all()
Disconnects all connected sockets.
int $_timeout_microseconds
Stream timeout in microseconds.
_fread($sock, $len)
Read the specified number of bytes from a stream.
bool $_have_zlib
Is compression available?
_connect_sock(&$sock, $host)
Connects $sock to $host, timing out after $timeout.
The index of the header message $result[1]=The index of the body text message $result[2 through n]=Parameters passed to body text message.Please note the header message cannot receive/use parameters. 'ImportHandleLogItemXMLTag':When parsing a XML tag in a log item.Return false to stop further processing of the tag $reader:XMLReader object $logInfo:Array of information 'ImportHandlePageXMLTag':When parsing a XML tag in a page.Return false to stop further processing of the tag $reader:XMLReader object &$pageInfo:Array of information 'ImportHandleRevisionXMLTag':When parsing a XML tag in a page revision.Return false to stop further processing of the tag $reader:XMLReader object $pageInfo:Array of page information $revisionInfo:Array of revision information 'ImportHandleToplevelXMLTag':When parsing a top level XML tag.Return false to stop further processing of the tag $reader:XMLReader object 'ImportHandleUploadXMLTag':When parsing a XML tag in a file upload.Return false to stop further processing of the tag $reader:XMLReader object $revisionInfo:Array of information 'ImportLogInterwikiLink':Hook to change the interwiki link used in log entries and edit summaries for transwiki imports.&$fullInterwikiPrefix:Interwiki prefix, may contain colons.&$pageTitle:String that contains page title. 'ImportSources':Called when reading from the $wgImportSources configuration variable.Can be used to lazy-load the import sources list.&$importSources:The value of $wgImportSources.Modify as necessary.See the comment in DefaultSettings.php for the detail of how to structure this array. 'InfoAction':When building information to display on the action=info page.$context:IContextSource object &$pageInfo:Array of information 'InitializeArticleMaybeRedirect':MediaWiki check to see if title is a redirect.&$title:Title object for the current page &$request:WebRequest &$ignoreRedirect:boolean to skip redirect check &$target:Title/string of redirect target &$article:Article object 'InternalParseBeforeLinks':during Parser's internalParse method before links but after nowiki/noinclude/includeonly/onlyinclude and other processings.&$parser:Parser object &$text:string containing partially parsed text &$stripState:Parser's internal StripState object 'InternalParseBeforeSanitize':during Parser's internalParse method just before the parser removes unwanted/dangerous HTML tags and after nowiki/noinclude/includeonly/onlyinclude and other processings.Ideal for syntax-extensions after template/parser function execution which respect nowiki and HTML-comments.&$parser:Parser object &$text:string containing partially parsed text &$stripState:Parser's internal StripState object 'InterwikiLoadPrefix':When resolving if a given prefix is an interwiki or not.Return true without providing an interwiki to continue interwiki search.$prefix:interwiki prefix we are looking for.&$iwData:output array describing the interwiki with keys iw_url, iw_local, iw_trans and optionally iw_api and iw_wikiid. 'InvalidateEmailComplete':Called after a user's email has been invalidated successfully.$user:user(object) whose email is being invalidated 'IRCLineURL':When constructing the URL to use in an IRC notification.Callee may modify $url and $query, URL will be constructed as $url.$query &$url:URL to index.php &$query:Query string $rc:RecentChange object that triggered url generation 'IsFileCacheable':Override the result of Article::isFileCacheable()(if true) &$article:article(object) being checked 'IsTrustedProxy':Override the result of IP::isTrustedProxy() &$ip:IP being check &$result:Change this value to override the result of IP::isTrustedProxy() 'IsUploadAllowedFromUrl':Override the result of UploadFromUrl::isAllowedUrl() $url:URL used to upload from &$allowed:Boolean indicating if uploading is allowed for given URL 'isValidEmailAddr':Override the result of Sanitizer::validateEmail(), for instance to return false if the domain name doesn't match your organization.$addr:The e-mail address entered by the user &$result:Set this and return false to override the internal checks 'isValidPassword':Override the result of User::isValidPassword() $password:The password entered by the user &$result:Set this and return false to override the internal checks $user:User the password is being validated for 'Language::getMessagesFileName':$code:The language code or the language we're looking for a messages file for &$file:The messages file path, you can override this to change the location. 'LanguageGetMagic':DEPRECATED!Use $magicWords in a file listed in $wgExtensionMessagesFiles instead.Use this to define synonyms of magic words depending of the language &$magicExtensions:associative array of magic words synonyms $lang:language code(string) 'LanguageGetNamespaces':Provide custom ordering for namespaces or remove namespaces.Do not use this hook to add namespaces.Use CanonicalNamespaces for that.&$namespaces:Array of namespaces indexed by their numbers 'LanguageGetSpecialPageAliases':DEPRECATED!Use $specialPageAliases in a file listed in $wgExtensionMessagesFiles instead.Use to define aliases of special pages names depending of the language &$specialPageAliases:associative array of magic words synonyms $lang:language code(string) 'LanguageGetTranslatedLanguageNames':Provide translated language names.&$names:array of language code=> language name $code:language of the preferred translations 'LanguageLinks':Manipulate a page's language links.This is called in various places to allow extensions to define the effective language links for a page.$title:The page's Title.&$links:Associative array mapping language codes to prefixed links of the form"language:title".&$linkFlags:Associative array mapping prefixed links to arrays of flags.Currently unused, but planned to provide support for marking individual language links in the UI, e.g.for featured articles. 'LanguageSelector':Hook to change the language selector available on a page.$out:The output page.$cssClassName:CSS class name of the language selector. 'LinkBegin':DEPRECATED!Use HtmlPageLinkRendererBegin instead.Used when generating internal and interwiki links in Linker::link(), before processing starts.Return false to skip default processing and return $ret.See documentation for Linker::link() for details on the expected meanings of parameters.$skin:the Skin object $target:the Title that the link is pointing to &$html:the contents that the< a > tag should have(raw HTML) $result
Definition: hooks.txt:1934
if($line===false) $args
Definition: cdb.php:64
int $_timeout_seconds
Stream timeout in seconds.
_fgets($sock)
Read a line from a stream.
set($key, $value, $exp=0)
Unconditionally sets a key to a given value in the memcache.
int $_compress_threshold
At how many bytes should we compress?
bool $_persistent
Are we using persistent links?
unserialize($serialized)
Definition: ApiMessage.php:102
$res
Definition: database.txt:21
const SERIALIZED
Flag: indicates data is serialized.
enable_compress($enable)
Enable / Disable compression.
set_compress_threshold($thresh)
Set the compression threshold.
add($key, $val, $exp=0)
Adds a key/value to the memcache server if one isn't already set with that key.
cas($casToken, $key, $value, $exp=0)
Sets a key to a given value in the memcache if the current value still corresponds to a known...
array $_servers
Array containing ip:port or array(ip:port, weight)
set_debug($dbg)
Set the debug flag.
bool $_debug
Current debug status; 0 - none to 9 - profiling.
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:9
__construct($args)
Memcache initializer.
array $_buckets
Our bit buckets.
touch($key, $time=0)
Changes the TTL on a key from the server to $time.
string $_single_sock
If only using one server; contains ip:port to connect to.
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:35
_flush_read_buffer($f)
Flush the read buffer of a stream.
int $_active
of total servers we have
_set($cmd, $key, $val, $exp, $casToken=null)
Performs the requested storage operation to the memcache server.
bool $_compress_enable
Do we want to use compression?
$line
Definition: cdb.php:59
_close_sock($sock)
Close the specified socket.
replace($key, $value, $exp=0)
Overwrites an existing value for key; only works if key is already set.
array $_cache_sock
Cached Sockets that are connected.
const COMPRESSED
Flag: indicates data is compressed.
run_command($sock, $cmd)
Passes through $cmd to the memcache server connected by $sock; returns output as an array (null array...
_hashfunc($key)
Creates a hash integer based on the $key.
serialize()
Definition: ApiMessage.php:94
const COMPRESSION_SAVINGS
Minimum savings to store data compressed.
sock_to_host($host)
Returns the socket for the host.
int $_bucketcount
Total # of bit buckets we have.
static configuration should be added through ResourceLoaderGetConfigVars instead & $vars
Definition: hooks.txt:2159
see documentation in includes Linker php for Linker::makeImageLink & $time
Definition: hooks.txt:1749
$_connect_attempts
Number of connection attempts for each server.
decr($key, $amt=1)
Decrease a value stored on the memcache server.
_incrdecr($cmd, $key, $amt=1)
Perform increment/decriment on $key.
LoggerInterface $_logger