def linear_solver(self, old_par, A, b, npar, na): """ if invert for moment tensor with zero-trace constraints or no constraint """ AA = np.zeros([na, na]) bb = np.zeros(na) AA[0:npar, 0:npar] = A bb[0:npar] = b if self.config.zero_trace: bb[na - 1] = - np.sum(old_par[0:3]) AA[0:6, na - 1] = np.array([1, 1, 1, 0, 0, 0]) AA[na - 1, 0:6] = np.array([1, 1, 1, 0, 0, 0]) AA[na - 1, na - 1] = 0.0 try: dm = np.linalg.solve(AA, bb) except: logger.error('Matrix is singular...LinearAlgError') raise ValueError("Check Matrix Singularity") new_par = old_par[0:npar] + dm[0:npar] return new_par
def run_command_with_output(command_description, command): process_output = "" logger.info("Starting process: " + command_description) logger.info("Running command: " + command) with subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=1, universal_newlines=True, shell=True) as process: for line in process.stdout: process_output += line errors = os.linesep.join(process.stderr.readlines()) if process.returncode != 0: logger.error(command_description + " failed!" + os.linesep + errors) raise subprocess.CalledProcessError(process.returncode, process.args) else: logger.info(command_description + " completed successfully") return process_output
def add_to_cluster(self, cluster, res): """ Specification: 0. Search and handle `master` tag in `cluster_name` 1. Imports `cluster_name`, seeks and sets (`install` xor `setup`) and (serve` or `start`) callables 2. Installs `cluster_name` 3. Serves `cluster_name` """ args = cluster['args'] if 'args' in cluster else tuple() kwargs = update_d({ 'domain': self.dns_name, 'node_name': self.node_name, 'public_ipv4': self.node.public_ips[-1], 'cache': {}, 'cluster_name': cluster.get('cluster_name') }, cluster['kwargs'] if 'kwargs' in cluster else {}) cluster_type = cluster['module'].replace('-', '_') cluster_path = '/'.join(ifilter(None, (cluster_type, kwargs['cluster_name']))) kwargs.update(cluster_path=cluster_path) if ':' in cluster_type: cluster_type, _, tag = cluster_type.rpartition(':') del _ else: tag = None kwargs.update(tag=tag) if tag == 'master': kwargs.update(master=True) if hasattr(self.node, 'private_ips') and len(self.node.private_ips): kwargs.update(private_ipv4=self.node.private_ips[-1]) guessed_os = self.guess_os() # import `cluster_type` try: setattr(self, 'fab', getattr(__import__(cluster_type, globals(), locals(), [guessed_os], -1), guessed_os)) except AttributeError as e: if e.message != "'module' object has no attribute '{os}'".format(os=guessed_os): raise raise ImportError('Cannot `import {os} from {cluster_type}`'.format(os=guessed_os, cluster_type=cluster_type)) fab_dir = dir(self.fab) # Sort functions like so: `step0`, `step1` func_names = sorted( (j for j in fab_dir if not j.startswith('_') and str.isdigit(j[-1])), key=lambda s: int(''.join(takewhile(str.isdigit, s[::-1]))[::-1] or -1) ) if 'run_cmds' in cluster: mapping = {'>=': operator.ge, '<': operator.lt, '>': operator.gt, '<=': operator.le} # TODO: There must be a full list somewhere! def dict_type(run_cmds, func_names): op = mapping[run_cmds['op']] return [func_name for func_name in func_names if op(int(''.join(takewhile(str.isdigit, func_name[::-1]))[::-1]), int(run_cmds['val']))] run_cmds_type = type(cluster['run_cmds']) if 'exclude' in cluster['run_cmds']: func_names = tuple(ifilter(lambda func: func not in cluster['run_cmds']['exclude'], func_names)) func_names = dict_type(cluster['run_cmds'], func_names) '''{ DictType: dict_type(cluster['run_cmds'], func_names) }.get(run_cmds_type, raise_f(NotImplementedError, '{!s} unexpected for run_cmds'.format(run_cmds_type)))''' if not func_names: try: get_attr = lambda a, b: a if hasattr(self.fab, a) else b if hasattr(self.fab, b) else raise_f( AttributeError, '`{a}` nor `{b}`'.format(a=a, b=b)) func_names = ( get_attr('install', 'setup'), get_attr('serve', 'start') ) except AttributeError as e: logger.error('{e} found in {cluster_type}'.format(e=e, cluster_type=cluster_type)) raise AttributeError( 'Function names in {cluster_type} must end in a number'.format(cluster_type=cluster_type) ) # 'must'! logger.warn('Deprecation: Function names in {cluster_type} should end in a number'.format( cluster_type=cluster_type) ) self.handle_deprecations(func_names) for idx, step in enumerate(func_names): exec_output = execute(getattr(self.fab, step), *args, **kwargs)[self.dns_name] if idx == 0: res[self.dns_name] = {cluster_path: {step: exec_output}} if tag == 'master': save_node_info('master', [self.node_name], folder=cluster_type, marshall=json) else: res[self.dns_name][cluster_path][step] = exec_output save_node_info(self.node_name, node_to_dict(self.node), folder=cluster_path, marshall=json)
def test_second(): global supported_commands try: tests_file_path = 'tests_descriptions.json' logger.info( f'---------------------- run test {tests_file_path} ----------------------' ) saved_values = {} test_data = {} with open(tests_file_path, 'r', encoding='utf-8') as file: test_data = json.load(file) for query in test_data: if query['commands_before_running'] != {}: logger.info( f"commands_before_running: {query['commands_before_running']}" ) for command in query['commands_before_running']: logger.info( f"run: {query['commands_before_running']}{query['commands_before_running'][command]}" ) supported_commands[command]['func']( **(query['commands_before_running'][command])) if 'saved_before' in query['params'].keys(): for type_param, array_name_params in query['params'][ 'saved_before'].items(): for name in array_name_params: query['params'][type_param][name] = saved_values[name] if 'saved_before' in query['custom_headers'].keys(): for name_header in query['custom_headers']['saved_before']: query['custom_headers']['headers'][ name_header] = saved_values[name_header] # print(f"params: {query['params']}") # print(f"custom_headers: {query['custom_headers']}") url = str(query['url']).format(**query['params']['path']) response = http_query.http_query_by_type[str( query['method']).lower()]( url=url, headers=query['custom_headers']['headers'], query_params=query['params']['query'], json_data=query['request_body_json'], ) # checks.check_mimetype(mimetype=response.content_type) checks.check_mimetype(mimetype=response.headers['content-type']) checks.check_http_code(code=response.status_code) response_data_json = response.json() checks.check_structure_successful_response( response=response_data_json) for scan_area, pattern in query['checks'].items(): if pattern is not None and pattern != {} and pattern != []: area = str(scan_area).replace('in_', '') ok, res_comparison = compare(pattern, response_data_json[area]) assert ok is True, f'A result that does not match the pattern was found.\nResult of comparing the url [{url}] response:\n{res_comparison}' for param_for_save in query['saves_from_body']: saved_values[param_for_save] = response_data_json['body'][ param_for_save] # show_dialog() return True except AssertionError as ex: logger.error(ex) print(f'[Error]{ex}') raise MyValueError(f'Тест не пройден: {ex}')