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'))
