def snapshot_rollback(request, dataset, snapname): snapshot = '%s@%s' % (dataset, snapname) if request.method == "POST": ret = notifier().rollback_zfs_snapshot(snapshot=snapshot.__str__()) if ret == '': return JsonResponse(message=_("Rollback successful.")) else: return JsonResponse(error=True, message=ret) else: return render(request, 'storage/snapshot_confirm_rollback.html', { 'snapname': snapname, 'dataset': dataset, })
def snapshot_delete(request, dataset, snapname): snapshot = '%s@%s' % (dataset, snapname) if request.method == 'POST': retval = notifier().destroy_zfs_dataset(path=str(snapshot)) if retval == '': notifier().restart("collectd") return JsonResponse(message=_("Snapshot successfully deleted.")) else: return JsonResponse(error=True, message=retval) else: return render(request, 'storage/snapshot_confirm_delete.html', { 'snapname': snapname, 'dataset': dataset, })
def snapshot_delete_bulk(request): snaps = request.POST.get("snaps", None) delete = request.POST.get("delete", None) if snaps and delete == "true": snap_list = snaps.split('|') for snapshot in snap_list: retval = notifier().destroy_zfs_dataset(path=str(snapshot)) if retval != '': return JsonResponse(error=True, message=retval) notifier().restart("collectd") return JsonResponse(message=_("Snapshots successfully deleted.")) return render(request, 'storage/snapshot_confirm_delete_bulk.html', { 'snaps': snaps, })
def shutdown_dialog(request): if request.method == "POST": request.session['allow_shutdown'] = True return JsonResponse(error=False, message=_("Shutdown is being issued"), events=['window.location="%s"' % reverse('system_shutdown')]) return render(request, 'system/shutdown_dialog.html')
def zvol_create(request, volume_name): defaults = { 'zvol_compression': 'inherit', } if request.method == 'POST': zvol_form = forms.ZVol_CreateForm(request.POST, vol_name=volume_name) if zvol_form.is_valid(): props = {} cleaned_data = zvol_form.cleaned_data zvol_size = cleaned_data.get('zvol_size') zvol_name = "%s/%s" % (volume_name, cleaned_data.get('zvol_name')) zvol_compression = cleaned_data.get('zvol_compression') props['compression'] = str(zvol_compression) errno, errmsg = notifier().create_zfs_vol(name=str(zvol_name), size=str(zvol_size), props=props) if errno == 0: return JsonResponse( message=_("ZFS Volume successfully added.")) else: zvol_form.set_error(errmsg) else: zvol_form = forms.ZVol_CreateForm(initial=defaults, vol_name=volume_name) return render(request, 'storage/zvols.html', { 'form': zvol_form, 'volume_name': volume_name, })
def wizard(request): if request.method == "POST": form = forms.VolumeWizardForm(request.POST) if form.is_valid(): form.done(request) return JsonResponse(message=_("Volume successfully added.")) 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 request.POST.keys() if zpoolfields.match(i)] else: form = forms.VolumeWizardForm() disks = [] zfsextra = None return render( request, 'storage/wizard.html', { 'form': form, 'disks': disks, 'zfsextra': zfsextra, 'zfsversion': notifier().zfs_get_version(), })
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 metanasUI.tools.alert import Alert alert = Alert() alert.perform() alert.write() del alert events.append("loadalert()") return JsonResponse(message=_("Password successfully updated."), events=events) extra_context.update({ 'form' : passform, 'inline': True, }) return render(request, 'account/passform.html', extra_context)
def clonesnap(request, snapshot): initial = {'cs_snapshot': snapshot} if request.method == "POST": form = forms.CloneSnapshotForm(request.POST, initial=initial) if form.is_valid(): retval = form.commit() if retval == '': return JsonResponse(message=_("Snapshot successfully cloned.")) else: return JsonResponse(error=True, message=retval) else: is_volume = 'volume' in request.GET form = forms.CloneSnapshotForm(initial=initial, is_volume=is_volume) return render(request, 'storage/clonesnap.html', { 'form': form, 'snapshot': snapshot, })
def geom_disk_replace(request, vname): volume = models.Volume.objects.get(vol_name=vname) if request.method == "POST": form = forms.UFSDiskReplacementForm(request.POST) if form.is_valid(): if form.done(volume): return JsonResponse( message=_("Disk replacement has been initiated.")) else: return JsonResponse(error=True, message=_("An error occurred.")) else: form = forms.UFSDiskReplacementForm() return render(request, 'storage/geom_disk_replace.html', { 'form': form, 'vname': vname, })
def volume_detach(request, vid): volume = models.Volume.objects.get(pk=vid) usedbytes = sum( [mp._get_used_bytes() for mp in volume.mountpoint_set.all()]) usedsize = humanize_size(usedbytes) services = volume.has_attachments() if request.method == "POST": form = forms.VolumeExport(request.POST, instance=volume, services=services) if form.is_valid(): try: volume.delete(destroy=form.cleaned_data['mark_new'], cascade=form.cleaned_data.get('cascade', True)) return JsonResponse( message=_("The volume has been successfully detached")) except ServiceFailed, e: return JsonResponse(error=True, message=unicode(e))
def dataset_delete(request, name): datasets = zfs.list_datasets(path=name, recursive=True) if request.method == 'POST': form = forms.Dataset_Destroy(request.POST, fs=name, datasets=datasets) if form.is_valid(): retval = notifier().destroy_zfs_dataset(path=name, recursive=True) if retval == '': notifier().restart("collectd") return JsonResponse( message=_("Dataset successfully destroyed.")) else: return JsonResponse(error=True, message=retval) else: form = forms.Dataset_Destroy(fs=name, datasets=datasets) return render(request, 'storage/dataset_confirm_delete.html', { 'name': name, 'form': form, 'datasets': datasets, })
def process_response(self, request, response): if sys.exc_type and sys.exc_type in (MiddlewareError, ServiceFailed): excp = sys.exc_info()[1] kwargs = { 'error': True, 'message': _("Error: %s") % unicode(excp.value), } if not request.is_ajax(): kwargs['enclosed'] = True return JsonResponse(**kwargs) return response
def done(self, request, form_list): retval = getattr(self, 'retval', None) events = [] if not retval: events.append('reloadHttpd()') return JsonResponse( error=bool(retval), message=retval if retval else __("PBI successfully installed."), enclosed=not request.is_ajax(), events=events, )
def zvol_delete(request, name): if request.method == 'POST': extents = iSCSITargetExtent.objects.filter( iscsi_target_extent_type='ZVOL', iscsi_target_extent_path='zvol/' + name) if extents.count() > 0: return JsonResponse( error=True, message=_("This is in use by the iscsi target, please remove " "it there first.")) retval = notifier().destroy_zfs_vol(name) if retval == '': return JsonResponse( message=_("ZFS Volume successfully destroyed.")) else: return JsonResponse(error=True, message=retval) else: return render(request, 'storage/zvol_confirm_delete.html', { 'name': name, })
def manualsnap(request, fs): if request.method == "POST": form = forms.ManualSnapshotForm(request.POST) if form.is_valid(): form.commit(fs) return JsonResponse(message=_("Snapshot successfully taken.")) else: form = forms.ManualSnapshotForm() return render(request, 'storage/manualsnap.html', { 'form': form, 'fs': fs, })
def user2group_update(request, object_id): if request.method == 'POST': f = forms.bsdUserToGroupForm(object_id, request.POST) if f.is_valid(): f.save() return JsonResponse(message=_("Groups successfully updated.")) else: f = forms.bsdUserToGroupForm(userid=object_id) return render(request, 'account/bsdgroup2user_form.html', { 'url': reverse('account_bsduser_groups', kwargs={'object_id':object_id}), 'form' : f, })
def lagg_add(request): lagg = forms.LAGGInterfaceForm() if request.method == 'POST': lagg = forms.LAGGInterfaceForm(request.POST) if lagg.is_valid(): _lagg_performadd(lagg) return JsonResponse(message=_("LAGG successfully added")) return render(request, 'network/lagg_add.html', { 'form': lagg, })
def zpool_disk_replace(request, vname, label): disk = notifier().label_to_disk(label) volume = models.Volume.objects.get(vol_name=vname) if request.method == "POST": form = forms.ZFSDiskReplacementForm(request.POST, disk=disk) if form.is_valid(): if form.done(volume, disk, label): return JsonResponse( message=_("Disk replacement has been initiated.")) else: return JsonResponse(error=True, message=_("An error occurred.")) else: form = forms.ZFSDiskReplacementForm(disk=disk) return render(request, 'storage/zpool_disk_replace.html', { 'form': form, 'vname': vname, 'label': label, 'disk': disk, })
def disk_detach(request, vname, label): volume = models.Volume.objects.get(vol_name=vname) if request.method == "POST": notifier().zfs_detach_disk(volume, label) return JsonResponse( message=_("Disk detach has been successfully done.")) return render(request, 'storage/disk_detach.html', { 'vname': vname, 'label': label, })
def zpool_scrub(request, vid): volume = models.Volume.objects.get(pk=vid) pool = notifier().zpool_parse(volume.vol_name) 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 JsonResponse(message=_("The scrub process has begun")) return render(request, 'storage/scrub_confirm.html', { 'volume': volume, 'scrub': pool.scrub, })
def zfsvolume_edit(request, object_id): mp = models.MountPoint.objects.get(pk=object_id) volume_form = forms.ZFSVolume_EditForm(mp=mp) if request.method == 'POST': volume_form = forms.ZFSVolume_EditForm(request.POST, mp=mp) if volume_form.is_valid(): volume = mp.mp_volume volume_name = volume.vol_name volume_name = mp.mp_path.replace("/mnt/", "") if volume_form.cleaned_data["volume_refquota"] == "0": volume_form.cleaned_data["volume_refquota"] = "none" error, errors = False, {} for attr in ( 'compression', 'atime', 'refquota', 'refreservation', ): formfield = 'volume_%s' % attr if volume_form.cleaned_data[formfield] == "inherit": success, err = notifier().zfs_inherit_option( volume_name, attr, ) else: success, err = notifier().zfs_set_option( volume_name, attr, volume_form.cleaned_data[formfield], ) if not success: error = True errors[formfield] = err if not error: return JsonResponse( message=_("Native dataset successfully edited.")) else: for field, err in errors.items(): volume_form._errors[field] = volume_form.error_class([ err, ]) return render(request, 'storage/volume_edit.html', { 'mp': mp, 'form': volume_form })
def zpool_disk_remove(request, vname, label): volume = models.Volume.objects.get(vol_name=vname) disk = notifier().label_to_disk(label) if request.method == "POST": notifier().zfs_remove_disk(volume, label) return JsonResponse(message=_("Disk has been removed.")) return render(request, 'storage/disk_remove.html', { 'vname': vname, 'label': label, 'disk': disk, })
def mp_permission(request, path): path = '/' + path if request.method == 'POST': form = forms.MountPointAccessForm(request.POST) if form.is_valid(): form.commit(path=path) return JsonResponse( message=_("Mount Point permissions successfully updated.")) else: form = forms.MountPointAccessForm(initial={'path': path}) return render(request, 'storage/permission.html', { 'path': path, 'form': form, })
def dataset_edit(request, dataset_name): if request.method == 'POST': dataset_form = forms.ZFSDataset_EditForm(request.POST, fs=dataset_name) 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 ( 'compression', 'atime', 'reservation', 'refreservation', 'quota', 'refquota', ): formfield = 'dataset_%s' % attr if dataset_form.cleaned_data[formfield] == "inherit": success, err = notifier().zfs_inherit_option( dataset_name, attr, ) else: success, err = notifier().zfs_set_option( dataset_name, attr, dataset_form.cleaned_data[formfield], ) error |= not success if not success: errors[formfield] = err if not error: return JsonResponse(message=_("Dataset successfully edited.")) else: for field, err in errors.items(): dataset_form._errors[field] = dataset_form.error_class([ err, ]) else: dataset_form = forms.ZFSDataset_EditForm(fs=dataset_name) return render(request, 'storage/dataset_edit.html', { 'dataset_name': dataset_name, 'form': dataset_form })
def periodicsnap(request): if request.method == "POST": form = forms.PeriodicSnapForm(request.POST) if form.is_valid(): form.save() return JsonResponse(message=_("Snapshot successfully added.")) else: form = forms.PeriodicSnapForm() return render(request, 'storage/periodicsnap.html', { 'form': form, 'extra_js': models.Task._admin.extra_js, })
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 JsonResponse(message=_("Admin user successfully updated.")) extra_context.update({ 'form' : changeform, 'inline': True, }) return render(request, 'account/changeform.html', extra_context)
def plugin_edit(request, plugin_id): plugin = models.Plugins.objects.filter(id=plugin_id)[0] if request.method == 'POST': plugins_form = forms.PluginsForm(request.POST, instance=plugin) if plugins_form.is_valid(): plugins_form.save() return JsonResponse(message=_("Plugin successfully updated.")) else: plugin = None else: plugins_form = forms.PluginsForm(instance=plugin) return render(request, 'plugins/plugin_edit.html', { 'plugin_id': plugin_id, 'form': plugins_form })
def volautoimport(request): if request.method == "POST": form = forms.VolumeAutoImportForm(request.POST) if form.is_valid(): form.done(request) return JsonResponse(message=_("Volume successfully added.")) else: if 'volume_disks' in request.POST: disks = request.POST.getlist('volume_disks') else: disks = None else: form = forms.VolumeAutoImportForm() disks = [] return render(request, 'storage/autoimport.html', { 'form': form, 'disks': disks })
def plugin_update(request, plugin_id): if request.method == "POST": pj = PluginsJail.objects.order_by("-id")[0] notifier().change_upload_location(pj.plugins_path) form = forms.PBIUpdateForm(request.POST, request.FILES) if form.is_valid(): form.done() return JsonResponse(message=_('Plugin successfully updated'), events=['reloadHttpd()'], enclosed=True) else: resp = render(request, "plugins/plugin_update.html", { 'form': form, }) resp.content = ("<html><body><textarea>" + resp.content + "</textarea></boby></html>") return resp else: form = forms.PBIUpdateForm() return render(request, "plugins/plugin_update.html", { 'form': form, })
def dataset_create(request, fs): defaults = {'dataset_compression': 'inherit', 'dataset_atime': 'inherit'} if request.method == 'POST': dataset_form = forms.ZFSDataset_CreateForm(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') 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_refreserv') if refreservation != '0': props['refreservation'] = refreservation.__str__() refreservation = cleaned_data.get('dataset_reserv') if refreservation != '0': props['refreservation'] = refreservation.__str__() errno, errmsg = notifier().create_zfs_dataset( path=str(dataset_name), props=props) if errno == 0: return JsonResponse(message=_("Dataset successfully added.")) else: dataset_form.set_error(errmsg) else: dataset_form = forms.ZFSDataset_CreateForm(initial=defaults, fs=fs) return render(request, 'storage/datasets.html', { 'form': dataset_form, 'fs': fs, })