PHP ZMQContext::getSocket方法代码示例

 public function __construct()
 {
     $this->servers = 0;
     $this->sequence = 0;
     $this->context = new ZMQContext();
     $this->socket = $this->context->getSocket(ZMQ::SOCKET_DEALER);
 }

 /**
  * @return \ZMQSocket
  */
 private function getSocket()
 {
     if (null == $this->pushSocket) {
         $this->pushSocket = $this->context->getSocket(\ZMQ::SOCKET_PUSH, 'my pusher');
         $this->pushSocket->connect("tcp://localhost:5555");
     }
     return $this->pushSocket;
 }

 /**
  * Connects to the given endpoint
  */
 public function connect()
 {
     $this->context = new \ZMQContext();
     $this->socket = $this->context->getSocket(\ZMQ::SOCKET_PULL);
     if ($this->isDebug()) {
         ConsoleLog::log("Connecting to zmq at '{$this->getZmq()}'");
     }
     $this->socket->connect($this->getZmq());
 }

 /**
  * @param $socketType
  * @param array $options
  * @param bool $justCreate
  * @return \ZMQSocket
  */
 protected function createSocket($socketType, array $options = [], $justCreate = false)
 {
     $socket = $this->context->getSocket($socketType);
     foreach ($options as $key => $value) {
         $socket->setSockOpt($key, $value);
     }
     if (!$justCreate) {
         $this->socket = $socket;
     }
     return $socket;
 }

 protected function _initSockets()
 {
     $this->log('starting to initialize sockets');
     $context = new \ZMQContext();
     $socket = $context->getSocket(\ZMQ::SOCKET_PAIR);
     $socket->connect(sprintf('ipc:///tmp/downloader-%d.ipc', $this->_downloadBundleId));
     $this->_socketToWorker = $socket;
     $socket = $context->getSocket(\ZMQ::SOCKET_DEALER);
     $socket->setSockOpt(\ZMQ::SOCKOPT_IDENTITY, sprintf('downloader/%s', uniqid()));
     $socket->connect($this->_config->get('sockets.queueManager'));
     $this->_socketToQueueManager = $socket;
     $this->_context = $context;
     $this->log('initialized sockets');
 }

 public function __construct($sender_id, $sub_addr, $pub_addr)
 {
     $this->sender_id = $sender_id;
     $ctx = new \ZMQContext();
     $reqs = $ctx->getSocket(\ZMQ::SOCKET_UPSTREAM);
     $reqs->connect($sub_addr);
     $resp = $ctx->getSocket(\ZMQ::SOCKET_PUB);
     $resp->connect($pub_addr);
     $resp->setSockOpt(\ZMQ::SOCKOPT_IDENTITY, $sender_id);
     $this->sub_addr = $sub_addr;
     $this->pub_addr = $pub_addr;
     $this->reqs = $reqs;
     $this->resp = $resp;
 }

 function attack()
 {
     $db = JFactory::getDBO();
     $user = JFactory::getUser();
     $id = JRequest::getvar('id');
     $monster = $this->getMonster($id, $db);
     $player = $this->getPlayer($user, $db);
     $attackRoundMonster = $monster->defence + rand(0, 6);
     $attackRoundPlayer = $monster->attack + rand(0, 6);
     if ($attackRoundPlayer > $attackRoundMonster) {
         $query = "UPDATE #__jigs_monsters SET health = health -10 WHERE id= {$id}";
         $db->setQuery($query);
         $db->query();
         $message = 'You caused 10 hit points of damage';
         MessagesHelper::sendFeedback($user->id, $message);
     }
     $query = "SELECT health FROM  #__jigs_monsters WHERE id= {$id}";
     $db->setQuery($query);
     $result['id'] = $id;
     $result['health'] = $db->loadResult();
     $entryData = array('category' => 'monsterHealthCategory', 'title' => 'title', 'article' => $result, 'when' => time());
     $context = new ZMQContext();
     $socket = $context->getSocket(ZMQ::SOCKET_PUSH, 'my pusher');
     if ($socket->connect("tcp://localhost:5555")) {
         //   echo 'connected';
     }
     if ($socket->send(json_encode($entryData))) {
         //  echo 'delivered';
     }
     return true;
 }

 /**
  * Execute the job.
  *
  * @return void
  */
 public function handle()
 {
     $reader = Reader::createFromPath($this->path);
     $read = 0;
     $saved = 0;
     foreach ($reader->fetchAssoc() as $row) {
         $read++;
         $artist = Artist::firstOrNew(['artist_id' => $row['artist_id']]);
         $artist->artist_id = $row['artist_id'];
         $artist->slug = $row['slug'];
         $artist->name = $row['name'];
         $artist->PID = $row['PID'];
         $artist->year_birth = $row['year_birth'];
         $artist->year_death = $row['year_death'];
         $artist->copyright = $row['copyright'];
         if ($artist->save()) {
             $saved++;
         }
     }
     $report = ['event' => 'artists.imported', 'data' => ['read' => $read, 'saved' => $saved]];
     $message = json_encode($report);
     $context = new \ZMQContext();
     $socket = $context->getSocket(\ZMQ::SOCKET_PUSH, 'my pusher');
     $socket->connect("tcp://localhost:5555");
     $socket->send($message);
 }

 /**
  * Отправка данных на сервер
  *
  * @param array $data
  */
 static function sendDataToServer(array $data)
 {
     $context = new \ZMQContext();
     $socket = $context->getSocket(\ZMQ::SOCKET_PUSH, 'my pusher');
     $socket->connect("tcp://localhost:5555");
     $socket->send(json_encode($data));
 }

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

 /**
  * Execute the job.
  *
  * @return void
  */
 public function handle(MergeManager $mergeManager, FileManager $fileManager)
 {
     $columns = ['PID', 'entity type', 'title', 'document type', 'URL', 'enabled', 'notes', 'format', 'reference', 'order'];
     $items = $mergeManager->fetchAll();
     $writer = Writer::createFromFileObject(new SplTempFileObject());
     $writer->insertOne($columns);
     $count = 0;
     foreach ($items as $item) {
         $row = [$item->object_number, $item->entity_type, $item->object->title, $item->url, $item->enabled, $item->format, $item->representation_order, $item->reference];
         $writer->insertOne($row);
         $count++;
     }
     $output = (string) $writer;
     $timestamp = Carbon::now();
     $fileName = sprintf("import_%s.csv", $timestamp->format('dmY_His'));
     $fileManager->saveFile($fileName, $output);
     $merger = new Merger();
     $merger->filename = $fileName;
     $merger->documents = $count;
     $merger->save();
     $context = new \ZMQContext();
     $socket = $context->getSocket(\ZMQ::SOCKET_PUSH, 'my pusher');
     $socket->connect("tcp://localhost:5555");
     $socket->send('test');
 }

 /**
  * Execute the job.
  *
  * @return void
  */
 public function handle()
 {
     $reader = Reader::createFromPath($this->path);
     $read = 0;
     $saved = 0;
     foreach ($reader->fetchAssoc() as $row) {
         $read++;
         $object_number = $row['object_number'];
         unset($row['object_number']);
         foreach ($row as $key => $value) {
             $document = Document::firstOrNew(['url' => $value]);
             $document->object_number = $object_number;
             $document->url = $value;
             if ($key == "data") {
                 $document->type = "data";
                 $document->order = "";
             } else {
                 list($type, $order) = explode("_", $key);
                 $document->type = $type;
                 $document->order = isset($order) ? $order : "";
             }
             if ($document->save()) {
                 $saved++;
             }
         }
     }
     $report = ['event' => 'documents.imported', 'data' => ['read' => $read, 'saved' => $saved]];
     $message = json_encode($report);
     $context = new \ZMQContext();
     $socket = $context->getSocket(\ZMQ::SOCKET_PUSH, 'my pusher');
     $socket->connect("tcp://localhost:5555");
     $socket->send($message);
 }

function initialize()
{
    global $config, $queue;
    /* Load the config.  Create a publishing socket. */
    // Danger! Danger!
    $json = shell_exec("fedmsg-config");
    $config = json_decode($json, true);
    /* Just make sure everything is sane with the fedmsg config */
    if (!array_key_exists('relay_inbound', $config)) {
        echo "fedmsg-config has no 'relay_inbound'";
        return false;
    }
    $context = new ZMQContext(1, true);
    $queue = $context->getSocket(ZMQ::SOCKET_PUB, "pub-a-dub-dub");
    $queue->setSockOpt(ZMQ::SOCKOPT_LINGER, $config['zmq_linger']);
    if (is_array($config['relay_inbound'])) {
        // API for fedmsg >= 0.5.2
        // TODO - be more robust here and if connecting to the first one fails, try
        // the next, and the next, and etc...
        $queue->connect($config['relay_inbound'][0]);
    } else {
        // API for fedmsg <= 0.5.1
        $queue->connect($config['relay_inbound']);
    }
    # Go to sleep for a brief moment.. just long enough to let our zmq socket
    # initialize.
    if (array_key_exists('post_init_sleep', $config)) {
        usleep($config['post_init_sleep'] * 1000000);
    }
    return true;
}

/**
 * Send real-time notifications to subscribed users
 *
 * @param string $hook   Hook name
 * @param string $type   Hook type
 * @param bool   $result Has anyone sent a message yet?
 * @param array  $params Hook parameters
 * @return bool
 * @access private
 */
function wizmass_notifier_notification_send($hook, $type, $result, $params)
{
    /** @var WizmassNotifier\Interfaces\WizmassNotification $notification */
    $notification = $params['notification'];
    //echo 'got notification: ' . $notification->guid . PHP_EOL;
    //$ia = elgg_set_ignore_access(true);
    //echo 'got subjects: ' . count($notification->getSubjects()) . PHP_EOL;
    //elgg_set_ignore_access($ia);
    require __DIR__ . '/vendor/autoload.php';
    $context = new ZMQContext();
    $socket = $context->getSocket(ZMQ::SOCKET_PUSH, 'my pusher');
    $socket->connect("tcp://localhost:5555");
    $subjects = [];
    foreach ($notification->getSubjects() as $subject) {
        $subjects[] = array('guid' => $subject->guid);
    }
    $msg = new \stdClass();
    $msg->recipient_guids = $subjects;
    //$msg->recipient_guid = $recipient->guid;
    //    $msg->subject_name = $actor->getDisplayName();
    //    $msg->subject_url = $actor->getURL();
    //    $msg->target_name = $entity->getDisplayName();
    //    $msg->target_url = $entity->getURL();
    //    $msg->text = $string;
    //    $msg->icon_url = $actor->getIconURL();
    $msg->data = $notification->BuildNotificationData();
    //echo 'encoded notification data: ' . json_encode($msg) . PHP_EOL;
    $socket->send(json_encode($msg));
}

function worker_thread()
{
    $context = new ZMQContext();
    $worker = $context->getSocket(ZMQ::SOCKET_REQ);
    $worker->connect("ipc://backend.ipc");
    //  Tell broker we're ready for work
    $worker->send("READY");
    while (true) {
        //  Read and save all frames until we get an empty frame
        //  In this example there is only 1 but it could be more
        $address = $worker->recv();
        // Additional logic to clean up workers.
        if ($address == "END") {
            exit;
        }
        $empty = $worker->recv();
        assert(empty($empty));
        //  Get request, send reply
        $request = $worker->recv();
        printf("Worker: %s%s", $request, PHP_EOL);
        $worker->send($address, ZMQ::MODE_SNDMORE);
        $worker->send("", ZMQ::MODE_SNDMORE);
        $worker->send("OK");
    }
}