public function read($id)
 {
     atsumi_Debug::startTimer('SESSION_READ');
     $result = $this->cache->get($id, null, 'SESSION');
     if (is_null($result)) {
         return '';
     }
     atsumi_Debug::record('Session loaded from cache', sf('Session ID: %s', $id), $result, 'SESSION_READ', atsumi_Debug::AREA_SESSION, $result);
     return $result;
 }
Beispiel #2
0
 /**
  * Constructor - Must use getInstance to get a session singalton object
  */
 protected function __construct($options = array())
 {
     // Start timer for constructor complete time
     atsumi_Debug::startTimer();
     $this->configure($options);
     // Fetch the session storage handler
     $storage = isset($options['storage']) ? $options['storage'] : self::DEFAULT_STORAGE;
     if (is_subclass_of($storage, 'session_AbstractStorage')) {
         $this->storage = new $storage($options);
     }
     // Start the session
     $this->start($options);
     // Add debug information
     atsumi_Debug::record('Session Created', 'The atsumi session constructor completed', null, true, atsumi_Debug::AREA_SESSION);
 }
 public function write($id, $sessionData)
 {
     try {
         if ($this->database->exists('session', 'checksum = %i AND session_id = %s', crc32($id), $id)) {
             atsumi_Debug::record('Updating Session', sf('The session(%s) is being updated to the DB', $id), atsumi_Debug::AREA_SESSION, base64_encode($sessionData));
             $this->database->update('session', 'checksum = %i AND session_id = %s', crc32($id), $id, 'data = %s', base64_encode($sessionData), 'last_active	= NOW()');
         } else {
             atsumi_Debug::record('Inserting Session', sf('The atsumi(%s) is being inserted to the DB: ', $id), atsumi_Debug::AREA_SESSION, $sessionData);
             $this->database->insert('session', 'checksum		= %i', crc32($id), 'session_id		= %s', $id, 'data			= %s', base64_encode($sessionData), 'last_active	= NOW()');
         }
         return true;
         /* this is a little drastic but will most likley segfault if Exception bubbles up */
     } catch (Exception $e) {
         die('Could not write session to database.');
     }
 }
 /**
  * Actually executes a sql string on the connected database.
  *
  * Direct use is not recommened.
  * @param string $sql
  * @throws db_NoConnectionException Thrown if there is no database connection.
  * @throws db_QueryFailedException Thrown if the query failed.
  */
 public function queryReal($sql)
 {
     if (!$this->connected) {
         throw new db_NoConnectionException('No Database Connection');
     }
     if ($this->debug) {
         $startTime = time() + microtime();
     }
     $this->affectedRows = null;
     try {
         $return = $this->pdo->query($sql);
         if ($return === false) {
             $error = $this->pdo->errorInfo();
             throw new PDOException(isset($error[2]) ? $error[2] : 'Database Error: ' . $error[0]);
         }
         $data = $return->fetchAll(PDO::FETCH_ASSOC);
         $this->affectedRows = count($data);
         if (!is_array($data)) {
             throw new PDOException('Failed to return data array');
         }
         if ($this->debug) {
             if (count($this->queryTimes) > 100) {
                 $this->queryTimes = null;
                 $this->debug = false;
                 atsumi_Debug::record('Too many queries to debug', 'Atsumi has disabled query debugging for this script as too many queries were fired.', atsumi_Debug::AREA_DATABASE, null);
             } else {
                 $this->queryTimes[] = array('sql' => $sql, 'time' => time() + microtime() - $startTime, 'row_count' => count($data));
             }
         }
         return $data;
     } catch (PDOException $e) {
         throw new db_QueryFailedException($e->getMessage() . "<h4>SQL:</h4>" . $sql);
     }
 }
Beispiel #5
0
 /**
  * Calls render on the processed controller
  * Note: process method must be execute before this method
  * @access public
  */
 public function render()
 {
     // Time and execute the pre render
     atsumi_Debug::startTimer('app:controller:preRender');
     $this->controller->publishFlashData();
     $this->controller->preRender();
     atsumi_Debug::record('Controller PreRender', 'Before rendering was processed the pre-render function was executed', null, 'app:controller:preRender');
     $viewHandler = $this->controller->getViewHandler();
     $view = $this->controller->getView();
     if (!in_array('mvc_ViewHandlerInterface', class_implements($viewHandler))) {
         throw new Exception('View handler must implement mvc_ViewHandlerInterface');
     }
     if (is_string($viewHandler)) {
         $viewHandler = new $viewHandler();
     }
     if (is_null($view)) {
         throw new mvc_NoViewSpecifiedException('A view has not been declared', $this->parserData['method']);
     }
     // Get the debugger and start a timer for rendering
     atsumi_Debug::startTimer('app:controller:rendering');
     $viewData = $this->controller->getViewData();
     atsumi_Debug::setViewData($viewData);
     // Time and execute the view handler
     atsumi_Debug::startTimer('app:controller:render');
     $viewHandler->render($view, $viewData);
     atsumi_Debug::record('Rendering', sf('Rendering was performed by the %s view handler', get_class($viewHandler)), null, 'app:controller:render');
     // tell the debug to print if required as connection will be closed by __destruct
     atsumi_Debug::printIfRequired();
     // Time and execute the post render
     atsumi_Debug::startTimer('app:controller:postRender');
     $this->controller->postRender();
     atsumi_Debug::record('Controller PostRender', 'After the rendering was processed the post-render function was executed', null, 'app:controller:postRender');
     // Log the whole processing time
     atsumi_Debug::record('Rendering Complete', 'All rendering was completed successfully', null, 'app:controller:rendering');
 }
 /**
  * Clears the cache store of all stored values
  * @access public
  * @return boolen True on success or, False on failure
  */
 public final function flush()
 {
     try {
         return $this->_flush();
     } catch (Exception $e) {
         atsumi_Debug::record('Cache Handler failed to flush', $e->getMessage(), false, atsumi_Debug::AREA_CACHE);
         return false;
     }
 }