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
class PredicateFactoryTest(TestCase):
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 tearDown(self):
pass
def test_match(self):
new = SimplePredicate("a", ThreadSafeObject({}))
ret = self.factory._ensure_new(new)
self.assertTrue(new is not ret)
def test_no_match(self):
new = SimplePredicate("c", ThreadSafeObject({}))
ret = self.factory._ensure_new(new)
self.assertTrue(new is ret)
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,
nodepath,
ephemeral_only=True,
met_on_delete=False,
operational=False,
new_node_callback=None,
parent=None):
"""
:type comp_name: str
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type ephemeral_only: bool
:type met_on_delete: bool
:param met_on_delete: Whether we want met to be True when nodepath is
deleted
:type operational: bool
:type new_node_callback: types.FunctionType or None
:param new_node_callback: This is a special callback used by
ZookeeperHasGranchildren to keep track of new static nodes
:type parent: str or None
"""
SimplePredicate.__init__(self,
comp_name,
operational=operational,
parent=parent)
self.node = nodepath
self.zkclient = zkclient
self._ephemeral_only = ephemeral_only
self._met_on_delete = met_on_delete
self._nn_calback = new_node_callback # currently unused
self._log = logging.getLogger('sent.{0}.pred.hc'.format(comp_name))
self._log.info('Registered {0}'.format(self))
def __init__(self, comp_name, zkclient, nodepath, ephemeral_only=True,
met_on_delete=False, operational=False, new_node_callback=None,
parent=None):
"""
:type comp_name: str
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type ephemeral_only: bool
:type met_on_delete: bool
:param met_on_delete: Whether we want met to be True when nodepath is
deleted
:type operational: bool
:type new_node_callback: types.FunctionType or None
:param new_node_callback: This is a special callback used by
ZookeeperHasGranchildren to keep track of new static nodes
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, operational=operational, parent=parent)
self.node = nodepath
self.zkclient = zkclient
self._ephemeral_only = ephemeral_only
self._met_on_delete = met_on_delete
self._nn_calback = new_node_callback # currently unused
self._log = logging.getLogger('sent.{0}.pred.hc'.format(comp_name))
self._log.info('Registered {0}'.format(self))
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,
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 __init__(self, comp_name, settings, zkclient, nodepath, parent=None, interval=5):
"""
:type comp_name: str
:type settings: zoom.agent.entities.thread_safe_object.ThreadSafeObject
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self, comp_name, settings, 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,
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
class PredicateFactoryTest(TestCase):
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", parent=None,
zkclient=None, proc_client=None,
system=None, pred_list=self.list,
settings={})
def tearDown(self):
pass
def test_match(self):
new = SimplePredicate("a", ThreadSafeObject({}))
ret = self.factory._ensure_new(new)
self.assertTrue(new is not ret)
def test_no_match(self):
new = SimplePredicate("c", ThreadSafeObject({}))
ret = self.factory._ensure_new(new)
self.assertTrue(new is ret)
def _create_simple_pred(self, cname=None, met=None):
if cname is None:
cname = self.comp_name
s = SimplePredicate(cname, parent='foo')
if met is not None:
s.set_met(met)
return s
def _create_simple_pred(self, cname=None, met=None):
if cname is None:
cname = self.comp_name
s = SimplePredicate(cname, parent='foo')
if met is not None:
s.set_met(met)
return s
def __init__(self, comp_name, pred, parent=None):
"""
:type comp_name: str
:type pred: zoom.agent.entities.dependency object
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, parent=parent)
self.dependency = pred
self._log = logging.getLogger("sent.{0}.pred.not".format(comp_name))
self._log.info("Registered {0}".format(self))
def __init__(self, comp_name, pred, parent=None):
"""
:type comp_name: str
:type pred: zoom.agent.entities.dependency object
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, parent=parent)
self.dependency = pred
self._log = logging.getLogger('sent.{0}.pred.not'.format(comp_name))
self._log.info('Registered {0}'.format(self))
def __init__(self, comp_name, predicates, parent=None):
"""
:type comp_name: str
:type predicates: list of zoom.agent.entities.predicate objects
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, parent=parent)
self.dependencies = predicates
self._log = logging.getLogger('sent.{0}.pred.and'.format(comp_name))
self._log.info('Registered {0}'.format(self))
self._started = False
def __init__(self, comp_name, predicates, parent=None):
"""
:type comp_name: str
:type predicates: list of zoom.agent.entities.predicate objects
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, parent=parent)
self.dependencies = predicates
self._log = logging.getLogger('sent.{0}.pred.or'.format(comp_name))
self._log.info('Registered {0}'.format(self))
self._started = False
def __init__(self, comp_name, settings, pred, parent=None):
"""
:type comp_name: str
:type settings: zoom.agent.entities.thread_safe_object.ThreadSafeObject
:type pred: zoom.agent.entities.dependency object
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, settings, parent=parent)
self.dependency = pred
self._log = logging.getLogger('sent.{0}.pred.not'.format(comp_name))
self._log.info('Registered {0}'.format(self))
def _create_dummy_predicate(self):
# to catch the case where there are no predicates
"""
A dummy predicate will be returned by the factory if there are no
predicates, or if the config has an unknown predicate type.
:rtype: zoom.agent.predicate.simple.SimplePredicate
"""
dummy = SimplePredicate(self._component_name,
self._settings,
parent=self._parent)
dummy.set_met(True)
return dummy
def __init__(self, comp_name, zkclient, nodepath,
operational=False, parent=None):
"""
:type comp_name: str
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type operational: bool
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, operational=operational, parent=parent)
self.node = nodepath
self.zkclient = zkclient
self._log = logging.getLogger('sent.{0}.pred.ne'.format(comp_name))
self._log.info('Registered {0}'.format(self))
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 __init__(self, comp_name, settings, zkclient, nodepath, met_on_delete=False,
parent=None):
"""
:type comp_name: str
:type settings: zoom.agent.entities.thread_safe_object.ThreadSafeObject
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type met_on_delete: bool
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, settings, parent=parent)
self.node = nodepath
self.zkclient = zkclient
self._met_on_delete = met_on_delete
self._log = logging.getLogger('sent.{0}.pred.hc'.format(comp_name))
self._log.info('Registered {0}'.format(self))
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, zkclient, nodepath,
ephemeral_only=True, operational=False, parent=None):
"""
:type comp_name: str
:type zkclient: kazoo.client.KazooClient
:type nodepath: str
:type ephemeral_only: bool
:type operational: bool
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, operational=operational, parent=parent)
self.node = nodepath
self.zkclient = zkclient
self._ephemeral_only = ephemeral_only
self._children = list()
self._log = logging.getLogger('sent.{0}.pred.hgc'.format(comp_name))
self._log.info('Registered {0}'.format(self))
def __init__(self, comp_name, settings, zkclient, parent=None, interval=10):
"""
:type comp_name: str
:type settings: zoom.agent.entities.thread_safe_object.ThreadSafeObject
:type zkclient: kazoo.client.KazooClient
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self, comp_name, settings, parent=parent)
self.zkclient = zkclient
self.interval = interval
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, 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 __init__(self, comp_name, settings, proc_client, interval, parent=None):
"""
:type comp_name: str
:type settings: zoom.agent.entities.thread_safe_object.ThreadSafeObject
:type proc_client: zoom.agent.client.process_client.ProcessClient
:type interval: int or float
:type parent: str or None
"""
SimplePredicate.__init__(self, comp_name, settings, 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, 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, settings,
start=None, stop=None, weekdays=None, parent=None, interval=5):
"""
:type comp_name: str
:type settings: ThreadSafeObject
:type start: str or None
:type stop: str or None
:type weekdays: str or None
:type parent: str or None
:type interval: int or float
"""
SimplePredicate.__init__(self, comp_name, settings, parent=parent)
self.start_time = self._get_datetime_object(start)
self.stop_time = self._get_datetime_object(stop)
self.day_range = self._parse_range(weekdays)
self.interval = interval
self._log = logging.getLogger('sent.{0}.pred.time'.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, 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 create(self, xmlpart, callback=None, parent=None):
"""
:type xmlpart: xml.etree.ElementTree.Element
:type callback: types.FunctionType or None
:type parent: str or None
"""
if xmlpart is None:
# A dummy predicate will be returned if there are no predicates
# met is true b/c we don't want to block on no predicates
return create_dummy(comp=self._component_name,
parent=self._action,
met=True)
if isinstance(xmlpart, str):
root = ElementTree.fromstring(xmlpart)
else:
root = xmlpart
if parent is None:
parent = self._action
ptype = verify_attribute(root, 'type').lower()
operational = bool(
verify_attribute(root, 'operational', none_allowed=True))
if ptype == 'simple':
return self._ensure_new(SimplePredicate(self._component_name,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERNODEEXISTS:
return self._ensure_new(ZookeeperNodeExists(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERHASCHILDREN:
return self._ensure_new(ZookeeperHasChildren(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
ephemeral_only=verify_attribute(root,
'ephemeral_only',
none_allowed=True,
default=True),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERHASGRANDCHILDREN:
return self._ensure_new(ZookeeperHasGrandChildren(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
ephemeral_only=verify_attribute(root,
'ephemeral_only',
none_allowed=True,
default=True),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERGLOB:
return self._ensure_new(ZookeeperGlob(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
ephemeral_only=verify_attribute(root,
'ephemeral_only',
none_allowed=True,
default=True),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.ZOOKEEPERGOODUNTILTIME:
return self._ensure_new(ZookeeperGoodUntilTime(
self._component_name,
self.zkclient,
verify_attribute(root, 'path'),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.PROCESS:
return self._ensure_new(PredicateProcess(self._component_name,
self._proc_client,
verify_attribute(
root,
'interval',
cast=float),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.API:
return self._ensure_new(APIPredicate(
self._component_name,
verify_attribute(root, 'url'),
verb=verify_attribute(root,
'verb',
none_allowed=True,
default='GET'),
expected_code=verify_attribute(root,
'expected_code',
none_allowed=True,
cast=int,
default=200),
interval=verify_attribute(root, 'interval', cast=float),
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.HEALTH:
return self._ensure_new(PredicateHealth(
self._component_name,
verify_attribute(root, 'command'),
verify_attribute(root, 'interval', cast=float),
self._system,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.HOLIDAY:
return self._ensure_new(PredicateHoliday(self._component_name,
self.zkclient,
path=self._holiday_path,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.WEEKEND:
return self._ensure_new(PredicateWeekend(self._component_name,
operational=operational,
parent=parent),
callback=callback)
elif ptype == PredicateType.TIMEWINDOW:
return self._ensure_new(TimeWindow(
self._component_name,
begin=verify_attribute(root, 'begin', none_allowed=True),
end=verify_attribute(root, 'end', none_allowed=True),
weekdays=verify_attribute(root, 'weekdays', none_allowed=True),
operational=operational,
parent=parent),
callback=callback)
# below, use recursion to get nested predicates
elif ptype == PredicateType.NOT:
for element in root.findall('Predicate'):
dep = self.create(element, callback=callback)
return self._ensure_new(
PredicateNot(self._component_name,
dep,
parent=self._parent_name(parent, 'not')))
elif ptype == PredicateType.AND:
deps = list()
for element in root.findall('Predicate'):
deps.append(
self.create(element,
callback=callback,
parent=self._parent_name(parent, 'and')))
return self._ensure_new(
PredicateAnd(self._component_name, deps, parent=parent))
elif ptype == PredicateType.OR:
deps = list()
for element in root.findall('Predicate'):
deps.append(
self.create(element,
callback=callback,
parent=self._parent_name(parent, 'or')))
return self._ensure_new(
PredicateOr(self._component_name, deps, parent=parent))
else:
self._log.error(
'Unknown predicate type "{0}". Ignoring'.format(ptype))
# create dummy if it is an unknown predicate type.
# met is set to true b/c we don't want to block on error
return create_dummy(comp=self._component_name,
parent=self._action,
met=True)
def test_no_match(self):
new = SimplePredicate("c", ThreadSafeObject({}))
ret = self.factory._ensure_new(new)
self.assertTrue(new is ret)
