def add_task(self, service_name, command): """ current supported commands are: stop, restart, undeploy_tars, patch_tars """ utilities.log_debug("add_task for service %s, command is %s" % (service_name, command)) (ret, server_id) = self.get_server_id(service_name, self.deploy_ip) if ret is False: utilities.log_error( "%s failed for get server id failed, please check the existence of %s" % (command, service_name)) return False items = [{ "server_id": server_id, "command": command, "parameters": {} }] request_data = {"serial": 'true', "items": items} response = requests.post(self.add_task_url, params=self.token_param, json=request_data) if TarsService.parse_response("execute command " + command, response) is False: utilities.log_error( "add_task failed for error response, server name: %s, msg: %s" % (service_name, response.content)) return False return True
def get_config_file_id(self, config_file_name, server_name, node_name): (ret, server_config_id) = self.get_server_config_file_id( config_file_name, server_name) if ret is False: return (False, 0) params = { "ticket": self.tars_token, "config_id": server_config_id, "level": TarsService.get_level(server_name), "application": self.app_name, "server_name": server_name, "set_name": "", "set_area": "", "set_group": "" } response = requests.get(self.node_config_file_list_url, params=params) if TarsService.parse_response( "query the node config file id for " + config_file_name, response) is False: return (False, 0) result = response.json() if "data" not in result or len(result["data"]) == 0: utilities.log_debug("the config %s doesn't exist" % (config_file_name)) return (False, 0) # try to find the config file info for item in result["data"]: if "filename" in item and item[ "filename"] == config_file_name and item[ "node_name"] == node_name: return (True, item["id"]) utilities.log_error( "the node config file %s not found, node: %s, :%s:" % (config_file_name, node_name, str(result["data"]))) return (False, 0)
def patch_tars(self, server_id, patch_id): utilities.log_debug( "patch tars for application %s, server_id: %s, patch_id: %s" % (self.app_name, server_id, patch_id)) items = [{ "server_id": server_id, "command": "patch_tars", "parameters": { "patch_id": patch_id, "bak_flag": 'false', "update_text": "", "group_name": "" } }] request_data = {"serial": 'true', "items": items} response = requests.post(self.add_task_url, params=self.token_param, json=request_data) if TarsService.parse_response("patch tars ", response) is False: utilities.log_error( "patch tars failed for error response, server id: %s, msg: %s" % (server_id, response.content)) return False utilities.log_debug("patch tars response %s" % response.content) return True
def add_non_empty_server_config_file(self, config_file_name, server_name, config_file_path): "add server the config file" utilities.log_debug( "add config file for application %s, config file path: %s, service_name: %s" % (self.app_name, config_file_path, server_name)) ret = self.add_server_config_file(config_file_name, server_name, config_file_path, False) if ret is False: ret = self.update_service_config(config_file_name, server_name, "", config_file_path) return ret
def create_application(self): "create application" if self.app_exists() is True: # utilities.log_error( # "application %s already exists" % self.app_name) return False utilities.log_debug("create application: %s" % self.app_name) request_data = {'f_name': self.app_name} response = requests.post(self.add_application_url, params=self.token_param, data=request_data) return TarsService.parse_response( "create application " + self.app_name, response)
def add_config_file(self, config_file_name, server_name, node_name, config_file_path, empty_server_config): "add the config file" (ret, id) = self.get_server_config_file_id(config_file_name, server_name) if ret is False: utilities.log_debug( "add config file for application %s, config file path: %s, service_name: %s" % (self.app_name, config_file_path, server_name)) self.add_server_config_file(config_file_name, server_name, config_file_path, empty_server_config) return self.update_service_config(config_file_name, server_name, node_name, config_file_path)
def get_server_config_file_id(self, config_file_name, server_name): utilities.log_debug("query the config file id for %s" % config_file_name) params = { "ticket": self.tars_token, "level": TarsService.get_level(server_name), "application": self.app_name, "server_name": server_name, "set_name": "", "set_area": "", "set_group": "" } response = requests.get(self.config_file_list_url, params=params) if TarsService.parse_response( "query the config file id for " + config_file_name, response) is False: return (False, 0) result = response.json() if "data" not in result or len(result["data"]) == 0: utilities.log_debug( "the config file id not found for %s because of empty return data, response: %s" % (config_file_name, response.content)) return (False, 0) # try to find the config file info for item in result["data"]: if "filename" in item and item["filename"] == config_file_name: utilities.log_debug( "get_server_config_file_id, server: %s, config_id: %s" % (server_name, item["id"])) return (True, item["id"]) utilities.log_debug("the config file %s not found" % config_file_name) return (False, 0)
def get_server_patch(self, task_id): utilities.log_debug("get server patch, task_id: %s" % task_id) params = {"task_id": task_id, "ticket": self.tars_token} response = requests.get(self.get_server_patch_url, params=params) if TarsService.parse_response("get server patch", response) is False: return (False, "") if response.status_code != 200: return (False, "") # get the id result = response.json() result_data = result['data'] if 'id' not in result_data: utilities.log_error( "get_server_patch failed for empty return message") return (False, "") id = result_data['id'] return (True, id)
def upload_tars_package(self, service_name, package_path): """ upload the tars package """ package_name = service_name + ServiceInfo.tars_pkg_postfix utilities.log_debug( "upload tars package for service %s, package_path: %s, package_name: %s" % (service_name, package_path, package_name)) if os.path.exists(package_path) is False: utilities.log_error( "upload tars package for service %s failed for the path %s not exists" % (service_name, package_path)) return (False, 0) task_id = str(uuid.uuid4()) form_data = MultipartEncoder( fields={ "application": self.app_name, "task_id": task_id, "module_name": service_name, "comment": "upload package", "suse": (package_name, open(package_path, 'rb'), 'text/plain/binary') }) response = requests.post( self.upload_package_url, data=form_data, params=self.token_param, headers={'Content-Type': form_data.content_type}) if TarsService.parse_response("upload tars package " + package_path, response) is False: return (False, 0) # get the id (ret, id) = self.get_server_patch(task_id) if ret is True: utilities.log_info("upload tar package %s success, config id: %s" % (package_path, id)) return (ret, id)
def add_config_list(self, config_list, service_name, node_name, config_file_list, empty_server_config): i = 0 for config_file_path in config_file_list: config = config_list[i] utilities.log_info( "* add config for service %s, node: %s, config: %s" % (service_name, node_name, config)) utilities.log_debug( "add config for service %s, node: %s, config: %s, path: %s" % (service_name, node_name, config, config_file_path)) if self.add_config_file(config, service_name, node_name, config_file_path, empty_server_config) is False: utilities.log_error( "add_config_list failed, config files info: %s" % config_list) return False i = i + 1 return True
def update_service_config(self, config_file_name, server_name, node_name, config_file_path): utilities.log_debug( "update config file for application %s, config file path: %s, node: %s" % (self.app_name, config_file_path, node_name)) if os.path.exists(config_file_path) is False: utilities.log_error( "update service config error:\n the config file %s doesn't exist, service: %s" % (config_file_path, server_name)) return False ret = True config_id = 0 if len(node_name) == 0: (ret, config_id) = self.get_server_config_file_id( config_file_name, server_name) else: ret, config_id = self.get_config_file_id(config_file_name, server_name, node_name) if ret is False: return False try: fp = open(config_file_path) content = fp.read() except OSError as reason: utilities.log_error("load the configuration failed, error: %s" % str(reason)) request_data = { "id": config_id, "config": content, "reason": "update config file" } response = requests.post(self.update_config_url, params=self.token_param, json=request_data) if TarsService.parse_response( "update config file for application " + self.app_name + ", config file:" + config_file_name, response) is False: return False return True
def get_node_auto_port(self, node_name): # get the auto_port utilities.log_debug("get the un-occuppied port") params = {"node_name": node_name, "ticket": self.tars_token} response = requests.get(self.get_port_url, params=params) if TarsService.parse_response("get the un-occupied port", response) is False: return (False, 0) result = response.json() if 'data' not in result: utilities.log_error("get empty un-occupied port") return (False, 0) node_info = result['data'] if len(node_info) <= 0: utilities.log_error("get empty un-occupied port") return (False, 0) if 'port' not in node_info[0]: utilities.log_error("get empty un-occupied port") return (False, 0) port = node_info[0]['port'] utilities.log_debug("get the un-occupied port success, port: %s" % (port)) return (True, int(port))
def fetch_server_config_file(self, config_file_name, server_name): (ret, config_id) = self.get_server_config_file_id(config_file_name, server_name) if ret is False: utilities.log_error( "fetch server config file failed, please check the existence of specified service, service: %s, config: %s" % (server_name, config_file_name)) return (False, "") param = {"ticket": self.tars_token, "id": config_id} response = requests.get(self.fetch_config_url, params=param) if TarsService.parse_response("fetch service config " + server_name, response) is False: return (False, "") utilities.log_debug("fetch service config file success, response: %s" % response.content) result = response.json() if "data" not in result or "config" not in result["data"]: utilities.log_error( "fetch service config file failed, response %s" % response.content) return (False, "") return (True, result["data"]["config"])