muzich/vendor/swiftmailer/lib/classes/Swift/FileSpool.php

<?php

/*
 * This file is part of SwiftMailer.
 * (c) 2009 Fabien Potencier <fabien.potencier@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * Stores Messages on the filesystem.
 * @package Swift
 * @author  Fabien Potencier
 * @author Xavier De Cock <xdecock@gmail.com>
 */
class Swift_FileSpool extends Swift_ConfigurableSpool
{
  /** The spool directory */
  private $_path;
  
  /**
   * File WriteRetry Limit
   * @var int
   */
  private $_retryLimit=10;
  
  /**
   * Create a new FileSpool.
   * @param string $path
   * @throws Swift_IoException
   */
  public function __construct($path)
  {
    $this->_path = $path;
    
    if (!file_exists($this->_path))
    {
      if (!mkdir($this->_path, 0777, true))
      {
        throw new Swift_IoException('Unable to create Path ['.$this->_path.']');
      }
    }
  }
  
  /**
   * Tests if this Spool mechanism has started.
   *
   * @return boolean
   */
  public function isStarted()
  {
    return true;
  }
  
  /**
   * Starts this Spool mechanism.
   */
  public function start()
  {
  }
  
  /**
   * Stops this Spool mechanism.
   */
  public function stop()
  {
  }
  
  /**
   * Allow to manage the enqueuing retry limit.
   * Default, is ten and allows over 64^20 different fileNames 
   * 
   * @param integer $limit
   */
  public function setRetryLimit($limit)
  {
    $this->_retryLimit=$limit;
  }
  
  /**
   * Queues a message.
   * @param Swift_Mime_Message $message The message to store
   * @return boolean
   * @throws Swift_IoException
   */
  public function queueMessage(Swift_Mime_Message $message)
  {
    $ser = serialize($message);
    $fileName=$this->_path.'/'.$this->getRandomString(10);
    for ($i = 0; $i < $this->_retryLimit; ++$i) 
    {
      /* We try an exclusive creation of the file
       * This is an atomic operation, it avoid locking mechanism
       */
      $fp=fopen($fileName.'.message', 'x');
      if ($fp) 
      {
        fwrite($fp, $ser);
        fclose($fp);
        
        return;
      } 
      else 
      {
        /* The file allready exists, we try a longer fileName
         */
        $fileName.=$this->getRandomString(1);
      }
    }
    
    throw new Swift_IoException('Unable to create a file for enqueuing Message');
  }
  
  /**
   * Execute a recovery if for anyreason a process is sending for too long
   * 
   * @param int $timeout in second Defaults is for very slow smtp responses
   */
  public function recover($timeout=900)
  {
    foreach (new DirectoryIterator($this->_path) as $file)
    {
      $file = $file->getRealPath();

      if (substr($file, -16)=='.message.sending')
      {
        $lockedtime=filectime($file);
        if ((time()-$lockedtime)>$timeout) 
        {
          rename($file, substr($file, 0, -8));
        }
      }
    }    
  }
  
  /**
   * Sends messages using the given transport instance.
   *
   * @param Swift_Transport $transport         A transport instance
   * @param string[]        &$failedRecipients An array of failures by-reference
   *
   * @return int The number of sent emails
   */
  public function flushQueue(Swift_Transport $transport, &$failedRecipients = null)
  {
    if (!$transport->isStarted())
    {
      $transport->start();
    }

    $failedRecipients = (array) $failedRecipients;
    $count = 0;
    $time = time();
    foreach (new DirectoryIterator($this->_path) as $file)
    {
      $file = $file->getRealPath();

      if (substr($file, -8) != '.message')
      {
        continue;
      }

      /* We try a rename, it's an atomic operation, and avoid locking the file */
      if (rename($file, $file.'.sending')) 
      {
        $message = unserialize(file_get_contents($file.'.sending'));

        $count += $transport->send($message, $failedRecipients);

        unlink($file.'.sending');
      }
      else 
      {
        /* This message has just been catched by another process */
        continue;
      }

      if ($this->getMessageLimit() && $count >= $this->getMessageLimit())
      {
        break;
      }

      if ($this->getTimeLimit() && (time() - $time) >= $this->getTimeLimit())
      {
        break;
      }
    }

    return $count;
  }
  
  /**
   * Returns a random string needed to generate a fileName for the queue.
   * @param int $count
   */
  protected function getRandomString($count) {
    // This string MUST stay FS safe, avoid special chars
    $base="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-.";
    $ret='';
    $strlen=strlen($base);
    for ($i=0; $i<$count; ++$i) 
    {
      $ret.=$base[((int)rand(0,$strlen-1))];
    }
    return $ret;
  }
}