def _parse_entry(self, line): m = re_entry.match(line) if m: log.debug("key-value '%s'='%s' added to section %s" % (m.group(1), m.group(2), self._name)) self._current_section[m.group(1)] = m.group(2) return m is not None
def _match(self, x, visited): def compare(a, b): if self.conflict_cache.has_key(a): # use the cache if possible for cache in self.conflict_cache[a]: if cache == b: return True if a == b: return True else: common = Levenshtein.ratio(a, b) comparison = common > 0.7 if comparison: # cache the match if self.conflict_cache.has_key(a): self.conflict_cache[a].append(b) else: self.conflict_cache[a] = [b] for v in visited: if len(v.path) == len(x.path) and v.event == x.event: if all((compare(a, b) for a, b in zip(x.path, v.path))): log.debug('resolving %s as %s' % (x, v)) return v
def _parse_section(self, line): m = re_section.match(line) if m: self._push_changes() self._name = m.group(1) log.debug('parsing section %s' % self._name) return m is not None
def main(monitors, cfg): # ant_glob for testcases testpattern = cfg.get('replayer', 'testcase') testcases = util.ant_glob(testpattern) log.info('collected %d test cases' % len(testcases)) log.debug(`testcases`) assert len(monitors) > 0, 'No monitors available' # Load oracles oracles = [] oracle_names = cfg.get('replayer', 'oracles') if len(oracle_names.strip()) != 0: for pkg, class_ in (s.strip().rsplit('.', 1) for s in oracle_names.split(',')): try: oracle = getattr(__import__(pkg,fromlist=[class_]), class_)() oracle.add_options(cfg) oracles.append(oracle) log.info('loaded oracle %r' % oracle) except (ImportError, AttributeError): log.warn('could not load oracle %s.%s' % (pkg, class_)) lock = threading.Lock() steptime = float(cfg.get('general', 'steptime')) out_dir = cfg.get('replayer', 'state_dir') if not os.path.exists(out_dir): log.debug('creating folder %s' % os.path.abspath(out_dir)) os.makedirs(out_dir) results = Results() replayers = [ Replayer(monitor = m, config = cfg, oracles = oracles, testcases = testcases, lock = lock, steptime = steptime, out_dir = out_dir, results = results) for m in monitors ] for replayer in replayers: replayer.start() while any(( replayer.is_alive() for replayer in replayers )): time.sleep(steptime) results_file = cfg.get('replayer', 'results') with open(results_file, 'w') as f: f.write( results.xmlreport().toprettyxml(indent = ' ') ) return 0 if not interrupt else 1
def disconnect(self, current = None): """ Kills the application. First calls the proxy version (so it can do any desired clean up) then it sends sigkill in case the process didn't clean itself up properly. @note: Due to the nature of this call, the process that kills itself <b>must</b> return from the disconnect function call. The proxy to this process becomes invalid after this call. """ if self.alive(): self._impl.disconnect() #os.kill(self.pid, signal.sigkill) #os.wait() process = subprocess.Popen('kill -9 '+ str(self.pid), stderr=subprocess.PIPE, shell=True) # destroy all components connected to this process for identity in self._connections: current.adapter.remove(identity) # Remove this object from the Ice runtime current.adapter.remove(current.id) # run a post script (if one exists) if self._post_command: cmd = shlex.split(self._post_command) log.debug('running post command %r' % cmd) process = subprocess.Popen(cmd, stdout = subprocess.PIPE, stderr = subprocess.PIPE) log.debug('return code: %d' % process.wait()) stdout, stderr = process.communicate() log.debug('stdout: %s' % stdout) log.debug('stderr: %s' % stderr)
def connect(self, cfg, current = None): # pre-run script if cfg.has_key('pre_command'): cmd = shlex.split(cfg['pre_command']) log.debug('running pre command %r' % cmd) process = subprocess.Popen(cmd, stdout = subprocess.PIPE, stderr = subprocess.PIPE) log.debug('return code: %d' % process.wait()) stdout, stderr = process.communicate() log.debug('stdout: %s' % stdout) log.debug('stderr: %s' % stderr) with self._lock: port = self._pids.pop(0) cmd, env = self._connect_impl(cfg, port) env.update(os.environ) log.info('launching command %r' % cmd) process = subprocess.Popen(cmd, env = env) log.info('starting process %d at port %d' % (process.pid, port)) with self._lock: self._active.append((port, process)) post_command = None if cfg.has_key('post_command'): post_command = cfg['post_command'] process = ProcessI(self._adapter, process, port, post_command) return guitarlib.ProcessPrx.uncheckedCast( self._adapter.addWithUUID(process))
def load(stream_list = None): """ Loads the specified files/streams into a new config parser with all the default values. The list of files can be files, streams, or strings. If a file or stream, they will be read directly. If a string, then it will be loaded as a file first and then processed. If the type of files is not an iterable type or is a string, then only the single file/stream will be loaded. @type stream_list: C{list}, C{str}, or C{file} @returns: The L{guitarlib.config.ConfigParser} gotten from loading the given streams. @rtype: L{guitarlib.config.ConfigParser} """ defaults = { 'general' : { 'gui_file' : 'gui_file.pckl', 'efg_file' : 'efg_file.pckl', 'hosts' : 'localhost', 'steptime' : '2', 'configuration' : 'configuration.yml' }, 'structure' : { 'graph' : 'False', 'image_file' : 'structure.png' }, 'testgenerator' : { 'format' : 'pckl', 'folder' : 'TC', 'plugin' : 'guitarlib.generator.SequenceLength', 'max' : 'infinity' }, 'replayer' : { 'testcase' : 'TC/**', 'state_dir' : 'state_files', 'oracles' : '', 'results' : 'replayer-results.xml' }, 'hosts' : { 'localhost' : 'default -p 10000 -h localhost' } } parser = ConfigParser(defaults) # None value defaults to 'guitar.cfg' if stream_list is None: stream_list = ('guitar.cfg',) # Determine if this is a single file if isinstance(stream_list, (str, file)): stream_list = (stream_list,) for stream in stream_list: if isinstance(stream, str) and os.path.exists(stream): log.debug('parsing %s for config values' % stream) with guitarlib.util.open(stream) as f: parser.load(f) elif not isinstance(stream, str): log.debug('parsing stream %r for config values' % stream) parser.load(stream) else: log.debug('no such file: %s' % stream) return parser
return 1 testgenerator.add_options(cfg) max = float(cfg.get('testgenerator', 'max')) progress = util.ProgressBar(max) counter = util.counter(max, progress.update) start_nodes = [x for x in gr if 'start_node' in gr.node_attributes(x)] tests = testgenerator.generate(gr, start_nodes, cfg, counter) # Write each one of these tests to a separate test file print 'writing test files to disk' progress = util.ProgressBar(len(tests)) output_dir = cfg.get('testgenerator', 'folder') if not os.path.exists(output_dir): log.debug('creating folder %s' % os.path.abspath(output_dir)) os.makedirs(output_dir) format = cfg.get('testgenerator', 'format') for i, t in enumerate(tests): name = 't_%s.%s' % ('_'.join(['e%u' % hash(m) for m in t]), format) file_ = os.path.join(output_dir, name) progress.update(i+1) log.debug('writing test case %s' % file_) parser.dump(t, file_) print log.info('%d test cases total' % len(tests)) return 0 if __name__ == '__main__':
# Convert all available hosts to proxies def proxy(name): """Tries to convert a host into a proxy""" try: return guitarlib.ApplicationPrx.checkedCast( self.communicator().stringToProxy( 'Application:%s' % potential_hosts[name])) except Exception, e: log.warn('monitor %s is invalid' % name) log.exception(e) return None server = {} if cfg.has_option('general', 'server'): section = cfg.get('general', 'server') log.debug('loading server configuration from section %s' % section) server = cfg.get_section(section) retrieveProxy = lambda name, prx: Monitor(prx, server, name) valid = lambda name: potential_hosts.has_key(name) # Filter out all invalid host names and find their proxies monitors = [(name, proxy(name)) for name in requested_hosts if valid(name)] # Filter out invalid proxies and create the monitors for valid ones monitors = [Monitor(prx, server, name) for name, prx in monitors if prx] if len(monitors) == 0: raise Exception('no monitors available') log.info('%d machine(s) available' % len(monitors))