Help with PHP call_user_func and integrate function into Class?

Question

Below is a function I found about a year ago that is supposed to put a lock on a memcache key so you can update it's value without any trouble of 2 request trying to update the key at the same time.

It is pretty basic but I could use a little help in figuring out how to use it 100%. The part I am not sure about is where it passes in a $updateFunction which is then passed to **

call_user_func($updateFunction, $data); // update data

I have never used the call_user_func() before. Based on this code could some one show me a basic example of what a function that it calls could look like (without doing any mysql or anything, just the way it would work). Would I be able to pass in multiple properties to the call function?

Thanks for any help. Also assuming I already have a Class name Memcache which has a connection or object with this $this->connection would I need to change anything in the function below to add it into my Memcache class? Also once this function is part of my existing memcache class, will that callback function be able to call methods in other classes?

Hope this isn't to confusing.

// {{{ locked_mecache_update($memcache,$key,$updateFunction,$expiryTime,$waitUTime,$maxTries)
/**
 * A function to do ensure only one thing can update a memcache at a time.
 *
 * Note that there are issues with the $expiryTime on memcache not being
 * fine enough, but this is the best I can do. The idea behind this form
 * of locking is that it takes advantage of the fact that
 * {@link memcache_add()}'s are atomic in nature.
 *
 * It would be possible to be a more interesting limiter (say that limits
 * updates to no more than 1/second) simply by storing a timestamp or
 * something of that nature with the lock key (currently stores "1") and
 * not deleitng the memcache entry.
 *
 * @param $memcache memcache the memcache object
 * @param $key string the key to do the update on
 * @param $updateFunction mixed the function to call that accepts the data
 *  from memcache and modifies it (use pass by reference).
 * @param $expiryTime integer time in seconds to allow the key to last before
 *  it will expire. This should only happen if the process dies during update.
 *  Choose a number big enough so that $updateFunction will take much less
 *  time to execute.
 * @param $waitUTime integer the amount of time in microseconds to wait before
 *  checking for the lock to release
 * @param $maxTries integer maximum number of attempts before it gives up
 *  on the locks. Note that if $maxTries is 0, then it will RickRoll forever
 *  (never give up). The default number ensures that it will wait for three
 *  full lock cycles to crash before it gives up also.
 * @return boolean success or failure
 */
function locked_memcache_update(
    $memcache,          // Memcache Object
    $key,               // Key to update
    $updateFunction,   // Function to pass key/value into to update
    $expiryTime=3,     // time before key expires
    $waitUtime=101,    // time to wait for to check for lock release
    $maxTries=100000) //  number of times to try to get lock
    {

    $lock = 'lock:'.$key;

    // get the lock {{{
    if ($maxTries>0) {
        for ($tries=0; $tries< $maxTries; ++$tries) {
            if ($memcache->add($lock,1,0,$expiryTime)) { break; }
            usleep($waitUtime);
        }
        if ($tries == $maxTries) {
            // handle failure case (use exceptions and try-catch if you need to be nice)
            trigger_error(sprintf('Lock failed for key: %s',$key), E_USER_NOTICE);
            return false;
        }
    } else {
        while (!$memcache->add($lock,1,0,$expiryTime)) {
            usleep($waitUtime);
        }
    }
    // }}}

    //Now we have a lock so we can update of key/value
    // modify data in cache {{{
    $data = $memcache->get($key, $flag);
    call_user_func($updateFunction, $data); // update data
    $memcache->set($key, $data, $flag);
    // }}}

    // Update complete so we release our lock
    // clear the lock
    $memcache->delete($lock,0);
    return true;
}
// }}}
?>

---

UPDATE

Here is my existing Memcache class that I would like to integrate this with

<?PHP
class MemCache
{

    // Memcache object
    public $connection;

    function __construct()
    {
        $this->connection = new MemCache;
    }

    // Set a key/value to memcache with Expire time
    function store($key, $data, $ttl)
    {
        return $this->connection->set($key, $data, 0, $ttl);
    }

    // Retrieve a Value from Memcache with a KEY
    function fetch($key)
    {
        return $this->connection->get($key);
    }

    // DELETE a Key/Value from Memcache with a KEY
    function delete($key)
    {
        return $this->connection->delete($key);
    }

    // Add a server connection to memcache
    function addServer($host, $port = 11211, $weight = 10)
    {
        $this->connection->addServer($host, $port, true, $weight);
    }

    // Clear all memcache data
    function flush()
    {
        return $this->connection->flush();
    }

    // Show Memcache stats
    function stats()
    {
        return statDetails($this->connection->getStats());
    }

    // Show Memcache stats in a table
    function statDetails($status)
    {
        echo "<table border='1'>";
        echo "<tr><td>Memcache Server version:</td><td> " . $status["version"] .
            "</td></tr>";
        echo "<tr><td>Process id of this server process </td><td>" . $status["pid"] .
            "</td></tr>";
        echo "<tr><td>Number of seconds this server has been running </td><td>" . $status["uptime"] .
            "</td></tr>";
        echo "<tr><td>Accumulated user time for this process </td><td>" . $status["rusage_user"] .
            " seconds</td></tr>";
        echo "<tr><td>Accumulated system time for this process </td><td>" . $status["rusage_system"] .
            " seconds</td></tr>";
        echo "<tr><td>Total number of items stored by this server ever since it started </td><td>" .
            $status["total_items"] . "</td></tr>";
        echo "<tr><td>Number of open connections </td><td>" . $status["curr_connections"] .
            "</td></tr>";
        echo "<tr><td>Total number of connections opened since the server started running </td><td>" .
            $status["total_connections"] . "</td></tr>";
        echo "<tr><td>Number of connection structures allocated by the server </td><td>" .
            $status["connection_structures"] . "</td></tr>";
        echo "<tr><td>Cumulative number of retrieval requests </td><td>" . $status["cmd_get"] .
            "</td></tr>";
        echo "<tr><td> Cumulative number of storage requests </td><td>" . $status["cmd_set"] .
            "</td></tr>";
        $percCacheHit = ((real)$status["get_hits"] / (real)$status["cmd_get"] * 100);
        $percCacheHit = round($percCacheHit, 3);
        $percCacheMiss = 100 - $percCacheHit;
        echo "<tr><td>Number of keys that have been requested and found present </td><td>" .
            $status["get_hits"] . " ($percCacheHit%)</td></tr>";
        echo "<tr><td>Number of items that have been requested and not found </td><td>" .
            $status["get_misses"] . "($percCacheMiss%)</td></tr>";
        $MBRead = (real)$status["bytes_read"] / (1024 * 1024);
        echo "<tr><td>Total number of bytes read by this server from network </td><td>" .
            $MBRead . " Mega Bytes</td></tr>";
        $MBWrite = (real)$status["bytes_written"] / (1024 * 1024);
        echo "<tr><td>Total number of bytes sent by this server to network </td><td>" .
            $MBWrite . " Mega Bytes</td></tr>";
        $MBSize = (real)$status["limit_maxbytes"] / (1024 * 1024);
        echo "<tr><td>Number of bytes this server is allowed to use for storage.</td><td>" .
            $MBSize . " Mega Bytes</td></tr>";
        echo "<tr><td>Number of valid items removed from cache to free memory for new items.</td><td>" .
            $status["evictions"] . "</td></tr>";
        echo "</table>";
    }

}

?>

Answer 1

The documentation of call_user_func() contains a link to the callback pseudo-type. In short it is either a function name or an array. The array must either contain two strings (a class name and a function name - callback for static functions) or an object and a string (an object and the method to call on that object - for member functions). Here are the examples from the documentation:

<?php 

// An example callback function
function my_callback_function() {
    echo 'hello world!';
}

// An example callback method
class MyClass {
    static function myCallbackMethod() {
        echo 'Hello World!';
    }
}

// Type 1: Simple callback
call_user_func('my_callback_function');


// Type 2: Static class method call
call_user_func(array('MyClass', 'myCallbackMethod')); 

// Type 3: Object method call
$obj = new MyClass();
call_user_func(array($obj, 'myCallbackMethod'));

// Type 4: Static class method call (As of PHP 5.2.3)
call_user_func('MyClass::myCallbackMethod');

// Type 5: Relative static class method call (As of PHP 5.3.0)
class A {
    public static function who() {
        echo "A\n";
    }
}

class B extends A {
    public static function who() {
        echo "B\n";
    }
}

call_user_func(array('B', 'parent::who')); // A
?>

One more thing: Your locking could be interrupted between add($lock,... and get(). Using increment() and decrement() would solve that problem.

Answer 2

Not directly an answer, but it's worth noting that you don't actually need to use call_user_func - you can just call a variable function:

function ham($jam) {
    echo $jam;
}

$bar = 'eggs';
$foo = 'ham';

$foo($bar);

This should work fine on instantiated objects too:

$bees->$honey($sting);

And there's more info in the docs.