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