Exemple #1
0
    def post(self, request):
        with self._handle_exception(request):
            if ('shares' not in request.data):
                e_msg = ('Cannot export without specifying shares')
                handle_exception(Exception(e_msg), request)
            shares = [validate_share(s, request) for s in request.data['shares']]
            options = parse_options(request)
            for s in shares:
                dup_export_check(s, options['host_str'], request)

            cur_exports = list(NFSExport.objects.all())
            eg = NFSExportGroup(**options)
            eg.save()
            for s in shares:
                mnt_pt = ('%s%s' % (settings.MNT_PT, s.name))
                export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, s.name))
                if (not is_share_mounted(s.name)):
                    pool_device = Disk.objects.filter(pool=s.pool)[0].name
                    mount_share(s, pool_device, mnt_pt)
                export = NFSExport(export_group=eg, share=s, mount=export_pt)
                export.full_clean()
                export.save()
                cur_exports.append(export)

            exports = create_nfs_export_input(cur_exports)
            adv_entries = [e.export_str for e in
                           AdvancedNFSExport.objects.all()]
            exports_d = create_adv_nfs_export_input(adv_entries, request)
            exports.update(exports_d)
            refresh_wrapper(exports, request, logger)
            nfs_serializer = NFSExportGroupSerializer(eg)
            return Response(nfs_serializer.data)
    def post(self, request, sname):
        try:
            share = validate_share(sname, request)
            options = parse_options(request)
            dup_export_check(share, options['host_str'], request)
            cur_exports = list(NFSExport.objects.all())
            eg = NFSExportGroup(**options)
            eg.save()
            mnt_pt = ('%s%s' % (settings.MNT_PT, share.name))
            export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, share.name))
            if (not is_share_mounted(share.name)):
                pool_device = Disk.objects.filter(pool=share.pool)[0].name
                mount_share(share.subvol_name, pool_device, mnt_pt)
            export = NFSExport(export_group=eg, share=share, mount=export_pt)
            export.full_clean()
            export.save()
            cur_exports.append(export)

            exports = create_nfs_export_input(cur_exports)
            refresh_wrapper(exports, request, logger)
            nfs_serializer = NFSExportGroupSerializer(eg)
            return Response(nfs_serializer.data)
        except RockStorAPIException:
            raise
        except Exception, e:
            handle_exception(e, request)
Exemple #3
0
    def post(self, request):
        with self._handle_exception(request):
            if ('shares' not in request.data):
                e_msg = ('Cannot export without specifying shares')
                handle_exception(Exception(e_msg), request)
            shares = [
                validate_share(s, request) for s in request.data['shares']
            ]
            options = parse_options(request)
            for s in shares:
                dup_export_check(s, options['host_str'], request)

            cur_exports = list(NFSExport.objects.all())
            eg = NFSExportGroup(**options)
            eg.save()
            for s in shares:
                mnt_pt = ('%s%s' % (settings.MNT_PT, s.name))
                export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, s.name))
                if (not is_share_mounted(s.name)):
                    pool_device = Disk.objects.filter(pool=s.pool)[0].name
                    mount_share(s, pool_device, mnt_pt)
                export = NFSExport(export_group=eg, share=s, mount=export_pt)
                export.full_clean()
                export.save()
                cur_exports.append(export)

            exports = create_nfs_export_input(cur_exports)
            adv_entries = [
                e.export_str for e in AdvancedNFSExport.objects.all()
            ]
            exports_d = create_adv_nfs_export_input(adv_entries, request)
            exports.update(exports_d)
            refresh_wrapper(exports, request, logger)
            nfs_serializer = NFSExportGroupSerializer(eg)
            return Response(nfs_serializer.data)
Exemple #4
0
    def post(self, request, sname):
        try:
            share = validate_share(sname, request)
            options = parse_options(request)
            dup_export_check(share, options['host_str'], request)
            cur_exports = list(NFSExport.objects.all())
            eg = NFSExportGroup(**options)
            eg.save()
            mnt_pt = ('%s%s' % (settings.MNT_PT, share.name))
            export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, share.name))
            if (not is_share_mounted(share.name)):
                pool_device = Disk.objects.filter(pool=share.pool)[0].name
                mount_share(share.subvol_name, pool_device, mnt_pt)
            export = NFSExport(export_group=eg, share=share, mount=export_pt)
            export.full_clean()
            export.save()
            cur_exports.append(export)

            exports = create_nfs_export_input(cur_exports)
            refresh_wrapper(exports, request, logger)
            nfs_serializer = NFSExportGroupSerializer(eg)
            return Response(nfs_serializer.data)
        except RockStorAPIException:
            raise
        except Exception, e:
            handle_exception(e, request)
Exemple #5
0
    def post(self, request):
        if ('shares' not in request.DATA):
            e_msg = ('Cannot export without specifying shares')
            handle_exception(Exception(e_msg), request)
        shares = [validate_share(s, request) for s in request.DATA['shares']]
        try:
            options = parse_options(request)
            for s in shares:
                dup_export_check(s, options['host_str'], request)

            cur_exports = list(NFSExport.objects.all())
            eg = NFSExportGroup(**options)
            eg.save()
            for s in shares:
                mnt_pt = ('%s%s' % (settings.MNT_PT, s.name))
                export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, s.name))
                if (not is_share_mounted(s.name)):
                    pool_device = Disk.objects.filter(pool=s.pool)[0].name
                    mount_share(s.subvol_name, pool_device, mnt_pt)
                export = NFSExport(export_group=eg, share=s, mount=export_pt)
                export.full_clean()
                export.save()
                cur_exports.append(export)

            exports = create_nfs_export_input(cur_exports)
            refresh_wrapper(exports, request, logger)
            nfs_serializer = NFSExportGroupSerializer(eg)
            return Response(nfs_serializer.data)
        except RockStorAPIException:
            raise
        except Exception, e:
            handle_exception(e, request)
Exemple #6
0
 def put(self, request, sname, export_id):
     with self._handle_exception(request):
         share = validate_share(sname, request)
         eg = validate_export_group(export_id, request)
         options = parse_options(request)
         dup_export_check(share, options["host_str"], request, export_id=int(export_id))
         NFSExportGroup.objects.filter(id=export_id).update(**options)
         NFSExportGroup.objects.filter(id=export_id)[0].save()
         cur_exports = list(NFSExport.objects.all())
         exports = create_nfs_export_input(cur_exports)
         refresh_wrapper(exports, request, logger)
         nfs_serializer = NFSExportGroupSerializer(eg)
         return Response(nfs_serializer.data)
Exemple #7
0
 def put(self, request, sname, export_id):
     with self._handle_exception(request):
         share = validate_share(sname, request)
         eg = validate_export_group(export_id, request)
         options = parse_options(request)
         dup_export_check(share, options['host_str'], request,
                          export_id=int(export_id))
         NFSExportGroup.objects.filter(id=export_id).update(**options)
         NFSExportGroup.objects.filter(id=export_id)[0].save()
         cur_exports = list(NFSExport.objects.all())
         exports = create_nfs_export_input(cur_exports)
         refresh_wrapper(exports, request, logger)
         nfs_serializer = NFSExportGroupSerializer(eg)
         return Response(nfs_serializer.data)
Exemple #8
0
 def put(self, request, export_id):
     if ('shares' not in request.DATA):
         e_msg = ('Cannot export without specifying shares')
         handle_exception(Exception(e_msg), request)
     shares = [validate_share(s, request) for s in request.DATA['shares']]
     try:
         eg = validate_export_group(export_id, request)
         options = parse_options(request)
         for s in shares:
             dup_export_check(s,
                              options['host_str'],
                              request,
                              export_id=int(export_id))
         NFSExportGroup.objects.filter(id=export_id).update(**options)
         NFSExportGroup.objects.filter(id=export_id)[0].save()
         cur_exports = list(NFSExport.objects.all())
         for e in NFSExport.objects.filter(export_group=eg):
             if (e.share not in shares):
                 cur_exports.remove(e)
                 e.delete()
             else:
                 shares.remove(e.share)
         for s in shares:
             mnt_pt = ('%s%s' % (settings.MNT_PT, s.name))
             export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, s.name))
             if (not is_share_mounted(s.name)):
                 pool_device = Disk.objects.filter(pool=s.pool)[0].name
                 mount_share(s.subvol_name, pool_device, mnt_pt)
             export = NFSExport(export_group=eg, share=s, mount=export_pt)
             export.full_clean()
             export.save()
             cur_exports.append(export)
         exports = create_nfs_export_input(cur_exports)
         adv_entries = [
             e.export_str for e in AdvancedNFSExport.objects.all()
         ]
         exports_d = create_adv_nfs_export_input(adv_entries, request)
         exports.update(exports_d)
         refresh_wrapper(exports, request, logger)
         nfs_serializer = NFSExportGroupSerializer(eg)
         return Response(nfs_serializer.data)
     except RockStorAPIException:
         raise
     except Exception, e:
         handle_exception(e, request)
 def put(self, request, export_id):
     if ('shares' not in request.DATA):
         e_msg = ('Cannot export without specifying shares')
         handle_exception(Exception(e_msg), request)
     shares = [validate_share(s, request) for s in request.DATA['shares']]
     try:
         eg = validate_export_group(export_id, request)
         options = parse_options(request)
         for s in shares:
             dup_export_check(s, options['host_str'], request,
                              export_id=int(export_id))
         NFSExportGroup.objects.filter(id=export_id).update(**options)
         NFSExportGroup.objects.filter(id=export_id)[0].save()
         cur_exports = list(NFSExport.objects.all())
         for e in NFSExport.objects.filter(export_group=eg):
             if (e.share not in shares):
                 cur_exports.remove(e)
                 e.delete()
             else:
                 shares.remove(e.share)
         for s in shares:
             mnt_pt = ('%s%s' % (settings.MNT_PT, s.name))
             export_pt = ('%s%s' % (settings.NFS_EXPORT_ROOT, s.name))
             if (not is_share_mounted(s.name)):
                 pool_device = Disk.objects.filter(pool=s.pool)[0].name
                 mount_share(s.subvol_name, pool_device, mnt_pt)
             export = NFSExport(export_group=eg, share=s, mount=export_pt)
             export.full_clean()
             export.save()
             cur_exports.append(export)
         exports = create_nfs_export_input(cur_exports)
         adv_entries = [e.export_str for e in
                        AdvancedNFSExport.objects.all()]
         exports_d = create_adv_nfs_export_input(adv_entries, request)
         exports.update(exports_d)
         refresh_wrapper(exports, request, logger)
         nfs_serializer = NFSExportGroupSerializer(eg)
         return Response(nfs_serializer.data)
     except RockStorAPIException:
         raise
     except Exception, e:
         handle_exception(e, request)
Exemple #10
0
    def post(self, request, sname):
        with self._handle_exception(request):
            share = validate_share(sname, request)
            options = parse_options(request)
            dup_export_check(share, options["host_str"], request)
            cur_exports = list(NFSExport.objects.all())
            eg = NFSExportGroup(**options)
            eg.save()
            mnt_pt = "%s%s" % (settings.MNT_PT, share.name)
            export_pt = "%s%s" % (settings.NFS_EXPORT_ROOT, share.name)
            if not is_share_mounted(share.name):
                mount_share(share, mnt_pt)
            export = NFSExport(export_group=eg, share=share, mount=export_pt)
            export.full_clean()
            export.save()
            cur_exports.append(export)

            exports = create_nfs_export_input(cur_exports)
            refresh_wrapper(exports, request, logger)
            nfs_serializer = NFSExportGroupSerializer(eg)
            return Response(nfs_serializer.data)