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