def main(self, *a, **kw):
# Setup physical memory
if hasattr(self, "domain"):
self.xai = pyxa_instance(self.domain)
else:
self.parser.error("PyXaFS: must provide a Xen domain to mount")
Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
# Setup physical memory
if hasattr(self, "domain"):
self.vm = pyvmi.init(self.domain, "partial")
else:
self.parser.error("PyVmiFS: must provide a Xen domain to mount")
Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
# Setup physical memory
if hasattr(self, "domain"):
self.vm = pyvmi.init(self.domain, "partial")
else:
self.parser.error("PyVmiFS: must provide a Xen domain to mount")
Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
# Setup physical memory
if hasattr(self, "domain"):
self.xai = pyxa_instance(self.domain)
else:
self.parser.error("PyXaFS: must provide a Xen domain to mount")
Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
"""
Main entry point. Mounts filesystem and daemonizes.
"""
self.file_class = self.UnfsFile
return Fuse.main(self, *a, **kw)
def main(self):
options, args = self.parser.parse_args()
if not args:
print("No image file specied.")
return
self.session = session.Session(
filename=args[0], logging=2, profile=options.profile)
# List all processes and hold on to their address spaces.
self.tasks = {}
for task in self.session.plugins.pslist(session=self.session).list_eprocess():
address_space = task.get_process_address_space()
process_name = u"%s_%s" % (task.UniqueProcessId, task.ImageFileName)
# Remove funky chars from the filename
process_name = re.sub("[^a-zA-Z0-9._]", "_", process_name)
if address_space:
self.tasks[process_name] = address_space
# Make a special entry for the kernel here.
self.tasks['kernel'] = self.session.kernel_address_space
## Prepare the file class - this will be used to read specific
## files:
self.file_class = self.ASFuseFile
self.file_class.fs = self
if self.session.profile.metadata("memory_model") == "64bit":
self.address_space_size = 0xfffffffffffffff
else:
self.address_space_size = 0xffffffff
return Fuse.main(self)
def main(self, *a, **kw):
"""
Main entry
:param a:
:param kw:
:return:
"""
return Fuse.main(self, *a, **kw)
def main(self, args=None):
'''
Mainline of the FUSE client filesystem. This directly overrides
the Fuse.main() method to allow us to manually shutdown things
after the FUSE event loop has finished.
'''
class FuseFileWrapper(tsumufs.FuseFile):
'''
Inner class to wrap the FuseFile class with the reference to this thread,
allowing us to get at the GetContext() call. Essentially we're creating a
closure here. Ugly, but it's the only way to get the uid and gid into the
FuseFile thread.
Idea borrowed directly from Robie Basak in his email to fuse-dev, which is
visible at <http://www.nabble.com/Python%3A-Pass-parameters-to-file_class-to18301066.html#a20066429>.
'''
def __new__(cls, path, *args, **kwargs):
kwargs.update(self.GetContext())
klass = tsumufs.getManager(path).getFileClass(path) or tsumufs.FuseFile
return klass(path, *args, **kwargs)
def __init__(self2, *args, **kwargs):
kwargs.update(self.GetContext())
tsumufs.FuseFile.__init__(self2, *args, **kwargs)
self.file_class = FuseFileWrapper
self._debug('Trying fsinit()')
if self.fsinit():
result = Fuse.main(self, args)
self._debug('Fuse main event loop exite')
self._debug('Setting event and condition states.')
tsumufs.unmounted.set()
self._debug('Waiting for the sync thread to finish.')
self._syncThread.join()
self._debug('Shutdown complete.')
self._debug("---BEGIN-GEN-BENCHMARK-REPORT---")
metrics=""
for key in tsumufs.metrics._metrics.keys():
self._debug(" %s: %s " % (str(key) , str(tsumufs.metrics._metrics[key])))
self._debug("---END-GEN-BENCHMARK-REPORT---")
else:
self._debug('fsinit() failed...')
result = False
return result
def main(self, *args, **kwargs):
fuse = self
class FileClass(GstreamerFS.File):
def __init__(self, *args, **kwargs):
syslog.syslog('fuse: %s' % fuse)
syslog.syslog('self: %s' % self)
GstreamerFS.File.__init__(self, fuse, *args, **kwargs)
self.file_class = FileClass
return Fuse.main(self, *args, **kwargs)
def main(self):
options, args = self.parser.parse_args()
self.img = images.SelectImage(options.type, args)
self.offset = parse_int(options.offset)
self.fs = pytsk3.FS_Info(self.img, offset = self.offset)
## Prepare the file class - this will be used to read specific
## files:
self.file_class = self.TSKFuseFile
self.file_class.fs = self.fs
return Fuse.main(self)
def main(self, *a, **kw):
self.restore = int(self.restore) != 0
self.shares = int(self.shares)
self.required = int(self.required)
assert self.required >= 1
assert self.required <= self.shares
if self.restore:
self.file_class = self.ZfecRestoreFile
self.decoder = zfec.Decoder(self.required, self.shares)
else:
self.file_class = self.ZfecFile
self.encoder = zfec.Encoder(self.required, self.shares)
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
if not self.fuse_args.getmod('showhelp'):
self._validate_args()
self.db = PhotoDb(self.root)
self.views = GetViews(self.db)
if self.db.TryLock():
logging.info('Acquired database lock, will write/update it')
else:
logging.error(('Failed to acquire database lock, '
'another instance is already running'))
sys.exit(0)
return Fuse.main(self, *a, **kw)
def main(self):
self.offset = parse_int(self.offset)
args = self.cmdline[1]
if len(args) != 1:
raise RuntimeError( "You must specify a single image name to load - try -h for help ")
print "Opening filesystem in %s" % args[0]
self.img = Img_Info(args[0])
self.fs = pytsk3.FS_Info(self.img, offset = self.offset)
## Prepare the file class - this will be used to read specific
## files:
self.file_class = self.TSKFuseFile
self.file_class.fs = self.fs
return Fuse.main(self)
def main(self):
self.offset = parse_int(self.offset)
args = self.cmdline[1]
if len(args) != 1:
raise RuntimeError(
"You must specify a single image name to load - try -h for help "
)
print "Opening filesystem in %s" % args[0]
self.img = Img_Info(args[0])
self.fs = pytsk3.FS_Info(self.img, offset=self.offset)
## Prepare the file class - this will be used to read specific
## files:
self.file_class = self.TSKFuseFile
self.file_class.fs = self.fs
return Fuse.main(self)
def main(self, *a, **kw):
if not os.path.isdir(self.local_cache_dir):
print("Creating local cache directory: {}".format(
self.local_cache_dir))
os.mkdir(self.local_cache_dir)
if self.local_cache_dir[-1] == '/':
self.local_cache_dir = self.local_cache_dir[:-1]
self.log_fh = open(self.log_file, "a")
parent = "{}:{}".format(self.host, self.port)
self.fs = HashFS_Core(parent_node=parent,
local_cache_dir=self.local_cache_dir,
local_run=self.local_run,
hash_alg=self.hash_alg)
return Fuse.main(self, *a, **kw)
def main(self):
options, args = self.parser.parse_args()
if not args:
print "No image file specied."
return
self.session = session.Session(filename=args[0],
logging=2,
profile=options.profile)
# List all processes and hold on to their address spaces.
self.tasks = {}
for task in self.session.plugins.pslist(
session=self.session).list_eprocess():
address_space = task.get_process_address_space()
process_name = u"%s_%s" % (task.UniqueProcessId,
task.ImageFileName)
# Remove funky chars from the filename
process_name = re.sub("[^a-zA-Z0-9._]", "_", process_name)
if address_space:
self.tasks[process_name] = address_space
# Make a special entry for the kernel here.
self.tasks['kernel'] = self.session.kernel_address_space
## Prepare the file class - this will be used to read specific
## files:
self.file_class = self.ASFuseFile
self.file_class.fs = self
if self.session.profile.metadata("memory_model") == "64bit":
self.address_space_size = 0xfffffffffffffff
else:
self.address_space_size = 0xffffffff
return Fuse.main(self)
def main(self):
if hasattr(self, "image"):
path = self.image
else:
raise ADFS_Error, "No path specified"
try:
self.adffile = open(path, "rb")
self.adfsdisc = ADFSlib.ADFSdisc(self.adffile, verify = 1)
except IOError:
raise ADFS_Error, "Failed to open the image file specified"
except ADFSlib.ADFS_exception:
self.adffile.close()
raise ADFS_Error
self.root_time = time.time()
return Fuse.main(self)
def main(self, *a, **kw):
"""This is the main method of MogamiFS.
"""
self.file_class = self.MogamiFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.TagFSFile
self.fsinit()
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.AFF4FuseFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
#self.file_class = self.Sha1File
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
debug("PyFuseMongo.main()")
self.file_class = self.PyFuseMongoFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kwargs):
"""Start and lose control"""
Fuse.main(self, *a, **kwargs)
def main(self, *a, **kw):
self.file_class = self.MiGAccessFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.PyFlagVFSFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.MeetingFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.AmnesiaFSFile
return Fuse.main(self, *a, **kw)
def main(self, *args, **kwargs):
return Fuse.main(self, *args, **kwargs)
def main(self, *a, **kw):
"""This is the main method of MogamiFS.
"""
self.file_class = self.MogamiFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = GRSFile
# this crashes and is not needed: self.dir_class = GRSDirectory
return Fuse.main(self, *a, **kw)
def main(self): self.connect(self.server, (self.username, self.password)) Fuse.main(self)
def main(self, *a, **kw):
self.SNFile.tree = self.tree
self.file_class = self.SNFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.MusicFSFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
return Fuse.main(self, *a, **kw)
def main(self):
options, args = self.parser.parse_args()
self.fd = images.SelectImage(options.type, args)
return Fuse.main(self)
def main(self, *a, **kw):
self.file_class = self.PyFlagVFSFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
dir_struct_module = importlib.import_module('dir_structure.' + self.struct)
self.dir_struct = dir_struct_module.get_dir_structure()
self.file_class = self.get_file_class(self.dir_struct)
return Fuse.main(self, *a, **kw)
def main(self, *args, **kwargs):
return Fuse.main(self, *args, **kwargs)
def main(self, *a, **kw):
# Define the file class locally as that seems to be the easiest way to
# inject instance specific data into it...
server = self
if server.fuse_args.mount_expected():
server.__initialize()
class DhtfsFile(object):
def __init__(self, path, flags, *mode):
# set logger
self.logger = server.logger
self.logger.info("###### Initiating file object In function : %s" % sys._getframe().f_code.co_name)
# set the dirs which are associated with this file
self.dirs = [x for x in os.path.dirname(path).split(os.path.sep) if x != '']
# Get actual path for the specified path
actualPath = server.getActualPath(path)
newCreated = False
if os.path.basename(actualPath) == Dhtfs.MISSING_FILE:
# File is not yet created. Create file
self.logger.info("Actual path missing")
actualPath = server.generateNewFileName()
newCreated = True
if path in server.fileCache:
self.logger.info("CACHE: Remove entry for path %s" % path)
del server.fileCache[path]
self.file = os.fdopen(os.open(os.path.join(server.root, actualPath), flags, *mode),
flag2mode(flags))
self.fd = self.file.fileno()
filename = os.path.basename(path)
self.fi = TagFile(actualPath, filename)
if newCreated:
self.logger.info("Adding tags %s, to file %s" %(self.dirs, self.fi))
# Add tag information for the newly created file
server.tagdir.addDirsToFiles([self.fi], self.dirs)
def read(self, length, offset):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
self.file.seek(offset)
return self.file.read(length)
def write(self, buf, offset):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
self.file.seek(offset)
self.file.write(buf)
return len(buf)
def release(self, flags):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
self.file.close()
def fsync(self, isfsyncfile):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
if isfsyncfile and hasattr(os, 'fdatasync'):
os.fdatasync(self.fd)
else:
os.fsync(self.fd)
def flush(self):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
self.file.flush()
# cf. xmp_flush() in fusexmp_fh.c
os.close(os.dup(self.fd))
def fgetattr(self):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
return os.fstat(self.fd)
def ftruncate(self, len):
self.logger.info("In function : %s" % sys._getframe().f_code.co_name)
self.file.truncate(len)
self.file_class = DhtfsFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.AFF4FuseFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw): #self.file_class = self.Sha1File return Fuse.main(self, *a, **kw)
def main(self, *a, **kw): self.file_class = fs45gFile fs45gFile.myFS = self return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.XmpFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.MiGAccessFile
return Fuse.main(self, *a, **kw)
def main(self, *args, **kw):
import os
fullpath = os.path.abspath(os.path.expanduser(os.path.expandvars(
self.db_path)))
self.__backend = DBDumpFS("sqlite:"+fullpath)
Fuse.main(self, *args, **kw)
def main(self, *a, **kw):
self.file_class = self.CloudNcfsFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.MusicFSFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.LindFuseFSFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = fs45gFile
fs45gFile.myFS = self
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = GRSFile
# this crashes and is not needed: self.dir_class = GRSDirectory
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.XmpFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = TNFS_File
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.CloudNcfsFile
return Fuse.main(self, *a, **kw)
def main(self, *a, **kw):
self.file_class = self.LindFuseFSFile
return Fuse.main(self, *a, **kw)
