def __init__(self, workdir: str, scheduler: Scheduler,
logger_queue: Queue):
self.workdir = workdir
self.__sched = scheduler
self.__hpc_stats_resolver = HPCStatsResolver(self.__templ_sign,
logger_queue)
self.__log_writer = NamedLogWriter(logger_queue, 'TemplateResolver')
def __init__(self, streams_handler: StreamsHandler,
template_resolver: TemplateResolver, io_handler: IOHandler,
logger_queue: Queue, workdir: str, server_addr: str):
# for writing files
self.__io_handler = io_handler
# for receiving/sending data to the web application using sockets
self.__streams_handler = streams_handler
self.__executor = Executor()
# support classes
self.__template_resolver = template_resolver
self.__compilation_handler = CompilationHandler(
template_resolver, logger_queue, workdir)
self.__task_stats_handler = StatsCmdHandler(streams_handler,
template_resolver,
io_handler, logger_queue)
self.__hpc_stats_handler = HPCStatsCmdHandler(
template_resolver=template_resolver,
hpc_stats_resolver=HPCStatsResolver(
template_resolver.get_templ_sign(), logger_queue),
logger_queue=logger_queue,
server_addr=server_addr)
self.__workdir = workdir
self.__log_writer = NamedLogWriter(logger_queue, 'RunCmdHandler')
super().__init__()
def build(workdir, scheds_list, logger_queue: Queue):
"""
Return TemplateResolver with Scheduler model, appropriate for the system
:param workdir: path to working directory
:param scheds_list: known Scheduler list
:param logger_queue: class instance that should be used for logging
:return: TemplateResolver with appropriate Scheduler
"""
log_writer = NamedLogWriter(logger_queue, 'TemplateResolverBuilder')
template_resolver = None
executor = Executor()
for sched in scheds_list: # type: Scheduler
try:
template_resolver = TemplateResolver(workdir, sched,
logger_queue)
caught = False
cmd = template_resolver.get_hpc_stats_cmd()
executor.execute_shell_command(cmd)
except ShellExecutionError as error:
log_writer.log('Scheduler {} wasn\'t found. Output: {}'.format(
sched.get_name(), error))
caught = True
if not caught:
return template_resolver
raise RuntimeError('Unknown scheduler or no scheduler was found')
def __init__(self, template_resolver: TemplateResolver,
logger_queue: Queue, workdir: str):
self.__workdir = workdir
self.__template_resolver = template_resolver
self.__log_writer = NamedLogWriter(logger_queue,
CompilationHandler.__name__)
if self.__check_cmake():
self.__cmake_handler = CMakeHandler(logger_queue, workdir,
self.__cmake_version)
def __init__(self, server_addr: str, logger_queue: Queue,
template_resolver: TemplateResolver,
hpc_stats_handler: HPCStatsResolver):
self.__server_addr = server_addr
self.__template_resolver = template_resolver
self.__hpc_stats_handler = hpc_stats_handler
self.__log_writer = NamedLogWriter(logger_queue, 'HTTPSender')
self.__executor = Executor()
self.__log_writer.log(
'Created instance with server addr: {}'.format(server_addr))
def __init__(self, template_resolver: TemplateResolver,
hpc_stats_resolver: HPCStatsResolver, logger_queue: Queue,
server_addr: str):
self.__server_addr = server_addr
self.__template_resolver = template_resolver
self.__hpc_stats_resolver = hpc_stats_resolver
self.__log_writer = NamedLogWriter(logger_queue, 'HPCStatsCmdHandler')
self.__sender = HTTPSender(self.__server_addr, logger_queue,
self.__template_resolver,
self.__hpc_stats_resolver)
def __init__(self, template_resolver: TemplateResolver, workdir: str, logger_queue: Queue,
writing_end_of_pipe: Connection):
self.__workdir = workdir
self.__writing_conn = writing_end_of_pipe
self.__sources = set()
self.__template_resolver = template_resolver
self.__log_writer = NamedLogWriter(logger_queue, 'RequestHandler')
self.__io_handler = IOHandler(self.__workdir, logger_queue)
self.__logger_queue = logger_queue
self.__cmd_handler_factory = CmdHandlerFactory()
def __init__(self,
host_n_port,
writing_end_of_pipe,
logger_queue: Queue,
template_resolver=None,
workdir='.'):
self.__host = host_n_port[0]
self.__port = host_n_port[1]
self.__handler = RequestHandler(template_resolver, workdir,
logger_queue, writing_end_of_pipe)
self.__executor = Executor()
self.__log_writer = NamedLogWriter(logger_queue, 'TaskServer')
self.__log_writer.log('Created instance of TaskServer')
def __init__(self, streams_handler: StreamsHandler,
template_resolver: TemplateResolver, io_handler: IOHandler,
logger_queue: Queue, server_addr):
self.__streams_handler = streams_handler
self.__template_resolver = template_resolver
self.__io_handler = io_handler
self.__server_addr = server_addr
self.__task_stats_handler = StatsCmdHandler(streams_handler,
template_resolver,
io_handler, logger_queue)
self.__hpc_stats_handler = HPCStatsCmdHandler(
template_resolver=template_resolver,
hpc_stats_resolver=HPCStatsResolver(
template_resolver.get_templ_sign(), logger_queue),
logger_queue=logger_queue,
server_addr=server_addr)
self.__log_writer = NamedLogWriter(logger_queue, 'CancelCmdHandler')
def __init__(self, server_addr: str, logger_queue: Queue, template_resolver: TemplateResolver,
reading_end_of_pipe: Connection, err_threshold=10):
self.__err_count = 0
self.__err_threshold = err_threshold
self.__reading_conn = reading_end_of_pipe
self.__template_resolver = None
self.sources = set()
self.__senders = []
if server_addr is not None and template_resolver is not None:
self.__template_resolver = template_resolver
self.__stats_resolver = HPCStatsResolver(template_resolver.get_templ_sign(), logger_queue)
self.__senders.append(HTTPSender(server_addr, logger_queue, template_resolver, self.__stats_resolver))
self.sources.add(server_addr)
self.__executor = Executor()
self.__logger_queue = logger_queue
self.__log_writer = NamedLogWriter(logger_queue, 'StatusDaemon')
self.__log_writer.log('Created instance of StatusDaemon')
def __init__(self, workdir, logger):
self.workdir = workdir
self.__log_writer = NamedLogWriter(logger, 'IOHandler')
self.__executor = Executor()
def __init__(self, templ_sign: str, logger_queue: Queue):
self.templ_sign = templ_sign
self.__log_writer = NamedLogWriter(logger_queue, 'HPCStatsResolver')
def __init__(self, input_stream: StreamReader, output_stream: StreamWriter,
io_handler: IOHandler, logger_queue: Queue):
self.__in_stream = input_stream
self.__out_stream = output_stream
self.__io_handler = io_handler
self.__log_writer = NamedLogWriter(logger_queue, 'StreamsHandler')
def __init__(self, logger_queue: Queue, workdir: str, cmake_version):
self.__workdir = workdir
self.__log_writer = NamedLogWriter(logger_queue, 'CMakeHandler')
self.__cmake_version = cmake_version
def __init__(self, streams_handler: StreamsHandler,
file_handler: IOHandler, logger_queue: Queue):
self.file_handler = file_handler
self.__log_writer = NamedLogWriter(logger_queue, 'ResultsCmdHandler')
super().__init__(streams_handler)
def __init__(self, streams_handler: StreamsHandler, io_handler: IOHandler,
logger_queue: Queue):
self.io_handler = io_handler
self.__log_writer = NamedLogWriter(logger_queue, 'SourcesCmdHandler')
super().__init__(streams_handler)