666 lines
24 KiB
Python
666 lines
24 KiB
Python
# -*- encoding: utf-8 -*-
|
|
|
|
import os
|
|
import time
|
|
from tarfile import filemode
|
|
import logging
|
|
import errno
|
|
|
|
import glob
|
|
import fnmatch
|
|
|
|
import openerp
|
|
from openerp import sql_db
|
|
import openerp.service
|
|
from openerp.service import security
|
|
from openerp.osv import osv
|
|
|
|
from openerp.addons.document.document import get_node_context
|
|
|
|
def _get_month_name(month):
|
|
month=int(month)
|
|
if month==1:return 'Jan'
|
|
elif month==2:return 'Feb'
|
|
elif month==3:return 'Mar'
|
|
elif month==4:return 'Apr'
|
|
elif month==5:return 'May'
|
|
elif month==6:return 'Jun'
|
|
elif month==7:return 'Jul'
|
|
elif month==8:return 'Aug'
|
|
elif month==9:return 'Sep'
|
|
elif month==10:return 'Oct'
|
|
elif month==11:return 'Nov'
|
|
elif month==12:return 'Dec'
|
|
|
|
from ftpserver import _to_decode, _to_unicode
|
|
|
|
|
|
class abstracted_fs(object):
|
|
"""A class used to interact with the file system, providing a high
|
|
level, cross-platform interface compatible with both Windows and
|
|
UNIX style filesystems.
|
|
|
|
It provides some utility methods and some wraps around operations
|
|
involved in file creation and file system operations like moving
|
|
files or removing directories.
|
|
|
|
Instance attributes:
|
|
- (str) root: the user home directory.
|
|
- (str) cwd: the current working directory.
|
|
- (str) rnfr: source file to be renamed.
|
|
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.root = None
|
|
self.cwd = '/'
|
|
self.cwd_node = None
|
|
self.rnfr = None
|
|
self._log = logging.getLogger(__name__)
|
|
|
|
# Ok
|
|
def db_list(self):
|
|
"""Get the list of available databases, with FTPd support
|
|
"""
|
|
s = openerp.service.db
|
|
result = s.exp_list(document=True)
|
|
self.db_name_list = []
|
|
for db_name in result:
|
|
db, cr = None, None
|
|
try:
|
|
try:
|
|
db = sql_db.db_connect(db_name)
|
|
cr = db.cursor()
|
|
cr.execute("SELECT 1 FROM pg_class WHERE relkind = 'r' AND relname = 'ir_module_module'")
|
|
if not cr.fetchone():
|
|
continue
|
|
|
|
cr.execute("SELECT id FROM ir_module_module WHERE name = 'document_ftp' AND state IN ('installed', 'to install', 'to upgrade') ")
|
|
res = cr.fetchone()
|
|
if res and len(res):
|
|
self.db_name_list.append(db_name)
|
|
cr.commit()
|
|
except Exception:
|
|
self._log.warning('Cannot use db "%s".', db_name)
|
|
finally:
|
|
if cr is not None:
|
|
cr.close()
|
|
return self.db_name_list
|
|
|
|
def ftpnorm(self, ftppath):
|
|
"""Normalize a "virtual" ftp pathname (tipically the raw string
|
|
coming from client).
|
|
|
|
Pathname returned is relative!.
|
|
"""
|
|
p = os.path.normpath(ftppath)
|
|
# normalize string in a standard web-path notation having '/'
|
|
# as separator. xrg: is that really in the spec?
|
|
p = p.replace("\\", "/")
|
|
# os.path.normpath supports UNC paths (e.g. "//a/b/c") but we
|
|
# don't need them. In case we get an UNC path we collapse
|
|
# redundant separators appearing at the beginning of the string
|
|
while p[:2] == '//':
|
|
p = p[1:]
|
|
if p == '.':
|
|
return ''
|
|
return p
|
|
|
|
def get_cwd(self):
|
|
""" return the cwd, decoded in utf"""
|
|
return _to_decode(self.cwd)
|
|
|
|
def ftp2fs(self, path_orig, data):
|
|
raise DeprecationWarning()
|
|
|
|
def fs2ftp(self, node):
|
|
""" Return the string path of a node, in ftp form
|
|
"""
|
|
res='/'
|
|
if node:
|
|
paths = node.full_path()
|
|
res = '/' + node.context.dbname + '/' + \
|
|
_to_decode(os.path.join(*paths))
|
|
|
|
return res
|
|
|
|
def validpath(self, path):
|
|
"""Check whether the path belongs to user's home directory.
|
|
Expected argument is a datacr tuple
|
|
"""
|
|
# TODO: are we called for "/" ?
|
|
return isinstance(path, tuple) and path[1] and True or False
|
|
|
|
# --- Wrapper methods around open() and tempfile.mkstemp
|
|
|
|
def create(self, datacr, objname, mode):
|
|
""" Create a children file-node under node, open it
|
|
@return open node_descriptor of the created node
|
|
"""
|
|
objname = _to_unicode(objname)
|
|
cr , node, rem = datacr
|
|
try:
|
|
child = node.child(cr, objname)
|
|
if child:
|
|
if child.type not in ('file','content'):
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
|
|
ret = child.open_data(cr, mode)
|
|
cr.commit()
|
|
assert ret, "Cannot create descriptor for %r: %r." % (child, ret)
|
|
return ret
|
|
except EnvironmentError:
|
|
raise
|
|
except Exception:
|
|
self._log.exception('Cannot locate item %s at node %s.', objname, repr(node))
|
|
pass
|
|
|
|
try:
|
|
child = node.create_child(cr, objname, data=None)
|
|
ret = child.open_data(cr, mode)
|
|
assert ret, "Cannot create descriptor for %r." % child
|
|
cr.commit()
|
|
return ret
|
|
except EnvironmentError:
|
|
raise
|
|
except Exception:
|
|
self._log.exception('Cannot create item %s at node %s.', objname, repr(node))
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
|
|
def open(self, datacr, mode):
|
|
if not (datacr and datacr[1]):
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
# Reading operation
|
|
cr, node, rem = datacr
|
|
try:
|
|
res = node.open_data(cr, mode)
|
|
cr.commit()
|
|
except TypeError:
|
|
raise IOError(errno.EINVAL, "No data.")
|
|
return res
|
|
|
|
# ok, but need test more
|
|
|
|
def mkstemp(self, suffix='', prefix='', dir=None, mode='wb'):
|
|
"""A wrap around tempfile.mkstemp creating a file with a unique
|
|
name. Unlike mkstemp it returns an object with a file-like
|
|
interface.
|
|
"""
|
|
raise NotImplementedError # TODO
|
|
|
|
text = not 'b' in mode
|
|
# for unique file , maintain version if duplicate file
|
|
if dir:
|
|
cr = dir.cr
|
|
uid = dir.uid
|
|
pool = openerp.registry(node.context.dbname)
|
|
object=dir and dir.object or False
|
|
object2=dir and dir.object2 or False
|
|
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)])
|
|
if len(res):
|
|
pre = prefix.split('.')
|
|
prefix=pre[0] + '.v'+str(len(res))+'.'+pre[1]
|
|
return self.create(dir,suffix+prefix,text)
|
|
|
|
|
|
|
|
# Ok
|
|
def chdir(self, datacr):
|
|
if (not datacr) or datacr == (None, None, None):
|
|
self.cwd = '/'
|
|
self.cwd_node = None
|
|
return None
|
|
if not datacr[1]:
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
if datacr[1].type not in ('collection','database'):
|
|
raise OSError(2, 'Path is not a directory.')
|
|
self.cwd = '/'+datacr[1].context.dbname + '/'
|
|
self.cwd += '/'.join(datacr[1].full_path())
|
|
self.cwd_node = datacr[1]
|
|
|
|
# Ok
|
|
def mkdir(self, datacr, basename):
|
|
"""Create the specified directory."""
|
|
cr, node, rem = datacr or (None, None, None)
|
|
if not node:
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
|
|
try:
|
|
basename =_to_unicode(basename)
|
|
cdir = node.create_child_collection(cr, basename)
|
|
self._log.debug("Created child dir: %r", cdir)
|
|
cr.commit()
|
|
except Exception:
|
|
self._log.exception('Cannot create dir "%s" at node %s.', basename, repr(node))
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
|
|
def close_cr(self, data):
|
|
if data and data[0]:
|
|
data[0].close()
|
|
return True
|
|
|
|
def get_cr(self, pathname):
|
|
raise DeprecationWarning()
|
|
|
|
def get_crdata(self, line, mode='file'):
|
|
""" Get database cursor, node and remainder data, for commands
|
|
|
|
This is the helper function that will prepare the arguments for
|
|
any of the subsequent commands.
|
|
It returns a tuple in the form of:
|
|
@code ( cr, node, rem_path=None )
|
|
|
|
@param line An absolute or relative ftp path, as passed to the cmd.
|
|
@param mode A word describing the mode of operation, so that this
|
|
function behaves properly in the different commands.
|
|
"""
|
|
path = self.ftpnorm(line)
|
|
if self.cwd_node is None:
|
|
if not os.path.isabs(path):
|
|
path = os.path.join(self.root, path)
|
|
|
|
if path == '/' and mode in ('list', 'cwd'):
|
|
return (None, None, None )
|
|
|
|
if path == '..': path = self.cwd + '/..'
|
|
path = _to_unicode(os.path.normpath(path)) # again, for '/db/../ss'
|
|
if path == '.': path = ''
|
|
|
|
if os.path.isabs(path) and self.cwd_node is not None \
|
|
and path.startswith(self.cwd):
|
|
# make relative, so that cwd_node is used again
|
|
path = path[len(self.cwd):]
|
|
if path.startswith('/'):
|
|
path = path[1:]
|
|
|
|
p_parts = path.split(os.sep)
|
|
|
|
assert '..' not in p_parts
|
|
|
|
rem_path = None
|
|
if mode in ('create',):
|
|
rem_path = p_parts[-1]
|
|
p_parts = p_parts[:-1]
|
|
|
|
if os.path.isabs(path):
|
|
# we have to start from root, again
|
|
while p_parts and p_parts[0] == '':
|
|
p_parts = p_parts[1:]
|
|
# self._log.debug("Path parts: %r ", p_parts)
|
|
if not p_parts:
|
|
raise IOError(errno.EPERM, 'Cannot perform operation at root directory.')
|
|
dbname = p_parts[0]
|
|
if dbname not in self.db_list():
|
|
raise IOError(errno.ENOENT,'Invalid database path: %s.' % dbname)
|
|
try:
|
|
db = openerp.registry(dbname).db
|
|
except Exception:
|
|
raise OSError(1, 'Database cannot be used.')
|
|
cr = db.cursor()
|
|
try:
|
|
uid = security.login(dbname, self.username, self.password)
|
|
except Exception:
|
|
cr.close()
|
|
raise
|
|
if not uid:
|
|
cr.close()
|
|
raise OSError(2, 'Authentification required.')
|
|
n = get_node_context(cr, uid, {})
|
|
node = n.get_uri(cr, p_parts[1:])
|
|
return (cr, node, rem_path)
|
|
else:
|
|
# we never reach here if cwd_node is not set
|
|
if p_parts and p_parts[-1] == '':
|
|
p_parts = p_parts[:-1]
|
|
cr, uid = self.get_node_cr_uid(self.cwd_node)
|
|
if p_parts:
|
|
node = self.cwd_node.get_uri(cr, p_parts)
|
|
else:
|
|
node = self.cwd_node
|
|
if node is False and mode not in ('???'):
|
|
cr.close()
|
|
raise IOError(errno.ENOENT, 'Path does not exist.')
|
|
return (cr, node, rem_path)
|
|
|
|
def get_node_cr_uid(self, node):
|
|
""" Get cr, uid, pool from a node
|
|
"""
|
|
assert node
|
|
db = openerp.registry(node.context.dbname).db
|
|
return db.cursor(), node.context.uid
|
|
|
|
def get_node_cr(self, node):
|
|
""" Get the cursor for the database of a node
|
|
|
|
The cursor is the only thing that a node will not store
|
|
persistenly, so we have to obtain a new one for each call.
|
|
"""
|
|
return self.get_node_cr_uid(node)[0]
|
|
|
|
def listdir(self, datacr):
|
|
"""List the content of a directory."""
|
|
class false_node(object):
|
|
write_date = 0.0
|
|
create_date = 0.0
|
|
unixperms = 040550
|
|
content_length = 0L
|
|
uuser = 'root'
|
|
ugroup = 'root'
|
|
type = 'database'
|
|
|
|
def __init__(self, db):
|
|
self.path = db
|
|
|
|
if datacr[1] is None:
|
|
result = []
|
|
for db in self.db_list():
|
|
try:
|
|
result.append(false_node(db))
|
|
except osv.except_osv:
|
|
pass
|
|
return result
|
|
cr, node, rem = datacr
|
|
res = node.children(cr)
|
|
return res
|
|
|
|
def rmdir(self, datacr):
|
|
"""Remove the specified directory."""
|
|
cr, node, rem = datacr
|
|
assert node
|
|
node.rmcol(cr)
|
|
cr.commit()
|
|
|
|
def remove(self, datacr):
|
|
assert datacr[1]
|
|
if datacr[1].type == 'collection':
|
|
return self.rmdir(datacr)
|
|
elif datacr[1].type == 'file':
|
|
return self.rmfile(datacr)
|
|
raise OSError(1, 'Operation is not permitted.')
|
|
|
|
def rmfile(self, datacr):
|
|
"""Remove the specified file."""
|
|
assert datacr[1]
|
|
cr = datacr[0]
|
|
datacr[1].rm(cr)
|
|
cr.commit()
|
|
|
|
def rename(self, src, datacr):
|
|
""" Renaming operation, the effect depends on the src:
|
|
* A file: read, create and remove
|
|
* A directory: change the parent and reassign children to ressource
|
|
"""
|
|
cr = datacr[0]
|
|
try:
|
|
nname = _to_unicode(datacr[2])
|
|
ret = src.move_to(cr, datacr[1], new_name=nname)
|
|
# API shouldn't wait for us to write the object
|
|
assert (ret is True) or (ret is False)
|
|
cr.commit()
|
|
except EnvironmentError:
|
|
raise
|
|
except Exception:
|
|
self._log.exception('Cannot rename "%s" to "%s" at "%s".', src, datacr[2], datacr[1])
|
|
raise OSError(1,'Operation is not permitted.')
|
|
|
|
def stat(self, node):
|
|
raise NotImplementedError()
|
|
|
|
# --- Wrapper methods around os.path.*
|
|
|
|
# Ok
|
|
def isfile(self, node):
|
|
if node and (node.type in ('file','content')):
|
|
return True
|
|
return False
|
|
|
|
# Ok
|
|
def islink(self, path):
|
|
"""Return True if path is a symbolic link."""
|
|
return False
|
|
|
|
def isdir(self, node):
|
|
"""Return True if path is a directory."""
|
|
if node is None:
|
|
return True
|
|
if node and (node.type in ('collection','database')):
|
|
return True
|
|
return False
|
|
|
|
def getsize(self, datacr):
|
|
"""Return the size of the specified file in bytes."""
|
|
if not (datacr and datacr[1]):
|
|
raise IOError(errno.ENOENT, "No such file or directory.")
|
|
if datacr[1].type in ('file', 'content'):
|
|
return datacr[1].get_data_len(datacr[0]) or 0L
|
|
return 0L
|
|
|
|
# Ok
|
|
def getmtime(self, datacr):
|
|
"""Return the last modified time as a number of seconds since
|
|
the epoch."""
|
|
|
|
node = datacr[1]
|
|
if node.write_date or node.create_date:
|
|
dt = (node.write_date or node.create_date)[:19]
|
|
result = time.mktime(time.strptime(dt, '%Y-%m-%d %H:%M:%S'))
|
|
else:
|
|
result = time.mktime(time.localtime())
|
|
return result
|
|
|
|
# Ok
|
|
def realpath(self, path):
|
|
"""Return the canonical version of path eliminating any
|
|
symbolic links encountered in the path (if they are
|
|
supported by the operating system).
|
|
"""
|
|
return path
|
|
|
|
# Ok
|
|
def lexists(self, path):
|
|
"""Return True if path refers to an existing path, including
|
|
a broken or circular symbolic link.
|
|
"""
|
|
raise DeprecationWarning()
|
|
return path and True or False
|
|
|
|
exists = lexists
|
|
|
|
# Ok, can be improved
|
|
def glob1(self, dirname, pattern):
|
|
"""Return a list of files matching a dirname pattern
|
|
non-recursively.
|
|
|
|
Unlike glob.glob1 raises exception if os.listdir() fails.
|
|
"""
|
|
names = self.listdir(dirname)
|
|
if pattern[0] != '.':
|
|
names = filter(lambda x: x.path[0] != '.', names)
|
|
return fnmatch.filter(names, pattern)
|
|
|
|
# --- Listing utilities
|
|
|
|
# note: the following operations are no more blocking
|
|
|
|
def get_list_dir(self, datacr):
|
|
""""Return an iterator object that yields a directory listing
|
|
in a form suitable for LIST command.
|
|
"""
|
|
if not datacr:
|
|
return None
|
|
elif self.isdir(datacr[1]):
|
|
listing = self.listdir(datacr)
|
|
return self.format_list(datacr[0], datacr[1], listing)
|
|
# if path is a file or a symlink we return information about it
|
|
elif self.isfile(datacr[1]):
|
|
par = datacr[1].parent
|
|
return self.format_list(datacr[0], par, [datacr[1]])
|
|
|
|
def get_stat_dir(self, rawline, datacr):
|
|
"""Return an iterator object that yields a list of files
|
|
matching a dirname pattern non-recursively in a form
|
|
suitable for STAT command.
|
|
|
|
- (str) rawline: the raw string passed by client as command
|
|
argument.
|
|
"""
|
|
ftppath = self.ftpnorm(rawline)
|
|
if not glob.has_magic(ftppath):
|
|
return self.get_list_dir(self.ftp2fs(rawline, datacr))
|
|
else:
|
|
basedir, basename = os.path.split(ftppath)
|
|
if glob.has_magic(basedir):
|
|
return iter(['Directory recursion not supported.\r\n'])
|
|
else:
|
|
basedir = self.ftp2fs(basedir, datacr)
|
|
listing = self.glob1(basedir, basename)
|
|
if listing:
|
|
listing.sort()
|
|
return self.format_list(basedir, listing)
|
|
|
|
def format_list(self, cr, parent_node, listing, ignore_err=True):
|
|
"""Return an iterator object that yields the entries of given
|
|
directory emulating the "/bin/ls -lA" UNIX command output.
|
|
|
|
- (str) basedir: the parent directory node. Can be None
|
|
- (list) listing: a list of nodes
|
|
- (bool) ignore_err: when False raise exception if os.lstat()
|
|
call fails.
|
|
|
|
On platforms which do not support the pwd and grp modules (such
|
|
as Windows), ownership is printed as "owner" and "group" as a
|
|
default, and number of hard links is always "1". On UNIX
|
|
systems, the actual owner, group, and number of links are
|
|
printed.
|
|
|
|
This is how output appears to client:
|
|
|
|
-rw-rw-rw- 1 owner group 7045120 Sep 02 3:47 music.mp3
|
|
drwxrwxrwx 1 owner group 0 Aug 31 18:50 e-books
|
|
-rw-rw-rw- 1 owner group 380 Sep 02 3:40 module.py
|
|
"""
|
|
for node in listing:
|
|
perms = filemode(node.unixperms) # permissions
|
|
nlinks = 1
|
|
size = node.content_length or 0L
|
|
uname = _to_decode(node.uuser)
|
|
gname = _to_decode(node.ugroup)
|
|
# stat.st_mtime could fail (-1) if last mtime is too old
|
|
# in which case we return the local time as last mtime
|
|
try:
|
|
st_mtime = node.write_date or 0.0
|
|
if isinstance(st_mtime, basestring):
|
|
st_mtime = time.strptime(st_mtime, '%Y-%m-%d %H:%M:%S')
|
|
elif isinstance(st_mtime, float):
|
|
st_mtime = time.localtime(st_mtime)
|
|
mname=_get_month_name(time.strftime("%m", st_mtime ))
|
|
mtime = mname+' '+time.strftime("%d %H:%M", st_mtime)
|
|
except ValueError:
|
|
mname=_get_month_name(time.strftime("%m"))
|
|
mtime = mname+' '+time.strftime("%d %H:%M")
|
|
fpath = node.path
|
|
if isinstance(fpath, (list, tuple)):
|
|
fpath = fpath[-1]
|
|
# formatting is matched with proftpd ls output
|
|
path=_to_decode(fpath)
|
|
yield "%s %3s %-8s %-8s %8s %s %s\r\n" %(perms, nlinks, uname, gname,
|
|
size, mtime, path)
|
|
|
|
# Ok
|
|
def format_mlsx(self, cr, basedir, listing, perms, facts, ignore_err=True):
|
|
"""Return an iterator object that yields the entries of a given
|
|
directory or of a single file in a form suitable with MLSD and
|
|
MLST commands.
|
|
|
|
Every entry includes a list of "facts" referring the listed
|
|
element. See RFC-3659, chapter 7, to see what every single
|
|
fact stands for.
|
|
|
|
- (str) basedir: the absolute dirname.
|
|
- (list) listing: the names of the entries in basedir
|
|
- (str) perms: the string referencing the user permissions.
|
|
- (str) facts: the list of "facts" to be returned.
|
|
- (bool) ignore_err: when False raise exception if os.stat()
|
|
call fails.
|
|
|
|
Note that "facts" returned may change depending on the platform
|
|
and on what user specified by using the OPTS command.
|
|
|
|
This is how output could appear to the client issuing
|
|
a MLSD request:
|
|
|
|
type=file;size=156;perm=r;modify=20071029155301;unique=801cd2; music.mp3
|
|
type=dir;size=0;perm=el;modify=20071127230206;unique=801e33; ebooks
|
|
type=file;size=211;perm=r;modify=20071103093626;unique=801e32; module.py
|
|
"""
|
|
permdir = ''.join([x for x in perms if x not in 'arw'])
|
|
permfile = ''.join([x for x in perms if x not in 'celmp'])
|
|
if ('w' in perms) or ('a' in perms) or ('f' in perms):
|
|
permdir += 'c'
|
|
if 'd' in perms:
|
|
permdir += 'p'
|
|
type = size = perm = modify = create = unique = mode = uid = gid = ""
|
|
for node in listing:
|
|
# type + perm
|
|
if self.isdir(node):
|
|
if 'type' in facts:
|
|
type = 'type=dir;'
|
|
if 'perm' in facts:
|
|
perm = 'perm=%s;' %permdir
|
|
else:
|
|
if 'type' in facts:
|
|
type = 'type=file;'
|
|
if 'perm' in facts:
|
|
perm = 'perm=%s;' %permfile
|
|
if 'size' in facts:
|
|
size = 'size=%s;' % (node.content_length or 0L)
|
|
# last modification time
|
|
if 'modify' in facts:
|
|
try:
|
|
st_mtime = node.write_date or 0.0
|
|
if isinstance(st_mtime, basestring):
|
|
st_mtime = time.strptime(st_mtime, '%Y-%m-%d %H:%M:%S')
|
|
elif isinstance(st_mtime, float):
|
|
st_mtime = time.localtime(st_mtime)
|
|
modify = 'modify=%s;' %time.strftime("%Y%m%d%H%M%S", st_mtime)
|
|
except ValueError:
|
|
# stat.st_mtime could fail (-1) if last mtime is too old
|
|
modify = ""
|
|
if 'create' in facts:
|
|
# on Windows we can provide also the creation time
|
|
try:
|
|
st_ctime = node.create_date or 0.0
|
|
if isinstance(st_ctime, basestring):
|
|
st_ctime = time.strptime(st_ctime, '%Y-%m-%d %H:%M:%S')
|
|
elif isinstance(st_mtime, float):
|
|
st_ctime = time.localtime(st_ctime)
|
|
create = 'create=%s;' %time.strftime("%Y%m%d%H%M%S",st_ctime)
|
|
except ValueError:
|
|
create = ""
|
|
# UNIX only
|
|
if 'unix.mode' in facts:
|
|
mode = 'unix.mode=%s;' %oct(node.unixperms & 0777)
|
|
if 'unix.uid' in facts:
|
|
uid = 'unix.uid=%s;' % _to_decode(node.uuser)
|
|
if 'unix.gid' in facts:
|
|
gid = 'unix.gid=%s;' % _to_decode(node.ugroup)
|
|
# We provide unique fact (see RFC-3659, chapter 7.5.2) on
|
|
# posix platforms only; we get it by mixing st_dev and
|
|
# st_ino values which should be enough for granting an
|
|
# uniqueness for the file listed.
|
|
# The same approach is used by pure-ftpd.
|
|
# Implementors who want to provide unique fact on other
|
|
# platforms should use some platform-specific method (e.g.
|
|
# on Windows NTFS filesystems MTF records could be used).
|
|
# if 'unique' in facts: todo
|
|
# unique = "unique=%x%x;" %(st.st_dev, st.st_ino)
|
|
path = node.path
|
|
if isinstance (path, (list, tuple)):
|
|
path = path[-1]
|
|
path=_to_decode(path)
|
|
yield "%s%s%s%s%s%s%s%s%s %s\r\n" %(type, size, perm, modify, create,
|
|
mode, uid, gid, unique, path)
|
|
|
|
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|
|
|