Getting current execution status within Python runner

[mjtice]

I've got a Python runner and I'd like to be able to get the current execution status (running, canceled, failed, etc.) from within the script. Is this possible? For example:

from st2actions.runners.pythonrunner import Action
import time

class MyAction(Action):
  def run(self):
    while True:
       my_status = <something>
       self.logger.info(f"My status is {my_status}")
       time.sleep(1)

[amanda11]

I'm confused. If your python script is being called then the action that it is configured for would be running if you are in the run method. So are you trying to get the status of another action or the action the script is.
By definition if its in the middle of the run method - then it's in the running state?

[mjtice]

What happens when I cancel the task while it's in the run method? That's what I'm looking to capture, essentially (but knowing other possible states may be worthwhile for what I'm doing).

[mjtice]

Let me expand on what I'm trying to accomplish.

I have a for loop that processes some data and creates a new stackstorm job in each iteration of the loop. The problem I'm running into is that if I need to cancel this action (and the loop) the action is canceled just fine however the for loop keeps running until completion. I'd like to be able to stop iterating over that loop if I decide to cancel the action.

Maybe there's a better way to handle this?

Some code:

# ST2 Libs
from st2actions.runners.pythonrunner import Action
from st2client.client import Client
from st2client.models import Execution
from st2client.commands.action import LIVEACTION_STATUS_REQUESTED, \
            LIVEACTION_STATUS_SCHEDULED, LIVEACTION_STATUS_RUNNING, LIVEACTION_STATUS_CANCELING, \
            LIVEACTION_STATUS_CANCELED, LIVEACTION_STATUS_FAILED, LIVEACTION_STATUS_TIMED_OUT, \
            LIVEACTION_STATUS_ABANDONED, LIVEACTION_STATUS_DELAYED, LIVEACTION_STATUS_PAUSING, \
            LIVEACTION_STATUS_PAUSED, LIVEACTION_STATUS_RESUMING

# Misc
import sys
import time

class MyAction(Action):

    def run(self, config=None, taskdata=None):

        self.pending_statuses = [
            LIVEACTION_STATUS_REQUESTED,
            LIVEACTION_STATUS_SCHEDULED,
            LIVEACTION_STATUS_RUNNING,
            LIVEACTION_STATUS_CANCELING,
            LIVEACTION_STATUS_DELAYED
        ]

        self.failed_statuses = [
            LIVEACTION_STATUS_FAILED,
            LIVEACTION_STATUS_ABANDONED,
            LIVEACTION_STATUS_TIMED_OUT
        ]

        self.running_statuses = [
            LIVEACTION_STATUS_REQUESTED,
            LIVEACTION_STATUS_SCHEDULED,
            LIVEACTION_STATUS_DELAYED,
            LIVEACTION_STATUS_RUNNING,
            LIVEACTION_STATUS_PAUSING,
            LIVEACTION_STATUS_PAUSED,
            LIVEACTION_STATUS_RESUMING
        ]
        
        self.st2_client = Client(api_url='http://localhost:9101', api_key="123abc")
        taskdata = range(1,100)
        
        try:
            for task in taskdata:
                action = "core.noop"
                
                # Here is where I'd like to evaluate whether or not this parent action has been canceled
                #if not "canceled":
                #    self._dispatch_action(action=action)
                self._dispatch_action(action=action)

        except Exception as e:
            return False, {'RESULTS': "Error processing Qlik task data into Alation: {}".format(e)}

        return True, {'RESULTS': "success"}


    def _dispatch_action(self, action):
            execution = Execution(action=action)
            self.logger.info(f"Creating new ST2 Job Execution for action {action}...")

            try:
                st2_job = self.st2_client.executions.create(execution)
                self._wait_for_st2(st2_job, self.st2_client)
            except requests.HTTPError as e:
                if "cannot be found" in str(e):
                    msg = "Action {0} does not exist.  {1}".format(action, str(e))
                    raise ValueError(msg)
                else:
                    self._logger.error(
                        "An HTTP error was encountered with Stackstorm: {}".format(str(e)))
                    raise ValueError(str(e))
            except Exception as e:
                msg = "Some other exception occurred with Stackstorm: {0}.".format(
                    str(e))
                raise ValueError(str(e))

    def _wait_for_st2(self, st2_job, client, throw_on_error=False):
        time.sleep(2)
        while st2_job.status in self.pending_statuses:
            self.logger.info("ST2 job {} in progress.  Current status: {} ".format(st2_job.id, st2_job.status))

            if st2_job.status == LIVEACTION_STATUS_CANCELING:
                break

            time.sleep(1)
            try:
                st2_job = client.executions.get_by_id(st2_job.id)
            except requests.exceptions.HTTPError as e:
                if e.response.status_code == 503:
                    time.sleep(5)
                    st2_job = client.executions.get_by_id(st2_job.id)
                else:
                    raise e

            # Captured cancel action and throw exception so the job fails for cloud.
            if st2_job.status == LIVEACTION_STATUS_CANCELED or st2_job.status == LIVEACTION_STATUS_CANCELING:
                self.logger.info("ST2 job {} was cancelled. ".format(st2_job.id))

        # Check for any failed jobs to raise fails to cloud.
        if st2_job.status in self.failed_statuses:
            self.logger.info("ST2 job {} failed... ".format(st2_job.id))
            self.task_succeeded = False

        return st2_job

[amanda11]

OK - so yes you do need to find status to find this out. The PythonRunner doesn't pass the cancel onto the underlying script - that's a potential feature request that could be useful to others, to allow the cancel to signal to the python script so that you knew it had been cancelled. But that's not in there at moment, or on the roadmap.

You may need to inquire into the database for your status similar to what you are already doing with:
st2_job = client.executions.get_by_id(<your action's execution id>)

Your action should be able to get the execution id from an environment variable - https://docs.stackstorm.com/actions.html#environment-variables-available-to-actions

[mjtice]

That did the trick, thanks @amanda11 !