def show(self):
if len(self.list_of_objects_in_basket) > 100:
size = 0
for el in self.list_of_objects_in_basket:
if getsize.get_size(el.index_in_basket) is not None:
size += getsize.get_size(el.index_in_basket)
print 'TOTAL SIZE:' + str(size)
else:
if self.list_of_objects_in_basket == []:
print 'EMPTY'
print '\n'
for el in self.list_of_objects_in_basket:
print 'NAME: ' + el.name
print 'RM_PATH: ' + el.rm_path
print 'BASKET: ' + el.basket_path
print 'NAME IN BASKET: ' + el.index_in_basket
print 'TIME: ' + str(el.time)
print 'TIME IN BASKET: ' + str(
(datetime.datetime.now() - el.time))
if getsize.get_size(el.index_in_basket) is not None:
print 'SIZE: ' + str(getsize.get_size(el.index_in_basket))
print '====================================='
print '\n'
def restore(self, restorename, basket_path, is_merge, is_replace, is_force):
restorer = Alirem()
restore_path = None
for obj in restorer.get_basket_list(basket_path):
if obj.name == restorename:
restore_path = obj.rm_path
if os.path.exists(restore_path):
existing_file_size = get_size(restore_path)
else:
existing_file_size = 0
total_size = get_size(os.path.join(basket_path, restorename))
def update(restorename, basket_path, is_merge, is_replace):
restorer = Alirem(is_force=is_force)
restorer.restore(restorename=restorename,
basket_path=basket_path,
is_merge=is_merge,
is_replace=is_replace)
t = threading.Thread(target=update, args=(restorename, basket_path, is_merge, is_replace))
t.start()
progress = 0
while t.is_alive():
time.sleep(0.1)
if os.path.exists(restore_path):
progress = update_progress(file_now=restore_path,
total_size=total_size,
existing_file_size=existing_file_size)
self.update_state(state='PROGRESS',
meta={'process_percent': progress})
def check_basket_for_cleaning(self):
self.show_basket()
if exists(self.basket_path):
if self.mode == 'size':
if getsize.get_size(self.basket_path) >= int(self.size):
for obj in listdir(self.basket_path):
if obj != 'basket_list.pickle':
if isfile(join(self.basket_path, obj)):
remove(join(self.basket_path, obj))
self.basket_list.remove(
self.basket_list.search(
obj, self.basket_path))
else:
shutil.rmtree(join(self.basket_path, obj))
self.basket_list.remove(
self.basket_list.search(
obj, self.basket_path))
elif self.mode == 'time':
for obj in listdir(self.basket_path):
if obj != 'basket_list.pickle':
if isfile(join(self.basket_path, obj)):
self.checking_file_for_deletion(
join(self.basket_path, obj), self.time,
self.basket_list, self.basket_path)
else:
self.checking_dir_for_deletion(
join(self.basket_path, obj), self.time,
self.basket_list, self.basket_path)
else:
self.logger.log("Basket doesn't exist", logging.ERROR,
exception.BasketDoesNotExists)
self.basket_list.save()
def remove(self, path_to_removing_file, basket_path, is_dir, is_recursive, is_force):
def on_failure(self, *args, **kwargs):
pass
total_size = get_size(path_to_removing_file)
def update(path_to_removing_file, basket_path, is_dir, is_recursive):
remover = Alirem(is_force=is_force)
remover.remove(path=path_to_removing_file,
basket_path=basket_path,
is_dir=is_dir,
is_recursive=is_recursive)
t = threading.Thread(target=update, args=(path_to_removing_file, basket_path,
is_dir, is_recursive))
t.start()
progress = 0
file_name_in_basket = os.path.join(basket_path, os.path.basename(path_to_removing_file))
while t.is_alive():
time.sleep(0.1)
if os.path.exists(file_name_in_basket):
progress = update_progress(file_now=file_name_in_basket,
total_size=total_size)
self.update_state(state='PROGRESS',
meta={'process_percent': progress})
def basket_detail(request, pk):
basket = get_object_or_404(Basket, pk=pk)
if request.method == "POST":
taskform = TaskForm(request.POST)
form_edit_basket = BasketEditForm(request.POST,
initial={'mode':basket.mode,
'delta_time':basket.delta_time,
'max_size':basket.max_size})
if request.POST.get("create_task_button") is not None:
if taskform.is_valid():
if taskform.cleaned_data['action'] == 'RM':
if os.path.exists(taskform.cleaned_data['path_to_removing_file']):
task = taskform.save()
task.basket_path = basket.path
task.progress = 0
check_flags = BasketHandler(path=task.path_to_removing_file,
logger=DefaultLogger(),
basket_path=basket.path,
is_dir=(task.params == 'd'),
is_recursive=(task.params == 'r'))
try:
check_flags.check_flags()
job = remove.apply_async([task.path_to_removing_file,
basket.path,
(task.params == 'd'),
(task.params == 'r'),
task.is_force])
task.task_id = job.id
task.status = job.status
task.save()
except Exception as e:
messages.add_message(request, messages.ERROR, str(type(e)))
task.status = str(type(e))
task.save()
else:
messages.add_message(request, messages.ERROR, "This path is not exists")
return redirect('alibaskets:basket_detail', pk=basket.pk)
elif taskform.cleaned_data['action'] == 'RS':
task = taskform.save()
is_merge = (task.params == 'm')
is_replace = (task.params == 'r')
if os.path.exists(os.path.join(basket.path, task.restorename)):
restorer = Alirem()
for obj in restorer.get_basket_list(basket.path):
if obj.name == task.restorename:
restore_path = obj.rm_path
if os.path.exists(restore_path) and not is_merge and not is_replace:
messages.add_message(request, messages.ERROR,
"Name conflict, use merge or replace param")
else:
job = restore.apply_async([task.restorename,
basket.path,
is_merge,
is_replace,
task.is_force])
task.task_id = job.id
task.basket_path = basket.path
task.status = job.status
task.save()
else:
messages.add_message(request, messages.ERROR,
"Could't find such file in basket")
return redirect('alibaskets:basket_detail', pk=basket.pk)
if request.POST.get("update_button") is not None:
if form_edit_basket.is_valid():
basket.mode = form_edit_basket.cleaned_data['mode']
basket.delta_time = form_edit_basket.cleaned_data['delta_time']
basket.max_size = form_edit_basket.cleaned_data['max_size']
basket.save()
basket_handler = Alirem()
if basket_can_be_cleared(pk):
basket_handler.check_basket_for_cleaning(mode=basket.get_mode_display(),
basket_path=basket.path,
time=iso8601(basket.delta_time),
size=basket.max_size)
return redirect('alibaskets:basket_detail', pk=basket.pk)
else:
taskform = TaskForm()
form_edit_basket = BasketEditForm(initial=
{'mode':basket.mode,
'delta_time':basket.delta_time,
'max_size':basket.max_size})
basket_handler = Alirem()
if os.path.exists(basket.path):
list_of_objects_in_basket = basket_handler.get_basket_list(basket.path)
basket_size = getsize.get_size(basket.path) / 1000000.0
basket_size_in_proc = (int)((basket_size*100.0)/basket.max_size)
for obj in list_of_objects_in_basket:
obj.disappearances_time = obj.time + basket.delta_time
else:
list_of_objects_in_basket = None
basket_size_in_proc = 0
return render(request, 'baskets/basket_detail.html',
{'basket': basket,
'form' : taskform,
'form_basket': form_edit_basket,
'list_of_objects': list_of_objects_in_basket,
'basket_size_in_proc': basket_size_in_proc})
def update_progress(file_now, total_size, existing_file_size=None):
if existing_file_size is not None:
percent = int(((get_size(file_now)-existing_file_size)*100.0)/(total_size+1))
else:
percent = int((get_size(file_now)*100.0)/(total_size+1))
return percent