def __init__(self, comp_name, zkclient, nodepath,
operational=False, parent=None, interval=5):
"""
:type comp_name: str
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type operational: bool
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self, comp_name, operational=operational, parent=parent)
self.node = nodepath
self.zkclient = zkclient
self.interval = interval
self._start = None
self._stop = None
self._log = logging.getLogger('sent.{0}.pred.gut'.format(comp_name))
self._log.info('Registered {0}'.format(self))
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._started = False
self._datetime_regex = (
"^((?P<year>\d{4})\-(?P<month>\d{2})\-(?P<day>\d{2})\s)?"
"(?P<hour>\d{2}):(?P<minute>\d{2})(:(?P<second>\d{2}))?"
)
def __init__(self,
comp_name,
command,
interval,
system,
operational=False,
parent=None):
"""
:type comp_name: str
:type command: str
:type interval: int or float
:type system: zoom.common.types.PlatformType
:type operational: bool
:type parent: str or None
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self._log = logging.getLogger('sent.{0}.pred.health'.format(comp_name))
self.interval = interval
self.rawcmd = command
self._runcmd = str()
self._system = system
self._verify()
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._log.info('Registered {0}'.format(self))
self._started = False
def __init__(self,
comp_name,
proc_client,
interval,
operational=False,
parent=None):
"""
:type comp_name: str
:type proc_client: zoom.agent.client.process_client.ProcessClient
:type interval: int or float
:type operational: bool
:type parent: str or None
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self._log = logging.getLogger(
'sent.{0}.pred.process'.format(comp_name))
self._proc_client = proc_client
# lock for synchronous decorator
if proc_client:
self.process_client_lock = proc_client.process_client_lock
else:
self.process_client_lock = Lock()
self.interval = interval
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._started = False
def __init__(self,
comp_name,
begin=None,
end=None,
weekdays=None,
operational=False,
parent=None,
interval=5):
"""
:type comp_name: str
:type begin: str or None
:type end: str or None
:type weekdays: str or None
:type operational: bool
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self.begin = self.get_datetime_object(begin)
self.end = self.get_datetime_object(end)
self.day_range = self.parse_range(weekdays)
self.interval = interval
self._log = logging.getLogger(
'sent.{0}.pred.timewin'.format(comp_name))
self._log.info('Registered {0}'.format(self))
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._started = False
def __init__(self,
comp_name,
zkclient,
path,
operational=False,
parent=None,
interval=10):
"""
:type comp_name: str
:type zkclient: kazoo.client.KazooClient
:type path: str or None
:type operational: bool
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self.zkclient = zkclient
self.interval = interval
self.path = path
self._log = logging.getLogger('sent.{0}.holiday'.format(comp_name))
self._log.info('Registered {0}'.format(self))
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._started = False
self._holidays = list()
def __init__(self,
comp_name,
url,
verb='GET',
expected_code=200,
interval=5.0,
operational=False,
parent=None):
"""
:type comp_name: str
:type url: str
:type verb: str
:type expected_code: int
:type interval: int or float
:type operational: bool
:type parent: str or None
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self._log = logging.getLogger('sent.{0}.pred.api'.format(comp_name))
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(
logging.WARNING)
self.url = url
self.verb = verb
self.expected_code = expected_code
self.interval = interval
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._log.info('Registered {0}'.format(self))
self._started = False
def setUp(self):
self.mox = mox.Mox()
self.comp_name = "Test Predicate Or"
self.predat = SimplePredicate("a", ThreadSafeObject({}))
self.predat.set_met(True)
self.predbt = SimplePredicate("b", ThreadSafeObject({}))
self.predbt.set_met(True)
self.predaf = SimplePredicate("a", ThreadSafeObject({}))
self.predbf = SimplePredicate("b", ThreadSafeObject({}))
self.list = [self.predaf, self.predbf, self.predat, self.predbt]
self.factory = PredicateFactory(component_name="factory",
zkclient=None,
proc_client=None,
system=None,
pred_list=self.list,
settings={})
def __init__(self, comp_name, queue, work_dict):
"""
:type comp_name: str
:type queue: zoom.agent.entities.unique_queue.UniqueQueue
:type work_dict: dict
"""
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run,
name='work_manager',
args=(self._operate, queue, work_dict))
self._thread.daemon = True
self._log = logging.getLogger('sent.{0}.wm'.format(comp_name))
def __init__(self, config, system, settings):
"""
:type config: xml.etree.ElementTree.Element
:type system: zoom.common.types.PlatformType
:type settings: dict
"""
self._log = logging.getLogger('sent.child')
self._action_queue = UniqueQueue()
self._cancel_flag = ThreadSafeObject(False)
self.name = verify_attribute(config, 'id')
self._application_type = verify_attribute(config, 'type')
self._config = config
self._system = system # Linux or Windows
self._settings = settings
self._process = self._create_process()
def __init__(self, comp_name, operational=False, parent=None, interval=10):
"""
:type comp_name: str
:type operational: bool
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self.interval = interval
self._log = logging.getLogger('sent.{0}.weekend'.format(comp_name))
self._log.info('Registered {0}'.format(self))
self._operate = ThreadSafeObject(True)
self._thread = Thread(target=self._run_loop, name=str(self))
self._thread.daemon = True
self._started = False
def test_no_match(self):
new = SimplePredicate("c", ThreadSafeObject({}))
ret = self.factory._ensure_new(new)
self.assertTrue(new is ret)
def __init__(self,
name,
component_name,
action,
xmlpart,
staggerpath=None,
staggertime=None,
mode_controlled=False,
action_q=None,
zkclient=None,
proc_client=None,
mode=None,
system=None,
pred_list=None,
settings=None,
disabled=False,
pd_enabled=True,
op_action=None,
pd_reason=None,
app_state=None):
"""
:param action: The function to run when all the action's predicates are met
:param xmlpart: The part of XML pertaining to this Action
:param mode_controlled: Whether or not the action will run based on the ApplicationMode
:param op_action: The function to run if this action's operation dependencies go down.
:type name: str
:type component_name: str
:type action: types.FunctionType
:type xmlpart: xml.etree.ElementTree.Element
:type staggerpath: str
:type staggertime: int
:type mode_controlled: bool
:type action_q: zoom.agent.entities.unique_queue.UniqueQueue
:type zkclient: kazoo.client.KazooClient
:type proc_client: zoom.agent.client.process_client.ProcessClient
:type mode: zoom.agent.entities.thread_safe_object.ApplicationMode
:type system: zoom.common.types.PlatformType
:type pred_list: list
:type settings: dict
:type disabled: bool
:type pd_enabled: bool
:type op_action: types.FunctionType or None
:type pd_reason: str or None
:type app_state: zoom.agent.entities.thread_safe_object.ThreadSafeObject
"""
self.name = name
self.disabled = disabled
self.component_name = component_name
self._log = logging.getLogger('sent.{0}.act'.format(component_name))
self._action = action
self._action_queue = action_q
self._mode_controlled = mode_controlled
self._mode = mode
self._pd_enabled = pd_enabled
self._op_action = op_action
self._pd_reason = pd_reason
self._acquire_lock = ThreadSafeObject(True)
if staggerpath is not None and staggertime is not None:
self._stag_lock = StaggerLock(staggerpath,
staggertime,
parent=self.component_name,
acquire_lock=self._acquire_lock,
app_state=app_state)
self._log.info('Using {0}'.format(self._stag_lock))
else:
self._stag_lock = None
factory = PredicateFactory(component_name=component_name,
action=self.name,
zkclient=zkclient,
proc_client=proc_client,
system=system,
pred_list=pred_list,
settings=settings)
self._predicate = factory.create(
xmlpart.find('./Dependency/Predicate'), callback=self._callback)
def __init__(self, config, settings, queue, system, application_type,
cancel_flag):
"""
:type config: dict (xml)
:type settings: dict
:type queue: zoom.agent.entities.unique_queue.UniqueQueue
:type system: zoom.common.types.PlatformType
:type application_type: zoom.common.types.ApplicationType
:type cancel_flag: zoom.agent.entities.thread_safe_object.ThreadSafeObject
"""
self.config = config
self._settings = settings
self.name = verify_attribute(self.config, 'id', none_allowed=False)
self._log = logging.getLogger('sent.{0}.app'.format(self.name))
# informational attributes
self._host = socket.getfqdn()
self._system = system
self._predicates = list()
self._running = True # used to manually stop the run loop
self._prev_state = None
self._actions = dict() # created in _reset_watches on zk connect
self._env = os.environ.get('EnvironmentToUse', 'Staging')
self._apptype = application_type
self._restart_on_crash = \
verify_attribute(self.config, 'restart_on_crash', none_allowed=True)
self._post_stop_sleep = verify_attribute(self.config,
'post_stop_sleep',
none_allowed=True,
cast=int,
default=5)
# tool-like attributes
self.listener_lock = Lock()
self._action_queue = queue
self._mode = ApplicationMode(
ApplicationMode.MANUAL,
callback=self._update_agent_node_with_app_details)
self._state = ThreadSafeObject(
ApplicationState.OK,
callback=self._update_agent_node_with_app_details)
self._start_stop_time = '' # Default to empty string for comparison
self._login_user = '******' # Default to Zoom
self._user_set_in_react = False
self._run_check_mode = False
self._pd_svc_key = verify_attribute(config,
'pagerduty_service',
none_allowed=True)
restartmax = verify_attribute(config,
'restartmax',
none_allowed=True,
cast=int,
default=3)
self._rl = RestartLogic(
self.name,
restartmax,
count_callback=self._update_agent_node_with_app_details)
self._read_only = False
self._paths = self._init_paths(self.config, settings, application_type)
# clients
self.zkclient = KazooClient(hosts=get_zk_conn_string(),
timeout=60.0,
handler=SequentialThreadingHandler(),
logger=logging.getLogger(
'kazoo.app.{0}'.format(self.name)))
self.zkclient.add_listener(self._zk_listener)
self._proc_client = self._init_proc_client(self.config,
application_type,
cancel_flag)
self._actions = self._init_actions(settings)
self._work_manager = self._init_work_manager(self._action_queue)