Safihre
8 years ago
23 changed files with 945 additions and 932 deletions
@ -0,0 +1,860 @@ |
|||
#!/usr/bin/python -OO |
|||
# Copyright 2008-2017 The SABnzbd-Team <team@sabnzbd.org> |
|||
# |
|||
# This program is free software; you can redistribute it and/or |
|||
# modify it under the terms of the GNU General Public License |
|||
# as published by the Free Software Foundation; either version 2 |
|||
# of the License, or (at your option) any later version. |
|||
# |
|||
# This program is distributed in the hope that it will be useful, |
|||
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
# GNU General Public License for more details. |
|||
# |
|||
# You should have received a copy of the GNU General Public License |
|||
# along with this program; if not, write to the Free Software |
|||
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|||
|
|||
""" |
|||
sabnzbd.misc - filesystem operations |
|||
""" |
|||
|
|||
import os |
|||
import sys |
|||
import logging |
|||
import urllib.request, urllib.parse, urllib.error |
|||
import re |
|||
import shutil |
|||
import threading |
|||
import subprocess |
|||
import socket |
|||
import time |
|||
import datetime |
|||
import fnmatch |
|||
import stat |
|||
from urllib.parse import urlparse |
|||
|
|||
import sabnzbd |
|||
from sabnzbd.decorators import synchronized |
|||
from sabnzbd.constants import DEFAULT_PRIORITY, FUTURE_Q_FOLDER, JOB_ADMIN, \ |
|||
GIGI, MEBI, DEF_CACHE_LIMIT |
|||
from sabnzbd.encoding import ubtou, unicoder, special_fixer, gUTF |
|||
|
|||
|
|||
def get_ext(filename): |
|||
""" Return lowercased file extension """ |
|||
try: |
|||
return os.path.splitext(filename)[1].lower() |
|||
except: |
|||
return '' |
|||
|
|||
|
|||
def get_filename(path): |
|||
""" Return path without the file extension """ |
|||
try: |
|||
return os.path.split(path)[1] |
|||
except: |
|||
return '' |
|||
|
|||
|
|||
def is_writable(path): |
|||
""" Return True is file is writable (also when non-existent) """ |
|||
if os.path.isfile(path): |
|||
return bool(os.stat(path).st_mode & stat.S_IWUSR) |
|||
else: |
|||
return True |
|||
|
|||
|
|||
_DEVICES = ('con', 'prn', 'aux', 'nul', |
|||
'com1', 'com2', 'com3', 'com4', 'com5', 'com6', 'com7', 'com8', 'com9', |
|||
'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9') |
|||
|
|||
def replace_win_devices(name): |
|||
''' Remove reserved Windows device names from a name. |
|||
aux.txt ==> _aux.txt |
|||
txt.aux ==> txt.aux |
|||
''' |
|||
if name: |
|||
lname = name.lower() |
|||
for dev in _DEVICES: |
|||
if lname == dev or lname.startswith(dev + '.'): |
|||
name = '_' + name |
|||
break |
|||
|
|||
# Remove special NTFS filename |
|||
if lname.startswith('$mft'): |
|||
name = name.replace('$', 'S', 1) |
|||
|
|||
return name |
|||
|
|||
|
|||
def has_win_device(p): |
|||
""" Return True if filename part contains forbidden name |
|||
Before and after sanitizing |
|||
""" |
|||
p = os.path.split(p)[1].lower() |
|||
for dev in _DEVICES: |
|||
if p == dev or p.startswith(dev + '.') or p.startswith('_' + dev + '.'): |
|||
return True |
|||
return False |
|||
|
|||
|
|||
if sabnzbd.WIN32: |
|||
# the colon should be here too, but we'll handle that separately |
|||
CH_ILLEGAL = '\/<>?*|"\t' |
|||
CH_LEGAL = '++{}!@#`+' |
|||
else: |
|||
CH_ILLEGAL = '/' |
|||
CH_LEGAL = '+' |
|||
|
|||
|
|||
def sanitize_filename(name): |
|||
""" Return filename with illegal chars converted to legal ones |
|||
and with the par2 extension always in lowercase |
|||
""" |
|||
if not name: |
|||
return name |
|||
illegal = CH_ILLEGAL |
|||
legal = CH_LEGAL |
|||
|
|||
if ':' in name: |
|||
if sabnzbd.WIN32: |
|||
# Compensate for the odd way par2 on Windows substitutes a colon character |
|||
name = name.replace(':', '3A') |
|||
elif sabnzbd.DARWIN: |
|||
# Compensate for the foolish way par2 on OSX handles a colon character |
|||
name = name[name.rfind(':') + 1:] |
|||
|
|||
if sabnzbd.WIN32 or sabnzbd.cfg.sanitize_safe(): |
|||
name = replace_win_devices(name) |
|||
|
|||
lst = [] |
|||
for ch in name.strip(): |
|||
if ch in illegal: |
|||
ch = legal[illegal.find(ch)] |
|||
lst.append(ch) |
|||
name = ''.join(lst) |
|||
|
|||
if not name: |
|||
name = 'unknown' |
|||
|
|||
name, ext = os.path.splitext(name) |
|||
lowext = ext.lower() |
|||
if lowext == '.par2' and lowext != ext: |
|||
ext = lowext |
|||
return name + ext |
|||
|
|||
|
|||
def sanitize_foldername(name, limit=True): |
|||
""" Return foldername with dodgy chars converted to safe ones |
|||
Remove any leading and trailing dot and space characters |
|||
""" |
|||
if not name: |
|||
return name |
|||
|
|||
illegal = CH_ILLEGAL + ':\x92"' |
|||
legal = CH_LEGAL + "-''" |
|||
|
|||
if sabnzbd.cfg.sanitize_safe(): |
|||
# Remove all bad Windows chars too |
|||
illegal += r'\/<>?*|":' |
|||
legal += r'++{}!@#`;' |
|||
|
|||
repl = sabnzbd.cfg.replace_illegal() |
|||
lst = [] |
|||
for ch in name.strip(): |
|||
if ch in illegal: |
|||
if repl: |
|||
ch = legal[illegal.find(ch)] |
|||
lst.append(ch) |
|||
else: |
|||
lst.append(ch) |
|||
name = ''.join(lst) |
|||
name = name.strip() |
|||
|
|||
if sabnzbd.WIN32 or sabnzbd.cfg.sanitize_safe(): |
|||
name = replace_win_devices(name) |
|||
|
|||
maxlen = sabnzbd.cfg.folder_max_length() |
|||
if limit and len(name) > maxlen: |
|||
name = name[:maxlen] |
|||
|
|||
# And finally, make sure it doesn't end in a dot |
|||
if name != '.' and name != '..': |
|||
name = name.rstrip('.') |
|||
if not name: |
|||
name = 'unknown' |
|||
|
|||
return name |
|||
|
|||
|
|||
def sanitize_and_trim_path(path): |
|||
""" Remove illegal characters and trim element size """ |
|||
path = path.strip() |
|||
new_path = '' |
|||
if sabnzbd.WIN32: |
|||
if path.startswith('\\\\?\\UNC\\'): |
|||
new_path = '\\\\?\\UNC\\' |
|||
path = path[8:] |
|||
elif path.startswith('\\\\?\\'): |
|||
new_path = '\\\\?\\' |
|||
path = path[4:] |
|||
|
|||
path = path.replace('\\', '/') |
|||
parts = path.split('/') |
|||
if sabnzbd.WIN32 and len(parts[0]) == 2 and ':' in parts[0]: |
|||
new_path += parts[0] + '/' |
|||
parts.pop(0) |
|||
elif path.startswith('//'): |
|||
new_path = '//' |
|||
elif path.startswith('/'): |
|||
new_path = '/' |
|||
for part in parts: |
|||
new_path = os.path.join(new_path, sanitize_foldername(part)) |
|||
return os.path.abspath(os.path.normpath(new_path)) |
|||
|
|||
|
|||
def sanitize_files_in_folder(folder): |
|||
""" Sanitize each file in the folder, return list of new names |
|||
""" |
|||
lst = [] |
|||
for root, _, files in os.walk(folder): |
|||
for file_ in files: |
|||
path = os.path.join(root, file_) |
|||
new_path = os.path.join(root, sanitize_filename(file_)) |
|||
if path != new_path: |
|||
try: |
|||
os.rename(path, new_path) |
|||
path = new_path |
|||
except: |
|||
logging.debug('Cannot rename %s to %s', path, new_path) |
|||
lst.append(path) |
|||
return lst |
|||
|
|||
|
|||
def is_obfuscated_filename(filename): |
|||
""" Check if this file has an extension, if not, it's |
|||
probably obfuscated and we don't use it |
|||
""" |
|||
return (os.path.splitext(filename)[1] == '') |
|||
|
|||
|
|||
def create_all_dirs(path, umask=False): |
|||
""" Create all required path elements and set umask on all |
|||
Return True if last element could be made or exists |
|||
""" |
|||
result = True |
|||
if sabnzbd.WIN32: |
|||
try: |
|||
os.makedirs(path) |
|||
except: |
|||
result = False |
|||
else: |
|||
lst = [] |
|||
lst.extend(path.split('/')) |
|||
path = '' |
|||
for d in lst: |
|||
if d: |
|||
path += '/' + d |
|||
if not os.path.exists(path): |
|||
try: |
|||
os.mkdir(path) |
|||
result = True |
|||
except: |
|||
result = False |
|||
if umask: |
|||
mask = sabnzbd.cfg.umask() |
|||
if mask: |
|||
try: |
|||
os.chmod(path, int(mask, 8) | 0o700) |
|||
except: |
|||
pass |
|||
return result |
|||
|
|||
|
|||
def real_path(loc, path): |
|||
""" When 'path' is relative, return normalized join of 'loc' and 'path' |
|||
When 'path' is absolute, return normalized path |
|||
A path starting with ~ will be located in the user's Home folder |
|||
""" |
|||
# The Windows part is a bit convoluted because |
|||
# os.path.join() doesn't behave the same for all Python versions |
|||
if path: |
|||
path = path.strip() |
|||
else: |
|||
path = '' |
|||
if path: |
|||
if not sabnzbd.WIN32 and path.startswith('~/'): |
|||
path = path.replace('~', os.environ.get('HOME', sabnzbd.DIR_HOME), 1) |
|||
if sabnzbd.WIN32: |
|||
path = path.replace('/', '\\') |
|||
if len(path) > 1 and path[0].isalpha() and path[1] == ':': |
|||
if len(path) == 2 or path[2] != '\\': |
|||
path = path.replace(':', ':\\', 1) |
|||
elif path.startswith('\\\\'): |
|||
pass |
|||
elif path.startswith('\\'): |
|||
if len(loc) > 1 and loc[0].isalpha() and loc[1] == ':': |
|||
path = loc[:2] + path |
|||
else: |
|||
path = os.path.join(loc, path) |
|||
elif path[0] != '/': |
|||
path = os.path.join(loc, path) |
|||
|
|||
# Always use long-path notation |
|||
path = long_path(path) |
|||
else: |
|||
path = loc |
|||
|
|||
return os.path.normpath(os.path.abspath(path)) |
|||
|
|||
|
|||
def create_real_path(name, loc, path, umask=False, writable=True): |
|||
""" When 'path' is relative, create join of 'loc' and 'path' |
|||
When 'path' is absolute, create normalized path |
|||
'name' is used for logging. |
|||
Optional 'umask' will be applied. |
|||
'writable' means that an existing folder should be writable |
|||
Returns ('success', 'full path') |
|||
""" |
|||
if path: |
|||
my_dir = real_path(loc, path) |
|||
if not os.path.exists(my_dir): |
|||
logging.info('%s directory: %s does not exist, try to create it', name, my_dir) |
|||
if not create_all_dirs(my_dir, umask): |
|||
logging.error(T('Cannot create directory %s'), clip_path(my_dir)) |
|||
return (False, my_dir) |
|||
|
|||
checks = (os.W_OK + os.R_OK) if writable else os.R_OK |
|||
if os.access(my_dir, checks): |
|||
return (True, my_dir) |
|||
else: |
|||
logging.error(T('%s directory: %s error accessing'), name, clip_path(my_dir)) |
|||
return (False, my_dir) |
|||
else: |
|||
return (False, "") |
|||
|
|||
|
|||
def is_relative_path(p): |
|||
""" Return True if path is relative """ |
|||
p = p.replace('\\', '/') |
|||
if p and p[0] == '/': |
|||
return False |
|||
if sabnzbd.WIN32 and p and len(p) > 2: |
|||
if p[0].isalpha() and p[1] == ':' and p[2] == '/': |
|||
return False |
|||
return True |
|||
|
|||
|
|||
def same_file(a, b): |
|||
""" Return 0 if A and B have nothing in common |
|||
return 1 if A and B are actually the same path |
|||
return 2 if B is a subfolder of A |
|||
""" |
|||
a = os.path.normpath(os.path.abspath(a)) |
|||
b = os.path.normpath(os.path.abspath(b)) |
|||
if sabnzbd.WIN32 or sabnzbd.DARWIN: |
|||
a = a.lower() |
|||
b = b.lower() |
|||
|
|||
if b.startswith(a): |
|||
return 2 |
|||
if "samefile" in os.path.__dict__: |
|||
try: |
|||
return int(os.path.samefile(a, b)) |
|||
except: |
|||
return 0 |
|||
else: |
|||
return int(a == b) |
|||
|
|||
|
|||
def check_mount(path): |
|||
""" Return False if volume isn't mounted on Linux or OSX |
|||
Retry 6 times with an interval of 1 sec. |
|||
""" |
|||
if sabnzbd.DARWIN: |
|||
m = re.search(r'^(/Volumes/[^/]+)/', path, re.I) |
|||
elif sabnzbd.WIN32: |
|||
m = re.search(r'^([a-z]:\\)', path, re.I) |
|||
else: |
|||
m = re.search(r'^(/(?:mnt|media)/[^/]+)/', path) |
|||
|
|||
if m: |
|||
for n in range(sabnzbd.cfg.wait_ext_drive() or 1): |
|||
if os.path.exists(m.group(1)): |
|||
return True |
|||
logging.debug('Waiting for %s to come online', m.group(1)) |
|||
time.sleep(1) |
|||
return not m |
|||
|
|||
|
|||
|
|||
def safe_fnmatch(f, pattern): |
|||
""" fnmatch will fail if the pattern contains any of it's |
|||
key characters, like [, ] or !. |
|||
""" |
|||
try: |
|||
return fnmatch.fnmatch(f, pattern) |
|||
except re.error: |
|||
return False |
|||
|
|||
|
|||
def globber(path, pattern='*'): |
|||
""" Return matching base file/folder names in folder `path` """ |
|||
# Cannot use glob.glob() because it doesn't support Windows long name notation |
|||
if os.path.exists(path): |
|||
return [f for f in os.listdir(path) if safe_fnmatch(f, pattern)] |
|||
return [] |
|||
|
|||
|
|||
def globber_full(path, pattern='*'): |
|||
""" Return matching full file/folder names in folder `path` """ |
|||
# Cannot use glob.glob() because it doesn't support Windows long name notation |
|||
if os.path.exists(path): |
|||
return [os.path.join(path, f) for f in os.listdir(path) if safe_fnmatch(f, pattern)] |
|||
return [] |
|||
|
|||
|
|||
def trim_win_path(path): |
|||
""" Make sure Windows path stays below 70 by trimming last part """ |
|||
if sabnzbd.WIN32 and len(path) > 69: |
|||
path, folder = os.path.split(path) |
|||
maxlen = 69 - len(path) |
|||
if len(folder) > maxlen: |
|||
folder = folder[:maxlen] |
|||
path = os.path.join(path, folder).rstrip('. ') |
|||
return path |
|||
|
|||
|
|||
def fix_unix_encoding(folder): |
|||
""" Fix bad name encoding for Unix systems """ |
|||
if not sabnzbd.WIN32 and not sabnzbd.DARWIN and gUTF: |
|||
for root, dirs, files in os.walk(folder.encode('utf-8')): |
|||
for name in files: |
|||
new_name = special_fixer(name).encode('utf-8') |
|||
if name != new_name: |
|||
try: |
|||
shutil.move(os.path.join(root, name), os.path.join(root, new_name)) |
|||
except: |
|||
logging.info('Cannot correct name of %s', os.path.join(root, name)) |
|||
|
|||
|
|||
def make_script_path(script): |
|||
""" Return full script path, if any valid script exists, else None """ |
|||
s_path = None |
|||
path = sabnzbd.cfg.script_dir.get_path() |
|||
if path and script: |
|||
if script.lower() not in ('none', 'default'): |
|||
s_path = os.path.join(path, script) |
|||
if not os.path.exists(s_path): |
|||
s_path = None |
|||
return s_path |
|||
|
|||
|
|||
def get_admin_path(name, future): |
|||
""" Return news-style full path to job-admin folder of names job |
|||
or else the old cache path |
|||
""" |
|||
if future: |
|||
return os.path.join(sabnzbd.cfg.admin_dir.get_path(), FUTURE_Q_FOLDER) |
|||
else: |
|||
return os.path.join(os.path.join(sabnzbd.cfg.download_dir.get_path(), name), JOB_ADMIN) |
|||
|
|||
def starts_with_path(path, prefix): |
|||
""" Return True if 'path' starts with 'prefix', |
|||
considering case-sensitivity of the file system |
|||
""" |
|||
if sabnzbd.WIN32: |
|||
return clip_path(path).lower().startswith(prefix.lower()) |
|||
elif sabnzbd.DARWIN: |
|||
return path.lower().startswith(prefix.lower()) |
|||
else: |
|||
return path.startswith(prefix) |
|||
|
|||
|
|||
def set_chmod(path, permissions, report): |
|||
""" Set 'permissions' on 'path', report any errors when 'report' is True """ |
|||
try: |
|||
logging.debug('Applying permissions %s (octal) to %s', oct(permissions), path) |
|||
os.chmod(path, permissions) |
|||
except: |
|||
lpath = path.lower() |
|||
if report and '.appledouble' not in lpath and '.ds_store' not in lpath: |
|||
logging.error(T('Cannot change permissions of %s'), clip_path(path)) |
|||
logging.info("Traceback: ", exc_info=True) |
|||
|
|||
|
|||
def set_permissions(path, recursive=True): |
|||
""" Give folder tree and its files their proper permissions """ |
|||
if not sabnzbd.WIN32: |
|||
umask = sabnzbd.cfg.umask() |
|||
try: |
|||
# Make sure that user R+W+X is on |
|||
umask = int(umask, 8) | int('0700', 8) |
|||
report = True |
|||
except ValueError: |
|||
# No or no valid permissions |
|||
# Use the effective permissions of the session |
|||
# Don't report errors (because the system might not support it) |
|||
umask = int('0777', 8) & (sabnzbd.ORG_UMASK ^ int('0777', 8)) |
|||
report = False |
|||
|
|||
# Remove X bits for files |
|||
umask_file = umask & int('7666', 8) |
|||
|
|||
if os.path.isdir(path): |
|||
if recursive: |
|||
# Parse the dir/file tree and set permissions |
|||
for root, _dirs, files in os.walk(path): |
|||
set_chmod(root, umask, report) |
|||
for name in files: |
|||
set_chmod(os.path.join(root, name), umask_file, report) |
|||
else: |
|||
set_chmod(path, umask, report) |
|||
else: |
|||
set_chmod(path, umask_file, report) |
|||
|
|||
|
|||
def clip_path(path): |
|||
r""" Remove \\?\ or \\?\UNC\ prefix from Windows path """ |
|||
if sabnzbd.WIN32 and path and '?' in path: |
|||
path = path.replace('\\\\?\\UNC\\', '\\\\', 1).replace('\\\\?\\', '', 1) |
|||
return path |
|||
|
|||
|
|||
def long_path(path): |
|||
""" For Windows, convert to long style path; others, return same path """ |
|||
if sabnzbd.WIN32 and path and not path.startswith('\\\\?\\'): |
|||
if path.startswith('\\\\'): |
|||
# Special form for UNC paths |
|||
path = path.replace('\\\\', '\\\\?\\UNC\\', 1) |
|||
else: |
|||
# Normal form for local paths |
|||
path = '\\\\?\\' + path |
|||
return path |
|||
|
|||
|
|||
############################################################################## |
|||
# Locked directory operations to avoid problems with simultaneous add/remove |
|||
############################################################################## |
|||
DIR_LOCK = threading.RLock() |
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def get_unique_path(dirpath, n=0, create_dir=True): |
|||
""" Determine a unique folder or filename """ |
|||
|
|||
if not check_mount(dirpath): |
|||
return dirpath |
|||
|
|||
path = dirpath |
|||
if n: |
|||
path = "%s.%s" % (dirpath, n) |
|||
|
|||
if not os.path.exists(path): |
|||
if create_dir: |
|||
return create_dirs(path) |
|||
else: |
|||
return path |
|||
else: |
|||
return get_unique_path(dirpath, n=n + 1, create_dir=create_dir) |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def get_unique_filename(path): |
|||
""" Check if path is unique. |
|||
If not, add number like: "/path/name.NUM.ext". |
|||
""" |
|||
num = 1 |
|||
new_path, fname = os.path.split(path) |
|||
name, ext = os.path.splitext(fname) |
|||
while os.path.exists(path): |
|||
fname = "%s.%d%s" % (name, num, ext) |
|||
num += 1 |
|||
path = os.path.join(new_path, fname) |
|||
return path |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def create_dirs(dirpath): |
|||
""" Create directory tree, obeying permissions """ |
|||
if not os.path.exists(dirpath): |
|||
logging.info('Creating directories: %s', dirpath) |
|||
if not create_all_dirs(dirpath, True): |
|||
logging.error(T('Failed making (%s)'), clip_path(dirpath)) |
|||
return None |
|||
return dirpath |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def move_to_path(path, new_path): |
|||
""" Move a file to a new path, optionally give unique filename |
|||
Return (ok, new_path) |
|||
""" |
|||
ok = True |
|||
overwrite = sabnzbd.cfg.overwrite_files() |
|||
new_path = os.path.abspath(new_path) |
|||
if overwrite and os.path.exists(new_path): |
|||
try: |
|||
os.remove(new_path) |
|||
except: |
|||
overwrite = False |
|||
if not overwrite: |
|||
new_path = get_unique_filename(new_path) |
|||
|
|||
if new_path: |
|||
logging.debug("Moving (overwrite: %s) %s => %s", overwrite, path, new_path) |
|||
try: |
|||
# First try cheap rename |
|||
renamer(path, new_path) |
|||
except: |
|||
# Cannot rename, try copying |
|||
logging.debug("File could not be renamed, trying copying: %s", path) |
|||
try: |
|||
if not os.path.exists(os.path.dirname(new_path)): |
|||
create_dirs(os.path.dirname(new_path)) |
|||
shutil.copyfile(path, new_path) |
|||
os.remove(path) |
|||
except: |
|||
# Check if the old-file actually exists (possible delete-delays) |
|||
if not os.path.exists(path): |
|||
logging.debug("File not moved, original path gone: %s", path) |
|||
return True, None |
|||
if not (sabnzbd.cfg.marker_file() and sabnzbd.cfg.marker_file() in path): |
|||
logging.error(T('Failed moving %s to %s'), clip_path(path), clip_path(new_path)) |
|||
logging.info("Traceback: ", exc_info=True) |
|||
ok = False |
|||
return ok, new_path |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def cleanup_empty_directories(path): |
|||
""" Remove all empty folders inside (and including) 'path' """ |
|||
path = os.path.normpath(path) |
|||
while 1: |
|||
repeat = False |
|||
for root, dirs, files in os.walk(path, topdown=False): |
|||
if not dirs and not files and root != path: |
|||
try: |
|||
remove_dir(root) |
|||
repeat = True |
|||
except: |
|||
pass |
|||
if not repeat: |
|||
break |
|||
try: |
|||
remove_dir(path) |
|||
except: |
|||
pass |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def get_filepath(path, nzo, filename): |
|||
""" Create unique filepath """ |
|||
# This procedure is only used by the Assembler thread |
|||
# It does no umask setting |
|||
# It uses the dir_lock for the (rare) case that the |
|||
# download_dir is equal to the complete_dir. |
|||
dName = nzo.work_name |
|||
if not nzo.created: |
|||
for n in range(200): |
|||
dName = dirname |
|||
if n: |
|||
dName += '.' + str(n) |
|||
try: |
|||
os.mkdir(os.path.join(path, dName)) |
|||
break |
|||
except: |
|||
pass |
|||
nzo.work_name = dName |
|||
nzo.created = True |
|||
|
|||
fPath = os.path.join(os.path.join(path, dName), filename) |
|||
fPath, ext = os.path.splitext(fPath) |
|||
n = 0 |
|||
while True: |
|||
if n: |
|||
fullPath = "%s.%d%s" % (fPath, n, ext) |
|||
else: |
|||
fullPath = fPath + ext |
|||
if os.path.exists(fullPath): |
|||
n = n + 1 |
|||
else: |
|||
break |
|||
|
|||
return fullPath |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def renamer(old, new): |
|||
""" Rename file/folder with retries for Win32 """ |
|||
# Sanitize last part of new name |
|||
path, name = os.path.split(new) |
|||
# Use the more stringent folder rename to end up with a nicer name, |
|||
# but do not trim size |
|||
new = os.path.join(path, sanitize_foldername(name, False)) |
|||
|
|||
logging.debug('Renaming "%s" to "%s"', old, new) |
|||
if sabnzbd.WIN32: |
|||
retries = 15 |
|||
while retries > 0: |
|||
# First we try 3 times with os.rename |
|||
if retries > 12: |
|||
try: |
|||
os.rename(old, new) |
|||
return |
|||
except: |
|||
retries -= 1 |
|||
time.sleep(3) |
|||
continue |
|||
|
|||
# Now we try the back-up method |
|||
logging.debug('Could not rename, trying move for %s to %s', old, new) |
|||
try: |
|||
shutil.move(old, new) |
|||
return |
|||
except WindowsError as err: |
|||
logging.debug('Error renaming "%s" to "%s" <%s>', old, new, err) |
|||
if err[0] == 32: |
|||
logging.debug('Retry rename %s to %s', old, new) |
|||
retries -= 1 |
|||
else: |
|||
raise WindowsError(err) |
|||
time.sleep(3) |
|||
raise WindowsError(err) |
|||
else: |
|||
shutil.move(old, new) |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def remove_dir(path): |
|||
""" Remove directory with retries for Win32 """ |
|||
logging.debug('Removing dir %s', path) |
|||
if sabnzbd.WIN32: |
|||
retries = 15 |
|||
while retries > 0: |
|||
try: |
|||
os.rmdir(path) |
|||
return |
|||
except WindowsError as err: |
|||
if err[0] == 32: |
|||
logging.debug('Retry delete %s', path) |
|||
retries -= 1 |
|||
else: |
|||
raise WindowsError(err) |
|||
time.sleep(3) |
|||
raise WindowsError(err) |
|||
else: |
|||
os.rmdir(path) |
|||
|
|||
|
|||
@synchronized(DIR_LOCK) |
|||
def remove_all(path, pattern='*', keep_folder=False, recursive=False): |
|||
""" Remove folder and all its content (optionally recursive) """ |
|||
if os.path.exists(path): |
|||
files = globber_full(path, pattern) |
|||
if pattern == '*' and not sabnzbd.WIN32: |
|||
files.extend(globber_full(path, '.*')) |
|||
|
|||
for f in files: |
|||
if os.path.isfile(f): |
|||
try: |
|||
logging.debug('Removing file %s', f) |
|||
os.remove(f) |
|||
except: |
|||
logging.info('Cannot remove file %s', f) |
|||
elif recursive: |
|||
remove_all(f, pattern, False, True) |
|||
if not keep_folder: |
|||
try: |
|||
logging.debug('Removing dir %s', path) |
|||
os.rmdir(path) |
|||
except: |
|||
logging.info('Cannot remove folder %s', path) |
|||
|
|||
############################################################################## |
|||
# Diskfree |
|||
############################################################################## |
|||
def find_dir(p): |
|||
""" Return first folder level that exists in this path """ |
|||
x = 'x' |
|||
while x and not os.path.exists(p): |
|||
p, x = os.path.split(p) |
|||
return p |
|||
|
|||
|
|||
if sabnzbd.WIN32: |
|||
# windows diskfree |
|||
try: |
|||
# Careful here, because win32api test hasn't been done yet! |
|||
import win32api |
|||
except: |
|||
pass |
|||
|
|||
def diskspace_base(_dir): |
|||
""" Return amount of free and used diskspace in GBytes """ |
|||
_dir = find_dir(_dir) |
|||
try: |
|||
available, disk_size, total_free = win32api.GetDiskFreeSpaceEx(_dir) |
|||
return disk_size / GIGI, available / GIGI |
|||
except: |
|||
return 0.0, 0.0 |
|||
|
|||
else: |
|||
try: |
|||
os.statvfs |
|||
# posix diskfree |
|||
def diskspace_base(_dir): |
|||
""" Return amount of free and used diskspace in GBytes """ |
|||
_dir = find_dir(_dir) |
|||
try: |
|||
s = os.statvfs(_dir) |
|||
if s.f_blocks < 0: |
|||
disk_size = float(sys.maxsize) * float(s.f_frsize) |
|||
else: |
|||
disk_size = float(s.f_blocks) * float(s.f_frsize) |
|||
if s.f_bavail < 0: |
|||
available = float(sys.maxsize) * float(s.f_frsize) |
|||
else: |
|||
available = float(s.f_bavail) * float(s.f_frsize) |
|||
return disk_size / GIGI, available / GIGI |
|||
except: |
|||
return 0.0, 0.0 |
|||
except ImportError: |
|||
def diskspace_base(_dir): |
|||
return 20.0, 10.0 |
|||
|
|||
|
|||
# Store all results to speed things up |
|||
__DIRS_CHECKED = [] |
|||
__DISKS_SAME = None |
|||
__LAST_DISK_RESULT = {'download_dir': [], 'complete_dir': []} |
|||
__LAST_DISK_CALL = 0 |
|||
|
|||
def diskspace(force=False): |
|||
""" Wrapper to cache results """ |
|||
global __DIRS_CHECKED, __DISKS_SAME, __LAST_DISK_RESULT, __LAST_DISK_CALL |
|||
|
|||
# Reset everything when folders changed |
|||
dirs_to_check = [sabnzbd.cfg.download_dir.get_path(), sabnzbd.cfg.complete_dir.get_path()] |
|||
if __DIRS_CHECKED != dirs_to_check: |
|||
__DIRS_CHECKED = dirs_to_check |
|||
__DISKS_SAME = None |
|||
__LAST_DISK_RESULT = {'download_dir': [], 'complete_dir': []} |
|||
__LAST_DISK_CALL = 0 |
|||
|
|||
# When forced, ignore any cache to avoid problems in UI |
|||
if force: |
|||
__LAST_DISK_CALL = 0 |
|||
|
|||
# Check against cache |
|||
if time.time() > __LAST_DISK_CALL + 10.0: |
|||
# Same disk? Then copy-paste |
|||
__LAST_DISK_RESULT['download_dir'] = diskspace_base(sabnzbd.cfg.download_dir.get_path()) |
|||
__LAST_DISK_RESULT['complete_dir'] = __LAST_DISK_RESULT['download_dir'] if __DISKS_SAME else diskspace_base(sabnzbd.cfg.complete_dir.get_path()) |
|||
__LAST_DISK_CALL = time.time() |
|||
|
|||
# Do we know if it's same disk? |
|||
if __DISKS_SAME is None: |
|||
__DISKS_SAME = (__LAST_DISK_RESULT['download_dir'] == __LAST_DISK_RESULT['complete_dir']) |
|||
|
|||
return __LAST_DISK_RESULT |
|||
Loading…
Reference in new issue