class ZFSDataset_CreateForm(Form):
dataset_name = forms.CharField(max_length=128, label=_('Dataset Name'))
dataset_compression = forms.ChoiceField(
choices=choices.ZFS_CompressionChoices,
widget=forms.Select(attrs=attrs_dict),
label=_('Compression level'))
dataset_atime = forms.ChoiceField(
choices=choices.ZFS_AtimeChoices,
widget=forms.RadioSelect(attrs=attrs_dict),
label=_('Enable atime'))
dataset_refquota = forms.CharField(max_length=128,
initial=0,
label=_('Quota for this dataset'),
help_text=_('0=Unlimited; example: 1g'))
dataset_quota = forms.CharField(
max_length=128,
initial=0,
label=_('Quota for this dataset and all children'),
help_text=_('0=Unlimited; example: 1g'))
dataset_refreserv = forms.CharField(
max_length=128,
initial=0,
label=_('Reserved space for this dataset'),
help_text=_('0=None; example: 1g'))
dataset_reserv = forms.CharField(
max_length=128,
initial=0,
label=_('Reserved space for this dataset and all children'),
help_text=_('0=None; example: 1g'))
def __init__(self, *args, **kwargs):
self.fs = kwargs.pop('fs')
super(ZFSDataset_CreateForm, self).__init__(*args, **kwargs)
def clean_dataset_name(self):
name = self.cleaned_data["dataset_name"]
if not re.search(r'^[a-zA-Z0-9][a-zA-Z0-9_\-:.]*$', name):
raise forms.ValidationError(
_("Dataset names must begin with an "
"alphanumeric character and may only contain "
"\"-\", \"_\", \":\" and \".\"."))
return name
def clean(self):
cleaned_data = _clean_quota_fields(
self, ('refquota', 'quota', 'reserv', 'refreserv'), "dataset_")
full_dataset_name = "%s/%s" % (self.fs,
cleaned_data.get("dataset_name"))
if len(zfs.list_datasets(path=full_dataset_name)) > 0:
msg = _(u"You already have a dataset with the same name")
self._errors["dataset_name"] = self.error_class([msg])
del cleaned_data["dataset_name"]
return cleaned_data
def set_error(self, msg):
msg = u"%s" % msg
self._errors['__all__'] = self.error_class([msg])
del self.cleaned_data
class ZFSDataset_EditForm(Form):
dataset_compression = forms.ChoiceField(
choices=choices.ZFS_CompressionChoices,
widget=forms.Select(attrs=attrs_dict),
label=_('Compression level'))
dataset_atime = forms.ChoiceField(
choices=choices.ZFS_AtimeChoices,
widget=forms.RadioSelect(attrs=attrs_dict),
label=_('Enable atime'))
dataset_refquota = forms.CharField(max_length=128,
initial=0,
label=_('Quota for this dataset'),
help_text=_('0=Unlimited; example: 1g'))
dataset_quota = forms.CharField(
max_length=128,
initial=0,
label=_('Quota for this dataset and all children'),
help_text=_('0=Unlimited; example: 1g'))
dataset_refreservation = forms.CharField(
max_length=128,
initial=0,
label=_('Reserved space for this dataset'),
help_text=_('0=None; example: 1g'))
dataset_reservation = forms.CharField(
max_length=128,
initial=0,
label=_('Reserved space for this dataset and all children'),
help_text=_('0=None; example: 1g'))
def __init__(self, *args, **kwargs):
self._fs = kwargs.pop("fs", None)
super(ZFSDataset_EditForm, self).__init__(*args, **kwargs)
data = notifier().zfs_get_options(self._fs)
self.fields['dataset_compression'].initial = data['compression']
self.fields['dataset_atime'].initial = data['atime']
for attr in ('refquota', 'quota', 'reservation', 'refreservation'):
formfield = 'dataset_%s' % (attr)
if data[attr] == 'none':
self.fields[formfield].initial = 0
else:
self.fields[formfield].initial = data[attr]
def clean(self):
return _clean_quota_fields(
self, ('refquota', 'quota', 'reservation', 'refreservation'),
"dataset_")
def set_error(self, msg):
msg = u"%s" % msg
self._errors['__all__'] = self.error_class([msg])
del self.cleaned_data
class LAGGInterfaceForm(forms.Form):
lagg_protocol = forms.ChoiceField(choices=choices.LAGGType,
widget=forms.RadioSelect())
lagg_interfaces = forms.MultipleChoiceField(
widget=forms.SelectMultiple(),
label=_('Physical NICs in the LAGG')
)
def __init__(self, *args, **kwargs):
super(LAGGInterfaceForm, self).__init__(*args, **kwargs)
self.fields['lagg_interfaces'].choices = list(
choices.NICChoices(nolagg=True)
)
class Meta:
model = models.LAGGInterface
exclude = ('lagg_interface', )
widgets = {
'lagg_protocol': forms.RadioSelect(),
}
class VolumeImportForm(forms.Form):
volume_name = forms.CharField(max_length=30, label=_('Volume name'))
volume_disks = forms.ChoiceField(choices=(),
widget=forms.Select(attrs=attrs_dict),
label=_('Member disk'))
volume_fstype = forms.ChoiceField(
choices=((x, x) for x in ('UFS', 'NTFS', 'MSDOSFS', 'EXT2FS')),
widget=forms.RadioSelect(attrs=attrs_dict),
label='File System type')
def __init__(self, *args, **kwargs):
super(VolumeImportForm, self).__init__(*args, **kwargs)
self.fields['volume_disks'].choices = self._populate_disk_choices()
def _populate_disk_choices(self):
used_disks = []
for v in models.Volume.objects.all():
used_disks.extend(v.get_disks())
qs = iSCSITargetExtent.objects.filter(iscsi_target_extent_type='Disk')
diskids = [i[0] for i in qs.values_list('iscsi_target_extent_path')]
used_disks.extend(
[d.disk_name for d in models.Disk.objects.filter(id__in=diskids)])
n = notifier()
# Grab partition list
# NOTE: This approach may fail if device nodes are not accessible.
_parts = n.get_partitions()
for name, part in _parts.items():
if len([i for i in used_disks \
if part['devname'].startswith(i)]) > 0:
del _parts[name]
parts = []
for name, part in _parts.items():
parts.append(Disk(part['devname'], part['capacity']))
choices = sorted(parts)
choices = [tuple(p) for p in choices]
return choices
def clean(self):
cleaned_data = self.cleaned_data
volume_name = cleaned_data.get("volume_name")
if models.Volume.objects.filter(vol_name=volume_name).count() > 0:
msg = _(u"You already have a volume with same name")
self._errors["volume_name"] = self.error_class([msg])
del cleaned_data["volume_name"]
devpath = "/dev/%s" % (cleaned_data.get('volume_disks', []), )
isvalid = notifier().precheck_partition(
devpath, cleaned_data.get('volume_fstype', ''))
if not isvalid:
msg = _(u"The selected disks were not verified for this import "
"rules.")
self._errors["volume_name"] = self.error_class([msg])
if "volume_name" in cleaned_data:
del cleaned_data["volume_name"]
if "volume_name" in cleaned_data:
dolabel = notifier().label_disk(cleaned_data["volume_name"],
devpath,
cleaned_data['volume_fstype'])
if not dolabel:
msg = _(u"An error occurred while labeling the disk.")
self._errors["volume_name"] = self.error_class([msg])
cleaned_data.pop("volume_name", None)
return cleaned_data
def done(self, request):
# Construct and fill forms into database.
volume_name = self.cleaned_data['volume_name']
volume_fstype = self.cleaned_data['volume_fstype']
volume = models.Volume(vol_name=volume_name, vol_fstype=volume_fstype)
volume.save()
self.volume = volume
mp = models.MountPoint(mp_volume=volume,
mp_path='/mnt/' + volume_name,
mp_options='rw')
mp.save()
notifier().start("mx-fstab")
notifier().mount_volume(volume)
class VolumeWizardForm(forms.Form):
volume_name = forms.CharField(max_length=30,
label=_('Volume name'),
required=False)
volume_fstype = forms.ChoiceField(
choices=((x, x) for x in ('UFS', 'ZFS')),
widget=forms.RadioSelect(attrs=attrs_dict),
label=_('Filesystem type'))
volume_disks = forms.MultipleChoiceField(
choices=(),
widget=forms.SelectMultiple(attrs=attrs_dict),
label='Member disks',
required=False)
group_type = forms.ChoiceField(choices=(),
widget=forms.RadioSelect(attrs=attrs_dict),
required=False)
force4khack = forms.BooleanField(
required=False,
initial=False,
help_text=_('Force 4096 bytes sector size'))
ufspathen = forms.BooleanField(initial=False,
label=_('Specify custom path'),
required=False)
ufspath = forms.CharField(max_length=1024, label=_('Path'), required=False)
def __init__(self, *args, **kwargs):
super(VolumeWizardForm, self).__init__(*args, **kwargs)
self.fields['volume_disks'].choices = self._populate_disk_choices()
qs = models.Volume.objects.filter(vol_fstype='ZFS')
if qs.exists():
self.fields['volume_add'] = forms.ChoiceField(
label=_('Volume add'), required=False)
self.fields['volume_add'].choices = [('', '-----')] + \
[(x.vol_name, x.vol_name) for x in qs]
self.fields['volume_add'].widget.attrs['onChange'] = (
'wizardcheckings(true);')
self.fields['volume_fstype'].widget.attrs['onClick'] = (
'wizardcheckings();')
self.fields['ufspathen'].widget.attrs['onClick'] = (
'toggleGeneric("id_ufspathen", ["id_ufspath"], true);')
if not self.data.get("ufspathen", False):
self.fields['ufspath'].widget.attrs['disabled'] = 'disabled'
self.fields['ufspath'].widget.attrs['promptMessage'] = _(
"Leaving this"
" blank will give the volume a default path of "
"/mnt/${VOLUME_NAME}")
grouptype_choices = (
('mirror', 'mirror'),
('stripe', 'stripe'),
)
fstype = self.data.get("volume_fstype", None)
if "volume_disks" in self.data:
disks = self.data.getlist("volume_disks")
else:
disks = []
if fstype == "UFS":
l = len(disks) - 1
if l >= 2 and (((l - 1) & l) == 0):
grouptype_choices += (('raid3', 'RAID-3'), )
elif fstype == "ZFS":
if len(disks) >= 3:
grouptype_choices += (('raidz', 'RAID-Z'), )
if len(disks) >= 4:
grouptype_choices += (('raidz2', 'RAID-Z2'), )
# Not yet
#if len(disks) >= 5:
# grouptype_choices += ( ('raidz3', 'RAID-Z3'), )
self.fields['group_type'].choices = grouptype_choices
def _populate_disk_choices(self):
disks = []
# Grab disk list
# Root device already ruled out
for disk, info in notifier().get_disks().items():
disks.append(
Disk(info['devname'],
info['capacity'],
serial=info.get('ident')))
# Exclude what's already added
used_disks = []
for v in models.Volume.objects.all():
used_disks.extend(v.get_disks())
qs = iSCSITargetExtent.objects.filter(iscsi_target_extent_type='Disk')
used_disks.extend([i.get_device()[5:] for i in qs])
for d in list(disks):
if d.dev in used_disks:
disks.remove(d)
choices = sorted(disks)
choices = [tuple(d) for d in choices]
return choices
def clean_volume_name(self):
vname = self.cleaned_data['volume_name']
if vname and not re.search(r'^[a-z][-_.a-z0-9]*$', vname, re.I):
raise forms.ValidationError(
_("The volume name must start with "
"letters and may include numbers, \"-\", \"_\" and \".\" ."))
if models.Volume.objects.filter(vol_name=vname).exists():
raise forms.ValidationError(
_("A volume with that name already "
"exists."))
return vname
def clean_group_type(self):
if 'volume_disks' not in self.cleaned_data or \
len(self.cleaned_data['volume_disks']) > 1 and \
self.cleaned_data['group_type'] in (None, ''):
raise forms.ValidationError(_("This field is required."))
return self.cleaned_data['group_type']
def clean_ufspath(self):
ufspath = self.cleaned_data['ufspath']
if not ufspath:
return None
if not access(ufspath, 0):
raise forms.ValidationError(_("Path does not exist."))
st = stat(ufspath)
if not S_ISDIR(st.st_mode):
raise forms.ValidationError(_("Path is not a directory."))
return ufspath
def clean(self):
cleaned_data = self.cleaned_data
volume_name = cleaned_data.get("volume_name", "")
disks = cleaned_data.get("volume_disks")
if volume_name and cleaned_data.get("volume_add"):
self._errors['__all__'] = self.error_class([
_("You cannot select an existing ZFS volume and specify a new "
"volume name"),
])
elif not (volume_name or cleaned_data.get("volume_add")):
self._errors['__all__'] = self.error_class([
_("You must specify a new volume name or select an existing "
"ZFS volume to append a virtual device"),
])
elif not volume_name:
volume_name = cleaned_data.get("volume_add")
if cleaned_data.get("volume_fstype") not in ('ZFS', 'UFS'):
msg = _(u"You must select a filesystem")
self._errors["volume_fstype"] = self.error_class([msg])
cleaned_data.pop("volume_fstype", None)
if len(disks) == 0 and models.Volume.objects.filter(
vol_name=volume_name).count() == 0:
msg = _(u"This field is required")
self._errors["volume_disks"] = self.error_class([msg])
del cleaned_data["volume_disks"]
if (cleaned_data.get("volume_fstype") == 'ZFS' and \
models.Volume.objects.filter(vol_name=volume_name).exclude(
vol_fstype='ZFS').count() > 0
) or (
cleaned_data.get("volume_fstype") == 'UFS' and \
models.Volume.objects.filter(
vol_name=volume_name).count() > 0
):
msg = _(u"You already have a volume with same name")
self._errors["volume_name"] = self.error_class([msg])
del cleaned_data["volume_name"]
if cleaned_data.get("volume_fstype", None) == 'ZFS':
if volume_name in ('log', ):
msg = _(u"\"log\" is a reserved word and thus cannot be used")
self._errors["volume_name"] = self.error_class([msg])
cleaned_data.pop("volume_name", None)
elif re.search(r'^c[0-9].*', volume_name) or \
re.search(r'^mirror.*', volume_name) or \
re.search(r'^spare.*', volume_name) or \
re.search(r'^raidz.*', volume_name):
msg = _(u"The volume name may NOT start with c[0-9], mirror, "
"raidz or spare")
self._errors["volume_name"] = self.error_class([msg])
cleaned_data.pop("volume_name", None)
elif cleaned_data.get("volume_fstype") == 'UFS' and volume_name:
if len(volume_name) > 9:
msg = _(u"UFS volume names cannot be higher than 9 characters")
self._errors["volume_name"] = self.error_class([msg])
cleaned_data.pop("volume_name", None)
elif not re.search(r'^[a-z0-9]+$', volume_name, re.I):
msg = _(u"UFS volume names can only contain alphanumeric "
"characters")
self._errors["volume_name"] = self.error_class([msg])
cleaned_data.pop("volume_name", None)
return cleaned_data
def done(self, request):
# Construct and fill forms into database.
volume_name = self.cleaned_data.get("volume_name") or \
self.cleaned_data.get("volume_add")
volume_fstype = self.cleaned_data['volume_fstype']
disk_list = self.cleaned_data['volume_disks']
force4khack = self.cleaned_data.get("force4khack", False)
ufspath = self.cleaned_data['ufspath']
mp_options = "rw"
mp_path = None
if (len(disk_list) < 2):
if volume_fstype == 'ZFS':
group_type = 'stripe'
else:
# UFS middleware expects no group_type for single disk volume
group_type = ''
else:
group_type = self.cleaned_data['group_type']
with transaction.commit_on_success():
vols = models.Volume.objects.filter(vol_name=volume_name,
vol_fstype='ZFS')
if vols.count() == 1:
volume = vols[0]
add = True
else:
add = False
volume = models.Volume(vol_name=volume_name,
vol_fstype=volume_fstype)
volume.save()
mp_path = ufspath if ufspath else '/mnt/' + volume_name
if volume_fstype == 'UFS':
mp_options = 'rw,nfsv4acls'
mp = models.MountPoint(mp_volume=volume,
mp_path=mp_path,
mp_options=mp_options)
mp.save()
self.volume = volume
zpoolfields = re.compile(r'zpool_(.+)')
grouped = OrderedDict()
grouped['root'] = {'type': group_type, 'disks': disk_list}
for i, gtype in request.POST.items():
if zpoolfields.match(i):
if gtype == 'none':
continue
disk = zpoolfields.search(i).group(1)
if gtype in grouped:
# if this is a log vdev we need to mirror it for safety
if gtype == 'log':
grouped[gtype]['type'] = 'log mirror'
grouped[gtype]['disks'].append(disk)
else:
grouped[gtype] = {
'type': gtype,
'disks': [
disk,
]
}
if len(disk_list) > 0 and add:
notifier().zfs_volume_attach_group(volume,
grouped['root'],
force4khack=force4khack)
if add:
for grp_type in grouped:
if grp_type in ('log', 'cache', 'spare'):
notifier().zfs_volume_attach_group(
volume,
grouped.get(grp_type),
force4khack=force4khack)
else:
notifier().init("volume",
volume,
groups=grouped,
force4khack=force4khack,
path=ufspath)
if volume.vol_fstype == 'ZFS':
models.Scrub.objects.create(scrub_volume=volume)
try:
notifier().restart("cron")
except:
pass
if mp_path in ('/etc', '/var', '/usr'):
device = '/dev/ufs/' + volume_name
mp = '/mnt/' + volume_name
if not access(mp, 0):
mkdir(mp, 755)
mount(device, mp)
popen("/usr/local/bin/rsync -avz '%s/*' '%s/'" %
(mp_path, mp)).close()
umount(mp)
if access(mp, 0):
rmdir(mp)
else:
# This must be outside transaction block to make sure the changes
# are committed before the call of mx-fstab
notifier().reload("disk")
