def main():
_parse_config()
if CONF.verbose:
_setup_logging()
output = logging.getLogger(__name__).info
else:
output = pprint.pprint
_setup_db()
_refire_trigger_instance(trigger_instance_id=CONF.trigger_instance_id,
log_=logging.getLogger(__name__))
output('Trigger re-fired')
db_teardown()
def __init__(self, pack, file_path, parameters=None, parent_args=None):
"""
:param pack: Name of the pack this action belongs to.
:type pack: ``str``
:param file_path: Path to the action module.
:type file_path: ``str``
:param parameters: action parameters.
:type parameters: ``dict`` or ``None``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._parameters = parameters or {}
self._parent_args = parent_args or []
self._class_name = None
self._logger = logging.getLogger('PythonActionWrapper')
try:
config.parse_args(args=self._parent_args)
except Exception:
pass
else:
db_setup()
def __init__(self, pack, file_path, class_name, trigger_types,
poll_interval=None, parent_args=None):
"""
:param pack: Name of the pack this sensor belongs to.
:type pack: ``str``
:param file_path: Path to the sensor module file.
:type file_path: ``str``
:param class_name: Sensor class name.
:type class_name: ``str``
:param trigger_types: A list of references to trigger types which
belong to this sensor.
:type trigger_types: ``list`` of ``str``
:param poll_interval: Sensor poll interval (in seconds).
:type poll_interval: ``int`` or ``None``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._class_name = class_name
self._trigger_types = trigger_types or []
self._poll_interval = poll_interval
self._parent_args = parent_args or []
self._trigger_names = {}
# 1. Parse the config with inherited parent args
try:
config.parse_args(args=self._parent_args)
except Exception:
pass
# 2. Establish DB connection
username = cfg.CONF.database.username if hasattr(cfg.CONF.database, 'username') else None
password = cfg.CONF.database.password if hasattr(cfg.CONF.database, 'password') else None
db_setup_with_retry(cfg.CONF.database.db_name, cfg.CONF.database.host,
cfg.CONF.database.port, username=username, password=password)
# 3. Instantiate the watcher
self._trigger_watcher = TriggerWatcher(create_handler=self._handle_create_trigger,
update_handler=self._handle_update_trigger,
delete_handler=self._handle_delete_trigger,
trigger_types=self._trigger_types,
queue_suffix='sensorwrapper_%s_%s' %
(self._pack, self._class_name),
exclusive=True)
# 4. Set up logging
self._logger = logging.getLogger('SensorWrapper.%s.%s' %
(self._pack, self._class_name))
logging.setup(cfg.CONF.sensorcontainer.logging)
if '--debug' in parent_args:
set_log_level_for_all_loggers()
self._sensor_instance = self._get_sensor_instance()
def get_logger(self, name):
"""
Retrieve an instance of a logger to be used by the sensor class.
"""
logger_name = '%s.%s' % (self._sensor_wrapper._logger.name, name)
logger = logging.getLogger(logger_name)
logger.propagate = True
return logger
def test_log_audit(self):
"""Test that AUDIT log entry goes to the audit log."""
logging.setup(self.cfg_path)
log = logging.getLogger(__name__)
msg = uuid.uuid4().hex
log.audit(msg)
info_log_entries = open(self.info_log_path).read()
self.assertIn(msg, info_log_entries)
audit_log_entries = open(self.audit_log_path).read()
self.assertIn(msg, audit_log_entries)
def test_log_critical(self):
"""Test that CRITICAL log entry does not go to the audit log."""
logging.setup(self.cfg_path)
log = logging.getLogger(__name__)
msg = uuid.uuid4().hex
log.critical(msg)
info_log_entries = open(self.info_log_path).read()
self.assertIn(msg, info_log_entries)
audit_log_entries = open(self.audit_log_path).read()
self.assertNotIn(msg, audit_log_entries)
def test_logger_set_level(self):
logging.setup(self.cfg_path)
log = logging.getLogger(__name__)
self.assertEqual(log.getEffectiveLevel(), logbase.DEBUG)
log.setLevel(logbase.INFO)
self.assertEqual(log.getEffectiveLevel(), logbase.INFO)
log.setLevel(logbase.WARN)
self.assertEqual(log.getEffectiveLevel(), logbase.WARN)
log.setLevel(logbase.ERROR)
self.assertEqual(log.getEffectiveLevel(), logbase.ERROR)
log.setLevel(logbase.CRITICAL)
self.assertEqual(log.getEffectiveLevel(), logbase.CRITICAL)
log.setLevel(logbase.AUDIT)
self.assertEqual(log.getEffectiveLevel(), logbase.AUDIT)
def __init__(self, pack, file_path, class_name, trigger_types,
poll_interval=None, parent_args=None):
"""
:param pack: Name of the pack this sensor belongs to.
:type pack: ``str``
:param file_path: Path to the sensor module file.
:type file_path: ``str``
:param class_name: Sensor class name.
:type class_name: ``str``
:param trigger_types: A list of references to trigger types which
belong to this sensor.
:type trigger_types: ``list`` of ``str``
:param poll_interval: Sensor poll interval (in seconds).
:type poll_interval: ``int`` or ``None``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._class_name = class_name
self._trigger_types = trigger_types or []
self._poll_interval = poll_interval
self._parent_args = parent_args or []
self._trigger_names = {}
# 1. Parse the config with inherited parent args
try:
config.parse_args(args=self._parent_args)
except Exception:
pass
# 2. Instantiate the watcher
self._trigger_watcher = TriggerWatcher(create_handler=self._handle_create_trigger,
update_handler=self._handle_update_trigger,
delete_handler=self._handle_delete_trigger,
trigger_types=self._trigger_types)
# 3. Set up logging
self._logger = logging.getLogger('SensorWrapper.%s' %
(self._class_name))
logging.setup(cfg.CONF.sensorcontainer.logging)
self._sensor_instance = self._get_sensor_instance()
def get_logger_for_python_runner_action(action_name):
"""
Set up a logger which logs all the messages with level DEBUG and above to stderr.
"""
logger_name = 'actions.python.%s' % (action_name)
logger = logging.getLogger(logger_name)
console = stdlib_logging.StreamHandler()
console.setLevel(stdlib_logging.DEBUG)
formatter = stdlib_logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logger.addHandler(console)
logger.setLevel(stdlib_logging.DEBUG)
return logger
def _set_up_logger(self):
"""
Set up a logger which logs all the messages with level DEBUG
and above to stderr.
"""
logger_name = "actions.python.%s" % (self.__class__.__name__)
logger = logging.getLogger(logger_name)
console = stdlib_logging.StreamHandler()
console.setLevel(stdlib_logging.DEBUG)
formatter = stdlib_logging.Formatter("%(name)-12s: %(levelname)-8s %(message)s")
console.setFormatter(formatter)
logger.addHandler(console)
logger.setLevel(stdlib_logging.DEBUG)
return logger
def __init__(self, pack, file_path, config=None, parameters=None, user=None, parent_args=None,
log_level=PYTHON_RUNNER_DEFAULT_LOG_LEVEL):
"""
:param pack: Name of the pack this action belongs to.
:type pack: ``str``
:param file_path: Path to the action module.
:type file_path: ``str``
:param config: Pack config.
:type config: ``dict``
:param parameters: action parameters.
:type parameters: ``dict`` or ``None``
:param user: Name of the user who triggered this action execution.
:type user: ``str``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._config = config or {}
self._parameters = parameters or {}
self._user = user
self._parent_args = parent_args or []
self._log_level = log_level
self._class_name = None
self._logger = logging.getLogger('PythonActionWrapper')
try:
st2common_config.parse_args(args=self._parent_args)
except Exception as e:
LOG.debug('Failed to parse config using parent args (parent_args=%s): %s' %
(str(self._parent_args), str(e)))
# Note: We can only set a default user value if one is not provided after parsing the
# config
if not self._user:
# Note: We use late import to avoid performance overhead
from oslo_config import cfg
self._user = cfg.CONF.system_user.user
def __init__(self, pack, file_path, parameters=None, user=None, parent_args=None):
"""
:param pack: Name of the pack this action belongs to.
:type pack: ``str``
:param file_path: Path to the action module.
:type file_path: ``str``
:param parameters: action parameters.
:type parameters: ``dict`` or ``None``
:param user: Name of the user who triggered this action execution.
:type user: ``str``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._parameters = parameters or {}
self._user = user
self._parent_args = parent_args or []
self._class_name = None
self._logger = logging.getLogger('PythonActionWrapper')
try:
config.parse_args(args=self._parent_args)
except Exception as e:
LOG.debug('Failed to parse config using parent args (parent_args=%s): %s' %
(str(self._parent_args), str(e)))
# We don't need to ensure indexes every subprocess because they should already be created
# and ensured by other services
db_setup(ensure_indexes=False)
# Note: We can only set a default user value if one is not provided after parsing the
# config
if not self._user:
self._user = cfg.CONF.system_user.user
def main():
args = _parse_args()
if args.verbose:
_setup_logging()
output = logging.getLogger(__name__).info
else:
output = pprint.pprint
rule_file_path = os.path.realpath(args.rule)
trigger_instance_file_path = os.path.realpath(args.trigger_instance)
tester = RuleTester(rule_file_path=rule_file_path,
trigger_instance_file_path=trigger_instance_file_path)
matches = tester.evaluate()
if matches:
output('=== RULE MATCHES ===')
sys.exit(0)
else:
output('=== RULE DOES NOT MATCH ===')
sys.exit(1)
def __init__(self, pack, file_path, parameters=None, user=None, parent_args=None):
"""
:param pack: Name of the pack this action belongs to.
:type pack: ``str``
:param file_path: Path to the action module.
:type file_path: ``str``
:param parameters: action parameters.
:type parameters: ``dict`` or ``None``
:param user: Name of the user who triggered this action execution.
:type user: ``str``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._parameters = parameters or {}
self._user = user
self._parent_args = parent_args or []
self._class_name = None
self._logger = logging.getLogger('PythonActionWrapper')
try:
config.parse_args(args=self._parent_args)
except Exception:
pass
db_setup()
# Note: We can only set a default user value if one is not provided after parsing the
# config
if not self._user:
self._user = cfg.CONF.system_user.user
def __init__(self,
pack,
file_path,
class_name,
trigger_types,
poll_interval=None,
parent_args=None):
"""
:param pack: Name of the pack this sensor belongs to.
:type pack: ``str``
:param file_path: Path to the sensor module file.
:type file_path: ``str``
:param class_name: Sensor class name.
:type class_name: ``str``
:param trigger_types: A list of references to trigger types which
belong to this sensor.
:type trigger_types: ``list`` of ``str``
:param poll_interval: Sensor poll interval (in seconds).
:type poll_interval: ``int`` or ``None``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._class_name = class_name
self._trigger_types = trigger_types or []
self._poll_interval = poll_interval
self._parent_args = parent_args or []
self._trigger_names = {}
# 1. Parse the config with inherited parent args
try:
config.parse_args(args=self._parent_args)
except Exception:
pass
# 2. Establish DB connection
username = cfg.CONF.database.username if hasattr(
cfg.CONF.database, 'username') else None
password = cfg.CONF.database.password if hasattr(
cfg.CONF.database, 'password') else None
db_setup(cfg.CONF.database.db_name,
cfg.CONF.database.host,
cfg.CONF.database.port,
username=username,
password=password)
# 3. Instantiate the watcher
self._trigger_watcher = TriggerWatcher(
create_handler=self._handle_create_trigger,
update_handler=self._handle_update_trigger,
delete_handler=self._handle_delete_trigger,
trigger_types=self._trigger_types,
queue_suffix='sensorwrapper')
# 4. Set up logging
self._logger = logging.getLogger('SensorWrapper.%s' %
(self._class_name))
logging.setup(cfg.CONF.sensorcontainer.logging)
self._sensor_instance = self._get_sensor_instance()
from st2common.util.loader import register_callback_module
from st2common.util.api import get_full_public_api_url
from st2common.util.deprecation import deprecated
__all__ = [
'ActionRunner',
'AsyncActionRunner',
'PollingAsyncActionRunner',
'ShellRunnerMixin',
'get_runner',
'get_metadata'
]
LOG = logging.getLogger(__name__)
# constants to lookup in runner_parameters
RUNNER_COMMAND = 'cmd'
def get_runner(package_name, module_name, config=None):
"""
Load the module and return an instance of the runner.
"""
if not package_name:
# Backward compatibility for Pre 2.7.0 where package name always equaled module name
package_name = module_name
LOG.debug('Runner loading Python module: %s.%s', package_name, module_name)
#
# 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.
from __future__ import absolute_import
from st2common import log as logging
from st2common.services.rules import get_rules_given_trigger
from st2common.services.triggers import get_trigger_db_by_ref
from st2reactor.rules.enforcer import RuleEnforcer
from st2reactor.rules.matcher import RulesMatcher
from st2common.metrics.base import get_driver
LOG = logging.getLogger('st2reactor.rules.RulesEngine')
__all__ = [
'RulesEngine'
]
class RulesEngine(object):
def handle_trigger_instance(self, trigger_instance):
# Find matching rules for trigger instance.
matching_rules = self.get_matching_rules_for_trigger(trigger_instance)
if matching_rules:
# Create rule enforcers.
enforcers = self.create_rule_enforcers(trigger_instance, matching_rules)
from st2common.constants import action as action_constants
from st2common.constants.trace import TRACE_CONTEXT
from st2common.models.api.trace import TraceContext
from st2common.models.db.liveaction import LiveActionDB
from st2common.models.db.rule_enforcement import RuleEnforcementDB
from st2common.models.utils import action_param_utils
from st2common.models.api.auth import get_system_username
from st2common.persistence.rule_enforcement import RuleEnforcement
from st2common.services import action as action_service
from st2common.services import trace as trace_service
from st2common.util import reference
from st2common.util import action_db as action_db_util
from st2reactor.rules.datatransform import get_transformer
LOG = logging.getLogger('st2reactor.ruleenforcement.enforce')
EXEC_KICKED_OFF_STATES = [
action_constants.LIVEACTION_STATUS_SCHEDULED,
action_constants.LIVEACTION_STATUS_REQUESTED
]
class RuleEnforcer(object):
def __init__(self, trigger_instance, rule):
self.trigger_instance = trigger_instance
self.rule = rule
try:
self.data_transformer = get_transformer(trigger_instance.payload)
except Exception as e:
from st2common.constants.system import AUTH_TOKEN_ENV_VARIABLE_NAME
from st2common.constants.triggers import (SENSOR_SPAWN_TRIGGER, SENSOR_EXIT_TRIGGER)
from st2common.models.system.common import ResourceReference
from st2common.services.access import create_token
from st2common.transport.reactor import TriggerDispatcher
from st2common.util.api import get_full_public_api_url
from st2common.util.shell import on_parent_exit
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
__all__ = [
'ProcessSensorContainer'
]
LOG = logging.getLogger('st2reactor.process_sensor_container')
SUCCESS_EXIT_CODE = 0
FAILURE_EXIT_CODE = 1
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
WRAPPER_SCRIPT_NAME = 'sensor_wrapper.py'
WRAPPER_SCRIPT_PATH = os.path.join(BASE_DIR, WRAPPER_SCRIPT_NAME)
# How many times to try to subsequently respawn a sensor after a non-zero exit before giving up
SENSOR_MAX_RESPAWN_COUNTS = 2
# How many seconds after the sensor has been started we should wait before considering sensor as
# being started and running successfuly
SENSOR_SUCCESSFUL_START_THRESHOLD = 10
from st2common.persistence.reactor import SensorType
from st2common.signal_handlers import register_common_signal_handlers
from st2reactor.sensor import config
from st2common.transport.utils import register_exchanges
from st2common.triggers import register_internal_trigger_types
from st2reactor.container.manager import SensorContainerManager
eventlet.monkey_patch(
os=True,
select=True,
socket=True,
thread=False if '--use-debugger' in sys.argv else True,
time=True)
LOG = logging.getLogger('st2reactor.bin.sensors_manager')
def _setup():
# Set up logger which logs everything which happens during and before config
# parsing to sys.stdout
logging.setup(DEFAULT_LOGGING_CONF_PATH)
# 1. parse config args
config.parse_args()
# 2. setup logging.
logging.setup(cfg.CONF.sensorcontainer.logging)
# 3. all other setup which requires config to be parsed and logging to
# be correctly setup.
# 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 six
from jsonpath_rw import parse
from st2common import log as logging
import st2common.operators as criteria_operators
from st2common.constants.rules import TRIGGER_PAYLOAD_PREFIX, RULE_TYPE_BACKSTOP
from st2common.constants.system import SYSTEM_KV_PREFIX
from st2common.services.keyvalues import KeyValueLookup
from st2common.util.templating import render_template_with_system_context
LOG = logging.getLogger('st2reactor.ruleenforcement.filter')
class RuleFilter(object):
def __init__(self, trigger_instance, trigger, rule, extra_info=False):
"""
:param trigger_instance: TriggerInstance DB object.
:type trigger_instance: :class:`TriggerInstanceDB``
:param trigger: Trigger DB object.
:type trigger: :class:`TriggerDB`
:param rule: Rule DB object.
:type rule: :class:`RuleDB`
"""
self.trigger_instance = trigger_instance
# 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.
from __future__ import absolute_import
from st2common import log as logging
from st2common.constants.triggers import TRIGGER_INSTANCE_PENDING
from st2common.exceptions.db import StackStormDBObjectNotFoundError
from st2common.models.db.trigger import TriggerInstanceDB
from st2common.persistence.trigger import TriggerInstance
from st2common.services.triggers import get_trigger_db_by_ref_or_dict
LOG = logging.getLogger('st2reactor.sensor.container_utils')
def create_trigger_instance(trigger, payload, occurrence_time, raise_on_no_trigger=False):
"""
This creates a trigger instance object given trigger and payload.
Trigger can be just a string reference (pack.name) or a ``dict`` containing 'id' or
'uid' or type' and 'parameters' keys.
:param trigger: Trigger reference or dictionary with trigger query filters.
:type trigger: ``str`` or ``dict``
:param payload: Trigger payload.
:type payload: ``dict``
"""
trigger_db = get_trigger_db_by_ref_or_dict(trigger=trigger)
# limitations under the License.
import json
from st2common import log as logging
from st2common.util import reference
from st2common.util import action_db as action_db_util
from st2reactor.rules.datatransform import get_transformer
from st2common.services import action as action_service
from st2common.models.db.liveaction import LiveActionDB
from st2common.models.utils import action_param_utils
from st2common.constants import action as action_constants
from st2common.models.api.auth import get_system_username
LOG = logging.getLogger('st2reactor.ruleenforcement.enforce')
class RuleEnforcer(object):
def __init__(self, trigger_instance, rule):
self.trigger_instance = trigger_instance
self.rule = rule
try:
self.data_transformer = get_transformer(trigger_instance.payload)
except Exception as e:
message = ('Failed to template-ize trigger payload: %s. If the payload contains '
'special characters such as "{{" which dont\'t reference value in '
'a datastore, those characters need to be escaped' % (str(e)))
raise ValueError(message)
def get_logger(self, name):
logging.getLogger(__name__ + '.' + name)
def get_logger(self, name):
from st2common import log as logging
logging.getLogger(__name__ + '.' + name)
from st2common import log as logging
from st2common.models.db import db_setup
from st2common.models.db import db_teardown
from st2common.constants.logging import DEFAULT_LOGGING_CONF_PATH
from st2common.transport.utils import register_exchanges
from st2reactor.sensor import config
from st2common.persistence.reactor import SensorType
from st2reactor.container.manager import SensorContainerManager
eventlet.monkey_patch(os=True,
select=True,
socket=True,
thread=False if '--use-debugger' in sys.argv else True,
time=True)
LOG = logging.getLogger('st2reactor.bin.sensors_manager')
def _setup():
# Set up logger which logs everything which happens during and before config
# parsing to sys.stdout
logging.setup(DEFAULT_LOGGING_CONF_PATH)
# 1. parse config args
config.parse_args()
# 2. setup logging.
logging.setup(cfg.CONF.sensorcontainer.logging)
# 3. all other setup which requires config to be parsed and logging to
# be correctly setup.
import paramiko
from fabric.operations import _execute as fabric_execute_cmd_blocking
from st2common import log as logging
from st2common.exceptions.connection import AuthenticationException
from st2common.exceptions.connection import (ConnectionErrorException, UnknownHostException)
eventlet.monkey_patch(
os=True,
select=True,
socket=True,
thread=False if '--use-debugger' in sys.argv else True,
time=True
)
LOG = logging.getLogger('st2.util.ssh.paramikoclient')
# This implementation of SSH is heavily inspired by parallel-ssh which uses gvent instead of
# eventlet.
class SSHClient(object):
'''
Thread unsafe version of SSHClient.
'''
def __init__(self, host,
user=None, password=None, port=None,
key=None, connect_max_retries=2):
ssh_config = paramiko.SSHConfig()
_ssh_config_file = os.path.sep.join([os.path.expanduser('~'),
'.ssh',
'config'])
from collections import defaultdict
import fnmatch
import os
import re
from st2common import log as logging
from st2common.exceptions.plugins import IncompatiblePluginException
import st2common.util.loader as sensors_loader
from st2reactor.sensor.base import Sensor
LOG = logging.getLogger('st2reactor.bin.sensor_container')
class SensorLoader(object):
# XXX: For now, let's just hardcode the includes & excludes pattern
# here. We should eventually move these to config if that makes sense
# at all.
includes = ['*.py']
excludes = ['*/__init__.py']
# transform glob patterns to regular expressions
_includes = r'|'.join([fnmatch.translate(x) for x in includes])
_excludes = r'|'.join([fnmatch.translate(x) for x in excludes])
def _get_sensor_files(self, base_dir):
if not os.path.isdir(base_dir):
raise Exception('Directory containing sensors must be provided.')
sensor_files = []
for (dirpath, dirnames, filenames) in os.walk(base_dir):
# exclude/include files
files = [os.path.join(dirpath, f) for f in filenames]
files = [f for f in files if re.match(self._includes, f)]
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import six
from st2common import log as logging
from st2common.exceptions.sensors import TriggerTypeRegistrationException
from st2common.persistence.reactor import SensorType, TriggerInstance
from st2common.models.db.reactor import SensorTypeDB, TriggerInstanceDB
from st2common.services import triggers as TriggerService
from st2common.constants.pack import SYSTEM_PACK_NAME
from st2common.constants.sensors import MINIMUM_POLL_INTERVAL
LOG = logging.getLogger('st2reactor.sensor.container_utils')
def create_trigger_instance(trigger, payload, occurrence_time):
"""
This creates a trigger instance object given trigger and payload.
Trigger can be just a string reference (pack.name) or a ``dict``
containing 'type' and 'parameters'.
:param trigger: Dictionary with trigger query filters.
:type trigger: ``dict``
:param payload: Trigger payload.
:type payload: ``dict``
"""
# TODO: This is nasty, this should take a unique reference and not a dict
from st2common.service_setup import teardown as common_teardown
from st2common.util.monkey_patch import monkey_patch
from st2common.exceptions.sensors import SensorNotFoundException
from st2common.constants.exit_codes import FAILURE_EXIT_CODE
from st2reactor.sensor import config
from st2reactor.container.manager import SensorContainerManager
from st2reactor.container.partitioner_lookup import get_sensors_partitioner
__all__ = [
'main'
]
monkey_patch()
LOGGER_NAME = get_logger_name_for_module(sys.modules[__name__])
LOG = logging.getLogger(LOGGER_NAME)
def _setup():
capabilities = {
'name': 'sensorcontainer',
'type': 'passive'
}
common_setup(service='sensorcontainer', config=config, setup_db=True,
register_mq_exchanges=True, register_signal_handlers=True,
register_runners=False, service_registry=True, capabilities=capabilities)
def _teardown():
common_teardown()
from st2common.models.db import db_teardown
from st2common.constants.logging import DEFAULT_LOGGING_CONF_PATH
from st2common.transport.utils import register_exchanges
from st2common.signal_handlers import register_common_signal_handlers
from st2reactor.rules import config
from st2reactor.rules import worker
from st2reactor.timer.base import St2Timer
eventlet.monkey_patch(
os=True,
select=True,
socket=True,
thread=False if '--use-debugger' in sys.argv else True,
time=True)
LOG = logging.getLogger('st2reactor.bin.rulesengine')
def _setup():
# Set up logger which logs everything which happens during and before config
# parsing to sys.stdout
logging.setup(DEFAULT_LOGGING_CONF_PATH)
# 1. parse config args
config.parse_args()
# 2. setup logging.
logging.setup(cfg.CONF.rulesengine.logging)
# 3. all other setup which requires config to be parsed and logging to
# be correctly setup.
# 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.
from __future__ import absolute_import
from st2common import log as logging
from st2common.constants.rules import RULE_TYPE_BACKSTOP
from st2reactor.rules.filter import RuleFilter, SecondPassRuleFilter
LOG = logging.getLogger('st2reactor.rules.RulesMatcher')
class RulesMatcher(object):
def __init__(self, trigger_instance, trigger, rules, extra_info=False):
self.trigger_instance = trigger_instance
self.trigger = trigger
self.rules = rules
self.extra_info = extra_info
def get_matching_rules(self):
first_pass, second_pass = self._split_rules_into_passes()
# first pass
rule_filters = [RuleFilter(trigger_instance=self.trigger_instance,
trigger=self.trigger,
rule=rule,
# 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.
from kombu import Connection
from st2common import log as logging
from st2common.transport import utils as transport_utils
from st2common.transport.connection_retry_wrapper import ConnectionRetryWrapper
from st2common.transport.execution import EXECUTION_XCHG
from st2common.transport.liveaction import LIVEACTION_XCHG
from st2common.transport.reactor import TRIGGER_CUD_XCHG, TRIGGER_INSTANCE_XCHG
from st2common.transport.reactor import SENSOR_CUD_XCHG
LOG = logging.getLogger('st2common.transport.bootstrap')
__all__ = [
'register_exchanges'
]
EXCHANGES = [EXECUTION_XCHG, LIVEACTION_XCHG, TRIGGER_CUD_XCHG, TRIGGER_INSTANCE_XCHG,
SENSOR_CUD_XCHG]
def _do_register_exchange(exchange, connection, channel, retry_wrapper):
try:
kwargs = {
'exchange': exchange.name,
'type': exchange.type,
'durable': exchange.durable,
#
# 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.
from kombu import Connection
from oslo_config import cfg
from st2common import log as logging
from st2common.transport.execution import EXECUTION_XCHG
from st2common.transport.liveaction import LIVEACTION_XCHG
from st2common.transport.reactor import TRIGGER_CUD_XCHG, TRIGGER_INSTANCE_XCHG
from st2common.transport.reactor import SENSOR_CUD_XCHG
LOG = logging.getLogger("st2common.transport.bootstrap")
EXCHANGES = [EXECUTION_XCHG, LIVEACTION_XCHG, TRIGGER_CUD_XCHG, TRIGGER_INSTANCE_XCHG, SENSOR_CUD_XCHG]
def _do_register_exchange(exchange, channel):
try:
channel.exchange_declare(
exchange=exchange.name,
type=exchange.type,
durable=exchange.durable,
auto_delete=exchange.auto_delete,
arguments=exchange.arguments,
nowait=False,
passive=None,
)
from st2common.service_setup import setup as common_setup
from st2common.service_setup import teardown as common_teardown
from st2common.util.monkey_patch import monkey_patch
from st2common.constants.exit_codes import FAILURE_EXIT_CODE
from st2reactor.garbage_collector import config
from st2reactor.garbage_collector.base import GarbageCollectorService
__all__ = [
'main'
]
monkey_patch()
LOGGER_NAME = get_logger_name_for_module(sys.modules[__name__])
LOG = logging.getLogger(LOGGER_NAME)
def _setup():
common_setup(service='garbagecollector', config=config, setup_db=True,
register_mq_exchanges=True, register_signal_handlers=True)
def _teardown():
common_teardown()
def main():
try:
_setup()
# 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 six
from jsonpath_rw import parse
from st2common import log as logging
import st2common.operators as criteria_operators
from st2common.constants.rules import TRIGGER_PAYLOAD_PREFIX, RULE_TYPE_BACKSTOP
from st2common.constants.system import SYSTEM_KV_PREFIX
from st2common.services.keyvalues import KeyValueLookup
from st2common.util.templating import render_template_with_system_context
LOG = logging.getLogger('st2reactor.ruleenforcement.filter')
class RuleFilter(object):
def __init__(self, trigger_instance, trigger, rule, extra_info=False):
"""
:param trigger_instance: TriggerInstance DB object.
:type trigger_instance: :class:`TriggerInstanceDB``
:param trigger: Trigger DB object.
:type trigger: :class:`TriggerDB`
:param rule: Rule DB object.
:type rule: :class:`RuleDB`
"""
self.trigger_instance = trigger_instance
def __init__(self,
pack,
file_path,
class_name,
trigger_types,
poll_interval=None,
parent_args=None):
"""
:param pack: Name of the pack this sensor belongs to.
:type pack: ``str``
:param file_path: Path to the sensor module file.
:type file_path: ``str``
:param class_name: Sensor class name.
:type class_name: ``str``
:param trigger_types: A list of references to trigger types which
belong to this sensor.
:type trigger_types: ``list`` of ``str``
:param poll_interval: Sensor poll interval (in seconds).
:type poll_interval: ``int`` or ``None``
:param parent_args: Command line arguments passed to the parent process.
:type parse_args: ``list``
"""
self._pack = pack
self._file_path = file_path
self._class_name = class_name
self._trigger_types = trigger_types or []
self._poll_interval = poll_interval
self._parent_args = parent_args or []
self._trigger_names = {}
# 1. Parse the config with inherited parent args
try:
config.parse_args(args=self._parent_args)
except Exception:
pass
# 2. Establish DB connection
username = cfg.CONF.database.username if hasattr(
cfg.CONF.database, 'username') else None
password = cfg.CONF.database.password if hasattr(
cfg.CONF.database, 'password') else None
db_setup_with_retry(
cfg.CONF.database.db_name,
cfg.CONF.database.host,
cfg.CONF.database.port,
username=username,
password=password,
ssl=cfg.CONF.database.ssl,
ssl_keyfile=cfg.CONF.database.ssl_keyfile,
ssl_certfile=cfg.CONF.database.ssl_certfile,
ssl_cert_reqs=cfg.CONF.database.ssl_cert_reqs,
ssl_ca_certs=cfg.CONF.database.ssl_ca_certs,
authentication_mechanism=cfg.CONF.database.
authentication_mechanism,
ssl_match_hostname=cfg.CONF.database.ssl_match_hostname)
# 3. Instantiate the watcher
self._trigger_watcher = TriggerWatcher(
create_handler=self._handle_create_trigger,
update_handler=self._handle_update_trigger,
delete_handler=self._handle_delete_trigger,
trigger_types=self._trigger_types,
queue_suffix='sensorwrapper_%s_%s' %
(self._pack, self._class_name),
exclusive=True)
# 4. Set up logging
self._logger = logging.getLogger('SensorWrapper.%s.%s' %
(self._pack, self._class_name))
logging.setup(cfg.CONF.sensorcontainer.logging)
if '--debug' in parent_args:
set_log_level_for_all_loggers()
else:
# NOTE: statsd logger logs everything by default under INFO so we ignore those log
# messages unless verbose / debug mode is used
logging.ignore_statsd_log_messages()
self._sensor_instance = self._get_sensor_instance()
# limitations under the License.
from kombu import Connection
from kombu.mixins import ConsumerMixin
from oslo.config import cfg
from st2actions.container.base import RunnerContainer
from st2common import log as logging
from st2common.exceptions.db import StackStormDBObjectNotFoundError
from st2common.constants.action import (ACTIONEXEC_STATUS_RUNNING, ACTIONEXEC_STATUS_FAILED)
from st2common.exceptions.actionrunner import ActionRunnerException
from st2common.transport import actionexecution, publishers
from st2common.util.action_db import (get_actionexec_by_id, update_actionexecution_status)
from st2common.util.greenpooldispatch import BufferedDispatcher
LOG = logging.getLogger(__name__)
ACTIONRUNNER_WORK_Q = actionexecution.get_queue('st2.actionrunner.work',
routing_key=publishers.CREATE_RK)
class Worker(ConsumerMixin):
def __init__(self, connection):
self.connection = connection
self.container = RunnerContainer()
self._dispatcher = BufferedDispatcher()
def shutdown(self):
self._dispatcher.shutdown()
from st2common.models.db import db_teardown
from st2common.constants.logging import DEFAULT_LOGGING_CONF_PATH
from st2common.transport.utils import register_exchanges
from st2common.signal_handlers import register_common_signal_handlers
from st2reactor.rules import config
from st2reactor.rules import worker
from st2reactor.timer.base import St2Timer
eventlet.monkey_patch(
os=True,
select=True,
socket=True,
thread=False if '--use-debugger' in sys.argv else True,
time=True)
LOG = logging.getLogger('st2reactor.bin.rulesengine')
def _setup():
# Set up logger which logs everything which happens during and before config
# parsing to sys.stdout
logging.setup(DEFAULT_LOGGING_CONF_PATH)
# 1. parse config args
config.parse_args()
# 2. setup logging.
logging.setup(cfg.CONF.rulesengine.logging)
# 3. all other setup which requires config to be parsed and logging to
# be correctly setup.
