Source Code for Module concurrent_tree_crawler.navigator_tree_wrapper

  1  import logging 
  2  import threading 
  3   
  4  from concurrent_tree_crawler.abstract_tree_navigator import NavigationException 
  5   
  6 -class NavigatorTreeWrapper: 
  7          """ 
  8          Wrapper for the tree navigator (L{AbstractTreeNavigator}). 
  9          It makes sure that accessing our tree representation 
 10          object L{TreeAccessor} is synchronized with actions executed on 
 11          L{AbstractTreeNavigator} object. It also handles L{NavigationException}s 
 12          that might occur while using the navigator. 
 13          """ 
 14           
 15 -        def __init__(self, navigator, tree): 
 16                  """ 
 17                  @type navigator: L{AbstractTreeNavigator} 
 18                  @type tree: L{AbstractTreeAccessor} 
 19                  """ 
 20                  self.__nav = navigator 
 21                  self.__tree = tree 
 22                  self.__current_node = None 
 23   
 24 -        def get_current_node(self): 
 25                  return self.__current_node 
 26   
 27 -        def start_in_sentinel(self): 
 28                  self.__current_node = self.__tree.get_sentinel() 
 29                  self.__log("Started in sentinel") 
 30           
 31 -        def get_possible_children(self): 
 32                  """ 
 33                  @return: children names 
 34                  @rtype: list of strings 
 35                  """ 
 36                  ret = None 
 37                  if self.__current_node == self.__tree.get_sentinel(): 
 38                          ret = ["root"] 
 39                  else: 
 40                          try: 
 41                                  ret = self.__nav.get_children() 
 42                          except NavigationException as ex: 
 43                                  self.__handle_exception(ex, "Getting children failed") 
 44                  self.__log("Got possible children") 
 45                  return ret 
 46           
 47 -        def move_to_child(self, destination_node): 
 48                  """ 
 49                  @param destination_node: L{AbstractNode} 
 50                  """ 
 51                  if self.__current_node == self.__tree.get_sentinel(): 
 52                          self.__start_in_root() 
 53                  else: 
 54                          try: 
 55                                  self.__current_node = destination_node 
 56                                  self.__nav.move_to_child(destination_node.get_name()) 
 57                          except NavigationException as ex: 
 58                                  self.__handle_exception(ex, "Moving to child failed") 
 59                  self.__log("Moved to child") 
 60   
 61 -        def __start_in_root(self): 
 62                  try: 
 63                          self.__current_node = self.__tree.get_root() 
 64                          self.__nav.start_in_root() 
 65                  except NavigationException as ex: 
 66                          self.__handle_exception(ex,  
 67                                  "Initializing navigator to start in the root failed") 
 68   
 69 -        def move_to_parent(self): 
 70                  """ 
 71                  @return: C{True} iff the navigator is currently in the root. It means 
 72                          that the whole tree has been traversed. 
 73                  """ 
 74                  ret = None 
 75                  ## The first part of this condition is true, when the root is CLOSEd 
 76                  ## and a new thread starting from sentinel is coming 
 77                  if self.__current_node.get_parent() is None or \ 
 78                          self.__current_node.get_parent() == self.__tree.get_sentinel(): 
 79                          ## The sentinel node should never be visited by the  
 80                          ## L{AbstractTreeNavigator} 
 81                          self.__current_node = self.__tree.get_sentinel() 
 82                          ret = True 
 83                  else: 
 84                          try: 
 85                                  self.__current_node = self.__current_node.get_parent() 
 86                                  self.__nav.move_to_parent() 
 87                                  ret = False 
 88                          except NavigationException as ex: 
 89                                  self.__handle_exception(ex, "Moving to parent failed") 
 90                  self.__log("Moved to parent") 
 91                  return ret 
 92   
 93 -        def process_node_and_check_if_is_leaf(self): 
 94                  """ 
 95                  @return: C{True} if the current node is a leaf, C{False} if it is  
 96                          an internal node.  
 97                  """ 
 98                  assert self.__current_node != self.__tree.get_sentinel() 
 99                  try: 
100                          ret =  self.__nav.process_node_and_check_if_is_leaf() 
101                          self.__log("Processed node, is_leaf={}".format(ret)) 
102                          return ret 
103                  except NavigationException as ex: 
104                          self.__handle_exception(ex, "Processing node failed") 
105   
106 -        def __handle_exception(self, ex, error_message): 
107                  self.__log_exception(error_message, ex, self.__current_node) 
108                  self.__tree.set_error(self.__current_node) 
109                  raise ex                 
110   
111 -        def __log_exception(self, error_message, ex, error_node): 
112                  """ 
113                  @type error_message: string 
114                  @type ex: L{Exception} 
115                  @type error_node: L{AbstractNode} 
116                  """ 
117                  path_str = "/"+("/".join(self.__tree.get_path(error_node))) 
118                  logging.warning("thread==\"{}\", navigation exception in node \"{}\":" 
119                          "{}\". Detailed message: \"{}\".".format( 
120                                  threading.current_thread().name, path_str, error_message, ex)) 
121           
122 -        def __log(self, message): 
123                  """ 
124                  @type message: string 
125                  """ 
126                  path_str = "/"+("/".join(self.__tree.get_path(self.get_current_node()))) 
127                  logging.debug("thread=\"{}\", node=\"{}\": {}".format( 
128                          threading.current_thread().name, path_str, message)) 
129