PHP ZMQSocket::bind方法代码示例

 private function initSocket()
 {
     $zmq_context = new \ZMQContext();
     $this->zmq_socket = $zmq_context->getSocket(\ZMQ::SOCKET_REP);
     $this->zmq_socket->bind('ipc:///tmp/ebussola-job-schedule.ipc');
     chmod('/tmp/ebussola-job-schedule.ipc', 0777);
 }

 /**
  * @param string $protocol
  * @param string $encoding
  * @param bool   $synchronous
  * @param array  $endpoint
  */
 public function __construct($protocol, $encoding, $synchronous = false, array $endpoint = [])
 {
     parent::__construct($protocol, $encoding, $synchronous, $endpoint);
     list($type, $dsn, $force, $mode) = array_values($this->endpoint);
     $this->context = new \ZMQContext();
     $this->socket = new \ZMQSocket($this->context, $type);
     $this->socket->bind($dsn, $force);
     $this->mode = $mode;
 }

 public function connect()
 {
     $context = new \ZMQContext();
     $socket = new \ZMQSocket($context, \ZMQ::SOCKET_SUB);
     $socket->bind($this->dsn());
     return $socket;
 }

function broker_task()
{
    //  Prepare our context and sockets
    $context = new ZMQContext();
    $frontend = new ZMQSocket($context, ZMQ::SOCKET_ROUTER);
    $backend = new ZMQSocket($context, ZMQ::SOCKET_ROUTER);
    $frontend->bind("tcp://*:5555");
    $backend->bind("tcp://*:5556");
    //  Initialize poll set
    $poll = new ZMQPoll();
    $poll->add($frontend, ZMQ::POLL_IN);
    $poll->add($backend, ZMQ::POLL_IN);
    $read = $write = array();
    while (true) {
        $events = $poll->poll($read, $write);
        foreach ($read as $socket) {
            $zmsg = new Zmsg($socket);
            $zmsg->recv();
            if ($socket === $frontend) {
                $zmsg->push("W");
                $zmsg->set_socket($backend)->send();
            } elseif ($socket === $backend) {
                $zmsg->pop();
                $zmsg->push("C");
                $zmsg->set_socket($frontend)->send();
            }
        }
    }
}

 public function collect(OutputInterface $output)
 {
     $context = new \ZMQContext();
     $resultsQueue = new \ZMQSocket($context, \ZMQ::SOCKET_PULL);
     $resultsQueue->bind(Spider::ZMQ_RESULTS_QUEUE_BIND_DSN);
     $statusQueue = new \ZMQSocket($context, \ZMQ::SOCKET_PUSH);
     $statusQueue->bind(Spider::ZMQ_STATUS_QUEUE_BIND_DSN);
     $tstart = microtime(true);
     $collectedResults = 0;
     $expectedResults = PHP_INT_MAX;
     $output->writeln('Collecting Task results');
     while ($collectedResults < $expectedResults) {
         $string = $resultsQueue->recv();
         if ($string === Spider::ZMQ_COMMAND_BATCH_START) {
             //  Wait for start of batch
         } elseif (stripos($string, Spider::ZMQ_COMMAND_BATCH_END) === false) {
             $output->writeln('Got task result: ' . substr($string, 0, 20) . ' ...');
             file_put_contents($this->resultsTargetPath . '/' . md5($string) . '.result', $string);
             // TODO: use Symfony/Filesystem
             $output->writeln('Collected results so far: ' . ++$collectedResults);
         } else {
             $expectedResults = (int) explode('%', $string)[1];
             $output->writeln('[INFO] Trying to collect ' . $expectedResults . ' as requested by Task Loader');
         }
     }
     $tend = microtime(true);
     $totalMsec = ($tend - $tstart) * 1000;
     $output->writeln('Task results collecting finished. Got ' . $collectedResults . ' results');
     $output->writeln("Total elapsed time: {$totalMsec} msec");
     $output->writeln('Sending Task Result Collector info');
     $statusQueue->send($collectedResults);
 }

 /**
  * Start the worker and wait for requests
  */
 public function listen()
 {
     $context = new \ZMQContext();
     $server = new \ZMQSocket($context, \ZMQ::SOCKET_PULL);
     $server->bind('tcp://127.0.0.1:' . ($this->defaultPort + $this->client->getId() - 1));
     $this->logger->info('Client worker ' . $this->client . ' is ready');
     while (true) {
         $request = $server->recv();
         $this->logger->debug('Client worker ' . $this->client . ' receiving request : ' . $request);
         // Check if the input is valid, ignore if wrong
         $request = json_decode($request, true);
         if (!$this->isValidInput($request)) {
             $this->logger->error('Client worker ' . $this->client . ' received an invalid input');
             continue;
         }
         try {
             // Call the right method in the client and push to redis the result
             $result = call_user_func_array(array($this->client, $request['command']), $request['parameters']);
         } catch (ClientNotReadyException $e) {
             $this->logger->warning('Client worker ' . $this->client . ' received a request (#' . $request['invokeId'] . ') whereas the client is not ready. This is normal in case of client reconnection process. Ignoring.');
             continue;
         }
         $key = $this->key . '.client.commands.' . $request['invokeId'];
         $this->redis->rpush($key, serialize($result));
         $this->redis->expire($key, $this->expire);
     }
 }

 /**
  * Run ZMQ interface for generator
  * 
  * Req-rep pattern; msgs are commands:
  * 
  * GEN    = Generate ID
  * STATUS = Get status string
  */
 public function run()
 {
     $context = new \ZMQContext();
     $receiver = new \ZMQSocket($context, \ZMQ::SOCKET_REP);
     $bindTo = 'tcp://*:' . $this->port;
     echo "Binding to {$bindTo}\n";
     $receiver->bind($bindTo);
     while (TRUE) {
         $msg = $receiver->recv();
         switch ($msg) {
             case 'GEN':
                 try {
                     $response = $this->generator->generate();
                 } catch (\Exception $e) {
                     $response = "ERROR";
                 }
                 break;
             case 'STATUS':
                 $response = json_encode($this->generator->status());
                 break;
             default:
                 $response = 'UNKNOWN COMMAND';
                 break;
         }
         $receiver->send($response);
     }
 }

 /**
  * @return void
  */
 protected function init()
 {
     $this->logger->info("Running " . self::class . " on " . str_replace("\n", "", `hostname; echo ' - ';uname -a;`));
     $this->logger->info("The eviction tick rate is set to {$this->config->getEvictionTicksPerSec()}/second.");
     // Create the event loop
     $this->reactLoop = React\EventLoop\Factory::create();
     // Object pool
     $this->queue = new PriorityHashQueue();
     // In default mode the latest data will be replaced for a given key. In DATA_MODE_APPEND the data will be appended
     // internally and available within the consumer as array (for instance for reducing purposes)
     //$this->queue->setDataMode(PriorityHashQueue::DATA_MODE_APPEND);
     // Setup ZMQ to send evicted objects.
     $this->zmqContext = new React\ZMQ\Context($this->reactLoop);
     $this->logger->info("Binding inbound ZMQ to '{$this->config->getZmqIn()}'.");
     // Receiver queue for incoming objects
     $this->zmqInboundQueue = $this->zmqContext->getSocket(\ZMQ::SOCKET_PULL);
     $this->zmqInboundQueue->bind($this->config->getZmqIn());
     $this->logger->info("Binding outbound ZMQ to '{$this->config->getZmqOut()}'.");
     // Outgoing queue for evicted objects
     $this->zmqOutboundQueue = $this->zmqContext->getSocket(\ZMQ::SOCKET_PUSH);
     $this->zmqOutboundQueue->bind($this->config->getZmqOut());
     // Register events
     $this->registerInboundEvents();
     $this->registerEvictionEvents();
     $this->registerTimedEvents();
 }

 /**
  * @param \ZMQContext $context
  * @return bool
  */
 public function connect(\ZMQContext $context)
 {
     $this->clientChannel = new \ZMQSocket($context, ZMQ::SOCKET_ROUTER);
     $this->workerChannel = new \ZMQSocket($context, ZMQ::SOCKET_ROUTER);
     try {
         $this->clientChannel->bind("tcp://*:{$this->config->getClientPort()}");
         $this->workerChannel->bind("tcp://*:{$this->config->getWorkerPort()}");
         return true;
     } catch (\ZMQSocketException $e) {
         return false;
     } catch (\ZMQException $e) {
         return false;
     } catch (\Exception $e) {
         return false;
     }
 }

 /**
  * @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);
 }

 /**
  * @param array[string]string $connUris
  */
 private function initSockets(array $connUris)
 {
     // Create context
     $this->reactLoop = ReactFactory::create();
     /** @var ReactZmqContext|\ZMQContext $reactZmqContext */
     $reactZmqContext = new ReactZmqContext($this->reactLoop);
     $this->hbSocket = $reactZmqContext->getSocket(\ZMQ::SOCKET_REP);
     $this->hbSocket->bind($connUris['hb']);
     $this->iopubSocket = $reactZmqContext->getSocket(\ZMQ::SOCKET_PUB);
     $this->iopubSocket->bind($connUris['iopub']);
     $this->controlSocket = $reactZmqContext->getSocket(\ZMQ::SOCKET_ROUTER);
     $this->controlSocket->bind($connUris['control']);
     $this->stdinSocket = $reactZmqContext->getSocket(\ZMQ::SOCKET_ROUTER);
     $this->stdinSocket->bind($connUris['stdin']);
     $this->shellSocket = $reactZmqContext->getSocket(\ZMQ::SOCKET_ROUTER);
     $this->shellSocket->bind($connUris['shell']);
 }

 protected function setupPullSocket($queueId)
 {
     $connect = true;
     if (!empty($this->pull)) {
         $endpoints = $this->pull->getendpoints();
         if (!empty($endpoints["bind"][0]) && $endpoints["bind"][0] != $queueId) {
             $this->pull->unbind($endpoints["bind"][0]);
         } else {
             $connect = false;
         }
     } else {
         $this->pull = $this->socketFactory->createPullSocket();
     }
     if ($connect) {
         $this->pull->bind($queueId);
     }
 }

 /**
  * @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;
 }

 /**
  * Binds broker to endpoint
  *
  * We use a single socket for both clients and workers.
  *
  * @param   string   $endpoint
  * @return  Broker
  */
 public function bind($endpoint)
 {
     $this->endpoint = $endpoint;
     $this->socket->bind($this->endpoint);
     if ($this->verbose) {
         $this->log("ZMQDEBUG", "MDP broker/0.1.1 is active at %s", $this->endpoint);
     }
     return $this;
 }

 /**
  * @return null
  */
 protected function initSockets()
 {
     $this->replyToReplyStack = $this->context->getSocket(\ZMQ::SOCKET_REP);
     $this->replyToReplyStack->bind($this->pulsarSocketsParams->getReplyToReplyStackSocketAddress());
     $this->publisher = $this->context->getSocket(\ZMQ::SOCKET_PUB);
     $this->publisher->bind($this->pulsarSocketsParams->getPublishSocketAddress());
     $this->pullActionInfo = $this->context->getSocket(\ZMQ::SOCKET_PULL);
     $this->pullActionInfo->bind($this->pulsarSocketsParams->getPullSocketAddress());
     return null;
 }