def _initialize_logger(self):
"""
initializes the logger
"""
# This makes sure default formatters get loaded. Otherwise exc_info is
# not processed correctly
logging.basicConfig()
root_logger = logging.getLogger('')
root_logger.setLevel(logging.DEBUG)
config_file = server_config_filename()
try:
config = configobj.ConfigObj(config_file).get("ots.server")
log_dir = config.get('log_dir', LOG_DIR)
# File handler for maintainers/developers
log_id_string = _generate_log_id_string(self._request_id,
self.testrun_uuid)
l_format = '%(asctime)s %(module)-12s %(levelname)-8s %(message)s'
os.system("mkdir -p %s" % log_dir)
log_file = os.path.join(log_dir, log_id_string)
self._filehandler = logging.FileHandler(log_file)
self._filehandler.setLevel(logging.DEBUG)
self._filehandler.setFormatter(logging.Formatter(l_format))
root_logger.addHandler(self._filehandler)
except IOError:
root_logger.error("IOError, no permission to write %s?" % log_dir,
exc_info=True)
except:
root_logger.error("Unexpected error while creating testrun log",
exc_info=True)
def _initialize_logger(self):
"""
initializes the logger
"""
# This makes sure default formatters get loaded. Otherwise exc_info is
# not processed correctly
logging.basicConfig()
root_logger = logging.getLogger('')
root_logger.setLevel(logging.DEBUG)
config_file = server_config_filename()
try:
config = configobj.ConfigObj(config_file).get("ots.server")
log_dir = config.get('log_dir', LOG_DIR)
# File handler for maintainers/developers
log_id_string = _generate_log_id_string(self._request_id,
self.testrun_uuid)
l_format = '%(asctime)s %(module)-12s %(levelname)-8s %(message)s'
os.system("mkdir -p %s" % log_dir)
log_file = os.path.join(log_dir, log_id_string)
self._filehandler = logging.FileHandler(log_file)
self._filehandler.setLevel(logging.DEBUG)
self._filehandler.setFormatter(logging.Formatter(l_format))
root_logger.addHandler(self._filehandler)
except IOError:
root_logger.error("IOError, no permission to write %s?" % log_dir,
exc_info=True)
except:
root_logger.error("Unexpected error while creating testrun log",
exc_info=True)
def _config():
"""
@rtype: C{tuple} of C{str} and C{int}
@return: hostname, port
"""
config_file = server_config_filename()
config = configobj.ConfigObj(config_file).get("ots.server.xmlrpc")
return config.get('host'), config.as_int('port')
def _config():
"""
@rtype: C{tuple} of C{str} and C{int}
@return: hostname, port
"""
config_file = server_config_filename()
config = configobj.ConfigObj(config_file).get("ots.server.xmlrpc")
return config.get('host'), config.as_int('port')
def test_two_tasks_one_worker(self):
if not DEBUG:
self.worker_processes.start()
self.testrun_id = 111
taskrunner = taskrunner_factory(routing_key=ROUTING_KEY,
execution_timeout=10,
testrun_id=self.testrun_id,
config_file=server_config_filename())
#
zipfile_1_name = os.path.join(TESTS_MODULE_DIRNAME, "data",
"test_definition_1.xml")
steps = ["mkdir foo"]
self._create_zip_test_definition_file(zipfile_1_name, steps)
command_1 = [
"ots_mock",
'"%s"' % (zipfile_1_name),
"%s" % self.testrun_id
]
taskrunner.add_task(command_1)
#
zipfile_2_name = os.path.join(TESTS_MODULE_DIRNAME, "data",
"test_definition_2.xml")
steps = ["mkdir bar"]
self._create_zip_test_definition_file(zipfile_2_name, steps)
command_2 = [
"ots_mock",
'"%s"' % (zipfile_2_name),
"%s" % self.testrun_id
]
taskrunner.add_task(command_2)
#
command_quit = ["quit"]
taskrunner.add_task(command_quit)
time_before_run = time.time()
time.sleep(1)
taskrunner.run()
time.sleep(1)
time_after_run = time.time()
if not DEBUG:
foo = os.path.join(EXECUTION_DIRNAME, "foo")
foo_time = os.path.getctime(foo)
bar = os.path.join(EXECUTION_DIRNAME, "bar")
bar_time = os.path.getctime(bar)
self.assertTrue(time_before_run < foo_time)
self.assertTrue(foo_time <= bar_time)
self.assertTrue(bar_time <= time_after_run)
#
self.assertFalse(all(self.worker_processes.exitcodes))
def _storage_address():
"""
rtype: C{str}
rparam: The storage address
"""
conf = server_config_filename()
config = configobj.ConfigObj(conf).get('ots.server.allocator')
storage_host = config['storage_host']
if not storage_host:
storage_host = gethostname()
# TODO: DEPRECATED REMOVE AFTER CONDUCTOR IS CHANGED
storage_port = "1982"
return "%s:%s" % (storage_host, storage_port)
def _default_options_dict(sw_product):
"""
@type sw_product: C{str}
@param sw_product: The name of the software product
@rtype: C{dict} or None
@return: The dictionary of options
Get the default options for the SW product
"""
conf = server_config_filename()
config = configobj.ConfigObj(conf).get('swproducts').get(sw_product)
if not config:
pdts = configobj.ConfigObj(conf).get('swproducts').keys()
msg = "'%s' not found in sw products: %s" % (sw_product, pdts)
raise ValueError(msg)
return config
def test_two_tasks_one_worker(self):
if not DEBUG:
self.worker_processes.start()
self.testrun_id = 111
taskrunner = taskrunner_factory(
routing_key=ROUTING_KEY,
execution_timeout=10,
testrun_id=self.testrun_id,
config_file=server_config_filename(),
)
#
zipfile_1_name = os.path.join(TESTS_MODULE_DIRNAME, "data", "test_definition_1.xml")
steps = ["mkdir foo"]
self._create_zip_test_definition_file(zipfile_1_name, steps)
command_1 = ["ots_mock", '"%s"' % (zipfile_1_name), "%s" % self.testrun_id]
taskrunner.add_task(command_1)
#
zipfile_2_name = os.path.join(TESTS_MODULE_DIRNAME, "data", "test_definition_2.xml")
steps = ["mkdir bar"]
self._create_zip_test_definition_file(zipfile_2_name, steps)
command_2 = ["ots_mock", '"%s"' % (zipfile_2_name), "%s" % self.testrun_id]
taskrunner.add_task(command_2)
#
command_quit = ["quit"]
taskrunner.add_task(command_quit)
time_before_run = time.time()
time.sleep(1)
taskrunner.run()
time.sleep(1)
time_after_run = time.time()
if not DEBUG:
foo = os.path.join(EXECUTION_DIRNAME, "foo")
foo_time = os.path.getctime(foo)
bar = os.path.join(EXECUTION_DIRNAME, "bar")
bar_time = os.path.getctime(bar)
self.assertTrue(time_before_run < foo_time)
self.assertTrue(foo_time <= bar_time)
self.assertTrue(bar_time <= time_after_run)
#
self.assertFalse(all(self.worker_processes.exitcodes))
def taskrunner_factory(routing_key,
execution_timeout,
testrun_id,
config_file=None):
"""
Instantiate a Taskrunner from the config file
@type routing_key : C{str}
@param routing_key : The routing_key for the Task
@type execution_timeout: C{int}
@param execution_timeout: The timeout for the remote commands
@type testrun_id: C{int}
@param testrun_id: The Testrun id
@type config_file: C{str}
@param config_file: The fqname of the config file
@rtype: L{TaskRunner}
@return: The TaskRunner
"""
if not config_file:
config_file = server_config_filename()
config = configobj.ConfigObj(config_file).get("ots.server.distributor")
taskrunner = TaskRunner(username = config["username"],
password = config["password"],
host = config["host"],
vhost = config["vhost"],
services_exchange = routing_key,
port = config.as_int("port"),
routing_key = routing_key,
testrun_id = testrun_id,
execution_timeout = execution_timeout,
queue_timeout = config.as_int("timeout_task_start"),
controller_timeout = \
config.as_int("timeout_for_preparation"))
return taskrunner
def taskrunner_factory(routing_key,
execution_timeout,
testrun_id,
config_file=None):
"""
Instantiate a Taskrunner from the config file
@type routing_key : C{str}
@param routing_key : The routing_key for the Task
@type execution_timeout: C{int}
@param execution_timeout: The timeout for the remote commands
@type testrun_id: C{int}
@param testrun_id: The Testrun id
@type config_file: C{str}
@param config_file: The fqname of the config file
@rtype: L{TaskRunner}
@return: The TaskRunner
"""
if not config_file:
config_file = server_config_filename()
config = configobj.ConfigObj(config_file).get("ots.server.distributor")
taskrunner = TaskRunner(username = config["username"],
password = config["password"],
host = config["host"],
vhost = config["vhost"],
services_exchange = routing_key,
port = config.as_int("port"),
routing_key = routing_key,
testrun_id = testrun_id,
execution_timeout = execution_timeout,
queue_timeout = config.as_int("timeout_task_start"),
controller_timeout = \
config.as_int("timeout_for_preparation"))
return taskrunner
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA
# ***** END LICENCE BLOCK *****
"""
Provides Class based access to Schema definition
"""
import configobj
from ots.server.server_config_filename import server_config_filename
SCHEMA_FILENAME = configobj.ConfigObj(server_config_filename())\
["ots.results"]["results_xsd"]
TRUE = "true"
FALSE = "false"
class Names(object):
"""
Names of the Schema Tags as Defined in the XSD
"""
INSIGNIFICANT = "insignificant"
RESULT = "result"
def test_one_task_one_worker(self):
"""
The simplest configuration...
Check that the results come back OK from the Worker
"""
self.test_definition_file_received = False
self.results_file_received = False
if not DEBUG:
self.worker_processes.start()
self.testrun_id = 111
taskrunner = taskrunner_factory(routing_key=ROUTING_KEY,
execution_timeout=10,
testrun_id=self.testrun_id,
config_file=server_config_filename())
#Create a zip file with a test definition
zipfile_name = os.path.join(TESTS_MODULE_DIRNAME, "data",
"test_definition_1.xml")
steps = ["mkdir foo", "mkdir bar", "mkdir baz"]
self._create_zip_test_definition_file(zipfile_name, steps)
#Add a Task
command = ["ots_mock", '"%s"' % (zipfile_name), "%s" % self.testrun_id]
taskrunner.add_task(command)
#
command_quit = ["quit"]
taskrunner.add_task(command_quit)
#Callback to handler results
def cb_handler(signal, dto, **kwargs):
self.cb_called = True
if isinstance(dto, Results):
filename = dto.data.name
if filename == "test_definition.xml":
self.test_definition_file_received = True
self.assertEquals(
EXPECTED.replace(' ', '').replace('\n', ''),
dto.data.read().replace(' ', '').replace('\n', ''))
elif filename == "dummy_results_file.xml":
self.results_file_received = True
expected = self._dummy_results_xml(filename)
self.assertEquals(expected, dto.data.read())
DTO_SIGNAL.connect(cb_handler)
#Run...
time_before_run = time.time()
time.sleep(1)
taskrunner.run()
time.sleep(1)
time_after_run = time.time()
#Check the results
if not DEBUG:
foo = os.path.join(EXECUTION_DIRNAME, "foo")
foo_time = os.path.getctime(foo)
bar = os.path.join(EXECUTION_DIRNAME, "bar")
bar_time = os.path.getctime(bar)
baz = os.path.join(EXECUTION_DIRNAME, "baz")
baz_time = os.path.getctime(baz)
self.assertTrue(time_before_run < foo_time <= bar_time <= baz_time
<= time_after_run)
self.assertTrue(self.results_file_received)
self.assertTrue(self.test_definition_file_received)
#
self.assertFalse(all(self.worker_processes.exitcodes))
def test_one_task_one_worker(self):
"""
The simplest configuration...
Check that the results come back OK from the Worker
"""
self.test_definition_file_received = False
self.results_file_received = False
if not DEBUG:
self.worker_processes.start()
self.testrun_id = 111
taskrunner = taskrunner_factory(
routing_key=ROUTING_KEY,
execution_timeout=10,
testrun_id=self.testrun_id,
config_file=server_config_filename(),
)
# Create a zip file with a test definition
zipfile_name = os.path.join(TESTS_MODULE_DIRNAME, "data", "test_definition_1.xml")
steps = ["mkdir foo", "mkdir bar", "mkdir baz"]
self._create_zip_test_definition_file(zipfile_name, steps)
# Add a Task
command = ["ots_mock", '"%s"' % (zipfile_name), "%s" % self.testrun_id]
taskrunner.add_task(command)
#
command_quit = ["quit"]
taskrunner.add_task(command_quit)
# Callback to handler results
def cb_handler(signal, dto, **kwargs):
self.cb_called = True
if isinstance(dto, Results):
filename = dto.data.name
if filename == "test_definition.xml":
self.test_definition_file_received = True
self.assertEquals(
EXPECTED.replace(" ", "").replace("\n", ""), dto.data.read().replace(" ", "").replace("\n", "")
)
elif filename == "dummy_results_file.xml":
self.results_file_received = True
expected = self._dummy_results_xml(filename)
self.assertEquals(expected, dto.data.read())
DTO_SIGNAL.connect(cb_handler)
# Run...
time_before_run = time.time()
time.sleep(1)
taskrunner.run()
time.sleep(1)
time_after_run = time.time()
# Check the results
if not DEBUG:
foo = os.path.join(EXECUTION_DIRNAME, "foo")
foo_time = os.path.getctime(foo)
bar = os.path.join(EXECUTION_DIRNAME, "bar")
bar_time = os.path.getctime(bar)
baz = os.path.join(EXECUTION_DIRNAME, "baz")
baz_time = os.path.getctime(baz)
self.assertTrue(time_before_run < foo_time <= bar_time <= baz_time <= time_after_run)
self.assertTrue(self.results_file_received)
self.assertTrue(self.test_definition_file_received)
#
self.assertFalse(all(self.worker_processes.exitcodes))
