示例#1
0
 def _rewalk_tree(self, event=None):
     """
     Clear children list and rewalk the tree starting at self.node.
     If the node does not exist, set a watch.
     When the node is created the watch will trigger the recursive walk.
     :type event: kazoo.protocol.states.WatchedEvent or None
     """
     if self.zkclient.exists(self.node, watch=self._rewalk_tree):
         # setting a watch on grandparent node for additional children
         self.zkclient.get_children(self.node, watch=self._rewalk_tree)
         new_nodes = list()
         self._walk(self.node, new_nodes)
         self._update_children_list(new_nodes)
         map(lambda x: x.start(), self._children)
     else:
         # This is a placeholder for when the path the ZKHGC is given a path
         # that doesn't exist
         # met is False b/c if the path doesn't exist we don't want to succeed.
         self._children.append(
             create_dummy(comp=self._comp_name, parent=self._parent))
         self._log.warning('Node {0} does not exist. Will wait until it '
                           'does.'.format(self.node))
示例#2
0
    def _update_children_list(self, new_nodes):
        """
        Remove any dummy predicates from children.
        Using the list of paths found in the tree walk, if we have an object
        that matches that path, keep it, add new objects, delete any extras.

        :type new_nodes: list of str
        """
        # remove dummy predicates if they exist
        existing_objs = copy.copy(self._children)
        for child in existing_objs:
            if child == create_dummy(comp=self._comp_name, parent=self._parent):
                self._children.remove(child)

        # remove obsolete objects
        existing_nodes = [i.node for i in self._children]
        for n in existing_nodes:
            if n in set(existing_nodes) - set(new_nodes):
                self._log.debug('Removing obsolete node: {0}'.format(n))
                temp = ZookeeperHasChildren('', '', n)  # create a dummy
                self._children.remove(temp)

        # add new
        # This currently has a limitation that nodes created at a deeper level
        # are not picked up automatically. For example if the base node is /A,
        # static nodes at /A/B or /A/D WILL be picked up, but if /A/B/C is
        # added later it WILL NOT be picked up until the next restart
        for node in set(new_nodes) - set(existing_nodes):
            self._log.debug('Adding new node: {0}'.format(node))
            zk_child = ZookeeperHasChildren(self._comp_name,
                                            self.zkclient,
                                            node,
                                            operational=self._operational,
                                            met_on_delete=True,
                                            parent='zk.has.gc')
            zk_child.add_callback({"zk_hgc": self._callback})
            self._children.append(zk_child)
示例#3
0
    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)
示例#4
0
    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)