Method _update_status

st2actions/st2actions/container/base.py:343–421

(self, liveaction_id, status, result, context)

        return (liveaction_db, state_changed)

    def _update_status(self, liveaction_id, status, result, context):
        with Timer(key="action.executions.update_liveaction_db"):
            try:
                # NOTE: The next two operations take a very long time in master with large executions
                # (long standing issue), but because start_timestamp and end_timestamp measure how long
                # it took for the runner to run the action, it doesn't include the time it took to
                # actually write results / persist execution into the database - that's a problem
                # because we have no good direct visibility into that.
                #
                # The UX user would experience is - they would run an action which produces large
                # result, CLI / API would show execution as running for a long time (until it's
                # persisted in the database), but when it will finally be written to the database,
                # duration will be shown as a short time, because it's measured based on start and
                # end timestamp.
                #
                # This mean we can have, for example, Python runner action which returns a lot of data
                # and takes only 0.5 second to finish, but next two database operations can easily take
                # 10 seconds each.
                #
                # To work around that and provide some additional visibility into that to the operators
                # and users, we update "end_timestamp" on each object again after both of them have
                # already been written. That atomic single field update is very fast and adds no
                # additional overhead.
                LOG.debug(
                    "Setting status: %s for liveaction: %s", status, liveaction_id
                )
                liveaction_db, state_changed = self._update_live_action_db(
                    liveaction_id, status, result, context
                )
            except Exception as e:
                LOG.exception(
                    "Cannot update liveaction "
                    "(id: %s, status: %s, result: %s)."
                    % (liveaction_id, status, result)
                )
                raise e

        # live_action_written_to_db_dt = date_utils.get_datetime_utc_now()

        with Timer(key="action.executions.update_execution_db"):
            try:
                executions.update_execution(
                    liveaction_db,
                    publish=state_changed,
                    set_result_size=True,
                )
                extra = {"liveaction_db": liveaction_db}
                LOG.debug("Updated liveaction after run", extra=extra)
            except Exception as e:
                LOG.exception(
                    "Cannot update action execution for liveaction "
                    "(id: %s, status: %s, result: %s)."
                    % (liveaction_id, status, result)
                )
                raise e

        # execution_written_to_db = date_utils.get_datetime_utc_now()