Update the status of messages from the specified connection
    :param msg_json:
    :return:
972743
async def vcx_messages_update_status(msg_json: str):
    
    logger = logging.getLogger(__name__)

    if not hasattr(vcx_messages_update_status, "cb"):
        logger.debug("vcx_messages_update_status: Creating callback")
        vcx_messages_update_status.cb = create_cb(CFUNCTYPE(None, c_uint32, c_uint32))

    c_msg_json = c_char_p(msg_json.encode('utf-8'))
    c_status = c_char_p("MS-106".encode('utf-8'))

    result = await do_call('vcx_messages_update_status',
                           c_status,
                           c_msg_json,
                           vcx_messages_update_status.cb)

    logger.debug("vcx_messages_update_status completed")
    return result
1301186
def _on_status_message(self, sequence, topic, message):
        

        self._logger.debug("Received message on (topic=%s): %s" % (topic, message))

        try:
            conn_key = self._find_connection(topic)
        except ArgumentError:
            self._logger.warn("Dropping message that does not correspond with a known connection, message=%s", message)
            return

        if messages.ConnectionResponse.matches(message):
            if self.name != message['client']:
                self._logger.debug("Connection response received for a different client, client=%s, name=%s", message['client'], self.name)
                return

            self.conns.finish_connection(conn_key, message['success'], message.get('failure_reason', None))
        else:
            self._logger.warn("Dropping message that did not correspond with a known schema, message=%s", message)
651478
def update_status(message, new_status = nil)
      @log      = @options[:logger] || RDSBackup.default_logger(STDOUT)
      @message  = message
      @status   = new_status if new_status
      @status == 200 ? (@log.info message) : (@log.error message)
      write_to_s3
    end
392258
def update(self, **kwargs):
        

        old_json = self.__json__()

        for prop in kwargs:
            setattr(self, prop, kwargs[prop])

        # We send notif only if object has changed
        if old_json != self.__json__():
            self.controller.notification.emit("project.updated", self.__json__())
            self.dump()
1019667
def update(message)
      case message.fetch(:type){""}
      when "error"
        logger.error message
      else
        logger.info message
      end
      exchange_out.publish(message.to_json)
    end
859989
def post_message(self, msg):
        ''''''
        if '_posted' in msg.__dict__:
            return
        msg._posted = True
        msg._timestamp = time.time()
        type = msg.get_type()
        if type != 'HEARTBEAT' or (msg.type != mavlink.MAV_TYPE_GCS and msg.type != mavlink.MAV_TYPE_GIMBAL):
            self.messages[type] = msg

        if 'usec' in msg.__dict__:
            self.uptime = msg.usec * 1.0e-6
        if 'time_boot_ms' in msg.__dict__:
            self.uptime = msg.time_boot_ms * 1.0e-3

        if self._timestamp is not None:
            if self.notimestamps:
                msg._timestamp = self.uptime
            else:
                msg._timestamp = self._timestamp

        src_system = msg.get_srcSystem()
        src_component = msg.get_srcComponent()
        src_tuple = (src_system, src_component)
        radio_tuple = (ord('3'), ord('D'))
        if not (src_tuple == radio_tuple or msg.get_type() == 'BAD_DATA'):
            if not src_tuple in self.last_seq:
                last_seq = -1
            else:
                last_seq = self.last_seq[src_tuple]
            seq = (last_seq+1) % 256
            seq2 = msg.get_seq()
            if seq != seq2 and last_seq != -1:
                diff = (seq2 - seq) % 256
                self.mav_loss += diff
                #print("lost %u seq=%u seq2=%u last_seq=%u src_system=%u %s" % (diff, seq, seq2, last_seq, src_system, msg.get_type()))
            self.last_seq[src_tuple] = seq2
            self.mav_count += 1
        
        self.timestamp = msg._timestamp
        if type == 'HEARTBEAT' and msg.get_srcComponent() != mavlink.MAV_COMP_ID_GIMBAL:
            self.target_system = msg.get_srcSystem()
            self.target_component = msg.get_srcComponent()
            if float(mavlink.WIRE_PROTOCOL_VERSION) >= 1 and msg.type != mavlink.MAV_TYPE_GCS:
                self.flightmode = mode_string_v10(msg)
                self.mav_type = msg.type
                self.base_mode = msg.base_mode
        elif type == 'PARAM_VALUE':
            s = str(msg.param_id)
            self.params[str(msg.param_id)] = msg.param_value
            if msg.param_index+1 == msg.param_count:
                self.param_fetch_in_progress = False
                self.param_fetch_complete = True
        elif type == 'SYS_STATUS' and mavlink.WIRE_PROTOCOL_VERSION == '0.9':
            self.flightmode = mode_string_v09(msg)
        elif type == 'GPS_RAW':
            if self.messages['HOME'].fix_type < 2:
                self.messages['HOME'] = msg
        elif type == 'GPS_RAW_INT':
            if self.messages['HOME'].fix_type < 3:
                self.messages['HOME'] = msg
        for hook in self.message_hooks:
            hook(self, msg)

        if (msg.get_signed() and
            self.mav.signing.link_id == 0 and
            msg.get_link_id() != 0 and
            self.target_system == msg.get_srcSystem() and
            self.target_component == msg.get_srcComponent()):
            # change to link_id from incoming packet
            self.mav.signing.link_id = msg.get_link_id()
433596
def _update_state_from_response(self, response_json):
        
        if response_json.get('data') is not None:
            cloud_clock = response_json.get('data')
        else:
            cloud_clock = response_json
        self.parent.json_state = cloud_clock

        cloud_clock_last_reading = cloud_clock.get('last_reading')
        dials = cloud_clock.get('dials')
        for dial in dials:
            if dial.get('object_id') == self.object_id():
                dial['connection'] = cloud_clock_last_reading.get('connection')
                self.json_state = dial
                return True
        return False
1317120
def on_message(self, client, userdata, msg):
        '''
        
        '''
        if msg.topic == 'serial_device/refresh_comports':
            self.refresh_comports()
            return

        match = CRE_MANAGER.match(msg.topic)
        if match is None:
            logger.debug('Topic NOT matched: `%s`', msg.topic)
        else:
            logger.debug('Topic matched: `%s`', msg.topic)
            # Message topic matches command.  Handle request.
            command = match.group('command')
            port = match.group('port')

            #     serial_device/<port>/send   # Bytes to send
            if command == 'send':
                self._serial_send(port, msg.payload)
            elif command == 'connect':
                # serial_device/<port>/connect  # Request connection
                try:
                    request = json.loads(msg.payload)
                except ValueError as exception:
                    logger.error('Error decoding "%s (%s)" request: %s',
                                 command, port, exception)
                    return
                self._serial_connect(port, request)
            elif command == 'close':
                self._serial_close(port)
1365634
def received_message(self, msg):
        
        logger.debug("Received message: %s", msg)
        if msg.is_binary:
            raise ValueError("Binary messages not supported")
        resps = json.loads(msg.data)

        cmd_group = _get_cmds_id(*resps)
        if cmd_group:
            (cmds, promise) = self._cmd_groups[cmd_group]
            promise.fulfill((cmds, resps))
        else:
            try:
                self.received_unsolicited(resps)
            except:
                logger.exception("Error in unsolicited msg handler")
                raise
440391
def update
      if @user_board.update(name: params[:board][:name], encrypted_password: params[:encrypted_password])
        render json: @user_board
      else
        errors = @board.errors.full_messages.concat @user_board.errors.full_messages
        render json: errors, status: 422
      end
    end
169600
def update(self, status=values.unset):
        
        return self._proxy.update(status=status, )
1285991
@PUT
    @Consumes("application/json")
    public void putJson(IncomingMessage msg) {
        chatBean.addMessage(msg.nick, msg.content);
    }
1195055
def update_status(self, callback_function_param=False):
        
        self.logger.debug("Receiver:Updating status")
        self.send_message({MESSAGE_TYPE: TYPE_GET_STATUS},
                          callback_function=callback_function_param)
1206973
def displayStatusMessage(self, msgObj):
        

        # Ensure the message ends with a newline character.
        msg = msgObj.data
        if not msg.endswith('\n'):
            msg = msg + '\n'

        # Display the message in the status field.
        self.qteLabel.setText(msg)
184440
public void sendCallStatsBridgeStatusUpdate(BridgeStatusInfo bridgeStatusInfo) {
    if (!isInitialized()) {
      bridgeStatusInfoQueue.push(bridgeStatusInfo);
      return;
    }

    long epoch = System.currentTimeMillis();
    String token = getToken();
    BridgeStatusUpdateMessage eventMessage =
        new BridgeStatusUpdateMessage(bridgeId, epoch, bridgeStatusInfo);
    String requestMessageString = gson.toJson(eventMessage);
    String url = "/" + appId + "/stats/bridge/status";
    httpClient.sendBridgeStatistics(url, token, requestMessageString,
        new CallStatsHttp2ResponseListener() {
          public void onResponse(Response response) {
            int responseStatus = response.code();
            BridgeStatusUpdateResponse eventResponseMessage;
            try {
              String responseString = response.body().string();
              eventResponseMessage =
                  gson.fromJson(responseString, BridgeStatusUpdateResponse.class);
            } catch (IOException e) {
              logger.error("IO Exception " + e.getMessage(), e);
              throw new RuntimeException(e);
            } catch (JsonSyntaxException e) {
              logger.error("Json Syntax Exception " + e.getMessage(), e);
              e.printStackTrace();
              throw new RuntimeException(e);
            }
            logger.debug("BridgeStatusUpdate Response " + eventResponseMessage.getStatus() + ":"
                + eventResponseMessage.getMsg());
            httpClient.setDisrupted(false);
            if (responseStatus == CallStatsResponseStatus.RESPONSE_STATUS_SUCCESS) {
              sendCallStatsBridgeStatusUpdateFromQueue();
            } else if (responseStatus == CallStatsResponseStatus.INVALID_AUTHENTICATION_TOKEN) {
              bridgeKeepAliveManager.stopKeepAliveSender();
              authenticator.doAuthentication();
            } else {
              httpClient.setDisrupted(true);
            }
          }

          public void onFailure(Exception e) {
            logger.error("Response exception" + e.getMessage(), e);
            httpClient.setDisrupted(true);
          }

        });
  }
160823
def status(self, *msg):
        
        label = colors.yellow("STATUS")
        self._msg(label, *msg)
404934
def add_status_message(self, message, level="info"):
        
        return self.context.plone_utils.addPortalMessage(message, level)