class Discoveryrun(Item): id = 1 #0 is always special in database, so we do not take risk here my_type = 'discoveryrun' properties = { 'discoveryrun_name': StringProp(), 'discoveryrun_command': StringProp(), } running_properties = { 'current_launch': StringProp(default=None), 'configuration_errors': ListProp(default=[]), } macros = {} # Output name def get_name(self): return self.discoveryrun_name # Get an eventhandler object and launch it def launch(self): m = MacroResolver() data = [] cmd = m.resolve_command(self.discoveryrun_command, data) self.current_launch = EventHandler(cmd, timeout=300) self.current_launch.execute() def check_finished(self): max_output = 10**9 #print "Max output", max_output self.current_launch.check_finished(max_output) # Look if the current launch is done or not def is_finished(self): if self.current_launch == None: return True if self.current_launch.status in ('done', 'timeout'): return True return False # we use an EventHandler object, so we have output with a single line # and longoutput with the rest. We just need to return all def get_output(self): return '\n'.join( [self.current_launch.output, self.current_launch.long_output])
class Discoveryrun(Item): id = 1 #0 is always special in database, so we do not take risk here my_type = 'discoveryrun' properties = { 'discoveryrun_name': StringProp (), 'discoveryrun_command': StringProp (), } running_properties = { 'current_launch': StringProp(default=None), 'configuration_errors': ListProp(default=[]), } macros = {} # Output name def get_name(self): return self.discoveryrun_name # Get an eventhandler object and launch it def launch(self): m = MacroResolver() data = [] cmd = m.resolve_command(self.discoveryrun_command, data) self.current_launch = EventHandler(cmd, timeout=300) self.current_launch.execute() def check_finished(self): max_output = 10**9 #print "Max output", max_output self.current_launch.check_finished(max_output) # Look if the current launch is done or not def is_finished(self): if self.current_launch == None: return True if self.current_launch.status in ('done', 'timeout'): return True return False # we use an EventHandler object, so we have output with a single line # and longoutput with the rest. We just need to return all def get_output(self): return '\n'.join([self.current_launch.output, self.current_launch.long_output])
class Discoveryrun(MatchingItem): id = 1 # zero is always special in database, so we do not take risk here my_type = 'discoveryrun' properties = Item.properties.copy() properties.update({ 'discoveryrun_name': StringProp(), 'discoveryrun_command': StringProp(), }) running_properties = Item.running_properties.copy() running_properties.update({ 'current_launch': StringProp(default=None), }) # The init of a discovery will set the property of # Discoveryrun.properties as in setattr, but all others # will be in a list because we need to have all names # and not lost all in __dict__ def __init__(self, params={}): cls = self.__class__ # We have our own id of My Class type :) # use set attr for going into the slots # instead of __dict__ :) setattr(self, 'id', cls.id) cls.id += 1 self.matches = {} # for matching rules self.not_matches = {} # for rules that should NOT match # In my own property: # -> in __dict__ # if not, in matches or not match (if key starts # with a !, it's a not rule) # -> in self.matches or self.not_matches # in writing properties if start with + (means 'add this') for key in params: if key in cls.properties: setattr(self, key, params[key]) else: if key.startswith('!'): key = key.split('!')[1] self.not_matches[key] = params['!'+key] else: self.matches[key] = params[key] # Then running prop :) cls = self.__class__ # adding running properties like latency, dependency list, etc for prop, entry in cls.running_properties.items(): # Copy is slow, so we check type # Type with __iter__ are list or dict, or tuple. # Item need it's own list, so qe copy val = entry.default if hasattr(val, '__iter__'): setattr(self, prop, copy(val)) else: setattr(self, prop, val) # each instance to have his own running prop! # Output name def get_name(self): try: return self.discoveryrun_name except AttributeError: return "UnnamedDiscoveryRun" # A Run that is first level means that it do not have # any matching filter def is_first_level(self): return len(self.not_matches) + len(self.matches) == 0 # Get an eventhandler object and launch it def launch(self, ctx=[], timeout=300): m = MacroResolver() cmd = m.resolve_command(self.discoveryrun_command, ctx) self.current_launch = EventHandler(cmd, timeout=timeout) self.current_launch.execute() def check_finished(self): max_output = 10 ** 9 #print "Max output", max_output self.current_launch.check_finished(max_output) # Look if the current launch is done or not def is_finished(self): if self.current_launch == None: return True if self.current_launch.status in ('done', 'timeout'): return True return False # we use an EventHandler object, so we have output with a single line # and longoutput with the rest. We just need to return all def get_output(self): return '\n'.join([self.current_launch.output, self.current_launch.long_output])
class Discoveryrun(MatchingItem): id = 1 # zero is always special in database, so we do not take risk here my_type = 'discoveryrun' properties = Item.properties.copy() properties.update({ 'discoveryrun_name': StringProp(), 'discoveryrun_command': StringProp(), }) running_properties = Item.running_properties.copy() running_properties.update({ 'current_launch': StringProp(default=None), }) # The init of a discovery will set the property of # Discoveryrun.properties as in setattr, but all others # will be in a list because we need to have all names # and not lost all in __dict__ def __init__(self, params={}): cls = self.__class__ # We have our own id of My Class type :) # use set attr for going into the slots # instead of __dict__ :) setattr(self, 'id', cls.id) cls.id += 1 self.matches = {} # for matching rules self.not_matches = {} # for rules that should NOT match # In my own property: # -> in __dict__ # if not, in matches or not match (if key starts # with a !, it's a not rule) # -> in self.matches or self.not_matches # in writing properties if start with + (means 'add this') for key in params: # delistify attributes if there is only one value params[key] = self.compact_unique_attr_value(params[key]) if key in cls.properties: setattr(self, key, params[key]) else: if key.startswith('!'): key = key.split('!')[1] self.not_matches[key] = params['!' + key] else: self.matches[key] = params[key] # Then running prop :) cls = self.__class__ # adding running properties like latency, dependency list, etc for prop, entry in cls.running_properties.items(): # Copy is slow, so we check type # Type with __iter__ are list or dict, or tuple. # Item need it's own list, so qe copy val = entry.default if hasattr(val, '__iter__'): setattr(self, prop, copy(val)) else: setattr(self, prop, val) # each instance to have his own running prop! # Output name def get_name(self): try: return self.discoveryrun_name except AttributeError: return "UnnamedDiscoveryRun" # A Run that is first level means that it do not have # any matching filter def is_first_level(self): return len(self.not_matches) + len(self.matches) == 0 # Get an eventhandler object and launch it def launch(self, ctx=[], timeout=300): m = MacroResolver() cmd = m.resolve_command(self.discoveryrun_command, ctx) self.current_launch = EventHandler(cmd, timeout=timeout) self.current_launch.execute() def check_finished(self): max_output = 10**9 #print "Max output", max_output self.current_launch.check_finished(max_output) # Look if the current launch is done or not def is_finished(self): if self.current_launch == None: return True if self.current_launch.status in ('done', 'timeout'): return True return False # we use an EventHandler object, so we have output with a single line # and longoutput with the rest. We just need to return all def get_output(self): return '\n'.join( [self.current_launch.output, self.current_launch.long_output])