Publish, reusing the mailbox for an existing service.
160327
@Override
  public ServiceRefAmp bind(ServiceRefAmp service, String address)
  {
    if (log.isLoggable(Level.FINEST)) {
      log.finest(L.l("bind {0} for {1} in {2}",
                    address, service.api().getType(), this));
    }

    address = toCanonical(address);
    
    registry().bind(address, service);

    return service;
  }
1363860
def serve(self, port=None, address=None):
        """"""
        port = port or self.port
        address = address or self.address

        log.info('Starting SMTP server at {0}:{1}'.format(address, port))

        server = InboxServer(self.collator, (address, port), None)

        try:
            asyncore.loop()
        except KeyboardInterrupt:
            log.info('Cleaning up')
734088
def _publish_response(self, slug, message):
        

        resp_topic = self.topics.gateway_topic(slug, 'data/response')
        self._logger.debug("Publishing response message: (topic=%s) (message=%s)", resp_topic, message)
        self.client.publish(resp_topic, message)
1334153
def publish(self, message, key=None, **kws):
        """"""
        return PSPut(self, message, key, **kws)
989859
def publish(self, message_type=ON_SEND, client_id=None, client_storage=None,
                *args, **kwargs):
        
        self.publisher.publish(
            message_type, client_id, client_storage, *args, **kwargs)
1125184
def publish(self, topic, payload, qos, retain):
        """"""
        self._mqttc.publish(topic, payload, qos, retain)
113207
def publish(self, payload, **kwargs):
        
        publish_kwargs = self.publish_kwargs.copy()

        # merge headers from when the publisher was instantiated
        # with any provided now; "extra" headers always win
        headers = publish_kwargs.pop('headers', {}).copy()
        headers.update(kwargs.pop('headers', {}))
        headers.update(kwargs.pop('extra_headers', {}))

        use_confirms = kwargs.pop('use_confirms', self.use_confirms)
        transport_options = kwargs.pop('transport_options',
                                       self.transport_options
                                       )
        transport_options['confirm_publish'] = use_confirms

        delivery_mode = kwargs.pop('delivery_mode', self.delivery_mode)
        mandatory = kwargs.pop('mandatory', self.mandatory)
        priority = kwargs.pop('priority', self.priority)
        expiration = kwargs.pop('expiration', self.expiration)
        serializer = kwargs.pop('serializer', self.serializer)
        compression = kwargs.pop('compression', self.compression)
        retry = kwargs.pop('retry', self.retry)
        retry_policy = kwargs.pop('retry_policy', self.retry_policy)

        declare = self.declare[:]
        declare.extend(kwargs.pop('declare', ()))

        publish_kwargs.update(kwargs)  # remaining publish-time kwargs win

        with get_producer(self.amqp_uri,
                          use_confirms,
                          self.ssl,
                          transport_options,
                          ) as producer:
            try:
                producer.publish(
                    payload,
                    headers=headers,
                    delivery_mode=delivery_mode,
                    mandatory=mandatory,
                    priority=priority,
                    expiration=expiration,
                    compression=compression,
                    declare=declare,
                    retry=retry,
                    retry_policy=retry_policy,
                    serializer=serializer,
                    **publish_kwargs
                )
            except ChannelError as exc:
                if "NO_ROUTE" in str(exc):
                    raise UndeliverableMessage()
                raise

            if mandatory:
                if not use_confirms:
                    warnings.warn(
                        "Mandatory delivery was requested, but "
                        "unroutable messages cannot be detected without "
                        "publish confirms enabled."
                    )
456291
void publish() {

        I_CmsUpdateListener<String> updateListener = new I_CmsUpdateListener<String>() {

            @Override
            public void onUpdate(List<String> updatedItems) {

                updateItems(updatedItems);
            }
        };
        CmsAppWorkplaceUi.get().disableGlobalShortcuts();
        CmsGwtDialogExtension extension = new CmsGwtDialogExtension(A_CmsUI.get(), updateListener);
        extension.openPublishDialog(getPublishResources());
    }
1189539
def publish(self):
        
        if self.published is False:
            self.published = True
        else:
            raise Warning(self.title + ' is already published.')
1320612
public void publish(Channel channel, DeliveryOptions deliveryOptions) throws IOException {
        // Assure to have a timestamp
        if (basicProperties.getTimestamp() == null) {
            basicProperties.builder().timestamp(new Date());
        }

        boolean mandatory = deliveryOptions == DeliveryOptions.MANDATORY;
        boolean immediate = deliveryOptions == DeliveryOptions.IMMEDIATE;

        LOGGER.info("Publishing message to exchange '{}' with routing key '{}' (deliveryOptions: {}, persistent: {})",
                new Object[] { exchange, routingKey, deliveryOptions, basicProperties.getDeliveryMode() == 2 });

        channel.basicPublish(exchange, routingKey, mandatory, immediate, basicProperties, bodyContent);
        LOGGER.info("Successfully published message to exchange '{}' with routing key '{}'", exchange, routingKey);
    }
496318
def publish(self, topic, payload, qos=0, retain=False):
        
        # TODO: check (full transmission) success
        return self._client.publish(topic, payload, qos, retain)
1220978
def multipublish(self, topic, messages):
        
        self.send(nsq.multipublish(topic, messages))
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');
      });
    }
  }
1229195
def create(self, publish):
        
        target_url = self.client.get_url('PUBLISH', 'POST', 'create')
        r = self.client.request('POST', target_url, json=publish._serialize())
        return self.create_from_result(r.json())
1373613
def promote(self, lane, svcs=None, meta=None):
        """"""

        svcs, meta, lane = self._prep_for_release(lane, svcs=svcs, meta=meta)

        # iterate and mark as future release
        for svc in svcs:
            self.changes.append("Promoting: {}.release.future={}".format(svc, self.name))
            self.rcs.patch('service', svc, {
                "release": {"future": self.name}, # new way
                "statuses": {"future": time.time()},
            })

        return self
1319641
def onOpen(self):
        
        self.factory.add_client(self)

        # Publish ON_OPEN message
        self.factory.mease.publisher.publish(
            message_type=ON_OPEN, client_id=self._client_id, client_storage=self.storage)
1128943
function reuse() {
      if(!storage[storageKey] && post.collection('parent') && post.collection('parent')[storageKey]){
        $contentDomNode.html(post.collection('parent')[storageKey]);
        $contentDomNode.attr('data-div-placeholder-content', 'true');
        saveData();
      }
    }