application/hub/main/helper/connection/class_BaseConnectionHelper.php

   1 <?php
   2 /**
   3  * A general ConnectionHelper class
   4  *
   5  * @author              Roland Haeder <webmaster@ship-simu.org>
   6  * @version             0.0.0
   7  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2011 Hub Developer Team
   8  * @license             GNU GPL 3.0 or any newer version
   9  * @link                http://www.ship-simu.org
  10  *
  11  * This program is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 3 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24 class BaseConnectionHelper extends BaseHubHelper implements Registerable, ProtocolHandler {
  25         /**
  26          * Protocol used
  27          */
  28         private $protocol = 'invalid';
  29
  30         /**
  31          * Port number used
  32          */
  33         private $port = 0;
  34
  35         /**
  36          * (IP) Adress used
  37          */
  38         private $address = 0;
  39
  40         /**
  41          * Sent data in bytes
  42          */
  43         private $sentData = 0;
  44
  45         /**
  46          * Offset
  47          */
  48         private $offset = 0;
  49
  50         /**
  51          * Connect retries for this connection
  52          */
  53         private $retryCount = 0;
  54
  55         /**
  56          * Wether this connection is shutted down
  57          */
  58         private $shuttedDown = false;
  59
  60         /**
  61          * Currently queued chunks
  62          */
  63         private $queuedChunks = array();
  64
  65         /**
  66          * Current final hash
  67          */
  68         private $currentFinalHash = '';
  69
  70         /**
  71          * Protected constructor
  72          *
  73          * @param       $className      Name of the class
  74          * @return      void
  75          */
  76         protected function __construct ($className) {
  77                 // Call parent constructor
  78                 parent::__construct($className);
  79
  80                 // Register this connection helper
  81                 Registry::getRegistry()->addInstance('connection', $this);
  82         }
  83
  84         /**
  85          * Getter for port number to satify ProtocolHandler
  86          *
  87          * @return      $port   The port number
  88          */
  89         public final function getPort () {
  90                 return $this->port;
  91         }
  92
  93         /**
  94          * Setter for port number to satify ProtocolHandler
  95          *
  96          * @param       $port   The port number
  97          * @return      void
  98          */
  99         protected final function setPort ($port) {
 100                 $this->port = $port;
 101         }
 102
 103         /**
 104          * Getter for protocol
 105          *
 106          * @return      $protocol       Used protocol
 107          */
 108         public final function getProtocol () {
 109                 return $this->protocol;
 110         }
 111
 112         /**
 113          * Setter for protocol
 114          *
 115          * @param       $protocol       Used protocol
 116          * @return      void
 117          */
 118         protected final function setProtocol ($protocol) {
 119                 $this->protocol = $protocol;
 120         }
 121
 122         /**
 123          * Getter for IP address
 124          *
 125          * @return      $address        The IP address
 126          */
 127         public final function getAddress () {
 128                 return $this->address;
 129         }
 130
 131         /**
 132          * Setter for IP address
 133          *
 134          * @param       $address        The IP address
 135          * @return      void
 136          */
 137         protected final function setAddress ($address) {
 138                 $this->address = $address;
 139         }
 140
 141         /**
 142          * "Getter" for raw data from a package array. A fragmenter is used which
 143          * will returns us only so many raw data which fits into the back buffer.
 144          * The rest is being held in a back-buffer and waits there for the next
 145          * cycle and while be then sent.
 146          *
 147          * This method does 4 simple steps:
 148          * 1) Aquire fragmenter object instance from the factory
 149          * 2) Handle over the package data array to the fragmenter
 150          * 3) Request a chunk
 151          * 4) Finally return the chunk (array) to the caller
 152          *
 153          * @param       $packageData    Raw package data array
 154          * @return      $chunkData              Raw data chunk
 155          */
 156         private function getRawDataFromPackageArray (array $packageData) {
 157                 // If there is no fragmenter?
 158                 if (!Registry::getRegistry()->instanceExists('package_fragmenter')) {
 159                         // Get the fragmenter instance
 160                         $fragmenterInstance = ObjectFactory::createObjectByConfiguredName('package_fragmenter_class');
 161
 162                         // Add it to the registry
 163                         Registry::getRegistry()->addInstance('package_fragmenter', $fragmenterInstance);
 164                 } else {
 165                         // Get fragmenter from registry
 166                         $fragmenterInstance = Registry::getRegistry()->getInstance('package_fragmenter');
 167                 }
 168
 169                 // Implode the package data array and fragement the resulting string, returns the final hash
 170                 $this->currentFinalHash = $fragmenterInstance->fragmentPackageArray($packageData, $this);
 171
 172                 // Get the next raw data chunk from the fragmenter
 173                 $rawDataChunk = $fragmenterInstance->getNextRawDataChunk($this->currentFinalHash);
 174
 175                 // Get chunk hashes and chunk data
 176                 $chunkHashes = array_keys($rawDataChunk);
 177                 $chunkData   = array_values($rawDataChunk);
 178
 179                 // Remember this chunk as queued
 180                 $this->queuedChunks[$chunkHashes[0]] = $chunkData[0];
 181
 182                 // Return the raw data
 183                 return $chunkData[0];
 184         }
 185
 186         /**
 187          * "Accept" a visitor by simply calling it back
 188          *
 189          * @param       $visitorInstance        A Visitor instance
 190          * @return      void
 191          */
 192         protected final function accept (Visitor $visitorInstance) {
 193                 // Just call the visitor
 194                 $visitorInstance->visitConnectionHelper($this);
 195         }
 196
 197         /**
 198          * Sends raw package data to the recipient
 199          *
 200          * @param       $packageData    Raw package data
 201          * @return      $sentBytes              Actual sent bytes to the peer
 202          * @throws      InvalidSocketException  If we got a problem with this socket
 203          */
 204         public function sendRawPackageData (array $packageData) {
 205                 // Convert the package data array to a raw data stream
 206                 $rawData = $this->getRawDataFromPackageArray($packageData);
 207
 208                 // Get socket resource
 209                 $socketResource = $this->getSocketResource();
 210
 211                 // And deliver it
 212                 $sentBytes = @socket_write($socketResource, $rawData, $this->getConfigInstance()->getConfigEntry($this->getProtocol() . '_buffer_length') - $this->offset);
 213
 214                 // If there was an error, we don't continue here
 215                 if ($sentBytes === false) {
 216                         // Get socket error code for verification
 217                         $socketError = socket_last_error($socketResource);
 218
 219                         // Get error message
 220                         $errorMessage = socket_strerror($socketError);
 221
 222                         // Shutdown this socket
 223                         $this->shutdownSocket($socketResource);
 224
 225                         // And throw it
 226                         throw new InvalidSocketException(array($this, gettype($socketResource), $socketError, $errorMessage), BaseListener::EXCEPTION_INVALID_SOCKET);
 227                 } elseif ($sentBytes == 0) {
 228                         // Nothing sent is bad news
 229                         die(__METHOD__.': Unhandled 0 sent bytes! rawData[]=' . strlen($rawData));
 230                 }
 231
 232                 // The difference between sent bytes and length of raw data should not be below zero
 233                 assert((strlen($rawData) - $sentBytes) >= 0);
 234
 235                 // Return sent bytes
 236                 return $sentBytes;
 237         }
 238
 239         /**
 240          * Getter for real class name
 241          *
 242          * @return      $class  Name of this class
 243          */
 244         public function __toString () {
 245                 // Class name representation
 246                 $class = $this->getAddress() . ':' . $this->getPort() . ':' . parent::__toString();
 247
 248                 // Return it
 249                 return $class;
 250         }
 251
 252         /**
 253          * Checks wether the connect retry is exhausted
 254          *
 255          * @return      $isExhaused             Wether connect retry is exchausted
 256          */
 257         public final function isConnectRetryExhausted () {
 258                 // Construct config entry
 259                 $configEntry = $this->getProtocol() . '_connect_retry_max';
 260
 261                 // Check it out
 262                 $isExhausted = ($this->retryCount >=  $this->getConfigInstance()->getConfigEntry($configEntry));
 263
 264                 // Return it
 265                 return $isExhausted;
 266         }
 267
 268         /**
 269          * Increases the connect retry count
 270          *
 271          * @return      void
 272          */
 273         public final function increaseConnectRetry () {
 274                 $this->retryCount++;
 275         }
 276
 277         /**
 278          * Marks this connection as shutted down
 279          *
 280          * @return      void
 281          */
 282         protected final function markConnectionShutdown () {
 283                 $this->shuttedDown = true;
 284         }
 285
 286         /**
 287          * Getter for shuttedDown
 288          *
 289          * @return      $shuttedDown    Wether this connection is shutted down
 290          */
 291         public final function isShuttedDown () {
 292                 return $this->shuttedDown;
 293         }
 294 }
 295
 296 // [EOF]
 297 ?>