PHP IP::splitHostAndPort方法代码示例

 /**
  * @param string $realServer
  * @return bool|mysqli
  * @throws DBConnectionError
  */
 protected function mysqlConnect($realServer)
 {
     global $wgDBmysql5;
     # Fail now
     # Otherwise we get a suppressed fatal error, which is very hard to track down
     if (!function_exists('mysqli_init')) {
         throw new DBConnectionError($this, "MySQLi functions missing," . " have you compiled PHP with the --with-mysqli option?\n");
     }
     // Other than mysql_connect, mysqli_real_connect expects an explicit port
     // and socket parameters. So we need to parse the port and socket out of
     // $realServer
     $port = null;
     $socket = null;
     $hostAndPort = IP::splitHostAndPort($realServer);
     if ($hostAndPort) {
         $realServer = $hostAndPort[0];
         if ($hostAndPort[1]) {
             $port = $hostAndPort[1];
         }
     } elseif (substr_count($realServer, ':') == 1) {
         // If we have a colon and something that's not a port number
         // inside the hostname, assume it's the socket location
         $hostAndSocket = explode(':', $realServer);
         $realServer = $hostAndSocket[0];
         $socket = $hostAndSocket[1];
     }
     $connFlags = 0;
     if ($this->mFlags & DBO_SSL) {
         $connFlags |= MYSQLI_CLIENT_SSL;
     }
     if ($this->mFlags & DBO_COMPRESS) {
         $connFlags |= MYSQLI_CLIENT_COMPRESS;
     }
     if ($this->mFlags & DBO_PERSISTENT) {
         $realServer = 'p:' . $realServer;
     }
     $mysqli = mysqli_init();
     if ($wgDBmysql5) {
         // Tell the server we're communicating with it in UTF-8.
         // This may engage various charset conversions.
         $mysqli->options(MYSQLI_SET_CHARSET_NAME, 'utf8');
     } else {
         $mysqli->options(MYSQLI_SET_CHARSET_NAME, 'binary');
     }
     $numAttempts = 2;
     for ($i = 0; $i < $numAttempts; $i++) {
         if ($i > 1) {
             usleep(1000);
         }
         if ($mysqli->real_connect($realServer, $this->mUser, $this->mPassword, $this->mDBname, $port, $socket, $connFlags)) {
             return $mysqli;
         }
     }
     return false;
 }

 /**
  * @param string $realServer
  * @return bool|mysqli
  * @throws DBConnectionError
  */
 protected function mysqlConnect($realServer)
 {
     # Avoid suppressed fatal error, which is very hard to track down
     if (!function_exists('mysqli_init')) {
         throw new DBConnectionError($this, "MySQLi functions missing," . " have you compiled PHP with the --with-mysqli option?\n");
     }
     // Other than mysql_connect, mysqli_real_connect expects an explicit port
     // and socket parameters. So we need to parse the port and socket out of
     // $realServer
     $port = null;
     $socket = null;
     $hostAndPort = IP::splitHostAndPort($realServer);
     if ($hostAndPort) {
         $realServer = $hostAndPort[0];
         if ($hostAndPort[1]) {
             $port = $hostAndPort[1];
         }
     } elseif (substr_count($realServer, ':') == 1) {
         // If we have a colon and something that's not a port number
         // inside the hostname, assume it's the socket location
         $hostAndSocket = explode(':', $realServer);
         $realServer = $hostAndSocket[0];
         $socket = $hostAndSocket[1];
     }
     $mysqli = mysqli_init();
     $connFlags = 0;
     if ($this->mFlags & self::DBO_SSL) {
         $connFlags |= MYSQLI_CLIENT_SSL;
         $mysqli->ssl_set($this->sslKeyPath, $this->sslCertPath, null, $this->sslCAPath, $this->sslCiphers);
     }
     if ($this->mFlags & self::DBO_COMPRESS) {
         $connFlags |= MYSQLI_CLIENT_COMPRESS;
     }
     if ($this->mFlags & self::DBO_PERSISTENT) {
         $realServer = 'p:' . $realServer;
     }
     if ($this->utf8Mode) {
         // Tell the server we're communicating with it in UTF-8.
         // This may engage various charset conversions.
         $mysqli->options(MYSQLI_SET_CHARSET_NAME, 'utf8');
     } else {
         $mysqli->options(MYSQLI_SET_CHARSET_NAME, 'binary');
     }
     $mysqli->options(MYSQLI_OPT_CONNECT_TIMEOUT, 3);
     if ($mysqli->real_connect($realServer, $this->mUser, $this->mPassword, $this->mDBname, $port, $socket, $connFlags)) {
         return $mysqli;
     }
     return false;
 }

	protected function mysqlConnect( $realServer ) {
		# Fail now
		# Otherwise we get a suppressed fatal error, which is very hard to track down
		if ( !function_exists( 'mysqli_init' ) ) {
			throw new DBConnectionError( $this, "MySQLi functions missing,"
				. " have you compiled PHP with the --with-mysqli option?\n" );
		}

		// Other than mysql_connect, mysqli_real_connect expects an explicit port
		// parameter. So we need to parse the port out of $realServer
		$port = null;
		$hostAndPort = IP::splitHostAndPort( $realServer );
		if ( $hostAndPort ) {
			$realServer = $hostAndPort[0];
			if ( $hostAndPort[1] ) {
				$port = $hostAndPort[1];
			}
		}

		$connFlags = 0;
		if ( $this->mFlags & DBO_SSL ) {
			$connFlags |= MYSQLI_CLIENT_SSL;
		}
		if ( $this->mFlags & DBO_COMPRESS ) {
			$connFlags |= MYSQLI_CLIENT_COMPRESS;
		}
		if ( $this->mFlags & DBO_PERSISTENT ) {
			$realServer = 'p:' . $realServer;
		}

		$mysqli = mysqli_init();
		$numAttempts = 2;

		for ( $i = 0; $i < $numAttempts; $i++ ) {
			if ( $i > 1 ) {
				usleep( 1000 );
			}
			if ( $mysqli->real_connect( $realServer, $this->mUser,
				$this->mPassword, $this->mDBname, $port, null, $connFlags ) )
			{
				return $mysqli;
			}
		}

		return false;
	}

 /**
  * Work out an appropriate URL prefix containing scheme and host, based on
  * information detected from $_SERVER
  *
  * @return string
  */
 public static function detectServer()
 {
     list($proto, $stdPort) = self::detectProtocolAndStdPort();
     $varNames = array('HTTP_HOST', 'SERVER_NAME', 'HOSTNAME', 'SERVER_ADDR');
     $host = 'localhost';
     $port = $stdPort;
     foreach ($varNames as $varName) {
         if (!isset($_SERVER[$varName])) {
             continue;
         }
         $parts = IP::splitHostAndPort($_SERVER[$varName]);
         if (!$parts) {
             // Invalid, do not use
             continue;
         }
         $host = $parts[0];
         if ($parts[1] === false) {
             if (isset($_SERVER['SERVER_PORT'])) {
                 $port = $_SERVER['SERVER_PORT'];
             }
             // else leave it as $stdPort
         } else {
             $port = $parts[1];
         }
         break;
     }
     return $proto . '://' . IP::combineHostAndPort($host, $port, $stdPort);
 }

 /**
  * Test for IP::splitHostAndPort().
  * @dataProvider provideSplitHostAndPort
  */
 function testSplitHostAndPort($expected, $input, $description)
 {
     $this->assertEquals($expected, IP::splitHostAndPort($input), $description);
 }

 /**
  * Get a connection to a redis server. Based on code in RedisBagOStuff.php.
  *
  * @param string $server A hostname/port combination or the absolute path of a UNIX socket.
  *                       If a hostname is specified but no port, port 6379 will be used.
  * @return RedisConnRef|bool Returns false on failure
  * @throws MWException
  */
 public function getConnection($server)
 {
     // Check the listing "dead" servers which have had a connection errors.
     // Servers are marked dead for a limited period of time, to
     // avoid excessive overhead from repeated connection timeouts.
     if (isset($this->downServers[$server])) {
         $now = time();
         if ($now > $this->downServers[$server]) {
             // Dead time expired
             unset($this->downServers[$server]);
         } else {
             // Server is dead
             $this->logger->debug('Server "{redis_server}" is marked down for another ' . ($this->downServers[$server] - $now) . 'seconds', array('redis_server' => $server));
             return false;
         }
     }
     // Check if a connection is already free for use
     if (isset($this->connections[$server])) {
         foreach ($this->connections[$server] as &$connection) {
             if ($connection['free']) {
                 $connection['free'] = false;
                 --$this->idlePoolSize;
                 return new RedisConnRef($this, $server, $connection['conn'], $this->logger);
             }
         }
     }
     if (substr($server, 0, 1) === '/') {
         // UNIX domain socket
         // These are required by the redis extension to start with a slash, but
         // we still need to set the port to a special value to make it work.
         $host = $server;
         $port = 0;
     } else {
         // TCP connection
         $hostPort = IP::splitHostAndPort($server);
         if (!$server || !$hostPort) {
             throw new MWException(__CLASS__ . ": invalid configured server \"{$server}\"");
         }
         list($host, $port) = $hostPort;
         if ($port === false) {
             $port = 6379;
         }
     }
     $conn = new Redis();
     try {
         if ($this->persistent) {
             $result = $conn->pconnect($host, $port, $this->connectTimeout);
         } else {
             $result = $conn->connect($host, $port, $this->connectTimeout);
         }
         if (!$result) {
             $this->logger->error('Could not connect to server "{redis_server}"', array('redis_server' => $server));
             // Mark server down for some time to avoid further timeouts
             $this->downServers[$server] = time() + self::SERVER_DOWN_TTL;
             return false;
         }
         if ($this->password !== null) {
             if (!$conn->auth($this->password)) {
                 $this->logger->error('Authentication error connecting to "{redis_server}"', array('redis_server' => $server));
             }
         }
     } catch (RedisException $e) {
         $this->downServers[$server] = time() + self::SERVER_DOWN_TTL;
         $this->logger->error('Redis exception connecting to "{redis_server}"', array('redis_server' => $server, 'exception' => $e));
         return false;
     }
     if ($conn) {
         $conn->setOption(Redis::OPT_READ_TIMEOUT, $this->readTimeout);
         $conn->setOption(Redis::OPT_SERIALIZER, $this->serializer);
         $this->connections[$server][] = array('conn' => $conn, 'free' => false);
         return new RedisConnRef($this, $server, $conn, $this->logger);
     } else {
         return false;
     }
 }

 /**
  * Work out an appropriate URL prefix containing scheme and host, based on
  * information detected from $_SERVER
  *
  * @return string
  */
 public static function detectServer()
 {
     global $wgAssumeProxiesUseDefaultProtocolPorts;
     $proto = self::detectProtocol();
     $stdPort = $proto === 'https' ? 443 : 80;
     $varNames = array('HTTP_HOST', 'SERVER_NAME', 'HOSTNAME', 'SERVER_ADDR');
     $host = 'localhost';
     $port = $stdPort;
     foreach ($varNames as $varName) {
         if (!isset($_SERVER[$varName])) {
             continue;
         }
         $parts = IP::splitHostAndPort($_SERVER[$varName]);
         if (!$parts) {
             // Invalid, do not use
             continue;
         }
         $host = $parts[0];
         if ($wgAssumeProxiesUseDefaultProtocolPorts && isset($_SERVER['HTTP_X_FORWARDED_PROTO'])) {
             // Bug 70021: Assume that upstream proxy is running on the default
             // port based on the protocol. We have no reliable way to determine
             // the actual port in use upstream.
             $port = $stdPort;
         } elseif ($parts[1] === false) {
             if (isset($_SERVER['SERVER_PORT'])) {
                 $port = $_SERVER['SERVER_PORT'];
             }
             // else leave it as $stdPort
         } else {
             $port = $parts[1];
         }
         break;
     }
     return $proto . '://' . IP::combineHostAndPort($host, $port, $stdPort);
 }

 /**
  * Get a connection to the server with the specified name. Connections
  * are cached, and failures are persistent to avoid multiple timeouts.
  *
  * @param $server
  * @throws MWException
  * @return Redis object, or false on failure
  */
 protected function getConnectionToServer($server)
 {
     if (isset($this->deadServers[$server])) {
         $now = time();
         if ($now > $this->deadServers[$server]) {
             // Dead time expired
             unset($this->deadServers[$server]);
         } else {
             // Server is dead
             $this->debug("server {$server} is marked down for another " . ($this->deadServers[$server] - $now) . " seconds, can't get connection");
             return false;
         }
     }
     if (isset($this->conns[$server])) {
         return $this->conns[$server];
     }
     if (substr($server, 0, 1) === '/') {
         // UNIX domain socket
         // These are required by the redis extension to start with a slash, but
         // we still need to set the port to a special value to make it work.
         $host = $server;
         $port = 0;
     } else {
         // TCP connection
         $hostPort = IP::splitHostAndPort($server);
         if (!$hostPort) {
             throw new MWException(__CLASS__ . ": invalid configured server \"{$server}\"");
         }
         list($host, $port) = $hostPort;
         if ($port === false) {
             $port = 6379;
         }
     }
     $conn = new Redis();
     try {
         if ($this->persistent) {
             $this->debug("opening persistent connection to {$host}:{$port}");
             $result = $conn->pconnect($host, $port, $this->connectTimeout);
         } else {
             $this->debug("opening non-persistent connection to {$host}:{$port}");
             $result = $conn->connect($host, $port, $this->connectTimeout);
         }
         if (!$result) {
             $this->logError("could not connect to server {$server}");
             // Mark server down for 30s to avoid further timeouts
             $this->deadServers[$server] = time() + 30;
             return false;
         }
         if ($this->password !== null) {
             if (!$conn->auth($this->password)) {
                 $this->logError("authentication error connecting to {$server}");
             }
         }
     } catch (RedisException $e) {
         $this->deadServers[$server] = time() + 30;
         wfDebugLog('redis', "Redis exception: " . $e->getMessage() . "\n");
         return false;
     }
     $conn->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
     $this->conns[$server] = $conn;
     return $conn;
 }

 /**
  * Constructor
  *
  * Available parameters are:
  *   - servers:             The list of IP:port combinations holding the memcached servers.
  *   - persistent:          Whether to use a persistent connection
  *   - compress_threshold:  The minimum size an object must be before it is compressed
  *   - timeout:             The read timeout in microseconds
  *   - connect_timeout:     The connect timeout in seconds
  *   - retry_timeout:       Time in seconds to wait before retrying a failed connect attempt
  *   - server_failure_limit:  Limit for server connect failures before it is removed
  *   - serializer:          May be either "php" or "igbinary". Igbinary produces more compact
  *                          values, but serialization is much slower unless the php.ini option
  *                          igbinary.compact_strings is off.
  * @param array $params
  * @throws MWException
  */
 function __construct($params)
 {
     parent::__construct($params);
     $params = $this->applyDefaultParams($params);
     if ($params['persistent']) {
         // The pool ID must be unique to the server/option combination.
         // The Memcached object is essentially shared for each pool ID.
         // We can only reuse a pool ID if we keep the config consistent.
         $this->client = new Memcached(md5(serialize($params)));
         if (count($this->client->getServerList())) {
             $this->logger->debug(__METHOD__ . ": persistent Memcached object already loaded.");
             return;
             // already initialized; don't add duplicate servers
         }
     } else {
         $this->client = new Memcached();
     }
     if (!isset($params['serializer'])) {
         $params['serializer'] = 'php';
     }
     if (isset($params['retry_timeout'])) {
         $this->client->setOption(Memcached::OPT_RETRY_TIMEOUT, $params['retry_timeout']);
     }
     if (isset($params['server_failure_limit'])) {
         $this->client->setOption(Memcached::OPT_SERVER_FAILURE_LIMIT, $params['server_failure_limit']);
     }
     // The compression threshold is an undocumented php.ini option for some
     // reason. There's probably not much harm in setting it globally, for
     // compatibility with the settings for the PHP client.
     ini_set('memcached.compression_threshold', $params['compress_threshold']);
     // Set timeouts
     $this->client->setOption(Memcached::OPT_CONNECT_TIMEOUT, $params['connect_timeout'] * 1000);
     $this->client->setOption(Memcached::OPT_SEND_TIMEOUT, $params['timeout']);
     $this->client->setOption(Memcached::OPT_RECV_TIMEOUT, $params['timeout']);
     $this->client->setOption(Memcached::OPT_POLL_TIMEOUT, $params['timeout'] / 1000);
     // Set libketama mode since it's recommended by the documentation and
     // is as good as any. There's no way to configure libmemcached to use
     // hashes identical to the ones currently in use by the PHP client, and
     // even implementing one of the libmemcached hashes in pure PHP for
     // forwards compatibility would require MWMemcached::get_sock() to be
     // rewritten.
     $this->client->setOption(Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
     // Set the serializer
     switch ($params['serializer']) {
         case 'php':
             $this->client->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP);
             break;
         case 'igbinary':
             if (!Memcached::HAVE_IGBINARY) {
                 throw new MWException(__CLASS__ . ': the igbinary extension is not available ' . 'but igbinary serialization was requested.');
             }
             $this->client->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY);
             break;
         default:
             throw new MWException(__CLASS__ . ': invalid value for serializer parameter');
     }
     $servers = array();
     foreach ($params['servers'] as $host) {
         $servers[] = IP::splitHostAndPort($host);
         // (ip, port)
     }
     $this->client->addServers($servers);
 }

	/**
	 *
	 */
	protected function streamThumbnail() {
		global $wgVipsThumbnailerHost, $wgVipsTestExpiry;

		$request = $this->getRequest();

		# Validate title and file existance
		$title = Title::makeTitleSafe( NS_FILE, $request->getText( 'thumb' ) );
		if ( is_null( $title ) ) {
			$this->streamError( 404, "VipsScaler: invalid title\n" );
			return;
		}
		$file = wfFindFile( $title );
		if ( !$file || !$file->exists() ) {
			$this->streamError( 404, "VipsScaler: file not found\n" );
			return;
		}

		# Check if vips can handle this file
		if ( VipsScaler::getVipsHandler( $file ) === false ) {
			$this->streamError( 500, "VipsScaler: VIPS cannot handle this file type\n" );
			return;
		}

		# Validate param string
		$handler = $file->getHandler();
		$params = array( 'width' => $request->getInt( 'width' ) );
		if ( !$handler->normaliseParams( $file, $params ) ) {
			$this->streamError( 500, "VipsScaler: invalid parameters\n" );
			return;
		}

		# Get the thumbnail
		if ( is_null( $wgVipsThumbnailerHost ) || $request->getBool( 'noproxy' ) ) {
			# No remote scaler, need to do it ourselves.
			# Emulate the BitmapHandlerTransform hook

			$dstPath = VipsCommand::makeTemp( $file->getExtension() );
			$dstUrl = '';
			wfDebug( __METHOD__ . ": Creating vips thumbnail at $dstPath\n" );

			$scalerParams = array(
				# The size to which the image will be resized
				'physicalWidth' => $params['physicalWidth'],
				'physicalHeight' => $params['physicalHeight'],
				'physicalDimensions' => "{$params['physicalWidth']}x{$params['physicalHeight']}",
				# The size of the image on the page
				'clientWidth' => $params['width'],
				'clientHeight' => $params['height'],
				# Comment as will be added to the EXIF of the thumbnail
				'comment' => isset( $params['descriptionUrl'] ) ?
					"File source: {$params['descriptionUrl']}" : '',
				# Properties of the original image
				'srcWidth' => $file->getWidth(),
				'srcHeight' => $file->getHeight(),
				'mimeType' => $file->getMimeType(),
				'srcPath' => $file->getPath(),
				'dstPath' => $dstPath,
				'dstUrl' => $dstUrl,
			);

			$options = array();
			if ( $request->getBool( 'bilinear' ) ) {
				$options['bilinear'] = true;
				wfDebug( __METHOD__ . ": using bilinear scaling\n" );
			}
			if ( $request->getVal( 'sharpen' ) && $request->getVal( 'sharpen' ) < 5 ) {
				# Limit sharpen sigma to 5, otherwise we have to write huge convolution matrices
				$options['sharpen'] = array( 'sigma' => floatval( $request->getVal( 'sharpen' ) ) );
				wfDebug( __METHOD__ . ": sharpening with radius {$options['sharpen']}\n" );
			}

			# Call the hook
			$mto = null;
			VipsScaler::doTransform( $handler, $file, $scalerParams, $options, $mto );
			if ( $mto && !$mto->isError() ) {
				wfDebug( __METHOD__ . ": streaming thumbnail...\n" );
				$this->getOutput()->disable();
				StreamFile::stream( $dstPath, array(
					"Cache-Control: public, max-age=$wgVipsTestExpiry, s-maxage=$wgVipsTestExpiry",
					'Expires: ' . gmdate( 'r ', time() + $wgVipsTestExpiry )
				) );
			} else {
				$this->streamError( 500, $mto->getHtmlMsg() );
			}

			# Cleanup the temporary file
			wfSuppressWarnings();
			unlink( $dstPath );
			wfRestoreWarnings();

		} else {
			# Request the thumbnail at a remote scaler
			$url = wfExpandUrl( $request->getRequestURL(), PROTO_INTERNAL );
			$url = wfAppendQuery( $url, array( 'noproxy' => '1' ) );
			wfDebug( __METHOD__ . ": Getting vips thumb from remote url $url\n" );

			$bits = IP::splitHostAndPort( $wgVipsThumbnailerHost );
//.........这里部分代码省略.........