def mp_permission(request, path):
path = urllib.unquote_plus(path)
#FIXME: dojo cannot handle urls partially urlencoded %2F => /
if not path.startswith('/'):
path = '/' + path
if request.method == 'POST':
form = forms.MountPointAccessForm(request.POST)
if form.is_valid():
form.commit(path=path)
return JsonResp(
request,
message=_("Mount Point permissions successfully updated."))
else:
form = forms.MountPointAccessForm(initial={'path': path})
return render(request, 'storage/permission.html', {
'path': path,
'form': form,
})
def volume_create_passphrase(request, object_id):
volume = models.Volume.objects.get(id=object_id)
if request.method == "POST":
form = forms.CreatePassphraseForm(request.POST)
if form.is_valid():
try:
form.done(volume=volume)
return JsonResp(
request,
message=_("Passphrase created"))
except ClientException as e:
form._errors['__all__'] = form.error_class([str(e)])
else:
form = forms.CreatePassphraseForm()
return render(request, "storage/create_passphrase.html", {
'volume': volume,
'form': form,
})
def index(request):
if request.method == 'POST':
if request.POST.get('eula') == 'unaccept':
request.session.pop('noeula', None)
with client as c:
c.call('truenas.unaccept_eula')
return HttpResponseRedirect('/')
sw_name = get_sw_name().lower()
license = utils.get_license()[0]
allow_update = True
if hasattr(notifier, 'failover_status'):
status = notifier().failover_status()
if status not in ('MASTER', 'SINGLE'):
allow_update = False
context = {
'sw_name': sw_name,
'license': license,
'fc_enabled': utils.fc_enabled(),
'allow_update': allow_update,
}
for c in appPool.hook_view_context('support.index', request):
context.update(c)
if not notifier().is_freenas():
with client as c:
context['eula_not_accepted'] = not c.call('truenas.is_eula_accepted')
if not notifier().is_freenas():
form = forms.ProductionForm()
if request.method == 'POST':
form = forms.ProductionForm(request.POST)
if form.is_valid():
form.save()
return JsonResp(
request,
message='Production status successfully updated.'
)
context['production_form'] = form
return render(request, 'support/home.html', context)
def zpool_scrub(request, vid):
volume = models.Volume.objects.get(pk=vid)
try:
pool = notifier().zpool_parse(volume.vol_name)
except:
raise MiddlewareError(
_('Pool output could not be parsed. Is the pool imported?')
)
if request.method == "POST":
if request.POST.get("scrub") == 'IN_PROGRESS':
notifier().zfs_scrub(str(volume.vol_name), stop=True)
else:
notifier().zfs_scrub(str(volume.vol_name))
return JsonResp(request, message=_("The scrub process has begun"))
return render(request, 'storage/scrub_confirm.html', {
'volume': volume,
'scrub': pool.scrub,
})
def services_s3(request):
try:
s3 = models.S3.objects.all()[0]
except:
s3 = models.S3()
if request.method == "POST":
form = S3Form(request.POST, instance=s3)
if form.is_valid():
form.save()
else:
return JsonResp(request, form=form)
else:
form = S3Form(instance=s3)
return render(request, 'services/s3.html', {
'form': form,
})
def vcp_home(request):
aux_enable_https = models.VcenterAuxSettings.objects.latest('id').vc_enable_https
if request.method == 'POST':
form = VcenterConfigurationForm(request.POST)
if form.is_valid():
if form.install_plugin():
form.save()
obj = models.VcenterConfiguration.objects.latest('id')
obj.vc_version = utils.get_plugin_version()
obj.vc_password = ''
obj.save()
else:
return JsonResp(
request, error=True, message=_(
form.vcp_status))
else:
form.is_update_needed()
return render(
request,
"vcp/index.html",
{
'form': form,
'aux_enable_https': aux_enable_https,
}
)
try:
obj = models.VcenterConfiguration.objects.latest('id')
form = VcenterConfigurationForm(instance=obj)
form.fields['vc_ip'].widget.attrs['readonly'] = True
form.is_update_needed()
except:
form = VcenterConfigurationForm()
form.is_update_needed()
return render(
request,
"vcp/index.html",
{
'form': form,
'aux_enable_https': aux_enable_https,
}
)
def volume_key(request, object_id):
if request.method == "POST":
form = forms.KeyForm(request.POST)
if form.is_valid():
request.session["allow_gelikey"] = True
return JsonResp(
request,
message=_("GELI key download starting..."),
events=["window.location='%s';" % (
reverse("storage_volume_key_download",
kwargs={'object_id': object_id}),
)],
)
else:
form = forms.KeyForm()
return render(request, "storage/key.html", {
'form': form,
})
def volimport(request):
if request.method == "POST":
form = forms.VolumeImportForm(request.POST)
if form.is_valid():
form.done(request)
return JsonResp(request, message=_("Volume successfully added."))
else:
if 'volume_disks' in request.POST:
disks = request.POST.getlist('volume_disks')
else:
disks = None
else:
form = forms.VolumeImportForm()
disks = []
return render(request, 'storage/import.html', {
'form': form,
'disks': disks
})
def volumemanager_zfs(request):
if request.method == "POST":
form = forms.ZFSVolumeWizardForm(request.POST)
events = []
if form.is_valid() and form.done(request, events):
return JsonResp(
request,
message=_("Volume successfully added."),
events=events,
)
else:
if 'volume_disks' in request.POST:
disks = request.POST.getlist('volume_disks')
else:
disks = None
zpoolfields = re.compile(r'zpool_(.+)')
zfsextra = [
(zpoolfields.search(i).group(1), i, request.POST.get(i))
for i in list(request.POST.keys()) if zpoolfields.match(i)
]
zfsextradisks = [v[0] for v in zfsextra if v[2] != 'none']
else:
form = forms.ZFSVolumeWizardForm()
disks = []
zfsextra = None
zfsextradisks = []
# dedup = forms._dedup_enabled()
dedup = True
return render(
request, 'storage/zfswizard.html', {
'form': form,
'disks': disks,
'zfsextra': zfsextra,
'zfsextradisks': zfsextradisks,
'dedup': dedup,
})
def start(request, id):
vm = models.VM.objects.get(id=id)
raw_file_cnt = None
raw_file_resize = 0
if request.method == 'POST':
if vm.vm_type == 'Container Provider':
devices = models.Device.objects.filter(vm__id=vm.id)
for device in devices:
if device.dtype == 'RAW' and device.attributes.get('boot'):
raw_file_cnt = device.attributes.get('path')
raw_file_resize = device.attributes.get('size')
with client as c:
job_id = c.call('vm.fetch_image', 'RancherOS')
status = None
while status != 'SUCCESS':
__call = c.call('vm.get_download_status', job_id)
status = __call.get('state')
utils.dump_download_progress(__call)
if status == 'FAILED':
return HttpResponse('Error: Image download failed!')
elif status == 'ABORTED':
return HttpResponse('Error: Download aborted!')
if status == 'SUCCESS':
prebuilt_image = c.call('vm.image_path', 'RancherOS')
if prebuilt_image and raw_file_cnt:
c.call('vm.decompress_gzip', prebuilt_image,
raw_file_cnt)
c.call('vm.raw_resize', raw_file_cnt, raw_file_resize)
elif prebuilt_image is False:
return HttpResponse(
'Error: Checksum error in downloaded image. Image removed. Please retry.'
)
with client as c:
c.call('vm.start', id)
return JsonResp(request, message='VM Started')
return render(request, "vm/start.html", {
'name': vm.name,
})
def user_change(request):
extra_context = {}
changeform = forms.UserChangeForm(instance=request.user)
if request.method == 'POST':
changeform = forms.UserChangeForm(
instance=request.user,
data=request.POST,
)
if changeform.is_valid():
changeform.save()
return JsonResp(
request,
message=_("Admin user successfully updated.")
)
extra_context.update({
'form': changeform,
'inline': True,
})
return render(request, 'account/changeform.html', extra_context)
def volume_lock(request, object_id):
volume = models.Volume.objects.get(id=object_id)
assert(volume.vol_encrypt > 0)
if request.method == "POST":
notifier().volume_detach(volume)
if hasattr(notifier, 'failover_status') and notifier().failover_status() == 'MASTER':
from freenasUI.failover.enc_helper import LocalEscrowCtl
escrowctl = LocalEscrowCtl()
escrowctl.clear()
try:
os.unlink('/tmp/.failover_master')
except Exception:
pass
try:
with client as c:
c.call('failover.call_remote', 'failover.encryption_clearkey')
except Exception:
log.warn('Failed to clear key on standby node, is it down?', exc_info=True)
notifier().restart("system_datasets")
return JsonResp(request, message=_("Volume locked"))
return render(request, "storage/lock.html")
def volume_recoverykey_add(request, object_id):
volume = models.Volume.objects.get(id=object_id)
if request.method == "POST":
form = forms.KeyForm(request.POST)
if form.is_valid():
reckey = notifier().geli_recoverykey_add(volume)
request.session["allow_gelireckey"] = reckey
return JsonResp(
request,
message=_("GELI recovery key download starting..."),
events=["window.location='%s';" % (
reverse("storage_volume_recoverykey_download",
kwargs={'object_id': object_id}),
)],
)
else:
form = forms.KeyForm()
return render(request, "storage/recoverykey_add.html", {
'form': form,
})
def alert_dismiss(self, request):
from freenasUI.freeadmin.views import JsonResp
from freenasUI.system.models import Alert
from freenasUI.system.alert import alert_node
msgid = request.POST.get("msgid", None)
dismiss = request.POST.get("dismiss", None)
assert msgid is not None # FIX ME
try:
alert = Alert.objects.get(node=alert_node(), message_id=msgid)
if dismiss == "0":
alert.dismiss = False
alert.save()
elif dismiss == "1":
alert.dismiss = True
alert.save()
except Alert.DoesNotExist:
if dismiss == "1":
alert = Alert.objects.create(
node=alert_node(),
message_id=msgid,
dismiss=True,
)
return JsonResp(request, message="OK")
def password_change(request):
extra_context = {}
password_change_form = forms.PasswordChangeForm
passform = password_change_form(user=request.user)
if request.method == 'POST':
passform = password_change_form(user=request.user, data=request.POST)
if passform.is_valid():
if passform.cleaned_data['change_root']:
root = models.bsdUsers.objects.get(bsdusr_username='******')
new_password = passform.cleaned_data.get('new_password1')
bsdpasswdform = forms.bsdUserPasswordForm(instance=root)
bsdpasswdform.cleaned_data = {}
bsdpasswdform.cleaned_data['bsdusr_password1'] = new_password
bsdpasswdform.cleaned_data['bsdusr_password2'] = new_password
bsdpasswdform.save()
usable = request.user.has_usable_password()
passform.save()
events = []
if not usable:
from freenasUI.tools.alert import Alert
alert = Alert()
alert.perform()
alert.write()
del alert
events.append("loadalert()")
return JsonResp(request,
message=_("Password successfully updated."),
events=events)
extra_context.update({
'form': passform,
'inline': True,
})
return render(request, 'account/passform.html', extra_context)
def zvol_create(request, parent):
defaults = {
'zvol_compression': 'inherit',
}
if request.method == 'POST':
zvol_form = forms.ZVol_CreateForm(request.POST, vol_name=parent)
if zvol_form.is_valid():
props = {}
cleaned_data = zvol_form.cleaned_data
zvol_volsize = cleaned_data.get('zvol_volsize')
zvol_blocksize = cleaned_data.get("zvol_blocksize")
zvol_name = "%s/%s" % (parent, cleaned_data.get('zvol_name'))
zvol_comments = cleaned_data.get('zvol_comments')
zvol_compression = cleaned_data.get('zvol_compression')
props['compression'] = str(zvol_compression)
if zvol_blocksize:
props['volblocksize'] = zvol_blocksize
errno, errmsg = notifier().create_zfs_vol(name=str(zvol_name),
size=str(zvol_volsize),
sparse=cleaned_data.get(
"zvol_sparse",
False),
props=props)
notifier().zfs_set_option(name=str(zvol_name),
item="org.freenas:description",
value=zvol_comments)
if errno == 0:
return JsonResp(request,
message=_("ZFS Volume successfully added."))
else:
zvol_form.set_error(errmsg)
else:
zvol_form = forms.ZVol_CreateForm(initial=defaults, vol_name=parent)
return render(request, 'storage/zvols.html', {
'form': zvol_form,
'volume_name': parent,
})
def fiberchanneltotarget(request):
i = 0
while True:
fc_port = request.POST.get('fcport-%d-port' % i)
fc_target = request.POST.get('fcport-%d-target' % i)
if fc_port is None:
break
qs = models.FiberChannelToTarget.objects.filter(fc_port=fc_port)
if qs.exists():
fctt = qs[0]
else:
fctt = models.FiberChannelToTarget()
fctt.fc_port = fc_port
if fc_target in ('false', False):
fctt.fc_target = None
fctt.save()
elif fc_target is None:
if fctt.id:
fctt.delete()
else:
fctt.fc_target = models.iSCSITarget.objects.get(id=fc_target)
fctt.save()
i += 1
if i > 0:
notifier().reload("iscsitarget")
return JsonResp(
request,
message=_('Fiber Channel Ports have been successfully changed.'),
)
def volume_rekey(request, object_id):
_n = notifier()
standby_offline = False
if not _n.is_freenas() and _n.failover_licensed():
try:
with client as c:
c.call('failover.call_remote', 'core.ping')
except Exception:
standby_offline = True
volume = models.Volume.objects.get(id=object_id)
if request.method == "POST":
form = forms.ReKeyForm(request.POST, volume=volume)
if form.is_valid() and form.done():
return JsonResp(request, message=_("Encryption re-key succeeded"))
else:
form = forms.ReKeyForm(volume=volume)
return render(request, "storage/rekey.html", {
'form': form,
'volume': volume,
'standby_offline': standby_offline,
})
def delete(self, request, oid, mf=None):
from freenasUI.freeadmin.navtree import navtree
from freenasUI.freeadmin.views import JsonResp
from freenasUI.freeadmin.utils import get_related_objects
m = self._model
instance = get_object_or_404(m, pk=oid)
try:
_temp = __import__('%s.forms' % m._meta.app_label, globals(),
locals(), [m._admin.delete_form], 0)
form = getattr(_temp, m._admin.delete_form)
except:
form = None
if not isinstance(navtree._modelforms[m], dict):
mf = navtree._modelforms[m]
else:
if mf is None:
try:
mf = navtree._modelforms[m][m._admin.edit_modelform]
except:
mf = list(navtree._modelforms[m].values())[-1]
else:
mf = navtree._modelforms[m][mf]
related, related_num = get_related_objects(instance)
context = {
'app': m._meta.app_label,
'model': m._meta.model_name,
'oid': oid,
'object': instance,
'model_name': m._meta.model_name,
'verbose_name': instance._meta.verbose_name,
'related': related,
'related_num': related_num,
}
form_i = None
mf = mf(data=request.POST, instance=instance)
if request.method == "POST":
if form:
form_i = form(request.POST, instance=instance)
if form_i.is_valid():
if '__confirm' not in request.POST:
message = self.get_confirm_message(
'delete',
obj=instance,
form=form_i,
)
if message:
return JsonResp(
request,
confirm=self.confirm(message),
)
events = []
if hasattr(form_i, "done"):
form_i.done(events=events)
mf.delete(events=events)
return JsonResp(request,
message=_("%s successfully deleted.") %
(m._meta.verbose_name, ),
events=events)
else:
if '__confirm' not in request.POST:
message = self.get_confirm_message(
'delete',
obj=instance,
form=form_i,
)
if message:
return JsonResp(
request,
confirm=self.confirm(message),
)
events = []
mf.delete(events=events)
return JsonResp(request,
message=_("%s successfully deleted.") %
(m._meta.verbose_name, ),
events=events)
if form and form_i is None:
form_i = form(instance=instance)
if form:
context.update({'form': form_i})
template = "%s/%s_delete.html" % (
m._meta.app_label,
m._meta.object_name.lower(),
)
try:
get_template(template)
except TemplateDoesNotExist:
template = 'freeadmin/generic_model_delete.html'
return render(request, template, context)
def edit(self, request, oid, mf=None):
from freenasUI.freeadmin.navtree import navtree
from freenasUI.freeadmin.views import JsonResp
m = self._model
if 'inline' in request.GET:
inline = True
else:
inline = False
context = {
'app': m._meta.app_label,
'model': m,
'modeladmin': m._admin,
'mf': mf,
'oid': oid,
'inline': inline,
'extra_js': m._admin.extra_js,
'model_name': m._meta.model_name,
'verbose_name': m._meta.verbose_name,
'deletable': m._admin.deletable,
}
if 'deletable' in request.GET:
context.update({'deletable': False})
instance = get_object_or_404(m, pk=oid)
if not isinstance(navtree._modelforms[m], dict):
mf = navtree._modelforms[m]
else:
if mf is None:
try:
mf = navtree._modelforms[m][m.FreeAdmin.edit_modelform]
except:
mf = list(navtree._modelforms[m].values())[-1]
else:
mf = navtree._modelforms[m][mf]
formsets = {}
if request.method == "POST":
mf = mf(request.POST, request.FILES, instance=instance)
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
valid = True
if m._admin.inlines:
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
formset = inlineopts.get("formset")
_temp = __import__('%s.forms' % m._meta.app_label,
globals(), locals(), [inline], 0)
inline = getattr(_temp, inline)
if formset:
formset = getattr(_temp, formset)
else:
formset = FreeBaseInlineFormSet
extrakw = {
'can_delete': True,
}
fset_fac = inlineformset_factory(m,
inline._meta.model,
form=inline,
formset=formset,
extra=0,
**extrakw)
try:
fsname = 'formset_%s' % (
inline._meta.model._meta.model_name, )
fset = fset_fac(request.POST,
prefix=prefix,
parent=mf,
instance=instance)
formsets[fsname] = {
'instance': fset,
'position': inlineopts.get('position', 'bottom'),
}
except dforms.ValidationError:
pass
for name, fsinfo in list(formsets.items()):
for frm in fsinfo['instance'].forms:
valid &= frm.is_valid()
valid &= fsinfo['instance'].is_valid()
valid &= mf.is_valid(formsets=formsets)
if valid:
if '__confirm' not in request.POST:
message = self.get_confirm_message(
'edit',
obj=instance,
form=mf,
)
if message:
return JsonResp(
request,
confirm=self.confirm(message),
)
try:
mf.save()
if not isinstance(mf, MiddlewareModelForm):
for name, fsinfo in list(formsets.items()):
fsinfo['instance'].save()
events = []
if hasattr(mf, "done") and callable(mf.done):
mf.done(request=request, events=events)
if 'iframe' in request.GET:
return JsonResp(request,
form=mf,
formsets=formsets,
message=_("%s successfully updated.") %
(m._meta.verbose_name, ))
else:
return JsonResp(request,
form=mf,
formsets=formsets,
message=_("%s successfully updated.") %
(m._meta.verbose_name, ),
events=events)
except ValidationErrors as e:
handle_middleware_validation(mf, e)
return JsonResp(request, form=mf, formsets=formsets)
except ServiceFailed as e:
return JsonResp(
request,
form=mf,
error=True,
message=e.value,
events=["serviceFailed(\"%s\")" % e.service])
except MiddlewareError as e:
return JsonResp(request,
form=mf,
error=True,
message=_("Error: %s") % str(e))
else:
return JsonResp(request, form=mf, formsets=formsets)
else:
mf = mf(instance=instance)
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
if m._admin.inlines:
extrakw = {
'can_delete': True,
}
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
formset = inlineopts.get("formset")
_temp = __import__('%s.forms' % m._meta.app_label,
globals(), locals(), [inline], 0)
inline = getattr(_temp, inline)
if formset:
formset = getattr(_temp, formset)
else:
formset = FreeBaseInlineFormSet
"""
Do not add any extra empty form for the inline formset
in case there is already any item in the relationship
"""
extra = 1
fk_name = None
for field in inline._meta.model._meta.fields:
if isinstance(field, ForeignKey) and m is field.rel.to:
fk_name = field.name
break
if fk_name:
qs = inline._meta.model.objects.filter(
**{'%s__id' % fk_name: instance.pk})
if qs.count() > 0:
extra = 0
fset_fac = inlineformset_factory(m,
inline._meta.model,
form=inline,
formset=formset,
extra=extra,
**extrakw)
fsname = 'formset_%s' % (
inline._meta.model._meta.model_name, )
fset = fset_fac(
prefix=prefix,
instance=instance,
parent=mf,
)
fset.verbose_name = (inline._meta.model._meta.verbose_name)
formsets[fsname] = {
'instance': fset,
'position': inlineopts.get('position', 'bottom'),
}
context.update({
'form':
mf,
'formsets':
formsets,
'instance':
instance,
'delete_url':
reverse('freeadmin_%s_%s_delete' % (
m._meta.app_label,
m._meta.model_name,
),
kwargs={
'oid': instance.pk,
}),
'hook_buttons':
appPool.hook_form_buttons(
str(type(mf).__name__),
mf,
'edit',
),
})
context.update(self.get_extra_context('edit', request=request,
form=mf))
template = "%s/%s_edit.html" % (
m._meta.app_label,
m._meta.object_name.lower(),
)
try:
get_template(template)
except TemplateDoesNotExist:
template = 'freeadmin/generic_model_edit.html'
if 'iframe' in request.GET:
resp = render(request, template, context, content_type='text/html')
resp.content = ("<html><body><textarea>" + resp.content +
"</textarea></boby></html>")
return resp
else:
return render(request, template, context, content_type='text/html')
def add(self, request, mf=None):
"""
Magic happens here
We dynamically import the module based on app and model names
passed as view argument
From there we retrieve the ModelForm associated (which was discovered
previously on the auto_generate process)
"""
from freenasUI.freeadmin.navtree import navtree
from freenasUI.freeadmin.views import JsonResp
m = self._model
app = self._model._meta.app_label
context = {
'app': app,
'model': m,
'modeladmin': m._admin,
'mf': mf,
'model_name': m._meta.model_name,
'verbose_name': m._meta.verbose_name,
'extra_js': m._admin.extra_js,
}
if not isinstance(navtree._modelforms[m], dict):
mf = navtree._modelforms[m]
else:
if mf is None:
try:
mf = navtree._modelforms[m][m._admin.create_modelform]
except:
try:
mf = navtree._modelforms[m][m._admin.edit_modelform]
except:
mf = list(navtree._modelforms[m].values())[-1]
else:
mf = navtree._modelforms[m][mf]
instance = m()
formsets = {}
if request.method == "POST":
mf = mf(request.POST, request.FILES, instance=instance)
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
valid = True
if m._admin.inlines:
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
formset = inlineopts.get("formset")
_temp = __import__('%s.forms' % app, globals(), locals(),
[inline], 0)
inline = getattr(_temp, inline)
if formset:
formset = getattr(_temp, formset)
else:
formset = FreeBaseInlineFormSet
extrakw = {'can_delete': False}
fset_fac = inlineformset_factory(m,
inline._meta.model,
form=inline,
formset=formset,
extra=0,
**extrakw)
try:
fsname = 'formset_%s' % (
inline._meta.model._meta.model_name, )
fset = fset_fac(request.POST,
prefix=prefix,
parent=mf,
instance=instance)
formsets[fsname] = {
'instance': fset,
'position': inlineopts.get('position', 'bottom')
}
except dforms.ValidationError:
pass
for name, fsinfo in list(formsets.items()):
for frm in fsinfo['instance'].forms:
valid &= frm.is_valid()
valid &= fsinfo['instance'].is_valid()
valid &= mf.is_valid(formsets=formsets)
if valid:
if '__confirm' not in request.POST:
message = self.get_confirm_message(
'add',
obj=instance,
form=mf,
)
if message:
return JsonResp(
request,
confirm=self.confirm(message),
)
try:
mf.save()
if not isinstance(mf, MiddlewareModelForm):
for name, fsinfo in list(formsets.items()):
fsinfo['instance'].save()
events = []
if hasattr(mf, "done") and callable(mf.done):
mf.done(request=request, events=events)
return JsonResp(request,
form=mf,
formsets=formsets,
message=_("%s successfully updated.") %
(m._meta.verbose_name, ),
events=events)
except ValidationErrors as e:
handle_middleware_validation(mf, e)
return JsonResp(request, form=mf, formsets=formsets)
except ServiceFailed as e:
return JsonResp(
request,
error=True,
message=e.value,
events=["serviceFailed(\"%s\")" % e.service])
except MiddlewareError as e:
return JsonResp(request,
error=True,
message=_("Error: %s") % str(e))
else:
return JsonResp(request, form=mf, formsets=formsets)
else:
mf = mf()
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
if m._admin.inlines:
extrakw = {'can_delete': False}
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
formset = inlineopts.get("formset")
_temp = __import__('%s.forms' % app, globals(), locals(),
[inline], 0)
inline = getattr(_temp, inline)
if formset:
formset = getattr(_temp, formset)
else:
formset = FreeBaseInlineFormSet
fset_fac = inlineformset_factory(m,
inline._meta.model,
form=inline,
formset=formset,
extra=1,
**extrakw)
fsname = 'formset_%s' % (
inline._meta.model._meta.model_name, )
fset = fset_fac(prefix=prefix,
instance=instance,
parent=mf)
fset.verbose_name = (inline._meta.model._meta.verbose_name)
formsets[fsname] = {
'instance': fset,
'position': inlineopts.get('position', 'bottom'),
}
context.update({
'form': mf,
'formsets': formsets,
})
context.update(self.get_extra_context('add', request=request, form=mf))
template = "%s/%s_add.html" % (
m._meta.app_label,
m._meta.object_name.lower(),
)
try:
get_template(template)
except TemplateDoesNotExist:
template = 'freeadmin/generic_model_add.html'
return render(request, template, context)
def fibrechanneltotarget(request):
i = 0
sysctl_set = {}
loader = False
while True:
fc_port = request.POST.get('fcport-%d-port' % i)
fc_target = request.POST.get('fcport-%d-target' % i)
if fc_port is None:
break
port = fc_port.replace('isp', '').replace('/', ',')
if ',' in port:
port_number, vport = port.split(',', 1)
mibname = '%s.chan%s' % (port_number, vport)
else:
port_number = port
vport = None
mibname = port
role = sysctl.filter('dev.isp.%s.role' % mibname)
if role:
role = role[0]
tun_var = 'hint.isp.%s.role' % mibname
qs = models.FibreChannelToTarget.objects.filter(fc_port=fc_port)
if qs.exists():
fctt = qs[0]
else:
fctt = models.FibreChannelToTarget()
fctt.fc_port = fc_port
# Initiator mode
if fc_target in ('false', False):
if role:
# From disabled to initiator, just set sysctl
if role.value == 0:
role.value = 2
# From target to initiator, reload ctld then set to 2
elif role.value == 1:
sysctl_set[mibname] = 2
fctt.fc_target = None
fctt.save()
qs = Tunable.objects.filter(tun_var=tun_var)
if qs.exists():
tun = qs[0]
if tun.tun_value != '2':
tun.tun_value = '2'
loader = True
tun.save()
else:
tun = Tunable()
tun.tun_var = tun_var
tun.tun_value = '2'
tun.save()
loader = True
# Disabled
elif fc_target is None:
if role:
# From initiator to disabled, just set sysctl
if role.value == 2:
role.value = 0
if fctt.id:
fctt.delete()
qs = Tunable.objects.filter(tun_var=tun_var)
if qs.exists():
loader = True
qs.delete()
# Target mode
else:
if role:
# From initiator to target, first set sysctl
if role.value == 2:
role.value = 0
fctt.fc_target = models.iSCSITarget.objects.get(id=fc_target)
fctt.save()
qs = Tunable.objects.filter(tun_var=tun_var)
if qs.exists():
loader = True
qs.delete()
i += 1
if i > 0:
notifier().reload("iscsitarget")
for mibname, val in list(sysctl_set.items()):
role = sysctl.filter('dev.isp.%s.role' % mibname)
if role:
role = role[0]
role.value = val
if loader:
notifier().reload('loader')
return JsonResp(
request,
message=_('Fibre Channel Ports have been successfully changed.'),
)
def edit(self, request, oid, mf=None):
from freenasUI.freeadmin.navtree import navtree
from freenasUI.freeadmin.views import JsonResp
m = self._model
if 'inline' in request.GET:
inline = True
else:
inline = False
context = {
'app': m._meta.app_label,
'model': m,
'modeladmin': m._admin,
'mf': mf,
'oid': oid,
'inline': inline,
'extra_js': m._admin.extra_js,
'verbose_name': m._meta.verbose_name,
'deletable': m._admin.deletable,
}
if 'deletable' in request.GET:
context.update({'deletable': False})
instance = get_object_or_404(m, pk=oid)
if not isinstance(navtree._modelforms[m], dict):
mf = navtree._modelforms[m]
else:
if mf is None:
try:
mf = navtree._modelforms[m][m.FreeAdmin.edit_modelform]
except:
mf = navtree._modelforms[m].values()[-1]
else:
mf = navtree._modelforms[m][mf]
formsets = {}
if request.method == "POST":
mf = mf(request.POST, request.FILES, instance=instance)
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
valid = True
if m._admin.inlines:
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
_temp = __import__(
'%s.forms' % m._meta.app_label,
globals(),
locals(),
[inline],
-1)
inline = getattr(_temp, inline)
extrakw = {
'can_delete': True,
}
fset_fac = inlineformset_factory(
m,
inline._meta.model,
form=inline,
formset=FreeBaseInlineFormSet,
extra=0,
**extrakw)
try:
fsname = 'formset_%s' % (
inline._meta.model._meta.model_name,
)
fset = fset_fac(
request.POST,
prefix=prefix,
parent=mf,
instance=instance)
formsets[fsname] = {
'instance': fset,
'position': inlineopts.get('position', 'bottom'),
}
except dforms.ValidationError:
pass
for name, fsinfo in formsets.items():
for frm in fsinfo['instance'].forms:
valid &= frm.is_valid()
valid &= fsinfo['instance'].is_valid()
valid &= mf.is_valid(formsets=formsets)
if valid:
if '__confirm' not in request.POST:
message = self.get_confirm_message(
'edit',
obj=instance,
form=mf,
)
if message:
return JsonResp(
request,
confirm=self.confirm(message),
)
try:
mf.save()
for name, fsinfo in formsets.items():
fsinfo['instance'].save()
events = []
if hasattr(mf, "done") and callable(mf.done):
mf.done(request=request, events=events)
if 'iframe' in request.GET:
return JsonResp(
request,
form=mf,
formsets=formsets,
message=_("%s successfully updated.") % (
m._meta.verbose_name,
))
else:
return JsonResp(
request,
form=mf,
formsets=formsets,
message=_("%s successfully updated.") % (
m._meta.verbose_name,
),
events=events)
except ServiceFailed, e:
return JsonResp(
request,
form=mf,
error=True,
message=_("The service failed to restart."),
events=["serviceFailed(\"%s\")" % e.service])
except MiddlewareError, e:
return JsonResp(
request,
form=mf,
error=True,
message=_(u"Error: %s") % unicode(e))
def plugin_update(request, oid):
host = get_base_url(request)
jc = JailsConfiguration.objects.order_by("-id")[0]
logfile = '%s/warden.log' % jc.jc_path
if os.path.exists(logfile):
os.unlink(logfile)
if os.path.exists(WARDEN_EXTRACT_STATUS_FILE):
os.unlink(WARDEN_EXTRACT_STATUS_FILE)
if os.path.exists("/tmp/.plugin_upload_install"):
os.unlink("/tmp/.plugin_upload_install")
if os.path.exists("/tmp/.jailcreate"):
os.unlink("/tmp/.jailcreate")
if os.path.exists(PROGRESS_FILE):
os.unlink(PROGRESS_FILE)
iplugin = models.Plugins.objects.filter(id=oid)
if not iplugin:
raise MiddlewareError(_("Plugin not installed"))
iplugin = iplugin[0]
rplugin = None
for rp in availablePlugins.get_remote(cache=True):
if rp.name.lower() == iplugin.plugin_name.lower():
rplugin = rp
break
if not rplugin:
raise MiddlewareError(_("Invalid plugin"))
(p, js, jail_status) = get_plugin_status([iplugin, host, request])
if js and js['status'] == 'RUNNING':
(p, js, jail_status) = get_plugin_stop([iplugin, host, request])
if request.method == "POST":
plugin_upload_path = notifier().get_plugin_upload_path()
notifier().change_upload_location(plugin_upload_path)
if not rplugin.download("/var/tmp/firmware/pbifile.pbi"):
raise MiddlewareError(_("Failed to download plugin"))
jail = Jails.objects.filter(jail_host=iplugin.plugin_jail)
if not jail:
raise MiddlewareError(_("Jail does not exist"))
if notifier().update_pbi(plugin=iplugin):
notifier()._start_plugins(
jail=iplugin.plugin_jail,
plugin=iplugin.plugin_name,
)
else:
raise MiddlewareError(_("Failed to update plugin"))
return JsonResp(
request,
message=_("Plugin successfully updated"),
events=['reloadHttpd()'],
)
return render(request, "plugins/plugin_update.html", {
'plugin': rplugin,
})
def dataset_edit(request, dataset_name):
if request.method == 'POST':
dataset_form = forms.ZFSDataset(
request.POST, fs=dataset_name, create=False
)
if dataset_form.is_valid():
if dataset_form.cleaned_data["dataset_quota"] == "0":
dataset_form.cleaned_data["dataset_quota"] = "none"
if dataset_form.cleaned_data["dataset_refquota"] == "0":
dataset_form.cleaned_data["dataset_refquota"] = "none"
error = False
errors = {}
for attr in (
'org.freenas:description',
'compression',
'atime',
'dedup',
'reservation',
'refreservation',
'quota',
'refquota',
'share_type'
):
if attr == 'org.freenas:description':
formfield = 'dataset_comments'
else:
formfield = 'dataset_%s' % attr
val = dataset_form.cleaned_data[formfield]
if val == "inherit":
success, err = notifier().zfs_inherit_option(
dataset_name,
attr)
else:
if attr == "share_type":
notifier().change_dataset_share_type(
dataset_name, val)
else:
success, err = notifier().zfs_set_option(
dataset_name,
attr,
val)
error |= not success
if not success:
errors[formfield] = err
if not error:
return JsonResp(
request,
message=_("Dataset successfully edited."))
else:
for field, err in errors.items():
dataset_form._errors[field] = dataset_form.error_class([
err,
])
return JsonResp(request, form=dataset_form)
else:
return JsonResp(request, form=dataset_form)
else:
dataset_form = forms.ZFSDataset(fs=dataset_name, create=False)
return render(request, 'storage/dataset_edit.html', {
'dataset_name': dataset_name,
'form': dataset_form
})
def dataset_create(request, fs):
defaults = {'dataset_compression': 'inherit', 'dataset_atime': 'inherit'}
if request.method == 'POST':
dataset_form = forms.ZFSDataset(request.POST, fs=fs)
if dataset_form.is_valid():
props = {}
cleaned_data = dataset_form.cleaned_data
dataset_name = "%s/%s" % (fs, cleaned_data.get('dataset_name'))
dataset_compression = cleaned_data.get('dataset_compression')
dataset_share_type = cleaned_data.get('dataset_share_type')
if dataset_share_type == "windows":
props['aclmode'] = 'restricted'
props['casesensitivity'] = cleaned_data.get(
'dataset_case_sensitivity'
)
props['compression'] = dataset_compression.__str__()
dataset_atime = cleaned_data.get('dataset_atime')
props['atime'] = dataset_atime.__str__()
refquota = cleaned_data.get('dataset_refquota')
if refquota != '0':
props['refquota'] = refquota.__str__()
quota = cleaned_data.get('dataset_quota')
if quota != '0':
props['quota'] = quota.__str__()
refreservation = cleaned_data.get('dataset_refreservation')
if refreservation != '0':
props['refreservation'] = refreservation.__str__()
refreservation = cleaned_data.get('dataset_reservation')
if refreservation != '0':
props['refreservation'] = refreservation.__str__()
dedup = cleaned_data.get('dataset_dedup')
if dedup != 'inherit':
props['dedup'] = dedup.__str__()
recordsize = cleaned_data.get('dataset_recordsize')
if recordsize:
props['recordsize'] = recordsize
dataset_comments = cleaned_data.get('dataset_comments')
errno, errmsg = notifier().create_zfs_dataset(
path=str(dataset_name),
props=props)
notifier().zfs_set_option(name=str(dataset_name), item="org.freenas:description", value=dataset_comments)
if errno == 0:
if dataset_share_type == "unix":
notifier().dataset_init_unix(dataset_name)
elif dataset_share_type == "windows":
notifier().dataset_init_windows(dataset_name)
elif dataset_share_type == "mac":
notifier().dataset_init_apple(dataset_name)
return JsonResp(
request,
message=_("Dataset successfully added."))
else:
dataset_form.set_error(errmsg)
return JsonResp(request, form=dataset_form)
else:
return JsonResp(request, form=dataset_form)
else:
dataset_form = forms.ZFSDataset(initial=defaults, fs=fs)
return render(request, 'storage/datasets.html', {
'form': dataset_form,
'fs': fs,
})
except Exception as e:
raise MiddlewareError(e)
newplugin = []
if notifier().install_pbi(jail.jail_host, newplugin):
newplugin = newplugin[0]
notifier()._restart_plugins(
jail=newplugin.plugin_jail,
plugin=newplugin.plugin_name,
)
else:
jail.delete()
return JsonResp(
request,
message=_("Plugin successfully installed"),
events=['reloadHttpd()'],
)
return render(request, "plugins/available_install.html", {
'plugin': plugin,
})
def install_progress(request):
jc = JailsConfiguration.objects.order_by("-id")[0]
logfile = '%s/warden.log' % jc.jc_path
data = {}
if os.path.exists(PROGRESS_FILE):
data = {'step': 1}
with open(PROGRESS_FILE, 'r') as f:
m._meta.verbose_name,
),
events=events)
except MiddlewareError, e:
return JsonResp(
request,
error=True,
message=_(u"Error: %s") % unicode(e))
except ServiceFailed, e:
return JsonResp(
request,
error=True,
message=_("The service failed to restart.")
)
else:
return JsonResp(request, form=mf, formsets=formsets)
else:
mf = mf()
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
if m._admin.inlines:
extrakw = {
'can_delete': False
}
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
_temp = __import__(
'%s.forms' % app,
globals(),
def volumemanager(request):
if request.method == "POST":
form = forms.VolumeManagerForm(request.POST)
if form.is_valid() and form.save():
events = []
form.done(request, events)
return JsonResp(
request,
message=_("Volume successfully added."),
events=events,
)
else:
return JsonResp(request,
form=form,
formsets={'layout': {
'instance': form._formset,
}})
_n = notifier()
disks = []
# Grab disk list
# Root device already ruled out
for disk, info in list(_n.get_disks().items()):
disks.append(
forms.Disk(info['devname'],
info['capacity'],
serial=info.get('ident')))
disks = sorted(disks, key=cmp_to_key(_diskcmp))
# 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])
bysize = dict()
for d in list(disks):
if d.dev in used_disks:
continue
hsize = forms.humanize_number_si(d.size)
if hsize not in bysize:
bysize[hsize] = []
display_name = d.dev
if '/' in display_name:
display_name = display_name.split('/')[-1]
bysize[hsize].append({
'dev': d.dev,
'name': str(d),
'displayName': display_name,
'size': d.size,
'serial': d.serial,
})
bysize = OrderedDict(sorted(iter(bysize.items()), reverse=True))
swap = Advanced.objects.latest('id').adv_swapondrive
encwarn = (
'<span style="color: red; font-size:110%%;">%s</span>'
'<p>%s</p>'
'<p>%s</p>'
'<p>%s</p>'
) % (
_('WARNING!'),
_('Always backup the key! If the key is lost, the data on the disks '
'will also be lost with no hope of recovery.'),
_('This type of encryption is primarily targeted at users who are '
'storing sensitive data and want the ability to remove disks from '
'the pool and dispose of/re-use them without concern for erasure.'),
_('iXsystems, Inc. can not be held responsible for any lost '
'or unrecoverable data as a consequence of using this feature.'),
)
extend = [{'value': '', 'label': '-----'}]
qs = models.Volume.objects.all()
for vol in qs:
if not vol.is_decrypted():
continue
try:
_n.zpool_parse(vol.vol_name)
except:
continue
extend.append({
'label': vol.vol_name,
'value': vol.vol_name,
'enc': vol.vol_encrypt > 0
})
return render(
request, "storage/volumemanager.html", {
'disks': json.dumps(bysize),
'dedup_warning': forms.DEDUP_WARNING,
'encryption_warning': encwarn,
'swap_size': swap * 1024 * 1024 * 1024,
'manual_url': reverse('storage_volumemanager_zfs'),
'extend': json.dumps(extend),
})
def add(self, request, mf=None):
"""
Magic happens here
We dynamically import the module based on app and model names
passed as view argument
From there we retrieve the ModelForm associated (which was discovered
previously on the auto_generate process)
"""
from freenasUI.freeadmin.navtree import navtree
from freenasUI.freeadmin.views import JsonResp
m = self._model
app = self._model._meta.app_label
context = {
'app': app,
'model': m,
'modeladmin': m._admin,
'mf': mf,
'verbose_name': m._meta.verbose_name,
'extra_js': m._admin.extra_js,
}
if not isinstance(navtree._modelforms[m], dict):
mf = navtree._modelforms[m]
else:
if mf is None:
try:
mf = navtree._modelforms[m][m._admin.create_modelform]
except:
try:
mf = navtree._modelforms[m][m._admin.edit_modelform]
except:
mf = navtree._modelforms[m].values()[-1]
else:
mf = navtree._modelforms[m][mf]
instance = m()
formsets = {}
if request.method == "POST":
mf = mf(request.POST, request.FILES, instance=instance)
if m._admin.advanced_fields:
mf.advanced_fields.extend(m._admin.advanced_fields)
valid = True
if m._admin.inlines:
for inlineopts in m._admin.inlines:
inline = inlineopts.get("form")
prefix = inlineopts.get("prefix")
_temp = __import__(
'%s.forms' % app,
globals(),
locals(),
[inline],
-1)
inline = getattr(_temp, inline)
extrakw = {
'can_delete': False
}
fset = inlineformset_factory(
m,
inline._meta.model,
form=inline,
extra=0,
**extrakw)
try:
fsname = 'formset_%s' % (
inline._meta.model._meta.module_name,
)
formsets[fsname] = fset(
request.POST,
prefix=prefix,
instance=instance)
except dforms.ValidationError:
pass
for name, fs in formsets.items():
for frm in fs.forms:
frm.parent = mf
valid &= fs.is_valid()
valid &= mf.is_valid(formsets=formsets)
if valid:
try:
mf.save()
for name, fs in formsets.items():
fs.save()
events = []
if hasattr(mf, "done") and callable(mf.done):
mf.done(request=request, events=events)
return JsonResp(
request,
form=mf,
formsets=formsets,
message=_("%s successfully updated.") % (
m._meta.verbose_name,
),
events=events)
except MiddlewareError, e:
return JsonResp(
request,
error=True,
message=_(u"Error: %s") % unicode(e))
except ServiceFailed, e:
return JsonResp(
request,
error=True,
message=_("The service failed to restart.")
)
