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_state(monitor, efg_file): cache_file = '%s.cache' % efg_file if os.path.exists(cache_file): try: # reload cache file log.info('loading cache file from %s' % cache_file) return parser.load(cache_file) except Exception, e: log.exception(e)
def run(self): try: while True: interrupt_point() with self._lock: testfile = self._testcases.pop() left = len(self._testcases) log.info('running %s on monitor %s (%d left)' % (testfile, self._monitor.name, left)) test = parser.load(testfile) name = os.path.split(testfile)[1] logfile = os.path.join( self._out_dir, os.path.splitext(name)[0]) + '.log' stdout = StringIO.StringIO() with self._monitor.open(logfile, stdout): interrupt_point() # Perform each action in the test try: for event in test: event.perform(self._monitor) time.sleep(self._steptime) interrupt_point() # Take final snapshot of the state and save it snapshot = self._monitor.take_snapshot() parser.dump(snapshot, os.path.join( self._out_dir, name)) except Exception, e: log.exception(e) self._results.error( testfile, message = str(e), stdout = stdout.getvalue()) else: # Validate with oracles for oracle in self._oracles: reason = oracle.validate( self._monitor, snapshot, testfile, test) if reason: log.error('test %s failed (oracle %s)' % (testfile, type(oracle))) self._results.failure( testfile, message = '%s\nreason: %s' % (type(oracle), reason), stdout = stdout.getvalue()) break else: self._results.success( testfile, stdout = stdout.getvalue())
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 main(argv = None): cfg = guitarlib.initialize(argv) # Load in the efg file efg_file = cfg.get('general', 'efg_file') log.info('loading efg file %s' % efg_file) gr = parser.load(efg_file) try: pkg, class_ = cfg.get('testgenerator', 'plugin').rsplit('.', 1) testgenerator = getattr(__import__(pkg, fromlist=[class_]), class_)() except (ImportError, AttributeError), e: log.exception(e) return 1
def run(self): while True: reap = set() for port, process in self._active: if process.poll() is not None: # Reap the child log.info('reaping process %d at port %d' % (process.pid, port)) retcode = process.wait() log.info('return code of process %d is %d' % (process.pid, retcode)) reap.add(process) with self._lock: self._pids.append(port) # Reap the processes from the list with self._lock: self._active = filter(lambda x: x[1] not in reap, self._active) time.sleep(1)
def run(self): self._cache_backup = '%s.%d.cache' % \ (os.path.splitext(cache_file)[0], self.ident) try: while True: #self.save_cache(state) if interrupt: self._monitor.log.critical( '%s interrupted' % self._monitor.name) break with lock: events = state.queue.pop(0) self._monitor.log.info( 'performing event %s (previous %r) (%d left)' % (events[-1], [str(e) for e in events[:-1]], len(state.queue))) if not ignored(events[-1], ignored_patterns): try: pict = performEvent(self._monitor, events) events[-1].terminal = not pict.alive except GException, ex: self._monitor.log.exception(ex) with lock: state.failures.append(events) else: # Add new events to the queue to be performed diff, all = [], [] for e in state.resolve_conflicts(pict.events,lock): try: with lock: if e not in state.visited: state.efg.add_node(e) state.queue.append(events + [e]) diff.append(e) all.append(e) except AdditionError: self._monitor.log.debug('duplicate event %s' % e) with lock: state.visited.update(diff) # Connect edges for this event for e in state.determine_mappings(all): try: state.efg.add_edge((events[-1], e)) except AdditionError: pass # log/fix it so it never happens else: self._monitor.log.debug( 'skipping event on component %s (ignored)' \ % events[-1].path) with lock: state.skipped.append(events) except IndexError: # No more events to consume log.info('%s thread finished' % self._monitor.name) except Exception, e: self._monitor.log.exception(e) # interrupt other tasks interrupt_ripper()
else: # new event yield e def load_state(monitor, efg_file): cache_file = '%s.cache' % efg_file if os.path.exists(cache_file): try: # reload cache file log.info('loading cache file from %s' % cache_file) return parser.load(cache_file) except Exception, e: log.exception(e) # initial snapshot log.info('taking initial snapshot') with monitor: initial = monitor.take_snapshot() return global_state(digraph(), initial) @requires_monitor(interrupt_ripper) def main(monitors, cfg): efg_file = cfg.get('general', 'efg_file') state, lock = load_state(monitors[0], efg_file), threading.Lock() config_loc = cfg.get('general', 'configuration') ignored_patterns = [] try: ignored_patterns = parser.load(config_loc) except Exception, e:
reason = oracle.validate( self._monitor, snapshot, testfile, test) if reason: log.error('test %s failed (oracle %s)' % (testfile, type(oracle))) self._results.failure( testfile, message = '%s\nreason: %s' % (type(oracle), reason), stdout = stdout.getvalue()) break else: self._results.success( testfile, stdout = stdout.getvalue()) except IndexError: # No more test cases log.info('monitor %s finished' % self._monitor.name) except KeyboardInterrupt: log.critical('%s interrupted' % self._monitor.name) class Results(object): SUCCESS, FAILURE, ERROR = 'success', 'failure', 'error' def __init__(self): self._doc = xml.dom.minidom.Document() self._lock = threading.Lock() self._testsuite = self._doc.createElement('testsuite') def result(self, level, testcase, message = '', stdout = ''): result = self._doc.createElement('testcase') result.attributes['classname'] = 'guitarlib' result.attributes['name'] = testcase
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__': sys.exit(main(sys.argv))
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)) for m in monitors: m.log.info('%s: %s' % (m.name, m.proxy.osVersion())) return self._action(monitors, cfg) class Monitor(object): """Monitors an application on a remote machine""" def __init__(self, app, cfg, name = None): self._app = app self._process = None self._name = name if self._name is None: self._name = self._app.osVersion() self._cfg = cfg self._delay = float(cfg.get('delay', '5'))