def test_resolve_adds_path(self):
ob = resolve_name('loads.tests.test_util.TestUtil')
self.assertTrue(ob is TestUtil)
self.assertTrue('' in sys.path)
old_len = len(sys.path)
# And checks that it's not added twice
ob = resolve_name('loads.tests.test_util.TestUtil')
self.assertEquals(len(sys.path), old_len)
def test_resolve_adds_path(self):
ob = resolve_name('loads.tests.test_util.TestUtil')
self.assertTrue(ob is TestUtil)
self.assertTrue('' in sys.path)
old_len = len(sys.path)
# And checks that it's not added twice
ob = resolve_name('loads.tests.test_util.TestUtil')
self.assertEquals(len(sys.path), old_len)
def test_resolve(self):
ob = resolve_name('loads.tests.test_util.TestUtil')
self.assertTrue(ob is TestUtil)
ob = resolve_name('loads')
self.assertTrue(ob is loads)
self.assertRaises(ImportError, resolve_name, 'xx.cc')
self.assertRaises(ImportError, resolve_name, 'xx')
self.assertRaises(ImportError, resolve_name, 'loads.xx')
def test_resolve(self):
ob = resolve_name('loads.tests.test_util.TestUtil')
self.assertTrue(ob is TestUtil)
ob = resolve_name('loads')
self.assertTrue(ob is loads)
self.assertRaises(ImportError, resolve_name, 'xx.cc')
self.assertRaises(ImportError, resolve_name, 'xx')
self.assertRaises(ImportError, resolve_name, 'loads.xx')
def __init__(self, args):
self.args = args
self.fqn = args['fqn']
self.test = resolve_name(self.fqn)
self.slave = 'slave' in args
self.outputs = []
self.stop = False
(self.total, self.cycles,
self.duration, self.users, self.agents) = _compute_arguments(args)
self.args['cycles'] = self.cycles
self.args['users'] = self.users
self.args['agents'] = self.agents
self.args['total'] = self.total
# If we are in slave mode, set the test_result to a 0mq relay
if self.slave:
self.test_result = ZMQRelay(self.args)
# The normal behavior is to collect the results locally.
else:
self.test_result = TestResult(args=self.args)
if not self.slave:
for output in self.args.get('output', ['stdout']):
self.register_output(output)
def __init__(self, args):
self.args = args
self.fqn = args.get('fqn')
self.test = None
self.slave = args.get('slave', False)
self.run_id = None
# Only resolve the name of the test if we're using the default python
# test-runner.
if args.get('test_runner') is None and self.fqn:
self.test = resolve_name(self.fqn)
else:
self.test = None
self.outputs = []
self.stop = False
(self.total, self.hits,
self.duration, self.users, self.agents) = _compute_arguments(args)
self.args['hits'] = self.hits
self.args['users'] = self.users
self.args['agents'] = self.agents
self.args['total'] = self.total
# If we are in slave mode, set the test_result to a 0mq relay
if self.slave:
self._test_result = ZMQRelay(self.args)
# The normal behavior is to collect the results locally.
else:
self._test_result = TestResult(args=self.args)
if not self.slave:
for output in self.args.get('output', ['stdout']):
self.register_output(output)
def run(fqn, concurrency=1, numruns=1):
""" Runs a test.
* fnq: fully qualified name
* concurrency: number of concurrent runs
* numruns: number of run per concurrent
"""
set_global_stream('stdout', total=concurrency * numruns)
test = resolve_name(fqn)
klass = test.im_class
ob = klass(test.__name__)
test_result = unittest.TestResult()
group = Group()
for i in range(concurrency):
group.spawn(_run, i, ob, test_result, numruns)
group.join()
return test_result
def __init__(self, args):
self.args = args
self.fqn = args.get('fqn')
self.test = None
self.slave = args.get('slave', False)
self.run_id = None
# Only resolve the name of the test if we're using the default python
# test-runner.
if args.get('test_runner') is None and self.fqn:
self.test = resolve_name(self.fqn)
else:
self.test = None
self.outputs = []
self.stop = False
(self.total, self.hits, self.duration, self.users,
self.agents) = _compute_arguments(args)
self.args['hits'] = self.hits
self.args['users'] = self.users
self.args['agents'] = self.agents
self.args['total'] = self.total
# If we are in slave mode, set the test_result to a 0mq relay
if self.slave:
self._test_result = ZMQTestResult(self.args)
# The normal behavior is to collect the results locally.
else:
self._test_result = TestResult(args=self.args)
if not self.slave:
for output in self.args.get('output', ['stdout']):
self.register_output(output)
def main(args=sys.argv):
parser = argparse.ArgumentParser(description='Run some watchers.')
parser.add_argument('--backend', dest='backend',
default=DEFAULT_BACKEND,
help="ZMQ socket to the broker.")
parser.add_argument('--register', dest='register',
default=DEFAULT_REG,
help="ZMQ socket for the registration.")
parser.add_argument('target', help="Fully qualified name of the callable.")
parser.add_argument('--debug', action='store_true', default=False,
help="Debug mode")
parser.add_argument('--logfile', dest='logfile', default='stdout',
help="File to log in to.")
parser.add_argument('--heartbeat', dest='heartbeat',
default=DEFAULT_HEARTBEAT,
help="ZMQ socket for the heartbeat.")
parser.add_argument('--params', dest='params', default=None,
help='The parameters to be used in the worker.')
parser.add_argument('--timeout', dest='timeout', type=float,
default=DEFAULT_TIMEOUT_MOVF,
help=('The maximum time allowed before the thread '
'stacks is dump and the message result not sent '
'back.'))
parser.add_argument('--max-age', dest='max_age', type=float,
default=DEFAULT_MAX_AGE,
help=('The maximum age for a worker in seconds. '
'After that delay, the worker will simply quit. '
'When set to -1, never quits.'))
parser.add_argument('--max-age-delta', dest='max_age_delta', type=int,
default=DEFAULT_MAX_AGE_DELTA,
help='The maximum value in seconds added to max_age')
args = parser.parse_args()
set_logger(args.debug, logfile=args.logfile)
sys.path.insert(0, os.getcwd()) # XXX
target = resolve_name(args.target)
if args.params is None:
params = {}
else:
params = decode_params(args.params)
logger.info('Worker registers at %s' % args.backend)
logger.info('The heartbeat socket is at %r' % args.heartbeat)
worker = Worker(target, backend=args.backend, heartbeat=args.heartbeat,
register=args.register,
params=params, timeout=args.timeout, max_age=args.max_age,
max_age_delta=args.max_age_delta)
try:
worker.start()
except KeyboardInterrupt:
return 1
finally:
worker.stop()
return 0
def _resolve_name(self):
if self.fqn is not None:
self.test = resolve_name(self.fqn)
def _resolve_name(self):
if self.fqn is not None:
self.test = resolve_name(self.fqn)
def _resolver(name):
try:
return resolve_name('loads.observers.%s' % name)
except ImportError:
return resolve_name(name)
