Emit a status update event. This can result in data being sent to the user's browser in realtime via socket.io.
11308
function updateStatus(evType, opts) {
    var t2 = new Date()
    var elapsed = (t2.getTime() - t1.getTime()) / 1000
    var msg = {
      timeElapsed:elapsed,
      stdout: opts.stdout || "",
      stderr: opts.stderr || "",
      stdmerged: opts.stdmerged || "",
      info: opts.info,
      step: opts.step,
      deployExitCode: null,
      url: null || opts.url,
    }
    if (opts.deployExitCode !== undefined) {
      msg.deployExitCode = opts.deployExitCode
    }

    emitter.emit(evType, msg)
  }
585388
private void sendPublishedStatus(IPlayItem item) {
        Status published = new Status(StatusCodes.NS_PLAY_PUBLISHNOTIFY);
        published.setClientid(streamId);
        published.setDetails(item.getName());

        doPushMessage(published);
    }
1362590
function checkLoadStatus(onload) {
            if (loadCount === resourceCount) {
                // wait 1/2s and execute callback (cheap workaround to ensure everything is loaded)
                if (onload || api.onload) {
                    // make sure we clear the timer
                    clearTimeout(timerId);
                    // trigger the onload callback
                    // we call either the supplied callback (which takes precedence) or the global one
                    var callback = onload || api.onload;
                    setTimeout(function () {
                        callback();
                        me.event.publish(me.event.LOADER_COMPLETE);
                    }, 300);
                }
                else {
                    throw new Error("no load callback defined");
                }
            }
            else {
                timerId = setTimeout(function() {
                    checkLoadStatus(onload);
                }, 100);
            }
        }
401562
def update_frontend(self, info):
        
        headers = {'Content-Type': 'text/event-stream'}
        if info.get('when'):
            info['when'] = info['when'].isoformat()
        requests.post(self.base_url + '/publish', data=json.dumps(info), headers=headers)
157607
def status( update_to = nil )
      resp = send_recv( KJess::Request::Status.new( :update_to => update_to ) )
      raise KJess::ProtocolError, "Status command is not supported" if KJess::Response::ClientError === resp
      return resp.message
    end
626981
function emit(eventName, id, args) {
  var js = "function () { window.socket.emit(\"" + eventName + "\"";

  // we're assuming args is an array of function arguments
  // if not, wrap it
  if (!(args instanceof Array)) {
    args = [args];
  }

  if (id) {
    js += ", " + id + ", " + JSON.stringify(args);
  }

  js += ");}";

  controlPage.evaluate(js);
}
1211832
def fire_update_event(self, *args, **kwargs):
        """"""
        for _handler in self._on_update:
            _handler(*args, **kwargs)
32198
def _send_update(self, data):
        """"""
        if isinstance(data, dict):
            data = json.dumps(data)
        self.update_callback(data)
562691
def _publish_status(self, slug, data):
        

        status_topic = self.topics.prefix + 'devices/{}/data/status'.format(slug)

        self._logger.debug("Publishing status message: (topic=%s) (message=%s)", status_topic, str(data))
        self.client.publish(status_topic, data)
845103
def update_status(type, state)
      old_state, @status[type] = @status[type], state
      Log.info("Client #{type.inspect} changed state from #{old_state.inspect} to #{state.inspect}")
      @status_callbacks.each do |callback|
        begin
          callback.call(type, state)
        rescue RuntimeError => e
          ErrorTracker.log(self, "Failed status callback", e, nil, :caller)
        end
      end
      true
    end
607701
def set_status(self, on, switch=1):
        
        # open device, send request, then close connection
        if isinstance(switch, int):
            switch = str(switch)  # index and payload is a string
        payload = self.generate_payload(SET, {switch:on})
        #print('payload %r' % payload)

        data = self._send_receive(payload)
        log.debug('set_status received data=%r', data)

        return data
359582
def trigger(self, event_name, data):
        
        if self.connection:
            if event_name.startswith("client-"):
                if self.name.startswith("private-") or self.name.startswith("presence-"):
                    self.connection.send_event(event_name, data, channel_name=self.name)
875062
def async_update(self, event):
        
        self.update_attr(event.get('state', {}))
        super().async_update(event)
185295
function sendStopTypinStatus() {
    if (currentDialog.type == 3) {
        QB.chat.sendIsStopTypingStatus(opponentId);
    } else {
        QB.chat.sendIsStopTypingStatus(currentDialog.xmpp_room_jid);
    }
}
309153
def change_status(self, status):
        

        def cb():
            self.user.update(status=status)
            return status

        return signals.user_update(self, ACTIONS["STATUS"], cb,
                                   data={"status": self.status})
248853
ServerMember update(Status status, Instant time) {
    if (this.status != status) {
      this.status = Assert.notNull(status, "status");
      if (time.isAfter(updated)) {
        this.updated = Assert.notNull(time, "time");
      }
      if (statusChangeListeners != null) {
        statusChangeListeners.accept(status);
      }
    }
    return this;
  }
401385
def emit(self):
        """"""

        self.count += 1

        # event_name = 'on_{0}'.format(self.context.subcategory.lower())
        event_name = self.context.subcategory
        if hasattr(self.handler, event_name):
            getattr(self.handler, event_name)(self.context)
        elif hasattr(self.handler, 'default'):
            self.handler.default(self.context)