gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

Christian · 27.02.2009

Hallo!

Ich habe vor (ob es klappt? keine Ahnung!) 2 HTTP-Verbindungen gleichzeitig über fsock herzustellen, allerdings hab ich keine Ahnung wie ich das realisieren sollte, einen kleinen Ansatz habe ich jedoch schon:

PHP:

<?
$socket1	= @fsockopen( $ResolvedIpAddress1, 80, $errno1, $errstr2, 3 );
$socket2	= @fsockopen( $ResolvedIpAddress2, 80, $errno1, $errstr2, 3 );

if( $socket ){
	stream_set_timeout( $socket1, 360000 );
	stream_set_timeout( $socket2, 360000 );

	#Daten aufbereiten
	$send1 	= 	"GET $FilePath1 HTTP/1.0\r\n"."\r\n";
	$send2 	= 	"GET $FilePath2 HTTP/1.0\r\n"."\r\n";

	#Anfrage an Adresse schicken
	@fwrite( $socket1, $send1 );
	@fwrite( $socket2, $send2 );

	$Buffer1 				= null;
	$Buffer2 				= null;
	$perc1 					= false;
	$perc2 					= false;
	$progress1				= 0;
	$progress2				= 0;
	
	#Ergebnis auslesen
	while( !@feof( $socket1 ) && !@feof( $socket2 ) ){
		if(!@feof( $socket1) ){
			$thisUselessBuffer1 = @fgets( $socket1, 8192 );
		}
		if(!@feof( $socket2 ) ){
			$thisUselessBuffer2 = @fgets( $socket2, 8192 );
		}
		
		#zum bestimmen des Ende des Headers
		if( strtolower( $thisUselessBuffer1 ) == "\r\n" && !$perc ) $perc1 = true;
		if( strtolower( $thisUselessBuffer2 ) == "\r\n" && !$perc ) $perc2 = true;
		
		#Ladebalken (optional)
		if(USE_GAUGE && ($perc1 || $perc2)){
			$oldProgress1 = $progress1;
			$oldProgress2 = $progress2;
			$progress1	= (int) str_replace("\r\n", "", $thisUselessBuffer1 );
			$progress2	= (int) str_replace("\r\n", "", $thisUselessBuffer2 );
			
			# wb_set_value teilt dem browser via ob_flush & jscript mit, welcher Ladebalken wieviel % aufweist,
			# sobald progress[N] > oldProgress[N] ist
			# als Referenz, wieviel % der Ladestatus eines sockets ist,
			# wird vom aufgerufenen Link ebenfalls via ob_flush() eine Prozentzahl des Fortschritts
			# an $thisUselessBuffer[N] übertragen, z.B.: 55\r\n = 55%
			if( is_numeric( $progress1 ) && $oldProgress1 < $progress1 ) wb_set_value( $ProgressBar1, $progress1 );
			if( is_numeric( $progress2 ) && $oldProgress2 < $progress2 ) wb_set_value( $ProgressBar2, $progress2 );
		}

		$Buffer1	.= $thisUselessBuffer1;
		$Buffer2	.= $thisUselessBuffer2;
		
	}

	#Verbindung schließen
	@fclose( $socket1 );
	@fclose( $socket2 );
}

?>

Erklärung:
Ich habe es mir so gedacht, dass ich 2 Verbindungen direkt aufeinanderfolgend via fsockopen herstelle und dann in einer Schleife solange bis beide !@feof 's erreicht sind, auslese.
Bei einer Verbindung klappt es (natürlich), ich hab jetzt auf die schnelle das mal so umgeschrieben, wie es mein erster Ansatz wäre, getestet ist es jedoch nicht.
Meine Frage ist:
Hat das überhaupt Sinn, oder gibt es "elegantere" Lösungen?
PS: Die Variablennamen sind natürlich freundlich gesagt scheiße ausgewählt, sollte der Ansatz Sinn haben, würde ich natürlich mit Arrays und Schleifen arbeiten, aber bevor ich da Arbeit reinstecke wollte ich mal nachfragen, ob es überhaupt Sinn macht, oder gar möglich ist.

Grüße
Christian

CIX88 · 27.02.2009

AW: gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

Ich hab ja schon einiges probiert, aber das auch nicht nicht

Ich glaube nicht, dass es überhaupt möglich ist. Mit einen Browser kannst du auch nicht zeitgleich auf unterschiedliche Websiten zugreiffen. Verschiebungen (selbst im millisekunden bereich) wird es immer geben.

Ich würde das eher nacheinander machen bzw. kommt drauf an was genau genau werden soll.

Duddle · 27.02.2009

AW: gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

Christian schrieb:
Hat das überhaupt Sinn, oder gibt es "elegantere" Lösungen?

Die Frage nach dem Sinn solltest du dir doch selbst stellen?
Spontan fällt mir keine sinnvolle Anwendung ein, bei der es sinnvoller ist, zwei Verbindungen quasiparallel auszuführen statt sequentiell.

Funktionieren wird es jedenfalls, es sei denn PHP hat da irgendwelche Einstellungen alá max_socks oder so.

Duddle

Christian · 27.02.2009

AW: gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

Der Sinn dieser Anwendung ist relativ einfach:
Ich habe zweierleit Arten von Datenaustauschscripten in 2 verschiedene Richtungen, die sich aus logischem Sinne nicht kombinieren lassen.
Die Dauer der Ausführungszeit beider Scripte (die über HTTP aufgerufen werden können) ist in etwa gleich hoch.
Beide Scripte sequentiell aufzurufen wäre zu zeitaufwendig, daher suche ich eine Lösung beide Scripte, wie Duddle schon treffend beschrieben hat, quasiparallel aufzurufen um bestenfalls die Ausführungszeit beider halbieren zu können. Und da beide Scripte nicht trafficlastig sondern eher rechenlastig sind, werde ich meinen Ansatz erstmal weiter nachverfolgen, da im Maximalfall pro Zeile 2-3Bytes gesendet werden, aber dennoch danke

CIX88 · 27.02.2009

AW: gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

Müsstest di nicht da deine while-Schleife ändern ?
Denn wenn ein Prozess fertig ist, wird dieser dennoch noch mit ausgeführt, weil vermutlich der andere etwas länger brauch.

Der benutze Port ist allerdings sehr interessant!

Christian · 28.02.2009

AW: gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

Für die, die es interessiert:
Es klappt in der Tat!
ich hab mittlerweile 4 pseudo-parallele Abfragen ohne Probleme ausführen können.
Nur zur Vollständigkeit:

PHP:

<?

class streamResource{
	public $results			= array();
	public $buffer			= array();
	protected $streams		= array();
	protected $sockets		= array();
	
	const PORT				= 80;
	const STREAM_TIMEOUT	= 36000;
	const LINE_SIZE			= 8192;
	
	public function __construct(){}
	
	/**
	 * register a link
	 *
	 * @param string $host (including GET-parameters)
	 * @param array $callbackFunction (means function to handle each resultline returned by fgets())
	 * @example callbackFunction = array('f'=>'myfunc','p'=>array('assignTo'=>'end','param'=>array('myparam1','myparam2')))
	 * 			calls to 
	 * 			-> myfunc( $ResultLine, 'myparam1', 'myparam2' )
	 * 			concerning that assignTo is set to 'end', otherwise if assignTo would be set to 'beginning' the call would
	 * 			look like that:
	 * 			-> myfunc( 'myparam1', 'myparam2', $ResultLine )
	 * 			Parameters are optional!
	 * @param mixed $result, reference to where the completed result-download of a stream should be stored
	 */
	public function registerStream( $host, $url, $callbackFunction, $id = null, &$result = null )
	{
		if( $id )
		{
			$this->streams[$id] = array( $host, $url, $callbackFunction, &$result );
			return;
		}
		
		$this->streams[] = array( $host, $url, $callbackFunction, &$result );
		return;
	}
	
	/**
	 * pseudo-parallel read of all sockets
	 *
	 * @return mixed buffer
	 */
	public function readStreams()
	{
		foreach( $this->streams as $id=>$stream )
		{
			$this->fsockopen( $id, $stream[0] );
		}
		
		if( sizeof( $this->sockets ) > 0 )
		{
			$this->applyStreamTimeout();
			
			foreach( $this->sockets as $id => $socket )
			{
				$this->sendURL( $socket, $this->streams[$id][1] );
			}
			
			while( !$this->socketsFeof() )
			{
				foreach( $this->sockets as $id=>$socket ){

					$buffer = $this->socketFgets( $socket, self::LINE_SIZE, $id );

					if( isset( $this->streams[$id][2]['f'] ) )
					{
						$this->parseUserFunction( $buffer, $id );
					}
				}
			}
			$this->socketsClose();
			return $this->results();
		}
	}
	
	public function results(){
		return $this->buffer;
	}
	
	/**
	 * close all connections
	 *
	 */
	public function socketsClose()
	{
		if( $this->sockets && sizeof( $this->sockets ) > 0 )
		{
			foreach( $this->sockets as $socket )
			{
				@fclose( $socket );
			}
		}
	}
	
	/**
	 * parse userfunction given in streamregistration
	 *
	 * @param string $buffer
	 * @param string StreamID $id
	 */
	public function parseUserFunction( $buffer, $id )
	{
		$evalString	= $this->streams[$id][2]['f'].'(';

		$bufferParam	= "'". addslashes($buffer) ."'";
		$customParam	= null;

		foreach( $this->streams[$id][2]['p']['param'] as $param )
		{
			$customParam .= "'". addslashes( $param ) ."',";
		}
		

		switch( $this->streams[$id][2]['p']['assignTo'] )
		{
			case 'end':
				$evalString .= substr( $bufferParam .','. $customParam, 0, -1 );
				break;
			case 'beginning':
				$evalString	.= $customParam.$bufferParam;
				break;
			default:
				$evalString	.= $bufferParam;
		}
		$evalString .= ",'". addslashes($evalString).")'";
		$evalString	.= ');';

		eval( $evalString );
		
	}
	
	/**
	 * read resource
	 *
	 * @param resource ID $socketID
	 * @param int $size
	 * @param string StreamID $id
	 * @return string
	 */
	public function socketFgets( $socketID, $size, $id )
	{
		$buffer					= @fgets( $socketID, $size );
		$this->buffer[$id][]	= $buffer;
		return $buffer;
	}
	
	/**
	 * apply streamtimeout to all streams
	 *
	 */
	public function applyStreamTimeout()
	{
		foreach( $this->sockets as $socket )
		{
			stream_set_timeout( $socket, self::STREAM_TIMEOUT );
		}
	}
	
	/**
	 * send request URL to socket resource
	 *
	 * @param resourde $resSocket
	 * @param string $strURL
	 * @return boolean
	 */
	public function sendURL( $resSocket, $strURL )
	{
		$socketSend = "GET $strURL HTTP/1.0\r\n"."\r\n";;
		return @fwrite( $resSocket, $socketSend );
	}
	
	/**
	 * array-fsockopen and saving of resource id
	 *
	 * @param string $id
	 * @param string $stream
	 */
	public function fsockopen( $id, $stream )
	{
		$this->sockets[$id]	= @fsockopen( $stream, self::PORT, $errno, $errstr, 3 );
	}
	
	/**
	 * feof for all sockets
	 *
	 * @return boolean
	 */
	public function socketsFeof()
	{
		if( $this->sockets && sizeof( $this->sockets ) > 0 )
		{
			$feof = true;
			foreach( $this->sockets as $socket )
			{
				if( !@feof( $socket ) )
				{
					$feof = false;
				}
			}
			return $feof;
		}
		else 
		{
			return true;
		}
	}
}
$sr = new streamResource();

$test = null;
function test(){
	$st = func_get_arg(2);
	echo 'called: '.str_replace("\r\n",'',$st).PHP_EOL;
}

$sr->registerStream('google.de', '/', array('f'=>'test','p'=>array('assignTo'=>'end', 'param'=>array('nyoar'))), 'TESTSTREAM', $test);
$sr->registerStream('google.de', '/search?q=loleintest', array('f'=>'test','p'=>array('assignTo'=>'end', 'param'=>array('nyoar'))), 'TESTSTREAM2', $test);
$sr->readStreams();
print_r($sr);
?>

Ausgabe:

Code:

und zu CIX:
Nein, er liest nur solange von einem Stream bis feof($streamid) erreicht ist. Ein Problem allerdings könnte sein, dass wenn eine URL signifikant länger braucht als die andere, dass die Verbindungen erst dann geschlossen werden, wenn die Anfrage an den längsten Stream abgeschlossen ist.
Die durchschnittliche Zeitersparnis bewegt sich im Bereich von 30-40%. Ist noch testhalber, einige Optimierungen müssen noch vorgenommen werden, aber die Grunfunktionen stehen soweit.

CIX88 · 28.02.2009

AW: gleichzeitige Öffnung zweier HTTP-Verbindungen via fsockopen?

> wenn eine URL signifikant länger braucht als die andere
Das meinte ich auch