TYPO3_6-2/_predis_store_8php_source.html

 <?php

 require_once 'Auth/OpenID/Interface.php';

 class Auth_OpenID_PredisStore extends Auth_OpenID_OpenIDStore {

     protected $redis;

     protected $prefix;

     function Auth_OpenID_PredisStore(\Predis\Client $redis, $prefix = '')
     {
         $this->prefix = $prefix;
         $this->redis = $redis;
     }

     function storeAssociation($server_url, $association)
     {
         // create Redis keys for association itself
         // and list of associations for this server
         $associationKey = $this->associationKey($server_url,
             $association->handle);
         $serverKey = $this->associationServerKey($server_url);

         // save association to server's associations' keys list
         $this->redis->lpush(
             $serverKey,
             $associationKey
         );

         // Will touch the association list expiration, to avoid filling up
         $newExpiration = ($association->issued + $association->lifetime);

         $expirationKey = $serverKey.'_expires_at';
         $expiration = $this->redis->get($expirationKey);
         if (!$expiration || $newExpiration > $expiration) {
             $this->redis->set($expirationKey, $newExpiration);
             $this->redis->expireat($serverKey, $newExpiration);
             $this->redis->expireat($expirationKey, $newExpiration);
         }

         // save association itself, will automatically expire
         $this->redis->setex(
             $associationKey,
             $newExpiration - time(),
             serialize($association)
         );
     }

     function getAssociation($server_url, $handle = null)
     {
         // simple case: handle given
         if ($handle !== null) {
             return $this->getAssociationFromServer(
                 $this->associationKey($server_url, $handle)
             );
         }

         // no handle given, receiving the latest issued
         $serverKey = $this->associationServerKey($server_url);
         $lastKey = $this->redis->lindex($serverKey, -1);
         if (!$lastKey) {
             // no previous association with this server
             return null;
         }

         // get association, return null if failed
         return $this->getAssociationFromServer($lastKey);
     }

     private function getAssociationFromServer($associationKey)
     {
         $association = $this->redis->get($associationKey);
         return $association ? unserialize($association) : null;
     }

     function removeAssociation($server_url, $handle)
     {
         // create Redis keys
         $serverKey = $this->associationServerKey($server_url);
         $associationKey = $this->associationKey($server_url,
             $handle);

         // Removing the association from the server's association list
         $removed = $this->redis->lrem($serverKey, 0, $associationKey);
         if ($removed < 1) {
             return false;
         }

         // Delete the association itself
         return $this->redis->del($associationKey);
     }

     function useNonce($server_url, $timestamp, $salt)
     {
         global $Auth_OpenID_SKEW;

         // save one request to memcache when nonce obviously expired
         if (abs($timestamp - time()) > $Auth_OpenID_SKEW) {
             return false;
         }

         // SETNX will set the value only of the key doesn't exist yet.
         $nonceKey = $this->nonceKey($server_url, $salt);
         $added = $this->redis->setnx($nonceKey, "1");
         if ($added) {
             // Will set expiration
             $this->redis->expire($nonceKey, $Auth_OpenID_SKEW);
             return true;
         } else {
             return false;
         }
     }

     private function nonceKey($server_url, $salt)
     {
         return $this->prefix .
                'openid_nonce_' .
                sha1($server_url) . '_' . sha1($salt);
     }

     function associationKey($server_url, $handle = null)
     {
         return $this->prefix .
                'openid_association_' .
                sha1($server_url) . '_' . sha1($handle);
     }

     function associationServerKey($server_url)
     {
         return $this->prefix .
                'openid_association_server_' .
                sha1($server_url);
     }

     function supportsCleanup()
     {
         return false;
     }

 }

Auth_OpenID_OpenIDStore
Definition: Interface.php:30

Auth_OpenID_PredisStore\storeAssociation
storeAssociation($server_url, $association)
Definition: PredisStore.php:59

Auth_OpenID_PredisStore\nonceKey
nonceKey($server_url, $salt)
Definition: PredisStore.php:175

Auth_OpenID_PredisStore\removeAssociation
removeAssociation($server_url, $handle)
Definition: PredisStore.php:130

Auth_OpenID_PredisStore\$redis
$redis
Definition: PredisStore.php:34

Auth_OpenID_PredisStore\supportsCleanup
supportsCleanup()
Definition: PredisStore.php:205

Auth_OpenID_PredisStore\getAssociationFromServer
getAssociationFromServer($associationKey)
Definition: PredisStore.php:121

Auth_OpenID_PredisStore\getAssociation
getAssociation($server_url, $handle=null)
Definition: PredisStore.php:96

Auth_OpenID_PredisStore\associationKey
associationKey($server_url, $handle=null)
Definition: PredisStore.php:185

Auth_OpenID_PredisStore\Auth_OpenID_PredisStore
Auth_OpenID_PredisStore(\Predis\Client $redis, $prefix='')
Definition: PredisStore.php:48

Auth_OpenID_PredisStore\associationServerKey
associationServerKey($server_url)
Definition: PredisStore.php:195

Auth_OpenID_PredisStore\$prefix
$prefix
Definition: PredisStore.php:40

$Auth_OpenID_SKEW
global $Auth_OpenID_SKEW
Definition: Nonce.php:23

Auth_OpenID_PredisStore
Definition: PredisStore.php:29

Auth_OpenID_PredisStore\useNonce
useNonce($server_url, $timestamp, $salt)
Definition: PredisStore.php:151