def get_exception_msg(e):
"""Executed when SXClientException occurs in views.
Exception message will be checked against known errors, and a prepared
message will be returned to the user.
If it isn't a known error, log the message since it might've not been
handled properly.
Returns a (field_name, error) tuple.
"""
if 'Max retries exceeded' in e.message or \
'Failed to query cluster' in e.message:
return _("Connection to the cluster failed.")
elif 'Invalid volume size' in e.message:
match = _invalid_volume_size_re.match(e.message)
if match:
min_, max_ = match.groups()
return _("Volume size should be between {min} and {max}.") \
.format(min=filesizeformat(min_), max=filesizeformat(max_))
logger.warning(
"Unknown exception ocurred. "
"The user will be shown a generic error message.\n"
"Exception: " + e.message)
return _("An error occurred while processing your request. "
"Please try again later.")
def get_sxclient_exception_msg(e):
msg = None
error = e.message
if 'Max retries exceeded' in error or \
'Failed to query cluster' in error:
msg = _("Connection to the cluster failed.")
elif 'Invalid volume size' in error:
match = _invalid_volume_size_re.match(error)
if match:
min_, max_ = match.groups()
msg = _("Volume size should be between {min} and {max}.") \
.format(min=filesizeformat(min_), max=filesizeformat(max_))
elif error.endswith('reached cluster capacity'):
msg = _("Can't create a new volume: "
"cluster capacity has been reached.")
elif 'Invalid metadata value' in error:
msg = _("Failed to update cluster metadata.")
elif 'Invalid distribution' in error:
match = _invalid_cluster_size_re.match(error)
if match:
min_ = match.groups()[0]
msg = _("Cluster size should be at least {min}.") \
.format(min=filesizeformat(min_))
return msg
def get_used_size_display(self):
usage = self.used_size
size = self.size
if size:
percentage = int(round(100. * usage / size))
return _("{usage} of {size} ({percentage}%)").format(
usage=filesizeformat(usage), size=filesizeformat(size),
percentage=percentage)
else:
return filesizeformat(usage)
def get_allocated_size_display(self):
allocated = sum(v.size for v in self.volumes)
size = self.size
if size:
percentage = int(round(100. * allocated / size))
return _("{usage} of {size} ({percentage}%)").format(
usage=filesizeformat(allocated), size=filesizeformat(size),
percentage=percentage)
else:
return filesizeformat(allocated)
def delete_files_not_in_a_request():
"""Delete those files that have the status of RESTORED but are actually not in a request"""
# build a list of RESTORED (or RESTORING) files from the requests
restored_files_tapereq = []
restored_file_size = 0
error_file_size = 0
for tr in TapeRequest.objects.iterator():
# list of request files
req_files = tr.request_files.split()
for rf in req_files:
try:
tf = TapeFile.objects.get(logical_path = rf)
if tf.stage == TapeFile.RESTORED or tf.stage == TapeFile.RESTORING:
restored_files_tapereq.append(tf)
restored_file_size += tf.size
except:
pass
# pattern match files
if tr.request_patterns != "":
pattern_files = TapeFile.objects.filter(
(Q(stage=TapeFile.RESTORED) |
Q(stage=TapeFile.RESTORING)) &
Q(logical_path__contains=tr.request_patterns)
)
for pf in pattern_files.iterator():
restored_files_tapereq.append(pf)
restored_file_size += tf.size
# get a list of files that the NLA thinks have been restored
restored_files_nla = TapeFile.objects.filter(Q(stage=TapeFile.RESTORED) | Q(stage=TapeFile.RESTORING))
total_size = 0
for rf in restored_files_nla.iterator():
total_size += rf.size
print("Restored files in NLA : {}".format(restored_files_nla.count()))
print("Restored files in requests : {}".format(len(restored_files_tapereq)))
print("Size of restored files in NLA : {}".format(filesizeformat(total_size)))
print("Size of restored files in requests: {}".format(filesizeformat(restored_file_size)))
# delete the files from the restore area and the symbolic link
for rf in restored_files_nla.iterator():
if rf not in restored_files_tapereq:
# delete the file
full_path = os.path.realpath(rf.logical_path)
print("DELETING {}".format(full_path))
os.unlink(full_path)
# delete the link
os.unlink(rf.logical_path)
# mark as on tape and save
rf.stage = TapeFile.ONTAPE
rf.save()
# add up errorneous sizes
error_file_size += rf.size
print("Size of deleted files: {}".format(filesizeformat(error_file_size)))
def get_allocated_size_display(self):
allocated = sum(v.size for v in self.volumes)
size = self.size
if size:
percentage = int(round(100. * allocated / size))
return _("{usage} of {size} ({percentage}%)").format(
usage=filesizeformat(allocated),
size=filesizeformat(size),
percentage=percentage)
else:
return filesizeformat(allocated)
def get_used_size_display(self):
usage = self.used_size
size = self.size
if size:
percentage = int(round(100. * usage / size))
return _("{usage} of {size} ({percentage}%)").format(
usage=filesizeformat(usage),
size=filesizeformat(size),
percentage=percentage)
else:
return filesizeformat(usage)
def clean(self, *args, **kwargs):
data = super(FileSizeCheckMixin, self).clean(*args, **kwargs)
if data is None:
return
if self.max_size is not None and data.size > self.max_size:
raise forms.ValidationError(
ugettext("File size must be under %s. Current file size is %s.")
% (filesizeformat(self.max_size), filesizeformat(data.size))
)
return data
def clean(self, *args, **kwargs):
data = super(FileSizeCheckMixin, self).clean(*args, **kwargs)
if data is None:
return
if self.max_size is not None and data.size > self.max_size:
raise forms.ValidationError(
ugettext('File size must be under %(max_size)s. Current file size is %(actual_size)s.') % {
'max_size': filesizeformat(self.max_size),
'actual_size': filesizeformat(data.size),
})
return data
def clean(self, *args, **kwargs):
data = super(FileSizeCheckMixin, self).clean(*args, **kwargs)
if data is None:
return
if self.max_size is not None and data.size > self.max_size:
raise forms.ValidationError(
ugettext('File size must be under %(max_size)s. Current file size is %(actual_size)s.') % {
'max_size': filesizeformat(self.max_size),
'actual_size': filesizeformat(data.size),
})
return data
def clean_cluster_size(self):
size = self.initial['cluster_size']
target = self.cleaned_data['cluster_size']
if not target:
return size
# Since this field is handled by FileSizeWidget, it may report slightly
# different values from the actual ones. (1040GB -> 1.0TB -> 1024GB)
# Therefore, `target` is ignored if it did not change significantly.
if abs(size - target) < 16 or \
filesizeformat(size) == filesizeformat(target):
return size
return target
def render(self, name, value, attrs=None):
if value:
try:
value = filesizeformat(value, is_binary=self.is_binary, ambiguous_suffix=self.ambiguous_suffix)
except ValueError:
pass
return super(FileSizeWidget, self).render(name, value, attrs)
def render(self, name, value, attrs=None):
if value:
try:
value = filesizeformat(value)
except ValueError:
pass
return super(FileSizeWidget, self).render(name, value, attrs)
def render(self, name, value, attrs=None):
if value:
try:
value = filesizeformat(value)
except ValueError:
pass
return super(FileSizeWidget, self).render(name, value, attrs)
def get_form_field_kwargs(self, instance):
kwargs = super(FileField, self).get_form_field_kwargs(instance)
if instance.max_size:
if 'help_text' in kwargs:
kwargs['help_text'] = kwargs['help_text'].replace(
'MAXSIZE', filesizeformat(instance.max_size))
kwargs['max_size'] = instance.max_size
return kwargs
def get_form_field_kwargs(self, instance):
kwargs = super(FileField, self).get_form_field_kwargs(instance)
if instance.max_size:
if 'help_text' in kwargs:
kwargs['help_text'] = kwargs['help_text'].replace(
'MAXSIZE', filesizeformat(instance.max_size))
kwargs['max_size'] = instance.max_size
return kwargs
def get_exception_msg(e):
"""Executed when SXClientException occurs in views.
Exception message will be checked against known errors, and a prepared
message will be returned to the user.
If it isn't a known error, log the message since it might've not been
handled properly.
Returns a (field_name, error) tuple.
"""
if 'Max retries exceeded' in e.message or \
'Failed to query cluster' in e.message:
return _("Connection to the cluster failed.")
elif 'Invalid volume size' in e.message:
match = _invalid_volume_size_re.match(e.message)
if match:
min_, max_ = match.groups()
return _("Volume size should be between {min} and {max}.") \
.format(min=filesizeformat(min_), max=filesizeformat(max_))
logger.warning("Unknown exception ocurred. "
"The user will be shown a generic error message.\n"
"Exception: " + e.message)
return _("An error occurred while processing your request. "
"Please try again later.")
def test_render(self):
from sizefield import utils
utils.SIZEFIELD_FORMAT = '{value} {unit}'
# Usual case
self.assertEqual('123.0 B', filesizeformat(123))
self.assertEqual('123.0 B', filesizeformat('123'))
# Incorrect input
self.assertRaises(ValueError, filesizeformat, (''))
self.assertRaises(ValueError, filesizeformat, ('abc'))
self.assertRaises(ValueError, filesizeformat, ('12 HB'))
# Units
self.assertEqual('1000.0 B', filesizeformat(1000))
self.assertEqual('1023.0 B', filesizeformat(1023))
self.assertEqual('1.0 KB', filesizeformat(1024))
self.assertEqual('1.0 MB', filesizeformat(1024 * 1024))
self.assertEqual('1.0 GB', filesizeformat(1024 * 1024 * 1024))
self.assertEqual('512.0 KB', filesizeformat(1024 * 1024 * 0.5))
self.assertEqual('307.2 KB', filesizeformat(1024 * 1024 * 0.3))
# Decimals
self.assertEqual('1 KB', filesizeformat(1024, decimals=0))
self.assertEqual('1.0 KB', filesizeformat(1024, decimals=1))
self.assertEqual('1.00 KB', filesizeformat(1024, decimals=2))
self.assertEqual('1.000 KB', filesizeformat(1024, decimals=3))
self.assertEqual('1.0000 KB', filesizeformat(1024, decimals=4))
# test SIZEFIELD_FORMAT
utils.SIZEFIELD_FORMAT = '{value}xxx {unit}'
self.assertEqual('1xxx KB', filesizeformat(1024, decimals=0))
self.assertEqual('1.0xxx KB', filesizeformat(1024, decimals=1))
self.assertEqual('1.00xxx KB', filesizeformat(1024, decimals=2))
self.assertEqual('1.000xxx KB', filesizeformat(1024, decimals=3))
self.assertEqual('1.0000xxx KB', filesizeformat(1024, decimals=4))
def quota_formatted_used(self):
return filesizeformat(self.quota_used)
def render(self, name, value, attrs=None):
if value:
value = filesizeformat(value)
return super(FileSizeWidget, self).render(name, value, attrs)
def __str__(self):
desc_str = "{} : {} : {} / {}".format(
self.workspace.workspace,
str(StorageQuota.__STORAGE_CHOICES[self.storage][1]),
filesizeformat(self.quota_used), filesizeformat(self.quota_size))
return desc_str
def formatted_size(self):
return filesizeformat(self.size)
def resolve_file_size(self, info):
if self.file_size:
return filesizeformat(self.file_size)
return None
def quota_formatted_size(self):
return filesizeformat(self.quota_size)
def filesize(value, decimals=1):
return filesizeformat(value, decimals)
def __unicode__(self):
return "%s (%s)" % (self.user, filesizeformat(self.size))
def filesize(value, decimals=1):
if value is None:
return ''
return filesizeformat(value, decimals)
def formatted_allocated(self):
return filesizeformat(self.allocated_bytes)
def formatted_used(self):
return filesizeformat(self.used_bytes)
