def getattr(self, path):
if path == "/":
st = fuse.Stat()
st.st_ino = 0
st.st_dev = 0
st.st_blksize = 4096
st.st_mode = stat.S_IFDIR | READ_ONLY_PERM
st.st_nlink = 1
st.st_uid = 0
st.st_gid = 0
st.st_rdev = None
st.st_size = len(self.lists)
st.st_blocks = 0
st.st_atime = self.timestamp
st.st_mtime = self.timestamp
st.st_ctime = self.timestamp
return st
elif path in self.lists:
L = self.lists[path]
L.reload()
st = fuse.Stat()
st.st_ino = 0
st.st_dev = 0
st.st_blksize = 4096
st.st_mode = stat.S_IFDIR | READ_ONLY_PERM
st.st_nlink = 1
st.st_uid = 0
st.st_gid = 0
st.st_rdev = None
st.st_size = len(L)
st.st_blocks = 0
if L.list_stat:
st.st_atime = L.list_stat.st_atime
st.st_mtime = L.list_stat.st_mtime
st.st_ctime = L.list_stat.st_ctime
else:
st.st_atime = 0
st.st_mtime = 0
st.st_ctime = 0
return st
else:
path = self._vpath_to_real_path(path)
stfile = os.lstat(path)
st = fuse.Stat()
st.st_ino = stfile.st_ino
st.st_dev = stfile.st_dev
st.st_blksize = stfile.st_blksize
st.st_mode = stfile.st_mode
st.st_nlink = stfile.st_nlink
st.st_uid = stfile.st_uid
st.st_gid = stfile.st_gid
st.st_rdev = stfile.st_rdev
st.st_size = stfile.st_size
st.st_blocks = stfile.st_blocks
st.st_atime = stfile.st_atime
st.st_mtime = stfile.st_mtime
st.st_ctime = stfile.st_ctime
return st
def multiple_root_list(self, generations):
repo = self.obnam.repo
mountroot = self.obnam.mountroot
rootlist = {}
used_generations = []
for gen in generations:
path = '/' + str(gen)
try:
genstat = self.get_stat(path)
start, end = repo.get_generation_times(gen)
genstat.st_ctime = genstat.st_mtime = end
rootlist[path] = genstat
used_generations.append(gen)
except obnamlib.Error:
pass
if not used_generations:
raise obnamlib.Error('No generations found for %s' % mountroot)
latest = used_generations[-1]
laststat = rootlist['/' + str(latest)]
rootstat = fuse.Stat(**laststat.__dict__)
laststat = fuse.Stat(target=str(latest), **laststat.__dict__)
laststat.st_mode &= ~(stat.S_IFDIR | stat.S_IFREG)
laststat.st_mode |= stat.S_IFLNK
rootlist['/latest'] = laststat
pidstat = fuse.Stat(**rootstat.__dict__)
pidstat.st_mode = stat.S_IFREG | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH
rootlist['/.pid'] = pidstat
return (rootstat, rootlist)
def getattr(self, path):
print("getattr({})".format(path))
if path == "/":
return fuse.Stat(st_mode=stat.S_IFDIR | 0o755, st_nlink=1)
if path == self._PATH:
return fuse.Stat(st_mode=stat.S_IFREG | 0o600,
st_size=len(self._DATA),
st_nlink=1)
return -errno.ENOENT
def init_root(self):
# we need the list of all real (non-checkpoint) generations
client_name = self.obnam.app.settings['client-name']
generations = [
gen
for gen in self.obnam.repo.get_client_generation_ids(client_name)
if not self.obnam.repo.get_generation_key(
gen, obnamlib.REPO_GENERATION_IS_CHECKPOINT)]
# self.rootlist holds the stat information for each entry at
# the root of the FUSE filesystem: /.pid, /latest, and one for
# each generation.
self.rootlist = {}
used_generations = []
for gen in generations:
genspec = self.obnam.repo.make_generation_spec(gen)
path = '/' + genspec
try:
genstat = self.get_stat_in_generation(path)
start = self.obnam.repo.get_generation_key(
gen, obnamlib.REPO_GENERATION_STARTED)
end = self.obnam.repo.get_generation_key(
gen, obnamlib.REPO_GENERATION_ENDED)
genstat.st_ctime = genstat.st_mtime = end
self.rootlist[path] = genstat
used_generations.append(gen)
except obnamlib.ObnamError as e:
logging.warning('Ignoring error %s' % str(e))
pass
assert used_generations
# self.rootstat is the stat information for the root of the
# FUSE filesystem. We set it to the same as that of the latest
# generation.
latest_gen_id = used_generations[-1]
latest_gen_spec = self.obnam.repo.make_generation_spec(latest_gen_id)
latest_gen_root_stat = self.rootlist['/' + latest_gen_spec]
self.rootstat = fuse.Stat(**latest_gen_root_stat.__dict__)
# Add an entry for /latest to self.rootlist.
symlink_stat = fuse.Stat(
target=latest_gen_spec,
**latest_gen_root_stat.__dict__)
symlink_stat.st_mode &= ~(stat.S_IFDIR | stat.S_IFREG)
symlink_stat.st_mode |= stat.S_IFLNK
self.rootlist['/latest'] = symlink_stat
# Add an entry for /.pid to self.rootlist.
pidstat = fuse.Stat(**self.rootstat.__dict__)
pidstat.st_mode = (
stat.S_IFREG | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
self.rootlist['/.pid'] = pidstat
def getattr(self, params):
path = params[0]
if path == '/.githistory':
fstat = os.lstat(self.fs.basePath)
ret = fuse.Stat()
ret.st_mode = stat.S_IFDIR | 0755
ret.st_nlink = 2
ret.st_uid = fstat.st_uid
ret.st_gid = fstat.st_gid
ret.st_atime = int(time.time())
ret.st_mtime = ret.st_atime
ret.st_ctime = ret.st_atime
return ret
subpath = path[13:]
if os.path.isdir(self.fs.basePath +
subpath) or os.path.isfile(self.fs.basePath +
subpath):
fstat = os.lstat(self.fs.basePath + subpath)
ret = fuse.Stat()
ret.st_mode = stat.S_IFDIR | 0755
ret.st_nlink = 2
ret.st_uid = fstat.st_uid
ret.st_gid = fstat.st_gid
ret.st_atime = int(time.time())
ret.st_mtime = ret.st_atime
ret.st_ctime = ret.st_atime
return ret
m = re.match(r'(.+)\/([0-9a-fA-F]{40})', subpath)
if m:
file = m.group(1)
revision = m.group(2)
fstat = os.lstat(self.fs.basePath + file)
commit = self.fs.repo.commit(revision)
ret = fuse.Stat()
ret.st_mode = stat.S_IFREG | (fstat.st_mode & 0777)
ret.st_uid = fstat.st_uid
ret.st_gid = fstat.st_gid
ret.st_nlink = 2
ret.st_atime = int(time.time())
ret.st_mtime = commit.committed_date
ret.st_ctime = commit.committed_date
self.open([path, 0])
if path in self.openFiles:
ret.st_size = len(self.openFiles[path]['data'])
self.release([path, 0])
return ret
return -errno.ENOENT
def getattr(self, path):
path = path[1:]
s = fuse.Stat()
s.st_mode = 0100644
s.st_ino = 1
s.st_dev = 0
s.st_nlink = 0
s.st_uid = 0
s.st_gid = 0
s.st_size = 0
s.st_atime = 0
s.st_mtime = 0
s.st_ctime = 0
s.st_blocks = 0
s.st_blksize = 4096
s.st_rdev = 0
## Is this a directory?
sub_dir = self.list_dir(path)
print "sub_dir of %s: %s" % (path, sub_dir)
if sub_dir:
s.st_mode = 040755
return s
urn = self.find_urn(path)
s.st_size = parse_int(oracle.resolve(urn, AFF4_SIZE))
s.st_atime = s.st_mtime = s.st_ctime = parse_int(
oracle.resolve(urn, AFF4_TIMESTAMP))
return s
def getattr(self, path):
sefs = file1()
st = fuse.Stat()
c = fuse.FuseGetContext()
ret = sefs.search(path)
print "Already present =", ret
if ret is True:
st.st_ino = int(sefs.getinode(path))
st.st_uid, st.st_gid = (c['uid'], c['gid'])
st.st_mode = sefs.getmode(path)
st.st_nlink = sefs.getlinkcount(path)
if sefs.getlength(path) is not None:
st.st_size = int(sefs.getlength(path))
else:
st.st_size = 0
tup = sefs.getutime(path)
st.st_mtime = int(tup[0].strip().split('.')[0])
st.st_ctime = int(tup[1].strip().split('.')[0])
st.st_atime = int(tup[2].strip().split('.')[0])
print "inode numder = %d" % st.st_ino
return st
else:
return -errno.ENOENT
def create(self, path, mode, flags):
sefs = file1()
ret = self.open(path, flags)
if ret == -errno.ENOENT:
ret = sefs.open(path)
print "Creating the file %s" % path
current_time = int(time.time())
new_time = (current_time, current_time, current_time)
ret = sefs.utime(path, new_time)
self.fd = len(sefs.ls())
print "In create:fd = %d" % (self.fd)
sefs.setinode(path, self.fd)
st = fuse.Stat()
if path == '/':
st.st_nlink = 2
st.st_mode = stat.S_IFDIR | 0755
if flags == 1:
st.st_nlink = 2
st.st_mode = stat.S_IFDIR | 0755
else:
st.st_mode = stat.S_IFREG | 0777
st.st_nlink = 1
sefs.set_id(path, self.gid, self.uid, st.st_mode, st.st_nlink)
else:
print "The file %s exists!!" % path
return 0
def getattr(self, path):
print "getattr", path
#initialize the stat object
st = fuse.Stat()
#if we're looking at the root
if path == '/':
st.st_mode = stat.S_IFDIR | 0755 #directory
st.st_nlink = 2 #2 links
#if we're looking at the counts per minute file
elif path[1:] == "count":
st.st_mode = stat.S_IFREG | 0644 #file
st.st_nlink = 1 #1 link
st.st_size = 4 #size of count file
#if we're looking at the random bits file
elif path[1:] == "random":
st.st_mode = stat.S_IFREG | 0644 #file
st.st_nlink = 1 #1 link
st.st_size = 1024 #size of random file
#else return an error
else:
return -errno.ENOENT #No such file or directory
return st
def getattr(self, path):
st = fuse.Stat()
st.st_ino = 0
st.st_dev = 0
st.st_blksize = 0
st.st_rdev = 0
st.st_uid = 0
st.st_gid = 0
st.st_size = 0
st.st_blocks = 0
st.st_atime = 0
st.st_mtime = 0
st.st_ctime = 0
if path == '/':
st.st_mode = stat.S_IFDIR | 0o755
st.st_nlink = 2
return st
else:
st.st_mode = stat.S_IFREG | 0o644
st.st_nlink = 1
if path == '/register':
st.st_mode = (st.st_mode & ~0o777) | 0o200
return st
elif path == '/status':
return st
else:
try:
st.st_size = len(self.create_entry(path))
return st
except ValueError:
return -errno.ENOENT
def getattr(self, path):
log_basic("getattr \"%s\"" % path)
st = fuse.Stat()
st.st_nlink = 1
st.st_mode = S_IFREG | 0666
if self.virt_pages.has_key(path):
st.st_size = len(self.virt_pages[path])
return st
if self.pages.has_key(path):
st.st_size = self.pages[path]['size']
return st
info = self.wikiproxy.getPageInfo(path)
if info.has_key('faultCode'):
log_error("getPageInfo(%s) failed" % path + repr(info))
return -ENOENT
page = self.wikiproxy.getPage(path).encode('utf-8')
st.st_size = len(page)
return st
def getattr(self, path):
#full_path = self._full_path(path)
#st = os.lstat(full_path)
#return dict((key, getattr(st, key)) for key in ('st_atime', 'st_ctime',
# 'st_gid', 'st_mode', 'st_mtime', 'st_nlink', 'st_size', 'st_uid'))
path = self._full_path(path)
if not os.path.exists(path):
return -errno.ENOENT
out = fuse.Stat()
out.st_uid = os.getuid()
out.st_gid = os.getgid()
out.st_ino = 0
out.st_dev = 0
out.st_atime = 0
out.st_mtime = 0
out.st_ctime = 0
if os.path.isdir(path):
out.st_mode = stat.S_IFDIR | 0o600
out.st_nlink = 2
for entry in os.listdir(path):
if os.path.isdir(entry):
out.st_nlink += 1
else:
out.st_mode = stat.S_IFREG | 0o700
out.st_nlink = 1
out.st_size = os.path.getsize(path)
return out
def getattr(self, path):
path = argv_bytes(path)
if self.verbose > 0:
log('--getattr(%r)\n' % path)
res = vfs.resolve(self.repo,
path,
want_meta=(not self.fake_metadata),
follow=False)
name, item = res[-1]
if not item:
return -errno.ENOENT
if self.fake_metadata:
item = vfs.augment_item_meta(self.repo, item, include_size=True)
else:
item = vfs.ensure_item_has_metadata(self.repo,
item,
include_size=True)
meta = item.meta
# FIXME: do we want/need to do anything more with nlink?
st = fuse.Stat(st_mode=meta.mode, st_nlink=1, st_size=meta.size)
st.st_mode = meta.mode
st.st_uid = meta.uid or 0
st.st_gid = meta.gid or 0
st.st_atime = max(0, xstat.fstime_floor_secs(meta.atime))
st.st_mtime = max(0, xstat.fstime_floor_secs(meta.mtime))
st.st_ctime = max(0, xstat.fstime_floor_secs(meta.ctime))
return st
def getattr(self, path):
"""
- st_mode (protection bits)
- st_ino (inode number)
- st_dev (device)
- st_nlink (number of hard links)
- st_uid (user ID of owner)
- st_gid (group ID of owner)
- st_size (size of file, in bytes)
- st_atime (time of most recent access)
- st_mtime (time of most recent content modification)
- st_ctime (platform dependent; time of most recent metadata change on Unix,
or the time of creation on Windows).
"""
log.info('getattr: %s' % path)
pFile = self.FS.get(path)
if not pFile: return -errno.ENOENT
st = fuse.Stat()
st.st_mode = pFile.type | pFile.mode
st.st_ino = pFile.inode
st.st_nlink = pFile.links()
st.st_uid = 1000 #pFile.uid
st.st_gid = 1000 #pFile.gid
st.st_size = pFile.size()
#st.st_atime = time()
#st.st_mtime = time()
#st.st_ctime = time()
#st.st_dev = 2050L
return st
def getattr(self, path):
# TODO: may cause problems with filenames that ends with "/"
path = path.rstrip('/')
logging.debug('"' + path + '"')
st = fuse.Stat()
if not (path in self.files):
self._getattr(path)
if not (path in self.files):
return -errno.ENOENT
file = self.files[path]
if file['type'] == self.TYPE_FILE:
st.st_mode = stat.S_IFREG | 0444
st.st_nlink = 1
st.st_size = 0
return st
elif file['type'] == self.TYPE_DIR:
st.st_mode = stat.S_IFDIR | 0755
if 'dirs' in file:
st.st_nlink = len(file['dirs'])
else:
st.st_nlink = 2
return st
# TODO: check for existens
return -errno.ENOENT
def make_stat(meta):
""" Return a stat structure from TSK metadata struct """
meta_type_dispatcher = {
pytsk3.TSK_FS_META_TYPE_DIR: stat.S_IFDIR,
pytsk3.TSK_FS_META_TYPE_REG: stat.S_IFREG,
pytsk3.TSK_FS_META_TYPE_FIFO: stat.S_IFIFO,
pytsk3.TSK_FS_META_TYPE_CHR: stat.S_IFCHR,
pytsk3.TSK_FS_META_TYPE_LNK: stat.S_IFLNK,
pytsk3.TSK_FS_META_TYPE_BLK: stat.S_IFBLK,
}
s = fuse.Stat()
s.st_ino = meta.addr
s.st_dev = 0
s.st_nlink = meta.nlink
s.st_uid = meta.uid
s.st_gid = meta.gid
s.st_size = meta.size
s.st_atime = meta.atime
s.st_mtime = meta.mtime
s.st_ctime = meta.crtime
s.st_blocks = 2
s.st_rdev = 0
s.st_mode = meta_type_dispatcher.get(int(meta.type), 0)
s.st_mode |= int(meta.mode)
return s
def getattr(self, path):
print '> getattr', path
st = fuse.Stat()
st.st_mode = stat.S_IFDIR | 0700
st.st_uid = os.getuid()
st.st_gid = os.getgid()
st.st_nlink = 2
st.st_atime = int(time.time())
st.st_mtime = st.st_atime
st.st_ctime = st.st_atime
pe = path.split('/')[1:]
if path == '/':
pass
elif pe[-1] in self.gmail.keys():
pass
elif len(pe) > 1 and self.getmail(pe[0], pe[1]) != None:
m = self.getmail(pe[0], pe[1])
st.st_mode = stat.S_IFREG | 0600
st.st_nlink = 1
st.st_size = len(self.format_mail_body(m))
#st.st_mtime = int(time.mktime(time.strptime(m['date'][0:-6], '%a, %d %b %Y %H:%M:%S')))
else:
return -errno.ENOENT
return st
def getattr(self, path):
sefs = seFS()
st = fuse.Stat()
c = fuse.FuseGetContext()
print c
print "getattr called path= %s", path
if path == '/':
st.st_nlink = 2
st.st_mode = stat.S_IFDIR | 0755
else:
print "For a regular file %s" % path
st.st_mode = stat.S_IFREG | 0777
st.st_nlink = 1
st.st_uid, st.st_gid = (c['uid'], c['gid'])
ret = sefs.search(path)
print "From database getattr ret=", ret
if ret is True:
tup = sefs.getutime(path)
print tup
st.st_mtime = int(tup[0].strip().split('.')[0])
st.st_ctime = int(tup[1].strip().split('.')[0])
st.st_atime = int(tup[2].strip().split('.')[0])
st.st_ino = int(sefs.getinode(path))
print "inode = %d" % st.st_ino
if sefs.getlength(path) is not None:
st.st_size = int(sefs.getlength(path))
else:
st.st_size = 0
return st
else:
return -errno.ENOENT
def getattr(self, path):
path = path[1:]
s = fuse.Stat()
s.st_mode = 0100644
s.st_ino = 1
s.st_dev = 0
s.st_nlink = 0
s.st_uid = 0
s.st_gid = 0
s.st_size = 0
s.st_atime = 0
s.st_mtime = 0
s.st_ctime = 0
s.st_blocks = 0
s.st_blksize = 4096
s.st_rdev = 0
## Is this a directory?
sub_dir = self.list_dir(path)
print "sub_dir of %s: %s" % (path, sub_dir)
if sub_dir:
s.st_mode = 040755
return s
## It must be a full object
for v in VOLUMES:
urn = fully_qualified_name(path, v)
if not oracle.resolve(urn, AFF4_TYPE): continue
s.st_size = parse_int(oracle.resolve(urn, AFF4_SIZE))
s.st_atime = s.st_mtime = s.st_ctime = parse_int(
oracle.resolve(urn, AFF4_TIMESTAMP))
break
return s
def getattr(self, path):
p = os.path.dirname(path)
from DIRAC.Resources.Catalog.FileCatalogClient import FileCatalogClient
self.result = FileCatalogClient().listDirectory(p, True)
st = fuse.Stat()
#print "+++++++++++++++++++++ "+self.SE
#print p
#print self.proxy
#print self.result['Value']['Successful'][p]
if path == '/':
st.st_mode = (stat.S_IFDIR | 0755)
st.st_ino = 0
st.st_dev = 0
st.st_nlink = 2
st.st_uid = os.getuid()
st.st_gid = os.getgid()
st.st_size = 4096
st.st_atime = time.time()
st.st_mtime = time.time()
st.st_ctime = time.time()
elif self.result["OK"] and self.result['Value']['Successful'][p][
'Files'].get(path):
md = self.result['Value']['Successful'][p]['Files'][path][
'MetaData']
st.st_mode = (stat.S_IFREG | md['Mode'])
st.st_ino = 0
st.st_dev = 0
st.st_nlink = 1
st.st_uid = os.getuid(
) if md['Owner'] == self.proxy['Value']['username'] else 65534
st.st_gid = os.getgid(
) if md['OwnerGroup'] == self.proxy['Value']['group'] else 65534
st.st_size = md['Size']
st.st_atime = time.mktime(md['ModificationDate'].timetuple())
st.st_mtime = time.mktime(md['ModificationDate'].timetuple())
st.st_ctime = time.mktime(md['CreationDate'].timetuple())
elif self.result["OK"] and (
self.result['Value']['Successful'][p]['SubDirs'].get('/' +
path)
or self.result['Value']['Successful'][p]['SubDirs'].get(path)):
#md = self.result['Value']['Successful'][p]['SubDirs']['/'+path] if p=='/' else self.result['Value']['Successful'][p]['SubDirs'][path]
# change to DIRAC version v6r12p16
md = self.result['Value']['Successful'][p]['SubDirs'][path]
st.st_mode = (stat.S_IFDIR | md['Mode'])
st.st_ino = 0
st.st_dev = 0
st.st_nlink = 2
st.st_uid = os.getuid(
) if md['Owner'] == self.proxy['Value']['username'] else 65534
st.st_gid = os.getgid(
) if md['OwnerGroup'] == self.proxy['Value']['group'] else 65534
st.st_size = 4096
st.st_atime = time.mktime(md['ModificationDate'].timetuple())
st.st_mtime = time.mktime(md['ModificationDate'].timetuple())
st.st_ctime = time.mktime(md['CreationDate'].timetuple())
else:
return -errno.ENOENT
return st
def getattr(self, path):
"""
Return attributes for the specified path :
- Search for the model as first part
- Search for an existing record as second part
- Search for an existing attachment as third part
- There cannot be more than 3 parts in the path
"""
fakeStat = fuse.Stat()
fakeStat.st_mode = stat.S_IFDIR | 0400
fakeStat.st_nlink = 0
if path == '/':
return fakeStat
paths = path.split('/')[1:]
if len(paths) > 3:
return -ENOENT
# Check for model existence
model_obj = Object(self.oerp_connection, 'ir.model')
model_ids = model_obj.search([('model', '=', paths[0])])
if not model_ids:
return -ENOENT
elif len(paths) == 1:
return fakeStat
# Check for record existence
element_obj = Object(self.oerp_connection, paths[0])
element_ids = element_obj.search([('id', '=', int(paths[1]))])
if not element_ids:
return -ENOENT
elif len(paths) == 2:
return fakeStat
# Chech for attachement existence
attachment_obj = Object(self.oerp_connection, 'ir.attachment')
attachment_ids = attachment_obj.search([
('res_model', '=', paths[0]), ('res_id', '=', int(paths[1])),
('id', '=', self.id_from_label(paths[2]))
])
if not attachment_ids:
return -ENOENT
# Common stats
fakeStat.st_mode = stat.S_IFREG | 0400
fakeStat.st_nlink = 2
# TODO : Read the file size from a dedicated field (created in a specific module)
attachment_obj = Object(self.oerp_connection, 'ir.attachment')
attachment_ids = attachment_obj.search([
('res_model', '=', paths[0]), ('res_id', '=', int(paths[1])),
('id', '=', self.id_from_label(paths[2]))
])
attachment_data = attachment_obj.read(attachment_ids, ['datas'])
fakeStat.st_size = len(base64.b64decode(attachment_data[0]['datas']))
return fakeStat
def get_fuse_stat(self):
st = fuse.Stat()
st.st_nlink = self.links
st.st_mode = self.get_type() | self.get_mode()
st.st_atime = self.atime
st.st_mtime = self.mtime
st.st_ctime = self.ctime
st.st_size = self.get_size()
return st
def getattr(self, params):
path = params[0]
ret = fuse.Stat()
ret.st_mode = stat.S_IFLNK | 0755
ret.st_nlink = 2
ret.st_atime = int(time.time())
ret.st_mtime = ret.st_atime
ret.st_ctime = ret.st_atime
return ret
def makeFileStatus(mode, nlink, size):
ret = fuse.Stat()
ret.st_mode = mode
ret.st_nlink = nlink
ret.st_size = size
ret.st_ino = ret.st_dev = 0
ret.st_uid = 0
ret.st_gid = 0
ret.st_atime = ret.st_mtime = ret.st_ctime = 0
return ret
def get_stat(self):
orig = os.lstat(self.path)
attr = fuse.Stat()
attr.st_mode = stat.S_IFDIR | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH
attr.st_nlink = 2 + len(self.content())
attr.st_mtime = orig.st_mtime
attr.st_atime = orig.st_atime
attr.st_ctime = orig.st_ctime
attr.st_uid = orig.st_uid
attr.st_gid = orig.st_gid
return attr
def __init__(self, is_file, time, uid, gid, content=None, entities=[]):
self.stat_ = fuse.Stat()
self.stat_.st_atime = self.stat_.st_mtime = self.stat_.st_ctime = time.timestamp(
)
self.stat_.st_mode = stat.S_IFREG | 0o444 if is_file else stat.S_IFDIR | 0o755
self.stat_.st_uid = uid
self.stat_.st_gid = gid
self.stat_.st_nlink = 1 if is_file else 2
self.content = content
self.entities = entities
def getattr(self, path):
upath = self.cache.get_upath(path)
info = self.cache.get_attr(upath, self.io)
if info['type'] == 'dir':
st = fuse.Stat()
st.st_mode = stat.S_IFDIR | stat.S_IRUSR | stat.S_IXUSR
st.st_nlink = 1
elif info['type'] == u'file':
st = fuse.Stat()
st.st_mode = stat.S_IFREG | stat.S_IRUSR | stat.S_IWUSR
st.st_nlink = 1
st.st_size = info['size']
st.st_mtime = info['mtime']
st.st_ctime = info['ctime']
else:
return -errno.EBADF
return st
def getattr(self, path):
folder = '/'.join((path).split('/')[:-1]) or '/'
st = fuse.Stat()
#I CAME FROM THE FUUUUUUUTURE
st.st_atime = 1528995828
st.st_mtime = 1528995828
st.st_ctime = 1528995828
st.st_mode = stat.S_IFDIR | 0755
st.st_nlink = 2
if path == '/': return st
if path.startswith('/files'):
filename = path.split('/')[-1]
path = '/'.join(path.split('/')[2:-1])
if not path:
if filename in self.files['files']:
st.st_mode = stat.S_IFREG | 0666
st.st_nlink = 1
st.st_size = 1024**2
else:
s = path.split('/')
workingFolder = self.files
for f in s:
if workingFolder['dirs'].get(f, 0) != 0:
workingFolder = workingFolder['dirs'][f]
else:
return -errno.ENOENT
if filename in workingFolder['files']:
st.st_mode = stat.S_IFREG | 0666
st.st_nlink = 1
st.st_size = 1024**2
return st
elif folder in self.structure:
if os.path.basename(path) in self.structure[folder]:
if self.structure[folder][os.path.basename(
path)]['type'] == 'f':
mode = self.structure[folder][os.path.basename(path)].get(
'mode', 0666)
st.st_mode = stat.S_IFREG | mode
st.st_nlink = 1
st.st_size = 1024**2
return st
if path in self.exists:
st.st_mode = stat.S_IFREG | 0777
st.st_nlink = 1
st.st_size = 1024**3
self.exists.remove(path)
return st
return -errno.ENOENT
def get_stat(self):
orig = os.lstat(self.path)
attr = fuse.Stat()
attr.st_mode = stat.S_IFREG | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH
attr.st_nlink = 1
attr.st_size = self.size()
timevalues = self.path.rsplit('/', 1)[1][:16].replace('.',
'-').split('-')
attr.st_mtime = time.mktime(
datetime.datetime(*[int(s) for s in timevalues]).timetuple())
attr.st_uid = orig.st_uid
attr.st_gid = orig.st_gid
return attr
def parse_stat(self, l):
l = [int(x) for x in l]
st = fuse.Stat(st_mode=l[0],
st_ino=l[1],
st_dev=l[2],
st_nlink=l[3],
st_uid=l[4],
st_gid=l[5],
st_size=l[6],
st_atime=l[7],
st_mtime=l[8],
st_ctime=l[9])
return st
