def http_login(host_name, host_ip, local_ip, tunnel_index):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(
r'apiv1/hosts/sessions/')
json_body = json.dumps({
'host_ident': host_name,
'host_ip': host_ip,
'local_ip': local_ip,
'tunnel_index': tunnel_index
})
response = requests.post(f_url,
headers={
'Content-Type': 'application/json',
'x-csrftoken': csrf_token
},
data=json_body,
cookies=secure_cookie)
if http_status.is_success(response.status_code):
return True
elif response.status_code == http_status.HTTP_429_TOO_MANY_REQUESTS:
return False
else:
error_description = r'客户端登陆失败：{}'.format(response.status_code)
error_debug = r'http_login call web api failed. [{}] :{}'.format(
f_url, response.status_code)
xlogging.raise_system_error(error_description, error_debug,
response.status_code, _logger)
def http_query_host_soft_ident(host_name):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(
r'apiv1/hosts/{}'.format(host_name))
r = requests.get(f_url,
headers={
'content-type': 'application/json; charset=utf-8',
'x-csrftoken': csrf_token
},
data='',
cookies=secure_cookie)
if http_status.is_success(r.status_code):
soft_ident = r.json().get('soft_ident', '')
if soft_ident:
return soft_ident
else:
xlogging.raise_system_error(r'无效的客户端标识',
r'http_query_host_soft_ident empty', 0,
_logger)
else:
error_description = '获取客户端标识失败：{}'.format(r.status_code)
error_debug = 'http_query_host_soft_ident call web api failed. [{}] :{}'.format(
f_url, r.status_code)
xlogging.raise_system_error(error_description, error_debug,
r.status_code, _logger)
def http_refresh_token(token):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(
r'apiv1/tokens/{}/'.format(token))
response = requests.get(f_url,
headers={
'Content-Type': 'application/json',
'x-csrftoken': csrf_token
},
cookies=secure_cookie)
if http_status.is_success(response.status_code):
pass
else:
error_description = r'获取Token信息失败，错误代码：{}'.format(response.status_code)
error_debug = r'http_refresh_token failed. [{}] :{}'.format(
f_url, response.status_code)
if xlogging.logger_traffic_control.is_logger_print(
'http_refresh_token__error', token):
xlogging.raise_system_error(error_description, error_debug,
response.status_code, _logger)
else:
xlogging.raise_system_error_without_logger(error_description,
error_debug,
response.status_code)
if xlogging.logger_traffic_control.is_logger_print(
'http_refresh_token__debug', token):
_logger.debug('http_refresh_token, input args: {}'.format(token))
def http_report_restore_status(token, progress, finished, host_ident=None):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(
r'apiv1/tokens/{}/'.format(token))
json_body = json.dumps({
'remainingBytes': progress.remainingBytes,
'totalBytes': progress.totalBytes,
'finished': finished,
'successful': True,
'host_ident': host_ident
})
response = requests.put(f_url,
headers={
'Content-Type': 'application/json',
'x-csrftoken': csrf_token
},
data=json_body,
cookies=secure_cookie)
if http_status.is_success(response.status_code):
return
else:
error_description = r'更新还原进度失败，错误代码：{}'.format(response.status_code)
error_debug = r'http_report_restore_status failed. [{}] :{}'.format(
f_url, response.status_code)
xlogging.raise_system_error(error_description, error_debug,
response.status_code, _logger)
def http_pe_host_login(disk_info_list, remoteAddress, localAddress,
boot_disk_id, login_type, tunnel_index, more_info):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(
r'apiv1/pe_hosts/sessions/')
disks = list()
for disk in disk_info_list:
disks.append(disk.__dict__)
json_body = json.dumps({
'disks': disks,
'remote_ip': remoteAddress,
'local_ip': localAddress,
'boot_disk_id': boot_disk_id,
'login_type': login_type,
'tunnel_index': tunnel_index,
'more_info': more_info,
})
response = requests.post(f_url,
headers={
'Content-Type': 'application/json',
'x-csrftoken': csrf_token
},
data=json_body,
cookies=secure_cookie)
if http_status.is_success(response.status_code):
return response.json()['ident']
else:
error_description = r'还原目标客户端登陆失败：{}'.format(response.status_code)
error_debug = r'http_pe_host_login call web api failed. [{}] :{}'.format(
f_url, response.status_code)
xlogging.raise_system_error(error_description, error_debug,
response.status_code, _logger)
def http_report_backup_progress(host_name, progress):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(
r'apiv1/hosts/sessions/{}/backup/'.format(host_name))
response = requests.put(f_url,
data=json.dumps({
'code':
progress.code.value,
'progressIndex':
progress.progressIndex,
'progressTotal':
progress.progressTotal
}),
headers={
'Content-Type': 'application/json',
'x-csrftoken': csrf_token
},
cookies=secure_cookie)
if http_status.is_success(response.status_code):
return
else:
error_description = r'提交备份进度失败：{}'.format(response.status_code)
error_debug = r'http_report_backup_progress call web api failed. [{}] :{}'.format(
f_url, response.status_code)
xlogging.raise_system_error(error_description, error_debug,
response.status_code, _logger)
def http_query_host_name(ident, host_name, user_ident, sysinfo):
global _logger
secure_cookie, csrf_token, f_url = authCookies.get(r'apiv1/hosts/')
json_body = json.dumps({
'user_ident': user_ident,
'macs': ident.Hardware,
'host_name': host_name,
'sysinfo': sysinfo
})
r = requests.post(f_url,
headers={
'content-type': 'application/json; charset=utf-8',
'x-csrftoken': csrf_token
},
data=json_body,
cookies=secure_cookie)
if http_status.is_success(r.status_code):
return r.json()['ident']
else:
error_description = '获取客户端标识号失败：{}'.format(r.status_code)
error_debug = 'http_query_host_name call web api failed. [{}] :{}'.format(
f_url, r.status_code)
xlogging.raise_system_error(error_description, error_debug,
r.status_code, _logger)
def refresh(self_call=False):
global _cookies, _username, _password, _csrftoken, _logger
_logger.info(r'refresh cookies ...')
url_login = _url + r'api-auth/login/'
web_login_get = requests.get(url_login)
if web_login_get.status_code == http_status.HTTP_200_OK:
csrftoken = web_login_get.cookies['csrftoken']
login_data = {
'username': _username,
'password': _password,
'csrfmiddlewaretoken': csrftoken
}
login_cookies = dict(csrftoken=web_login_get.cookies['csrftoken'])
web_login_post = requests.post(url_login,
allow_redirects=False,
data=login_data,
cookies=login_cookies)
if web_login_post.status_code == http_status.HTTP_302_FOUND:
_cookies = web_login_post.cookies
_logger.info('refresh cookies ok')
elif web_login_post.status_code == http_status.HTTP_200_OK and not self_call:
_logger.error('refresh cookies failed. super user Not exist!')
refresh(True)
else:
xlogging.raise_system_error('无法通过Web组件验证',
'refresh cookies post failed',
web_login_post.status_code, _logger)
else:
xlogging.raise_system_error('无法连接到Web组件', 'refresh cookies get failed',
web_login_get.status_code, _logger)
def _start_logic(self, runner_dir):
self._check_func()
work_dir = os.path.join(runner_dir, 'agent_application')
cmd = r'{} application_main.py'.format(self._python_path)
self.logger.info('fetch_patch cmd : {} work_dir : {}'.format(
cmd, work_dir))
try:
rc = json.loads(self._get_loader_prx().popen(
json.dumps({
'async': True,
'shell': False,
'cmd': cmd,
'work_dir': work_dir,
'timeouts_seconds': None
})))
except Exception as e:
xlogging.raise_system_error(r'启动备份代理失败',
'start_logic {}'.format(e),
1,
logger=self.logger)
raise # fix pycharm warn
logger_msg = r'start_logic rc : {}'.format(rc)
if not rc['pid']:
xlogging.raise_system_error(r'启动备份代理失败',
logger_msg,
1,
logger=self.logger)
else:
self.logger.info(logger_msg)
def pull_file(self, remote_relative_path, local_file_path):
try:
sftp = self.ssh.open_sftp()
sftp.get(self.get_full_path_by_relative(remote_relative_path), local_file_path)
sftp.close()
except Exception as e:
xlogging.raise_system_error(r'获取文件失败', r'push_files failed {}'.format(e), 0, _logger)
def create_nbd_device(self):
if not self._host_params['disksnapshots']:
xlogging.raise_system_error('参数错误, 无效的磁盘信息', 'no disk info', 3036)
vnc_address = None
for disk_info in self._host_params['disksnapshots']:
_nbd_type = disk_info.get('nbd_type', 'nbdrw')
nbd_object = nbdrwthread.NbdReadWriteThread()
_nbd_dev_name, _nbd_dev_number = nbd_object.get_nbd_device_name()
if _nbd_type == 'nbdrw':
_cmd_nbd_umount = "/sbin/aio/nbdrw -d {}".format(_nbd_dev_name)
_cmd_nbd_mount = "/sbin/aio/nbdrw -rw {} {}".format(
_nbd_dev_name, disk_info['disk_bytes'])
elif _nbd_type == 'gznbd':
_cmd_nbd_umount = "/sbin/aio/gznbd -d {}".format(_nbd_dev_name)
_cmd_nbd_mount = "/sbin/aio/gznbd -c {}".format(_nbd_dev_name)
else:
xlogging.raise_system_error(
'未知的nbd类型', 'not support nbd type : {}'.format(_nbd_type),
2055)
return
for _disk_snapshot in disk_info['images']:
_cmd_nbd_mount += r' {} {}'.format(_disk_snapshot['path'],
_disk_snapshot['ident'])
nbd_object.setDaemon(True)
nbd_object.set_scsi_id(disk_info.get('scsi_id', uuid.uuid4().hex))
nbd_object.start_and_wait_ready(_cmd_nbd_mount, _cmd_nbd_umount)
if vnc_address is None:
if os.path.exists('/dev/shm/debug_vnc'):
vnc_address = '0.0.0.0:{}'.format(200 + _nbd_dev_number)
else:
vnc_address = '127.0.0.1:{}'.format(200 + _nbd_dev_number)
self._nbds.append(nbd_object)
return vnc_address
def start_logic(self, ip, timeout_seconds, runner_dir):
self._check_quit()
work_dir = os.path.join(runner_dir, 'FileBackupLogic')
cmd = r'/usr/bin/python3 FileBackupLogicMain.py'
self.logger.info('fetch_patch cmd : {} work_dir : {}'.format(
cmd, work_dir))
try:
rc = json.loads(self._get_loader_prx().popen(
json.dumps({
'async': True,
'shell': False,
'cmd': cmd,
'work_dir': work_dir,
'timeouts_seconds': None
})))
except Exception as e:
xlogging.raise_system_error(r'启动备份代理失败',
'start_logic {}'.format(e),
1,
logger=self.logger)
raise # fix pycharm warn
logger_msg = r'start_logic rc : {}'.format(rc)
if not rc['pid']:
xlogging.raise_system_error(r'启动备份代理失败',
logger_msg,
1,
logger=self.logger)
else:
self.logger.info(logger_msg)
self._check_connct(ip, timeout_seconds, self._get_prx, False)
self._set_flag_with_lock('_backup_logic_running')
def _check_quit(self):
with self._locker:
if self._quit:
xlogging.raise_system_error(r'用户取消操作',
'self._quit',
1,
logger=self.logger)
def _run_kvm(self):
kvm_cmd = self.__kvm_cmd_mgr.generate_kvm_cmd_line()
alloc_success = False
while not alloc_success:
alloc_success = all_big_mm.CAllocBigMM.try_alloc(self.__kvm_cmd_mgr.get_memory_mbyte())
if not alloc_success:
_logger.warning(r'alloc mem for kvm failed,will retry')
if self.__kvm_cmd_mgr.is_aio_sys_vt_valid():
cwd = None
else:
cwd = r'/sbin/aio/qemu-nokvm' # 非vt下需要指定工作路径 否则出错
# shlex.split(kvm_cmd)
# use exec will not create two process
self._process = subprocess.Popen('exec ' + kvm_cmd, cwd=cwd, shell=True, stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
universal_newlines=True)
if self._process.poll() is None:
_logger.info('KvmHandle start kvm PID:{} {}'.format(self._process.pid, kvm_cmd))
else:
msg = 'start kvm error {}|{}|{}'.format(self._process.returncode, *self._process.communicate())
xlogging.raise_system_error('启动虚拟机失败', msg, 1111)
def set_root_passwd(passwdinfo):
cmdline = 'mount -no remount, rw /boot'
retval = net_common.get_info_from_syscmd(cmdline)
_logger.debug('remount /boot {} {}'.format(retval[0], retval[1]))
tmpfile = '/dev/shm/tempstr'
mpasswd = json.loads(passwdinfo)
_logger.debug("set root pwd info {} {}".format(passwdinfo, mpasswd))
retval = net_common.set_info_to_file(tmpfile, mpasswd, 'w')
if retval != 0:
_logger.error('set passwd write file failed,ret {}'.format(retval))
xlogging.raise_system_error('set passwd failed,{}'.format(retval),
'set passwd failed,{}'.format(retval), -1,
_logger)
cmdline = 'set_passwd -f {}'.format(tmpfile)
retval = net_common.get_info_from_syscmd(cmdline)
if retval[0] != 0:
_logger.error('set passwd failed,ret {} {}'.format(
retval[0], retval[1]))
xlogging.raise_system_error('set passwd failed,{}'.format(retval[0]),
'set passwd failed,{}'.format(retval[0]),
-1, _logger)
else:
_logger.debug('set passwd success')
cmdline = 'umount /boot'
retval = net_common.get_info_from_syscmd(cmdline)
_logger.debug('umount /boot {} {}'.format(retval[0], retval[1]))
cmdline = 'mount -o ro /dev/mapper/boot /boot'
retval = net_common.get_info_from_syscmd(cmdline)
_logger.debug('mount /dev/mapper/boot /boot {} {}'.format(
retval[0], retval[1]))
def mount_with_box_service(self, peHostIdent, diskToken, diskBytes):
try:
if self.is_mount:
xlogging.raise_system_error(
r'内部错误，重复挂载虚拟磁盘设备',
r'mount_with_box_service is_mount {}'.format(
self.device_path), self.device_index, _logger)
nbd_wrapper.check_unused(self.device_name)
if nbd_wrapper.nbd_read_ok(self.device_path):
xlogging.raise_system_error(
r'内部错误，挂载虚拟磁盘设备重复',
r'mount_with_box_service nbd_read_ok {}'.format(
self.device_path), self.device_index, _logger)
cmd_nbd = "{} -b {} {} {} {:d} 5".format(_EXEC_PATH,
self.device_path,
peHostIdent, diskToken,
diskBytes)
split_nbd_cmd = shlex.split(cmd_nbd)
with subprocess.Popen(split_nbd_cmd,
stderr=subprocess.PIPE,
universal_newlines=True) as p:
self.is_mount = True
_logger.info("mount_with_box_service pid:{} {} ".format(
p.pid, cmd_nbd))
for line in p.stderr:
_nbd_logger.debug('{}:{}'.format(p.pid, line.rstrip()))
_logger.info("mount_with_box_service end : pid:{} - {}".format(
p.pid, p.returncode))
finally:
self.is_mount = False
def fetch_patch(self, ip_address):
self.create_patch_dir()
if self._logic == 'windows':
icepatch2client = r'%SYSTEMDRIVE%\icepatch2\icepatch2client'
else:
icepatch2client = r'/usr/bin/icepatch2client'
cmd = r'{icepatch2client} -t' \
r' --IcePatch2Client.Proxy="IcePatch2/server:tcp -h {ip_address} -p 20090"' \
r' {patch_dir}'.format(icepatch2client=icepatch2client, ip_address=ip_address, patch_dir=self.patch_dir)
self.logger.info('fetch_patch cmd : {}'.format(cmd))
try:
json.loads(self._get_loader_prx().popen(
json.dumps({
'async': False,
'shell': True,
'cmd': cmd,
'work_dir': None,
'timeouts_seconds': 60 * 2
})))
except Exception as e:
self.logger.info('fetch_patch Failed. cmd={},e={}'.format(cmd, e))
xlogging.raise_system_error(r'配置备份代理失败',
'fetch_patch {}'.format(e),
1,
logger=self.logger)
raise
def mount(self):
if self._mounted:
xlogging.raise_system_error(r'内部异常，多次挂载', r'MountNbdLinux mount failed', 1)
else:
self._mounted = True
if self._read_only:
self.change_gpt_guid()
self.change_vgs_name_and_uuid()
mount_params, pvs, swap_devices = self.analyze_mount_params()
if self._read_only:
self.change_pvs_uuid(pvs)
self.activate_lvm()
if self._read_only:
self.change_xfs_uuid(mount_params)
self.change_ext_uuid(mount_params)
self.change_btrfs_uuid(mount_params)
self.mount_all(mount_params)
if self._read_only:
self.change_chmod_only_read()
else:
self.fix_swap(swap_devices)
def _create_qcows(self):
for qcow_file in self._host_params['qcow_files']:
base_file = qcow_file.get('base') # 不是必须
disk_bytes = qcow_file.get('disk_bytes') # 不是必须
new_file = qcow_file['new']
qcow_type = qcow_file['qcow_type']
self._new_qcow_files.append(new_file)
_remove_no_exception(new_file)
if qcow_type == 'with_base':
assert base_file
rev = qemuimgcmd.QemuImgCmd().create_qcow2_file_base_old(
base_file, new_file)
elif qcow_type == 'empty':
assert disk_bytes
rev = qemuimgcmd.QemuImgCmd().create_qcow2_file_empty(
new_file, disk_bytes)
else:
xlogging.raise_system_error(
'未知的qcow类型',
'not support qcow type : {}'.format(qcow_type), 2092)
return
if rev[0] != 0:
xlogging.raise_system_error(
'创建虚拟磁盘失败', '_create_qcow failed, rev:{}'.format(rev),
2066)
def do_work(self, src_ko_file, target_ko_file):
# 检查文件是不是存在？
if not os.path.isfile(src_ko_file):
xlogging.raise_system_error(
'drv3: file({}) not exist'.format(src_ko_file),
'文件不存在:{}'.format(src_ko_file), 6, _logger)
src_bin = get_file_BytesIO(src_ko_file)
target_bin = copy.copy(src_bin)
src_elffile = elftools.elf.elffile.ELFFile(src_bin)
self.check_src_and_include_elf(src_ko_file, src_elffile)
_src_modinfo_section = src_elffile.get_section_by_name(r'.modinfo')
_src_version_section = src_elffile.get_section_by_name(r'__versions')
print_section_info(src_ko_file, _src_modinfo_section)
src_mod_info = ElfModInfo(src_ko_file, src_bin, _src_modinfo_section)
self.copy_ver_magic(target_bin, src_mod_info)
if _src_version_section:
src_version = ElfVersion(src_bin, _src_version_section,
src_elffile.elfclass)
self.copy_crc32(target_bin, src_version)
# 产生新的文件
self.do_create_target_and_flush(target_bin, target_ko_file)
return
def __init__(self, link_info):
self.__vm_filename = None
if 'vm_file' in link_info:
self.__vm_filename = link_info['vm_file']
self.__module_sym_file = None
if 'sym_file' in link_info:
self.__module_sym_file = link_info['sym_file']
self.__inc_elf_filename = None
if 'inc_ko' in link_info:
self.__inc_elf_filename = link_info['inc_ko']
self.__target_vermagic = None
if 'vermagic' in link_info:
self.__target_vermagic = link_info['vermagic']
if self.__inc_elf_filename is None and self.__target_vermagic is None:
xlogging.raise_system_error(r'drv3: no inc.ko or vermagic',
'没有inc.ko或vermagic', 11, _logger)
if self.__vm_filename is None and self.__module_sym_file is None:
xlogging.raise_system_error(r'drv3: no vm_file or sym_file',
'没有vmlinux或sym_file', 11, _logger)
self.__crc32Table = elf_read_crctab.ElfReadCrcTable(
self.__vm_filename, self.__module_sym_file)
self.__inc_elf_filename_list = [self.__inc_elf_filename]
self.__inc_ko = None
self.init_vermagic()
def get_device_files(kernel_version, release_version, arch, device):
"""
得到 设备驱动文件列表 的绝对路径
:param kernel_version: linux 内核版本
:param release_version: linux 发行版本
:param arch: "32" "64" "32_PAE" x86 or x86_64 or x86_PAE
:param device: 设备描述
:return: 成功返回路径数组
"""
pci_value_list = modget.convert_pci_str_2_pci_value_list(device)
if not modget.is_pci_value_valid(pci_value_list):
_logger.error(
r'modget.is_pci_value_valid False : {}'.format(pci_value_list))
return None
db_json = _get_db_json()
relative_folder, files = _search_db_json(db_json, kernel_version,
release_version, arch,
pci_value_list)
if relative_folder is None:
xlogging.raise_system_error(
r'不支持的设备：{}'.format(device),
r'get_device_files failed : {} {} {} {}'.format(
kernel_version, release_version, arch, device), 1)
result = list()
for file in files:
result.append(os.path.join(loadIce.current_dir, relative_folder, file))
return result
def _mount_file_system_to_local(self, mount_point):
self.logger.info('begin _mount_file_system_to_local')
self._samba_mount_handle = SAMBAMountHandle(self._samba_params, mount_point)
self._samba_mount_handle.set_ip(self._guest_ip)
if not self._samba_mount_handle.mount(self._samba_params['read_only']):
xlogging.raise_system_error('挂载文件系统失败', 'mount fail', 753)
self.logger.info('end _mount_file_system_to_local ')
def _worker(self, name):
_logger.info('{} worker begin'.format(name))
while not self._error:
params = self._work_params.get()
tmp_file = '/tmp/cluster_gen_qcow{}.json'.format(uuid.uuid4().hex)
try:
if params is self._end_flag:
break
with open(tmp_file, 'w') as f:
json.dump(params, f)
cmd = 'python /sbin/aio/logic_service/generate_cluster_diff_qcow_task.py {}'.format(
tmp_file)
with subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=True) as p:
stdout, stderr = p.communicate()
if p.returncode != 0:
xlogging.raise_system_error(
'生成QCOW失败',
'error:{}|{}|{}'.format(p.returncode, stdout,
stderr), 3073)
except Exception as e:
self._error = e
finally:
_remove_no_exception(tmp_file)
self._work_params.task_done()
_logger.info('{} worker end'.format(name))
def get_ext_vmlinux(src_vm):
# 已经是解压缩文件，并且可用。
try:
if check_is_elf_file(src_vm):
if is_include_setion(src_vm):
with open(src_vm, "rb") as f:
return io.BytesIO(f.read())
except:
# 忽略错误。
pass
try:
os.makedirs(_TMP_VM_DIR)
except:
pass
exe_sc = os.path.join(loadIce.current_dir, "extract_vmlinux")
tmp_file = os.path.join(_TMP_VM_DIR, str(uuid.uuid4().hex))
try:
# extract-vmlinux >> /tmp/xxxx.bmp
cmd = "{} {} >> {}".format(exe_sc, src_vm, tmp_file)
retval, outs, errinfo = net_common.get_info_from_syscmd(cmd)
_logger.info("drv3: runcmd {} return:{} out:{} errorinfo:{}".format(
retval, cmd, outs, errinfo))
if not check_is_elf_file(tmp_file):
_str = "drv3: 不是标准的elf文件:{}".format(tmp_file)
_logger.error(_str)
raise Exception(_str)
# 有可能没有开始CRC 功能。
#if not is_include_setion(tmp_file, "__kcrctab"):
# _str = "drv3: elf文件:{}不包含__kcrctab".format(tmp_file)
# _logger.error(_str)
# raise Exception(_str)
f = open(tmp_file, "rb")
_vm_iobs = io.BytesIO(f.read())
f.close()
os.remove(tmp_file)
return _vm_iobs
except Exception as e:
try:
os.remove(tmp_file)
except:
pass
xlogging.raise_system_error(
'drv3: decompress vm ({}) failed{}'.format(src_vm, e),
'解开({})vm 失败:{}'.format(src_vm, e), 8, _logger)
try:
os.remove(tmp_file)
except:
pass
xlogging.raise_system_error(
'drv3: error vmlinux file ({}) failed'.format(src_vm),
"错误的vm file({})vm".format(src_vm), 9, _logger)
def raise_last_error(self, key, params):
ins = self._fetch(key)
if ins and ins.error:
raise ins.error
else:
xlogging.raise_system_error('无效的错误码',
'not found error, ins:{}'.format(ins),
197)
def get_snapshot_disk_index(self, disk_ident):
for info in self._linux_disk_index_info:
if disk_ident == info['disk_ident']:
return info['snapshot_disk_index']
xlogging.raise_system_error(
r'内部异常，代码3110',
'get_snapshot_disk_index failed {} not in {}'.format(
disk_ident, self._linux_disk_index_info), 1)
def __init__(self, info):
self._info = info
self._meta_data = self._info['meta_data']
self._media = media_objects.get(self._info['media_uuid'])
if not self._media:
xlogging.raise_system_error('获取介质失败', 'get media fail', 138)
self._logger = merge_hash_core.LoggerAdapter(_logger,
{'prefix': 'ExportSnapshotsLogic_{}'.format(uuid.uuid4().hex[-6:])})
def check_unused(device_name):
_logger.debug(
'nbd_wrapper check_unused device_name:{}'.format(device_name))
if os.path.exists(
'/dev/{}'.format(device_name)) and nbd_wrapper.nbd_read_ok(
'/dev/{}'.format(device_name)):
xlogging.raise_system_error(
r'内部错误，虚拟磁盘设备残留',
r'nbd_wrapper set_used {}'.format(device_name), 2312)
def share(self):
ret = smb_add_user(self.user, self.password, self.read_only)
if ret[0] != 0:
xlogging.raise_system_error('SambaShareUser add user fail', 'SambaShareUser add user fail', 131)
self.add_user = True
ret = smb_add_hostpath(self.user, self.host_path)
if ret[0] != 0:
xlogging.raise_system_error('SambaShareUser add host path fail', 'SambaShareUser add host path fail', 132)
self.add_host = True
