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