def get(self, task_id): try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') task_handler = TasksHandler() try: task = task_handler.get_task_by_taskid(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') index = int(self._get_args().get('index', 0)) try: with open(os.path.join(consts.TASK_LOG_DIR, '{}.log'.format(task_id))) as f: f.seek(index) data = f.readlines() index = f.tell() except OSError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'log file does not exist') return result_handler(consts.API_ERROR, 'error with log file') return_data = { 'index': index, 'data': data } return result_handler(task.status, return_data)
def delete(self, container_id): try: uuid.UUID(container_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid container id') try: container = container_handler.get_by_uuid(container_id) except ValueError: return result_handler(consts.API_ERROR, 'no such container id') environment_id = container.environment_id client = Client(base_url=consts.DOCKER_URL) LOG.info('delete container: %s', container.name) try: client.remove_container(container.name, force=True) except Exception: LOG.exception('delete container failed') return result_handler(consts.API_ERROR, 'delete container failed') LOG.info('delete container in database') container_handler.delete_by_uuid(container_id) LOG.info('update container in environment') environment = environment_handler.get_by_uuid(environment_id) container_info = jsonutils.loads(environment.container_id) key = next((k for k, v in container_info.items() if v == container_id)) container_info.pop(key) environment_delete_data = { 'container_id': jsonutils.dumps(container_info) } environment_handler.update_attr(environment_id, environment_delete_data) return result_handler(consts.API_SUCCESS, {'container': container_id})
def delete(self, container_id): try: uuid.UUID(container_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid container id') try: container = container_handler.get_by_uuid(container_id) except ValueError: return result_handler(consts.API_ERROR, 'no such container id') environment_id = container.environment_id client = Client(base_url=consts.DOCKER_URL) LOG.info('delete container: %s', container.name) try: client.remove_container(container.name, force=True) except Exception: LOG.exception('delete container failed') return result_handler(consts.API_ERROR, 'delete container failed') LOG.info('delete container in database') container_handler.delete_by_uuid(container_id) LOG.info('update container in environment') environment = environment_handler.get_by_uuid(environment_id) container_info = jsonutils.loads(environment.container_id) key = next((k for k, v in container_info.items() if v == container_id)) container_info.pop(key) environment_delete_data = { 'container_id': jsonutils.dumps(container_info) } environment_handler.update_attr(environment_id, environment_delete_data) return result_handler(consts.API_SUCCESS, {'container': container_id})
def get(self, task_id): try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') task_handler = TasksHandler() try: task = task_handler.get_task_by_taskid(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') index = int(self._get_args().get('index', 0)) try: with open( os.path.join(consts.TASK_LOG_DIR, '{}.log'.format(task_id))) as f: f.seek(index) data = f.readlines() index = f.tell() except OSError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'log file does not exist') return result_handler(consts.API_ERROR, 'error with log file') return_data = {'index': index, 'data': data} return result_handler(task.status, return_data)
def add_environment(self, args): task_id = args['task_id'] try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') environment_handler = V2EnvironmentHandler() try: environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment id') LOG.info('update environment_id in task') task_handler = V2TaskHandler() task_handler.update_attr(task_id, {'environment_id': environment_id}) return result_handler(consts.API_SUCCESS, {'uuid': task_id})
def delete(self, project_id): try: uuid.UUID(project_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid project id') project_handler = V2ProjectHandler() try: project = project_handler.get_by_uuid(project_id) except ValueError: return result_handler(consts.API_ERROR, 'no such project id') if project.tasks: LOG.info('delete related task') task_handler = V2TaskHandler() for task_id in project.tasks.split(','): LOG.debug('delete task: %s', task_id) try: task_handler.delete_by_uuid(task_id) except ValueError: LOG.exception('no such task id: %s', task_id) LOG.info('delete project in database') project_handler.delete_by_uuid(project_id) return result_handler(consts.API_SUCCESS, {'project': project_id})
def update_openrc(self, args): try: openrc_vars = args['openrc'] except KeyError: return result_handler(consts.API_ERROR, 'openrc must be provided') else: if not isinstance(openrc_vars, collections.Mapping): return result_handler(consts.API_ERROR, 'args should be a dict') lines = ['export {}={}\n'.format(k, v) for k, v in openrc_vars.items()] LOG.debug('Writing: %s', ''.join(lines)) LOG.info('Writing openrc: Writing') utils.makedirs(consts.CONF_DIR) with open(consts.OPENRC, 'w') as f: f.writelines(lines) LOG.info('Writing openrc: Done') LOG.info('Source openrc: Sourcing') try: self._source_file(consts.OPENRC) except subprocess.CalledProcessError as e: LOG.exception('Failed to source openrc') return result_handler(consts.API_ERROR, str(e)) LOG.info('Source openrc: Done') return result_handler(consts.API_SUCCESS, {'openrc': openrc_vars})
def create_suite(self, args): try: suite_name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'name must be provided') try: testcases = args['testcases'] except KeyError: return result_handler(consts.API_ERROR, 'testcases must be provided') testcases = [{'file_name': '{}.yaml'.format(t)} for t in testcases] suite = os.path.join(consts.TESTSUITE_DIR, '{}.yaml'.format(suite_name)) suite_content = { 'schema': 'yardstick:suite:0.1', 'name': suite_name, 'test_cases_dir': 'tests/opnfv/test_cases/', 'test_cases': testcases } LOG.info('write test suite') with open(suite, 'w') as f: yaml.dump(suite_content, f, default_flow_style=False) return result_handler(consts.API_SUCCESS, {'suite': suite_name})
def get(self, case_name): case_path = os.path.join(consts.TESTCASE_DIR, '{}.yaml'.format(case_name)) try: with open(case_path) as f: data = f.read() except IOError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'case does not exist') options = { k: { 'description': '', 'type': v.__class__.__name__ } for k, v in jinja2schema.infer(data).items() } # [('segmentation_id', < scalar >), ('image', < string >), ('provider', < scalar >), # ('physical_network', < string >), ('packetsize', < number >)] for k, v in options.items(): if k == 'segmentation_id': options[k]['type'] = 'Number' if k == 'provider': options[k]['type'] = 'String' return result_handler(consts.API_SUCCESS, { 'testcase': data, 'args': options })
def create_task(self, args): try: name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'name must be provided') try: project_id = args['project_id'] except KeyError: return result_handler(consts.API_ERROR, 'project_id must be provided') task_id = str(uuid.uuid4()) create_time = datetime.now() task_handler = V2TaskHandler() LOG.info('create task in database') task_init_data = { 'uuid': task_id, 'project_id': project_id, 'name': name, 'time': create_time, 'status': -1 } task_handler.insert(task_init_data) LOG.info('create task in project') project_handler = V2ProjectHandler() project_handler.append_attr(project_id, {'tasks': task_id}) return result_handler(consts.API_SUCCESS, {'uuid': task_id})
def delete(self, project_id): try: uuid.UUID(project_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid project id') project_handler = V2ProjectHandler() try: project = project_handler.get_by_uuid(project_id) except ValueError: return result_handler(consts.API_ERROR, 'no such project id') if project.tasks: LOG.info('delete related task') task_handler = V2TaskHandler() for task_id in project.tasks.split(','): LOG.debug('delete task: %s', task_id) try: task_handler.delete_by_uuid(task_id) except ValueError: LOG.exception('no such task id: %s', task_id) LOG.info('delete project in database') project_handler.delete_by_uuid(project_id) return result_handler(consts.API_SUCCESS, {'project': project_id})
def create_suite(self, args): try: suite_name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'name must be provided') try: testcases = args['testcases'] except KeyError: return result_handler(consts.API_ERROR, 'testcases must be provided') testcases = [{'file_name': '{}.yaml'.format(t)} for t in testcases] suite = os.path.join(consts.TESTSUITE_DIR, '{}.yaml'.format(suite_name)) suite_content = { 'schema': 'yardstick:suite:0.1', 'name': suite_name, 'test_cases_dir': 'tests/opnfv/test_cases/', 'test_cases': testcases } LOG.info('write test suite') with open(suite, 'w') as f: yaml.dump(suite_content, f, default_flow_style=False) return result_handler(consts.API_SUCCESS, {'suite': suite_name})
def update_openrc(self, args): try: openrc_vars = args['openrc'] except KeyError: return result_handler(consts.API_ERROR, 'openrc must be provided') else: if not isinstance(openrc_vars, collections.Mapping): return result_handler(consts.API_ERROR, 'args should be a dict') lines = ['export {}={}\n'.format(k, v) for k, v in openrc_vars.items()] LOG.debug('Writing: %s', ''.join(lines)) LOG.info('Writing openrc: Writing') utils.makedirs(consts.CONF_DIR) with open(consts.OPENRC, 'w') as f: f.writelines(lines) LOG.info('Writing openrc: Done') LOG.info('Source openrc: Sourcing') try: self._source_file(consts.OPENRC) except subprocess.CalledProcessError as e: LOG.exception('Failed to source openrc') return result_handler(consts.API_ERROR, str(e)) LOG.info('Source openrc: Done') return result_handler(consts.API_SUCCESS, {'openrc': openrc_vars})
def get(self, environment_id): try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') environment_handler = V2EnvironmentHandler() try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment id') if not environment.pod_id: return result_handler(consts.API_SUCCESS, {'sut': {}}) pod_handler = V2PodHandler() try: pod = pod_handler.get_by_uuid(environment.pod_id) except ValueError: return result_handler(consts.API_ERROR, 'no such pod id') else: pod_content = pod.content env = Environment(pod=pod_content) sut_info = env.get_sut_info() return result_handler(consts.API_SUCCESS, {'sut': sut_info})
def delete(self, image_id): try: uuid.UUID(image_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid image id') image_handler = V2ImageHandler() try: image = image_handler.get_by_uuid(image_id) except ValueError: return result_handler(consts.API_ERROR, 'no such image id') LOG.info('delete image in openstack') glance_client = get_glance_client() try: image_o = next((i for i in glance_client.images.list() if i.name == image.name)) except StopIteration: return result_handler(consts.API_ERROR, 'can not find image') glance_client.images.delete(image_o.id) LOG.info('delete image in environment') environment_id = image.environment_id environment_handler = V2EnvironmentHandler() environment = environment_handler.get_by_uuid(environment_id) image_list = environment.image_id.split(',') image_list.remove(image_id) environment_handler.update_attr(environment_id, {'image_id': ','.join(image_list)}) LOG.info('delete image in DB') image_handler.delete_by_uuid(image_id) return result_handler(consts.API_SUCCESS, {'image': image_id})
def delete(self, task_id): try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task id') task_handler = V2TaskHandler() try: project_id = task_handler.get_by_uuid(task_id).project_id except ValueError: return result_handler(consts.API_ERROR, 'no such task id') LOG.info('delete task in database') task_handler.delete_by_uuid(task_id) project_handler = V2ProjectHandler() project = project_handler.get_by_uuid(project_id) if project.tasks: LOG.info('update tasks in project') new_task_list = project.tasks.split(',') new_task_list.remove(task_id) if new_task_list: new_tasks = ','.join(new_task_list) else: new_tasks = None project_handler.update_attr(project_id, {'tasks': new_tasks}) return result_handler(consts.API_SUCCESS, {'task': task_id})
def delete(self, suite_name): suite_path = os.path.join(consts.TESTSUITE_DIR, '{}.yaml'.format(suite_name)) try: os.remove(suite_path) except IOError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'suite does not exist') return result_handler(consts.API_SUCCESS, {'testsuite': suite_name})
def delete(self, suite_name): suite_path = os.path.join(consts.TESTSUITE_DIR, '{}.yaml'.format(suite_name)) try: os.remove(suite_path) except IOError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'suite does not exist') return result_handler(consts.API_SUCCESS, {'testsuite': suite_name})
def get(self, suite_name): suite_path = os.path.join(consts.TESTSUITE_DIR, '{}.yaml'.format(suite_name)) try: with open(suite_path) as f: data = f.read() except IOError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'suite does not exist') return result_handler(consts.API_SUCCESS, {'testsuite': data})
def get(self, case_name): docs_path = os.path.join(consts.DOCS_DIR, '{}.rst'.format(case_name)) if not os.path.exists(docs_path): return result_handler(consts.API_ERROR, 'case not exists') LOG.info('Reading %s', case_name) with open(docs_path) as f: content = f.read() return result_handler(consts.API_SUCCESS, {'docs': content})
def get(self, suite_name): suite_path = os.path.join(consts.TESTSUITE_DIR, '{}.yaml'.format(suite_name)) try: with open(suite_path) as f: data = f.read() except IOError as e: if e.errno == errno.ENOENT: return result_handler(consts.API_ERROR, 'suite does not exist') return result_handler(consts.API_SUCCESS, {'testsuite': data})
def get(self, case_name): docs_path = os.path.join(consts.DOCS_DIR, '{}.rst'.format(case_name)) if not os.path.exists(docs_path): return result_handler(consts.API_ERROR, 'case not exists') LOG.info('Reading %s', case_name) with open(docs_path) as f: content = f.read() return result_handler(consts.API_SUCCESS, {'docs': content})
def upload_image(self, args): try: image_file = args['file'] except KeyError: return result_handler(consts.API_ERROR, 'file must be provided') try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') environment_handler = V2EnvironmentHandler() try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment') file_path = os.path.join(consts.IMAGE_DIR, image_file.filename) LOG.info('saving file') image_file.save(file_path) LOG.info('loading image') self._load_image(image_file.filename, file_path) LOG.info('creating image in DB') image_handler = V2ImageHandler() image_id = str(uuid.uuid4()) image_init_data = { 'uuid': image_id, 'name': image_file.filename, 'environment_id': environment_id } image_handler.insert(image_init_data) LOG.info('update image in environment') if environment.image_id: image_list = environment.image_id.split(',') image_list.append(image_id) new_image_id = ','.join(image_list) else: new_image_id = image_id environment_handler.update_attr(environment_id, {'image_id': new_image_id}) return result_handler(consts.API_SUCCESS, {'uuid': image_id})
def load_image(self, args): try: image_name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'image name must provided') if image_name not in IMAGE_MAP: return result_handler(consts.API_ERROR, 'wrong image name') thread = threading.Thread(target=self._do_load_image, args=(image_name, )) thread.start() return result_handler(consts.API_SUCCESS, {'image': image_name})
def upload_case(self, args): try: upload_file = args['file'] except KeyError: return result_handler(consts.API_ERROR, 'file must be provided') case_name = os.path.join(consts.TESTCASE_DIR, upload_file.filename) LOG.info('save case file') upload_file.save(case_name) return result_handler(consts.API_SUCCESS, {'testcase': upload_file.filename})
def put(self, task_id): try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task id') task_handler = V2TaskHandler() try: task_handler.get_by_uuid(task_id) except ValueError: return result_handler(consts.API_ERROR, 'no such task id') return self._dispatch_post(task_id=task_id)
def upload_image_by_url(self, args): try: url = args['url'] except KeyError: return result_handler(consts.API_ERROR, 'url must be provided') try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') environment_handler = V2EnvironmentHandler() try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment') thread = threading.Thread(target=self._do_upload_image_by_url, args=(url, )) thread.start() file_name = url.split('/')[-1] LOG.info('creating image in DB') image_handler = V2ImageHandler() image_id = str(uuid.uuid4()) image_init_data = { 'uuid': image_id, 'name': file_name, 'environment_id': environment_id } image_handler.insert(image_init_data) LOG.info('update image in environment') if environment.image_id: image_list = environment.image_id.split(',') image_list.append(image_id) new_image_id = ','.join(image_list) else: new_image_id = image_id environment_handler.update_attr(environment_id, {'image_id': new_image_id}) return result_handler(consts.API_SUCCESS, {'uuid': image_id})
def create_environment(self, args): try: name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'name must be provided') env_id = str(uuid.uuid4()) environment_handler = V2EnvironmentHandler() env_init_data = {'name': name, 'uuid': env_id} environment_handler.insert(env_init_data) return result_handler(consts.API_SUCCESS, {'uuid': env_id})
def add_params(self, args): task_id = args['task_id'] try: params = args['params'] except KeyError: return result_handler(consts.API_ERROR, 'params must be provided') LOG.info('update params info in task') task_handler = V2TaskHandler() task_update_data = {'params': jsonutils.dumps(params)} task_handler.update_attr(task_id, task_update_data) return result_handler(consts.API_SUCCESS, {'uuid': task_id})
def update_openrc(self, args): try: openrc_vars = args['openrc'] except KeyError: return result_handler(consts.API_ERROR, 'openrc must be provided') try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') LOG.info('writing openrc: %s', consts.OPENRC) makedirs(consts.CONF_DIR) lines = ['export {}={}\n'.format(k, v) for k, v in openrc_vars.items()] LOG.debug('writing: %s', ''.join(lines)) with open(consts.OPENRC, 'w') as f: f.writelines(lines) LOG.info('writing openrc: Done') LOG.info('source openrc: %s', consts.OPENRC) try: source_env(consts.OPENRC) except Exception: LOG.exception('source openrc failed') raise y_exc.UpdateOpenrcError() LOG.info('source openrc: Done') openrc_id = str(uuid.uuid4()) self._write_into_database(environment_id, openrc_id, openrc_vars) LOG.info('writing ansible cloud conf') try: self._generate_ansible_conf_file(openrc_vars) except Exception: LOG.exception('write cloud conf failed') raise y_exc.UpdateOpenrcError() LOG.info('finish writing ansible cloud conf') return result_handler(consts.API_SUCCESS, { 'openrc': openrc_vars, 'uuid': openrc_id })
def get(self, pod_id): try: uuid.UUID(pod_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid pod id') pod_handler = V2PodHandler() try: pod = pod_handler.get_by_uuid(pod_id) except ValueError: return result_handler(consts.API_ERROR, 'no such pod') content = jsonutils.loads(pod.content) return result_handler(consts.API_SUCCESS, {'pod': content})
def update_pod_file(self, args): try: pod_dic = args['pod'] except KeyError: return result_handler(consts.API_ERROR, 'pod must be provided') else: if not isinstance(pod_dic, collections.Mapping): return result_handler(consts.API_ERROR, 'pod should be a dict') LOG.info('Writing file') with open(consts.POD_FILE, 'w') as f: yaml.dump(pod_dic, f, default_flow_style=False) LOG.info('Writing finished') return result_handler(consts.API_SUCCESS, {'pod_info': pod_dic})
def get(self, pod_id): try: uuid.UUID(pod_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid pod id') pod_handler = V2PodHandler() try: pod = pod_handler.get_by_uuid(pod_id) except ValueError: return result_handler(consts.API_ERROR, 'no such pod') content = jsonutils.loads(pod.content) return result_handler(consts.API_SUCCESS, {'pod': content})
def update_pod_file(self, args): try: pod_dic = args['pod'] except KeyError: return result_handler(consts.API_ERROR, 'pod must be provided') else: if not isinstance(pod_dic, collections.Mapping): return result_handler(consts.API_ERROR, 'pod should be a dict') LOG.info('Writing file') with open(consts.POD_FILE, 'w') as f: yaml.dump(pod_dic, f, default_flow_style=False) LOG.info('Writing finished') return result_handler(consts.API_SUCCESS, {'pod_info': pod_dic})
def create_influxdb(self, args): try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment id') container_info = environment.container_id container_info = jsonutils.loads(container_info) if container_info else {} if container_info.get('influxdb'): return result_handler(consts.API_ERROR, 'influxdb container already exist') name = 'influxdb-{}'.format(environment_id[:8]) port = get_free_port(consts.SERVER_IP) container_id = str(uuid.uuid4()) LOG.info('%s will launch on : %s', name, port) LOG.info('launch influxdb background') args = (name, port, container_id) thread = threading.Thread(target=self._create_influxdb, args=args) thread.start() LOG.info('record container in database') container_init_data = { 'uuid': container_id, 'environment_id': environment_id, 'name': name, 'port': port, 'status': 0 } container_handler.insert(container_init_data) LOG.info('update container in environment') container_info['influxdb'] = container_id environment_info = {'container_id': jsonutils.dumps(container_info)} environment_handler.update_attr(environment_id, environment_info) return result_handler(consts.API_SUCCESS, {'uuid': container_id})
def create_influxdb(self, args): try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment id') container_info = environment.container_id container_info = jsonutils.loads(container_info) if container_info else {} if container_info.get('influxdb'): return result_handler(consts.API_ERROR, 'influxdb container already exist') name = 'influxdb-{}'.format(environment_id[:8]) port = get_free_port(consts.SERVER_IP) container_id = str(uuid.uuid4()) LOG.info('%s will launch on : %s', name, port) LOG.info('launch influxdb background') args = (name, port, container_id) thread = threading.Thread(target=self._create_influxdb, args=args) thread.start() LOG.info('record container in database') container_init_data = { 'uuid': container_id, 'environment_id': environment_id, 'name': name, 'port': port, 'status': 0 } container_handler.insert(container_init_data) LOG.info('update container in environment') container_info['influxdb'] = container_id environment_info = {'container_id': jsonutils.dumps(container_info)} environment_handler.update_attr(environment_id, environment_info) return result_handler(consts.API_SUCCESS, {'uuid': container_id})
def create_grafana(self, *args): task_id = str(uuid.uuid4()) thread = threading.Thread(target=self._create_grafana, args=(task_id,)) thread.start() return result_handler(consts.API_SUCCESS, {'task_id': task_id})
def get(self): param = Param({}) testsuite_list = Testsuite().list_all(param) data = {'testsuites': testsuite_list} return result_handler(consts.API_SUCCESS, data)
def get(self): args = self._get_args() try: task_id = args['task_id'] except KeyError: return result_handler(consts.API_ERROR, 'task_id must be provided') try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') task_handler = TasksHandler() try: task = task_handler.get_task_by_taskid(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') def _unfinished(): return result_handler(consts.TASK_NOT_DONE, {}) def _finished(): if task.result: return result_handler(consts.TASK_DONE, json.loads(task.result)) else: return result_handler(consts.TASK_DONE, {}) def _error(): return result_handler(consts.TASK_FAILED, task.error) status = task.status LOG.debug('Task status is: %s', status) if status not in [ consts.TASK_NOT_DONE, consts.TASK_DONE, consts.TASK_FAILED ]: return result_handler(consts.API_ERROR, 'internal server error') switcher = { consts.TASK_NOT_DONE: _unfinished, consts.TASK_DONE: _finished, consts.TASK_FAILED: _error } return switcher.get(status)()
def get(self): args = self._get_args() try: task_id = args['task_id'] except KeyError: return result_handler(consts.API_ERROR, 'task_id must be provided') try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') task_handler = TasksHandler() try: task = task_handler.get_task_by_taskid(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task_id') def _unfinished(): return result_handler(consts.TASK_NOT_DONE, {}) def _finished(): if task.result: return result_handler(consts.TASK_DONE, json.loads(task.result)) else: return result_handler(consts.TASK_DONE, {}) def _error(): return result_handler(consts.TASK_FAILED, task.error) status = task.status LOG.debug('Task status is: %s', status) if status not in [consts.TASK_NOT_DONE, consts.TASK_DONE, consts.TASK_FAILED]: return result_handler(consts.API_ERROR, 'internal server error') switcher = { consts.TASK_NOT_DONE: _unfinished, consts.TASK_DONE: _finished, consts.TASK_FAILED: _error } return switcher.get(status)()
def update_hosts(self, hosts_ip): if not isinstance(hosts_ip, collections.Mapping): return result_handler(consts.API_ERROR, 'args should be a dict') LOG.info('Writing hosts: Writing') LOG.debug('Writing: %s', hosts_ip) cmd = ["sudo", "python", "write_hosts.py"] p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=os.path.join(consts.REPOS_DIR, "api/resources")) _, err = p.communicate(jsonutils.dumps(hosts_ip)) if p.returncode != 0: return result_handler(consts.API_ERROR, err) LOG.info('Writing hosts: Done') return result_handler(consts.API_SUCCESS, 'success')
def upload_pod_file(self, args): try: pod_file = args['file'] except KeyError: return result_handler(consts.API_ERROR, 'file must be provided') LOG.info('Checking file') data = yaml_load(pod_file.read()) if not isinstance(data, collections.Mapping): return result_handler(consts.API_ERROR, 'invalid yaml file') LOG.info('Writing file') with open(consts.POD_FILE, 'w') as f: yaml.dump(data, f, default_flow_style=False) LOG.info('Writing finished') return result_handler(consts.API_SUCCESS, {'pod_info': data})
def prepare_env(self, *args): task_id = str(uuid.uuid4()) thread = threading.Thread(target=self._prepare_env_daemon, args=(task_id,)) thread.start() return result_handler(consts.API_SUCCESS, {'task_id': task_id})
def get(self, project_id): try: uuid.UUID(project_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid project id') project_handler = V2ProjectHandler() try: project = project_handler.get_by_uuid(project_id) except ValueError: return result_handler(consts.API_ERROR, 'no such project id') project_info = change_obj_to_dict(project) tasks = project_info['tasks'] project_info['tasks'] = tasks.split(',') if tasks else [] return result_handler(consts.API_SUCCESS, {'project': project_info})
def create_environment(self, args): try: name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'name must be provided') env_id = str(uuid.uuid4()) environment_handler = V2EnvironmentHandler() env_init_data = { 'name': name, 'uuid': env_id } environment_handler.insert(env_init_data) return result_handler(consts.API_SUCCESS, {'uuid': env_id})
def get(self, openrc_id): try: uuid.UUID(openrc_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid openrc id') LOG.info('Geting openrc: %s', openrc_id) openrc_handler = V2OpenrcHandler() try: openrc = openrc_handler.get_by_uuid(openrc_id) except ValueError: return result_handler(consts.API_ERROR, 'no such openrc id') LOG.info('load openrc content') content = jsonutils.loads(openrc.content) return result_handler(consts.API_ERROR, {'openrc': content})
def get(self, task_id): try: uuid.UUID(task_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid task id') task_handler = V2TaskHandler() try: task = task_handler.get_by_uuid(task_id) except ValueError: return result_handler(consts.API_ERROR, 'no such task id') task_info = change_obj_to_dict(task) result = task_info['result'] task_info['result'] = jsonutils.loads(result) if result else None return result_handler(consts.API_SUCCESS, {'task': task_info})
def get(self, openrc_id): try: uuid.UUID(openrc_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid openrc id') LOG.info('Geting openrc: %s', openrc_id) openrc_handler = V2OpenrcHandler() try: openrc = openrc_handler.get_by_uuid(openrc_id) except ValueError: return result_handler(consts.API_ERROR, 'no such openrc id') LOG.info('load openrc content') content = jsonutils.loads(openrc.content) return result_handler(consts.API_ERROR, {'openrc': content})
def create_grafana(self, *args): task_id = str(uuid.uuid4()) thread = threading.Thread(target=self._create_grafana, args=(task_id, )) thread.start() return result_handler(consts.API_SUCCESS, {'task_id': task_id})
def get(self): param = Param({}) testsuite_list = Testsuite().list_all(param) data = { 'testsuites': testsuite_list } return result_handler(consts.API_SUCCESS, data)
def get(self): project_handler = V2ProjectHandler() projects = [change_obj_to_dict(p) for p in project_handler.list_all()] for p in projects: tasks = p['tasks'] p['tasks'] = tasks.split(',') if tasks else [] return result_handler(consts.API_SUCCESS, {'projects': projects})
def create_project(self, args): try: name = args['name'] except KeyError: return result_handler(consts.API_ERROR, 'name must be provided') project_id = str(uuid.uuid4()) create_time = datetime.now() project_handler = V2ProjectHandler() project_init_data = { 'uuid': project_id, 'name': name, 'time': create_time } project_handler.insert(project_init_data) return result_handler(consts.API_SUCCESS, {'uuid': project_id})
def delete(self, pod_id): try: uuid.UUID(pod_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid pod id') pod_handler = V2PodHandler() try: pod = pod_handler.get_by_uuid(pod_id) except ValueError: return result_handler(consts.API_ERROR, 'no such pod') LOG.info('update pod in environment') environment_handler = V2EnvironmentHandler() environment_handler.update_attr(pod.environment_id, {'pod_id': None}) LOG.info('delete pod in database') pod_handler.delete_by_uuid(pod_id) return result_handler(consts.API_SUCCESS, {'pod': pod_id})
def delete(self, openrc_id): try: uuid.UUID(openrc_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid openrc id') LOG.info('Geting openrc: %s', openrc_id) openrc_handler = V2OpenrcHandler() try: openrc = openrc_handler.get_by_uuid(openrc_id) except ValueError: return result_handler(consts.API_ERROR, 'no such openrc id') LOG.info('update openrc in environment') environment_handler = V2EnvironmentHandler() environment_handler.update_attr(openrc.environment_id, {'openrc_id': None}) openrc_handler.delete_by_uuid(openrc_id) return result_handler(consts.API_SUCCESS, {'openrc': openrc_id})
def delete(self, environment_id): try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') environment_handler = V2EnvironmentHandler() try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment id') if environment.openrc_id: LOG.info('delete openrc: %s', environment.openrc_id) openrc_handler = V2OpenrcHandler() openrc_handler.delete_by_uuid(environment.openrc_id) if environment.pod_id: LOG.info('delete pod: %s', environment.pod_id) pod_handler = V2PodHandler() pod_handler.delete_by_uuid(environment.pod_id) if environment.container_id: LOG.info('delete containers') container_info = jsonutils.loads(environment.container_id) container_handler = V2ContainerHandler() client = Client(base_url=consts.DOCKER_URL) for k, v in container_info.items(): LOG.info('start delete: %s', k) container = container_handler.get_by_uuid(v) LOG.debug('container name: %s', container.name) try: client.remove_container(container.name, force=True) except Exception: LOG.exception('remove container failed') container_handler.delete_by_uuid(v) environment_handler.delete_by_uuid(environment_id) return result_handler(consts.API_SUCCESS, {'environment': environment_id})
def run_test_case(self, args): try: name = args['testcase'] except KeyError: return result_handler(consts.API_ERROR, 'testcase must be provided') testcase = os.path.join(consts.SAMPLE_CASE_DIR, '{}.yaml'.format(name)) task_id = str(uuid.uuid4()) task_args = { 'inputfile': [testcase], 'task_id': task_id } task_args.update(args.get('opts', {})) param = Param(task_args) task_thread = TaskThread(Task().start, param, TasksHandler()) task_thread.start() return result_handler(consts.API_SUCCESS, {'task_id': task_id})
def get(self, environment_id): try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') environment_handler = V2EnvironmentHandler() try: environment = environment_handler.get_by_uuid(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'no such environment id') environment = change_obj_to_dict(environment) container_id = environment['container_id'] environment['container_id'] = jsonutils.loads(container_id) if container_id else {} image_id = environment['image_id'] environment['image_id'] = image_id.split(',') if image_id else [] return result_handler(consts.API_SUCCESS, {'environment': environment})
def upload_pod_file(self, args): try: upload_file = args['file'] except KeyError: return result_handler(consts.API_ERROR, 'file must be provided') try: environment_id = args['environment_id'] except KeyError: return result_handler(consts.API_ERROR, 'environment_id must be provided') try: uuid.UUID(environment_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid environment id') LOG.info('writing pod file: %s', consts.POD_FILE) upload_file.save(consts.POD_FILE) with open(consts.POD_FILE) as f: data = yaml_load(TaskTemplate.render(f.read())) LOG.debug('pod content is: %s', data) LOG.info('create pod in database') pod_id = str(uuid.uuid4()) pod_handler = V2PodHandler() pod_init_data = { 'uuid': pod_id, 'environment_id': environment_id, 'content': jsonutils.dumps(data) } pod_handler.insert(pod_init_data) LOG.info('update pod in environment') environment_handler = V2EnvironmentHandler() environment_handler.update_attr(environment_id, {'pod_id': pod_id}) return result_handler(consts.API_SUCCESS, {'uuid': pod_id, 'pod': data})
def get(self, container_id): try: uuid.UUID(container_id) except ValueError: return result_handler(consts.API_ERROR, 'invalid container id') try: container = container_handler.get_by_uuid(container_id) except ValueError: return result_handler(consts.API_ERROR, 'no such container id') name = container.name client = Client(base_url=consts.DOCKER_URL) info = client.inspect_container(name) data = { 'name': name, 'status': info.get('State', {}).get('Status', 'error'), 'time': info.get('Created'), 'port': container.port } return result_handler(consts.API_SUCCESS, {'container': data})
def get(self): environment_handler = V2EnvironmentHandler() environments = [change_obj_to_dict(e) for e in environment_handler.list_all()] for e in environments: container_info = e['container_id'] e['container_id'] = jsonutils.loads(container_info) if container_info else {} image_id = e['image_id'] e['image_id'] = image_id.split(',') if image_id else [] data = { 'environments': environments } return result_handler(consts.API_SUCCESS, data)