PHP OO retry logic implementation and passing dynamic method and args - php

Question

My first question here.
The question is similar to this one: PHP: Retrying a query a set number of times or until success
Try till success in OO way.
Here example what i'm trying to do:
class Creatives {
public function run() {
$auth_token='mypassword';
$id=123123;
$this->retry_till_success ( $this->getCreatives, array($auth_token, $id) );
print $this->creatives;
}
public function getCreatives($auth_token, $id) {
$this->creatives = $this->campagin->get($auth_token, $id);
}
private function retry_till_success($method, $args) {
do {
$try_again = false;
try {
/* how to call the method with */
/* call user method with params pass */
/* do until success */
} catch (SoapFault $fault) {
if($fault->faultstring== 'couldnt connect to host')
$try_again=true;
}
} while ($try_again);
}
}
i read about call_user_func, but don't know if i could use it inside the class,
I need to make 99.9% success rate in my calls, any suggestion to achieve this will be great.
thank you.

Answer 1

Best way would be to extend SoapClient and add the retry in the __call method.
class LocalSoapClient extends SoapClient
{
public function __call($function_name, $arguments)
{
$result = false;
$max_retries = 5;
$retry_count = 0;
while(! $result && $retry_count < $max_retries)
{
try
{
$result = parent::__call($function_name, $arguments);
}
catch(SoapFault $fault)
{
if($fault->faultstring != 'Could not connect to host')
{
throw $fault;
}
}
sleep(1);
$retry_count ++;
}
if($retry_count == $max_retries)
{
throw new SoapFault('Could not connect to host after 5 attempts');
}
return $result;
}
}
then when you instantiate your soap client use new LocalSoapClient() instead of new SoapClient()

Answer 2

call_user_func_array() is great for this:
$result = call_user_func_array( array($this, $method), $args );
The first argument is the callback pseudo-type, and the second is an array of parameters which will be passed to the function/method as individual arguments.
As a side note, you might want to look at throttling your retries (e.g. have a sleep time which doubles every time it fails up to a set limit). If the connection to the host is down there may not be much point in retrying as fast as possible.

Answer 3

private function retry_till_success($method, $args) {
...
$this->$method($args[0], $args[1]);
}
You could also use ReflectionClass/ReflectionMethod and call InvokeArgs() for a variable number of args
http://nz.php.net/oop5.reflection

Answer 4

I'm not quite sure what you mean, but this is how call_user_func(_array)() works:
call_user_func($method, $arg); //call global function named $method like this: $method($arg)
call_user_func(array($this, $method), $arg); call class method on this class like this: $this->$method($arg);
//lets presume args is an array: $args = array(1, 2);
call_user_func_array($method, $args); //calls global function named $method like this: $method($args[0], $args[1]);
call_user_func_array(array($this, $method), $args); //calls class method like this: $this->$method($args[0], $args[1]);
Also see the documentation for call_user_func:
http://nl3.php.net/manual/en/function.call-user-func.php
and for call_user_func_array:
http://nl3.php.net/manual/en/function.call-user-func-array.php

Answer 5

$this->getCreatives won't work because in PHP functions are not base class citizen. You can use call_user_func[_array] or create a factory for tasks and represent every task as an object which implements an interface (ie iRepeatableTask). Thus you can call
try
{
$task->repeatUntilSuccess()
} catch (SoapFault $e) {...}
and the advantage is that those objecs are easy-to-save/restore in DB to perform later (ie with cronjob etc.).

Answer 6

Here is my final solution I'm using in production.
protected function retry_till_success($method, $args) {
/*
* -1 : unrecoverable error
* 0 : recoverable error
* 1 : success
*/
$success = 0;
$tries = 0;
do {
$tries++;
$success = call_user_func_array( array($this, $method), $args );
if ($success===0) {
usleep(self::DELAY_MS);
}
} while ($success===0 && $tries < self::MAX_RETRIES);
if ($tries >= self::MAX_RETRIES)
return false;
return true;
}