st2actions.runners.PythonRunner.run() - Code Metrics - Inspection of "Merge pull request #2396 from Plexxi/kale/action-d..." - StackStorm/st2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dfd3a9...2b76ca )

by Manas

created 2016-02-03 20:21 UTC

st2actions.runners.PythonRunner.run() F

↳ Parent: st2actions.runners.PythonRunner

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	78
rs	2.0916
cc	12

How to fix Long Method Complexity

# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import os
import sys
import abc
import json
import uuid

import six
from eventlet.green import subprocess

from st2actions.runners import ActionRunner
from st2common.util.green.shell import run_command
from st2common.constants.action import ACTION_OUTPUT_RESULT_DELIMITER
from st2common.constants.action import LIVEACTION_STATUS_SUCCEEDED
from st2common.constants.action import LIVEACTION_STATUS_FAILED
from st2common.constants.action import LIVEACTION_STATUS_TIMED_OUT
from st2common.constants.error_messages import PACK_VIRTUALENV_DOESNT_EXIST
from st2common.util.sandboxing import get_sandbox_path
from st2common.util.sandboxing import get_sandbox_python_path
from st2common.util.sandboxing import get_sandbox_python_binary_path
from st2common.util.sandboxing import get_sandbox_virtualenv_path
from st2common.constants.runners import PYTHON_RUNNER_DEFAULT_ACTION_TIMEOUT

__all__ = [
    'get_runner',

    'PythonRunner',
    'Action'
]

# constants to lookup in runner_parameters.
RUNNER_ENV = 'env'
RUNNER_TIMEOUT = 'timeout'

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
WRAPPER_SCRIPT_NAME = 'python_action_wrapper.py'
WRAPPER_SCRIPT_PATH = os.path.join(BASE_DIR, WRAPPER_SCRIPT_NAME)


def get_runner():
    return PythonRunner(str(uuid.uuid4()))


@six.add_metaclass(abc.ABCMeta)
class Action(object):
    """
    Base action class other Python actions should inherit from.
    """

    description = None

    def __init__(self, config=None):
        """
        :param config: Action config.
        :type config: ``dict``
        """
        self.config = config or {}
        # logger and datastore are assigned in PythonActionWrapper._get_action_instance
        self.logger = None
        self.datastore = None

    @abc.abstractmethod
    def run(self, **kwargs):
        pass


class PythonRunner(ActionRunner):

    def __init__(self, runner_id, timeout=PYTHON_RUNNER_DEFAULT_ACTION_TIMEOUT):
        """
        :param timeout: Action execution timeout in seconds.
        :type timeout: ``int``
        """
        super(PythonRunner, self).__init__(runner_id=runner_id)
        self._timeout = timeout

    def pre_run(self):
        # TODO :This is awful, but the way "runner_parameters" and other variables get
        # assigned on the runner instance is even worse. Those arguments should
        # be passed to the constructor.
        self._env = self.runner_parameters.get(RUNNER_ENV, {})
        self._timeout = self.runner_parameters.get(RUNNER_TIMEOUT, self._timeout)

    def run(self, action_parameters):
        pack = self.get_pack_name()
        serialized_parameters = json.dumps(action_parameters) if action_parameters else ''
        virtualenv_path = get_sandbox_virtualenv_path(pack=pack)
        python_path = get_sandbox_python_binary_path(pack=pack)

        if virtualenv_path and not os.path.isdir(virtualenv_path):
            format_values = {'pack': pack, 'virtualenv_path': virtualenv_path}
            msg = PACK_VIRTUALENV_DOESNT_EXIST % format_values
            raise Exception(msg)

        if not self.entry_point:
            raise Exception('Action "%s" is missing entry_point attribute' % (self.action.name))

        args = [
            python_path,
            WRAPPER_SCRIPT_PATH,
            '--pack=%s' % (pack),
            '--file-path=%s' % (self.entry_point),
            '--parameters=%s' % (serialized_parameters),
            '--parent-args=%s' % (json.dumps(sys.argv[1:]))
        ]

        # We need to ensure all the st2 dependencies are also available to the
        # subprocess
        env = os.environ.copy()
        env['PATH'] = get_sandbox_path(virtualenv_path=virtualenv_path)
        env['PYTHONPATH'] = get_sandbox_python_path(inherit_from_parent=True,
                                                    inherit_parent_virtualenv=True)

        # Include user provided environment variables (if any)
        user_env_vars = self._get_env_vars()
        env.update(user_env_vars)

        # Include common st2 environment variables
        st2_env_vars = self._get_common_action_env_variables()
        env.update(st2_env_vars)

        exit_code, stdout, stderr, timed_out = run_command(cmd=args, stdout=subprocess.PIPE,
                                                           stderr=subprocess.PIPE, shell=False,
                                                           env=env, timeout=self._timeout)

        if timed_out:
            error = 'Action failed to complete in %s seconds' % (self._timeout)
        else:
            error = None

        if ACTION_OUTPUT_RESULT_DELIMITER in stdout:
            split = stdout.split(ACTION_OUTPUT_RESULT_DELIMITER)
            assert len(split) == 3
            result = split[1].strip()
            stdout = split[0] + split[2]
        else:
            result = None

        try:
            result = json.loads(result)
        except:
            pass

        output = {
            'stdout': stdout,
            'stderr': stderr,
            'exit_code': exit_code,
            'result': result
        }

        if error:
            output['error'] = error

        if exit_code == 0:
            status = LIVEACTION_STATUS_SUCCEEDED
        elif timed_out:
            status = LIVEACTION_STATUS_TIMED_OUT
        else:
            status = LIVEACTION_STATUS_FAILED

        return (status, output, None)

    def _get_env_vars(self):
        """
        Return sanitized environment variables which will be used when launching
        a subprocess.

        :rtype: ``dict``
        """
        # Don't allow user to override PYTHONPATH since this would break things
        blacklisted_vars = ['pythonpath']
        env_vars = {}

        if self._env:
            env_vars.update(self._env)

        # Remove "blacklisted" environment variables
        to_delete = []
        for key, value in env_vars.items():
            if key.lower() in blacklisted_vars:
                to_delete.append(key)

        for key in to_delete:
            del env_vars[key]

        return env_vars


1			# Licensed to the StackStorm, Inc ('StackStorm') under one or more
2			# contributor license agreements. See the NOTICE file distributed with
3			# this work for additional information regarding copyright ownership.
4			# The ASF licenses this file to You under the Apache License, Version 2.0
5			# (the "License"); you may not use this file except in compliance with
6			# the License. You may obtain a copy of the License at
7			#
8			# http://www.apache.org/licenses/LICENSE-2.0
9			#
10			# Unless required by applicable law or agreed to in writing, software
11			# distributed under the License is distributed on an "AS IS" BASIS,
12			# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13			# See the License for the specific language governing permissions and
14			# limitations under the License.
15
16			import os
17			import sys
18			import abc
19			import json
20			import uuid
21
22			import six
23			from eventlet.green import subprocess
24
25			from st2actions.runners import ActionRunner
26			from st2common.util.green.shell import run_command
27			from st2common.constants.action import ACTION_OUTPUT_RESULT_DELIMITER
28			from st2common.constants.action import LIVEACTION_STATUS_SUCCEEDED
29			from st2common.constants.action import LIVEACTION_STATUS_FAILED
30			from st2common.constants.action import LIVEACTION_STATUS_TIMED_OUT
31			from st2common.constants.error_messages import PACK_VIRTUALENV_DOESNT_EXIST
32			from st2common.util.sandboxing import get_sandbox_path
33			from st2common.util.sandboxing import get_sandbox_python_path
34			from st2common.util.sandboxing import get_sandbox_python_binary_path
35			from st2common.util.sandboxing import get_sandbox_virtualenv_path
36			from st2common.constants.runners import PYTHON_RUNNER_DEFAULT_ACTION_TIMEOUT
37
38			__all__ = [
39			'get_runner',
40
41			'PythonRunner',
42			'Action'
43			]
44
45			# constants to lookup in runner_parameters.
46			RUNNER_ENV = 'env'
47			RUNNER_TIMEOUT = 'timeout'
48
49			BASE_DIR = os.path.dirname(os.path.abspath(__file__))
50			WRAPPER_SCRIPT_NAME = 'python_action_wrapper.py'
51			WRAPPER_SCRIPT_PATH = os.path.join(BASE_DIR, WRAPPER_SCRIPT_NAME)
52
53
54			def get_runner():
55			return PythonRunner(str(uuid.uuid4()))
56
57
58			@six.add_metaclass(abc.ABCMeta)
59			class Action(object):
60			"""
61			Base action class other Python actions should inherit from.
62			"""
63
64			description = None
65
66			def __init__(self, config=None):
67			"""
68			:param config: Action config.
69			:type config: ``dict``
70			"""
71			self.config = config or {}
72			# logger and datastore are assigned in PythonActionWrapper._get_action_instance
73			self.logger = None
74			self.datastore = None
75
76			@abc.abstractmethod
77			def run(self, **kwargs):
78			pass
79
80
81			class PythonRunner(ActionRunner):
82
83			def __init__(self, runner_id, timeout=PYTHON_RUNNER_DEFAULT_ACTION_TIMEOUT):
84			"""
85			:param timeout: Action execution timeout in seconds.
86			:type timeout: ``int``
87			"""
88			super(PythonRunner, self).__init__(runner_id=runner_id)
89			self._timeout = timeout
90
91			def pre_run(self):
92			# TODO :This is awful, but the way "runner_parameters" and other variables get
93			# assigned on the runner instance is even worse. Those arguments should
94			# be passed to the constructor.
95			self._env = self.runner_parameters.get(RUNNER_ENV, {})
96			self._timeout = self.runner_parameters.get(RUNNER_TIMEOUT, self._timeout)
97
98			def run(self, action_parameters):
99			pack = self.get_pack_name()
100			serialized_parameters = json.dumps(action_parameters) if action_parameters else ''
101			virtualenv_path = get_sandbox_virtualenv_path(pack=pack)
102			python_path = get_sandbox_python_binary_path(pack=pack)
103
104			if virtualenv_path and not os.path.isdir(virtualenv_path):
105			format_values = {'pack': pack, 'virtualenv_path': virtualenv_path}
106			msg = PACK_VIRTUALENV_DOESNT_EXIST % format_values
107			raise Exception(msg)
108
109			if not self.entry_point:
110			raise Exception('Action "%s" is missing entry_point attribute' % (self.action.name))
111
112			args = [
113			python_path,
114			WRAPPER_SCRIPT_PATH,
115			'--pack=%s' % (pack),
116			'--file-path=%s' % (self.entry_point),
117			'--parameters=%s' % (serialized_parameters),
118			'--parent-args=%s' % (json.dumps(sys.argv[1:]))
119			]
120
121			# We need to ensure all the st2 dependencies are also available to the
122			# subprocess
123			env = os.environ.copy()
124			env['PATH'] = get_sandbox_path(virtualenv_path=virtualenv_path)
125			env['PYTHONPATH'] = get_sandbox_python_path(inherit_from_parent=True,
126			inherit_parent_virtualenv=True)
127
128			# Include user provided environment variables (if any)
129			user_env_vars = self._get_env_vars()
130			env.update(user_env_vars)
131
132			# Include common st2 environment variables
133			st2_env_vars = self._get_common_action_env_variables()
134			env.update(st2_env_vars)
135
136			exit_code, stdout, stderr, timed_out = run_command(cmd=args, stdout=subprocess.PIPE,
137			stderr=subprocess.PIPE, shell=False,
138			env=env, timeout=self._timeout)
139
140			if timed_out:
141			error = 'Action failed to complete in %s seconds' % (self._timeout)
142			else:
143			error = None
144
145			if ACTION_OUTPUT_RESULT_DELIMITER in stdout:
146			split = stdout.split(ACTION_OUTPUT_RESULT_DELIMITER)
147			assert len(split) == 3
148			result = split[1].strip()
149			stdout = split[0] + split[2]
150			else:
151			result = None
152
153			try:
154			result = json.loads(result)
155			except:
156			pass
157
158			output = {
159			'stdout': stdout,
160			'stderr': stderr,
161			'exit_code': exit_code,
162			'result': result
163			}
164
165			if error:
166			output['error'] = error
167
168			if exit_code == 0:
169			status = LIVEACTION_STATUS_SUCCEEDED
170			elif timed_out:
171			status = LIVEACTION_STATUS_TIMED_OUT
172			else:
173			status = LIVEACTION_STATUS_FAILED
174
175			return (status, output, None)
176
177			def _get_env_vars(self):
178			"""
179			Return sanitized environment variables which will be used when launching
180			a subprocess.
181
182			:rtype: ``dict``
183			"""
184			# Don't allow user to override PYTHONPATH since this would break things
185			blacklisted_vars = ['pythonpath']
186			env_vars = {}
187
188			if self._env:
189			env_vars.update(self._env)
190
191			# Remove "blacklisted" environment variables
192			to_delete = []
193			for key, value in env_vars.items():
194			if key.lower() in blacklisted_vars:
195			to_delete.append(key)
196
197			for key in to_delete:
198			del env_vars[key]
199
200			return env_vars
201

StackStorm / st2

Push — master ( dfd3a9...2b76ca )

st2actions.runners.PythonRunner.run() F

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like