library/Zend/Queue/Stomp/Frame.php

   1 <?php
   2 /**
   3  * Zend Framework
   4  *
   5  * LICENSE
   6  *
   7  * This source file is subject to the new BSD license that is bundled
   8  * with this package in the file LICENSE.txt.
   9  * It is also available through the world-wide-web at this URL:
  10  * http://framework.zend.com/license/new-bsd
  11  * If you did not receive a copy of the license and are unable to
  12  * obtain it through the world-wide-web, please send an email
  13  * to license@zend.com so we can send you a copy immediately.
  14  *
  15  * @category   Zend
  16  * @package    Zend_Queue
  17  * @subpackage Stomp
  18  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  19  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  20  * @version    $Id: Frame.php 16971 2009-07-22 18:05:45Z mikaelkael $
  21  */
  22
  23 /**
  24  * @see Zend_Queue_Stomp_FrameInterface
  25  */
  26 require_once 'Zend/Queue/Stomp/FrameInterface.php';
  27
  28 /**
  29  * This class represents a Stomp Frame
  30  *
  31  * @category   Zend
  32  * @package    Zend_Queue
  33  * @subpackage Stomp
  34  * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
  35  * @license    http://framework.zend.com/license/new-bsd     New BSD License
  36  */
  37 class Zend_Queue_Stomp_Frame
  38     implements Zend_Queue_Stomp_FrameInterface
  39 {
  40     const END_OF_FRAME   = "\x00\n";
  41     const CONTENT_LENGTH = 'content-length';
  42     const EOL            = "\n";
  43
  44     /**
  45      * Headers for the frame
  46      *
  47      * @var array
  48      */
  49     protected $_headers = array();
  50
  51     /**
  52      * The command for the frame
  53      *
  54      * @var string
  55      */
  56     protected $_command = null;
  57
  58     /**
  59      * The body of the frame
  60      *
  61      * @var string
  62      */
  63     protected $_body = null;
  64
  65     /**
  66      * Do the content-length automatically?
  67      */
  68     protected $_autoContentLength = null;
  69
  70     /**
  71      * Constructor
  72      */
  73     public function __construct()
  74     {
  75         $this->setHeaders(array());
  76         $this->setBody(null);
  77         $this->setCommand(null);
  78         $this->setAutoContentLength(true);
  79     }
  80
  81     /**
  82      * get the status of the auto content length
  83      *
  84      * If AutoContentLength is true this code will automatically put the
  85      * content-length header in, even if it is already set by the user.
  86      *
  87      * This is done to make the message sending more reliable.
  88      *
  89      * @return boolean
  90      */
  91     public function getAutoContentLength()
  92     {
  93         return $this->_autoContentLength;
  94     }
  95
  96     /**
  97      * setAutoContentLength()
  98      *
  99      * Set the value on or off.
 100      *
 101      * @param boolean $auto
 102      * @return $this;
 103      * @throws Zend_Queue_Exception
 104      */
 105     public function setAutoContentLength($auto)
 106     {
 107         if (!is_bool($auto)) {
 108             require_once 'Zend/Queue/Exception.php';
 109             throw new Zend_Queue_Exception('$auto is not a boolean');
 110         }
 111
 112         $this->_autoContentLength = $auto;
 113         return $this;
 114     }
 115
 116     /**
 117      * Get the headers
 118      *
 119      * @return array
 120      */
 121     public function getHeaders()
 122     {
 123         return $this->_headers;
 124     }
 125
 126     /**
 127      * Set the headers
 128      *
 129      * Throws an exception if the array values are not strings.
 130      *
 131      * @param array $headers
 132      * @return $this
 133      * @throws Zend_Queue_Exception
 134      */
 135     public function setHeaders(array $headers)
 136     {
 137         foreach ($headers as $header => $value) {
 138             $this->setHeader($header, $value);
 139         }
 140
 141         return $this;
 142     }
 143
 144     /**
 145      * Sets a value for a header
 146      *
 147      * @param  string $header
 148      * @param  string $value
 149      * @return Zend_Queue_Stomp_Frame
 150      * @throws Zend_Queue_Exception
 151      */
 152     public function setHeader($header, $value) {
 153         if (!is_string($header)) {
 154             require_once 'Zend/Queue/Exception.php';
 155             throw new Zend_Queue_Exception('$header is not a string: ' . print_r($header, true));
 156         }
 157
 158         if (!is_scalar($value)) {
 159             require_once 'Zend/Queue/Exception.php';
 160             throw new Zend_Queue_Exception('$value is not a string: ' . print_r($value, true));
 161         }
 162
 163         $this->_headers[$header] = $value;
 164         return $this;
 165     }
 166
 167
 168     /**
 169      * Returns a value for a header
 170      *
 171      * Returns false if the header does not exist.
 172      *
 173      * @param  string $header
 174      * @return string|false
 175      * @throws Zend_Queue_Exception
 176      */
 177     public function getHeader($header)
 178     {
 179         if (!is_string($header)) {
 180             require_once 'Zend/Queue/Exception.php';
 181             throw new Zend_Queue_Exception('$header is not a string');
 182         }
 183
 184         return isset($this->_headers[$header])
 185             ? $this->_headers[$header]
 186             : false;
 187     }
 188
 189     /**
 190      * Return the body for this frame
 191      *
 192      * Returns false if the body does not exist
 193      *
 194      * @return false|string
 195      */
 196     public function getBody()
 197     {
 198         return is_null($this->_body)
 199             ? false
 200             : $this->_body;
 201     }
 202
 203     /**
 204      * Set the body for this frame
 205      *
 206      * Set to null for no body.
 207      *
 208      * @param  string|null $body
 209      * @return Zend_Queue_Stomp_Frame
 210      * @throws Zend_Queue_Exception
 211      */
 212     public function setBody($body)
 213     {
 214         if (!is_string($body) && !is_null($body)) {
 215             require_once 'Zend/Queue/Exception.php';
 216             throw new Zend_Queue_Exception('$body is not a string or null');
 217         }
 218
 219         $this->_body = $body;
 220         return $this;
 221     }
 222
 223     /**
 224      * Return the command for this frame
 225      *
 226      * Return false if the command does not exist
 227      *
 228      * @return string|false
 229      */
 230     public function getCommand()
 231     {
 232         return is_null($this->_command)
 233             ? false
 234             : $this->_command;
 235     }
 236
 237     /**
 238      * Set the body for this frame
 239      *
 240      * @param  string|null
 241      * @return Zend_Queue_Stomp_Frame
 242      * @throws Zend_Queue_Exception
 243      */
 244     public function setCommand($command)
 245     {
 246         if (!is_string($command) && !is_null($command)) {
 247             require_once 'Zend/Queue/Exception.php';
 248             throw new Zend_Queue_Exception('$command is not a string or null');
 249         }
 250
 251         $this->_command = $command;
 252         return $this;
 253     }
 254
 255     /**
 256      * Takes the current parameters and returns a Stomp Frame
 257      *
 258      * @return string
 259      * @throws Zend_Queue_Exception
 260      */
 261     public function toFrame()
 262     {
 263         if ($this->getCommand() === false) {
 264             require_once 'Zend/Queue/Exception.php';
 265             throw new Zend_Queue_Exception('You must set the command');
 266         }
 267
 268         $command = $this->getCommand();
 269         $headers = $this->getHeaders();
 270         $body    = $this->getBody();
 271         $frame   = '';
 272
 273         // add a content-length to the SEND command.
 274         // @see http://stomp.codehaus.org/Protocol
 275         if ($this->getAutoContentLength()) {
 276             $headers[self::CONTENT_LENGTH] = strlen($this->getBody());
 277         }
 278
 279         // Command
 280         $frame = $command . self::EOL;
 281
 282         // Headers
 283         foreach ($headers as $key=>$value) {
 284             $frame .= $key . ': ' . $value . self::EOL;
 285         }
 286
 287         // Seperator
 288         $frame .= self::EOL; // blank line required by protocol
 289
 290         // add the body if any
 291         if ($body !== false) {
 292             $frame .= $body;
 293         }
 294         $frame .= self::END_OF_FRAME;
 295
 296         return $frame;
 297     }
 298
 299     /**
 300      * @see toFrame()
 301      * @return string
 302      */
 303     public function __toString()
 304     {
 305         try {
 306             $return = $this->toFrame();
 307         } catch (Zend_Queue_Exception $e) {
 308             $return = '';
 309         }
 310         return $return;
 311     }
 312
 313     /**
 314      * Accepts a frame and deconstructs the frame into its component parts
 315      *
 316      * @param  string $frame - a stomp frame
 317      * @return $this
 318      */
 319     public function fromFrame($frame)
 320     {
 321         if (!is_string($frame)) {
 322             require_once 'Zend/Queue/Exception.php';
 323             throw new Zend_Queue_Exception('$frame is not a string');
 324         }
 325
 326         $headers = array();
 327         $body    = null;
 328         $command = false;
 329         $header  = '';
 330
 331         // separate the headers and the body
 332         $match = self::EOL . self::EOL;
 333         if (preg_match('/' . $match . '/', $frame)) {
 334             list ($header, $body) = explode($match, $frame, 2);
 335         } else {
 336             $header = $frame;
 337         }
 338
 339         // blow up headers
 340         $headers = explode(self::EOL, $header);
 341         unset($header);
 342
 343         // get the command (first line)
 344         $this->setCommand(array_shift($headers));
 345
 346         // set each of the headers.
 347         foreach ($headers as $header) {
 348             if (strpos($header, ':') > 0) {
 349                 list($name, $value) = explode(':', $header, 2);
 350                 $this->setHeader($name, $value);
 351             }
 352         }
 353
 354         // crop the body if content-length is present
 355         if ($this->getHeader(self::CONTENT_LENGTH) !== false ) {
 356             $length = (int) $this->getHeader(self::CONTENT_LENGTH);
 357             $body   = substr($body, 0, $length);
 358         }
 359
 360         $this->setBody($body);
 361         return $this;
 362     }
 363 }