def __init__(self, device_path, device_type):
'''
Initial constructor.
:param device_path: file descriptor device path.
:type device_path: <str>
:param device_type: file descriptor device type.
:type device_type: <int>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([
('str:device_path', device_path),
('int:device_type', device_type)
])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
supported_device_types = [
FileDescriptor.STDIN, FileDescriptor.STDOUT, FileDescriptor.STDERR
]
if device_type in supported_device_types:
self.__device_path = device_path
self.__device_type = device_type
self.__device_file = None
else:
error = 'file descriptor type can be <STDIN | STDOUT | STDERR>'
error_message(FileDescriptor.PKG_VERBOSE, error)
def choose_module(self, verbose=False):
'''
Choose type of kernel module.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: data model, type id {0, 1, 2, 3, 4}.
:rtype: <dict>, <int>
:exceptions: None
'''
type_selected, pro_type_id = None, None
types = self.config[GenLKM.MODULES]
pro_types_len = len(types)
for index, lkm_pro in enumerate(types):
lkm_pro_key, lkm_option = lkm_pro.keys()[0], 'Cancel'
if lkm_pro_key != 'cancel':
lkm_option = lkm_pro[lkm_pro_key][0]['info']
print(' {0} {1}'.format(index + 1, lkm_option))
while True:
input_type = input(' select project type: ')
options = range(1, pro_types_len + 1, 1)
try:
if int(input_type) in list(options):
type_selected = types[int(input_type) - 1]
pro_type_id = int(input_type) - 1
break
raise ValueError
except ValueError:
error_message(GenLKM.GEN_VERBOSE, 'not an appropriate choice')
verbose_message(GenLKM.GEN_VERBOSE, verbose, 'selected', type_selected)
return type_selected, pro_type_id
def check(self, daemon_operation, verbose=False):
'''
Checking usage of Daemon process.
:param daemon_operation: daemon operation.
:type daemon_operation: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:daemon_operation',
daemon_operation)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
verbose_message(DaemonUsage.PKG_VERBOSE, verbose, 'checking usage')
for index, option in enumerate(DaemonUsage.DAEMON_OPERATIONS):
if option == daemon_operation:
self.__usage_status = index
if daemon_operation not in DaemonUsage.DAEMON_OPERATIONS:
self.__usage_status = 127
error_message(
DaemonUsage.PKG_VERBOSE,
'usage: {0}'.format('|'.join(DaemonUsage.DAEMON_OPERATIONS)))
verbose_message(DaemonUsage.PKG_VERBOSE, verbose, 'usage status',
self.__usage_status)
def __init__(self, file_process_id_path, file_process_id_mode):
'''
Initial constructor.
:param file_process_id_path: file process id path.
:type file_process_id_path: <str>
:param file_process_id_mode: file process id mode.
:type file_process_id_mode: <str>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([
('str:file_process_id_path', file_process_id_path),
('str:file_process_id_mode', file_process_id_mode)
])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
if file_process_id_mode in FileProcessId.MODE:
self.__file_process_id_path = file_process_id_path
self.__file_process_id_mode = file_process_id_mode
self.__file_process_id = None
else:
error = 'PID file mode can be <w+ | r>'
error_message(FileProcessId.PKG_VERBOSE, error)
def choose_osc(self, verbose=False):
'''
Select FOSC for target.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: FOSC | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
verbose_message(OSCSelector.GEN_VERBOSE, verbose, 'select FOSC')
fosc_name_index, fosc_name = -1, None
if bool(self.__fosc_list):
while True:
print('{0}\n'.format('#' * 30))
for index in range(len(self.__fosc_list)):
print('\t{0}: {1}'.format(index, self.__fosc_list[index]))
print('{0}\n'.format('#' * 30))
fosc_name_index = int(input(' select FOSC: '))
if fosc_name_index not in range(len(self.__fosc_list)):
error_message(OSCSelector.GEN_VERBOSE,
'not an appropriate choice')
else:
fosc_name = self.__fosc_list[fosc_name_index]
break
return fosc_name
def check_mode(self, file_mode, verbose=False):
'''
Check operation mode for file.
:param file_mode: file mode ('r', 'w', 'a', 'b', 'x', 't', '+').
:type file_mode: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: True (regular file mode) | False.
:rtype: <bool>
:exceptions: None
'''
modes, mode_checks = list(file_mode), []
for mode in modes:
if mode not in FileChecking.MODES:
mode_checks.append(False)
else:
mode_checks.append(True)
if all(mode_checks):
self.__file_mode_ok = True
verbose_message(FileChecking.VERBOSE, self.__verbose or verbose,
file_mode)
else:
self.__file_mode_ok = False
error_message(FileChecking.VERBOSE,
'{0} [{1}]'.format('not supported mode', file_mode))
def start(self, verbose=False):
'''
Start daemon process.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: start daemon process status (True) | False.
:rtype: <bool>
:exceptions: None
'''
pid, status = None, False
verbose_message(Daemon.PKG_VERBOSE, verbose, 'start daemon process')
if self.unix_status:
with FileProcessId(self.__pid_file_path, 'w+') as pid_file_path:
pid = pid_file_path.read().strip()
if bool(pid):
error_message(
Daemon.PKG_VERBOSE,
'file {0} already exist'.format(self.__pid_file_path),
'daemon already running?')
else:
self.daemonize(verbose=verbose)
self.run()
status = True
return status
def usage(self, operation, verbose=False):
'''
Create daemon process.
:param operation: daemon operation.
:type operation: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:operation', operation)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
verbose_message(Daemon.PKG_VERBOSE, verbose, 'daemon operation',
operation)
if self.unix_status:
self.__daemon_usage.check(operation, verbose=verbose)
if self.__daemon_usage.usage_status == 127:
sys.exit(127)
elif self.__daemon_usage.usage_status == 0:
self.start(verbose=verbose)
elif self.__daemon_usage.usage_status == 1:
self.stop(verbose=verbose)
elif self.__daemon_usage.usage_status == 2:
self.restart(verbose=verbose)
else:
error_message(Daemon.PKG_VERBOSE, 'wrong option code')
sys.exit(128)
def check_format(self, file_path, file_format, verbose=False):
'''
Check file format by extension.
:param file_path: file path.
:type file_path: <str>
:param file_format: file format (file extension).
:type file_format: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
if file_format != 'makefile':
file_name_path, extension = splitext(file_path)
extension = extension.replace('.', '')
if extension == '':
extension = file_format
else:
if file_format.capitalize() in file_path:
extension = 'makefile'
else:
extension = 'wrong_format'
if not extension == file_format or extension == 'wrong_format':
error_message(
FileChecking.VERBOSE,
'{0} [{1}] {2}'.format('not matched file extension',
file_format, file_path))
self.__file_format_ok = False
else:
self.__file_format_ok = True
verbose_message(FileChecking.VERBOSE, self.__verbose or verbose,
file_path)
def choose_mcu(self, verbose=False):
'''
Select MCU target.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: MCU name | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
verbose_message(MCUSelector.GEN_VERBOSE, verbose, 'select MCU')
mcu_name_index, mcu_name = -1, None
if bool(self.__mcu_list):
while True:
print('{0}\n'.format('#' * 30))
for index in range(len(self.__mcu_list)):
print('\t{0}: {1}'.format(index, self.__mcu_list[index]))
print('{0}\n'.format('#' * 30))
mcu_name_index = int(input(' select MCU: '))
if mcu_name_index not in range(len(self.__mcu_list)):
error_message(MCUSelector.GEN_VERBOSE,
'not an appropriate choice')
else:
mcu_name = self.__mcu_list[mcu_name_index]
break
return mcu_name
def choose_model(cls, verbose=False):
"""
Choose type of data model.
:param verbose: Enable/disable verbose option
:type verbose: <bool>
:return: Type of data model (0, 1, 2)
:rtype: <int>
:exceptions: None
"""
verbose_message(cls.VERBOSE, verbose, 'Loading options')
print("\n {0}".format('model option list:'))
for key in sorted(cls.__MODELS):
print(" {0} {1}".format(key, cls.__MODELS[key]))
while True:
try:
model_type = int(raw_input(' Select model: '))
except NameError:
model_type = input(' Select model: ')
if model_type not in cls.__MODELS.keys():
error_message(cls.VERBOSE, 'Not an appropriate choice.')
else:
break
verbose_message(cls.VERBOSE, verbose, 'Selected option', model_type)
return model_type
def write(self, element, modules, verbose=False):
'''
Write templates content with parameters to modules.
:param element: processes element.
:type element: <dict>
:param modules: modules for tool/generator.
:type modules: <list>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('dict:element', element),
('list:modules', modules)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
status, statuses, expected_num_modules = False, [], len(modules[1:])
for template_content in modules[1:]:
template = Template(template_content[0])
module_content = template.substitute({
ElementKeys.TOOL_NAME_KEY:
'{0}'.format(element[ElementKeys.ROOT_KEY][0][
ElementKeys.TOOL_NAME_KEY]),
ElementKeys.TOOL_UPPER_KEY:
'{0}'.format(element[ElementKeys.ROOT_KEY][1][
ElementKeys.TOOL_UPPER_KEY]),
ElementKeys.TOOL_CLASS_KEY:
'{0}'.format(element[ElementKeys.ROOT_KEY][2][
ElementKeys.TOOL_CLASS_KEY]),
ElementKeys.TOOL_YEAR_KEY:
'{0}'.format(element[ElementKeys.ROOT_KEY][3][
ElementKeys.TOOL_YEAR_KEY])
})
module_path = '{0}/{1}'.format(getcwd(), template_content[1])
module_extension = module_path.split('.')[1]
with open(module_path, 'w') as module_file:
module_file.write(module_content)
chmod(module_path, 0o666)
self.check_path(file_path=module_path, verbose=verbose)
self.check_mode(file_mode='w', verbose=verbose)
self.check_format(file_path=module_path,
file_format=module_extension,
verbose=verbose)
if self.is_file_ok():
statuses.append(True)
else:
statuses.append(False)
if all([statuses, len(statuses) == expected_num_modules]):
status = True
else:
error_message(WriteTemplate.GEN_VERBOSE,
'failed to generate all modules')
return status
def select_pro_type(self, verbose=False):
'''
Select project type.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: template type | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
template_selected = None
if bool(self.config):
types = self.config['templates']
pro_types_len = len(types)
for index, pro_type in enumerate(types):
for project_type, template_file in pro_type.items():
if project_type == 'cancel':
print(
'{0} {1}'.format(
index + 1, project_type.capitalize()
)
)
else:
print(
'{0} {1}'.format(
index + 1,
project_type.upper().replace('_', ' ')
)
)
verbose_message(
UnixDomainSocket.GEN_VERBOSE, verbose,
'to be processed template', template_file
)
while True:
input_type = input(' select project type: ')
options = range(1, pro_types_len + 1, 1)
try:
if int(input_type) in list(options):
for target in types[int(input_type) - 1].keys():
if target is None:
template_selected = 'cancel'
else:
template_selected = target
break
else:
raise ValueError
except ValueError:
error_message(
UnixDomainSocket.GEN_VERBOSE,
'not an appropriate choice'
)
verbose_message(
UnixDomainSocket.GEN_VERBOSE, verbose,
'selected', template_selected
)
return template_selected
def choose_module(self, config, verbose=False):
'''
Select module type.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: project template selected | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
template_target = None
if bool(config):
types = config['py_module']
pro_types_len = len(types)
for pro_type in types:
for project_type, project_info in pro_type.items():
if project_type != 'cancel':
print('{0} {1}'.format(
types.index(pro_type) + 1,
project_info[0]['info']))
verbose_message(ModuleSelector.GEN_VERBOSE, verbose,
'to be processed template',
project_info[1]['template'])
else:
print('{0} {1}'.format(
types.index(pro_type) + 1, 'Cancel'))
while True:
try:
try:
input_type = raw_input(' select project type: ')
except NameError:
input_type = input(' select project type: ')
options = xrange(1, pro_types_len + 1, 1)
except NameError:
options = range(1, pro_types_len + 1, 1)
try:
if int(input_type) in list(options):
for target in types[int(input_type) - 1].keys():
if target == 'cancel':
template_target = 'cancel'
else:
template_target = types[
int(input_type) - 1][target][1]['template']
break
else:
raise ValueError
except ValueError:
error_message(ModuleSelector.GEN_VERBOSE,
'not an appropriate choice')
verbose_message(ModuleSelector.GEN_VERBOSE, verbose, 'selected',
template_target)
return template_target
def __enter__(self):
'''
Open configuration file in mode.
:return: file object | None.
:rtype: <file> | <NoneType>
:exceptions: None
'''
if self.is_file_ok():
self.__file = open(self.__file_path, self.__file_mode)
else:
error_message(ConfigFile.VERBOSE, 'check file', self.__file_path)
self.__file = None
return self.__file
def process(self, verbose=False):
'''
Process and run operation.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: None
'''
status = False
if self.tool_operational:
num_of_args_sys = len(sys.argv)
if num_of_args_sys > 1:
operation = sys.argv[1]
if operation not in DistPyModule.OPS:
sys.argv.append('-h')
else:
sys.argv.append('-h')
args = self.parse_args(sys.argv[1:])
setup_exists = Path('{0}/{1}'.format(getcwd(),
'setup.py')).exists()
if not setup_exists:
if bool(getattr(args, 'gen')):
print('{0} {1} [{2}]'.format(
'[{0}]'.format(DistPyModule.GEN_VERBOSE.lower()),
'generating', getattr(args, 'gen')))
generator = GenSetup(
verbose=getattr(args, 'verbose') or verbose)
status = generator.gen_setup(
'{0}'.format(getattr(args, 'gen')),
verbose=getattr(args, 'verbose') or verbose)
if status:
success_message(DistPyModule.GEN_VERBOSE, 'done\n')
self.logger.write_log(
'{0} {1} done'.format(
'generating setup.py for package',
getattr(args, 'gen')), ATSLogger.ATS_INFO)
else:
error_message(DistPyModule.GEN_VERBOSE,
'generation failed')
self.logger.write_log('generation failed',
ATSLogger.ATS_ERROR)
else:
error_message(DistPyModule.GEN_VERBOSE,
'provide package name')
self.logger.write_log('provide package name',
ATSLogger.ATS_ERROR)
else:
error_message(DistPyModule.GEN_VERBOSE,
'setup.py already exist')
self.logger.write_log('setup.py already exist',
ATSLogger.ATS_ERROR)
else:
error_message(DistPyModule.GEN_VERBOSE, 'tool is not operational')
self.logger.write_log('tool is not operational',
ATSLogger.ATS_ERROR)
return status
def process(self, verbose=False):
'''
Process and run operation.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: None
'''
status = False
if self.tool_operational:
if len(sys.argv) >= 4:
options = [arg for i, arg in enumerate(sys.argv) if i % 2 != 0]
if any([arg not in GenAVR8.OPS for arg in options]):
sys.argv.append('-h')
else:
sys.argv.append('-h')
args = self.parse_args(sys.argv[1:])
project_exists = exists('{0}/{1}'.format(getcwd(),
getattr(args, 'gen')))
if not project_exists:
if bool(getattr(args, 'gen')) and bool(getattr(args, 'type')):
generator = AVR8Setup(
verbose=getattr(args, 'verbose') or verbose)
generator.project_setup(getattr(args, 'gen'),
getattr(args, 'type'))
print('{0} {1} {2} [{3}]'.format(
'[{0}]'.format(GenAVR8.GEN_VERBOSE.lower()),
'generating AVR8 project skeleton',
getattr(args, 'type'), getattr(args, 'gen')))
status = generator.gen_pro_setup(
verbose=getattr(args, 'verbose') or verbose)
if status:
success_message(GenAVR8.GEN_VERBOSE, 'done\n')
self.logger.write_log(
'{0} {1} done'.format('generation of project',
getattr(args, 'gen')),
ATSLogger.ATS_INFO)
else:
error_message(GenAVR8.GEN_VERBOSE,
'failed to generate project')
self.logger.write_log('generation failed',
ATSLogger.ATS_ERROR)
else:
error_message(GenAVR8.GEN_VERBOSE,
'provide project name and type')
self.logger.write_log('provide project name and type',
ATSLogger.ATS_ERROR)
else:
error_message(GenAVR8.GEN_VERBOSE, 'project dir already exist')
self.logger.write_log('project dir already exist',
ATSLogger.ATS_ERROR)
else:
error_message(GenAVR8.GEN_VERBOSE, 'tool is not operational')
self.logger.write_log('tool is not operational',
ATSLogger.ATS_ERROR)
return status
def check_path(self, file_path, verbose=False):
'''
Check file path.
:param file_path: file path.
:type file_path: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
if not isfile(file_path):
error_message(FileChecking.VERBOSE, 'check file', file_path)
else:
self.__file_path_ok = True
verbose_message(FileChecking.VERBOSE, self.__verbose or verbose,
file_path)
def exit_handler(self, verbose=False):
'''
Remove PID file at exit.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
if self.unix_status:
if exists(self.__pid_file_path):
verbose_message(Daemon.PKG_VERBOSE, verbose,
'removing pid file', self.__pid_file_path)
remove(self.__pid_file_path)
else:
error_message(Daemon.PKG_VERBOSE, 'check PID file',
self.__pid_file_path)
def process(self, verbose=False):
'''
Process and run operation.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: None
'''
status = False
if self.tool_operational:
num_of_args_sys = len(sys.argv)
if num_of_args_sys > 1:
operation = sys.argv[1]
if operation not in GenPyModule.OPS:
sys.argv.append('-h')
else:
sys.argv.append('-h')
args = self.parse_args(sys.argv[1:])
target_module = '{0}.py'.format(getattr(args, 'gen')).lower()
current_dir = getcwd()
mod_path = '{0}/{1}'.format(current_dir, target_module)
mod_exists = exists(mod_path)
if not mod_exists:
if bool(getattr(args, 'gen')):
generator = GenModule(verbose=getattr(args, 'verbose'))
print('{0} {1} [{2}]'.format(
'[{0}]'.format(GenPyModule.GEN_VERBOSE),
'generating python module', getattr(args, 'gen')))
status = generator.gen_module('{0}'.format(
getattr(args, 'gen')))
if status:
success_message(GenPyModule.GEN_VERBOSE, 'done\n')
self.logger.write_log(
'{0} {1} done'.format('generating module',
getattr(args, 'gen')),
ATSLogger.ATS_INFO)
else:
error_message(GenPyModule.GEN_VERBOSE,
'generation failed')
self.logger.write_log('generation failed',
ATSLogger.ATS_ERROR)
else:
error_message(GenPyModule.GEN_VERBOSE,
'provide module name')
self.logger.write_log('provide module name',
ATSLogger.ATS_ERROR)
else:
error_message(GenPyModule.GEN_VERBOSE, 'module already exist')
self.logger.write_log('module already exist',
ATSLogger.ATS_ERROR)
else:
error_message(GenPyModule.GEN_VERBOSE, 'tool is not operational')
self.logger.write_log('tool is not operational',
ATSLogger.ATS_ERROR)
return status
def process(self, verbose=False):
'''
Process and run operation.
:param verbose: enable/disable verbose option
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: None
'''
status = False
if self.tool_operational:
num_of_args_sys = len(sys.argv)
if num_of_args_sys > 1:
operation = sys.argv[1]
if operation not in GenKernelModule.OPS:
sys.argv.append('-h')
else:
sys.argv.append('-h')
args, current_dir = self.parse_args(sys.argv[1:]), getcwd()
setup_path = '{0}/{1}'.format(current_dir, args.gen)
setup_exists = exists(setup_path)
if not setup_exists:
if bool(args.gen):
print('{0} {1} [{2}]'.format(
'[{0}]'.format(GenKernelModule.GEN_VERBOSE),
'generating kernel module', args.gen))
generator = GenLKM(verbose=verbose)
status = generator.gen_module('{0}'.format(args.gen),
verbose=verbose)
if status:
success_message(GenKernelModule.GEN_VERBOSE, 'done\n')
self.logger.write_log(
'{0} {1} done'.format('generating kernel module',
args.gen),
ATSLogger.ATS_INFO)
else:
error_message(GenKernelModule.GEN_VERBOSE,
'generation failed')
self.logger.write_log('generation failed',
ATSLogger.ATS_ERROR)
else:
error_message(GenKernelModule.GEN_VERBOSE,
'provide package name')
self.logger.write_log('provide package name',
ATSLogger.ATS_ERROR)
else:
error_message(GenKernelModule.GEN_VERBOSE,
'project already exist')
self.logger.write_log('project already exist',
ATSLogger.ATS_ERROR)
else:
error_message(GenKernelModule.GEN_VERBOSE,
'tool is not operational')
self.logger.write_log('tool is not operational',
ATSLogger.ATS_ERROR)
return status
def unix_kill(self, process_id, pid_file_path, verbose=False):
'''
Kill Unix Like OS process.
:param process_id: process ID.
:type process_id: <int>
:param pid_file_path: PID file path.
:type pid_file_path: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True | False.
:rtype: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status, sleep_time = ATSChecker(), None, False, 0.1
error, status = checker.check_params([('int:process_id', process_id),
('str:pid_file_path',
pid_file_path)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
if self.__unix_status:
try:
verbose_message(UnixOperations.PKG_VERBOSE, verbose,
'kill process {0}'.format(process_id))
while 1:
kill(process_id, SIGTERM)
sleep(sleep_time)
status = True
except OSError as os_error:
os_error = str(os_error)
if os_error.find(UnixOperations.NO_PROCESS) > 0:
if exists(pid_file_path):
verbose_message(
UnixOperations.PKG_VERBOSE, verbose,
'{0} with PID: {1}, removing pid file {2}'.format(
UnixOperations.NO_PROCESS, process_id,
pid_file_path))
remove(pid_file_path)
status = True
else:
error_message(UnixOperations.PKG_VERBOSE,
'{0}'.format(os_error))
status = False
return status
def select_pro_type(cls, config, verbose=False):
'''
Select project type.
:param config: dictionary with configuration.
:type config: <dict>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: project type and project ID | None and None.
:rtype: <str> <int> | <NoneType> <NoneType>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('dict:config', config)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
type_selected, pro_type_id = None, None
config_ok = cls.check_config_keys(config, verbose=verbose)
if status == ATSChecker.NO_ERROR and bool(config_ok):
types = config[cls.TYPE_KEY]
pro_types_len = len(types)
for index, pro_type in enumerate(types):
print('{0} {1}'.format(index + 1, pro_type.capitalize()))
while True:
try:
try:
input_type = raw_input(' select project type: ')
except NameError:
input_type = input(' select project type: ')
options = xrange(1, pro_types_len + 1, 1)
except NameError:
options = range(1, pro_types_len + 1, 1)
try:
if int(input_type) in list(options):
type_selected = types[int(input_type) - 1]
pro_type_id = int(input_type) - 1
break
raise ValueError
except ValueError:
error_message(ProjectSelector.GEN_VERBOSE,
'not an appropriate choice')
verbose_message(ProjectSelector.GEN_VERBOSE, verbose, 'selected',
type_selected)
return type_selected, pro_type_id
def process(self, verbose=False):
'''
Process and run operation.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: None
'''
status = False
if self.tool_operational:
num_of_args_sys = len(sys.argv)
if num_of_args_sys > 1:
operation = sys.argv[1]
if operation not in GenPyTool.OPS:
sys.argv.append('-h')
else:
sys.argv.append('-h')
args = self.parse_args(sys.argv[1:])
pro_exists = exists(getattr(args, 'gen'))
if not pro_exists:
if bool(getattr(args, 'gen')):
print('{0} {1} [{2}]'.format(
'[{0}]'.format(GenPyTool.GEN_VERBOSE.lower()),
'generating python tool/gen', getattr(args, 'gen')))
generator = GenPro(getattr(args, 'gen'),
verbose=getattr(args, 'verbose')
or verbose)
status = generator.gen_pro(
verbose=getattr(args, 'verbose') or verbose)
if status:
success_message(GenPyTool.GEN_VERBOSE, 'done\n')
self.logger.write_log(
'{0} {1} done'.format('generating tool/gen',
getattr(args, 'gen')),
ATSLogger.ATS_INFO)
else:
error_message(GenPyTool.GEN_VERBOSE,
'generation failed')
self.logger.write_log('generation failed',
ATSLogger.ATS_ERROR)
else:
error_message(GenPyTool.GEN_VERBOSE,
'provide tool/gen name')
self.logger.write_log('provide tool/gen name',
ATSLogger.ATS_ERROR)
else:
error_message(GenPyTool.GEN_VERBOSE, 'tool/gen already exist')
self.logger.write_log('tool/gen already exist',
ATSLogger.ATS_ERROR)
else:
error_message(GenPyTool.GEN_VERBOSE, 'tool is not operational')
self.logger.write_log('tool is not operational',
ATSLogger.ATS_ERROR)
return status
def produce(self, pro_property, schema, template, element, verbose=False):
'''
Preparing project factory object.
:param pro_property: project property (name and type).
:type pro_property: <dict>
:param template: project tool/generator template.
:type template: <dict>
:param schema: project tool/generator schema.
:type schema: <dict>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: factory product object | None.
:rtype: <Python Object> | <NoneType>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('dict:pro_property',
pro_property),
('dict:schema', schema),
('dict:template', template),
('dict:element', element)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
product_container = None
if self.check_pro_type(pro_property['type'], verbose=verbose):
if self.__supported_pro_types[0] == pro_property['type']:
product_container = ToolFactory(pro_property,
schema,
template,
element,
verbose=verbose)
if self.__supported_pro_types[1] == pro_property['type']:
product_container = GenFactory(pro_property,
schema,
template,
element,
verbose=verbose)
else:
error_message(Factory.GEN_VERBOSE, 'not supported project type',
pro_property['type'])
return product_container
def write_log(self, message, ctrl, verbose=False):
'''
Write message to log file.
:param message: log message.
:type message: <str>
:param ctrl: control flag (debug, warning, critical, errors, info).
:type ctrl: <int>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:message', message),
('int:ctrl', ctrl)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
status = False
verbose_message(ATSLogger.VERBOSE, self.__verbose or verbose, message,
ctrl)
if self.logger_status:
switch_dict = {
ATSLogger.ATS_DEBUG: self.logger.debug,
ATSLogger.ATS_WARNING: self.logger.warning,
ATSLogger.ATS_CRITICAL: self.logger.critical,
ATSLogger.ATS_ERROR: self.logger.error,
ATSLogger.ATS_INFO: self.logger.info
}
ctrl_options = [
ATSLogger.ATS_DEBUG, ATSLogger.ATS_WARNING,
ATSLogger.ATS_CRITICAL, ATSLogger.ATS_ERROR, ATSLogger.ATS_INFO
]
if ctrl in ctrl_options:
switch_dict[ctrl](message)
status = True
else:
message = '{0} [{1}]'.format('not supported log level', ctrl)
error_message(ATSLogger.VERBOSE, message)
return status
def second_fork(self, verbose=False):
'''
Won't be started merely by opening a terminal.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exit code: 0 (success) | 1 (failed)
:exceptions: None
'''
if self.__unix_status:
try:
process_id = fork()
if process_id > 0:
verbose_message(UnixOperations.PKG_VERBOSE, verbose,
'second fork')
sys.exit(0)
except OSError as os_error:
error_message('fork #2 failed: {0} {1}\n'.format(
os_error.errno, os_error.strerror))
sys.exit(1)
def first_fork(self, verbose=False):
'''
Make sure that process is not group leader.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exit code: 0 (success) | 1 (failed)
:exceptions: None
'''
if self.__unix_status:
try:
process_id = fork()
if process_id > 0:
verbose_message(UnixOperations.PKG_VERBOSE, verbose,
'first fork')
sys.exit(0)
except OSError as os_error:
error_message('fork #1 failed: {0} {1}\n'.format(
os_error.errno, os_error.strerror))
sys.exit(1)
def select_rcp_type(self, verbose=False):
'''
Select RCP type.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: project template selected | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
template_selected = None
if bool(self.config):
types = self.config['types']
pro_types_len = len(types)
for index, pro_type in enumerate(types):
print(
'{0} {1}'.format(index + 1, pro_type.capitalize())
)
verbose_message(
RPCService.GEN_VERBOSE, verbose,
'to be processed template', pro_type.capitalize()
)
while True:
input_type = input(' select RPC type: ')
options = range(1, pro_types_len + 1, 1)
try:
if int(input_type) in list(options):
template_selected = self.config['templates'][
int(input_type) - 1
]
break
else:
raise ValueError
except ValueError:
error_message(
RPCService.GEN_VERBOSE, 'not an appropriate choice'
)
verbose_message(
RPCService.GEN_VERBOSE, verbose, 'selected', template_selected
)
return template_selected
def stop(self, verbose=False):
'''
Stop daemon process.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: stop daemon process status (True) | False.
:rtype: <bool>
:exceptions: None
'''
pid, status = None, False
verbose_message(Daemon.PKG_VERBOSE, verbose, 'stop daemon process')
if self.unix_status:
with FileProcessId(self.__pid_file_path, 'r') as pid_file_path:
pid = int(pid_file_path.read().strip())
if not pid:
error_message(Daemon.PKG_VERBOSE,
'daemon process running?')
else:
status = self.unix_kill(pid, self.__pid_file_path)
return status
