def create_clone(share, new_name, request, logger, snapshot=None): # if snapshot is None, create clone of the share. # If it's not, then clone it. if (re.match(settings.SHARE_REGEX + '$', new_name) is None): e_msg = ('Clone name is invalid. It must start with a letter and can' ' contain letters, digits, _, . and - characters') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=new_name).exists()): e_msg = ('Another Share with name: %s already exists.' % new_name) handle_exception(Exception(e_msg), request) if (Snapshot.objects.filter(share=share, name=new_name).exists()): e_msg = ('Snapshot with name: %s already exists for the ' 'share: %s. Choose a different name' % (new_name, share.name)) handle_exception(Exception(e_msg), request) try: share_name = share.subvol_name snap = None if (snapshot is not None): snap = snapshot.real_name add_clone(share.pool, share_name, new_name, snapshot=snap) snap_id = share_id(share.pool, new_name) qgroup_id = ('0/%s' % snap_id) update_quota(share.pool, qgroup_id, share.size * 1024) new_share = Share(pool=share.pool, qgroup=qgroup_id, name=new_name, size=share.size, subvol_name=new_name) new_share.save() return Response(ShareSerializer(new_share).data) except Exception, e: handle_exception(e, request)
def create_clone(share, new_name, request, logger): if (Share.objects.filter(name=new_name).exists()): e_msg = ('Share with name: %s already exists.' % new_name) handle_exception(Exception(e_msg), request) pool_device = Disk.objects.filter(pool=share.pool)[0].name snap_name = ('%s-clone-%s-snapshot' % (share.name, new_name)) if (Snapshot.objects.filter(share=share, name=snap_name).exists()): e_msg = ('Snapshot with name: %s already exists for the ' 'share: %s' % (snap_name, share.name)) handle_exception(Exception(e_msg), request) try: add_snap(share.pool.name, pool_device, share.subvol_name, snap_name, share_prepend=False) snap_id = share_id(share.pool.name, pool_device, snap_name) qgroup_id = ('0/%s' % snap_id) update_quota(share.pool.name, pool_device, qgroup_id, share.size * 1024) new_share = Share(pool=share.pool, qgroup=qgroup_id, name=new_name, size=share.size, subvol_name=snap_name) new_share.save() return Response(ShareSerializer(new_share).data) except Exception, e: e_msg = ('Failed to create clone due to a system error.') logger.error(e_msg) logger.exception(e) handle_exception(Exception(e_msg), request)
def post(self, request): try: sname = request.DATA['sname'] if (Share.objects.filter(name=sname).exists()): e_msg = ('Share with name: %s already exists.' % sname) handle_exception(Exception(e_msg), request) pool_name = request.DATA['pool'] size = int(request.DATA['size']) #in KB self._validate_share_size(request, size) pool = None try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool with name: %s does not exist.' % pool_name) handle_exception(Exception(e_msg), request) disk = None try: disk = Disk.objects.filter(pool=pool)[0] except: e_msg = ('Pool with name: %s does not have any disks in it.' % pool_name) handle_exception(Exception(e_msg), request) add_share(pool_name, disk.name, sname) qgroup_id = self._update_quota(pool_name, disk.name, sname, size) s = Share(pool=pool, qgroup=qgroup_id, name=sname, size=size, subvol_name=sname) s.save() return Response(ShareSerializer(s).data) except RockStorAPIException: raise except Exception, e: handle_exception(e, request)
def create_clone(share, new_name, request, logger, snapshot=None): # if snapshot is None, create clone of the share. # If it's not, then clone it. if (re.match(settings.SHARE_REGEX + '$', new_name) is None): e_msg = ('Clone name is invalid. It must start with a letter and can' ' contain letters, digits, _, . and - characters') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=new_name).exists()): e_msg = ('Another Share with name: %s already exists.' % new_name) handle_exception(Exception(e_msg), request) if (Snapshot.objects.filter(share=share, name=new_name).exists()): e_msg = ('Snapshot with name: %s already exists for the ' 'share: %s. Choose a different name' % (new_name, share.name)) handle_exception(Exception(e_msg), request) try: share_name = share.subvol_name snap = None if (snapshot is not None): snap = snapshot.real_name add_clone(share.pool, share_name, new_name, snapshot=snap) snap_id = share_id(share.pool, new_name) qgroup_id = ('0/%s' % snap_id) update_quota(share.pool, qgroup_id, share.size * 1024) new_share = Share(pool=share.pool, qgroup=qgroup_id, name=new_name, size=share.size, subvol_name=new_name) new_share.save() return Response(ShareSerializer(new_share).data) except Exception as e: handle_exception(e, request)
def import_shares(pool, request): disk = Disk.objects.filter(pool=pool)[0].name shares = [s.name for s in Share.objects.filter(pool=pool)] shares_d = shares_info('%s%s' % (settings.MNT_PT, pool.name)) for s in shares: if (s not in shares_d): Share.objects.get(pool=pool, name=s).delete() for s in shares_d: if (s in shares): share = Share.objects.get(name=s) share.qgroup = shares_d[s] rusage, eusage = share_usage(pool, share.qgroup) ts = datetime.utcnow().replace(tzinfo=utc) if (rusage != share.rusage or eusage != share.eusage): share.rusage = rusage share.eusage = eusage su = ShareUsage(name=s, r_usage=rusage, e_usage=eusage, ts=ts) su.save() else: try: su = ShareUsage.objects.filter(name=s).latest('id') su.ts = ts su.count += 1 except ShareUsage.DoesNotExist: su = ShareUsage(name=s, r_usage=rusage, e_usage=eusage, ts=ts) finally: su.save() share.save() continue try: cshare = Share.objects.get(name=s) cshares_d = shares_info('%s%s' % (settings.MNT_PT, cshare.pool.name)) if (s in cshares_d): e_msg = ('Another pool(%s) has a Share with this same ' 'name(%s) as this pool(%s). This configuration is not supported.' ' You can delete one of them manually with this command: ' 'btrfs subvol delete %s[pool name]/%s' % (cshare.pool.name, s, pool.name, settings.MNT_PT, s)) handle_exception(Exception(e_msg), request) else: cshare.pool = pool cshare.qgroup = shares_d[s] cshare.size = pool.size cshare.subvol_name = s cshare.rusage, cshare.eusage = share_usage(pool, cshare.qgroup) cshare.save() except Share.DoesNotExist: pqid = qgroup_create(pool) update_quota(pool, pqid, pool.size * 1024) nso = Share(pool=pool, qgroup=shares_d[s], pqgroup=pqid, name=s, size=pool.size, subvol_name=s) nso.save() mount_share(nso, '%s%s' % (settings.MNT_PT, s))
def import_shares(pool, request): disk = Disk.objects.filter(pool=pool)[0].name shares = [s.name for s in Share.objects.filter(pool=pool)] shares_d = shares_info(pool) for s in shares: if (s not in shares_d): Share.objects.get(pool=pool, name=s).delete() for s in shares_d: if (s in shares): share = Share.objects.get(name=s) share.qgroup = shares_d[s] rusage, eusage = share_usage(pool, share.qgroup) ts = datetime.utcnow().replace(tzinfo=utc) if (rusage != share.rusage or eusage != share.eusage): share.rusage = rusage share.eusage = eusage su = ShareUsage(name=s, r_usage=rusage, e_usage=eusage, ts=ts) su.save() else: try: su = ShareUsage.objects.filter(name=s).latest('id') su.ts = ts su.count += 1 except ShareUsage.DoesNotExist: su = ShareUsage(name=s, r_usage=rusage, e_usage=eusage, ts=ts) finally: su.save() share.save() continue try: cshare = Share.objects.get(name=s) cshares_d = shares_info('%s%s' % (settings.MNT_PT, cshare.pool.name)) if (s in cshares_d): e_msg = ('Another pool(%s) has a Share with this same ' 'name(%s) as this pool(%s). This configuration is not supported.' ' You can delete one of them manually with this command: ' 'btrfs subvol delete %s[pool name]/%s' % (cshare.pool.name, s, pool.name, settings.MNT_PT, s)) handle_exception(Exception(e_msg), request) else: cshare.pool = pool cshare.qgroup = shares_d[s] cshare.size = pool.size cshare.subvol_name = s cshare.rusage, cshare.eusage = share_usage(pool, cshare.qgroup) cshare.save() except Share.DoesNotExist: pqid = qgroup_create(pool) update_quota(pool, pqid, pool.size * 1024) nso = Share(pool=pool, qgroup=shares_d[s], pqgroup=pqid, name=s, size=pool.size, subvol_name=s) nso.save() mount_share(nso, '%s%s' % (settings.MNT_PT, s))
def post(self, request): with self._handle_exception(request): pool_name = request.data.get('pool', None) try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool(%s) does not exist.' % pool_name) handle_exception(Exception(e_msg), request) compression = self._validate_compression(request) size = self._validate_share_size(request, pool) sname = request.data.get('sname', None) if ((sname is None or re.match('%s$' % settings.SHARE_REGEX, sname) is None)): e_msg = ('Share name must start with a alphanumeric(a-z0-9) ' 'character and can be followed by any of the ' 'following characters: letter(a-z), digits(0-9), ' 'hyphen(-), underscore(_) or a period(.).') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): e_msg = ('Share(%s) already exists. Choose a different name' % sname) handle_exception(Exception(e_msg), request) if (Pool.objects.filter(name=sname).exists()): e_msg = ( 'A Pool with this name(%s) exists. Share and Pool names ' 'must be distinct. Choose a different name' % sname) handle_exception(Exception(e_msg), request) disk = Disk.objects.filter(pool=pool)[0] replica = False if ('replica' in request.data): replica = request.data['replica'] if (type(replica) != bool): e_msg = ('replica must be a boolean, not %s' % type(replica)) handle_exception(Exception(e_msg), request) add_share(pool, disk.name, sname) qid = qgroup_id(pool, disk.name, sname) update_quota(pool, disk.name, qid, size * 1024) s = Share(pool=pool, qgroup=qid, name=sname, size=size, subvol_name=sname, replica=replica, compression_algo=compression) s.save() mnt_pt = '%s%s' % (settings.MNT_PT, sname) if (not is_share_mounted(sname)): disk = Disk.objects.filter(pool=pool)[0].name mount_share(s, disk, mnt_pt) if (compression != 'no'): set_property(mnt_pt, 'compression', compression) return Response(ShareSerializer(s).data)
def post(self, request): with self._handle_exception(request): pool_name = request.DATA.get('pool', None) try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool(%s) does not exist.' % pool_name) handle_exception(Exception(e_msg), request) compression = self._validate_compression(request) size = self._validate_share_size(request, pool) sname = request.DATA.get('sname', None) if ((sname is None or re.match('%s$' % settings.SHARE_REGEX, sname) is None)): e_msg = ('Share name must start with a letter(a-z) and can ' 'be followed by any of the following characters: ' 'letter(a-z), digits(0-9), hyphen(-), underscore' '(_) or a period(.).') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): e_msg = ('Share(%s) already exists.' % sname) handle_exception(Exception(e_msg), request) try: disk = Disk.objects.filter(pool=pool)[0] except: e_msg = ('Pool(%s) does not have any disks in it.' % pool_name) handle_exception(Exception(e_msg), request) replica = False if ('replica' in request.DATA): replica = request.DATA['replica'] if (type(replica) != bool): e_msg = ('replica must be a boolean, not %s' % type(replica)) handle_exception(Exception(e_msg), request) add_share(pool, disk.name, sname) qgroup_id = self._update_quota(pool, disk.name, sname, size) s = Share(pool=pool, qgroup=qgroup_id, name=sname, size=size, subvol_name=sname, replica=replica, compression_algo=compression) s.save() mnt_pt = '%s%s' % (settings.MNT_PT, sname) if (not is_share_mounted(sname)): disk = Disk.objects.filter(pool=pool)[0].name mount_share(s, disk, mnt_pt) if (compression != 'no'): set_property(mnt_pt, 'compression', compression) return Response(ShareSerializer(s).data)
def post(self, request): try: sname = request.DATA['sname'] if (re.match('%s$' % settings.SHARE_REGEX, sname) is None): e_msg = ('Share name must start with a letter(a-z) and can' ' be followed by any of the following characters: ' 'letter(a-z), digits(0-9), hyphen(-), underscore' '(_) or a period(.).') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): e_msg = ('Share with name: %s already exists.' % sname) handle_exception(Exception(e_msg), request) pool_name = request.DATA['pool'] size = int(request.DATA['size']) #in KB self._validate_share_size(request, size) pool = None try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool with name: %s does not exist.' % pool_name) handle_exception(Exception(e_msg), request) disk = None try: disk = Disk.objects.filter(pool=pool)[0] except: e_msg = ('Pool with name: %s does not have any disks in it.' % pool_name) handle_exception(Exception(e_msg), request) replica = False if ('replica' in request.DATA): replica = request.DATA['replica'] if (type(replica) != bool): e_msg = ('replica must be a boolean, not %s' % type(replica)) handle_exception(Exception(e_msg), request) add_share(pool_name, disk.name, sname) qgroup_id = self._update_quota(pool_name, disk.name, sname, size) s = Share(pool=pool, qgroup=qgroup_id, name=sname, size=size, subvol_name=sname, replica=replica) s.save() return Response(ShareSerializer(s).data) except RockStorAPIException: raise except Exception, e: handle_exception(e, request)
def post(self, request): with self._handle_exception(request): pool_name = request.data.get('pool', None) try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool(%s) does not exist.' % pool_name) handle_exception(Exception(e_msg), request) compression = self._validate_compression(request) size = self._validate_share_size(request, pool) sname = request.data.get('sname', None) if ((sname is None or re.match('%s$' % settings.SHARE_REGEX, sname) is None)): e_msg = ('Share name must start with a alphanumeric(a-z0-9) ' 'character and can be followed by any of the ' 'following characters: letter(a-z), digits(0-9), ' 'hyphen(-), underscore(_) or a period(.).') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): e_msg = ('Share(%s) already exists. Choose a different name' % sname) handle_exception(Exception(e_msg), request) if (Pool.objects.filter(name=sname).exists()): e_msg = ('A Pool with this name(%s) exists. Share and Pool names ' 'must be distinct. Choose a different name' % sname) handle_exception(Exception(e_msg), request) disk = Disk.objects.filter(pool=pool)[0] replica = False if ('replica' in request.data): replica = request.data['replica'] if (type(replica) != bool): e_msg = ('replica must be a boolean, not %s' % type(replica)) handle_exception(Exception(e_msg), request) add_share(pool, disk.name, sname) qid = qgroup_id(pool, disk.name, sname) update_quota(pool, disk.name, qid, size * 1024) s = Share(pool=pool, qgroup=qgroup_id, name=sname, size=size, subvol_name=sname, replica=replica, compression_algo=compression) s.save() mnt_pt = '%s%s' % (settings.MNT_PT, sname) if (not is_share_mounted(sname)): disk = Disk.objects.filter(pool=pool)[0].name mount_share(s, disk, mnt_pt) if (compression != 'no'): set_property(mnt_pt, 'compression', compression) return Response(ShareSerializer(s).data)
def create_clone(share, new_name, request, logger, snapshot=None): # if snapshot is None, create clone of the share. # If it's not, then clone it. if re.match(settings.SHARE_REGEX + "$", new_name) is None: e_msg = ("Clone name is invalid. It must start with a letter and can " "contain letters, digits, _, . and - characters.") handle_exception(Exception(e_msg), request) if Share.objects.filter(name=new_name).exists(): e_msg = "Another share with name ({}) already exists.".format(new_name) handle_exception(Exception(e_msg), request) if Snapshot.objects.filter(share=share, name=new_name).exists(): e_msg = ("Snapshot with name ({}) already exists for the " "share ({}). Choose a different name.").format( new_name, share.name) handle_exception(Exception(e_msg), request) try: share_name = share.subvol_name snap = None if snapshot is not None: snap = snapshot.real_name add_clone(share.pool, share_name, new_name, snapshot=snap) snap_id = share_id(share.pool, new_name) qgroup_id = "0/{}".format(snap_id) pqid = qgroup_create(share.pool) new_share = Share( pool=share.pool, qgroup=qgroup_id, pqgroup=pqid, name=new_name, size=share.size, subvol_name=new_name, ) new_share.save() if pqid != PQGROUP_DEFAULT: update_quota(new_share.pool, pqid, new_share.size * 1024) share_pqgroup_assign(pqid, new_share) # Mount our new clone share. # We independently mount all shares, data pool or system pool, in /mnt2/name mnt_pt = "{}{}".format(settings.MNT_PT, new_name) mount_share(new_share, mnt_pt) return Response(ShareSerializer(new_share).data) except Exception as e: handle_exception(e, request)
def create_clone(share, new_name, request, logger, snapshot=None): # if snapshot is None, create clone of the share. # If it's not, then clone it. if (re.match(settings.SHARE_REGEX + '$', new_name) is None): e_msg = ('Clone name is invalid. It must start with a letter and can ' 'contain letters, digits, _, . and - characters.') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=new_name).exists()): e_msg = 'Another share with name ({}) already exists.'.format(new_name) handle_exception(Exception(e_msg), request) if (Snapshot.objects.filter(share=share, name=new_name).exists()): e_msg = ('Snapshot with name ({}) already exists for the ' 'share ({}). Choose a different name.').format(new_name, share.name) handle_exception(Exception(e_msg), request) try: share_name = share.subvol_name snap = None if (snapshot is not None): snap = snapshot.real_name add_clone(share.pool, share_name, new_name, snapshot=snap) snap_id = share_id(share.pool, new_name) qgroup_id = ('0/%s' % snap_id) pqid = qgroup_create(share.pool) new_share = Share(pool=share.pool, qgroup=qgroup_id, pqgroup=pqid, name=new_name, size=share.size, subvol_name=new_name) new_share.save() if pqid is not PQGROUP_DEFAULT: update_quota(new_share.pool, pqid, new_share.size * 1024) share_pqgroup_assign(pqid, new_share) # Mount our new clone share. mnt_pt = '{}{}'.format(settings.MNT_PT, new_name) mount_share(new_share, mnt_pt) return Response(ShareSerializer(new_share).data) except Exception as e: handle_exception(e, request)
def post(self, request): try: pool_name = request.DATA['pool'] share_name = request.DATA['name'] size = int(request.DATA['size']) pool = None for p in Pool.objects.all(): if (p.name == pool_name): pool = p break disk = Disk.objects.filter(pool=p)[0] add_share(pool_name, disk.name, share_name) sid = share_id(pool_name, disk.name, share_name) qgroup_id = '0/' + sid update_quota(pool_name, disk.name, qgroup_id, str(size)) cur_usage = int(share_usage(pool_name, disk.name, qgroup_id)) qgroup = Qgroup(uuid=qgroup_id) qgroup.save() s = Share(pool=pool, qgroup=qgroup, name=share_name, size=size, free=(size - cur_usage)) s.save() return Response(ShareSerializer(s).data) except Exception, e: handle_exception(e, request)
def import_shares(pool, request): # Establish known shares/subvols within our db for the given pool: shares_in_pool_db = [s.name for s in Share.objects.filter(pool=pool)] # Find the actual/current shares/subvols within the given pool: # Limited to Rockstor relevant subvols ie shares and clones. shares_in_pool = shares_info(pool) # List of pool's share.pqgroups so we can remove inadvertent duplication. # All pqgroups are removed when quotas are disabled, combined with a part # refresh we could have duplicates within the db. share_pqgroups_used = [] # Delete db Share object if it is no longer found on disk. for s_in_pool_db in shares_in_pool_db: if s_in_pool_db not in shares_in_pool: logger.debug("Removing, missing on disk, share db entry ({}) from " "pool ({}).".format(s_in_pool_db, pool.name)) Share.objects.get(pool=pool, name=s_in_pool_db).delete() # Check if each share in pool also has a db counterpart. for s_in_pool in shares_in_pool: logger.debug("---- Share name = {}.".format(s_in_pool)) if s_in_pool in shares_in_pool_db: logger.debug("Updating pre-existing same pool db share entry.") # We have a pool db share counterpart so retrieve and update it. share = Share.objects.get(name=s_in_pool, pool=pool) # Initially default our pqgroup value to db default of '-1/-1' # This way, unless quotas are enabled, all pqgroups will be # returned to db default. pqgroup = PQGROUP_DEFAULT if share.pool.quotas_enabled: # Quotas are enabled on our pool so we can validate pqgroup. if (share.pqgroup == pqgroup or not share.pqgroup_exist or share.pqgroup in share_pqgroups_used): # we have a void '-1/-1' or non existent pqgroup or # this pqgroup has already been seen / used in this pool. logger.debug( "#### replacing void, non-existent, or duplicate pqgroup." ) pqgroup = qgroup_create(pool) if pqgroup != PQGROUP_DEFAULT: update_quota(pool, pqgroup, share.size * 1024) share_pqgroup_assign(pqgroup, share) else: # Our share's pqgroup looks OK so use it. pqgroup = share.pqgroup # Record our use of this pqgroup to spot duplicates later. share_pqgroups_used.append(deepcopy(share.pqgroup)) if share.pqgroup != pqgroup: # we need to update our share.pqgroup share.pqgroup = pqgroup share.save() share.qgroup = shares_in_pool[s_in_pool] rusage, eusage, pqgroup_rusage, pqgroup_eusage = volume_usage( pool, share.qgroup, pqgroup) if (rusage != share.rusage or eusage != share.eusage or pqgroup_rusage != share.pqgroup_rusage or pqgroup_eusage != share.pqgroup_eusage): share.rusage = rusage share.eusage = eusage share.pqgroup_rusage = pqgroup_rusage share.pqgroup_eusage = pqgroup_eusage update_shareusage_db(s_in_pool, rusage, eusage) else: update_shareusage_db(s_in_pool, rusage, eusage, UPDATE_TS) share.save() continue try: logger.debug("No prior entries in scanned pool trying all pools.") # Test (Try) for an existing system wide Share db entry. cshare = Share.objects.get(name=s_in_pool) # Get a list of Rockstor relevant subvols (ie shares and clones) # for the prior existing db share entry's pool. cshares_d = shares_info(cshare.pool) if s_in_pool in cshares_d: e_msg = ("Another pool ({}) has a share with this same " "name ({}) as this pool ({}). This configuration " "is not supported. You can delete one of them " "manually with the following command: " '"btrfs subvol delete {}[pool name]/{}" WARNING this ' "will remove the entire contents of that " "subvolume.").format(cshare.pool.name, s_in_pool, pool.name, settings.MNT_PT, s_in_pool) handle_exception(Exception(e_msg), request) else: # Update the prior existing db share entry previously # associated with another pool. logger.debug("Updating prior db entry from another pool.") cshare.pool = pool cshare.qgroup = shares_in_pool[s_in_pool] cshare.size = pool.size cshare.subvol_name = s_in_pool ( cshare.rusage, cshare.eusage, cshare.pqgroup_rusage, cshare.pqgroup_eusage, ) = volume_usage(pool, cshare.qgroup, cshare.pqgroup) cshare.save() update_shareusage_db(s_in_pool, cshare.rusage, cshare.eusage) except Share.DoesNotExist: logger.debug("Db share entry does not exist - creating.") # We have a share on disk that has no db counterpart so create one. # Retrieve new pool quota id for use in db Share object creation. # As the replication receive share is 'special' we tag it as such. replica = False share_name = s_in_pool if re.match(".snapshot", s_in_pool) is not None: # We have an initial replication share, non snap in .snapshots. # We could change it's name here but still a little mixing # of name and subvol throughout project. replica = True logger.debug("Initial receive quirk-subvol found: Importing " "as share and setting replica flag.") qid = shares_in_pool[s_in_pool] pqid = qgroup_create(pool) if pqid != PQGROUP_DEFAULT: update_quota(pool, pqid, pool.size * 1024) qgroup_assign(qid, pqid, pool.mnt_pt) rusage, eusage, pqgroup_rusage, pqgroup_eusage = volume_usage( pool, qid, pqid) nso = Share( pool=pool, qgroup=qid, pqgroup=pqid, name=share_name, size=pool.size, subvol_name=s_in_pool, rusage=rusage, eusage=eusage, pqgroup_rusage=pqgroup_rusage, pqgroup_eusage=pqgroup_eusage, replica=replica, ) nso.save() update_shareusage_db(s_in_pool, rusage, eusage) mount_share(nso, "{}{}".format(settings.MNT_PT, s_in_pool))
def post(self, request): #qgroup notes for shares. we need to create a qgroup prior to share #creation. qgroup ids 0/<subvol_id> automatically get created when a #subvolume(i.e., a Share or a Snapshot) is created. So let's create a #new qgroup: 2015/<some_number> whenever a Share is #created. <some_number> starts from 1 and is incremented as more Shares #are created. So, for the very first Share in a pool, it's qgroup will #be 1/1. 2015 is arbitrarily chose. #Before creating a new Share, we create the qgroup for it. And during #it's creation, we assign this qgroup to it. During it's creation a 0/x #qgroup will automatically be created, but it will become the child of #our explicitly-created qgroup(2015/x). #We will set the qgroup limit on our qgroup and it will enforce the #quota on every subvolume(i.e., Share and Snapshot) in that qgroup. #When a Share is deleted, we need to destroy two qgroups. One is it's #auto 0/x qgroup and the other is our explicitly-created 2015/y qgroup. with self._handle_exception(request): pool_name = request.data.get('pool', None) try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool(%s) does not exist.' % pool_name) handle_exception(Exception(e_msg), request) compression = self._validate_compression(request) size = self._validate_share_size(request, pool) sname = request.data.get('sname', None) if ((sname is None or re.match('%s$' % settings.SHARE_REGEX, sname) is None)): e_msg = ('Share name must start with a alphanumeric(a-z0-9) ' 'character and can be followed by any of the ' 'following characters: letter(a-z), digits(0-9), ' 'hyphen(-), underscore(_) or a period(.).') handle_exception(Exception(e_msg), request) if (len(sname) > 254): #btrfs subvolume names cannot exceed 254 characters. e_msg = ('Share name length cannot exceed 254 characters') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): e_msg = ('Share(%s) already exists. Choose a different name' % sname) handle_exception(Exception(e_msg), request) if (Pool.objects.filter(name=sname).exists()): e_msg = ('A Pool with this name(%s) exists. Share and Pool names ' 'must be distinct. Choose a different name' % sname) handle_exception(Exception(e_msg), request) disk = Disk.objects.filter(pool=pool)[0] replica = False if ('replica' in request.data): replica = request.data['replica'] if (type(replica) != bool): e_msg = ('replica must be a boolean, not %s' % type(replica)) handle_exception(Exception(e_msg), request) pqid = qgroup_create(pool) add_share(pool, sname, pqid) qid = qgroup_id(pool, sname) update_quota(pool, pqid, size * 1024) s = Share(pool=pool, qgroup=qid, pqgroup=pqid, name=sname, size=size, subvol_name=sname, replica=replica, compression_algo=compression) s.save() mnt_pt = '%s%s' % (settings.MNT_PT, sname) if (not is_share_mounted(sname)): mount_share(s, mnt_pt) if (compression != 'no'): set_property(mnt_pt, 'compression', compression) return Response(ShareSerializer(s).data)
def post(self, request): #qgroup notes for shares. we need to create a qgroup prior to share #creation. qgroup ids 0/<subvol_id> automatically get created when a #subvolume(i.e., a Share or a Snapshot) is created. So let's create a #new qgroup: 2015/<some_number> whenever a Share is #created. <some_number> starts from 1 and is incremented as more Shares #are created. So, for the very first Share in a pool, it's qgroup will #be 1/1. 2015 is arbitrarily chose. #Before creating a new Share, we create the qgroup for it. And during #it's creation, we assign this qgroup to it. During it's creation a 0/x #qgroup will automatically be created, but it will become the child of #our explicitly-created qgroup(2015/x). #We will set the qgroup limit on our qgroup and it will enforce the #quota on every subvolume(i.e., Share and Snapshot) in that qgroup. #When a Share is deleted, we need to destroy two qgroups. One is it's #auto 0/x qgroup and the other is our explicitly-created 2015/y qgroup. with self._handle_exception(request): pool_name = request.data.get('pool', None) try: pool = Pool.objects.get(name=pool_name) except: e_msg = ('Pool(%s) does not exist.' % pool_name) handle_exception(Exception(e_msg), request) compression = self._validate_compression(request) size = self._validate_share_size(request, pool) sname = request.data.get('sname', None) if ((sname is None or re.match('%s$' % settings.SHARE_REGEX, sname) is None)): e_msg = ('Share name must start with a alphanumeric(a-z0-9) ' 'character and can be followed by any of the ' 'following characters: letter(a-z), digits(0-9), ' 'hyphen(-), underscore(_) or a period(.).') handle_exception(Exception(e_msg), request) if (len(sname) > 254): #btrfs subvolume names cannot exceed 254 characters. e_msg = ('Share name length cannot exceed 254 characters') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): e_msg = ('Share(%s) already exists. Choose a different name' % sname) handle_exception(Exception(e_msg), request) if (Pool.objects.filter(name=sname).exists()): e_msg = ( 'A Pool with this name(%s) exists. Share and Pool names ' 'must be distinct. Choose a different name' % sname) handle_exception(Exception(e_msg), request) disk = Disk.objects.filter(pool=pool)[0] replica = False if ('replica' in request.data): replica = request.data['replica'] if (type(replica) != bool): e_msg = ('replica must be a boolean, not %s' % type(replica)) handle_exception(Exception(e_msg), request) pqid = qgroup_create(pool) add_share(pool, sname, pqid) qid = qgroup_id(pool, sname) update_quota(pool, pqid, size * 1024) s = Share(pool=pool, qgroup=qid, pqgroup=pqid, name=sname, size=size, subvol_name=sname, replica=replica, compression_algo=compression) s.save() mnt_pt = '%s%s' % (settings.MNT_PT, sname) if (not is_share_mounted(sname)): mount_share(s, mnt_pt) if (compression != 'no'): set_property(mnt_pt, 'compression', compression) return Response(ShareSerializer(s).data)
def post(self, request, uuid): """ import a pool with given uuid """ disks = Disk.objects.filter(btrfs_uuid=uuid) if (not btrfs_importable(disks[0].name)): e_msg = ('btrfs check failed on device: %s Cannot automatically ' 'import the pool with uuid: %s' % (disks[0].name, uuid)) handle_exception(Exception(e_msg), request) #get name of the pool pname = btrfs_label(uuid) #mount the pool mount_root(pname, '/dev/%s' % disks[0].name) pool_mnt_pt = '%s/%s' % (settings.MNT_PT, pname) #get raid level raid_level = btrfs_raid_level(pname) if (raid_level is None): umount_root(pool_mnt_pt) e_msg = ('Problem while probing for the raid level of the pool.' 'Cannot automatically import the pool with uuid: %s' % uuid) handle_exception(Exception(e_msg), request) #check for shares in the pool subvols, e, rc = subvol_list_helper(pool_mnt_pt) snap_list = snapshot_list(pool_mnt_pt) share_map = {} for s in subvols: s_fields = s.split() if (s_fields[-1] not in snap_list): share_map[s_fields[-1]] = s_fields[1] entries = os.listdir(pool_mnt_pt) e_msg_prefix = ('Only btrfs filesystem with nothing but subvolumes in ' 'it can be imported.') for e in entries: if (os.path.isfile('%s/%s' % (pool_mnt_pt, e))): e_msg = ('%s Unexpected file %s found. Due to this reason, ' 'pool with uuid: %s cannot be imported' % (e_msg_prefix, e, uuid)) handle_exception(Exception(e_msg), request) elif (e not in share_map): e_msg = ('%s Unexpected directory %s found. Due to this ' 'reason, pool with uuid: %s cannot be imported' % (e_msg_prefix, e, uuid)) handle_exception(Exception(e_msg), request) #add pool model pool_size = self._pool_size(disks, raid_level) p = Pool(name=pname, raid=raid_level, size=pool_size, uuid=uuid) p.save() #import shares for s in share_map.keys(): so = Share(pool=p, qgroup='0/%s' % share_map[s], name=s, size=qgroup_size, subvol_name=s, replica=False) so.save() #import snapshots? for snap in snap_list: snap_fields = snap.split('_') snap_name = snap_fields[-1] sname = '_'.join(snap_fields[0:-1]) if (sname == s): snapo = Snapshot(share=so, name=snap_name, real_name=snap, qgroup=qgroup_id) snapo.save()
def import_shares(pool, request): # Establish known shares/subvols within our db for the given pool: shares_in_pool_db = [s.name for s in Share.objects.filter(pool=pool)] # Find the actual/current shares/subvols within the given pool: # Limited to Rockstor relevant subvols ie shares and clones. shares_in_pool = shares_info(pool) # Delete db Share object if it is no longer found on disk. for s_in_pool_db in shares_in_pool_db: if s_in_pool_db not in shares_in_pool: Share.objects.get(pool=pool, name=s_in_pool_db).delete() # Check if each share in pool also has a db counterpart. for s_in_pool in shares_in_pool: logger.debug('Share name = {}.'.format(s_in_pool)) if s_in_pool in shares_in_pool_db: logger.debug('Updating pre-existing same pool db share entry.') # We have a pool db share counterpart so retrieve and update it. share = Share.objects.get(name=s_in_pool, pool=pool) share.qgroup = shares_in_pool[s_in_pool] rusage, eusage, pqgroup_rusage, pqgroup_eusage = \ volume_usage(pool, share.qgroup, share.pqgroup) if (rusage != share.rusage or eusage != share.eusage or pqgroup_rusage != share.pqgroup_rusage or pqgroup_eusage != share.pqgroup_eusage): share.rusage = rusage share.eusage = eusage share.pqgroup_rusage = pqgroup_rusage share.pqgroup_eusage = pqgroup_eusage update_shareusage_db(s_in_pool, rusage, eusage) else: update_shareusage_db(s_in_pool, rusage, eusage, UPDATE_TS) share.save() continue try: logger.debug('No prior entries in scanned pool trying all pools.') # Test (Try) for an existing system wide Share db entry. cshare = Share.objects.get(name=s_in_pool) # Get a list of Rockstor relevant subvols (ie shares and clones) # for the prior existing db share entry's pool. cshares_d = shares_info(cshare.pool) if s_in_pool in cshares_d: e_msg = ('Another pool ({}) has a Share with this same ' 'name ({}) as this pool ({}). This configuration ' 'is not supported. You can delete one of them ' 'manually with the following command: ' '"btrfs subvol delete {}[pool name]/{}" WARNING this ' 'will remove the entire contents of that subvolume.'. format(cshare.pool.name, s_in_pool, pool.name, settings.MNT_PT, s_in_pool)) handle_exception(Exception(e_msg), request) else: # Update the prior existing db share entry previously # associated with another pool. logger.debug('Updating prior db entry from another pool.') cshare.pool = pool cshare.qgroup = shares_in_pool[s_in_pool] cshare.size = pool.size cshare.subvol_name = s_in_pool (cshare.rusage, cshare.eusage, cshare.pqgroup_rusage, cshare.pqgroup_eusage) = volume_usage(pool, cshare.qgroup, cshare.pqgroup) cshare.save() update_shareusage_db(s_in_pool, cshare.rusage, cshare.eusage) except Share.DoesNotExist: logger.debug('Db share entry does not exist - creating.') # We have a share on disk that has no db counterpart so create one. # Retrieve pool quota id for use in db Share object creation. pqid = qgroup_create(pool) update_quota(pool, pqid, pool.size * 1024) rusage, eusage, pqgroup_rusage, pqgroup_eusage = \ volume_usage(pool, shares_in_pool[s_in_pool], pqid) nso = Share(pool=pool, qgroup=shares_in_pool[s_in_pool], pqgroup=pqid, name=s_in_pool, size=pool.size, subvol_name=s_in_pool, rusage=rusage, eusage=eusage, pqgroup_rusage=pqgroup_rusage, pqgroup_eusage=pqgroup_eusage) nso.save() update_shareusage_db(s_in_pool, rusage, eusage) mount_share(nso, '%s%s' % (settings.MNT_PT, s_in_pool))
def import_shares(pool, request): # Establish known shares/subvols within our db for the given pool: shares_in_pool_db = [s.name for s in Share.objects.filter(pool=pool)] # Find the actual/current shares/subvols within the given pool: # Limited to Rockstor relevant subvols ie shares and clones. shares_in_pool = shares_info(pool) # List of pool's share.pqgroups so we can remove inadvertent duplication. # All pqgroups are removed when quotas are disabled, combined with a part # refresh we could have duplicates within the db. share_pqgroups_used = [] # Delete db Share object if it is no longer found on disk. for s_in_pool_db in shares_in_pool_db: if s_in_pool_db not in shares_in_pool: logger.debug('Removing, missing on disk, share db entry ({}) from ' 'pool ({}).'.format(s_in_pool_db, pool.name)) Share.objects.get(pool=pool, name=s_in_pool_db).delete() # Check if each share in pool also has a db counterpart. for s_in_pool in shares_in_pool: logger.debug('---- Share name = {}.'.format(s_in_pool)) if s_in_pool in shares_in_pool_db: logger.debug('Updating pre-existing same pool db share entry.') # We have a pool db share counterpart so retrieve and update it. share = Share.objects.get(name=s_in_pool, pool=pool) # Initially default our pqgroup value to db default of '-1/-1' # This way, unless quotas are enabled, all pqgroups will be # returned to db default. pqgroup = PQGROUP_DEFAULT if share.pool.quotas_enabled: # Quotas are enabled on our pool so we can validate pqgroup. if share.pqgroup == pqgroup or not share.pqgroup_exist \ or share.pqgroup in share_pqgroups_used: # we have a void '-1/-1' or non existent pqgroup or # this pqgroup has already been seen / used in this pool. logger.debug('#### replacing void, non-existent, or ' 'duplicate pqgroup.') pqgroup = qgroup_create(pool) if pqgroup is not PQGROUP_DEFAULT: update_quota(pool, pqgroup, share.size * 1024) share_pqgroup_assign(pqgroup, share) else: # Our share's pqgroup looks OK so use it. pqgroup = share.pqgroup # Record our use of this pqgroup to spot duplicates later. share_pqgroups_used.append(deepcopy(share.pqgroup)) if share.pqgroup != pqgroup: # we need to update our share.pqgroup share.pqgroup = pqgroup share.save() share.qgroup = shares_in_pool[s_in_pool] rusage, eusage, pqgroup_rusage, pqgroup_eusage = \ volume_usage(pool, share.qgroup, pqgroup) if (rusage != share.rusage or eusage != share.eusage or pqgroup_rusage != share.pqgroup_rusage or pqgroup_eusage != share.pqgroup_eusage): share.rusage = rusage share.eusage = eusage share.pqgroup_rusage = pqgroup_rusage share.pqgroup_eusage = pqgroup_eusage update_shareusage_db(s_in_pool, rusage, eusage) else: update_shareusage_db(s_in_pool, rusage, eusage, UPDATE_TS) share.save() continue try: logger.debug('No prior entries in scanned pool trying all pools.') # Test (Try) for an existing system wide Share db entry. cshare = Share.objects.get(name=s_in_pool) # Get a list of Rockstor relevant subvols (ie shares and clones) # for the prior existing db share entry's pool. cshares_d = shares_info(cshare.pool) if s_in_pool in cshares_d: e_msg = ('Another pool ({}) has a share with this same ' 'name ({}) as this pool ({}). This configuration ' 'is not supported. You can delete one of them ' 'manually with the following command: ' '"btrfs subvol delete {}[pool name]/{}" WARNING this ' 'will remove the entire contents of that ' 'subvolume.').format(cshare.pool.name, s_in_pool, pool.name, settings.MNT_PT, s_in_pool) handle_exception(Exception(e_msg), request) else: # Update the prior existing db share entry previously # associated with another pool. logger.debug('Updating prior db entry from another pool.') cshare.pool = pool cshare.qgroup = shares_in_pool[s_in_pool] cshare.size = pool.size cshare.subvol_name = s_in_pool (cshare.rusage, cshare.eusage, cshare.pqgroup_rusage, cshare.pqgroup_eusage) = volume_usage(pool, cshare.qgroup, cshare.pqgroup) cshare.save() update_shareusage_db(s_in_pool, cshare.rusage, cshare.eusage) except Share.DoesNotExist: logger.debug('Db share entry does not exist - creating.') # We have a share on disk that has no db counterpart so create one. # Retrieve new pool quota id for use in db Share object creation. # As the replication receive share is 'special' we tag it as such. replica = False share_name = s_in_pool if re.match('.snapshot', s_in_pool) is not None: # We have an initial replication share, non snap in .snapshots. # We could change it's name here but still a little mixing # of name and subvol throughout project. replica = True logger.debug('Initial receive quirk-subvol found: Importing ' 'as share and setting replica flag.') qid = shares_in_pool[s_in_pool] pqid = qgroup_create(pool) if pqid is not PQGROUP_DEFAULT: update_quota(pool, pqid, pool.size * 1024) pool_mnt_pt = '{}{}'.format(settings.MNT_PT, pool.name) qgroup_assign(qid, pqid, pool_mnt_pt) rusage, eusage, pqgroup_rusage, pqgroup_eusage = \ volume_usage(pool, qid, pqid) nso = Share(pool=pool, qgroup=qid, pqgroup=pqid, name=share_name, size=pool.size, subvol_name=s_in_pool, rusage=rusage, eusage=eusage, pqgroup_rusage=pqgroup_rusage, pqgroup_eusage=pqgroup_eusage, replica=replica) nso.save() update_shareusage_db(s_in_pool, rusage, eusage) mount_share(nso, '%s%s' % (settings.MNT_PT, s_in_pool))
def import_shares(pool, request): # Establish known shares/subvols within our db for the given pool: shares_in_pool_db = [s.name for s in Share.objects.filter(pool=pool)] # Find the actual/current shares/subvols within the given pool: # Limited to Rockstor relevant subvols ie shares and clones. shares_in_pool = shares_info(pool) # List of pool's share.pqgroups so we can remove inadvertent duplication. # All pqgroups are removed when quotas are disabled, combined with a part # refresh we could have duplicates within the db. share_pqgroups_used = [] # Delete db Share object if it is no longer found on disk. for s_in_pool_db in shares_in_pool_db: if s_in_pool_db not in shares_in_pool: Share.objects.get(pool=pool, name=s_in_pool_db).delete() # Check if each share in pool also has a db counterpart. for s_in_pool in shares_in_pool: logger.debug('---- Share name = {}.'.format(s_in_pool)) if s_in_pool in shares_in_pool_db: logger.debug('Updating pre-existing same pool db share entry.') # We have a pool db share counterpart so retrieve and update it. share = Share.objects.get(name=s_in_pool, pool=pool) # Initially default our pqgroup value to db default of '-1/-1' # This way, unless quotas are enabled, all pqgroups will be # returned to db default. pqgroup = settings.MODEL_DEFS['pqgroup'] if share.pool.quotas_enabled: # Quotas are enabled on our pool so we can validate pqgroup. if share.pqgroup == pqgroup or not share.pqgroup_exist \ or share.pqgroup in share_pqgroups_used: # we have a void '-1/-1' or non existent pqgroup or # this pqgroup has already been seen / used in this pool. logger.debug('#### replacing void, non-existent, or ' 'duplicate pqgroup') pqgroup = qgroup_create(pool) update_quota(pool, pqgroup, share.size * 1024) share_pqgroup_assign(pqgroup, share) else: # Our share's pqgroup looks OK so use it. pqgroup = share.pqgroup # Record our use of this pqgroup to spot duplicates later. share_pqgroups_used.append(deepcopy(share.pqgroup)) if share.pqgroup != pqgroup: # we need to update our share.pqgroup share.pqgroup = pqgroup share.save() share.qgroup = shares_in_pool[s_in_pool] rusage, eusage, pqgroup_rusage, pqgroup_eusage = \ volume_usage(pool, share.qgroup, pqgroup) if (rusage != share.rusage or eusage != share.eusage or pqgroup_rusage != share.pqgroup_rusage or pqgroup_eusage != share.pqgroup_eusage): share.rusage = rusage share.eusage = eusage share.pqgroup_rusage = pqgroup_rusage share.pqgroup_eusage = pqgroup_eusage update_shareusage_db(s_in_pool, rusage, eusage) else: update_shareusage_db(s_in_pool, rusage, eusage, UPDATE_TS) share.save() continue try: logger.debug('No prior entries in scanned pool trying all pools.') # Test (Try) for an existing system wide Share db entry. cshare = Share.objects.get(name=s_in_pool) # Get a list of Rockstor relevant subvols (ie shares and clones) # for the prior existing db share entry's pool. cshares_d = shares_info(cshare.pool) if s_in_pool in cshares_d: e_msg = ('Another pool ({}) has a Share with this same ' 'name ({}) as this pool ({}). This configuration ' 'is not supported. You can delete one of them ' 'manually with the following command: ' '"btrfs subvol delete {}[pool name]/{}" WARNING this ' 'will remove the entire contents of that subvolume.'. format(cshare.pool.name, s_in_pool, pool.name, settings.MNT_PT, s_in_pool)) handle_exception(Exception(e_msg), request) else: # Update the prior existing db share entry previously # associated with another pool. logger.debug('Updating prior db entry from another pool.') cshare.pool = pool cshare.qgroup = shares_in_pool[s_in_pool] cshare.size = pool.size cshare.subvol_name = s_in_pool (cshare.rusage, cshare.eusage, cshare.pqgroup_rusage, cshare.pqgroup_eusage) = volume_usage(pool, cshare.qgroup, cshare.pqgroup) cshare.save() update_shareusage_db(s_in_pool, cshare.rusage, cshare.eusage) except Share.DoesNotExist: logger.debug('Db share entry does not exist - creating.') # We have a share on disk that has no db counterpart so create one. # Retrieve new pool quota id for use in db Share object creation. pqid = qgroup_create(pool) update_quota(pool, pqid, pool.size * 1024) rusage, eusage, pqgroup_rusage, pqgroup_eusage = \ volume_usage(pool, shares_in_pool[s_in_pool], pqid) nso = Share(pool=pool, qgroup=shares_in_pool[s_in_pool], pqgroup=pqid, name=s_in_pool, size=pool.size, subvol_name=s_in_pool, rusage=rusage, eusage=eusage, pqgroup_rusage=pqgroup_rusage, pqgroup_eusage=pqgroup_eusage) nso.save() update_shareusage_db(s_in_pool, rusage, eusage) mount_share(nso, '%s%s' % (settings.MNT_PT, s_in_pool))
def post(self, request): # qgroup notes for shares. we need to create a qgroup prior to share # creation. qgroup ids 0/<subvol_id> automatically get created when a # subvolume(i.e., a Share or a Snapshot) is created. So let's create a # new qgroup: 2015/<some_number> whenever a Share is # created. <some_number> starts from 1 and is incremented as more # Shares are created. So, for the very first Share in a pool, it's # qgroup will be 1/1. 2015 is arbitrarily chose. # Before creating a new Share, we create the qgroup for it. And during # it's creation, we assign this qgroup to it. During it's creation a # 0/x qgroup will automatically be created, but it will become the # child of our explicitly-created qgroup(2015/x). # We will set the qgroup limit on our qgroup and it will enforce the # quota on every subvolume(i.e., Share and Snapshot) in that qgroup. # When a Share is deleted, we need to destroy two qgroups. One is it's # auto 0/x qgroup and the other is our explicitly-created 2015/y # qgroup. with self._handle_exception(request): pool_name = request.data.get('pool', None) try: pool = Pool.objects.get(name=pool_name) except: e_msg = 'Pool ({}) does not exist.'.format(pool_name) handle_exception(Exception(e_msg), request) compression = self._validate_compression(request) size = self._validate_share_size(request, pool) sname = request.data.get('sname', None) if ((sname is None or re.match('%s$' % settings.SHARE_REGEX, sname) is None)): e_msg = ('Invalid characters in share name. Following are ' 'allowed: letter(a-z or A-Z), digit(0-9), ' 'hyphen(-), underscore(_) or a period(.).') handle_exception(Exception(e_msg), request) if (len(sname) > 254): # btrfs subvolume names cannot exceed 254 characters. e_msg = ('Share name length cannot exceed 254 characters.') handle_exception(Exception(e_msg), request) if (Share.objects.filter(name=sname).exists()): # Note e_msg is consumed by replication/util.py create_share() e_msg = ('Share ({}) already exists. Choose a ' 'different name.').format(sname) handle_exception(Exception(e_msg), request) if (Pool.objects.filter(name=sname).exists()): e_msg = ('A pool with this name ({}) exists. Share ' 'and pool names must be distinct. Choose ' 'a different name.').format(sname) handle_exception(Exception(e_msg), request) replica = False if ('replica' in request.data): replica = request.data['replica'] if (type(replica) != bool): # TODO: confirm this 'type' call works as format parameter. e_msg = ('Replica must be a boolean, ' 'not ({}).').format(type(replica)) handle_exception(Exception(e_msg), request) pqid = qgroup_create(pool) add_share(pool, sname, pqid) qid = qgroup_id(pool, sname) s = Share(pool=pool, qgroup=qid, pqgroup=pqid, name=sname, size=size, subvol_name=sname, replica=replica, compression_algo=compression) # The following pool.save() was informed by test_share.py pool.save() s.save() if pqid is not PQGROUP_DEFAULT: update_quota(pool, pqid, size * 1024) share_pqgroup_assign(pqid, s) mnt_pt = '%s%s' % (settings.MNT_PT, sname) if not s.is_mounted: mount_share(s, mnt_pt) if (compression != 'no'): set_property(mnt_pt, 'compression', compression) return Response(ShareSerializer(s).data)