Request.inc.php

Go to the documentation of this file.

<?php

namespace HCE\transport {

        require_once 'zmsg.php';
        require_once 'Constants.inc.php';
        require_once 'Response.inc.php';
        require_once 'Connection.inc.php';

        class Request {
                protected $connection = NULL;

                protected $messageId = NULL;

                protected $messageBody = NULL;

                protected $timeout = PROTOCOL_MSG_RESPONSE_TIMEOUT_DEFAULT;

                protected $error = 0;

                public function setConnection($connection = null) {
                        if ($connection == NULL) {
                                $this->connection = new \HCE\transport\Connection ();
                        } else {
                                $this->connection = $connection;
                        }
                }

                public function getConnection() {
                        return $this->connection;
                }

                public function setMessageId($messageId) {
                        if ($messageId == '') {
                                return false;
                        } else {
                                $this->messageId = $messageId;
                                return true;
                        }
                }

                public function getMessageId() {
                        return $this->messageId;
                }

                public function setMessageBody($messageBody) {
                        $this->messageBody = $messageBody;
                }

                public function getMessageBody() {
                        return $this->messageBody;
                }

                public function setErrorCode($errorCode) {
                        $this->error = $errorCode;
                }

                public function getErrorCode() {
                        return $this->error;
                }

                public function __construct($connection = null) {
                        // Set connection
                        $this->setConnection ( $connection );

                        // Set message Id
                        $this->setMessageId ( \HCE\transport\IdGenerator::getMessageId () );

                        // Set message Body
                        $this->setMessageBody ( '' );
                }

                public function __destruct() {
                        $this->connection = NULL;
                }

                public function execute($msgBody = NULL, $timeout = null) {
                        // Reset error state
                        $this->setErrorCode ( 0 );

                        // New response object
                        $response = new \HCE\transport\Response ();

                        $message = array (
                                        'id' => $this->getMessageId (),
                                        'body' => ($msgBody === NULL ? $this->getMessageBody () : $msgBody)
                        );
                        // Send message
                        $ret = $this->messageSend ( $message );

                        // Check state
                        if ($ret ['error'] == PROTOCOL_ERROR_OK) {
                                // Receive response
                                $responseItem = $this->messageReceive ( $timeout === null ? $this->timeout : $timeout );
                                // Check state
                                if ($responseItem ['error'] == PROTOCOL_ERROR_OK) {
                                        if ($responseItem ['messages'] !== NULL) {
                                                // Check response items corespondence for requested message and filter items set
                                                $responseItems = array ();
                                                $wrongItems = 0;
                                                foreach ( $responseItem ['messages'] as $responseItem ) {
                                                        if ($responseItem ['id'] == $message ['id']) {
                                                                $responseItems [] = $responseItem;
                                                        } else {
                                                                $wrongItems ++;
                                                        }
                                                }
                                                if ($wrongItems > 0) {
                                                        $response->setErrorCode ( PROTOCOL_ERROR_WRONG_RESPONSE_MSG_ID );
                                                }
                                                $response->setResponses ( $responseItems );
                                        }
                                } else {
                                        // Set own error code
                                        $this->setErrorCode ( $responseItem ['error'] );
                                        // Set error code for response object
                                        $response->setErrorCode ( $responseItem ['error'] );
                                }
                        } else {
                                // Set error code
                                $this->setErrorCode ( $ret ['error'] );
                                // Set error code for response object
                                $response->setErrorCode ( $ret ['error'] );
                        }

                        return $response;
                }

                public function messageSend($fields_array) {
                        // Init return HCE message array
                        $ret = array (
                                        'error' => PROTOCOL_ERROR_OK,
                                        'message' => null
                        );

                        if (! isset ( $fields_array ['body'] ) || ! isset ( $fields_array ['id'] )) {
                                $ret ['error'] = PROTOCOL_ERROR_FIELDS_NOT_SET;
                        } else {
                                // Create message
                                $ret ['message'] = new \Zmsg ( $this->connection->socket );

                                // Set fields
                                $ret ['message']->wrap ( $fields_array ['body'], NULL );
                                $ret ['message']->wrap ( $fields_array ['id'], NULL );

                                // Send message
                                $ret ['message']->send ();
                        }

                        return $ret;
                }

                protected function messageReceive($timeout = PROTOCOL_MSG_RESPONSE_TIMEOUT_DEFAULT) {
                        // Init return HCE response item array
                        $ret = array (
                                        'error' => PROTOCOL_ERROR_OK,
                                        'messages' => array ()
                        );

                        // Poll socket for a reply, with timeout
                        $read = $write = array ();
                        $poll = new \ZMQPoll ();
                        $poll->add ( $this->connection->socket, \ZMQ::POLL_IN );
                        $events = $poll->poll ( $read, $write, $timeout );
                        // Handle events
                        if ($events) {
                                foreach ( $read as $socket ) {
                                        $zmsg_r = new \Zmsg ( $socket );
                                        $zmsg_r->recv ();
                                        $ret ['messages'] [] = array (
                                                        'error' => PROTOCOL_ERROR_OK,
                                                        'message' => $zmsg_r,
                                                        'id' => $zmsg_r->unwrap (),
                                                        'body' => $zmsg_r->unwrap ()
                                        );
                                        // var_dump ( $ret );
                                }
                        } else {
                                $ret ['error'] = PROTOCOL_ERROR_TIMEOUT;
                        }
                        $poll->remove ( $this->connection->socket );

                        return $ret;
                }
        }
}

?>