Source for file MDB2.php

Documentation is available at MDB2.php

  1. <?php
  2. /**
  3.  * OpenID_Store_MDB2
  4.  * 
  5.  * PHP Version 5.2.0+
  6.  * 
  7.  * @uses      OpenID_Store_Interface
  8.  * @category  Auth
  9.  * @package   OpenID
  10.  * @author    Bill Shupp <hostmaster@shupp.org>
  11.  * @copyright 2009 Bill Shupp
  12.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  13.  * @link      http://pearopenid.googlecode.com
  14.  */
  15.  
  16. /**
  17.  * Required files
  18.  */
  19. require_once 'MDB2.php';
  20. require_once 'OpenID/Store/Interface.php';
  21. require_once 'OpenID/Store/Exception.php';
  22. require_once 'OpenID.php';
  23. require_once 'OpenID/Discover.php';
  24. require_once 'OpenID/Association.php';
  25. require_once 'OpenID/Nonce.php';
  26.  
  27. /**
  28.  * A first pass at SQL support via MDB2.  This may have some MySQL specific things
  29.  * so it might get refactored a bit to support other DBs.
  30.  * 
  31.  * @uses      OpenID_Store_Interface
  32.  * @category  Auth
  33.  * @package   OpenID
  34.  * @author    Bill Shupp <hostmaster@shupp.org>
  35.  * @copyright 2009 Bill Shupp
  36.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  37.  * @link      http://pearopenid.googlecode.com
  38.  */
  39. class OpenID_Store_MDB2 implements OpenID_Store_Interface
  40. {
  41.     /**
  42.      * Instance of MDB2
  43.      * 
  44.      * @var mixed 
  45.      */
  46.     protected $db = null;
  47.  
  48.     /**
  49.      * Table names which you can override in a child class
  50.      * 
  51.      * @var array 
  52.      */
  53.     protected $tableNames = array(
  54.         'nonce'       => 'OpenIDNonces',
  55.         'association' => 'OpenIDAssociations',
  56.         'discovery'   => 'OpenIDDiscovery',
  57.     );
  58.  
  59.     /**
  60.      * Calls MDB2::factory().  Connections are lazy loaded upon queries.
  61.      * 
  62.      * @param array $options Array of options to pass to MDB2::factory().  Note that
  63.      *                        you must also include the key 'dsn', which is used as
  64.      *                        the first argument to MDB2::factory(), and is not
  65.      *                        passed with the options argument.
  66.      * 
  67.      * @throws OpenID_Store_Exception on error or missing DSN in options
  68.      * @return void 
  69.      */
  70.     public function __construct(array $options)
  71.     {
  72.         if (!isset($options['dsn'])) {
  73.             throw new OpenID_Store_Exception('Missing dsn from options');
  74.         }
  75.  
  76.         $dsn = $options['dsn'];
  77.         unset($options['dsn']);
  78.         $this->db = MDB2::factory($dsn, $options);
  79.  
  80.         if (PEAR::isError($this->db)) {
  81.             throw new OpenID_Store_Exception('Error connecting to DB', $this->db);
  82.         }
  83.     }
  84.  
  85.     /**
  86.      * Creates tables
  87.      * 
  88.      * @throws OpenID_Store_Exception on failure to create tables
  89.      * @return OpenID_Store_MDB2 
  90.      */
  91.     public function createTables()
  92.     {
  93.         $nonceCreate = "CREATE TABLE {$this->tableNames['nonce']} (
  94.                           uri VARCHAR(2047) NOT NULL,
  95.                           nonce VARCHAR(100) NOT NULL,
  96.                           created INTEGER NOT NULL,
  97.                           UNIQUE (uri(255), nonce, created)
  98.                         ) ENGINE=InnoDB";
  99.  
  100.         $assocCreate = "CREATE TABLE {$this->tableNames['association']} (
  101.                           uri VARCHAR(2047) NOT NULL,
  102.                           assocHandle VARCHAR(255) NOT NULL,
  103.                           sharedSecret BLOB NOT NULL,
  104.                           created INTEGER NOT NULL,
  105.                           expiresIn INTEGER NOT NULL,
  106.                           assocType VARCHAR(64) NOT NULL,
  107.                           PRIMARY KEY (uri(255), assocHandle)
  108.                         ) ENGINE=InnoDB";
  109.  
  110.         $discoveryCreate = "CREATE TABLE {$this->tableNames['discovery']} (
  111.                               identifier VARCHAR(2047) NOT NULL,
  112.                               serialized_discover BLOB NOT NULL,
  113.                               expires INTEGER NOT NULL,
  114.                               PRIMARY KEY (identifier(255))
  115.                             ) ENGINE=InnoDB";
  116.  
  117.         $queries = array($nonceCreate, $assocCreate, $discoveryCreate);
  118.  
  119.         foreach ($queries as $sql) {
  120.             $result = $this->db->exec($sql);
  121.             if (PEAR::isError($result)) {
  122.                 throw new OpenID_Store_Exception(
  123.                     'Error creating table', $result);
  124.             }
  125.         }
  126.  
  127.         return $this;
  128.     }
  129.  
  130.     /**
  131.      * A shortcut to handle the error checking of prepare()/execute() in one place.
  132.      * 
  133.      * @param string $sql  The SQL to prepare
  134.      * @param array  $args The corresponding arguments
  135.      * 
  136.      * @throws OpenID_Store_Exception on error
  137.      * @return MDB2_Result 
  138.      */
  139.     protected function prepareExecute($sql, array $args)
  140.     {
  141.         $prepared = $this->db->prepare($sql);
  142.         if (PEAR::isError($prepared)) {
  143.             throw new OpenID_Store_Exception($prepared);
  144.         }
  145.  
  146.         $result = $prepared->execute($args);
  147.         $prepared->free();
  148.         if (PEAR::isError($result)) {
  149.             throw new OpenID_Store_Exception($result);
  150.         }
  151.         return $result;
  152.     }
  153.  
  154.     /**
  155.      * Gets an instance of OpenID_Discover from the SQL server if it exists.
  156.      * 
  157.      * @param string $identifier The user supplied identifier
  158.      * 
  159.      * @return false on failure, OpenID_Discover on success
  160.      */
  161.     public function getDiscover($identifier)
  162.     {
  163.         $normalized = OpenID::normalizeIdentifier($identifier);
  164.  
  165.         $sql = "SELECT serialized_discover
  166.                     FROM {$this->tableNames['discovery']}
  167.                     WHERE identifier = ?
  168.                     AND expires > ?";
  169.  
  170.         $result = $this->prepareExecute($sql, array($normalized, time()));
  171.         if (!$result->numRows()) {
  172.             return false;
  173.         }
  174.  
  175.         $row = $result->fetchRow(MDB2_FETCHMODE_ASSOC);
  176.         $result->free();
  177.  
  178.         return unserialize($row['serialized_discover']);
  179.     }
  180.  
  181.     /**
  182.      * Adds discoverd infomation to the SQL server
  183.      * 
  184.      * @param OpenID_Discover $discover The OpenID_Discover instance
  185.      * @param int             $expire   The time (in seconds) that the cached object
  186.      *                                   should live
  187.      * 
  188.      * @return OpenID_Store_MDB2 
  189.      */
  190.     public function setDiscover(OpenID_Discover $discover, $expire = 3600)
  191.     {
  192.         $sql = "REPLACE INTO {$this->tableNames['discovery']} 
  193.                 (identifier, serialized_discover, expires)
  194.                 VALUES (?, ?, ?)";
  195.  
  196.         $this->prepareExecute($sql, array($discover->identifier,
  197.                                           serialize($discover),
  198.                                           time() + $expire));
  199.         return $this;
  200.     }
  201.  
  202.     /**
  203.      * Gets an association from the SQL server
  204.      * 
  205.      * @param string $uri    The OP Endpoint URL
  206.      * @param string $handle The association handle if available
  207.      * 
  208.      * @return OpenID_Association on success, false on failure
  209.      */
  210.     public function getAssociation($uri, $handle = null)
  211.     {
  212.         if ($handle === null) {
  213.             $sql    = "SELECT * FROM {$this->tableNames['association']}
  214.                            WHERE uri = ?";
  215.             $params = array($uri);
  216.         } else {
  217.             $sql    = "SELECT * FROM {$this->tableNames['association']}
  218.                            WHERE uri = ? AND assocHandle = ?";
  219.             $params = array($uri, $handle);
  220.         }
  221.  
  222.         $result = $this->prepareExecute($sql, $params);
  223.         if (!$result->numRows()) {
  224.             return false;
  225.         }
  226.  
  227.         $row = $result->fetchRow(MDB2_FETCHMODE_ASSOC);
  228.         $result->free();
  229.  
  230.         if (($row['expiresin'] + $row['created']) < time()) {
  231.             return false;
  232.         }
  233.  
  234.         $association = new OpenID_Association(array(
  235.             'uri'          => $row['uri'],
  236.             'expiresIn'    => $row['expiresin'],
  237.             'created'      => $row['created'],
  238.             'assocType'    => $row['assoctype'],
  239.             'assocHandle'  => $row['assochandle'],
  240.             'sharedSecret' => $row['sharedsecret']
  241.         ));
  242.  
  243.         return $association;
  244.     }
  245.  
  246.     /**
  247.      * Sets an association in the SQL server
  248.      * 
  249.      * @param OpenID_Association $association An instance of OpenID_Association
  250.      * 
  251.      * @return OpenID_Store_MDB2 
  252.      */
  253.     public function setAssociation(OpenID_Association $association)
  254.     {
  255.         $sql = "REPLACE INTO {$this->tableNames['association']}
  256.                     (uri, assocHandle, sharedSecret, created, expiresIn, assocType)
  257.                     VALUES (?, ?, ?, ?, ?, ?)";
  258.  
  259.         $args = array(
  260.             $association->uri,
  261.             $association->assocHandle,
  262.             $association->sharedSecret,
  263.             $association->created,
  264.             $association->expiresIn,
  265.             $association->assocType
  266.         );
  267.         $this->prepareExecute($sql, $args);
  268.  
  269.         return $this;
  270.     }
  271.  
  272.     /**
  273.      * Deletes an association from the SQL server
  274.      * 
  275.      * @param string $uri The OP Endpoint URL
  276.      * 
  277.      * @return OpenID_Store_MDB2 
  278.      */
  279.     public function deleteAssociation($uri)
  280.     {
  281.         $sql = "DELETE FROM {$this->tableNames['association']}
  282.                     WHERE uri = ?";
  283.  
  284.         $result = $this->prepareExecute($sql, array($uri));
  285.  
  286.         return $this;
  287.     }
  288.  
  289.     /**
  290.      * Gets a nonce from the SQL server if it exists
  291.      * 
  292.      * @param string $nonce The nonce to retrieve
  293.      * @param string $opURL The OP Endpoint URL that it is associated with
  294.      * 
  295.      * @return string (nonce) on success, false on failure
  296.      */
  297.     public function getNonce($nonce, $opURL)
  298.     {
  299.         $sql = "SELECT nonce FROM {$this->tableNames['nonce']}
  300.                     WHERE uri = ?
  301.                     AND nonce = ?";
  302.  
  303.         $result = $this->prepareExecute($sql, array($opURL, $nonce));
  304.         if (!$result->numRows()) {
  305.             return false;
  306.         }
  307.  
  308.         $row = $result->fetchRow(MDB2_FETCHMODE_ASSOC);
  309.         $result->free();
  310.  
  311.         return $row['nonce'];
  312.     }
  313.  
  314.     /**
  315.      * Sets a nonce in the SQL server
  316.      * 
  317.      * @param string $nonce The nonce value to set
  318.      * @param string $opURL The OP Endpoint URL it is associated with
  319.      * 
  320.      * @return OpenID_Store_MDB2 
  321.      */
  322.     public function setNonce($nonce, $opURL)
  323.     {
  324.         $sql = "INSERT INTO {$this->tableNames['nonce']}
  325.                     (uri, nonce, created)
  326.                     VALUES (?, ?, ?)";
  327.         $this->prepareExecute($sql, array($opURL, $nonce, time()));
  328.  
  329.         return $this;
  330.     }
  331.  
  332.     /**
  333.      * Deletes a nonce from the SQL server
  334.      * 
  335.      * @param string $nonce The nonce value
  336.      * @param string $opURL The OP Endpoint URL it is associated with
  337.      * 
  338.      * @return OpenID_Store_MDB2 
  339.      */
  340.     public function deleteNonce($nonce, $opURL)
  341.     {
  342.         $sql = "DELETE FROM {$this->tableNames['nonce']}
  343.                     WHERE uri = ?
  344.                     AND nonce = ?";
  345.  
  346.         $result = $this->prepareExecute($sql, array($opURL, $nonce));
  347.  
  348.         return $this;
  349.     }
  350. }
  351. ?>

Documentation generated on Tue, 15 Dec 2009 19:00:55 -0800 by phpDocumentor 1.4.3