block_location = fs.path_resolver(path) metadata = fs.get_block_metadata(block_location) metadata.ATIME = int(atime) metadata.MTIME = int(mtime) metadata.save_to_block(block_location) def write(self, path: str, data: bytes, offset: int, fh): fs = Filesystem() block_of_interest = fs.path_resolver(path) size = fs.edit_file(block_of_interest, data, offset) return size if __name__ == "__main__": import argparse version = platform.python_version_tuple() if not (int(version[0]) == 3 and (int(version[1]) >= 8)): FMLog.error( f"Python 3.8.5 may be required. Features are used that might not be in your detected version, Python {platform.python_version()}." ) parser = argparse.ArgumentParser() parser.add_argument("mount") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG) fuse = FUSE(Small(), args.mount, foreground=True)
def bundle_mount(client, mountpoint, bundle_uuid, verbose=False): ''' Mount the filesystem on the mountpoint. ''' FUSE(BundleFuse(client, bundle_uuid, verbose), mountpoint, nothreads=True, foreground=True)
if item is not None: return S_ISREG(item["st_mode"]) return False def isDirectory(self, item): if item is not None: return S_ISDIR(item["st_mode"]) return False def isLink(self, item): if item is not None: return S_ISLNK(item["st_mode"]) return False def newItem(self, attrs): return self.table.new_item(attrs=attrs) if __name__ == '__main__': if len(argv) != 4: print('usage: %s <region> <dynamo table> <mount point>' % argv[0]) exit(1) logging.basicConfig(filename='/var/log/dynamo-fuse.log', filemode='w') logging.getLogger("dynamo-fuse").setLevel(logging.DEBUG) logging.getLogger("dynamo-fuse-file").setLevel(logging.DEBUG) logging.getLogger("fuse.log-mixin").setLevel(logging.INFO) logging.getLogger("dynamo-fuse-lock").setLevel(logging.DEBUG) fuse = FUSE(DynamoFS(argv[1], argv[2]), argv[3], foreground=True)
def main(configFile, mountpoint): accessKeyId, accessKeySecret, endpoint, bucketName = getConfig(configFile) bucket = oss2.Bucket(oss2.Auth(accessKeyId, accessKeySecret), endpoint, bucketName) FUSE(OSS(bucket), mountpoint, nothreads=True, foreground=False)
def main(mft_filename, mountpoint): with Mmap(mft_filename) as buf: tree = MFTTree(buf) tree.build(progress_class=ProgressBarProgress) handler = MFTFuseOperations(mountpoint, tree, buf) FUSE(handler, mountpoint, foreground=True)
def main(mountpoint, root): FUSE(gfs(root), mountpoint, nothreads=True, foreground=True)
return {"status": "ok"} elif op_name in bindfs.io_op_delay_ms: bindfs.io_op_should_fail[op_name] = True return {"status": "ok"} else: return {"status": "fail", "error": "op " + op_name + " isn't found"} @app.route('/recover', methods=['GET']) def fuse_recover(): for key in bindfs.io_op_should_fail.keys(): bindfs.io_op_should_fail[key] = False for key in bindfs.io_op_delay_ms.keys(): bindfs.io_op_delay_ms[key] = 0 return {"status": "ok"} @app.route('/status', methods=['GET']) def status(): return {"status": "ok"} fuse_thread = threading.Thread( target=lambda: FUSE(bindfs, mountpoint, nothreads=True, foreground=True)) fuse_thread.start() print("Successfully started iofaults!") app.run(host='0.0.0.0', port=port, use_reloader=False) fuse_thread.join()
uid, gid, pid = fuse_get_context() node = self.get_node(path) entry = node['file'] return self.pbo.read(entry, offset, length) def readdir(self, path, fh): base = ['.', '..']; node = self.get_node(path) if node: return base + map(lambda x: x['name'], node['files'].values()) raise RuntimeError('unexpected path: %r' % path) # Disable unused operations: access = None flush = None getxattr = None listxattr = None open = None opendir = None release = None releasedir = None statfs = None if __name__ == '__main__': if len(argv) != 3: print('usage: %s <file> <mountpoint>' % argv[0]) exit(1) fuse = FUSE(PBOFuse(argv[1]), argv[2], foreground=True, ro=True)
self.col_fam.insert(path, {str(nbBlock): tmp + data[:rest]}) i = 0 while (i < nbNewBlocks): self.col_fam.insert( path, { str(i + nbBlock + 1): data[(rest + i * sizeBlock):(rest + (i + 1) * sizeBlock)] }) i = i + 1 if (lenData > rest + nbNewBlocks * sizeBlock): self.col_fam.insert( path, { str(nbNewBlocks + nbBlock + 1): data[(rest + nbNewBlocks * sizeBlock):] }) #cassandra #self.col_fam.insert(path, {"content": self.data[path]}) self.col_fam.insert("files", {"metadata": json.dumps(self.files)}) return len(data) if __name__ == '__main__': if len(argv) != 2: print('usage: %s <mountpoint>' % argv[0]) exit(1) logging.basicConfig(level=logging.DEBUG) fuse = FUSE(Cassandra(), argv[1], foreground=True)
def main(mountpoint, root1, root2): FUSE(A2Fuse2(root1, root2), mountpoint, nothreads=True, foreground=True)
if sync: return os.fsync(fh) def release(self, path, fh): self.log("release", path) # self.flush(path,fh,sync=False) # self.buffers_active[path].flush() o = j.md.getentry(path) o.stat.st_size = os.stat(self._full_path(path)).st_size j.md.setentry(path, o) return os.close(fh) def fsync(self, path, fdatasync, fh): self.log("fsync", path) return self.flush(path, fh) # def main(mountpoint, backend,root): # FUSE(Passthrough(root,backend), mountpoint, foreground=True) if __name__ == '__main__': # main(sys.argv[2], sys.argv[1]) user = sys.argv[1] fusepath = "/opt/fuse/%s" % user j.system.fs.removeDirTree(fusepath) j.system.fs.createDir(fusepath) j.md = MD(user=user, reset=True) j.vfs = VFS(backend="/opt/backend/") FUSE(VFSFUSE(), fusepath, foreground=True)
def release(self, path, fh): self.flush(path, fh) return 0 def fsync(self, path, fdatasync, fh): return self.flush(path, fh) import nacl.secret user = "******" password = "******" keyname = "key1" create_key(".", user, password, keyname) key = Key("key_%s_%s" % (user, keyname)) enc = Encryption(key.key(password)) def read_callback(cryptext): return enc.decrypt(cryptext) def write_callback(plaintext): return enc.encrypt(plaintext) fs = LiverpoolFS("image", read_callback, write_callback) FUSE(fs, "mount", nothreads=True, foreground=True, **{'allow_other': True})
def main(mountpoint): FUSE(InMemoryFS(), mountpoint, nothreads=True, foreground=True)
'f_favail', 'f_ffree', 'f_files', 'f_flag', 'f_frsize', 'f_namemax')) def unlink(self, path): return os.unlink(self._full_path(path)) def symlink(self, name, target): return os.symlink(target, self._full_path(name)) def rename(self, old, new): return os.rename(self._full_path(old), self._full_path(new)) def link(self, target, name): return os.link(self._full_path(name), self._full_path(target)) def utimens(self, path, times=None): return os.utime(self._full_path(path), times) if __name__ == '__main__': with open('tests/resources/gold/key', 'rb') as key_file, open('tests/resources/gold/iv', 'rb') as iv_file: key = key_file.read() iv = iv_file.read() FUSE(EncFileHandler( key, iv, '/Users/vaddipar/Desktop/tests/resources/generated/unenc_mount'), '/Users/vaddipar/Desktop/tests/resources/generated/enc_mount', nothreads=True, foreground=True)
bytes = str if __name__ == '__main__': if len(argv) != 2: print('usage: %s <mountpoint>' % argv[0]) exit(1) logging.basicConfig(level=logging.DEBUG) def loader(path, tree): logging.debug('load: %s', path) if '/' == path: tree.setDir('/', loaded=True) tree.setDir('/jobs_queue') tree.setFile('/features') tree.setFile('/status') else: resp = requests.get("http://korchasa.host/api/v1" + path.rstrip('/')) tree.setFile(path + '/request', var_dump.var_export(resp.request).encode('utf8')) tree.setDir(path, loaded=True) data = resp.json().get('data', []) for i, value in data.items() if isinstance( data, dict) else enumerate(data): content = json.dumps(value, ensure_ascii=False, indent=2).encode('utf8') tree.setFile(path + '/' + str(i).replace('/', '_'), content) fuse = FUSE(ApiFs(loader), argv[1], foreground=True)
appLog('error', 'Unknown error.', traceback.format_exc()) exit(-1) # Save valid access token to configuration file. if args.access_token_temp == False: try: scriptpath = os.path.dirname(os.path.abspath(__file__)) f = open(scriptpath + '/ff4d.config', 'w') f.write(access_token) f.close() os.chmod(scriptpath + '/ff4d.config', 0600) if debug == True: appLog('debug', 'Wrote accesstoken to configuration file.\n') except Exception, e: appLog('error', 'Could not write configuration file.', traceback.format_exc()) # Everything went fine and we're authed against the Dropbox api. print "Welcome " + account_info.name.display_name print "Space used: " + str(space_usage.used/1024/1024/1024) + " GB" print "Space available: " + str(space_usage_allocated(space_usage)/1024/1024/1024) + " GB" print print "Starting FUSE..." try: FUSE(Dropbox(dbx), mountpoint, foreground=args.background, debug=debug_fuse, sync_read=True, allow_other=allow_other, allow_root=allow_root) except Exception, e: appLog('error', 'Failed to start FUSE...', traceback.format_exc()) sys.exit(-1)
def run(self): fuse = FUSE(self.__fs, self.__mnt, foreground=True, allow_other=True)
def main(mountpoint, root): # mountpoint 挂载点 root表示fuse filesystem的初始状态. global GBFS_graph GBFS_graph = py2neo.Graph("http://localhost:7474/db", username="******", password="******") FUSE(Passthrough(root), mountpoint, foreground=True, debug=True)
def main(mountpoint, root): FUSE(Passthrough(root), mountpoint, nothreads=True, foreground=True)
d = d[:length] p = self.traverse(path) p['st_size'] = length def unlink(self, path): p, tar = self.traverseparent(path) p['files'].pop(tar) def utimens(self, path, times=None): now = time() atime, mtime = times if times else (now, now) p = self.traverse(path) p['st_atime'] = atime p['st_mtime'] = mtime def write(self, path, data, offset, fh): p = self.traverse(path) d, d1 = self.traverseparent(path, True) d[d1] = d[d1][:offset] + data p['st_size'] = len(d[d1]) return len(data) if __name__ == '__main__': if len(argv) != 2: print('usage: %s <mountpoint>' % argv[0]) exit(1) logging.getLogger().setLevel(logging.DEBUG) fuse = FUSE(Memory(), argv[1], foreground=True)
def main(): parser = ArgumentParser( description= "YTFS - YouTube Filesystem: search and play materials from YouTube using filesystem operations.", epilog= "Streaming may not work if your player will read whole file into its buffer.", prog="ytfs", formatter_class=lambda prog: HelpFormatter(prog, max_help_position=50)) parser.add_argument('MOUNTPOINT', type=str, nargs=1, help="Mountpoint") avgrp = parser.add_mutually_exclusive_group() avgrp.add_argument('-a', action='store_true', default=False, help="Download only audio") avgrp.add_argument('-v', action='store_true', default=False, help="Download only video") parser.add_argument( '-f', default=False, help= "Preferred video format as video height (e.g. 720). Ignored if -a specified.", metavar="FORMAT") parser.add_argument('-r', action='store_true', default=False, help="RickRoll flag") s_grp = parser.add_mutually_exclusive_group() s_grp.add_argument( '-P', action='store_true', default=False, help= "Always download whole data before reading. Useful for obtaining heighest video quality." ) parser.add_argument('-d', action='store_true', default=False, help="debug: run in foreground") parser.add_argument( '-m', default="", help= "Metadata to fetch. Values: `desc` for descriptions, `thumb` for thumbnails. Use comma (,) for separating multiple values.", metavar="META1[,META2[,...]]") avgrp.add_argument( '-o', choices=['date', 'rating', 'relevance', 'title', 'viewCount'], default='relevance', help= 'Specify the method that will be used to order resources. Values: `date`, `rating`, `relevance`, `title` and `viewCount`. Default is relevance.' ) parser.add_argument( '--allow-other', action='store_true', default=False, help= "Allow other users to access the filesystem. For this to work, you'll need to set 'user_allow_other' in /etc/fuse.conf. You will need this setting if you want to share YTFS over network (SMB, NFS, etc)." ) parser.add_argument( '--youtube-api-key', type=str, help= "Specify the YouTube Data API v3 key to use. By default a library key will be used." ) x = parser.parse_args() if x.a: YTStor.preferences['audio'] = True YTStor.preferences['video'] = False elif x.v: YTStor.preferences['video'] = True YTStor.preferences['audio'] = False if x.r: YTStor.rickastley = True if x.f: YTStor.preferences['format'] = x.f if x.P: YTStor.preferences['stream'] = False if x.m: for m in x.m.split(','): YTActions.preferences['metadata'][m] = True if x.youtube_api_key: YTActions.preferences['api_key'] = x.youtube_api_key elif "YTFS_YOUTUBE_API_KEY" in os.environ: YTActions.preferences['api_key'] = os.environ["YTFS_YOUTUBE_API_KEY"] YTActions.preferences['order'] = x.o print( "Mounting YTFS ver. " + __version__ + ".\nIf you encounter any bugs, please open an issue on GitHub: https://github.com/rasguanabana/ytfs" ) FUSE(YTFS(), x.MOUNTPOINT[0], foreground=x.d, allow_other=x.allow_other)
#remove from the dictionary del self.memory[path] #skip ''' @logged def fsync(self, path, fdatasync, fh): """Flush any dirty information to disk. Flush any dirty information about the file to disk. If isdatasync is nonzero, only data, not metadata, needs to be flushed. When this call returns, all file data should be on stable storage. Many filesystems leave this call unimplemented, although technically that's a Bad Thing since it risks losing data. If you store your filesystem inside a plain file on another filesystem, you can implement this by calling fsync(2) on that file, which will flush too much data (slowing performance) but achieve the desired guarantee. """ return self.flush(path, fh) ''' if __name__ == '__main__': from sys import argv if len(argv) != 3: print('usage: %s <encrypted folder> <mountpoint>' % argv[0]) exit(1) logging.basicConfig(level=logging.DEBUG) #create our virtual filesystem using argv[1] as the physical filesystem #and argv[2] as the virtual filesystem fuse = FUSE(EncFS(argv[1]), argv[2], foreground=True)
def main(mountpoint): FUSE(VersionFS(), mountpoint, nothreads=True, foreground=True)
def truncate(self, path, length, fh=None): print("truncate") full_path = self._full_path(path) with open(full_path, 'r+') as f: f.truncate(length) def flush(self, path, fh): print("flush") return os.fsync(fh) def release(self, path, fh): print("release") return os.close(fh) def fsync(self, path, fdatasync, fh): print("fsync") return self.flush(path, fh) if __name__ == '__main__': os.system('clear') if not os.path.isdir(g_root): os.mkdir(g_root) if not os.path.isdir(g_mount): os.mkdir(g_mount) FUSE(Passthrough(g_root), g_mount, nothreads=True, foreground=False)
def main(): log.setLevel(logging.WARNING) logging.getLogger('gmusicapi').setLevel(logging.WARNING) logging.getLogger('fuse').setLevel(logging.WARNING) logging.getLogger('requests.packages.urllib3').setLevel(logging.WARNING) parser = argparse.ArgumentParser(description='GMusicFS', add_help=False) parser.add_argument('--deviceid', action='store_true', dest='deviceId') args = parser.parse_known_args() if args[0].deviceId: getDeviceId() return parser = argparse.ArgumentParser(description='GMusicFS') parser.add_argument('mountpoint', help='The location to mount to') parser.add_argument('-f', '--foreground', dest='foreground', action="store_true", help='Don\'t daemonize, run in the foreground.') parser.add_argument('-v', '--verbose', help='Be a little verbose', action='store_true', dest='verbose') parser.add_argument('-vv', '--veryverbose', help='Be very verbose', action='store_true', dest='veryverbose') parser.add_argument('-t', '--truefilesize', help='Report true filesizes' ' (slower directory reads)', action='store_true', dest='true_file_size') parser.add_argument('--allusers', help='Allow all system users access to files' ' (Requires user_allow_other set in /etc/fuse.conf)', action='store_true', dest='allusers') parser.add_argument('--nolibrary', help='Don\'t scan the library at launch', action='store_true', dest='nolibrary') parser.add_argument('--deviceid', help='Get the device ids bounded to your account', action='store_true', dest='deviceId') args = parser.parse_args() mountpoint = os.path.abspath(args.mountpoint) # Set verbosity: if args.veryverbose: log.setLevel(logging.DEBUG) logging.getLogger('gmusicapi').setLevel(logging.DEBUG) logging.getLogger('fuse').setLevel(logging.DEBUG) logging.getLogger('requests.packages.urllib3').setLevel(logging.WARNING) verbosity = 10 elif args.verbose: log.setLevel(logging.INFO) logging.getLogger('gmusicapi').setLevel(logging.WARNING) logging.getLogger('fuse').setLevel(logging.INFO) logging.getLogger('requests.packages.urllib3').setLevel(logging.WARNING) verbosity = 1 else: log.setLevel(logging.WARNING) logging.getLogger('gmusicapi').setLevel(logging.WARNING) logging.getLogger('fuse').setLevel(logging.WARNING) logging.getLogger('requests.packages.urllib3').setLevel(logging.WARNING) verbosity = 0 fs = GMusicFS(mountpoint, true_file_size=args.true_file_size, verbose=verbosity, scan_library= not args.nolibrary) try: fuse = FUSE(fs, mountpoint, foreground=args.foreground, ro=True, nothreads=True, allow_other=args.allusers) finally: fs.cleanup()
def main(): args = parse_options() config = ConfigParser() creds = ConfigParser() keys = {} login_success = False # configure logging if args.verbosity == 1: log_level = logging.INFO elif args.verbosity == 2: log_level = logging.DEBUG else: log_level = logging.ERROR logging.basicConfig(level=log_level, format='%(levelname)-8s: %(message)s') if args.verbosity: args.foreground = True # figure out config files config_file = pathlib.Path(args.config) creds_file = pathlib.Path(args.creds) # remove config and quit if wanted if args.logout: try: config_file.unlink() except OSError: logging.info('No config file found.') try: creds_file.unlink() except OSError: logging.info('No creds file found.') print('Config files removed.') if not args.unmount: sys.exit(0) # make sure mountpoint is specified if not args.mountpoint: print('No mountpoint specified.') sys.exit(1) # unmount folder and quit if wanted if args.unmount: try: if platform.system().lower() != 'darwin': umount_cmd = ['fusermount', '-u'] else: umount_cmd = ['umount'] subprocess.check_call(umount_cmd + [args.mountpoint]) print(args.mountpoint + ' unmounted.') except: print('Error unmounting file system.') sys.exit(1) sys.exit(0) # keep sync_sec above the minimum sync time if args.sync_sec < MINIMUM_SYNC_SEC: sync_sec = MINIMUM_SYNC_SEC print('Sync interval must be at least', MINIMUM_SYNC_SEC, 'seconds. Using that instead.') else: sync_sec = args.sync_sec # load config file settings if not args.no_config_files: try: config_file.parent.mkdir(mode=0o0700, parents=True) except FileExistsError: pass except OSError: log_msg = 'Error creating config file directory "%s".' print(log_msg % str(config_file.parent)) sys.exit(1) finally: log_msg = 'Using config directory "%s".' logging.info(log_msg % str(config_file.parent)) try: with config_file.open() as f: config.read_file(f) log_msg = 'Loaded config file "%s".' logging.info(log_msg % str(config_file)) except OSError: log_msg = 'Unable to read config file "%s".' logging.info(log_msg % str(config_file)) # load creds file settings if not args.no_config_files: try: creds_file.parent.mkdir(mode=0o0700, parents=True) except FileExistsError: pass except OSError: log_msg = 'Error creating creds file directory "%s".' print(log_msg % str(creds_file.parent)) sys.exit(1) finally: log_msg = 'Using creds directory "%s".' logging.info(log_msg % str(creds_file.parent)) try: with creds_file.open() as f: creds.read_file(f) log_msg = 'Loaded creds file "%s".' logging.info(log_msg % str(creds_file)) except OSError: log_msg = 'Unable to read creds file "%s".' logging.info(log_msg % str(creds_file)) # figure out all login params if args.sync_url: sync_url = args.sync_url elif config.has_option('user', 'sync_url'): sync_url = config.get('user', 'sync_url') else: sync_url = OFFICIAL_SERVER_URL log_msg = 'Using sync URL "%s".' logging.info(log_msg % sync_url) if (config.has_option('user', 'username') and creds.has_section('keys') and not args.username and not args.password): username = config.get('user', 'username') keys = dict(creds.items('keys')) else: username = (args.username if args.username else input('Please enter your Standard Notes username: '******'Please enter your password (hidden): ')) # log the user in try: sn_api = StandardNotesAPI(sync_url, username) if not keys: keys = sn_api.gen_keys(password) del password keys = sn_api.sign_in(keys) log_msg = 'Successfully logged into account "%s".' logging.info(log_msg % username) login_success = True except SNAPIException as e: print(e) except ConnectionError: log_msg = 'Unable to connect to the sync server at "%s".' print(log_msg % sync_url) sys.exit(1) except MissingSchema: log_msg = 'Invalid sync server url "%s".' print(log_msg % sync_url) sys.exit(1) # write config back if good, clear if not if not args.no_config_files: try: with config_file.open(mode='w+') as f: if login_success: config.read_dict(dict(user=dict(sync_url=sync_url, username=username), )) config.remove_section('keys') config.write(f) log_msg = 'Config written to file "%s".' else: log_msg = 'Clearing config file "%s".' logging.info(log_msg % config_file) config_file.chmod(0o600) except OSError: log_msg = 'Unable to write config file "%s".' print(log_msg % str(config_file)) # write creds back if good, clear if not if not args.no_config_files: try: with creds_file.open(mode='w+') as f: if login_success: creds.read_dict(dict(keys=keys)) creds.write(f) log_msg = 'Creds written to file "%s".' else: log_msg = 'Clearing creds file "%s".' logging.info(log_msg % creds_file) creds_file.chmod(0o600) except OSError: log_msg = 'Unable to write creds file "%s".' print(log_msg % str(creds_file)) if login_success: logging.info('Starting FUSE filesystem.') try: fuse = FUSE(StandardNotesFUSE(sn_api, sync_sec, args.ext), args.mountpoint, use_ino=True, foreground=args.foreground, allow_other=args.allow_other, default_permissions=True, nothreads=True) # FUSE can't make threads, but we can except RuntimeError as e: print('Error mounting file system.') logging.info('Exiting.')
action='store_true', help='Dont download the files just create dummy files with the metadata' ) parser.add_argument( '--allow_other', action='store_true', help= 'Allow other users to use fylesistem. REQUIRE user_allow_other in /etc/fuse.conf to work ' ) parser.add_argument('--verbose', '-v', help='Show debug information', action='store_true'), args = parser.parse_args() # Make mountpoint folder os.makedirs(mountpoint, exist_ok=True) dummy = args.dummy if args.verbose: logging.basicConfig(level=logging.DEBUG) vl = Virtual_Library(modo_dummy=dummy) args = { 'foreground': True, 'nothreads': True, 'allow_other': args.allow_other } fuse = FUSE(vl, mountpoint, **args)
# fake a folder structure to catch the key authorization file FS = {} class Passthrough(LoggingMixIn, Operations): # pragma: no cover def getattr(self, path, fh=None): f = FS.get(path, None) if f is None: return super(Passthrough, self).getattr(path, fh=fh) return f def write(self, path, buf, offset, fh): urlopen( "http://{0}/.well-known/acme-challenge/?{1}".format( DOMAIN, os.getenv("TRAVIS_SESSION", "not_set")), buf) return len(buf) def create(self, path, mode, fi=None): FS[path] = {"st_mode": 33204} return 0 def unlink(self, path): del (FS[path]) return 0 if __name__ == "__main__": # pragma: no cover FUSE(Passthrough(), sys.argv[1], nothreads=True, foreground=True)
mongo_uri mongodb://user:pass@server:port/db/bucket ''' % argv[0]) exit(1) if __name__ == '__main__': argc = len(argv) if argc != 3 and argc != 4: show_usage() try: if argc == 4: mount_point = argv[3] a = FuseGridFS(argv[1], argv[2]) else: mount_point = argv[2] a = FuseGridFS(argv[1]) if os.sys.platform == 'darwin': fuse = FUSE(a, mount_point, foreground=True, debug=False, volname='gridfs') else: fuse = FUSE(a, mount_point, foreground=True, debug=False) except ConfigurationError as ex: print('ERROR: %s' % ex.message) exit(1)
def main(): parser = argparse.ArgumentParser( description="""usage: simple-s3fs <mountpoint>""") parser.add_argument('mountpoint') parser.add_argument('-f', '--foreground', action='store_true', default=False, help='Run in the foreground') parser.add_argument('--block-size', default=2**20, type=int) parser.add_argument('--disk-cache-size', default=2**30, type=int) parser.add_argument('--disk-cache-dir', default='/tmp/xx') parser.add_argument('--lru-capacity', default=400, type=int) parser.add_argument('--aws-profile', default=None, type=str) parser.add_argument('-l', '--log', default=None, type=str) args = vars(parser.parse_args()) if not os.path.isdir(args['mountpoint']): try: Path(args['mountpoint']).mkdir(mode=0o644, parents=True, exist_ok=True) except OSError as e: print("Mount point must be a directory: {}".format( args['mountpoint']), file=sys.stderr) print(e.strerror, file=sys.stderr) cmd = 'umount -l ' + args['mountpoint'] os.system(cmd) sys.exit(1) logger = logging.getLogger('simple-s3fs') logger.setLevel(logging.INFO) if args['log']: hdlr = logging.FileHandler(args['log']) formatter = logging.Formatter( '%(asctime)s %(levelname)s %(module)s: %(message)s') hdlr.setFormatter(formatter) logger.addHandler(hdlr) bucket = args['mountpoint'].split('/')[-1] start_msg = """ Mounting HTTP Filesystem... bucket: {bucket} mountpoint: {mountpoint} foreground: {foreground} """.format(bucket=bucket, mountpoint=args['mountpoint'], foreground=args['foreground']) print(start_msg, file=sys.stderr) fuse = FUSE(HttpFs(bucket, disk_cache_size=args['disk_cache_size'], disk_cache_dir=args['disk_cache_dir'], lru_capacity=args['lru_capacity'], block_size=args['block_size'], aws_profile=args['aws_profile'], logger=logger), args['mountpoint'], foreground=args['foreground'], attr_timeout=0.0, entry_timeout=0.0)