def __init__(self, session=None, **kwargs): cache_dir = session.GetParameter("cache_dir") if not cache_dir: raise io_manager.IOManagerError( "Local profile cache is not configured - " "add a cache_dir parameter to ~/.rekallrc.") # Cache dir may be specified relative to the home directory. if config.GetHomeDir(): cache_dir = os.path.join(config.GetHomeDir(), cache_dir) if not os.access(cache_dir, os.F_OK | os.R_OK | os.W_OK | os.X_OK): try: os.makedirs(cache_dir) except (IOError, OSError): raise io_manager.IOManagerError( "Unable to create or access cache directory %s" % cache_dir) # We use an IO manager to manage the cache directory directly. self.cache_io_manager = io_manager.DirectoryIOManager(urn=cache_dir, session=session) self.url_manager = self.DELEGATE(session=session, **kwargs) self.CheckUpstreamRepository() super(CachingManager, self).__init__(session=session, **kwargs)
def __init__(self, spec=None, root="./", manager=None, **kwargs): super(BuildIndex, self).__init__(**kwargs) self.spec = spec if manager is None: manager = io_manager.DirectoryIOManager( root, session=self.session) self.io_manager = manager
def __init__(self, session=None, **kwargs): super(CachingManager, self).__init__(session=session, **kwargs) cache_dir = cache.GetCacheDir(session) # We use an IO manager to manage the cache directory directly. self.cache_io_manager = io_manager.DirectoryIOManager(urn=cache_dir, session=session) self.url_manager = self.DELEGATE(session=session, **kwargs) self.CheckUpstreamRepository()
def testDirectoryIOManager(self): manager = io_manager.DirectoryIOManager(self.temp_directory, session=self.MakeUserSession()) # Cant decode from json. self.assertEqual(manager.GetData("foo"), None) self.assertEqual(manager.GetData("foo", raw=True), "hello") # Test ListFiles(). self.assertListEqual(sorted(manager.ListFiles()), ["bar", "foo"]) # Storing a data structure. data = dict(a=1) manager.StoreData("baz", data) self.assertDictEqual(manager.GetData("baz"), data) self.assertTrue( isinstance(manager.GetData("baz", raw=True), basestring))
def repository_managers(self): """The IO managers that are used to fetch profiles from the profile repository. """ if self._repository_managers: return self._repository_managers # The profile path is specified in search order. repository_path = (self.GetParameter("repository_path") or self.GetParameter("profile_path") or []) for path in repository_path: # TODO(scudette): remove this hack for 1.6 release. Github has # changed their static URL access. If the user is using an old URL # we warn and correct it. if path in constants.OLD_DEPRECATED_URLS: self.logging.warn( "Rekall's profile repository is pointing to deprecated URL " "(%s). Please update your ~/.rekallrc file.", path) path = constants.PROFILE_REPOSITORIES[0] try: self._repository_managers.append( (path, io_manager.Factory(path, session=self))) except ValueError: pass if not self._repository_managers: try: self.logging.warn( "No usable repositories were found. " "Rekall Will attempt to use the local cache. " "This is likely to fail if profiles are missing locally!") self._repository_managers = [ (None, io_manager.DirectoryIOManager(urn=cache.GetCacheDir(self), session=self)) ] except IOError: self._repository_managers = [] return self._repository_managers
def LoadProfile(self, name, use_cache=True): """Try to load a profile directly by its name. Args: name: A string which represents the canonical name for the profile. We ask all repositories in the repository_path to resolve this name into a profile. Returns: a Profile() instance or a NoneObject() """ if not name: return obj.NoneObject("No filename") if isinstance(name, obj.Profile): return name # We only want to deal with unix paths. name = name.replace("\\", "/") try: if use_cache: cached_profile = self.profile_cache[name] if cached_profile: return cached_profile else: return obj.NoneObject( "Unable to load profile %s from any repository." % name) except KeyError: pass result = None try: # If the name is a path we try to open it directly: container = io_manager.DirectoryIOManager(os.path.dirname(name), version=None, session=self) data = container.GetData(os.path.basename(name)) if data == None: raise IOError("Not found.") result = obj.Profile.LoadProfileFromData(data, self, name=name) except IOError: pass # Traverse the profile path until one works. if not result: # Add the last supported repository as the last fallback path. for path, manager in self.repository_managers: try: # The inventory allows us to fail fetching the profile # quickly - without making the round trip. if not manager.CheckInventory(name): self.logging.debug( "Skipped profile %s from %s (Not in inventory)", name, path) continue now = time.time() result = obj.Profile.LoadProfileFromData( manager.GetData(name), session=self, name=name) if result: self.logging.info( "Loaded profile %s from %s (in %s sec)", name, manager, time.time() - now) break except (IOError, KeyError) as e: result = obj.NoneObject(e) self.logging.debug("Could not find profile %s in %s: %s", name, path, e) continue # Cache it for later. Note that this also caches failures so we do not # retry again. self.profile_cache[name] = result if result == None: return obj.NoneObject( "Unable to load profile %s from any repository." % name) return result