addons/document_ftp/ftpserver/abstracted_fs.py

   1 # -*- encoding: utf-8 -*-
   2
   3 import os
   4 import time
   5 from tarfile import filemode
   6 import logging
   7 import errno
   8
   9 import glob
  10 import fnmatch
  11
  12 from openerp import pooler, netsvc, sql_db
  13 import openerp.service
  14 from openerp.service import security
  15 from openerp.osv import osv
  16
  17 from openerp.addons.document.document import get_node_context
  18
  19 def _get_month_name(month):
  20     month=int(month)
  21     if month==1:return 'Jan'
  22     elif month==2:return 'Feb'
  23     elif month==3:return 'Mar'
  24     elif month==4:return 'Apr'
  25     elif month==5:return 'May'
  26     elif month==6:return 'Jun'
  27     elif month==7:return 'Jul'
  28     elif month==8:return 'Aug'
  29     elif month==9:return 'Sep'
  30     elif month==10:return 'Oct'
  31     elif month==11:return 'Nov'
  32     elif month==12:return 'Dec'
  33
  34 from ftpserver import _to_decode, _to_unicode
  35
  36
  37 class abstracted_fs(object):
  38     """A class used to interact with the file system, providing a high
  39     level, cross-platform interface compatible with both Windows and
  40     UNIX style filesystems.
  41
  42     It provides some utility methods and some wraps around operations
  43     involved in file creation and file system operations like moving
  44     files or removing directories.
  45
  46     Instance attributes:
  47      - (str) root: the user home directory.
  48      - (str) cwd: the current working directory.
  49      - (str) rnfr: source file to be renamed.
  50
  51     """
  52
  53     def __init__(self):
  54         self.root = None
  55         self.cwd = '/'
  56         self.cwd_node = None
  57         self.rnfr = None
  58         self._log = logging.getLogger(__name__)
  59
  60     # Ok
  61     def db_list(self):
  62         """Get the list of available databases, with FTPd support
  63         """
  64         s = openerp.service.db
  65         result = s.exp_list(document=True)
  66         self.db_name_list = []
  67         for db_name in result:
  68             db, cr = None, None
  69             try:
  70                 try:
  71                     db = sql_db.db_connect(db_name)
  72                     cr = db.cursor()
  73                     cr.execute("SELECT 1 FROM pg_class WHERE relkind = 'r' AND relname = 'ir_module_module'")
  74                     if not cr.fetchone():
  75                         continue
  76
  77                     cr.execute("SELECT id FROM ir_module_module WHERE name = 'document_ftp' AND state IN ('installed', 'to install', 'to upgrade') ")
  78                     res = cr.fetchone()
  79                     if res and len(res):
  80                         self.db_name_list.append(db_name)
  81                     cr.commit()
  82                 except Exception:
  83                     self._log.warning('Cannot use db "%s".', db_name)
  84             finally:
  85                 if cr is not None:
  86                     cr.close()
  87         return self.db_name_list
  88
  89     def ftpnorm(self, ftppath):
  90         """Normalize a "virtual" ftp pathname (tipically the raw string
  91         coming from client).
  92
  93         Pathname returned is relative!.
  94         """
  95         p = os.path.normpath(ftppath)
  96         # normalize string in a standard web-path notation having '/'
  97         # as separator. xrg: is that really in the spec?
  98         p = p.replace("\\", "/")
  99         # os.path.normpath supports UNC paths (e.g. "//a/b/c") but we
 100         # don't need them.  In case we get an UNC path we collapse
 101         # redundant separators appearing at the beginning of the string
 102         while p[:2] == '//':
 103             p = p[1:]
 104         if p == '.':
 105             return ''
 106         return p
 107
 108     def get_cwd(self):
 109         """ return the cwd, decoded in utf"""
 110         return _to_decode(self.cwd)
 111
 112     def ftp2fs(self, path_orig, data):
 113         raise DeprecationWarning()
 114
 115     def fs2ftp(self, node):
 116         """ Return the string path of a node, in ftp form
 117         """
 118         res='/'
 119         if node:
 120             paths = node.full_path()
 121             res = '/' + node.context.dbname + '/' +  \
 122                 _to_decode(os.path.join(*paths))
 123
 124         return res
 125
 126     def validpath(self, path):
 127         """Check whether the path belongs to user's home directory.
 128         Expected argument is a datacr tuple
 129         """
 130         # TODO: are we called for "/" ?
 131         return isinstance(path, tuple) and path[1] and True or False
 132
 133     # --- Wrapper methods around open() and tempfile.mkstemp
 134
 135     def create(self, datacr, objname, mode):
 136         """ Create a children file-node under node, open it
 137             @return open node_descriptor of the created node
 138         """
 139         objname = _to_unicode(objname)
 140         cr , node, rem = datacr
 141         try:
 142             child = node.child(cr, objname)
 143             if child:
 144                 if child.type not in ('file','content'):
 145                     raise OSError(1, 'Operation is not permitted.')
 146
 147                 ret = child.open_data(cr, mode)
 148                 cr.commit()
 149                 assert ret, "Cannot create descriptor for %r: %r." % (child, ret)
 150                 return ret
 151         except EnvironmentError:
 152             raise
 153         except Exception:
 154             self._log.exception('Cannot locate item %s at node %s.', objname, repr(node))
 155             pass
 156
 157         try:
 158             child = node.create_child(cr, objname, data=None)
 159             ret = child.open_data(cr, mode)
 160             assert ret, "Cannot create descriptor for %r." % child
 161             cr.commit()
 162             return ret
 163         except EnvironmentError:
 164             raise
 165         except Exception:
 166             self._log.exception('Cannot create item %s at node %s.', objname, repr(node))
 167             raise OSError(1, 'Operation is not permitted.')
 168
 169     def open(self, datacr, mode):
 170         if not (datacr and datacr[1]):
 171             raise OSError(1, 'Operation is not permitted.')
 172         # Reading operation
 173         cr, node, rem = datacr
 174         try:
 175             res = node.open_data(cr, mode)
 176             cr.commit()
 177         except TypeError:
 178             raise IOError(errno.EINVAL, "No data.")
 179         return res
 180
 181     # ok, but need test more
 182
 183     def mkstemp(self, suffix='', prefix='', dir=None, mode='wb'):
 184         """A wrap around tempfile.mkstemp creating a file with a unique
 185         name.  Unlike mkstemp it returns an object with a file-like
 186         interface.
 187         """
 188         raise NotImplementedError # TODO
 189
 190         text = not 'b' in mode
 191         # for unique file , maintain version if duplicate file
 192         if dir:
 193             cr = dir.cr
 194             uid = dir.uid
 195             pool = pooler.get_pool(node.context.dbname)
 196             object=dir and dir.object or False
 197             object2=dir and dir.object2 or False
 198             res=pool.get('ir.attachment').search(cr,uid,[('name','like',prefix),('parent_id','=',object and object.type in ('directory','ressource') and object.id or False),('res_id','=',object2 and object2.id or False),('res_model','=',object2 and object2._name or False)])
 199             if len(res):
 200                 pre = prefix.split('.')
 201                 prefix=pre[0] + '.v'+str(len(res))+'.'+pre[1]
 202         return self.create(dir,suffix+prefix,text)
 203
 204
 205
 206     # Ok
 207     def chdir(self, datacr):
 208         if (not datacr) or datacr == (None, None, None):
 209             self.cwd = '/'
 210             self.cwd_node = None
 211             return None
 212         if not datacr[1]:
 213             raise OSError(1, 'Operation is not permitted.')
 214         if datacr[1].type not in  ('collection','database'):
 215             raise OSError(2, 'Path is not a directory.')
 216         self.cwd = '/'+datacr[1].context.dbname + '/'
 217         self.cwd += '/'.join(datacr[1].full_path())
 218         self.cwd_node = datacr[1]
 219
 220     # Ok
 221     def mkdir(self, datacr, basename):
 222         """Create the specified directory."""
 223         cr, node, rem = datacr or (None, None, None)
 224         if not node:
 225             raise OSError(1, 'Operation is not permitted.')
 226
 227         try:
 228             basename =_to_unicode(basename)
 229             cdir = node.create_child_collection(cr, basename)
 230             self._log.debug("Created child dir: %r", cdir)
 231             cr.commit()
 232         except Exception:
 233             self._log.exception('Cannot create dir "%s" at node %s.', basename, repr(node))
 234             raise OSError(1, 'Operation is not permitted.')
 235
 236     def close_cr(self, data):
 237         if data and data[0]:
 238             data[0].close()
 239         return True
 240
 241     def get_cr(self, pathname):
 242         raise DeprecationWarning()
 243
 244     def get_crdata(self, line, mode='file'):
 245         """ Get database cursor, node and remainder data, for commands
 246
 247         This is the helper function that will prepare the arguments for
 248         any of the subsequent commands.
 249         It returns a tuple in the form of:
 250         @code        ( cr, node, rem_path=None )
 251
 252         @param line An absolute or relative ftp path, as passed to the cmd.
 253         @param mode A word describing the mode of operation, so that this
 254                     function behaves properly in the different commands.
 255         """
 256         path = self.ftpnorm(line)
 257         if self.cwd_node is None:
 258             if not os.path.isabs(path):
 259                 path = os.path.join(self.root, path)
 260
 261         if path == '/' and mode in ('list', 'cwd'):
 262             return (None, None, None )
 263
 264         path = _to_unicode(os.path.normpath(path)) # again, for '/db/../ss'
 265         if path == '.': path = ''
 266
 267         if os.path.isabs(path) and self.cwd_node is not None \
 268                 and path.startswith(self.cwd):
 269             # make relative, so that cwd_node is used again
 270             path = path[len(self.cwd):]
 271             if path.startswith('/'):
 272                 path = path[1:]
 273
 274         p_parts = path.split(os.sep)
 275
 276         assert '..' not in p_parts
 277
 278         rem_path = None
 279         if mode in ('create',):
 280             rem_path = p_parts[-1]
 281             p_parts = p_parts[:-1]
 282
 283         if os.path.isabs(path):
 284             # we have to start from root, again
 285             while p_parts and p_parts[0] == '':
 286                 p_parts = p_parts[1:]
 287             # self._log.debug("Path parts: %r ", p_parts)
 288             if not p_parts:
 289                 raise IOError(errno.EPERM, 'Cannot perform operation at root directory.')
 290             dbname = p_parts[0]
 291             if dbname not in self.db_list():
 292                 raise IOError(errno.ENOENT,'Invalid database path: %s.' % dbname)
 293             try:
 294                 db = pooler.get_db(dbname)
 295             except Exception:
 296                 raise OSError(1, 'Database cannot be used.')
 297             cr = db.cursor()
 298             try:
 299                 uid = security.login(dbname, self.username, self.password)
 300             except Exception:
 301                 cr.close()
 302                 raise
 303             if not uid:
 304                 cr.close()
 305                 raise OSError(2, 'Authentification required.')
 306             n = get_node_context(cr, uid, {})
 307             node = n.get_uri(cr, p_parts[1:])
 308             return (cr, node, rem_path)
 309         else:
 310             # we never reach here if cwd_node is not set
 311             if p_parts and p_parts[-1] == '':
 312                 p_parts = p_parts[:-1]
 313             cr, uid = self.get_node_cr_uid(self.cwd_node)
 314             if p_parts:
 315                 node = self.cwd_node.get_uri(cr, p_parts)
 316             else:
 317                 node = self.cwd_node
 318             if node is False and mode not in ('???'):
 319                 cr.close()
 320                 raise IOError(errno.ENOENT, 'Path does not exist.')
 321             return (cr, node, rem_path)
 322
 323     def get_node_cr_uid(self, node):
 324         """ Get cr, uid, pool from a node
 325         """
 326         assert node
 327         db = pooler.get_db(node.context.dbname)
 328         return db.cursor(), node.context.uid
 329
 330     def get_node_cr(self, node):
 331         """ Get the cursor for the database of a node
 332
 333         The cursor is the only thing that a node will not store
 334         persistenly, so we have to obtain a new one for each call.
 335         """
 336         return self.get_node_cr_uid(node)[0]
 337
 338     def listdir(self, datacr):
 339         """List the content of a directory."""
 340         class false_node(object):
 341             write_date = 0.0
 342             create_date = 0.0
 343             unixperms = 040550
 344             content_length = 0L
 345             uuser = 'root'
 346             ugroup = 'root'
 347             type = 'database'
 348
 349             def __init__(self, db):
 350                 self.path = db
 351
 352         if datacr[1] is None:
 353             result = []
 354             for db in self.db_list():
 355                 try:
 356                     result.append(false_node(db))
 357                 except osv.except_osv:
 358                     pass
 359             return result
 360         cr, node, rem = datacr
 361         res = node.children(cr)
 362         return res
 363
 364     def rmdir(self, datacr):
 365         """Remove the specified directory."""
 366         cr, node, rem = datacr
 367         assert node
 368         node.rmcol(cr)
 369         cr.commit()
 370
 371     def remove(self, datacr):
 372         assert datacr[1]
 373         if datacr[1].type == 'collection':
 374             return self.rmdir(datacr)
 375         elif datacr[1].type == 'file':
 376             return self.rmfile(datacr)
 377         raise OSError(1, 'Operation is not permitted.')
 378
 379     def rmfile(self, datacr):
 380         """Remove the specified file."""
 381         assert datacr[1]
 382         cr = datacr[0]
 383         datacr[1].rm(cr)
 384         cr.commit()
 385
 386     def rename(self, src, datacr):
 387         """ Renaming operation, the effect depends on the src:
 388             * A file: read, create and remove
 389             * A directory: change the parent and reassign children to ressource
 390         """
 391         cr = datacr[0]
 392         try:
 393             nname = _to_unicode(datacr[2])
 394             ret = src.move_to(cr, datacr[1], new_name=nname)
 395             # API shouldn't wait for us to write the object
 396             assert (ret is True) or (ret is False)
 397             cr.commit()
 398         except EnvironmentError:
 399             raise
 400         except Exception:
 401             self._log.exception('Cannot rename "%s" to "%s" at "%s".', src, datacr[2], datacr[1])
 402             raise OSError(1,'Operation is not permitted.')
 403
 404     def stat(self, node):
 405         raise NotImplementedError()
 406
 407     # --- Wrapper methods around os.path.*
 408
 409     # Ok
 410     def isfile(self, node):
 411         if node and (node.type in ('file','content')):
 412             return True
 413         return False
 414
 415     # Ok
 416     def islink(self, path):
 417         """Return True if path is a symbolic link."""
 418         return False
 419
 420     def isdir(self, node):
 421         """Return True if path is a directory."""
 422         if node is None:
 423             return True
 424         if node and (node.type in ('collection','database')):
 425             return True
 426         return False
 427
 428     def getsize(self, datacr):
 429         """Return the size of the specified file in bytes."""
 430         if not (datacr and datacr[1]):
 431             raise IOError(errno.ENOENT, "No such file or directory.")
 432         if datacr[1].type in ('file', 'content'):
 433             return datacr[1].get_data_len(datacr[0]) or 0L
 434         return 0L
 435
 436     # Ok
 437     def getmtime(self, datacr):
 438         """Return the last modified time as a number of seconds since
 439         the epoch."""
 440
 441         node = datacr[1]
 442         if node.write_date or node.create_date:
 443             dt = (node.write_date or node.create_date)[:19]
 444             result = time.mktime(time.strptime(dt, '%Y-%m-%d %H:%M:%S'))
 445         else:
 446             result = time.mktime(time.localtime())
 447         return result
 448
 449     # Ok
 450     def realpath(self, path):
 451         """Return the canonical version of path eliminating any
 452         symbolic links encountered in the path (if they are
 453         supported by the operating system).
 454         """
 455         return path
 456
 457     # Ok
 458     def lexists(self, path):
 459         """Return True if path refers to an existing path, including
 460         a broken or circular symbolic link.
 461         """
 462         raise DeprecationWarning()
 463         return path and True or False
 464
 465     exists = lexists
 466
 467     # Ok, can be improved
 468     def glob1(self, dirname, pattern):
 469         """Return a list of files matching a dirname pattern
 470         non-recursively.
 471
 472         Unlike glob.glob1 raises exception if os.listdir() fails.
 473         """
 474         names = self.listdir(dirname)
 475         if pattern[0] != '.':
 476             names = filter(lambda x: x.path[0] != '.', names)
 477         return fnmatch.filter(names, pattern)
 478
 479     # --- Listing utilities
 480
 481     # note: the following operations are no more blocking
 482
 483     def get_list_dir(self, datacr):
 484         """"Return an iterator object that yields a directory listing
 485         in a form suitable for LIST command.
 486         """
 487         if not datacr:
 488             return None
 489         elif self.isdir(datacr[1]):
 490             listing = self.listdir(datacr)
 491             return self.format_list(datacr[0], datacr[1], listing)
 492         # if path is a file or a symlink we return information about it
 493         elif self.isfile(datacr[1]):
 494             par = datacr[1].parent
 495             return self.format_list(datacr[0], par, [datacr[1]])
 496
 497     def get_stat_dir(self, rawline, datacr):
 498         """Return an iterator object that yields a list of files
 499         matching a dirname pattern non-recursively in a form
 500         suitable for STAT command.
 501
 502          - (str) rawline: the raw string passed by client as command
 503          argument.
 504         """
 505         ftppath = self.ftpnorm(rawline)
 506         if not glob.has_magic(ftppath):
 507             return self.get_list_dir(self.ftp2fs(rawline, datacr))
 508         else:
 509             basedir, basename = os.path.split(ftppath)
 510             if glob.has_magic(basedir):
 511                 return iter(['Directory recursion not supported.\r\n'])
 512             else:
 513                 basedir = self.ftp2fs(basedir, datacr)
 514                 listing = self.glob1(basedir, basename)
 515                 if listing:
 516                     listing.sort()
 517                 return self.format_list(basedir, listing)
 518
 519     def format_list(self, cr, parent_node, listing, ignore_err=True):
 520         """Return an iterator object that yields the entries of given
 521         directory emulating the "/bin/ls -lA" UNIX command output.
 522
 523          - (str) basedir: the parent directory node. Can be None
 524          - (list) listing: a list of nodes
 525          - (bool) ignore_err: when False raise exception if os.lstat()
 526          call fails.
 527
 528         On platforms which do not support the pwd and grp modules (such
 529         as Windows), ownership is printed as "owner" and "group" as a
 530         default, and number of hard links is always "1". On UNIX
 531         systems, the actual owner, group, and number of links are
 532         printed.
 533
 534         This is how output appears to client:
 535
 536         -rw-rw-rw-   1 owner   group    7045120 Sep 02  3:47 music.mp3
 537         drwxrwxrwx   1 owner   group          0 Aug 31 18:50 e-books
 538         -rw-rw-rw-   1 owner   group        380 Sep 02  3:40 module.py
 539         """
 540         for node in listing:
 541             perms = filemode(node.unixperms)  # permissions
 542             nlinks = 1
 543             size = node.content_length or 0L
 544             uname = _to_decode(node.uuser)
 545             gname = _to_decode(node.ugroup)
 546             # stat.st_mtime could fail (-1) if last mtime is too old
 547             # in which case we return the local time as last mtime
 548             try:
 549                 st_mtime = node.write_date or 0.0
 550                 if isinstance(st_mtime, basestring):
 551                     st_mtime = time.strptime(st_mtime, '%Y-%m-%d %H:%M:%S')
 552                 elif isinstance(st_mtime, float):
 553                     st_mtime = time.localtime(st_mtime)
 554                 mname=_get_month_name(time.strftime("%m", st_mtime ))
 555                 mtime = mname+' '+time.strftime("%d %H:%M", st_mtime)
 556             except ValueError:
 557                 mname=_get_month_name(time.strftime("%m"))
 558                 mtime = mname+' '+time.strftime("%d %H:%M")
 559             fpath = node.path
 560             if isinstance(fpath, (list, tuple)):
 561                 fpath = fpath[-1]
 562             # formatting is matched with proftpd ls output
 563             path=_to_decode(fpath)
 564             yield "%s %3s %-8s %-8s %8s %s %s\r\n" %(perms, nlinks, uname, gname,
 565                                                      size, mtime, path)
 566
 567     # Ok
 568     def format_mlsx(self, cr, basedir, listing, perms, facts, ignore_err=True):
 569         """Return an iterator object that yields the entries of a given
 570         directory or of a single file in a form suitable with MLSD and
 571         MLST commands.
 572
 573         Every entry includes a list of "facts" referring the listed
 574         element.  See RFC-3659, chapter 7, to see what every single
 575         fact stands for.
 576
 577          - (str) basedir: the absolute dirname.
 578          - (list) listing: the names of the entries in basedir
 579          - (str) perms: the string referencing the user permissions.
 580          - (str) facts: the list of "facts" to be returned.
 581          - (bool) ignore_err: when False raise exception if os.stat()
 582          call fails.
 583
 584         Note that "facts" returned may change depending on the platform
 585         and on what user specified by using the OPTS command.
 586
 587         This is how output could appear to the client issuing
 588         a MLSD request:
 589
 590         type=file;size=156;perm=r;modify=20071029155301;unique=801cd2; music.mp3
 591         type=dir;size=0;perm=el;modify=20071127230206;unique=801e33; ebooks
 592         type=file;size=211;perm=r;modify=20071103093626;unique=801e32; module.py
 593         """
 594         permdir = ''.join([x for x in perms if x not in 'arw'])
 595         permfile = ''.join([x for x in perms if x not in 'celmp'])
 596         if ('w' in perms) or ('a' in perms) or ('f' in perms):
 597             permdir += 'c'
 598         if 'd' in perms:
 599             permdir += 'p'
 600         type = size = perm = modify = create = unique = mode = uid = gid = ""
 601         for node in listing:
 602             # type + perm
 603             if self.isdir(node):
 604                 if 'type' in facts:
 605                     type = 'type=dir;'
 606                 if 'perm' in facts:
 607                     perm = 'perm=%s;' %permdir
 608             else:
 609                 if 'type' in facts:
 610                     type = 'type=file;'
 611                 if 'perm' in facts:
 612                     perm = 'perm=%s;' %permfile
 613             if 'size' in facts:
 614                 size = 'size=%s;' % (node.content_length or 0L)
 615             # last modification time
 616             if 'modify' in facts:
 617                 try:
 618                     st_mtime = node.write_date or 0.0
 619                     if isinstance(st_mtime, basestring):
 620                         st_mtime = time.strptime(st_mtime, '%Y-%m-%d %H:%M:%S')
 621                     elif isinstance(st_mtime, float):
 622                         st_mtime = time.localtime(st_mtime)
 623                     modify = 'modify=%s;' %time.strftime("%Y%m%d%H%M%S", st_mtime)
 624                 except ValueError:
 625                     # stat.st_mtime could fail (-1) if last mtime is too old
 626                     modify = ""
 627             if 'create' in facts:
 628                 # on Windows we can provide also the creation time
 629                 try:
 630                     st_ctime = node.create_date or 0.0
 631                     if isinstance(st_ctime, basestring):
 632                         st_ctime = time.strptime(st_ctime, '%Y-%m-%d %H:%M:%S')
 633                     elif isinstance(st_mtime, float):
 634                         st_ctime = time.localtime(st_ctime)
 635                     create = 'create=%s;' %time.strftime("%Y%m%d%H%M%S",st_ctime)
 636                 except ValueError:
 637                     create = ""
 638             # UNIX only
 639             if 'unix.mode' in facts:
 640                 mode = 'unix.mode=%s;' %oct(node.unixperms & 0777)
 641             if 'unix.uid' in facts:
 642                 uid = 'unix.uid=%s;' % _to_decode(node.uuser)
 643             if 'unix.gid' in facts:
 644                 gid = 'unix.gid=%s;' % _to_decode(node.ugroup)
 645             # We provide unique fact (see RFC-3659, chapter 7.5.2) on
 646             # posix platforms only; we get it by mixing st_dev and
 647             # st_ino values which should be enough for granting an
 648             # uniqueness for the file listed.
 649             # The same approach is used by pure-ftpd.
 650             # Implementors who want to provide unique fact on other
 651             # platforms should use some platform-specific method (e.g.
 652             # on Windows NTFS filesystems MTF records could be used).
 653             # if 'unique' in facts: todo
 654             #    unique = "unique=%x%x;" %(st.st_dev, st.st_ino)
 655             path = node.path
 656             if isinstance (path, (list, tuple)):
 657                 path = path[-1]
 658             path=_to_decode(path)
 659             yield "%s%s%s%s%s%s%s%s%s %s\r\n" %(type, size, perm, modify, create,
 660                                                 mode, uid, gid, unique, path)
 661
 662 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
 663