X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=application%2Fhub%2Fmain%2Fpackage%2Fclass_NetworkPackage.php;h=ba893bd89869f120708c79d1d332b42208568940;hb=aeaa81ff59126567436dc8d0eaa95d86ce4c409e;hp=323dba060d5854601be8f64adf85748f561245a0;hpb=ca8b7f82b8d488b2a6766ca02fe6de767128be31;p=hub.git diff --git a/application/hub/main/package/class_NetworkPackage.php b/application/hub/main/package/class_NetworkPackage.php index 323dba060..ba893bd89 100644 --- a/application/hub/main/package/class_NetworkPackage.php +++ b/application/hub/main/package/class_NetworkPackage.php @@ -1,9 +1,10 @@ * @version 0.0.0 - * @copyright Copyright (c) 2007, 2008 Roland Haeder, 2009, 2010 Hub Developer Team + * @copyright Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2012 Hub Developer Team * @license GNU GPL 3.0 or any newer version * @link http://www.ship-simu.org * @todo Needs to add functionality for handling the object's type @@ -34,20 +35,32 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ -class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registerable { +class NetworkPackage extends BaseHubSystem implements Deliverable, Receivable, Registerable, Visitable { /** * Package mask for compressing package data: - * 1.) Compressor extension - * 2.) Raw package data - * 3.) Tags, seperated by semicolons, no semicolon is required if only one tag is needed - * 4.) Checksum + * 0: Compressor extension + * 1: Raw package data + * 2: Tags, seperated by semicolons, no semicolon is required if only one tag is needed + * 3: Checksum + * 0 1 2 3 */ - const PACKAGE_MASK = '%s:%s:%s:%s'; + const PACKAGE_MASK = '%s%s%s%s%s%s%s'; /** - * Seperator for the above mask + * Separator for the above mask */ - const PACKAGE_MASK_SEPERATOR = ':'; + const PACKAGE_MASK_SEPARATOR = '^'; + + /** + * Size of an array created by invoking + * explode(NetworkPackage::PACKAGE_MASK_SEPARATOR, $content). + */ + const PACKAGE_CONTENT_ARRAY_SIZE = 4; + + /** + * Separator for checksum + */ + const PACKAGE_CHECKSUM_SEPARATOR = '_'; /** * Array indexes for above mask, start with zero @@ -63,46 +76,151 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe const INDEX_PACKAGE_SENDER = 0; const INDEX_PACKAGE_RECIPIENT = 1; const INDEX_PACKAGE_CONTENT = 2; + const INDEX_PACKAGE_STATUS = 3; + const INDEX_PACKAGE_SIGNATURE = 4; + + /** + * Size of the decoded data array ('status' is not included) + */ + const DECODED_DATA_ARRAY_SIZE = 4; + + /** + * Named array elements for decoded package content + */ + const PACKAGE_CONTENT_EXTENSION = 'compressor'; + const PACKAGE_CONTENT_MESSAGE = 'message'; + const PACKAGE_CONTENT_TAGS = 'tags'; + const PACKAGE_CONTENT_CHECKSUM = 'checksum'; + + /** + * Named array elements for package data + */ + const PACKAGE_DATA_SENDER = 'sender'; + const PACKAGE_DATA_RECIPIENT = 'recipient'; + const PACKAGE_DATA_PROTOCOL = 'protocol'; + const PACKAGE_DATA_CONTENT = 'content'; + const PACKAGE_DATA_STATUS = 'status'; + const PACKAGE_DATA_SIGNATURE = 'signature'; + + /** + * All package status + */ + const PACKAGE_STATUS_NEW = 'new'; + const PACKAGE_STATUS_FAILED = 'failed'; + const PACKAGE_STATUS_DECODED = 'decoded'; + const PACKAGE_STATUS_FAKED = 'faked'; + + /** + * Constants for message data array + */ + const MESSAGE_ARRAY_DATA = 'message_data'; + const MESSAGE_ARRAY_TYPE = 'message_type'; + + /** + * Generic answer status field + */ + + /** + * Tags separator + */ + const PACKAGE_TAGS_SEPARATOR = ';'; + + /** + * Raw package data separator + */ + const PACKAGE_DATA_SEPARATOR = '#'; + + /** + * Separator for more than one recipient + */ + const PACKAGE_RECIPIENT_SEPARATOR = ':'; + + /** + * Network target (alias): 'upper nodes' + */ + const NETWORK_TARGET_UPPER = 'upper'; + + /** + * Network target (alias): 'self' + */ + const NETWORK_TARGET_SELF = 'self'; /** - * Tags seperator + * Network target (alias): 'dht' */ - const PACKAGE_TAGS_SEPERATOR = ';'; + const NETWORK_TARGET_DHT = 'dht'; /** - * Raw package data seperator + * TCP package size in bytes */ - const PACKAGE_DATA_SEPERATOR = '|'; + const TCP_PACKAGE_SIZE = 512; + + /************************************************************************** + * Stacker for out-going packages * + **************************************************************************/ /** * Stacker name for "undeclared" packages */ - const STACKER_NAME_UNDECLARED = 'undeclared'; + const STACKER_NAME_UNDECLARED = 'package_undeclared'; /** * Stacker name for "declared" packages (which are ready to send out) */ - const STACKER_NAME_DECLARED = 'declared'; + const STACKER_NAME_DECLARED = 'package_declared'; /** * Stacker name for "out-going" packages */ - const STACKER_NAME_OUTGOING = 'outgoing'; + const STACKER_NAME_OUTGOING = 'package_outgoing'; + + /************************************************************************** + * Stacker for incoming packages * + **************************************************************************/ /** - * Stacker name for "back-buffered" packages + * Stacker name for "incoming" decoded raw data */ - const STACKER_NAME_BACK_BUFFER = 'backbuffer'; + const STACKER_NAME_DECODED_INCOMING = 'package_decoded_data'; /** - * Network target (alias): 'upper hubs' + * Stacker name for handled decoded raw data */ - const NETWORK_TARGET_UPPER_HUBS = 'upper'; + const STACKER_NAME_DECODED_HANDLED = 'package_handled_decoded'; /** - * Network target (alias): 'self' + * Stacker name for "chunked" decoded raw data */ - const NETWORK_TARGET_SELF = 'self'; + const STACKER_NAME_DECODED_CHUNKED = 'package_chunked_decoded'; + + /************************************************************************** + * Stacker for incoming messages * + **************************************************************************/ + + /** + * Stacker name for new messages + */ + const STACKER_NAME_NEW_MESSAGE = 'package_new_message'; + + /** + * Stacker name for processed messages + */ + const STACKER_NAME_PROCESSED_MESSAGE = 'package_processed_message'; + + /************************************************************************** + * Stacker for other/internal purposes * + **************************************************************************/ + + /** + * Stacker name for "back-buffered" packages + */ + const STACKER_NAME_BACK_BUFFER = 'package_backbuffer'; + + /************************************************************************** + * Protocol names * + **************************************************************************/ + const PROTOCOL_TCP = 'TCP'; + const PROTOCOL_UDP = 'UDP'; /** * Protected constructor @@ -112,13 +230,6 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe protected function __construct () { // Call parent constructor parent::__construct(__CLASS__); - - // We need to initialize a stack here for our packages even those - // which have no recipient address and stamp... ;-) - $stackerInstance = ObjectFactory::createObjectByConfiguredName('package_stacker_class'); - - // At last, set it in this class - $this->setStackerInstance($stackerInstance); } /** @@ -127,46 +238,180 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe * @param $compressorInstance A Compressor instance for compressing the content * @return $packageInstance An instance of a Deliverable class */ - public final static function createNetworkPackage (Compressor $compressorInstance) { + public static final function createNetworkPackage (Compressor $compressorInstance) { // Get new instance $packageInstance = new NetworkPackage(); // Now set the compressor instance $packageInstance->setCompressorInstance($compressorInstance); + /* + * We need to initialize a stack here for our packages even for those + * which have no recipient address and stamp... ;-) This stacker will + * also be used for incoming raw data to handle it. + */ + $stackerInstance = ObjectFactory::createObjectByConfiguredName('network_package_stacker_class'); + + // At last, set it in this class + $packageInstance->setStackerInstance($stackerInstance); + + // Init all stacker + $packageInstance->initStackers(); + + // Get a visitor instance for speeding up things and set it + $visitorInstance = ObjectFactory::createObjectByConfiguredName('node_raw_data_monitor_visitor_class', array($packageInstance)); + $packageInstance->setVisitorInstance($visitorInstance); + + // Get crypto instance and set it, too + $cryptoInstance = ObjectFactory::createObjectByConfiguredName('crypto_class'); + $packageInstance->setCryptoInstance($cryptoInstance); + + // Get a singleton package assembler instance from factory and set it here, too + $assemblerInstance = PackageAssemblerFactory::createAssemblerInstance($packageInstance); + $packageInstance->setAssemblerInstance($assemblerInstance); + // Return the prepared instance return $packageInstance; } /** - * "Getter" for hash from given content and helper instance + * Initialize all stackers + * + * @param $forceReInit Whether to force reinitialization of all stacks + * @return void + */ + protected function initStackers ($forceReInit = FALSE) { + // Initialize all + foreach ( + array( + self::STACKER_NAME_UNDECLARED, + self::STACKER_NAME_DECLARED, + self::STACKER_NAME_OUTGOING, + self::STACKER_NAME_DECODED_INCOMING, + self::STACKER_NAME_DECODED_HANDLED, + self::STACKER_NAME_DECODED_CHUNKED, + self::STACKER_NAME_NEW_MESSAGE, + self::STACKER_NAME_PROCESSED_MESSAGE, + self::STACKER_NAME_BACK_BUFFER + ) as $stackerName) { + // Init this stacker + //* DEBUG: */ print(__METHOD__ . ': stackerName=' . $stackerName . ',forceReInit=' . intval($forceReInit) . PHP_EOL); + $this->getStackerInstance()->initStacker($stackerName, $forceReInit); + } // END - foreach + } + + /** + * "Getter" for hash from given content * * @param $content Raw package content - * @param $helperInstance A BaseHubHelper instance - * @return $hash Hash for given package content + * @return $hash Hash for given package content */ - private function getHashFromContent ($content, BaseHubHelper $helperInstance) { + private function getHashFromContent ($content) { + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: content[md5]=' . md5($content) . ',sender=' . $this->getSessionId() . ',compressor=' . $this->getCompressorInstance()->getCompressorExtension()); + // Create the hash - // @TODO crc32 is not good, but it needs to be fast + // @TODO crc32() is very weak, but it needs to be fast $hash = crc32( $content . - ':' . - $helperInstance->getNodeInstance()->getSessionId() . - ':' . + self::PACKAGE_CHECKSUM_SEPARATOR . + $this->getSessionId() . + self::PACKAGE_CHECKSUM_SEPARATOR . $this->getCompressorInstance()->getCompressorExtension() ); + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: content[md5]=' . md5($content) . ',sender=' . $this->getSessionId() . ',hash=' . $hash . ',compressor=' . $this->getCompressorInstance()->getCompressorExtension()); + // And return it return $hash; } + /** + * Checks whether the checksum (sometimes called "hash") is the same + * + * @param $decodedContent Package raw content + * @param $decodedData Whole raw package data array + * @return $isChecksumValid Whether the checksum is the same + */ + private function isChecksumValid (array $decodedContent, array $decodedData) { + // Get checksum + $checksum = $this->getHashFromContentSessionId($decodedContent, $decodedData[self::PACKAGE_DATA_SENDER]); + + // Is it the same? + $isChecksumValid = ($checksum == $decodedContent[self::PACKAGE_CONTENT_CHECKSUM]); + + // Return it + return $isChecksumValid; + } + + /** + * Change the package with given status in given stack + * + * @param $packageData Raw package data in an array + * @param $stackerName Name of the stacker + * @param $newStatus New status to set + * @return void + */ + private function changePackageStatus (array $packageData, $stackerName, $newStatus) { + // Skip this for empty stacks + if ($this->getStackerInstance()->isStackEmpty($stackerName)) { + // This avoids an exception after all packages has failed + return; + } // END - if + + // Pop the entry (it should be it) + $nextData = $this->getStackerInstance()->popNamed($stackerName); + + // Compare both signatures + assert($nextData[self::PACKAGE_DATA_SIGNATURE] == $packageData[self::PACKAGE_DATA_SIGNATURE]); + + // Temporary set the new status + $packageData[self::PACKAGE_DATA_STATUS] = $newStatus; + + // And push it again + $this->getStackerInstance()->pushNamed($stackerName, $packageData); + } + + /** + * "Getter" for hash from given content and sender's session id + * + * @param $decodedContent Raw package content + * @param $sessionId Session id of the sender + * @return $hash Hash for given package content + */ + public function getHashFromContentSessionId (array $decodedContent, $sessionId) { + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: content[md5]=' . md5($decodedContent[self::PACKAGE_CONTENT_MESSAGE]) . ',sender=' . $sessionId . ',compressor=' . $decodedContent[self::PACKAGE_CONTENT_EXTENSION]); + + // Create the hash + // @TODO crc32() is very weak, but it needs to be fast + $hash = crc32( + $decodedContent[self::PACKAGE_CONTENT_MESSAGE] . + self::PACKAGE_CHECKSUM_SEPARATOR . + $sessionId . + self::PACKAGE_CHECKSUM_SEPARATOR . + $decodedContent[self::PACKAGE_CONTENT_EXTENSION] + ); + + // And return it + return $hash; + } + + /////////////////////////////////////////////////////////////////////////// + // Delivering packages / raw data + /////////////////////////////////////////////////////////////////////////// + /** * Delivers the given raw package data. * * @param $packageData Raw package data in an array * @return void */ - private function deliverPackage (array $packageData) { + private function declareRawPackageData (array $packageData) { + // Make sure the required field is there + assert(isset($packageData[self::PACKAGE_DATA_RECIPIENT])); + /* * We need to disover every recipient, just in case we have a * multi-recipient entry like 'upper' is. 'all' may be a not so good @@ -181,35 +426,48 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe // Now get an iterator $iteratorInstance = $discoveryInstance->getIterator(); + // Rewind back to the beginning + $iteratorInstance->rewind(); + // ... and begin iteration while ($iteratorInstance->valid()) { // Get current entry $currentRecipient = $iteratorInstance->current(); // Debug message - $this->debugOutput('PACKAGE: Package declared for recipient ' . $currentRecipient); + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Setting recipient to ' . $currentRecipient . ',previous=' . $packageData[self::PACKAGE_DATA_RECIPIENT]); // Set the recipient - $packageData['recipient'] = $currentRecipient; + $packageData[self::PACKAGE_DATA_RECIPIENT] = $currentRecipient; // And enqueue it to the writer class $this->getStackerInstance()->pushNamed(self::STACKER_NAME_DECLARED, $packageData); + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Package declared for recipient ' . $currentRecipient); + // Skip to next entry $iteratorInstance->next(); } // END - while - // Clean-up the list + /* + * The recipient list can be cleaned up here because the package which + * shall be delivered has already been added for all entries from the + * list. + */ $discoveryInstance->clearRecipients(); } /** - * Sends a raw package out + * Delivers raw package data. In short, this will discover the raw socket + * resource through a discovery class (which will analyse the receipient of + * the package), register the socket with the connection (handler/helper?) + * instance and finally push the raw data on our outgoing queue. * * @param $packageData Raw package data in an array * @return void */ - private function sendRawPackage (array $packageData) { + private function deliverRawPackageData (array $packageData) { /* * This package may become big, depending on the shared object size or * delivered message size which shouldn't be so long (to save @@ -225,22 +483,50 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe $discoveryInstance = SocketDiscoveryFactory::createSocketDiscoveryInstance(); // Now discover the right protocol - $socketResource = $discoveryInstance->discoverSocket($packageData); + $socketResource = $discoveryInstance->discoverSocket($packageData, BaseConnectionHelper::CONNECTION_TYPE_OUTGOING); + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Reached line ' . __LINE__ . ' after discoverSocket() has been called.'); // We have to put this socket in our registry, so get an instance - $registryInstance = SocketRegistry::createSocketRegistry(); + $registryInstance = SocketRegistryFactory::createSocketRegistryInstance(); // Get the listener from registry - $connectionInstance = Registry::getRegistry()->getInstance('connection'); + $helperInstance = Registry::getRegistry()->getInstance('connection'); + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: stateInstance=' . $helperInstance->getStateInstance()); + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Reached line ' . __LINE__ . ' before isSocketRegistered() has been called.'); // Is it not there? - if (!$registryInstance->isSocketRegistered($connectionInstance, $socketResource)) { + if ((is_resource($socketResource)) && (!$registryInstance->isSocketRegistered($helperInstance, $socketResource))) { + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Registering socket ' . $socketResource . ' ...'); + // Then register it - $registryInstance->registerSocket($connectionInstance, $socketResource, $packageData); - } // END - if + $registryInstance->registerSocket($helperInstance, $socketResource, $packageData); + } elseif (!$helperInstance->getStateInstance()->isPeerStateConnected()) { + // Is not connected, then we cannot send + self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Unexpected peer state ' . $helperInstance->getStateInstance()->__toString() . ' detected.'); - // We enqueue it again, but now in the out-going queue + // Shutdown the socket + $this->shutdownSocket($socketResource); + } + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Reached line ' . __LINE__ . ' after isSocketRegistered() has been called.'); + + // Make sure the connection is up + $helperInstance->getStateInstance()->validatePeerStateConnected(); + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Reached line ' . __LINE__ . ' after validatePeerStateConnected() has been called.'); + + // Enqueue it again on the out-going queue, the connection is up and working at this point $this->getStackerInstance()->pushNamed(self::STACKER_NAME_OUTGOING, $packageData); + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Reached line ' . __LINE__ . ' after pushNamed() has been called.'); } /** @@ -249,65 +535,118 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe * @param $packageData Raw package data * @return void */ - private function sendOutgoingPackage (array $packageData) { + private function sendOutgoingRawPackageData (array $packageData) { + // Init sent bytes + $sentBytes = 0; + // Get the right connection instance - $connectionInstance = SocketRegistry::createSocketRegistry()->getHandlerInstanceFromPackageData($packageData); + $helperInstance = SocketRegistryFactory::createSocketRegistryInstance()->getHandlerInstanceFromPackageData($packageData); // Is this connection still alive? - if ($connectionInstance->isShuttedDown()) { + if ($helperInstance->isShuttedDown()) { // This connection is shutting down // @TODO We may want to do somthing more here? return; } // END - if - // Sent it away (we catch exceptions one method above - $sentBytes = $connectionInstance->sendRawPackageData($packageData); + // Sent out package data + $sentBytes = $helperInstance->sendRawPackageData($packageData); // Remember unsent raw bytes in back-buffer, if any $this->storeUnsentBytesInBackBuffer($packageData, $sentBytes); } + /** + * Generates a signature for given raw package content and sender id + * + * @param $content Raw package data + * @param $senderId Sender id to generate a signature for + * @return $signature Signature as BASE64-encoded string + */ + private function generatePackageSignature ($content, $senderId) { + // Hash content and sender id together, use md5() as last algo + $hash = md5($this->getCryptoInstance()->hashString($senderId . $content, $this->getPrivateKey(), false)); + + // Encrypt the content again with the hash as a key + $encryptedContent = $this->getCryptoInstance()->encryptString($content, $hash); + + // Encode it with BASE64 + $signature = base64_encode($encryptedContent); + + // Return it + return $signature; + } + + /** + * Checks whether the signature of given package data is 'valid', here that + * means it is the same or not. + * + * @param $decodedArray An array with 'decoded' (explode() was mostly called) data + * @return $isSignatureValid Whether the signature is valid + * @todo Unfinished area, signatures are currently NOT fully supported + */ + private function isPackageSignatureValid (array $decodedArray) { + // Generate the signature of comparing it + $signature = $this->generatePackageSignature($decodedArray[self::INDEX_PACKAGE_CONTENT], $decodedArray[self::INDEX_PACKAGE_SENDER]); + + // Is it the same? + //$isSignatureValid = + exit(__METHOD__.': signature='.$signature.chr(10).',decodedArray='.print_r($decodedArray,true)); + } + /** * "Enqueues" raw content into this delivery class by reading the raw content - * from given template instance and pushing it on the 'undeclared' stack. + * from given helper's template instance and pushing it on the 'undeclared' + * stack. * - * @param $helperInstance A BaseHubHelper instance + * @param $helperInstance An instance of a Helper class + * @param $protocol Name of used protocol (TCP/UDP) * @return void */ - public function enqueueRawDataFromTemplate (BaseHubHelper $helperInstance) { + public function enqueueRawDataFromTemplate (Helper $helperInstance, $protocolName) { // Get the raw content ... $content = $helperInstance->getTemplateInstance()->getRawTemplateData(); + //* DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('content(' . strlen($content) . ')=' . $content); // ... and compress it $content = $this->getCompressorInstance()->compressStream($content); // Add magic in front of it and hash behind it, including BASE64 encoding - $content = sprintf(self::PACKAGE_MASK, + $packageContent = sprintf(self::PACKAGE_MASK, // 1.) Compressor's extension $this->getCompressorInstance()->getCompressorExtension(), + // - separator + self::PACKAGE_MASK_SEPARATOR, // 2.) Raw package content, encoded with BASE64 base64_encode($content), + // - separator + self::PACKAGE_MASK_SEPARATOR, // 3.) Tags - implode(self::PACKAGE_TAGS_SEPERATOR, $helperInstance->getPackageTags()), + implode(self::PACKAGE_TAGS_SEPARATOR, $helperInstance->getPackageTags()), + // - separator + self::PACKAGE_MASK_SEPARATOR, // 4.) Checksum - $this->getHashFromContent($content, $helperInstance) + $this->getHashFromContent($content) ); // Now prepare the temporary array and push it on the 'undeclared' stack $this->getStackerInstance()->pushNamed(self::STACKER_NAME_UNDECLARED, array( - 'sender' => $helperInstance->getNodeInstance()->getSessionId(), - 'recipient' => $helperInstance->getRecipientType(), - 'content' => $content, + self::PACKAGE_DATA_SENDER => $this->getSessionId(), + self::PACKAGE_DATA_RECIPIENT => $helperInstance->getRecipientType(), + self::PACKAGE_DATA_PROTOCOL => $protocolName, + self::PACKAGE_DATA_CONTENT => $packageContent, + self::PACKAGE_DATA_STATUS => self::PACKAGE_STATUS_NEW, + self::PACKAGE_DATA_SIGNATURE => $this->generatePackageSignature($packageContent, $this->getSessionId()) )); } /** - * Checks wether a package has been enqueued for delivery. + * Checks whether a package has been enqueued for delivery. * - * @return $isEnqueued Wether a package is enqueued + * @return $isEnqueued Whether a package is enqueued */ public function isPackageEnqueued () { - // Check wether the stacker is not empty + // Check whether the stacker is not empty $isEnqueued = (($this->getStackerInstance()->isStackInitialized(self::STACKER_NAME_UNDECLARED)) && (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_UNDECLARED))); // Return the result @@ -315,12 +654,12 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe } /** - * Checks wether a package has been declared + * Checks whether a package has been declared * - * @return $isDeclared Wether a package is declared + * @return $isDeclared Whether a package is declared */ public function isPackageDeclared () { - // Check wether the stacker is not empty + // Check whether the stacker is not empty $isDeclared = (($this->getStackerInstance()->isStackInitialized(self::STACKER_NAME_DECLARED)) && (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_DECLARED))); // Return the result @@ -328,12 +667,12 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe } /** - * Checks wether a package should be sent out + * Checks whether a package should be sent out * - * @return $isWaitingDelivery Wether a package is waiting for delivery + * @return $isWaitingDelivery Whether a package is waiting for delivery */ - public function isPackageWaitingDelivery () { - // Check wether the stacker is not empty + public function isPackageWaitingForDelivery () { + // Check whether the stacker is not empty $isWaitingDelivery = (($this->getStackerInstance()->isStackInitialized(self::STACKER_NAME_OUTGOING)) && (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_OUTGOING))); // Return the result @@ -358,15 +697,14 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe return; } // END - if - // Now we know for sure there are packages to deliver, we can start - // with the first one. - $packageData = $this->getStackerInstance()->getNamed(self::STACKER_NAME_UNDECLARED); - - // Finally, deliver the package - $this->deliverPackage($packageData); + /* + * Now there are for sure packages to deliver, so start with the first + * one. + */ + $packageData = $this->getStackerInstance()->popNamed(self::STACKER_NAME_UNDECLARED); - // And remove it finally - $this->getStackerInstance()->popNamed(self::STACKER_NAME_UNDECLARED); + // Declare the raw package data for delivery + $this->declareRawPackageData($packageData); } /** @@ -380,18 +718,30 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe // Sanity check if we have packages declared if (!$this->isPackageDeclared()) { // This is not fatal but should be avoided - // @TODO Add some logging here + self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: No package has been declared, but ' . __METHOD__ . ' has been called!'); return; } // END - if - // Get the package again + // Get the package $packageData = $this->getStackerInstance()->getNamed(self::STACKER_NAME_DECLARED); - // And send it - $this->sendRawPackage($packageData); + // Assert on it + assert(isset($packageData[self::PACKAGE_DATA_RECIPIENT])); - // And remove it finally - $this->getStackerInstance()->popNamed(self::STACKER_NAME_DECLARED); + // Try to deliver the package + try { + // And try to send it + $this->deliverRawPackageData($packageData); + + // And remove it finally + $this->getStackerInstance()->popNamed(self::STACKER_NAME_DECLARED); + } catch (InvalidStateException $e) { + // The state is not excepected (shall be 'connected') + self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Caught ' . $e->__toString() . ',message=' . $e->getMessage()); + + // Mark the package with status failed + $this->changePackageStatus($packageData, self::STACKER_NAME_DECLARED, self::PACKAGE_STATUS_FAILED); + } } /** @@ -400,31 +750,403 @@ class NetworkPackage extends BaseFrameworkSystem implements Deliverable, Registe * @return void */ public function sendWaitingPackage () { - // Sent any waiting bytes in the back-buffer + // Send any waiting bytes in the back-buffer before sending a new package $this->sendBackBufferBytes(); // Sanity check if we have packages waiting for delivery - if (!$this->isPackageWaitingDelivery()) { + if (!$this->isPackageWaitingForDelivery()) { // This is not fatal but should be avoided - // @TODO Add some logging here + self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: No package is waiting for delivery, but ' . __METHOD__ . ' was called.'); return; } // END - if - // Get the package again + // Get the package $packageData = $this->getStackerInstance()->getNamed(self::STACKER_NAME_OUTGOING); try { // Now try to send it - $this->sendOutgoingPackage($packageData); - die("O!\n"); + $this->sendOutgoingRawPackageData($packageData); // And remove it finally $this->getStackerInstance()->popNamed(self::STACKER_NAME_OUTGOING); } catch (InvalidSocketException $e) { // Output exception message - $this->debugOutput('PACKAGE: Package was not delivered: ' . $e->getMessage()); + self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Package was not delivered: ' . $e->getMessage()); + + // Mark package as failed + $this->changePackageStatus($packageData, self::STACKER_NAME_OUTGOING, self::PACKAGE_STATUS_FAILED); } } + + /////////////////////////////////////////////////////////////////////////// + // Receiving packages / raw data + /////////////////////////////////////////////////////////////////////////// + + /** + * Checks whether decoded raw data is pending + * + * @return $isPending Whether decoded raw data is pending + */ + private function isRawDataPending () { + // Just return whether the stack is not empty + $isPending = (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_DECODED_INCOMING)); + + // Return the status + return $isPending; + } + + /** + * Checks whether new raw package data has arrived at a socket + * + * @param $poolInstance An instance of a PoolableListener class + * @return $hasArrived Whether new raw package data has arrived for processing + */ + public function isNewRawDataPending (PoolableListener $poolInstance) { + // Visit the pool. This monitors the pool for incoming raw data. + $poolInstance->accept($this->getVisitorInstance()); + + // Check for new data arrival + $hasArrived = $this->isRawDataPending(); + + // Return the status + return $hasArrived; + } + + /** + * Handles the incoming decoded raw data. This method does not "convert" the + * decoded data back into a package array, it just "handles" it and pushs it + * on the next stack. + * + * @return void + */ + public function handleIncomingDecodedData () { + /* + * This method should only be called if decoded raw data is pending, + * so check it again. + */ + if (!$this->isRawDataPending()) { + // This is not fatal but should be avoided + // @TODO Add some logging here + return; + } // END - if + + // Very noisy debug message: + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: Stacker size is ' . $this->getStackerInstance()->getStackCount(self::STACKER_NAME_DECODED_INCOMING) . ' entries.'); + + // "Pop" the next entry (the same array again) from the stack + $decodedData = $this->getStackerInstance()->popNamed(self::STACKER_NAME_DECODED_INCOMING); + + // Make sure both array elements are there + assert( + (is_array($decodedData)) && + (isset($decodedData[BaseRawDataHandler::PACKAGE_RAW_DATA])) && + (isset($decodedData[BaseRawDataHandler::PACKAGE_ERROR_CODE])) + ); + + /* + * Also make sure the error code is SOCKET_ERROR_UNHANDLED because we + * only want to handle unhandled packages here. + */ + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: errorCode=' . $decodedData[BaseRawDataHandler::PACKAGE_ERROR_CODE] . '(' . BaseRawDataHandler::SOCKET_ERROR_UNHANDLED . ')'); + assert($decodedData[BaseRawDataHandler::PACKAGE_ERROR_CODE] == BaseRawDataHandler::SOCKET_ERROR_UNHANDLED); + + // Remove the last chunk SEPARATOR (because it is being added and we don't need it) + if (substr($decodedData[BaseRawDataHandler::PACKAGE_RAW_DATA], -1, 1) == PackageFragmenter::CHUNK_SEPARATOR) { + // It is there and should be removed + $decodedData[BaseRawDataHandler::PACKAGE_RAW_DATA] = substr($decodedData[BaseRawDataHandler::PACKAGE_RAW_DATA], 0, -1); + } // END - if + + // This package is "handled" and can be pushed on the next stack + $this->getStackerInstance()->pushNamed(self::STACKER_NAME_DECODED_HANDLED, $decodedData); + } + + /** + * Adds raw decoded data from the given handler instance to this receiver + * + * @param $handlerInstance An instance of a Networkable class + * @return void + */ + public function addRawDataToIncomingStack (Networkable $handlerInstance) { + /* + * Get the decoded data from the handler, this is an array with + * 'raw_data' and 'error_code' as elements. + */ + $decodedData = $handlerInstance->getNextRawData(); + + // Very noisy debug message: + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: decodedData[' . gettype($decodedData) . ']=' . print_r($decodedData, true)); + + // And push it on our stack + $this->getStackerInstance()->pushNamed(self::STACKER_NAME_DECODED_INCOMING, $decodedData); + } + + /** + * Checks whether incoming decoded data is handled. + * + * @return $isHandled Whether incoming decoded data is handled + */ + public function isIncomingRawDataHandled () { + // Determine if the stack is not empty + $isHandled = (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_DECODED_HANDLED)); + + // Return it + return $isHandled; + } + + /** + * Checks whether the assembler has pending data left + * + * @return $isHandled Whether the assembler has pending data left + */ + public function ifAssemblerHasPendingDataLeft () { + // Determine if the stack is not empty + $isHandled = (!$this->getAssemblerInstance()->isPendingDataEmpty()); + + // Return it + return $isHandled; + } + + /** + * Handles the attached assemler's pending data queue to be finally + * assembled to the raw package data back. + * + * @return void + */ + public function handleAssemblerPendingData () { + // Handle it + $this->getAssemblerInstance()->handlePendingData(); + } + + /** + * Assembles incoming decoded data so it will become an abstract network + * package again. The assembler does later do it's job by an other task, + * not this one to keep best speed possible. + * + * @return void + */ + public function assembleDecodedDataToPackage () { + // Make sure the raw decoded package data is handled + assert($this->isIncomingRawDataHandled()); + + // Get current package content (an array with two elements; see handleIncomingDecodedData() for details) + $packageContent = $this->getStackerInstance()->getNamed(self::STACKER_NAME_DECODED_HANDLED); + + // Start assembling the raw package data array by chunking it + $this->getAssemblerInstance()->chunkPackageContent($packageContent); + + // Remove the package from 'handled_decoded' stack ... + $this->getStackerInstance()->popNamed(self::STACKER_NAME_DECODED_HANDLED); + + // ... and push it on the 'chunked' stacker + $this->getStackerInstance()->pushNamed(self::STACKER_NAME_DECODED_CHUNKED, $packageContent); + } + + /** + * Accepts the visitor to process the visit "request" + * + * @param $visitorInstance An instance of a Visitor class + * @return void + */ + public function accept (Visitor $visitorInstance) { + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: ' . $visitorInstance->__toString() . ' has visited - START'); + + // Visit the package + $visitorInstance->visitNetworkPackage($this); + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: ' . $visitorInstance->__toString() . ' has visited - FINISHED'); + } + + /** + * Clears all stacker + * + * @return void + */ + public function clearAllStacker () { + // Call the init method to force re-initialization + $this->initStackers(true); + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: All stacker have been re-initialized.'); + } + + /** + * Removes the first failed outoging package from the stack to continue + * with next one (it will never work until the issue is fixed by you). + * + * @return void + * @throws UnexpectedPackageStatusException If the package status is not 'failed' + * @todo This may be enchanced for outgoing packages? + */ + public function removeFirstFailedPackage () { + // Get the package again + $packageData = $this->getStackerInstance()->getNamed(self::STACKER_NAME_DECLARED); + + // Is the package status 'failed'? + if ($packageData[self::PACKAGE_DATA_STATUS] != self::PACKAGE_STATUS_FAILED) { + // Not failed! + throw new UnexpectedPackageStatusException(array($this, $packageData, self::PACKAGE_STATUS_FAILED), BaseListener::EXCEPTION_UNEXPECTED_PACKAGE_STATUS); + } // END - if + + // Remove this entry + $this->getStackerInstance()->popNamed(self::STACKER_NAME_DECLARED); + } + + /** + * "Decode" the package content into the same array when it was sent. + * + * @param $rawPackageContent The raw package content to be "decoded" + * @return $decodedData An array with 'sender', 'recipient', 'content' and 'status' elements + */ + public function decodeRawContent ($rawPackageContent) { + // Use the separator '#' to "decode" it + $decodedArray = explode(self::PACKAGE_DATA_SEPARATOR, $rawPackageContent); + + // Assert on count (should be always 3) + assert(count($decodedArray) == self::DECODED_DATA_ARRAY_SIZE); + + // Generate the signature of comparing it + /* + * @todo Unsupported feature of "signed" messages commented out + if (!$this->isPackageSignatureValid($decodedArray)) { + // Is not valid, so throw an exception here + exit(__METHOD__ . ':INVALID SIG! UNDER CONSTRUCTION!' . chr(10)); + } // END - if + */ + + /* + * Create 'decodedData' array with all assoziative array elements, + * except signature. + */ + $decodedData = array( + self::PACKAGE_DATA_SENDER => $decodedArray[self::INDEX_PACKAGE_SENDER], + self::PACKAGE_DATA_RECIPIENT => $decodedArray[self::INDEX_PACKAGE_RECIPIENT], + self::PACKAGE_DATA_CONTENT => $decodedArray[self::INDEX_PACKAGE_CONTENT], + self::PACKAGE_DATA_STATUS => self::PACKAGE_STATUS_DECODED + ); + + // And return it + return $decodedData; + } + + /** + * Handles decoded data for this node by "decoding" the 'content' part of + * it. Again this method uses explode() for the "decoding" process. + * + * @param $decodedData An array with decoded raw package data + * @return void + * @throws InvalidDataChecksumException If the checksum doesn't match + */ + public function handleRawData (array $decodedData) { + /* + * "Decode" the package's content by a simple explode() call, for + * details of the array elements, see comments for constant + * PACKAGE_MASK. + */ + $decodedContent = explode(self::PACKAGE_MASK_SEPARATOR, $decodedData[self::PACKAGE_DATA_CONTENT]); + + // Assert on array count for a very basic validation + assert(count($decodedContent) == self::PACKAGE_CONTENT_ARRAY_SIZE); + + /* + * Convert the indexed array into an associative array. This is much + * better to remember than plain numbers, isn't it? + */ + $decodedContent = array( + // Compressor's extension used to compress the data + self::PACKAGE_CONTENT_EXTENSION => $decodedContent[self::INDEX_COMPRESSOR_EXTENSION], + // Package data (aka "message") in BASE64-decoded form but still compressed + self::PACKAGE_CONTENT_MESSAGE => base64_decode($decodedContent[self::INDEX_PACKAGE_DATA]), + // Tags as an indexed array for "tagging" the message + self::PACKAGE_CONTENT_TAGS => explode(self::PACKAGE_TAGS_SEPARATOR, $decodedContent[self::INDEX_TAGS]), + // Checksum of the _decoded_ data + self::PACKAGE_CONTENT_CHECKSUM => $decodedContent[self::INDEX_CHECKSUM] + ); + + // Is the checksum valid? + if (!$this->isChecksumValid($decodedContent, $decodedData)) { + // Is not the same, so throw an exception here + throw new InvalidDataChecksumException(array($this, $decodedContent, $decodedData), BaseListener::EXCEPTION_INVALID_DATA_CHECKSUM); + } // END - if + + /* + * The checksum is the same, then it can be decompressed safely. The + * original message is at this point fully decoded. + */ + $decodedContent[self::PACKAGE_CONTENT_MESSAGE] = $this->getCompressorInstance()->decompressStream($decodedContent[self::PACKAGE_CONTENT_MESSAGE]); + + // And push it on the next stack + $this->getStackerInstance()->pushNamed(self::STACKER_NAME_NEW_MESSAGE, $decodedContent); + } + + /** + * Checks whether a new message has arrived + * + * @return $hasArrived Whether a new message has arrived for processing + */ + public function isNewMessageArrived () { + // Determine if the stack is not empty + $hasArrived = (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_NEW_MESSAGE)); + + // Return it + return $hasArrived; + } + + /** + * Handles newly arrived messages + * + * @return void + * @todo Implement verification of all sent tags here? + */ + public function handleNewlyArrivedMessage () { + // Get it from the stacker, it is the full array with the decoded message + $decodedContent = $this->getStackerInstance()->popNamed(self::STACKER_NAME_NEW_MESSAGE); + + // Now get a filter chain back from factory with given tags array + $chainInstance = PackageFilterChainFactory::createChainByTagsArray($decodedContent[self::PACKAGE_CONTENT_TAGS]); + + /* + * Process the message through all filters, note that all other + * elements from $decodedContent are no longer needed. + */ + $chainInstance->processMessage($decodedContent[self::PACKAGE_CONTENT_MESSAGE], $this); + } + + /** + * Checks whether a processed message is pending for "interpretation" + * + * @return $isPending Whether a processed message is pending + */ + public function isProcessedMessagePending () { + // Check it + $isPending = (!$this->getStackerInstance()->isStackEmpty(self::STACKER_NAME_PROCESSED_MESSAGE)); + + // Return it + return $isPending; + } + + /** + * Handle processed messages by "interpreting" the 'message_type' element + * + * @return void + */ + public function handleProcessedMessage () { + // Get it from the stacker, it is the full array with the processed message + $messageArray = $this->getStackerInstance()->popNamed(self::STACKER_NAME_PROCESSED_MESSAGE); + + // Add type for later easier handling + $messageArray[self::MESSAGE_ARRAY_DATA][self::MESSAGE_ARRAY_TYPE] = $messageArray[self::MESSAGE_ARRAY_TYPE]; + + // Debug message + //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__)->debugOutput('NETWORK-PACKAGE[' . __LINE__ . ']: messageArray=' . print_r($messageArray, true)); + + // Create a handler instance from given message type + $handlerInstance = MessageTypeHandlerFactory::createMessageTypeHandlerInstance($messageArray[self::MESSAGE_ARRAY_TYPE]); + + // Handle message data + $handlerInstance->handleMessageData($messageArray[self::MESSAGE_ARRAY_DATA], $this); + } } // [EOF]