558 lines
22 KiB
Python
558 lines
22 KiB
Python
# dialogs_tkinter.py
|
|
import os
|
|
import tkinter as tk
|
|
from tkinter import ttk, messagebox, simpledialog
|
|
import logging
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class BaseDialog:
|
|
"""对话框基类"""
|
|
|
|
def __init__(self, parent, title, width=400, height=300):
|
|
self.parent = parent
|
|
self.result = None
|
|
|
|
# 创建顶层窗口
|
|
self.dialog = tk.Toplevel(parent)
|
|
self.dialog.title(title)
|
|
self.dialog.geometry(f"{width}x{height}")
|
|
self.dialog.transient(parent) # 设置父窗口
|
|
self.dialog.grab_set() # 模态对话框
|
|
|
|
# 居中显示
|
|
self._center_window()
|
|
|
|
# 创建主框架
|
|
self.main_frame = ttk.Frame(self.dialog, padding="10")
|
|
self.main_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
def _center_window(self):
|
|
"""将窗口居中显示"""
|
|
self.dialog.update_idletasks()
|
|
width = self.dialog.winfo_width()
|
|
height = self.dialog.winfo_height()
|
|
x = (self.dialog.winfo_screenwidth() // 2) - (width // 2)
|
|
y = (self.dialog.winfo_screenheight() // 2) - (height // 2)
|
|
self.dialog.geometry(f"{width}x{height}+{x}+{y}")
|
|
|
|
def _create_button_box(self):
|
|
"""创建确定/取消按钮"""
|
|
btn_frame = ttk.Frame(self.main_frame)
|
|
btn_frame.pack(fill=tk.X, pady=(10, 0))
|
|
|
|
self.confirm_btn = ttk.Button(btn_frame, text="确定", command=self._on_confirm)
|
|
self.confirm_btn.pack(side=tk.RIGHT, padx=5)
|
|
|
|
self.cancel_btn = ttk.Button(btn_frame, text="取消", command=self._on_cancel)
|
|
self.cancel_btn.pack(side=tk.RIGHT, padx=5)
|
|
|
|
# 绑定回车键和 ESC 键
|
|
self.dialog.bind('<Return>', lambda e: self._on_confirm())
|
|
self.dialog.bind('<Escape>', lambda e: self._on_cancel())
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调 - 子类重写"""
|
|
pass
|
|
|
|
def _on_cancel(self):
|
|
"""取消按钮回调"""
|
|
self.dialog.destroy()
|
|
|
|
def wait_for_result(self):
|
|
"""等待对话框关闭并返回结果"""
|
|
self.dialog.wait_window()
|
|
return self.result
|
|
|
|
|
|
class CreatePartitionDialog(BaseDialog):
|
|
"""创建分区对话框"""
|
|
|
|
def __init__(self, parent, disk_path="", total_disk_mib=0.0, max_available_mib=0.0):
|
|
self.disk_path = disk_path
|
|
self.total_disk_mib = total_disk_mib
|
|
self.max_available_mib = max_available_mib
|
|
|
|
super().__init__(parent, "创建分区", 450, 280)
|
|
|
|
logger.debug(f"CreatePartitionDialog initialized for {disk_path}. Total MiB: {total_disk_mib}, Max Available MiB: {max_available_mib}")
|
|
|
|
self._setup_ui()
|
|
self._initialize_state()
|
|
|
|
def _setup_ui(self):
|
|
"""设置 UI"""
|
|
# 创建内容框架
|
|
content_frame = ttk.Frame(self.main_frame)
|
|
content_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
# 磁盘路径
|
|
ttk.Label(content_frame, text="磁盘路径:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
|
|
ttk.Label(content_frame, text=self.disk_path).grid(row=0, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 分区表类型
|
|
ttk.Label(content_frame, text="分区表类型:").grid(row=1, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.part_type_var = tk.StringVar(value="gpt")
|
|
self.part_type_combo = ttk.Combobox(content_frame, textvariable=self.part_type_var,
|
|
values=["gpt", "msdos"], state="readonly", width=15)
|
|
self.part_type_combo.grid(row=1, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 使用最大空间复选框
|
|
self.use_max_var = tk.BooleanVar(value=True)
|
|
self.use_max_check = ttk.Checkbutton(content_frame, text="使用最大可用空间",
|
|
variable=self.use_max_var,
|
|
command=self._toggle_size_input)
|
|
self.use_max_check.grid(row=2, column=0, columnspan=2, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 分区大小
|
|
ttk.Label(content_frame, text="分区大小 (GB):").grid(row=3, column=0, sticky=tk.W, padx=5, pady=5)
|
|
|
|
calculated_max_gb = self.max_available_mib / 1024.0
|
|
self.max_gb = max(0.01, calculated_max_gb)
|
|
|
|
self.size_var = tk.DoubleVar(value=self.max_gb)
|
|
self.size_spin = tk.Spinbox(content_frame, from_=0.01, to=self.max_gb,
|
|
increment=0.01, textvariable=self.size_var, width=12)
|
|
self.size_spin.grid(row=3, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
logger.debug(f"Size spinbox max set to: {self.max_gb} GB (calculated from {calculated_max_gb} GB)")
|
|
|
|
# 按钮
|
|
self._create_button_box()
|
|
|
|
def _initialize_state(self):
|
|
"""初始化状态"""
|
|
self._toggle_size_input()
|
|
|
|
def _toggle_size_input(self):
|
|
"""切换大小输入框状态"""
|
|
is_checked = self.use_max_var.get()
|
|
logger.debug(f"[_toggle_size_input] Called. Checkbox isChecked(): {is_checked}")
|
|
|
|
if is_checked:
|
|
logger.debug(f"[_toggle_size_input] Checkbox is CHECKED. Disabling spinbox and setting value to max.")
|
|
self.size_spin.configure(state=tk.DISABLED)
|
|
self.size_var.set(self.max_gb)
|
|
logger.debug(f"[_toggle_size_input] Spinbox value set to max: {self.max_gb} GB.")
|
|
else:
|
|
logger.debug(f"[_toggle_size_input] Checkbox is UNCHECKED. Enabling spinbox.")
|
|
self.size_spin.configure(state=tk.NORMAL)
|
|
current_val = self.size_var.get()
|
|
if current_val >= self.max_gb:
|
|
self.size_var.set(0.01)
|
|
logger.debug(f"[_toggle_size_input] Spinbox was at max, reset to min: 0.01 GB.")
|
|
else:
|
|
logger.debug(f"[_toggle_size_input] Spinbox was not at max, keeping current value: {current_val} GB.")
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调"""
|
|
size_gb = self.size_var.get()
|
|
use_max_space = self.use_max_var.get()
|
|
|
|
if not use_max_space and size_gb <= 0:
|
|
messagebox.showwarning("输入错误", "分区大小必须大于0。")
|
|
return
|
|
|
|
if not use_max_space and size_gb > self.max_gb:
|
|
messagebox.showwarning("输入错误", "分区大小不能超过最大可用空间。")
|
|
return
|
|
|
|
self.result = {
|
|
'disk_path': self.disk_path,
|
|
'partition_table_type': self.part_type_var.get(),
|
|
'size_gb': size_gb,
|
|
'total_disk_mib': self.total_disk_mib,
|
|
'use_max_space': use_max_space
|
|
}
|
|
self.dialog.destroy()
|
|
|
|
def get_partition_info(self):
|
|
"""获取分区信息"""
|
|
return self.result
|
|
|
|
|
|
class MountDialog(BaseDialog):
|
|
"""挂载对话框"""
|
|
|
|
def __init__(self, parent, device_path=""):
|
|
self.device_path = device_path
|
|
super().__init__(parent, "挂载分区", 400, 200)
|
|
self._setup_ui()
|
|
|
|
def _setup_ui(self):
|
|
"""设置 UI"""
|
|
# 创建内容框架
|
|
content_frame = ttk.Frame(self.main_frame)
|
|
content_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
# 设备路径
|
|
ttk.Label(content_frame, text="设备路径:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
|
|
ttk.Label(content_frame, text=self.device_path).grid(row=0, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 挂载点
|
|
ttk.Label(content_frame, text="挂载点:").grid(row=1, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.mount_point_var = tk.StringVar(value=f"/mnt/{os.path.basename(self.device_path)}")
|
|
self.mount_point_entry = ttk.Entry(content_frame, textvariable=self.mount_point_var, width=30)
|
|
self.mount_point_entry.grid(row=1, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 开机自动挂载复选框
|
|
self.add_to_fstab_var = tk.BooleanVar(value=False)
|
|
self.fstab_check = ttk.Checkbutton(content_frame, text="开机自动挂载 (添加到 /etc/fstab)",
|
|
variable=self.add_to_fstab_var)
|
|
self.fstab_check.grid(row=2, column=0, columnspan=2, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 按钮
|
|
self._create_button_box()
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调"""
|
|
mount_point = self.mount_point_var.get().strip()
|
|
|
|
if not mount_point:
|
|
messagebox.showwarning("输入错误", "挂载点不能为空。")
|
|
return
|
|
|
|
if not mount_point.startswith('/'):
|
|
messagebox.showwarning("输入错误", "挂载点必须是绝对路径 (以 '/' 开头)。")
|
|
return
|
|
|
|
self.result = {
|
|
'mount_point': mount_point,
|
|
'add_to_fstab': self.add_to_fstab_var.get()
|
|
}
|
|
self.dialog.destroy()
|
|
|
|
def get_mount_info(self):
|
|
"""获取挂载信息"""
|
|
return self.result
|
|
|
|
|
|
class CreateRaidDialog(BaseDialog):
|
|
"""创建 RAID 阵列对话框"""
|
|
|
|
def __init__(self, parent, available_devices=None):
|
|
self.available_devices = available_devices if available_devices is not None else []
|
|
self.selected_devices = []
|
|
|
|
super().__init__(parent, "创建 RAID 阵列", 450, 450)
|
|
self._setup_ui()
|
|
|
|
def _setup_ui(self):
|
|
"""设置 UI"""
|
|
# 创建内容框架
|
|
content_frame = ttk.Frame(self.main_frame)
|
|
content_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
# RAID 级别
|
|
ttk.Label(content_frame, text="RAID 级别:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.raid_level_var = tk.StringVar(value="raid0")
|
|
self.raid_level_combo = ttk.Combobox(content_frame, textvariable=self.raid_level_var,
|
|
values=["raid0", "raid1", "raid5", "raid6", "raid10"],
|
|
state="readonly", width=12)
|
|
self.raid_level_combo.grid(row=0, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# Chunk 大小
|
|
ttk.Label(content_frame, text="Chunk 大小 (KB):").grid(row=1, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.chunk_size_var = tk.IntVar(value=512)
|
|
self.chunk_size_spin = tk.Spinbox(content_frame, from_=4, to=1024, increment=4,
|
|
textvariable=self.chunk_size_var, width=10)
|
|
self.chunk_size_spin.grid(row=1, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 设备选择
|
|
ttk.Label(content_frame, text="选择设备:").grid(row=2, column=0, sticky=tk.NW, padx=5, pady=5)
|
|
|
|
# 创建设备选择框架
|
|
device_frame = ttk.Frame(content_frame)
|
|
device_frame.grid(row=2, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 设备复选框列表
|
|
self.device_vars = {}
|
|
for i, dev in enumerate(self.available_devices):
|
|
var = tk.BooleanVar(value=False)
|
|
self.device_vars[dev] = var
|
|
cb = ttk.Checkbutton(device_frame, text=dev, variable=var)
|
|
cb.pack(anchor=tk.W)
|
|
|
|
# 按钮
|
|
self._create_button_box()
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调"""
|
|
# 收集选中的设备
|
|
self.selected_devices = [dev for dev, var in self.device_vars.items() if var.get()]
|
|
|
|
if not self.selected_devices:
|
|
messagebox.showwarning("输入错误", "请选择至少一个设备来创建 RAID 阵列。")
|
|
return
|
|
|
|
raid_level = self.raid_level_var.get()
|
|
num_devices = len(self.selected_devices)
|
|
|
|
# RAID 级别检查
|
|
if raid_level == "raid0" and num_devices < 1:
|
|
messagebox.showwarning("输入错误", "RAID0 至少需要一个设备。")
|
|
return
|
|
elif raid_level == "raid1" and num_devices < 2:
|
|
messagebox.showwarning("输入错误", "RAID1 至少需要两个设备。")
|
|
return
|
|
elif raid_level == "raid5" and num_devices < 3:
|
|
messagebox.showwarning("输入错误", "RAID5 至少需要三个设备。")
|
|
return
|
|
elif raid_level == "raid6" and num_devices < 4:
|
|
messagebox.showwarning("输入错误", "RAID6 至少需要四个设备。")
|
|
return
|
|
elif raid_level == "raid10" and num_devices < 2:
|
|
messagebox.showwarning("输入错误", "RAID10 至少需要两个设备。")
|
|
return
|
|
|
|
self.result = {
|
|
'devices': self.selected_devices,
|
|
'level': raid_level.replace('raid', ''),
|
|
'chunk_size': self.chunk_size_var.get()
|
|
}
|
|
self.dialog.destroy()
|
|
|
|
def get_raid_info(self):
|
|
"""获取 RAID 信息"""
|
|
return self.result
|
|
|
|
|
|
class CreatePvDialog(BaseDialog):
|
|
"""创建物理卷 (PV) 对话框"""
|
|
|
|
def __init__(self, parent, available_partitions=None):
|
|
self.available_partitions = available_partitions if available_partitions is not None else []
|
|
|
|
super().__init__(parent, "创建物理卷 (PV)", 400, 200)
|
|
self._setup_ui()
|
|
|
|
def _setup_ui(self):
|
|
"""设置 UI"""
|
|
# 创建内容框架
|
|
content_frame = ttk.Frame(self.main_frame)
|
|
content_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
# 设备选择
|
|
ttk.Label(content_frame, text="选择设备:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
|
|
|
|
self.device_var = tk.StringVar()
|
|
if self.available_partitions:
|
|
self.device_var.set(self.available_partitions[0])
|
|
|
|
self.device_combo = ttk.Combobox(content_frame, textvariable=self.device_var,
|
|
values=self.available_partitions, state="readonly", width=30)
|
|
self.device_combo.grid(row=0, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 按钮
|
|
self._create_button_box()
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调"""
|
|
device_path = self.device_var.get()
|
|
|
|
if not device_path:
|
|
messagebox.showwarning("输入错误", "请选择一个设备来创建物理卷。")
|
|
return
|
|
|
|
self.result = {'device_path': device_path}
|
|
self.dialog.destroy()
|
|
|
|
def get_pv_info(self):
|
|
"""获取 PV 信息"""
|
|
return self.result
|
|
|
|
|
|
class CreateVgDialog(BaseDialog):
|
|
"""创建卷组 (VG) 对话框"""
|
|
|
|
def __init__(self, parent, available_pvs=None):
|
|
self.available_pvs = available_pvs if available_pvs is not None else []
|
|
self.selected_pvs = []
|
|
|
|
super().__init__(parent, "创建卷组 (VG)", 450, 350)
|
|
self._setup_ui()
|
|
|
|
def _setup_ui(self):
|
|
"""设置 UI"""
|
|
# 创建内容框架
|
|
content_frame = ttk.Frame(self.main_frame)
|
|
content_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
# 卷组名称
|
|
ttk.Label(content_frame, text="卷组名称:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.vg_name_var = tk.StringVar()
|
|
self.vg_name_entry = ttk.Entry(content_frame, textvariable=self.vg_name_var, width=25)
|
|
self.vg_name_entry.grid(row=0, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 物理卷选择
|
|
ttk.Label(content_frame, text="选择物理卷:").grid(row=1, column=0, sticky=tk.NW, padx=5, pady=5)
|
|
|
|
pv_frame = ttk.Frame(content_frame)
|
|
pv_frame.grid(row=1, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
self.pv_vars = {}
|
|
for pv in self.available_pvs:
|
|
var = tk.BooleanVar(value=False)
|
|
self.pv_vars[pv] = var
|
|
cb = ttk.Checkbutton(pv_frame, text=pv, variable=var)
|
|
cb.pack(anchor=tk.W)
|
|
|
|
# 按钮
|
|
self._create_button_box()
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调"""
|
|
vg_name = self.vg_name_var.get().strip()
|
|
self.selected_pvs = [pv for pv, var in self.pv_vars.items() if var.get()]
|
|
|
|
if not vg_name:
|
|
messagebox.showwarning("输入错误", "卷组名称不能为空。")
|
|
return
|
|
|
|
if not self.selected_pvs:
|
|
messagebox.showwarning("输入错误", "请选择至少一个物理卷来创建卷组。")
|
|
return
|
|
|
|
self.result = {
|
|
'vg_name': vg_name,
|
|
'pvs': self.selected_pvs
|
|
}
|
|
self.dialog.destroy()
|
|
|
|
def get_vg_info(self):
|
|
"""获取 VG 信息"""
|
|
return self.result
|
|
|
|
|
|
class CreateLvDialog(BaseDialog):
|
|
"""创建逻辑卷 (LV) 对话框"""
|
|
|
|
def __init__(self, parent, available_vgs=None, vg_sizes=None):
|
|
self.available_vgs = available_vgs if available_vgs is not None else []
|
|
self.vg_sizes = vg_sizes if vg_sizes is not None else {}
|
|
|
|
super().__init__(parent, "创建逻辑卷", 450, 300)
|
|
|
|
logger.debug(f"CreateLvDialog initialized. Available VGs: {self.available_vgs}, VG Sizes: {self.vg_sizes}")
|
|
|
|
self._setup_ui()
|
|
self._initialize_state()
|
|
|
|
def _setup_ui(self):
|
|
"""设置 UI"""
|
|
# 逻辑卷名称
|
|
# 创建内容框架
|
|
content_frame = ttk.Frame(self.main_frame)
|
|
content_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
|
ttk.Label(content_frame, text="逻辑卷名称:").grid(row=0, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.lv_name_var = tk.StringVar()
|
|
self.lv_name_entry = ttk.Entry(content_frame, textvariable=self.lv_name_var, width=25)
|
|
self.lv_name_entry.grid(row=0, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 卷组选择
|
|
ttk.Label(content_frame, text="选择卷组:").grid(row=1, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.vg_var = tk.StringVar()
|
|
if self.available_vgs:
|
|
self.vg_var.set(self.available_vgs[0])
|
|
self.vg_combo = ttk.Combobox(content_frame, textvariable=self.vg_var,
|
|
values=self.available_vgs, state="readonly", width=25)
|
|
self.vg_combo.grid(row=1, column=1, sticky=tk.W, padx=5, pady=5)
|
|
self.vg_combo.bind('<<ComboboxSelected>>', lambda e: self._update_size_options())
|
|
|
|
# 使用最大空间复选框
|
|
self.use_max_var = tk.BooleanVar(value=True)
|
|
self.use_max_check = ttk.Checkbutton(content_frame, text="使用最大可用空间",
|
|
variable=self.use_max_var,
|
|
command=self._toggle_size_input)
|
|
self.use_max_check.grid(row=2, column=0, columnspan=2, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 逻辑卷大小
|
|
ttk.Label(content_frame, text="大小 (GB):").grid(row=3, column=0, sticky=tk.W, padx=5, pady=5)
|
|
self.size_var = tk.DoubleVar(value=1.0)
|
|
self.size_spin = tk.Spinbox(content_frame, from_=0.01, to=100000.0, increment=0.01,
|
|
textvariable=self.size_var, width=12)
|
|
self.size_spin.grid(row=3, column=1, sticky=tk.W, padx=5, pady=5)
|
|
|
|
# 按钮
|
|
self._create_button_box()
|
|
|
|
def _initialize_state(self):
|
|
"""初始化状态"""
|
|
self._update_size_options()
|
|
|
|
def _update_size_options(self):
|
|
"""根据选中的卷组更新大小选项"""
|
|
selected_vg = self.vg_var.get()
|
|
max_size_gb = self.vg_sizes.get(selected_vg, 0.0)
|
|
|
|
logger.debug(f"[_update_size_options] Selected VG: {selected_vg}, Max available GB: {max_size_gb}")
|
|
|
|
# 确保最大值至少大于等于最小值
|
|
effective_max = max(0.01, max_size_gb)
|
|
self.size_spin.configure(to=effective_max)
|
|
self.max_gb = effective_max
|
|
|
|
logger.debug(f"[_update_size_options] Spinbox max set to: {effective_max} GB.")
|
|
|
|
# 应用复选框状态
|
|
self._toggle_size_input()
|
|
logger.debug("[_update_size_options] Completed.")
|
|
|
|
def _toggle_size_input(self):
|
|
"""切换大小输入框状态"""
|
|
is_checked = self.use_max_var.get()
|
|
logger.debug(f"[_toggle_size_input] Called. Checkbox isChecked(): {is_checked}")
|
|
|
|
if is_checked:
|
|
logger.debug(f"[_toggle_size_input] Checkbox is CHECKED. Disabling spinbox and setting value to max.")
|
|
self.size_spin.configure(state=tk.DISABLED)
|
|
self.size_var.set(self.max_gb)
|
|
logger.debug(f"[_toggle_size_input] Spinbox value set to max: {self.max_gb} GB.")
|
|
else:
|
|
logger.debug(f"[_toggle_size_input] Checkbox is UNCHECKED. Enabling spinbox.")
|
|
self.size_spin.configure(state=tk.NORMAL)
|
|
current_val = self.size_var.get()
|
|
if current_val >= self.max_gb:
|
|
self.size_var.set(0.01)
|
|
logger.debug(f"[_toggle_size_input] Spinbox was at max, reset to min: 0.01 GB.")
|
|
else:
|
|
logger.debug(f"[_toggle_size_input] Spinbox was not at max, keeping current value: {current_val} GB.")
|
|
logger.debug("[_toggle_size_input] Completed.")
|
|
|
|
def _on_confirm(self):
|
|
"""确定按钮回调"""
|
|
lv_name = self.lv_name_var.get().strip()
|
|
vg_name = self.vg_var.get()
|
|
size_gb = self.size_var.get()
|
|
use_max_space = self.use_max_var.get()
|
|
|
|
if not lv_name:
|
|
messagebox.showwarning("输入错误", "逻辑卷名称不能为空。")
|
|
return
|
|
|
|
if not vg_name:
|
|
messagebox.showwarning("输入错误", "请选择一个卷组。")
|
|
return
|
|
|
|
if not use_max_space:
|
|
if size_gb <= 0:
|
|
messagebox.showwarning("输入错误", "逻辑卷大小必须大于0。")
|
|
return
|
|
if size_gb > self.max_gb:
|
|
messagebox.showwarning("输入错误", "逻辑卷大小不能超过卷组的可用空间。")
|
|
return
|
|
|
|
self.result = {
|
|
'lv_name': lv_name,
|
|
'vg_name': vg_name,
|
|
'size_gb': size_gb,
|
|
'use_max_space': use_max_space
|
|
}
|
|
self.dialog.destroy()
|
|
|
|
def get_lv_info(self):
|
|
"""获取 LV 信息"""
|
|
return self.result
|