code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Tools/Directories.py

   1 # -*- coding: utf-8 -*-
   2
   3 from os import path as os_path, mkdir, rmdir, system, walk, stat as os_stat, listdir, readlink, makedirs, error as os_error, symlink, access, F_OK, R_OK, W_OK
   4 from stat import S_IMODE
   5 from re import compile
   6 from enigma import eEnv
   7
   8 try:
   9         from os import chmod
  10         have_chmod = True
  11 except:
  12         have_chmod = False
  13
  14 try:
  15         from os import utime
  16         have_utime = True
  17 except:
  18         have_utime = False
  19
  20 import os
  21
  22 SCOPE_TRANSPONDERDATA = 0
  23 SCOPE_SYSETC = 1
  24 SCOPE_FONTS = 2
  25 SCOPE_SKIN = 3
  26 SCOPE_SKIN_IMAGE = 4
  27 SCOPE_USERETC = 5
  28 SCOPE_CONFIG = 6
  29 SCOPE_LANGUAGE = 7
  30 SCOPE_HDD = 8
  31 SCOPE_PLUGINS = 9
  32 SCOPE_MEDIA = 10
  33 SCOPE_PLAYLIST = 11
  34 SCOPE_CURRENT_SKIN = 12
  35 SCOPE_DEFAULTDIR = 13
  36 SCOPE_DEFAULTPARTITION = 14
  37 SCOPE_DEFAULTPARTITIONMOUNTDIR = 15
  38 SCOPE_METADIR = 16
  39 SCOPE_CURRENT_PLUGIN = 17
  40
  41 PATH_CREATE = 0
  42 PATH_DONTCREATE = 1
  43 PATH_FALLBACK = 2
  44 defaultPaths = {
  45                 SCOPE_TRANSPONDERDATA: (eEnv.resolve("${sysconfdir}/"), PATH_DONTCREATE),
  46                 SCOPE_SYSETC: (eEnv.resolve("${sysconfdir}/"), PATH_DONTCREATE),
  47                 SCOPE_FONTS: (eEnv.resolve("${datadir}/fonts/"), PATH_DONTCREATE),
  48                 SCOPE_CONFIG: (eEnv.resolve("${sysconfdir}/enigma2/"), PATH_CREATE),
  49                 SCOPE_PLUGINS: (eEnv.resolve("${libdir}/enigma2/python/Plugins/"), PATH_CREATE),
  50
  51                 SCOPE_LANGUAGE: (eEnv.resolve("${datadir}/enigma2/po/"), PATH_DONTCREATE),
  52
  53                 SCOPE_SKIN: (eEnv.resolve("${datadir}/enigma2/"), PATH_DONTCREATE),
  54                 SCOPE_SKIN_IMAGE: (eEnv.resolve("${datadir}/enigma2/"), PATH_DONTCREATE),
  55                 SCOPE_HDD: ("/hdd/movie/", PATH_DONTCREATE),
  56                 SCOPE_MEDIA: ("/media/", PATH_DONTCREATE),
  57                 SCOPE_PLAYLIST: (eEnv.resolve("${sysconfdir}/enigma2/playlist/"), PATH_CREATE),
  58
  59                 SCOPE_USERETC: ("", PATH_DONTCREATE), # user home directory
  60
  61                 SCOPE_DEFAULTDIR: (eEnv.resolve("${datadir}/enigma2/defaults/"), PATH_CREATE),
  62                 SCOPE_DEFAULTPARTITION: ("/dev/mtdblock6", PATH_DONTCREATE),
  63                 SCOPE_DEFAULTPARTITIONMOUNTDIR: (eEnv.resolve("${datadir}/enigma2/dealer"), PATH_CREATE),
  64                 SCOPE_METADIR: (eEnv.resolve("${datadir}/meta"), PATH_CREATE),
  65         }
  66
  67 FILE_COPY = 0 # copy files from fallback dir to the basedir
  68 FILE_MOVE = 1 # move files
  69 PATH_COPY = 2 # copy the complete fallback dir to the basedir
  70 PATH_MOVE = 3 # move the fallback dir to the basedir (can be used for changes in paths)
  71 fallbackPaths = {
  72                 SCOPE_CONFIG: [("/home/root/", FILE_MOVE),
  73                                            (eEnv.resolve("${datadir}/enigma2/defaults/"), FILE_COPY)],
  74                 SCOPE_HDD: [("/hdd/movies", PATH_MOVE)]
  75         }
  76
  77 def resolveFilename(scope, base = "", path_prefix = None):
  78         if base[0:2] == "~/":
  79                 # you can only use the ~/ if we have a prefix directory
  80                 assert path_prefix is not None
  81                 base = os_path.join(path_prefix, base[2:])
  82
  83         # don't resolve absolute paths
  84         if base[0:1] == '/':
  85                 return base
  86
  87         if scope == SCOPE_CURRENT_SKIN:
  88                 from Components.config import config
  89                 tmp = defaultPaths[SCOPE_SKIN]
  90                 pos = config.skin.primary_skin.value.rfind('/')
  91                 if pos != -1:
  92                         #if basefile is not available use default skin path as fallback
  93                         tmpfile = tmp[0]+config.skin.primary_skin.value[:pos+1] + base
  94                         if fileExists(tmpfile):
  95                                 path = tmp[0]+config.skin.primary_skin.value[:pos+1]
  96                         else:
  97                                 path = tmp[0]
  98                 else:
  99                         path = tmp[0]
 100
 101         elif scope == SCOPE_CURRENT_PLUGIN:
 102                 tmp = defaultPaths[SCOPE_PLUGINS]
 103                 from Components.config import config
 104                 skintmp = defaultPaths[SCOPE_SKIN]
 105                 pos = config.skin.primary_skin.value.rfind('/')
 106                 if pos != -1:
 107                         #if basefile is not available inside current skin path, use the original provided file as fallback
 108                         skintmpfile = skintmp[0]+config.skin.primary_skin.value[:pos+1] + base
 109                         if fileExists(skintmpfile):
 110                                 path = skintmp[0]+config.skin.primary_skin.value[:pos+1]
 111                         else:
 112                                 path = tmp[0]
 113                 else:
 114                         path = tmp[0]
 115         else:
 116                 tmp = defaultPaths[scope]
 117                 path = tmp[0]
 118
 119         flags = tmp[1]
 120
 121         if flags == PATH_CREATE:
 122                 if not pathExists(path):
 123                         try:
 124                                 mkdir(path)
 125                         except OSError:
 126                                 print "resolveFilename: Couldn't create %s" % path
 127                                 return None
 128
 129         fallbackPath = fallbackPaths.get(scope)
 130
 131         if fallbackPath and not fileExists(path + base):
 132                 for x in fallbackPath:
 133                         if x[1] == FILE_COPY:
 134                                 if fileExists(x[0] + base):
 135                                         system("cp " + x[0] + base + " " + path + base)
 136                                         break
 137                         elif x[1] == FILE_MOVE:
 138                                 if fileExists(x[0] + base):
 139                                         system("mv " + x[0] + base + " " + path + base)
 140                                         break
 141                         elif x[1] == PATH_COPY:
 142                                 if pathExists(x[0]):
 143                                         if not pathExists(defaultPaths[scope][0]):
 144                                                 mkdir(path)
 145                                         system("cp -a " + x[0] + "* " + path)
 146                                         break
 147                         elif x[1] == PATH_MOVE:
 148                                 if pathExists(x[0]):
 149                                         system("mv " + x[0] + " " + path)
 150                                         break
 151
 152         # FIXME: we also have to handle DATADIR etc. here.
 153         return path + base
 154         # this is only the BASE - an extension must be added later.
 155
 156 pathExists = os.path.exists
 157 isMount = os.path.ismount
 158
 159 def bestRecordingLocation(candidates):
 160         path = ''
 161
 162         from Components import Harddisk
 163         ata_devices = [candidate for candidate in candidates if Harddisk.getDeviceInterface(candidate[1]) == "ata"]
 164
 165         if len(ata_devices) == 1:
 166                 path = ata_devices[0][1]
 167
 168         elif len(ata_devices):
 169                 best = ""
 170                 for device in ata_devices:
 171                         dev = os.path.basename(device[0])
 172                         if not best or (best > dev):
 173                                 best = dev
 174                                 path = device[1]
 175         else: # Find the largest usb disk
 176                 biggest = 0
 177                 for candidate in candidates:
 178                         try:
 179                                 stat = os.statvfs(candidate[1])
 180                                 # must have some free space (i.e. not read-only)
 181                                 if stat.f_bavail:
 182                                         # Free space counts double
 183                                         size = (stat.f_blocks + stat.f_bavail) * stat.f_bsize
 184                                         if size > biggest:
 185                                                 path = candidate[1]
 186                                                 biggest = size
 187                         except Exception, e:
 188                                 print "[DRL]", e
 189
 190         return path
 191
 192 def defaultRecordingLocation(candidate=None):
 193         if candidate and os.path.exists(candidate):
 194                 return candidate
 195         # First, try whatever /hdd points to, or /media/hdd
 196         try:
 197                 path = os.path.realpath('/hdd')
 198         except:
 199                 path = '/media/hdd'
 200         if not os.path.exists(path) or not os.path.ismount(path):
 201                 path = ''
 202                 from Components import Harddisk
 203                 mounts = [m for m in Harddisk.getProcMounts() if m[1].startswith('/media/')]
 204                 path = bestRecordingLocation([m for m in mounts if m[0].startswith('/dev/')])
 205         if path:
 206                 # If there's a movie subdir, we'd probably want to use that.
 207                 movie = os.path.join(path, 'movie')
 208                 if os.path.isdir(movie):
 209                         path = movie
 210                 if not path.endswith('/'):
 211                         path += '/' # Bad habits die hard, old code relies on this
 212
 213         return path
 214
 215 def createDir(path, makeParents = False):
 216         try:
 217                 if makeParents:
 218                         makedirs(path)
 219                 else:
 220                         mkdir(path)
 221         except:
 222                 ret = 0
 223         else:
 224                 ret = 1
 225         return ret
 226
 227 def removeDir(path):
 228         try:
 229                 rmdir(path)
 230         except:
 231                 ret = 0
 232         else:
 233                 ret = 1
 234         return ret
 235
 236 def fileExists(f, mode='r'):
 237         if mode == 'r':
 238                 acc_mode = R_OK
 239         elif mode == 'w':
 240                 acc_mode = W_OK
 241         else:
 242                 acc_mode = F_OK
 243         return access(f, acc_mode)
 244
 245 def fileCheck(f, mode='r'):
 246         return fileExists(f, mode) and f
 247
 248 def getRecordingFilename(basename, dirname = None):
 249         if not dirname.endswith('/'):
 250                 dirname += '/'
 251
 252         # filter out non-allowed characters
 253         non_allowed_characters = "/.\\:*?<>|\""
 254         filename = ""
 255
 256         basename = basename.replace('\xc2\x86', '').replace('\xc2\x87', '')
 257
 258         for c in basename:
 259                 if c in non_allowed_characters or ord(c) < 32:
 260                         c = "_"
 261                 filename += c
 262
 263         if dirname is not None:
 264                 filename = ''.join((dirname, filename))
 265
 266         while len(filename) > 240:
 267                 filename = filename.decode('UTF-8')
 268                 filename = filename[:-1]
 269                 filename = filename.encode('UTF-8')
 270
 271         i = 0
 272         while True:
 273                 path = resolveFilename(SCOPE_HDD, filename)
 274                 if i > 0:
 275                         path += "_%03d" % i
 276                 try:
 277                         open(path + ".ts")
 278                         i += 1
 279                 except IOError:
 280                         return path
 281
 282 # this is clearly a hack:
 283 def InitFallbackFiles():
 284         resolveFilename(SCOPE_CONFIG, "userbouquet.favourites.tv")
 285         resolveFilename(SCOPE_CONFIG, "bouquets.tv")
 286         resolveFilename(SCOPE_CONFIG, "userbouquet.favourites.radio")
 287         resolveFilename(SCOPE_CONFIG, "bouquets.radio")
 288
 289 # returns a list of tuples containing pathname and filename matching the given pattern
 290 # example-pattern: match all txt-files: ".*\.txt$"
 291 def crawlDirectory(directory, pattern):
 292         list = []
 293         if directory:
 294                 expression = compile(pattern)
 295                 for root, dirs, files in walk(directory):
 296                         for file in files:
 297                                 if expression.match(file) is not None:
 298                                         list.append((root, file))
 299         return list
 300
 301 def copyfile(src, dst):
 302         try:
 303                 f1 = open(src, "rb")
 304                 if os_path.isdir(dst):
 305                         dst = os_path.join(dst, os_path.basename(src))
 306                 f2 = open(dst, "w+b")
 307                 while True:
 308                         buf = f1.read(16*1024)
 309                         if not buf:
 310                                 break
 311                         f2.write(buf)
 312                 st = os_stat(src)
 313                 mode = S_IMODE(st.st_mode)
 314                 if have_chmod:
 315                         chmod(dst, mode)
 316                 if have_utime:
 317                         utime(dst, (st.st_atime, st.st_mtime))
 318         except:
 319                 print "copy", src, "to", dst, "failed!"
 320                 return -1
 321         return 0
 322
 323 def copytree(src, dst, symlinks=False):
 324         names = listdir(src)
 325         if os_path.isdir(dst):
 326                 dst = os_path.join(dst, os_path.basename(src))
 327                 if not os_path.isdir(dst):
 328                         mkdir(dst)
 329         else:
 330                 makedirs(dst)
 331         for name in names:
 332                 srcname = os_path.join(src, name)
 333                 dstname = os_path.join(dst, name)
 334                 try:
 335                         if symlinks and os_path.islink(srcname):
 336                                 linkto = readlink(srcname)
 337                                 symlink(linkto, dstname)
 338                         elif os_path.isdir(srcname):
 339                                 copytree(srcname, dstname, symlinks)
 340                         else:
 341                                 copyfile(srcname, dstname)
 342                 except:
 343                         print "dont copy srcname (no file or link or folder)"
 344         try:
 345                 st = os_stat(src)
 346                 mode = S_IMODE(st.st_mode)
 347                 if have_chmod:
 348                         chmod(dst, mode)
 349                 if have_utime:
 350                         utime(dst, (st.st_atime, st.st_mtime))
 351         except:
 352                 print "copy stats for", src, "failed!"
 353
 354 def getSize(path, pattern=".*"):
 355         path_size = 0
 356         if os_path.isdir(path):
 357                 files = crawlDirectory(path, pattern)
 358                 for file in files:
 359                         filepath = os_path.join(file[0], file[1])
 360                         path_size += os_path.getsize(filepath)
 361         elif os_path.isfile(path):
 362                 path_size = os_path.getsize(path)
 363         return path_size