PHP ZMQSocket::setSockOpt方法代码示例

 public function mainAction()
 {
     echo "Madserver\n";
     $context = new ZMQContext();
     $sub_socket = new ZMQSocket($context, ZMQ::SOCKET_SUB);
     $sub_socket->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "");
     $sub_socket->setSockOpt(ZMQ::SOCKOPT_TCP_KEEPALIVE, 0);
     $sub_socket->setSockOpt(ZMQ::SOCKOPT_TCP_KEEPALIVE_IDLE, 10);
     $sub_socket->setSockOpt(ZMQ::SOCKOPT_TCP_KEEPALIVE_CNT, 2);
     $sub_socket->setSockOpt(ZMQ::SOCKOPT_TCP_KEEPALIVE_INTVL, 5);
     $sub_socket->connect("tcp://127.0.0.1:5557");
     $snapshot = new ZMQSocket($context, ZMQ::SOCKET_DEALER);
     $snapshot->connect("tcp://127.0.0.1:5556");
     $sequence = 1;
     $snapshot->sendmulti(array("ICANHAZ?", self::SUBTREE), ZMQ::MODE_SNDMORE);
     while (1) {
         $kvmsg = new Zmq_Kvmsg($sequence);
         $kvmsg->recv($snapshot);
         if ($kvmsg->key() == "KTHXBAI") {
             echo "I: received snapshot=" . $kvmsg->sequence() . "\n";
             break;
         }
     }
     while (1) {
         $kvmsg = new Zmq_Kvmsg($sequence);
         $kvmsg->recv($sub_socket);
         echo "I: start receive sub=" . $kvmsg->sequence() . "\n";
         $kvmsg->dump();
     }
     return false;
 }

 /**
  * @param $context
  * @param $endpoint
  * @return Zmsg
  */
 private function createSubscriber($context, $endpoint)
 {
     $receiver = new \ZMQSocket($context, \ZMQ::SOCKET_SUB);
     $receiver->setSockOpt(\ZMQ::SOCKOPT_LINGER, 0);
     $receiver->setSockOpt(\ZMQ::SOCKOPT_SUBSCRIBE, "");
     $receiver->connect($endpoint);
     return new Zmsg($receiver);
 }

 /**
  * @param $context
  * @param $endpoint
  * @return Zmsg
  */
 private function createCollector($context, $endpoint)
 {
     $receiver = new \ZMQSocket($context, \ZMQ::SOCKET_SUB);
     $receiver->setSockOpt(\ZMQ::SOCKOPT_LINGER, 0);
     $receiver->setSockOpt(\ZMQ::SOCKOPT_SUBSCRIBE, "");
     $receiver->bind($endpoint);
     return $receiver;
 }

 /**
  * @param $context
  * @param $endpoint
  * @return Zmsg
  */
 private function createPublisher($context, $endpoint)
 {
     $publisher = new \ZMQSocket($context, \ZMQ::SOCKET_PUB);
     $publisher->setSockOpt(\ZMQ::SOCKOPT_SNDHWM, 1);
     $publisher->setSockOpt(\ZMQ::SOCKOPT_LINGER, 0);
     $publisher->bind($endpoint);
     return new Zmsg($publisher);
 }

 /**
  * Connects or reconnect to broker
  *
  * @return  AsynClient
  */
 public function connect()
 {
     if ($this->client) {
         unset($this->client);
     }
     $this->client = new ZMQSocket($this->context, ZMQ::SOCKET_DEALER);
     $this->client->setSockOpt(ZMQ::SOCKOPT_LINGER, 0);
     $this->client->connect($this->broker);
     if ($this->verbose) {
         $this->log("ZMQDEBUG", "connecting to broker at %s...", $this->broker);
     }
     return $this;
 }

function s_worker_socket($context)
{
    $worker = new ZMQSocket($context, ZMQ::SOCKET_DEALER);
    //  Set random identity to make tracing easier
    $identity = sprintf("%04X-%04X", rand(0, 0x10000), rand(0, 0x10000));
    $worker->setSockOpt(ZMQ::SOCKOPT_IDENTITY, $identity);
    $worker->connect("tcp://localhost:5556");
    //  Configure socket to not wait at close time
    $worker->setSockOpt(ZMQ::SOCKOPT_LINGER, 0);
    //  Tell queue we're ready for work
    printf("I: (%s) worker ready%s", $identity, PHP_EOL);
    $worker->send("READY");
    return array($worker, $identity);
}

function client_task()
{
    $context = new ZMQContext();
    $client = new ZMQSocket($context, ZMQ::SOCKET_DEALER);
    //  Generate printable identity for the client
    $identity = sprintf("%04X", rand(0, 0x10000));
    $client->setSockOpt(ZMQ::SOCKOPT_IDENTITY, $identity);
    $client->connect("tcp://localhost:5570");
    $read = $write = array();
    $poll = new ZMQPoll();
    $poll->add($client, ZMQ::POLL_IN);
    $request_nbr = 0;
    while (true) {
        //  Tick once per second, pulling in arriving messages
        for ($centitick = 0; $centitick < 100; $centitick++) {
            $events = $poll->poll($read, $write, 1000);
            $zmsg = new Zmsg($client);
            if ($events) {
                $zmsg->recv();
                printf("%s: %s%s", $identity, $zmsg->body(), PHP_EOL);
            }
        }
        $zmsg = new Zmsg($client);
        $zmsg->body_fmt("request #%d", ++$request_nbr)->send();
    }
}

 /**
  * @param string|null $queueId
  * @param int $waitTime
  *
  * @return QueueMessage
  */
 public function receiveMessage($queueId = null, $waitTime = null)
 {
     $queueId = empty($queueId) ? $this->getQueueId() : $queueId;
     $this->setupPullSocket($queueId);
     $this->pull->setSockOpt(\ZMQ::SOCKOPT_RCVTIMEO, isset($waitTime) ? $waitTime : $this->waitTime);
     $message = $this->pull->recv();
     return $this->messageFactory->createMessage($message, $queueId);
 }

function client_socket(ZMQContext $context)
{
    echo "I: connecting to server...", PHP_EOL;
    $client = new ZMQSocket($context, ZMQ::SOCKET_REQ);
    $client->connect("tcp://localhost:5555");
    //  Configure socket to not wait at close time
    $client->setSockOpt(ZMQ::SOCKOPT_LINGER, 0);
    return $client;
}

 public function pushActionResultInfo(ActionResultingPushDto $resultingPushDto)
 {
     $this->subscriberSocket->setSockOpt(\ZMQ::SOCKOPT_UNSUBSCRIBE, "");
     $this->performerEarlyTerminated->setStandOnSubscription(false);
     $this->logger->debug("Performer was unsubscribed.");
     $this->initOrCheckPushConnection();
     $this->pushSocket->send(serialize($resultingPushDto));
     $this->logger->debug("Performer send actionResulting msg.");
     return null;
 }

function worker_task()
{
    $context = new ZMQContext();
    $worker = new ZMQSocket($context, ZMQ::SOCKET_DEALER);
    $worker->setSockOpt(ZMQ::SOCKOPT_IDENTITY, "W");
    $worker->connect("tcp://localhost:5556");
    while (true) {
        $zmsg = new Zmsg($worker);
        $zmsg->recv();
        $zmsg->send();
    }
}

 public function handlerAction()
 {
     try {
         // setup the ZMQ content so as to avoid issues with conflicts
         $ctx = new \ZMQContext();
         // create a SOCKET_REP server
         $server = new \ZMQSocket($ctx, \ZMQ::SOCKET_REP);
         //  configure the server socket to not wait at close time
         // this is intended to minimise the possibility of messages being received and not handled
         // however as is mentioned in the TODO below they should be handle them explicitly
         $server->setSockOpt(\ZMQ::SOCKOPT_LINGER, 0);
         // bind it to tcp on port 5454
         $server->bind('tcp://*:5454');
         // create a Poll object to enable us to utilize the REQUEST_TIMEOUT functionality
         $poll = new \ZMQPoll();
         $poll->add($server, \ZMQ::POLL_IN);
         // initialise the read/write buffers for polling
         $read = $write = array();
         // get the time that we start the loop
         $start = time();
         do {
             // this instruction will wait for a message or the timeout to occur
             $events = $poll->poll($read, $write, REQUEST_TIMEOUT);
             // @TODO since exiting the loop will happens after this point a race condition exists
             // We need to consider solutions that will ensure ALL messages to $server are processed
             // if the loop will exit after this iteration.
             // one could check the $events variable as this contains the number of events
             // however in this situation we only want to process the $read resources and can
             // just loop through an array (if it is empty nothing will be done)
             foreach ($read as $socket) {
                 $message = $socket->recv();
                 $server->send($message . ' World');
             }
             // ensure that even when a message is processed the handler
             // does not timeout until the REQUEST_TIMEOUT period
             // has elapsed
             $active = time() - $start < REQUEST_TIMEOUT / 1000.0;
         } while ($active);
     } catch (Exception $e) {
         // handle the exception
         // @TODO
     }
     // exit the handler
     die('This handler has timed out');
 }

function subscriber()
{
    $context = new ZMQContext();
    // Subscribe to everything
    $subscriber = new ZMQSocket($context, ZMQ::SOCKET_SUB);
    $subscriber->connect("tcp://localhost:5556");
    $subscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "");
    //  Get and process messages
    while (true) {
        $clock = $subscriber->recv();
        //  Suicide snail logic
        if (microtime(true) * 100 - $clock * 100 > MAX_ALLOWED_DELAY) {
            echo "E: subscriber cannot keep up, aborting", PHP_EOL;
            break;
        }
        //  Work for 1 msec plus some random additional time
        usleep(1000 + rand(0, 1000));
    }
}

<?php

/*
 *  Durable subscriber
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */
$context = new ZMQContext(1);
//  Connect our subscriber socket
$subscriber = new ZMQSocket($context, ZMQ::SOCKET_SUB);
$subscriber->setSockOpt(ZMQ::SOCKOPT_IDENTITY, "Hello");
$subscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "");
$subscriber->connect("tcp://localhost:5565");
//  Synchronize with publisher
$sync = new ZMQSocket($context, ZMQ::SOCKET_PUSH);
$sync->connect("tcp://localhost:5564");
$sync->send("");
//  Get updates, expect random Ctrl-C death
while (true) {
    $string = $subscriber->recv();
    echo $string, "\n";
    if ($string == "END") {
        break;
    }
}

<?php

$context = new ZMQContext();
// Socket to talk to server
echo "Collecting updates from weather server...", PHP_EOL;
$subscriber = new ZMQSocket($context, ZMQ::SOCKET_SUB);
$subscriber->connect("tcp://localhost:5556");
$subscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, 'Message');
// Process 100 updates
while (true) {
    print $subscriber->recv();
}