Use :meth:`NsqdHTTPClient.multipublish` instead.

        .. deprecated:: 1.0.0
358832
def multipublish_http(self, topic, messages, **kwargs):
        
        return self.__http_client.multipublish(topic, messages, **kwargs)
1197222
def mpub(self, topic, *messages):
        ''''''
        return self.send(constants.MPUB + ' ' + topic, messages)
120721
def hideFromPublicBundle(self, otpk_pub):
        

        self.__checkSPKTimestamp()

        for otpk in self.__otpks:
            if otpk.pub == otpk_pub:
                self.__otpks.remove(otpk)
                self.__hidden_otpks.append(otpk)
                self.__refillOTPKs()
1260087
function PubNubTransport(config) {
  this.id = config.id || null;
  this.networkId = config.publish_key || null;
  this['default'] = config['default'] || false;
  this.pubnub = PUBNUB().init(config);
}
601598
function sendPreparedMessageToHub(ws, recipient_device_pubkey, message_hash, json, callbacks){
	if (!callbacks)
		callbacks = {ifOk: function(){}, ifError: function(){}};
	if (typeof ws === "string"){
		var hub_host = ws;
		network.findOutboundPeerOrConnect(conf.WS_PROTOCOL+hub_host, function onLocatedHubForSend(err, ws){
			if (err)
				return callbacks.ifError(err);
			sendPreparedMessageToConnectedHub(ws, recipient_device_pubkey, message_hash, json, callbacks);
		});
	}
	else
		sendPreparedMessageToConnectedHub(ws, recipient_device_pubkey, message_hash, json, callbacks);
}
796564
function rollbackPublish() {
			try {
				chkoutRun(options.distBranch, function() {
					var cph = cmd('git rev-parse HEAD');
					if (pubHash && pubHash !== cph) {
						cmd('git checkout -qf ' + pubHash);
						cmd('git commit -q -m "Rollback: ' + tmpltData.distBranchPubMsg + '"');
						cmd('git push -f ' + options.repoName + ' ' + options.distBranch);
					} else if (!pubHash) {
						cmd('git push ' + options.repoName + ' --delete ' + options.distBranch);
					} else {
						rbot.log.verbose('Skipping rollback for ' + options.distBranch + ' for hash "' + pubHash
								+ '" (current hash: "' + cph + '")');
					}
				});
			} catch (e) {
				var msg = 'Failed to rollback publish branch changes!';
				rollCall.error(msg, e);
			}
		}
1011270
def publish(self, topic, data, defer=None):
        
        if defer is None:
            self.send(nsq.publish(topic, data))
        else:
            self.send(nsq.deferpublish(topic, data, defer))
57517
def pubsub(nid=nil)
      node_jid = if nid
                   JID.new(jid.node, jid.domain, nid)
                 else
                   jid.to_s
                 end
      PubSub.new(connection, node_jid)
    end
170957
private void deletePubsubSubscription(String subscription) throws IOException {
    if (pubsubClient == null) {
      pubsubClient = newPubsubClient(options.as(PubsubOptions.class)).build();
    }
    if (executeNullIfNotFound(pubsubClient.projects().subscriptions().get(subscription)) != null) {
      pubsubClient.projects().subscriptions().delete(subscription).execute();
    }
  }
334131
function getPublishOptions(message){
    let publishOptions = {
      type: message.type || '',
      contentType: message.contentType,
      contentEncoding: message.contentEncoding,
      correlationId: message.correlationId || '',
      replyTo: message.replyTo || '',
      messageId: message.messageId || message.id || '',
      timestamp: message.timestamp,
      appId: message.appId || '',
      headers: message.headers || {},
      expiration: message.expiresAfter || undefined,
      persistent: message.persistent !== false
    };
    if (publishOptions.replyTo === 'amq.rabbitmq.reply-to') {
      publishOptions.headers['direct-reply-to'] = 'true';
    }
    return publishOptions;
  }
275695
def multicast(topic, payload = {})
      begin
        x_topic.publish(
          payload.to_json,
          routing_key: dot_formatted(topic)
        )
        log_message("multicast status: success, Topic : #{topic}, Content : #{payload}")
        :success
      rescue => ex
        log_message("Multicast error:#{ex.message}")
        :error
      end
    end
609093
function publish (channel, ...args) {
    _publishStream.emit('message', channel, uniqueId(`${node.name}_`), ...args)
  }
970908
async def publish(self, channel, event, data=None):
        
        msg = {'event': event, 'channel': channel}
        if data:
            msg['data'] = data
        try:
            await self.pubsub.publish(self.prefixed(channel), msg)
        except ConnectionRefusedError:
            self.connection_error = True
            self.logger.critical(
                '%s cannot publish on "%s" channel - connection error',
                self,
                channel
            )
        else:
            self.connection_ok()
159923
func MultiPublish(topic string, body [][]byte) error {
	return DefaultProducer.MultiPublish(topic, body)
}
239701
function publishCachedMessages() {
    if (_cachedPublishMessages.length > 0) {
      async.each(_cachedPublishMessages, function(message, callback) {
        debug('republish message', message);
        self.publishTopic(message.exchange, message.topic, message.message, message.options, function(err) {
          if (err) {
            debug('Failed to republish message', message);
          } else {
            var idx = _cachedPublishMessages.indexOf(message);
            _cachedPublishMessages.splice(idx, 1);
            debug('cached publish message re-published, now there are ' + _cachedPublishMessages.length + ' messages left');
          }
          return callback();
        });
      }, function() {
        debug('cached publish messages processed');
      });
    }
  }
846313
def kps_callback(sender, instance, created, raw, **kwargs):
    '''  '''
    if created and not raw:
        if sender == Api:
            for key in Key.objects.all():
                KeyPublicationStatus.objects.create(key=key, api=instance)
        elif isinstance(instance, Key):
            for api in Api.objects.all():
                KeyPublicationStatus.objects.create(key=instance, api=api)
919382
function createPublisher(broker, configurator) {
    var params = getParams(PublisherConfiguration, configurator);
    return Publisher(broker, params.envelope, params.pipeline, params.routeName, params.routePattern, params.logger);
  }