pytagsfs-0.9.2/0000755000175000017500000000000011315711421012744 5ustar forestforestpytagsfs-0.9.2/modules/0000755000175000017500000000000011315711421014414 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/0000755000175000017500000000000011315711421016254 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/multithreading.py0000644000175000017500000001316511315711421021654 0ustar forestforest# Copyright (c) 2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. ''' This module implements token-style locking. This prevents deadlocks by enforcing that no thread can acquire more than one lock at a time. Tokens are identified by an arbitrary object. The GLOBAL object defined here identifies a global token. Most code should simply assume that the global token is acquired and need not be written to be thread safe. Code that uses blocking I/O should either wrap such calls with bracketing release_token/reacquire_token or push_token/pop_token calls. Generally, use release_token/reacquire_token when the calls are atomic (i.e. do not use an open file descriptor) and use push_token/pop_token when the calls are not atomic (i.e. do use an open file descriptor). push_token/pop_token should be used with a token identifier that uniquely identifies the resource (usually an object associated with a file descriptor) being protected. As little code as possible should sit in the critical section where the global token is no longer held, since most code will assume that the global token has been acquired. Do not call arbitrary functions, if possible, only I/O functions whose thread safety is known. ''' from thread import get_ident, allocate_lock try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps # Note: Do not call logging functions from this module. Logging functions # assume that the global token is acquired. We cannot make that assumption # here. GLOBAL = object() class TokenError(Exception): pass class BaseToken(object): _id = None def __init__(self, id): self._id = id def acquire(self): raise NotImplementedError() def release(self): raise NotImplementedError() class Token(BaseToken): _lock = None _owner = None def __init__(self, id): super(Token, self).__init__(id) self._lock = allocate_lock() def acquire(self): owner = get_ident() if self._owner == owner: # Token may only be acquired once per thread. raise TokenError('token already acquired') self._lock.acquire() self._owner = owner def release(self): owner = self._owner if owner != get_ident(): raise TokenError('token not acquired') del self._owner self._lock.release() class NullToken(BaseToken): def acquire(self): pass def release(self): pass class NullLock(object): def acquire(self): pass def release(self): pass class TokenExchange(object): _tokens = None _lock = None _owner_token_queues = None def __init__(self): self._tokens = {} self._lock = allocate_lock() self._owner_token_queues = {} def push_token(self, id): owner = get_ident() self._lock.acquire() try: try: prev_token = self._owner_token_queues[owner][-1] except (KeyError, IndexError): prev_token = None try: next_token = self._tokens[id] except KeyError: next_token = Token(id) self._tokens[id] = next_token self._owner_token_queues.setdefault(owner, []).append(next_token) finally: self._lock.release() if prev_token is not None: prev_token.release() next_token.acquire() def pop_token(self): owner = get_ident() self._lock.acquire() try: prev_token = self._owner_token_queues[owner].pop() try: next_token = self._owner_token_queues[owner][-1] except (KeyError, IndexError): next_token = None finally: self._lock.release() prev_token.release() if next_token is not None: next_token.acquire() def token_pushed(self, get_id): def decorator(wrapped): @wraps(wrapped) def fn(*args, **kwargs): if callable(get_id): id = get_id(*args, **kwargs) else: id = get_id self.push_token(id) try: return wrapped(*args, **kwargs) finally: self.pop_token() return fn return decorator def release_token(self): owner = get_ident() self._lock.acquire() try: try: token = self._owner_token_queues[owner][-1] except (KeyError, IndexError): token = None finally: self._lock.release() if token is not None: token.release() def reacquire_token(self): owner = get_ident() self._lock.acquire() try: try: token = self._owner_token_queues[owner][-1] except (KeyError, IndexError): token = None finally: self._lock.release() if token is not None: token.acquire() def token_released(self, wrapped): @wraps(wrapped) def fn(*args, **kwargs): self.release_token() try: return wrapped(*args, **kwargs) finally: self.reacquire_token() return fn token_exchange = TokenExchange() pytagsfs-0.9.2/modules/pytagsfs/debug.py0000644000175000017500000000561011315711421017716 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from sclapp import locale import traceback, logging, time from logging import DEBUG, INFO, WARNING, ERROR, CRITICAL try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps class VirtualLogFileStream(object): def write(self, s): # Re-bind write method on first invocation to avoid performance hit # from importing on every call (necessary to avoid import loop via # pytagsfs.file). from pytagsfs.specialfile.logfile import VirtualLogFile self.write = VirtualLogFile.log_write return self.write(s) def flush(self): pass logger = logging.getLogger() class FormatterWithMicroseconds(logging.Formatter): def formatTime(self, record, datefmt): ct = self.converter(record.created) s = time.strftime(datefmt, ct) if '${us}' in s: s = s.replace('${us}', '%03d' % record.msecs) return s formatter = FormatterWithMicroseconds( '[%(asctime)s] %(message)s', '%H:%M:%S,${us}', ) stderr_handler = logging.StreamHandler() stderr_handler.setFormatter(formatter) virtual_log_file_handler = logging.StreamHandler(VirtualLogFileStream()) virtual_log_file_handler.setFormatter(formatter) logger.addHandler(virtual_log_file_handler) def set_log_level(lvl): logger.setLevel(lvl) def set_logsize(size): from pytagsfs.specialfile.logfile import VirtualLogFile VirtualLogFile.set_max_length(size) stderr_enabled = False def enable_stderr(): global stderr_enabled if not stderr_enabled: logger.addHandler(stderr_handler) stderr_enabled = True def log_debug(*args, **kwargs): logger.debug(*args, **kwargs) def log_info(*args, **kwargs): logger.info(*args, **kwargs) def log_warning(*args, **kwargs): logger.warning(*args, **kwargs) def log_error(*args, **kwargs): logger.error(*args, **kwargs) def log_critical(*args, **kwargs): logger.critical(*args, **kwargs) def log_loud(*args, **kwargs): if not stderr_enabled: logger.addHandler(stderr_handler) try: log_critical(*args, **kwargs) finally: logger.removeHandler(stderr_handler) else: log_critical(*args, **kwargs) def log_traceback(): log_critical(traceback.format_exc()) def ignore_exceptions(*ignored_exceptions): def decorator(fn): @wraps(fn) def new_fn(*args, **kwargs): try: return fn(*args, **kwargs) except ignored_exceptions, e: pass return new_fn return decorator pytagsfs-0.9.2/modules/pytagsfs/pathstore/0000755000175000017500000000000011315711421020265 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/pathstore/pytypes.py0000644000175000017500000003632411315711421022364 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os.path try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps from sclapp.util import safe_encode from pytagsfs.pathstore import PathStore from pytagsfs.util import ( last_unique, unicode_path_sep, ) from pytagsfs.exceptions import ( FakePathNotFound, RealPathNotFound, NotADirectory, IsADirectory, PathExists, PathNotFound, InvalidArgument, DirectoryNotEmpty, NoMetaDataExists, NotAnEndPoint, PathError, ) class DictList(dict): def get_or_set_and_get(self, k): try: return self[k] except KeyError: pass try: self[k] = [] except: del self[k] raise return self[k] def pop_and_clean(self, k): try: return self[k].pop() finally: self.clean(k) def clean(self, k): if not self[k]: del self[k] class PathDoesNotExistInPathMapping(PathError): pass class PathMapping(object): forward_mapping = None reverse_mapping = None def __init__(self): self.forward_mapping = DictList() self.reverse_mapping = DictList() def add_real_path(self, fake_path, real_path): self.forward_mapping.get_or_set_and_get(fake_path).append(real_path) try: self.reverse_mapping.get_or_set_and_get(real_path).append(fake_path) except: self.forward_mapping.pop_and_clean(fake_path) raise def remove_real_path(self, fake_path, real_path = None): if real_path is None: real_path = self.forward_mapping.pop_and_clean(fake_path) else: self.forward_mapping[fake_path].remove(real_path) self.forward_mapping.clean(fake_path) try: self.reverse_mapping[real_path].remove(fake_path) if not self.reverse_mapping[real_path]: del self.reverse_mapping[real_path] except: self.forward_mapping.get_or_set_and_get(fake_path).append(real_path) raise def get_real_path(self, fake_path): try: return self.forward_mapping[fake_path][-1] except (KeyError, IndexError): raise PathDoesNotExistInPathMapping(fake_path) def get_fake_paths(self, real_path): try: return self.reverse_mapping[real_path] except KeyError: raise PathDoesNotExistInPathMapping(real_path) def get_reverse_keys(self): return self.reverse_mapping.keys() class Entry(unicode): def __init__(self, s): if not isinstance(s, unicode): raise TypeError(u'must be unicode: %s' % repr(s)) super(Entry, self).__init__() def set_meta_data(self, meta_data): self.meta_data = meta_data def get_meta_data(self): try: return self.meta_data except AttributeError: raise NoMetaDataExists(self) def unset_meta_data(self): try: del self.meta_data except AttributeError: raise NoMetaDataExists(self) class DirectoryAlreadyExistsInEntryStore(PathError): pass class DirectoryDoesNotExistInEntryStore(PathError): pass class EntryDoesNotExistInEntryStore(PathError): pass class EntryStore(object): entries = None def __init__(self): self.entries = {} self.add_directory(unicode_path_sep) def add_directory(self, directory): if directory in self.entries: raise DirectoryAlreadyExistsInEntryStore(directory) self.entries[directory] = [] def remove_directory(self, directory): if directory == unicode_path_sep: raise ValueError(unicode_path_sep) del self.entries[directory] def add_entry(self, directory, entry): if not isinstance(entry, Entry): entry = Entry(entry) try: self.entries[directory].append(entry) except KeyError: raise DirectoryDoesNotExistInEntryStore(directory) def add_entries(self, directory, entries): for entry in entries: self.add_entry(directory, entry) def remove_entry(self, directory, entry): directory, index = self._locate_entry(directory, entry) del self.entries[directory][index] def get_all_entries(self, directory): try: return self.entries[directory] except KeyError: raise DirectoryDoesNotExistInEntryStore(directory) def get_entries(self, directory): return last_unique(self.get_all_entries(directory)) def get_entry(self, fake_path): directory, index = self._locate_entry_by_fake_path(fake_path) return self.get_all_entries(directory)[index] def _locate_entry_by_fake_path(self, fake_path): if fake_path.endswith(unicode_path_sep): raise ValueError(fake_path) directory, entry = os.path.split(fake_path) return self._locate_entry(directory, entry) def _locate_entry(self, directory, entry): reversed_entries = list(reversed(self.get_all_entries(directory))) try: reverse_index = reversed_entries.index(entry) except IndexError: raise EntryDoesNotExistInEntryStore(entry) index = len(reversed_entries) - reverse_index - 1 return directory, index def replace_entry(self, directory, entry, new_entry): if not isinstance(new_entry, Entry): new_entry = Entry(new_entry) directory, index = self._locate_entry(directory, entry) self.entries[directory][index] = new_entry def iter_directories_and_entries_recursive_reversed(self, fake_path): if fake_path.endswith(unicode_path_sep): raise ValueError(fake_path) while True: fake_path, entry = os.path.split(fake_path) if not entry: break yield fake_path, entry def iter_directories_and_entries_recursive(self, fake_path): for fake_path, entry in reversed(list( self.iter_directories_and_entries_recursive_reversed(fake_path) )): yield fake_path, entry def add_entries_and_directories_recursive(self, fake_path): for fake_path, entry in ( self.iter_directories_and_entries_recursive(fake_path)): try: entries = self.get_all_entries(fake_path) except DirectoryDoesNotExistInEntryStore: self.add_directory(fake_path) else: if (fake_path != unicode_path_sep) and (entries == []): self.remove_entries_and_directories_recursive(fake_path) self.add_entry(fake_path, entry) def remove_entries_and_directories_recursive(self, fake_path): directories = [] for fake_path, entry in self.iter_directories_and_entries_recursive_reversed( fake_path): self.remove_entry(fake_path, entry) directories.insert(0, fake_path) for directory in directories: if ( (not self.get_all_entries(directory)) and (directory != unicode_path_sep) ): self.remove_directory(directory) class PyTypesPathStore(PathStore): __doc__ = ''' Path store implementation that stores path information in data types based on built-in Python types (dict, list, etc). >>> path_store = PyTypesPathStore() ''' + PathStore.__doc__ path_mapping = None entries = None meta_data = None def __init__(self): super(PyTypesPathStore, self).__init__() self.path_mapping = PathMapping() self.entries = EntryStore() self.meta_data = {} def _assert_not_root(self, path): if path == unicode_path_sep: raise AssertionError( 'old_fake_path must not be "%s"' % unicode_path_sep) def add_file(self, fake_path, real_path): try: if self.is_dir(fake_path): raise PathExists(fake_path) except PathNotFound: pass try: if real_path == self.get_real_path(fake_path): raise ValueError(u'duplicate path mapping: %s, %s' % ( repr(fake_path), repr(real_path))) except PathNotFound: pass self.path_mapping.add_real_path(fake_path, real_path) self.entries.add_entries_and_directories_recursive(fake_path) def add_directory(self, fake_path): self._must_not_exist(fake_path) self.entries.add_entries_and_directories_recursive(fake_path) self.entries.add_directory(fake_path) def rename(self, old_fake_path, new_fake_path): if self.is_dir(old_fake_path): return self._rename_directory(old_fake_path, new_fake_path) if self.is_file(old_fake_path): return self._rename_file(old_fake_path, new_fake_path) raise FakePathNotFound(old_fake_path) def _rename_file(self, old_fake_path, new_fake_path): real_path = self.get_real_path(old_fake_path) self._verify_rename(old_fake_path, new_fake_path) old_dir, old_entry = os.path.split(old_fake_path) new_dir, new_entry = os.path.split(new_fake_path) if old_dir == new_dir: self.entries.replace_entry(old_dir, old_entry, new_entry) self.path_mapping.remove_real_path(old_fake_path, real_path) self.path_mapping.add_real_path(new_fake_path, real_path) else: self._remove_file(old_fake_path, real_path) self.add_file(new_fake_path, real_path) def _rename_directory(self, old_fake_path, new_fake_path): self._must_be_empty_directory(old_fake_path) self._assert_not_root(old_fake_path) self._assert_not_root(new_fake_path) self._verify_rename(old_fake_path, new_fake_path) old_dir, old_entry = os.path.split(old_fake_path) new_dir, new_entry = os.path.split(new_fake_path) entries = self.entries.get_all_entries(old_fake_path) if old_dir == new_dir: self.entries.remove_directory(old_fake_path) self.entries.replace_entry(old_dir, old_entry, new_entry) self.entries.add_directory(new_fake_path) else: self._remove_directory(old_fake_path) self.add_directory(new_fake_path) self.entries.add_entries(new_fake_path, entries) def _verify_rename(self, old_fake_path, new_fake_path): if old_fake_path == new_fake_path: raise ValueError('old_fake_path and new_fake_path are the same') if old_fake_path.endswith(unicode_path_sep): raise ValueError(old_fake_path) if new_fake_path.endswith(unicode_path_sep): raise ValueError(new_fake_path) def remove(self, fake_path, real_path = None): if self.is_dir(fake_path): if real_path is not None: raise IsADirectory(fake_path) if self.is_empty_dir(fake_path): return self._remove_directory(fake_path) raise DirectoryNotEmpty(fake_path) if self.is_file(fake_path): return self._remove_file(fake_path, real_path) raise FakePathNotFound(fake_path) def _remove_file(self, fake_path, real_path = None): self.path_mapping.remove_real_path(fake_path, real_path) self.entries.remove_entries_and_directories_recursive(fake_path) def _remove_directory(self, fake_path): self._assert_not_root(fake_path) self._must_be_empty_directory(fake_path) self.entries.remove_directory(fake_path) self.entries.remove_entries_and_directories_recursive(fake_path) def get_real_path(self, fake_path): try: return self.path_mapping.get_real_path(fake_path) except PathDoesNotExistInPathMapping: if self.is_dir(fake_path): raise IsADirectory(fake_path) raise FakePathNotFound(fake_path) def get_fake_paths(self, real_path): try: return list(self.path_mapping.get_fake_paths(real_path)) except PathDoesNotExistInPathMapping: raise RealPathNotFound(real_path) def get_real_subpaths(self, real_path): if real_path.endswith(unicode_path_sep): raise ValueError(u'real_path %s ends with %s' % ( repr(real_path), repr(unicode_path_sep))) real_path = u'%s%s' % (real_path, unicode_path_sep) real_paths = self.path_mapping.get_reverse_keys() return [p for p in real_paths if p.startswith(real_path)] def get_entries(self, fake_path): self._must_be_dir(fake_path) return list(self.entries.get_entries(fake_path)) def is_file(self, fake_path): try: self.path_mapping.get_real_path(fake_path) except PathDoesNotExistInPathMapping: return False return True def is_dir(self, fake_path): try: self.entries.get_entries(fake_path) except DirectoryDoesNotExistInEntryStore: return False return True def is_empty_dir(self, fake_path): return ( self.is_dir(fake_path) and not self.entries.get_all_entries(fake_path) ) def path_exists(self, fake_path): if self.is_file(fake_path): return True if self.is_dir(fake_path): return True return False def _must_exist(self, fake_path): if not self.path_exists(fake_path): raise FakePathNotFound(fake_path) def _must_not_exist(self, fake_path): if self.path_exists(fake_path): raise PathExists(fake_path) def _must_be_file(self, fake_path): self._must_exist(fake_path) if not self.is_file(fake_path): raise IsADirectory(fake_path) def _must_be_dir(self, fake_path): self._must_exist(fake_path) if not self.is_dir(fake_path): raise NotADirectory(fake_path) def _must_be_empty_directory(self, fake_path): self._must_exist(fake_path) if self.is_empty_dir(fake_path): return if self.is_file(fake_path): raise NotADirectory(fake_path) raise NotAnEndPoint(fake_path) def _must_be_end_point(self, fake_path): self._must_exist(fake_path) if self.is_file(fake_path): return if self.is_empty_dir(fake_path): return raise NotAnEndPoint(fake_path) def set_meta_data(self, fake_path, meta_data): self._must_be_end_point(fake_path) entry = self.entries.get_entry(fake_path) entry.set_meta_data(meta_data) def get_meta_data(self, fake_path): self._must_be_end_point(fake_path) entry = self.entries.get_entry(fake_path) return entry.get_meta_data() def unset_meta_data(self, fake_path): self._must_be_end_point(fake_path) entry = self.entries.get_entry(fake_path) entry.unset_meta_data() def supports_threads(self): return True pytagsfs-0.9.2/modules/pytagsfs/pathstore/__init__.py0000644000175000017500000002742211315711421022405 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from pytagsfs.util import join_path_abs class PathStore(object): ''' Abstract base class for path store implementations. Sub-classes must override the following methods: * ``add_file`` * ``add_directory`` * ``remove`` * ``rename`` * ``get_real_path`` * ``get_fake_paths`` * ``is_file`` * ``is_dir`` * ``path_exists`` * ``get_entries`` * ``get_real_subpaths`` * ``set_meta_data`` * ``get_meta_data`` * ``unset_meta_data`` Path stores store path mappings from real paths to fake (virtual) paths. Multiple real paths can be associated with a given fake path. The most recently added real path takes precedence over previously added real paths. Conceptually, associating a real path with a fake path should behave like a stack, such that: >>> path_store.add_file(u'/foo', u'/bar') >>> path_store.get_real_path(u'/foo') u'/bar' >>> path_store.add_file(u'/foo', u'/baz') >>> path_store.get_real_path(u'/foo') u'/baz' >>> path_store.remove(u'/foo') >>> path_store.get_real_path(u'/foo') u'/bar' >>> path_store.remove(u'/foo') >>> path_store.get_real_path(u'/foo') Traceback (most recent call last): ... FakePathNotFound: /foo Parent directories of virtual files are implicitly created. Once all files and sub-directories of these directories cease to exist, the directories themselves should magically disappear: >>> path_store.add_file(u'/foo/bar', u'/baz') >>> path_store.get_entries(u'/foo') [u'bar'] >>> path_store.remove(u'/foo/bar') >>> path_store.get_entries(u'/foo') Traceback (most recent call last): ... FakePathNotFound: /foo Empty directories are handled differently from other directories in that they must be explicitly created, and that they are transient, which is to say that they cease to exist if they at any point contain entries and those entries are removed via ``remove``. >>> path_store.add_directory(u'/foo') >>> path_store.get_entries(u'/foo') [] >>> path_store.add_file(u'/foo/bar/baz', u'/boink') >>> path_store.get_entries(u'/foo') [u'bar'] >>> path_store.remove(u'/foo/bar/baz') >>> path_store.get_entries(u'/foo') Traceback (most recent call last): ... FakePathNotFound: /foo >>> path_store.add_directory(u'/foo') >>> path_store.get_entries(u'/foo') [] >>> path_store.add_directory(u'/foo/bar') >>> path_store.get_entries(u'/foo') [u'bar'] >>> path_store.get_entries(u'/foo/bar') [] >>> path_store.remove(u'/foo/bar') >>> path_store.get_entries(u'/foo') Traceback (most recent call last): ... FakePathNotFound: /foo Another way of thinking about this is that empty directories exist as end points only in order to support incrementally building longer paths. Once the need for an empty end point subsides, these directories are handled exactly the same as other implicitly-created directories. ``set_meta_data`` is expected to accept and store a single arbitrary, picklable Python object for later retrieval via ``get_meta_data`` (or removal via ``unset_meta_data``). Any stored meta-data should be associated with a fake path and the real path that was most recently added for that fake path. Thus, if multiple real paths are associated with the same fake path, meta-data is set for that fake path, and the most recently added real path is then removed, the meta-data should be removed with it. If meta-data had previously been associated with the fake path and the now-current real path, that meta-data should be associated with the fake path. >>> path_store.add_file(u'/foo', u'/bar') >>> path_store.set_meta_data(u'/foo', u'bink') >>> path_store.get_meta_data(u'/foo') u'bink' >>> path_store.add_file(u'/foo', u'/baz') >>> path_store.set_meta_data(u'/foo', u'bonk') >>> path_store.get_meta_data(u'/foo') u'bonk' >>> path_store.remove(u'/foo') >>> path_store.get_meta_data(u'/foo') u'bink' If the path store is thread safe, it should also override method ``supports_threads`` and return True (possibly only conditionally for the duration of the mount). All paths (both fake and real) are specified as unicode strings exclusively, so implementations don't need to care about character encodings at all, except as a matter of internal storage). Sub-classes are encouraged to define their class-level docstrings as follows in order to test consistency with the assumptions expressed here: # class MyPathStoreImplementation(PathStore): # __doc__ = """ # Documentation for MyPathStoreImplementation. # # >>> path_store = MyPathStoreImplementation() # # """ + PathStore.__doc__ There is also a unit test case that can be sub-classed to more thoroughly test the implementation. See tests/pathstore.py. ''' def add_file(self, real_path, fake_path): ''' Add path mapping ``fake_path`` => ``real_path`` to the path store. Note that multiple real paths can be associated with any given fake path, with the most recently-added real path being returned by ``get_real_path``. See the class docstring for more information. ''' raise NotImplementedError def add_directory(self, fake_path): ''' Create an empty virtual directory by virtual path. Parent directories are implicitly created as for ``add_file``. If the virtual path already exists in the path store, ``PathExists`` should be raised. ''' raise NotImplementedError def remove(self, fake_path, real_path = None): ''' Remove the virtual file or empty virtual directory by virtual path. For virtual files, this amounts to removing the mapping to the most recently added real path from the given fake path. If ``real_path`` is specified, the specific path mapping should be removed, rather than simply removing the most recently added mapping (this is used when a source file disappears from disk). If ``fake_path`` refers to a virtual directory and ``real_path`` is specified, ``IsADirectory`` should be raised. Raise ``PathNotFound`` if no such path exists, or ``DirectoryNotEmpty`` if the path is a non-empty directory. Any meta-data set for this end point should also be removed. ''' raise NotImplementedError def rename(self, old_fake_path, new_fake_path): ''' Rename end point ``old_fake_path`` to ``new_fake_path``, or raise ``NotAnEndPoint`` if ``old_fake_path`` is not an end point (file or empty directory). This is subtly different from calling ``remove(old_fake_path)`` followed by ``add_file(new_fake_path, real_path)`` or ``add_directory(new_fake_path)`` in that ``rename`` should not cause the order of entries returned by ``get_entries`` to change when ``old_fake_path`` and ``new_fake_path`` refer to virtual files within the same virtual directory. Additionally, ``rename`` should always be more efficient than this remove/add pattern. Any meta-data associated with ``old_fake_path`` should be removed. ''' raise NotImplementedError def get_real_path(self, fake_path): ''' Return the most recently added real path associated with virtual path ``fake_path``. Raise ``FakePathNotFound`` if this virtual path is not in the path store. ''' raise NotImplementedError def get_fake_paths(self, real_path): ''' Return the fake paths associated with real path ``real_path``. Raise ``RealPathNotFound`` if no such association exists in the path store. ''' raise NotImplementedError def is_file(self, fake_path): ''' Return True if virtual path ``fake_path`` refers to a virtual file. Return False otherwise, even if ``fake_path`` does not exist in the path store. ''' raise NotImplementedError def is_dir(self, fake_path): ''' Return True if virtual path ``fake_path`` refers to a virtual directory, whether that directory is empty or not. Return False otherwise, even if ``fake_path`` does not exist in the path store. ''' raise NotImplementedError def path_exists(self, fake_path): ''' Return True if ``fake_path`` exists in the path store, independent of whether that path refers to a file or directory (empty or not). Return False otherwise, even if ``fake_path`` does not exist in the path store. ''' raise NotImplementedError def get_entries(self, fake_path): ''' Return the names of all file and directories contained by the virtual directory with virtual path ``fake_path``. The order of these entries should be consistent across multiple calls to ``get_entries``. Raise ``NotADirectory`` if ``fake_path`` refers to a virtual file rather than a virtual directory. Raise ``FakePathNotFound`` if no such fake path exists in the path store. ''' raise NotImplementedError def get_real_subpaths(self, real_path): ''' Return all real sub-paths of ``real_path``, not limited to the most recently added paths. ''' raise NotImplementedError def set_meta_data(self, fake_path, meta_data): ''' Store ``meta_data`` for ``fake_path``. Raise ``PathNotFound`` if ``fake_path`` does not exist. Raise ``NotAnEndPoint`` if ``fake_path`` does not refer to an end point. ''' raise NotImplementedError def get_meta_data(self, fake_path): ''' Get meta-data for ``fake_path``. Raise ``PathNotFound`` if ``fake_path`` does not exist. Raise ``NoMetaDataExists`` if meta-data has not been set for this file. Raise ``NotAnEndPoint`` if ``fake_path`` does not refer to an end point. ''' raise NotImplementedError def unset_meta_data(self, fake_path): ''' Remove meta-data for ``fake_path``. Raise ``PathNotFound`` if ``fake_path`` does not exist. Raise ``NoMetaDataExists`` if meta-data has not been set for this file. Raise ``NotAnEndPoint`` if ``fake_path`` does not refer to an end point. ''' raise NotImplementedError def supports_threads(self): ''' Return True if the path store is thread-safe under current run-time conditions. The result of this call should not vary over the course of a single mount. In most cases, it will unconditionally return True or False to indicate the thread-safety of the specific path store implementation. The default implementation returns False unconditionally. ''' return False ################################################################################ def get_end_points(self, fake_path): if self.is_file(fake_path): return [fake_path] entries = self.get_entries(fake_path) if entries == []: return [fake_path] end_points = [] for entry in entries: entry_path = join_path_abs([fake_path, entry]) end_points.extend(self.get_end_points(entry_path)) return end_points pytagsfs-0.9.2/modules/pytagsfs/metastore/0000755000175000017500000000000011315711421020257 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/metastore/__init__.py0000644000175000017500000000466511315711421022403 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os.path from pytagsfs.exceptions import ErrorWithMessage, InvalidArgument from pytagsfs.util import sorted_items from pytagsfs.values import Values class UnsettableKeyError(ErrorWithMessage): def __init__(self, key): self.key = key ErrorWithMessage.__init__(self, "can't set key %s" % key) class MetaStore(object): def get(self, path): ''' Return a Values instance containing all key/value pairs for ``path``. If path does not exist or no tags can be read from path with this MetaStore implementation, return an empty ``Values`` instance. ''' raise NotImplementedError def set(self, path, values): ''' Set the metadata for ``path`` according to dict ``values``. Return a list of the keys applied. If path does not exist or cannot be used to store tag values using this ``MetaStore`` implementation, an empty list should always be returned to indicate that no tags were stored. For some implementations, nothing may actually get stored, but a non-empty list of keys may be returned to indicate that those keys are "owned" and that the caller should behave as if they had been stored (i.e. other ``MetaStore`` implementations should not handle those tags). ''' raise NotImplementedError class DelegateMultiMetaStore(MetaStore): def __init__(self, meta_stores): self.meta_stores = meta_stores def get(self, path): values = Values() for meta_store in self.meta_stores: try: values.update(meta_store.get(path)) except NotImplementedError: continue return values def set(self, path, values): values = dict(values) keys = [] for meta_store in self.meta_stores: try: new_keys = meta_store.set(path, values) except NotImplementedError: continue for key in new_keys: del values[key] keys.extend(new_keys) return keys pytagsfs-0.9.2/modules/pytagsfs/metastore/mutagen_.py0000644000175000017500000001613311315711421022434 0ustar forestforest# coding: utf-8 # Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import mutagen from mutagen.id3 import ID3FileType from mutagen.easyid3 import EasyID3 from mutagen.mp4 import MP4 from pytagsfs.metastore import MetaStore from pytagsfs.values import Values from pytagsfs.debug import log_info class TranslatedMP4(MP4): ''' Wrapper for mutagen.mp4.MP4 that translates funky MP4 keys to standard keys common with other formats. ''' KEYS = ( (u'©nam'.encode('iso-8859-1'), 'title'), (u'titl'.encode('iso-8859-1'), 'title'), (u'©ART'.encode('iso-8859-1'), 'artist'), (u'arti'.encode('iso-8859-1'), 'artist'), (u'©alb'.encode('iso-8859-1'), 'album'), (u'albu'.encode('iso-8859-1'), 'album'), (u'©wrt'.encode('iso-8859-1'), 'writer'), (u'©day'.encode('iso-8859-1'), 'date'), (u'©gen'.encode('iso-8859-1'), 'genre'), (u'gnre'.encode('iso-8859-1'), 'genre'), (u'©too'.encode('iso-8859-1'), 'tool'), (u'©cmt'.encode('iso-8859-1'), 'comment'), (u'cpil'.encode('iso-8859-1'), 'compilation'), (u'trac'.encode('iso-8859-1'), 'tracknumber'), (u'disk'.encode('iso-8859-1'), 'disc'), (u'covr'.encode('iso-8859-1'), 'cover'), ) def keys(self): ks = super(TranslatedMP4, self).keys() for k_native, k_translated in self.KEYS: if k_translated not in ks: if k_native in ks: ks.append(k_translated) ks.sort() return ks def __getitem__(self, key): # If key is native, return it. If it is translated, return the native # key value. keys = [item[0] for item in self.KEYS if item[1] == key] for k in [key] + keys: try: return super(TranslatedMP4, self).__getitem__(k) except KeyError: pass raise KeyError(key) def __setitem__(self, key, value): # If the key already exists as-is, maintain it: if key in super(TranslatedMP4, self).keys(): super(TranslatedMP4, self).__setitem__(key, value) return # Enforce consistency between tracknumber/trac and trkn if key in ('tracknumber', 'trac'): if 'trkn' in self: int_value = int(value) if int_value > self['trkn'][0][1]: raise ValueError('track number too big') self['trkn'][0] = (int_value, self['trkn'][0][1]) # Enforce consistency between trkn and tracknumber if key == 'trkn': if 'tracknumber' in self: self['tracknumber'] = unicode(value[0]) # Set native keys if this key is one of the known translated keys: found = False for k_native, k_translated in self.KEYS: if k_translated == key: super(TranslatedMP4, self).__setitem__(k_native, value) found = True if found: return # We don't know how to translate this key, so set it directly: super(TranslatedMP4, self).__setitem__(key, value) def __delitem__(self, key): # We actually delete this key and all translated keys known to # correspond with it. keys = [item[0] for item in self.KEYS if item[1] == key] for k in [key] + keys: try: super(TranslatedMP4, self).__delitem__(k) except KeyError: pass raise KeyError(key) def __contains__(self, key): return key in self.keys() def SimpleMutagenFile(filename): f = mutagen.File(filename) if isinstance(f, ID3FileType): f = f.__class__(filename, ID3 = EasyID3) # Odd that this is necessary. Is it a mutagen bug? # http://www.listen-project.org/ticket/714 # http://www.listen-project.org/changeset/841 if f.tags is None: f.tags = EasyID3() elif isinstance(f, MP4): f.__class__ = TranslatedMP4 return f MUTAGEN_FIELD_MAPPING = { 'n': 'tracknumber', 'a': 'artist', 'c': 'composer', 't': 'title', 'l': 'album', 'y': 'date', 'g': 'genre', } def get_field_for_mutagen_field(mutagen_field): for field in MUTAGEN_FIELD_MAPPING: if MUTAGEN_FIELD_MAPPING[field] == mutagen_field: return field raise ValueError('No such mutagen field: %s' % mutagen_field) class _BaseMutagenMetaStore(MetaStore): tags_class = None error_class = None def make_tags_obj(self, path): cls = self.tags_class return cls(path) def get(self, path): try: tags = self.make_tags_obj(path) except self.error_class: tags = None if tags is None: tags = {} return self.extract(tags) def set(self, path, values): tags = self.make_tags_obj(path) log_info(u'set: values=%s', unicode(values)) self.inject(tags, values) log_info(u'set: tags=%s', unicode(dict(tags))) tags.save() return values.keys() @classmethod def extract(cls, tags): values = Values() for field in tags: tag = tags[field] try: values[field] = cls.get_value_from_tag(field, tags[field]) except ValueError: pass for field in MUTAGEN_FIELD_MAPPING: mutagen_field = MUTAGEN_FIELD_MAPPING[field] if tags.get(mutagen_field, False): try: values[field] = cls.get_value_from_tag( mutagen_field, tags[mutagen_field]) except ValueError: pass cls.post_process(values) return values @classmethod def get_value_from_tag(cls, field, tag): if not isinstance(tag, (list, tuple)): log_info( ( u'_BaseMutagenMetaStore.get_value_from_tag: ' u'tag value is not a list, dropping: %r, %r' ), field, tag, ) raise ValueError(tag) return list(tag) @classmethod def post_process(cls, values): if 'n' in values: try: values['n'] = ['%u' % int(v) for v in values['n']] except ValueError: del values['n'] else: values['TRACKNUMBER'] = values['N'] = [ '%02u' % int(v) for v in values['n']] @classmethod def inject(cls, tags, values): for field in values: if field in MUTAGEN_FIELD_MAPPING: mutagen_field = MUTAGEN_FIELD_MAPPING[field] tags[mutagen_field] = values[field] else: tags[field] = values[field] class MutagenFileMetaStore(_BaseMutagenMetaStore): tags_class = staticmethod(SimpleMutagenFile) error_class = Exception pytagsfs-0.9.2/modules/pytagsfs/metastore/testlines.py0000644000175000017500000000600411315711421022643 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import errno from pytagsfs.metastore import MetaStore from pytagsfs.values import Values from pytagsfs.debug import log_loud encoding = 'utf-8' class TestLinesMetaStore(MetaStore): ord_a = ord('a') last_index = 26 def __init__(self): log_loud( 'WARNING: TestLinesMetaStore is for testing and benchmarking only!') log_loud( 'WARNING: It WILL destroy your files. Unmount now to avoid this.') def get(self, path): lines = [] num_lines = 0 try: f = open(path) except (IOError, OSError): pass else: try: content = f.read() finally: f.close() index = content.rfind('\n') header = content[:index] for line in header.split('\n'): try: line = line.decode(encoding) except UnicodeDecodeError: line = '' lines.append(line) num_lines = num_lines + 1 if num_lines >= self.last_index: break keys = [self.index_to_key(index) for index in range(num_lines)] d = dict(zip(keys, lines)) for k in list(iter(d)): if not d[k]: del d[k] return Values.from_flat_dict(d) def set(self, path, values): d = self.get(path).to_flat_dict() d.update(values.to_flat_dict()) indexes = [self.key_to_index(k) for k in d] lines = [] if indexes: max_index = max(indexes) for index in range(max_index + 1): line = d.get(self.index_to_key(index), '').encode(encoding) lines.append(line) try: f = open(path, 'r') except IOError, e: if e.errno != errno.ENOENT: raise content = '' else: try: content = f.read() finally: f.close() index = content.rfind('\n') + 1 data = content[index:] f = open(path, 'w') try: f.write('\n'.join(lines)) f.write('\n') f.write(data) finally: f.close() def index_to_key(self, index): if index < 0: raise ValueError(index) if index > self.last_index: raise ValueError(index) return chr(self.ord_a + index) def key_to_index(self, key): if len(key) != 1: raise ValueError(key) if key < 'a': raise ValueError(key) if key > 'z': raise ValueError(key) return ord(key) - self.ord_a pytagsfs-0.9.2/modules/pytagsfs/metastore/maildir.py0000644000175000017500000000565711315711421022267 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os.path from mailbox import Maildir, ExternalClashError import email.header from pytagsfs.metastore import MetaStore from pytagsfs.values import Values from pytagsfs.util import rpartition from pytagsfs.debug import log_debug TAG_HEADER = 'X-Pytagsfs-Tag' class MaildirMetaStore(MetaStore): def open_mailbox(self, path): mailbox_dir = os.path.dirname(os.path.dirname(path.encode('utf-8'))) return Maildir(mailbox_dir, None) def get_message_key(self, path): return rpartition(os.path.basename(path), u':')[0].encode('utf-8') def parse_tags(self, message): raw_header_values = message.get_all(TAG_HEADER) if raw_header_values is None: return for raw_header_value in raw_header_values: yield self.decode_header(raw_header_value) def decode_header(self, raw_header_value): parts = [] for content, charset in email.header.decode_header(raw_header_value): if charset is None: charset = 'ascii' parts.append(content.decode(charset)) return ''.join(parts) def encode_header(self, value): return email.header.make_header([value.encode('utf-8'), 'utf-8']) def get(self, path): values = Values() message_key = self.get_message_key(path) if message_key: mailbox = self.open_mailbox(path) try: message = mailbox.get_message(message_key) finally: mailbox.close() message_tags = list(self.parse_tags(message)) log_debug( u'MaildirMetaStore.get: %s: %s' % (path, repr(message_tags))) if message_tags: values['maildir_tag'] = message_tags return values def set(self, path, values): message_key = self.get_message_key(path) if not message_key: return [] try: message_tags = values['maildir_tag'] except KeyError: return [] if not message_tags: return [] mailbox = self.open_mailbox(path) try: try: mailbox.lock() except ExternalClashError: return [] try: message = mailbox.get_message(message_key) del message[TAG_HEADER] for message_tag in message_tags: message[TAG_HEADER] = self.encode_header(message_tag) mailbox.update({message_key: message}) finally: mailbox.unlock() finally: mailbox.close() pytagsfs-0.9.2/modules/pytagsfs/metastore/path.py0000644000175000017500000000340211315711421021564 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os.path from pytagsfs.metastore import MetaStore, UnsettableKeyError from pytagsfs.util import sorted_items, unicode_path_sep from pytagsfs.values import Values class PathMetaStore(MetaStore): ''' >>> store = PathMetaStore() >>> path = '/foo/bar.baz' >>> sorted(store.get(path).keys()) ['e', 'extension', 'f', 'filename', 'p', 'parent'] >>> sorted_items(store.get(path)) [('e', 'baz'), ('extension', 'baz'), ('f', 'bar.baz'), ('filename', 'bar.baz'), ('p', 'foo'), ('parent', 'foo')] >>> store.set(path, Values({'f': 'boink.bonk'})) Traceback (most recent call last): ... UnsettableKeyError: can't set key f ''' keys = ('f', 'filename', 'p', 'parent', 'e', 'extension') def get(self, path): path = path.rstrip(unicode_path_sep) filename = os.path.basename(path) parent = os.path.basename(os.path.dirname(path)) extension = os.path.splitext(path)[1][1:] if not extension: extension = None values = Values() if filename: values['f'] = values['filename'] = [filename] if parent: values['p'] = values['parent'] = [parent] if extension: values['e'] = values['extension'] = [extension] return values def set(self, path, values): for key in self.keys: if key in values: raise UnsettableKeyError(key) return [] pytagsfs-0.9.2/modules/pytagsfs/sourcetree.py0000644000175000017500000001060511315711421021010 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, errno from pytagsfs.util import unicode_path_sep from pytagsfs.debug import ( log_debug, log_warning, log_traceback, ) from pytagsfs.multithreading import token_exchange class SourceTree(object): root = None iocharset = None def __init__(self, root, iocharset = 'utf-8'): if not os.path.isabs(root): raise ValueError('root "%s" is not an absolute path' % root) self.root = root self.iocharset = iocharset def _validate_path(self, path): if not path.startswith(unicode_path_sep): raise ValueError(u'%s must start with a %s' % ( repr(path), unicode_path_sep)) if (path != unicode_path_sep) and path.endswith(unicode_path_sep): raise ValueError(u'%s must not end with a %s' % ( repr(path), unicode_path_sep)) def get_relative_path(self, abs_path): self._validate_path(abs_path) if self.root == unicode_path_sep: return abs_path rel_path = abs_path[len(self.root):] if not rel_path: rel_path = unicode_path_sep return rel_path def get_absolute_path(self, rel_path): self._validate_path(rel_path) if rel_path == unicode_path_sep: return self.root abs_path = os.path.join( self.root, rel_path.lstrip(unicode_path_sep) ) return abs_path def walk(self, path = None): if path is None: path = self.root # os.walk seems to want encoded input path = self.encode(path) token_exchange.release_token() try: iterator = os.walk(path) finally: token_exchange.reacquire_token() while True: token_exchange.release_token() try: try: dirpath, dirnames, filenames = iterator.next() except StopIteration: break finally: token_exchange.reacquire_token() dirpath = self.decode(dirpath) dirnames = [self.decode(dirname) for dirname in dirnames] filenames = [self.decode(filename) for filename in filenames] yield (dirpath, dirnames, filenames) def decode(self, path): try: return path.decode(self.iocharset) except UnicodeDecodeError: log_traceback() except UnicodeEncodeError: log_traceback() if type(path) == unicode: log_warning('Warning: tried to decode a unicode string') decoded_path = path.decode(self.iocharset, 'replace') log_debug(u'Decoded path is "%s".', decoded_path) return decoded_path def encode(self, path): try: return path.encode(self.iocharset) except UnicodeEncodeError: log_traceback() except UnicodeDecodeError: log_traceback() if type(path) == str: log_warning('Warning: tried to encode a byte string') encoded_path = path.encode(self.iocharset, 'replace') log_debug(u'Encoded path is "%s".', encoded_path) return encoded_path @token_exchange.token_released def isreadable(self, path): ''' Return True if an attempt to read a byte from the file does not cause an IOError or OSError. ''' try: f = open(self.encode(path), 'r') try: f.read(1) finally: f.close() except (IOError, OSError): return False return True @token_exchange.token_released def issymlink(self, path): ''' Return True if readlink succeeds. ''' try: os.readlink(self.encode(path)) except (IOError, OSError): return False return True @token_exchange.token_released def lstat(self, path): return os.lstat(self.encode(path)) @token_exchange.token_released def utime(self, path, times): return os.utime(self.encode(path), times) pytagsfs-0.9.2/modules/pytagsfs/optgroup.py0000644000175000017500000003045711315711421020516 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import sys from optparse import ( Option, OptionParser, OptionContainer, OptParseError, BadOptionError, HelpFormatter, IndentedHelpFormatter, ) class GroupingOption(Option): ''' An option that establishes a group, i.e. `-o' in `-o foo=bar'. ''' group_parser = None title = None def __init__(self, *args, **kwargs): self.group_parser = kwargs['group_parser'] del kwargs['group_parser'] self.title = kwargs['title'] del kwargs['title'] if 'metavar' not in kwargs: kwargs['metavar'] = 'opt,opt,...' Option.__init__(self, *args, **kwargs) self._check_dest() def take_action(self, action, dest, opt, value, values, parser): self.group_parser.take_grouping_option_action( self, action, dest, opt, value, values, parser) class GroupOption(Option): ''' An option within a group, i.e. `foo' in `-o foo=bar'. ''' group = None def __init__(self, opt, *args, **kwargs): if 'dest' not in kwargs: # Override default dest, which would strip first two characters: kwargs['dest'] = opt.replace('-', '_') self.group = kwargs['group'] del kwargs['group'] Option.__init__(self, opt, *args, **kwargs) # FIXME: Overriding a private method; may be fragile. def _set_opt_strings(self, opts): for opt in opts: if len(opt) < 1: raise OptionError('invalid option string %r: ' % opt, self) else: self._long_opts.append(opt) class GroupingOptionParser(OptionParser): ''' An option parser capable of having grouping options. >>> class NonExitingGroupingOptionParser(GroupingOptionParser): ... def error(self, msg): ... raise OptParseError(msg) >>> p = NonExitingGroupingOptionParser(prog = 'optgroup') >>> o = p.add_group( ... '-o', ... help = "see `Grouped Options' below", ... title = 'Grouped Options' ... ) >>> o = p.add_option( ... 'foo', ... group = '-o', ... help = 'set foo value (default %default)', ... default = 'default_foo', ... ) >>> o = p.add_option( ... 'bar', ... group = '-o', ... action = 'store_true', ... default = False, ... help = 'enable bar', ... ) >>> opts, args = p.parse_args([]) >>> opts.o.foo 'default_foo' >>> opts.o.bar False >>> opts, args = p.parse_args(['boink']) >>> opts.o.foo 'default_foo' >>> opts.o.bar False >>> args ['boink'] >>> opts, args = p.parse_args(['-o', 'foo=boink']) >>> opts.o.foo 'boink' >>> opts, args = p.parse_args(['-o', 'foo']) Traceback (most recent call last): ... OptParseError: option foo requires an argument >>> opts, args = p.parse_args(['-o', 'foo', 'boink']) Traceback (most recent call last): ... OptParseError: option foo requires an argument >>> opts, args = p.parse_args(['-o', 'foo,bar']) Traceback (most recent call last): ... OptParseError: option foo requires an argument ''' # Python 2.5's OptionParser module introduced some new formatting (note # capitilization), so we have to test conditionally: if sys.version_info[0:2] >= (2, 5): __doc__ = __doc__ + ''' >>> print p.format_help() Usage: optgroup [options] Options: -h, --help show this help message and exit -o opt,opt,... see `Grouped Options' below Grouped Options: foo=FOO set foo value (default default_foo) bar enable bar ''' else: __doc__ = __doc__ + ''' >>> print p.format_help() usage: optgroup [options] options: -h, --help show this help message and exit -o opt,opt,... see `Grouped Options' below Grouped Options: foo=FOO set foo value (default default_foo) bar enable bar ''' groups = None group_args = None def __init__(self, *args, **kwargs): self.groups = {} if 'formatter' not in kwargs: kwargs['formatter'] = IndentedGroupingOptionHelpFormatter() OptionParser.__init__(self, *args, **kwargs) def parse_args(self, *args, **kwargs): self.group_args = {} for group in self.groups: self.group_args[group] = [] values, final_args = OptionParser.parse_args(self, *args, **kwargs) for group, args in self.group_args.items(): # Make a copy of args because it will be modified by the following # call and we want to save self.group_args so the caller can get # information about what command-line options were used. args = list(args) group_values, group_args = self.groups[group].parse_args(args) assert not group_args setattr( values, self.groups[group].grouping_option.dest, group_values) return values, final_args def add_group(self, group, **kwargs): assert 'type' not in kwargs self.groups[group] = OptionGroupParser(parent_parser = self) kwargs['type'] = 'str' kwargs['group_parser'] = self.groups[group] option = GroupingOption(group, **kwargs) self.groups[group].grouping_option = option return OptionParser.add_option(self, option) def add_option(self, *args, **kwargs): if isinstance(args[0], GroupingOption): raise OptParseError('use add_group to add GroupingOptions') try: group = kwargs['group'] except KeyError: return OptionParser.add_option(self, *args, **kwargs) opt_str = args[0] if group not in self.groups: raise OptParseError( 'GroupingOption must be added before GroupOptions can be') option = GroupOption(opt_str, **kwargs) option = self.groups[group].add_option(option) return option def take_grouping_option_action( self, option, action, dest, opt, value, values, parser): if value is None: raise ValueError('value must not be None') self.group_args[opt].append(value) def format_option_help(self, formatter = None): if formatter is None: formatter = self.formatter help_sections = [ OptionParser.format_option_help(self, formatter = formatter)] for group in self.groups: old_parser = formatter.parser formatter.set_parser(self.groups[group]) try: help_sections.append( self.groups[group].format_option_help(formatter = formatter)) finally: formatter.set_parser(old_parser) return '\n'.join(help_sections) class OptionGroupParser(OptionParser): ''' An option parser that parses group options for a single grouping option. ''' parent_parser = None grouping_option = None def __init__(self, *args, **kwargs): self.parent_parser = kwargs['parent_parser'] del kwargs['parent_parser'] kwargs['add_help_option'] = False OptionParser.__init__(self, *args, **kwargs) def error(self, msg): return self.parent_parser.error(msg) def parse_args(self, args, values = None): if values is None: values = self.get_default_values() self.values = values # We're deliberately not handling exceptions here: stop = self._process_args(args, values) # We never have args left over, so pass [] as args: return self.check_values(values, []) def _process_args(self, args, values): while args: self._process_long_opt(args, values) def _process_long_opt(self, args, values): for arg in args.pop(0).split(','): try: opt, value = arg.split('=') except ValueError: opt, value = arg, None try: option = self._long_opt[opt] except KeyError: raise BadOptionError(opt) if option.takes_value(): if option.nargs != 1: raise OptParseError( 'grouped options must only take a single argument') if value is None: self.error('option %s requires an argument' % opt) option.process(opt, value, values, self) # FIXME: Overriding a private method; may be fragile. def _check_conflict(self, option): conflict_opts = [] for opt in option._short_opts: if self._short_opt.has_key(opt): conflict_opts.append((opt, self._short_opt[opt])) for opt in option._long_opts: if self._long_opt.has_key(opt): conflict_opts.append((opt, self._long_opt[opt])) if conflict_opts: handler = self.conflict_handler if handler == "error": raise OptionConflictError( "conflicting option string(s): %s" % ", ".join([co[0] for co in conflict_opts]), option) elif handler == "resolve": for (opt, c_option) in conflict_opts: # This is the part where we differ from the method being # overridden. We do this because our options don't start # with "--", so we have to force the use of _long_opts. c_option._long_opts.remove(opt) del self._long_opt[opt] if not (c_option._short_opts or c_option._long_opts): c_option.container.option_list.remove(c_option) def take_grouping_option_action( self, option, action, dest, opt, value, values, parser): self.parent_parser.take_grouping_option_action( option, action, dest, opt, value, values, parser) def format_option_help(self, formatter = None): if formatter is None: formatter = self.formatter formatter.store_option_strings(self) result = [] result.append(formatter.format_heading(self.grouping_option.title)) formatter.indent() if self.option_list: result.append(OptionContainer.format_option_help(self, formatter)) result.append("\n") for group in self.option_groups: result.append(group.format_help(formatter)) result.append("\n") formatter.dedent() # Drop the last "\n", or the header if no options or option groups: return "".join(result[:-1]) class GroupingOptionHelpFormatter(HelpFormatter): def __init__(self, *args, **kwargs): HelpFormatter.__init__(self, *args, **kwargs) self.help_position = 0 def format_option_strings(self, option): if isinstance(option, GroupOption): if option.takes_value(): metavar = option.metavar or option.dest.upper() return '%s=%s' % ( option._long_opts[0], metavar, ) else: return option._long_opts[0] else: return HelpFormatter.format_option_strings(self, option) def store_option_strings(self, parser): old_help_position = self.help_position HelpFormatter.store_option_strings(self, parser) new_help_position = self.help_position if new_help_position < old_help_position: self.help_position = old_help_position class IndentedGroupingOptionHelpFormatter( IndentedHelpFormatter, GroupingOptionHelpFormatter): def __init__(self, *args, **kwargs): IndentedHelpFormatter.__init__(self, *args, **kwargs) self.help_position = 0 format_option_strings = GroupingOptionHelpFormatter.format_option_strings store_option_strings = GroupingOptionHelpFormatter.store_option_strings pytagsfs-0.9.2/modules/pytagsfs/exceptions.py0000644000175000017500000000354411315711421021015 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. class Error(Exception): pass class FuseError(Error): errno = None def __init__(self, errno): self.errno = errno class ErrorSupportingUnicode(Error): def __str__(self): return str(unicode(self)) class ErrorWithMessage(ErrorSupportingUnicode): def __init__(self, msg): self.msg = msg def __unicode__(self): return unicode(self.msg) class PathError(Error): def __init__(self, path = None): self.path = path Error.__init__(self, path) def __str__(self): return str(unicode(self)) def __unicode__(self): if self.path: return unicode(self.path) return u'[unknown path]' def __repr__(self): return '%s(%s)' % (self.__class__.__name__, repr(self.path)) class PathNotFound(PathError): pass class FakePathNotFound(PathNotFound): pass class RealPathNotFound(PathNotFound): pass class NotADirectory(PathError): pass class IsADirectory(PathError): pass class PathExists(PathError): pass class DirectoryNotEmpty(PathError): pass class NoMetaDataExists(PathError): pass class NotAnEndPoint(PathError): pass class UnrepresentablePath(ErrorWithMessage): pass class InvalidArgument(Error): pass class ComponentError(ErrorWithMessage): pass class MissingDependency(ComponentError): def __init__(self, dependency): self.dependency = dependency def __unicode__(self): return u'missing dependency %s' % unicode(self.dependency) pytagsfs-0.9.2/modules/pytagsfs/profiling.py0000644000175000017500000000233111315711421020616 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import time from pytagsfs.specialfile.logfile import VirtualLogFile from pytagsfs.debug import log_critical, log_info from pytagsfs.util import wraps, join_path_abs _profiling_enabled = False def enable_profiling(): log_info('enabling profiling; times are in ms') global _profiling_enabled _profiling_enabled = True def disable_profiling(): log_info('disabling profiling') global _profiling_enabled _profiling_enabled = False def profile(fn, *args, **kwargs): start = int(1000.0 * time.time()) try: return fn(*args, **kwargs) finally: duration = int(1000.0 * time.time()) - start log_critical(u'PROF %s %s', duration, fn.__name__) def profiled(fn): @wraps(fn) def wrapped(*args, **kwargs): if not _profiling_enabled: return fn(*args, **kwargs) return profile(fn, *args, **kwargs) return wrapped pytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/0000755000175000017500000000000011315711421021146 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/kqueue_.py0000644000175000017500000002347211315711421023166 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, stat from pytagsfs.util import ref_self from pytagsfs.sourcetreemon import SourceTreeMonitor from pytagsfs.sourcetreemon.deferred import DeferredSourceTreeMonitor from pytagsfs.debug import log_debug from pytagsfs.exceptions import MissingDependency from pytagsfs.multithreading import token_exchange ################################################################################ ADD = object() REMOVE = object() UPDATE = object() class KqueueException(Exception): pass class NotWatching(KqueueException): pass class AlreadyWatching(KqueueException): pass class KqueueEvent(object): path = None type = None is_dir = None kevent = None def __init__(self, path, type, is_dir, kevent): self.path = path self.type = type self.is_dir = is_dir self.kevent = kevent class KqueueManager(object): kqueue = None directory_entries = None paths = None base_kevents = None def __init__(self, kqueue_mod): self.kqueue_mod = kqueue_mod self.kqueue = self.kqueue_mod.kqueue() self.directory_entries = {} self.paths = {} self.base_kevents = {} @token_exchange.token_pushed(ref_self) def watch_directory(self, path): if path in self.paths.values(): raise AlreadyWatching(path) try: fd = os.open(path, 0) except (IOError, OSError): return mode = os.fstat(fd)[stat.ST_MODE] if not stat.S_ISDIR(mode): return base_kevent = self.kqueue_mod.EV_SET( fd, self.kqueue_mod.EVFILT_VNODE, ( self.kqueue_mod.EV_ADD | self.kqueue_mod.EV_ENABLE | self.kqueue_mod.EV_CLEAR ), self.kqueue_mod.NOTE_WRITE, ) self.kqueue.kevent(base_kevent, 0, 0) try: entries = os.listdir(path) except (IOError, OSError): self.unwatch_dir(path) self.paths[fd] = path self.base_kevents[fd] = base_kevent self.directory_entries[path] = entries for entry in entries: entry_path = os.path.join(path, entry) try: self.watch_path(entry_path) except (OSError, KqueueException): pass @token_exchange.token_pushed(ref_self) def watch_file(self, path): if path in self.paths.values(): raise AlreadyWatching(path) try: fd = os.open(path, 0) except (IOError, OSError): return mode = os.fstat(fd)[stat.ST_MODE] if not stat.S_ISREG(mode): return base_kevent = self.kqueue_mod.EV_SET( fd, self.kqueue_mod.EVFILT_VNODE, ( self.kqueue_mod.EV_ADD | self.kqueue_mod.EV_ENABLE | self.kqueue_mod.EV_CLEAR ), ( self.kqueue_mod.NOTE_WRITE | self.kqueue_mod.NOTE_ATTRIB | self.kqueue_mod.NOTE_EXTEND | self.kqueue_mod.NOTE_DELETE ), ) self.kqueue.kevent(base_kevent, 0, 0) self.paths[fd] = path self.base_kevents[fd] = base_kevent def watch_path(self, path): self.watch_directory(path) self.watch_file(path) @token_exchange.token_pushed(ref_self) def stop_watch(self, path): if path not in self.paths.values(): raise NotWatching(path) for fd, path_ in self.paths.items(): if path_ == path: del self.paths[fd] try: del self.directory_entries[path] except KeyError: pass del self.base_kevents[fd] os.close(fd) @token_exchange.token_pushed(ref_self) def get_events(self): kevents = self.kqueue.kevent(None, 1024, 0) for kevent in kevents: try: path = self.paths[kevent.ident] except KeyError: log_debug( 'KqueueManager.get_events: unable to find path for fd %u', kevent.ident ) continue if self.is_dir(path): try: new_entries = os.listdir(path) except (IOError, OSError): # Directory corresponding with path must've been removed. # We'll treat it like an empty directory for now. We # should eventually get a remove event from the parent # directory. new_entries = [] old_entries = self.directory_entries[path] self.directory_entries[path] = new_entries new_entries_set = set(new_entries) old_entries_set = set(old_entries) added_entries = new_entries_set - old_entries_set removed_entries = old_entries_set - new_entries_set for entry in added_entries: added_path = os.path.join(path, entry) yield KqueueEvent( os.path.join(path, entry), ADD, None, kevent) for entry in removed_entries: yield KqueueEvent( os.path.join(path, entry), REMOVE, None, kevent) else: if kevent.fflags & self.kqueue_mod.NOTE_DELETE: parent_path = os.path.dirname(path) entry = os.path.basename(path) # Parent directory path *must* be in # self.directory_entries. No need to catch the KeyError, # because it is a bug if it is not a valid key. known_entry = (entry in self.directory_entries[parent_path]) if known_entry: # If the file was deleted but it is still in our local # database of entries, it must be that it was # immediately replaced following removal. Directory # events are handled such that this situation will not # generate events there, so we have to force the events # here. self.stop_watch(path) self.watch_file(path) # It is unnecessary to provide a remove event in this # case. #yield KqueueEvent(path, REMOVE, False, None) yield KqueueEvent(path, ADD, False, None) else: # File was removed and not replaced. This will come up # as an event for the parent directory, so we need not # handle it here. pass else: # All fflags except NOTE_DELETE indicate a plain old update. yield KqueueEvent(path, UPDATE, False, kevent) def is_dir(self, path): return (path in self.directory_entries) @token_exchange.token_pushed(ref_self) def stop(self): for path in self.paths.values(): self.stop_watch(path) ################################################################################ class KqueueSourceTreeMonitor(SourceTreeMonitor): kqueue_manager = None def __init__(self): try: import kqueue except ImportError: raise MissingDependency('kqueue') self.kqueue = kqueue ################################################################################ # SourceTreeMonitor API def start(self, debug = False): self.kqueue_manager = KqueueManager(self.kqueue) def stop(self): self.kqueue_manager.stop() def supports_threads(self): return True def supports_writes(self): return True def can_handle_fork(self): return False def add_source_dir(self, real_path): self.watch_dir(real_path) def remove_source_dir(self, real_path): self.unwatch_dir(real_path) def add_source_file(self, real_path): self.watch_file(real_path) def remove_source_file(self, real_path): self.unwatch_file(real_path) def fileno(self): return self.kqueue_manager.kqueue.fileno() def _get_events(self): return self.kqueue_manager.get_events() def process_events(self): for event in self._get_events(): if event.type is ADD: self.add_cb(event.path, event.is_dir) elif event.type is REMOVE: self.remove_cb(event.path, event.is_dir) elif event.type is UPDATE: self.update_cb(event.path, event.is_dir) ################################################################################ def _unwatch_path(self, real_path): try: self.kqueue_manager.stop_watch(real_path) except NotWatching: pass def watch_dir(self, real_path): try: self.kqueue_manager.watch_directory(real_path) except AlreadyWatching: return unwatch_dir = _unwatch_path def watch_file(self, real_path): try: self.kqueue_manager.watch_file(real_path) except AlreadyWatching: return unwatch_file = _unwatch_path ################################################################################ class DeferredKqueueSourceTreeMonitor( DeferredSourceTreeMonitor, KqueueSourceTreeMonitor, ): pass pytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/dummy.py0000644000175000017500000000160311315711421022653 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from pytagsfs.sourcetreemon import SourceTreeMonitor class DummySourceTreeMonitor(SourceTreeMonitor): def start(self, debug = False): pass def stop(self): pass def process_events(self): pass def add_source_dir(self, real_path): pass def remove_source_dir(self, real_path): pass def add_source_file(self, real_path): pass def remove_source_file(self, real_path): pass def supports_threads(self): return True def can_handle_fork(self): return True pytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/__init__.py0000644000175000017500000000700711315711421023263 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. SOURCE_TREE_MONITORS = ( 'pytagsfs.sourcetreemon.inotifyx_.DeferredInotifyxSourceTreeMonitor', 'pytagsfs.sourcetreemon.gamin_.DeferredGaminSourceTreeMonitor', 'pytagsfs.sourcetreemon.kqueue_.DeferredKqueueSourceTreeMonitor', 'pytagsfs.sourcetreemon.dummy.DummySourceTreeMonitor', ) def get_source_tree_monitor(dotted_name): from pytagsfs.util import get_obj_by_dotted_name source_tree_mon_cls = get_obj_by_dotted_name(dotted_name) return source_tree_mon_cls() class SourceTreeMonitor(object): add_cb = lambda *args, **kwargs: None remove_cb = lambda *args, **kwargs: None update_cb = lambda *args, **kwargs: None def __init__(self): '''Initialize.''' def set_add_cb(self, add_cb): self.add_cb = add_cb def set_remove_cb(self, remove_cb): self.remove_cb = remove_cb def set_update_cb(self, update_cb): self.update_cb = update_cb def start(self, debug = False): '''Start monitoring the source tree.''' def stop(self): '''Stop monitoring the source tree; clean up.''' def fileno(self): ''' Return a file descriptor that can be used to poll for new events. If unsupported, raise NotImplementedError; this is the default behavior, so this method can be left unimplemented. ''' def process_events(self): '''Process pending events. Do not block.''' def add_source_dir(self, real_path): ''' Monitor source directory ``real_path``. Fail silently if: * path does not exist * path exists but is not a directory * path exists but cannot be monitored (perhaps due to permissions) * path is already being watched ''' def remove_source_dir(self, real_path): ''' Stop monitoring source directory ``real_path``. Fail silently if directory was not previously being monitored. ''' def add_source_file(self, real_path): ''' Monitor source file ``real_path``. Fail silently if: * path does not exist * path exists but is not a regular file * path exists but cannot be monitored (perhaps due to permissions) * path is already being watched ''' def remove_source_file(self, real_path): ''' Stop monitor source file ``real_path``. Fail silently if file was not previously being monitored. ''' def supports_threads(self): ''' Return True if source tree monitor is thread-safe. The default implementation always returns False. ''' return False def supports_writes(self): ''' Return True if source tree monitor supports updates due to writing in mount tree. The default implementation always returns False. ''' return False def can_handle_fork(self): ''' Return True if the source tree monitor can survive a fork call after the start method has been called. Otherwise, return False to indicate that start should not be called until after the filesystem process is forked. The default implementation always returns False. ''' return False pytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/gamin_.py0000644000175000017500000001223511315711421022755 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os from pytagsfs.util import ref_self from pytagsfs.sourcetreemon import SourceTreeMonitor from pytagsfs.sourcetreemon.deferred import DeferredSourceTreeMonitor from pytagsfs.debug import log_critical from pytagsfs.exceptions import MissingDependency from pytagsfs.multithreading import token_exchange, GLOBAL ################################################################################ class GaminSourceTreeMonitor(SourceTreeMonitor): watch_monitor = None def __init__(self): try: import gamin except ImportError: raise MissingDependency('gamin') self.gamin = gamin self.event_processors = { gamin.GAMChanged: 'process_changed', gamin.GAMDeleted: 'process_deleted', gamin.GAMStartExecuting: 'process_ignored', gamin.GAMStopExecuting: 'process_ignored', gamin.GAMCreated: 'process_created', gamin.GAMMoved: 'process_deleted', gamin.GAMAcknowledge: 'process_ignored', gamin.GAMExists: 'process_unexpected', gamin.GAMEndExist: 'process_unexpected', } ################################################################################ # SourceTreeMonitor API def start(self, debug = False): self.watch_monitor = self.gamin.WatchMonitor() self.watch_monitor.no_exists() @token_exchange.token_pushed(ref_self) def stop(self): for real_path in self.watch_monitor.objects: self.watch_monitor.stop_watch(real_path) def supports_threads(self): return True def supports_writes(self): return True def can_handle_fork(self): return True def add_source_dir(self, real_path): self.watch_dir(real_path) def remove_source_dir(self, real_path): self.unwatch_dir(real_path) def add_source_file(self, real_path): pass def remove_source_file(self, real_path): pass def fileno(self): return self.watch_monitor.get_fd() @token_exchange.token_pushed(ref_self) def process_events(self): return self.watch_monitor.handle_events() ################################################################################ @token_exchange.token_pushed(ref_self) def watch_dir(self, real_path): if real_path in self.watch_monitor.objects: # already watching return try: self.watch_monitor.watch_directory( real_path, self.event_callback, real_path, ) except self.gamin.GaminException: pass @token_exchange.token_pushed(ref_self) def unwatch_dir(self, real_path): if real_path not in self.watch_monitor.objects: return try: self.watch_monitor.stop_watch(real_path) except self.gamin.GaminException: pass def process_changed(self, real_path): if real_path.endswith(os.path.sep): # FIXME: Is log_critical necessary here? log_critical( u'GaminSourceTreeMonitor.process_changed: ignoring %s', real_path, ) return return self.update_cb(real_path) def process_deleted(self, real_path): if real_path.endswith(os.path.sep): # FIXME: Is log_critical necessary here? log_critical( u'GaminSourceTreeMonitor.process_deleted: ignoring %s', real_path, ) return return self.remove_cb(real_path) def process_ignored(self, real_path): pass def process_created(self, real_path): if real_path.endswith(os.path.sep): # FIXME: Is log_critical necessary here? log_critical( u'GaminSourceTreeMonitor.process_created: ignoring %s', real_path, ) return return self.add_cb(real_path) def process_unexpected(self, real_path): # FIXME: Is log_critical necessary here? log_critical( u'GaminSourceTreeMonitor.process_unexpected: %s', real_path, ) # process_events executes with token identified by self and eventually # calls this callback function. At this point, we no longer need that # token, but we must reacquire the global token before calling update_cb, # add_cb, or remove_cb. This is the best place to do that because we are # certain of context here. @token_exchange.token_pushed(GLOBAL) def event_callback(self, entry, kind, watch_path): real_path = os.path.join(watch_path, entry) return getattr(self, self.event_processors[kind])(real_path) ################################################################################ class DeferredGaminSourceTreeMonitor( DeferredSourceTreeMonitor, GaminSourceTreeMonitor): pass pytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/inotifyx_.py0000644000175000017500000001226311315711421023534 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, errno from pytagsfs.util import ref_self from pytagsfs.sourcetreemon import SourceTreeMonitor from pytagsfs.sourcetreemon.deferred import DeferredSourceTreeMonitor from pytagsfs.exceptions import MissingDependency from pytagsfs.debug import log_warning, log_critical from pytagsfs.multithreading import token_exchange class InotifyxSourceTreeMonitor(SourceTreeMonitor): wd_to_path = None path_to_wd = None fd = None def __init__(self): try: import inotifyx except ImportError: raise MissingDependency('inotifyx') self.inotifyx = inotifyx self.event_mask = ( inotifyx.IN_DELETE | inotifyx.IN_CREATE | inotifyx.IN_MOVED_FROM | inotifyx.IN_MOVED_TO | inotifyx.IN_MODIFY | inotifyx.IN_ATTRIB ) self.wd_to_path = {} self.path_to_wd = {} def start(self, debug = False): self.fd = self.inotifyx.init() @token_exchange.token_pushed(ref_self) def watch_dir(self, real_path): if real_path in self.path_to_wd: # already watching return wd = self.inotifyx.add_watch(self.fd, real_path, self.event_mask) # FIXME: What happens if inotifyx has an error? if wd > 0: # watch successful self.path_to_wd[real_path] = wd self.wd_to_path[wd] = real_path else: # watch unsuccessful, clean up self._rm_watch(wd) @token_exchange.token_pushed(ref_self) def unwatch_dir(self, real_path): try: wd = self.path_to_wd[real_path] except KeyError: # not watching return self._rm_watch(wd) del self.path_to_wd[real_path] del self.wd_to_path[wd] def _rm_watch(self, wd): try: self.inotifyx.rm_watch(self.fd, wd) except IOError, e: if e.errno != errno.EINVAL: raise ### SourceTreeMonitor API: @token_exchange.token_pushed(ref_self) def stop(self): os.close(self.fd) def add_source_dir(self, real_path): self.watch_dir(real_path) def remove_source_dir(self, real_path): self.unwatch_dir(real_path) def add_source_file(self, real_path): pass def remove_source_file(self, real_path): pass def supports_threads(self): return True def supports_writes(self): return True def can_handle_fork(self): return True def fileno(self): return self.fd def _process_event(self, event): try: basepath = self.wd_to_path[event.wd] except KeyError: # We got an event for a path that we are no longer watching. If # the event is IN_IGNORED, this is expected since we get IN_IGNORED # when we remove the watch, which happens after the directory is # removed. Otherwise, the event is late, which won't usually # happen for other event types, but could if paths were rapidly # added and removed. if not (event.mask & self.inotifyx.IN_IGNORED): log_warning( 'InotifyxSourceTreeMonitor: late event: %s, %r', event, event, ) return if event.name: path = os.path.join(basepath, event.name) else: path = basepath is_dir = bool(event.mask & self.inotifyx.IN_ISDIR) if event.mask & self.inotifyx.IN_DELETE: self.remove_cb(path, is_dir) elif event.mask & self.inotifyx.IN_CREATE: self.add_cb(path, is_dir) elif event.mask & self.inotifyx.IN_MOVED_FROM: self.remove_cb(path, is_dir) elif event.mask & self.inotifyx.IN_MOVED_TO: self.add_cb(path, is_dir) elif event.mask & self.inotifyx.IN_MODIFY: self.update_cb(path, is_dir) elif event.mask & self.inotifyx.IN_ATTRIB: self.update_cb(path, is_dir) elif event.mask & self.inotifyx.IN_UNMOUNT: self.remove_cb(path, is_dir) elif event.mask & self.inotifyx.IN_IGNORED: pass elif event.mask & self.inotifyx.IN_Q_OVERFLOW: log_critical( 'InotifyxSourceTreeMonitor: ' 'event queue overflowed, events were probably lost' ) else: raise ValueError( 'failed to match event mask: %s' % event.get_mask_description() ) @token_exchange.token_pushed(ref_self) def _get_events(self): return self.inotifyx.get_events(self.fd, 0) def process_events(self): for event in self._get_events(): self._process_event(event) class DeferredInotifyxSourceTreeMonitor( DeferredSourceTreeMonitor, InotifyxSourceTreeMonitor): pass pytagsfs-0.9.2/modules/pytagsfs/sourcetreemon/deferred.py0000644000175000017500000000525611315711421023310 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from pytagsfs.sourcetreemon import SourceTreeMonitor ADD = 'ADD' REMOVE = 'REMOVE' UPDATE = 'UPDATE' class DeferredSourceTreeMonitor(SourceTreeMonitor): event_queue = None orig_add_cb = None orig_remove_cb = None orig_update_cb = None def __init__(self): super(DeferredSourceTreeMonitor, self).__init__() self.event_queue = [] def set_add_cb(self, add_cb): self.orig_add_cb = add_cb super(DeferredSourceTreeMonitor, self).set_add_cb(self.dstm_add_cb) def set_remove_cb(self, remove_cb): self.orig_remove_cb = remove_cb super(DeferredSourceTreeMonitor, self).set_remove_cb( self.dstm_remove_cb) def set_update_cb(self, update_cb): self.orig_update_cb = update_cb super(DeferredSourceTreeMonitor, self).set_update_cb( self.dstm_update_cb) def dstm_add_cb(self, path, *args): self.event_queue.append((ADD, path) + args) def dstm_remove_cb(self, path, *args): self.event_queue.append((REMOVE, path) + args) def dstm_update_cb(self, path, *args): # Look for the last event for this path. Update events can be collapsed # together, since more than one update can be handled no differently # than a single update. for event in reversed(self.event_queue): if event[1] == path: if event[0] == UPDATE: # Last event for this path was an update event, no need for # another one (they can be collapsed together). return else: # Last event for this path was *not* an update event, so we # need to record this one. break self.event_queue.append((UPDATE, path) + args) def finish_processing(self): while self.event_queue: event = self.event_queue.pop(0) if event[0] == ADD: self.orig_add_cb(*(event[1:])) elif event[0] == REMOVE: self.orig_remove_cb(*(event[1:])) elif event[0] == UPDATE: self.orig_update_cb(*(event[1:])) else: raise ValueError('unknown action %s' % str(event[0])) def process_events(self): super(DeferredSourceTreeMonitor, self).process_events() self.finish_processing() pytagsfs-0.9.2/modules/pytagsfs/sourcetreerep/0000755000175000017500000000000011315711421021143 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/sourcetreerep/pollinline.py0000644000175000017500000000222011315711421023656 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps from pytagsfs.sourcetreerep import SourceTreeRepresentation def process_events_before_calling(wrapped): @wraps(wrapped) def wrapper(self, *args, **kwargs): self.monitor.process_events() return wrapped(self, *args, **kwargs) return wrapper def process_events_after_calling(wrapped): @wraps(wrapped) def wrapper(self, *args, **kwargs): retval = wrapped(self, *args, **kwargs) self.monitor.process_events() return retval return wrapper class PollInLineSourceTreeRepresentation(SourceTreeRepresentation): populate = process_events_after_calling(SourceTreeRepresentation.populate) getattr = process_events_before_calling(SourceTreeRepresentation.getattr) pytagsfs-0.9.2/modules/pytagsfs/sourcetreerep/__init__.py0000644000175000017500000006732711315711421023273 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, re, stat from itertools import chain from pytagsfs.metastore import UnsettableKeyError from pytagsfs.exceptions import ( IsADirectory, PathNotFound, InvalidArgument, UnrepresentablePath, ) from pytagsfs.util import ( split_path, join_path_abs, unicode_path_sep, ) from pytagsfs.values import Values from pytagsfs.subspat import Error as PatternError from pytagsfs.debug import ( log_debug, log_info, log_error, log_traceback, ) def _make_filter(expr, real): if real: get_arg = lambda args: args[0] else: get_arg = lambda args: args[1] if expr.startswith('!'): trans_result = lambda x: not x regex = re.compile(expr[1:]) else: trans_result = lambda x: x regex = re.compile(expr) def filtr(*args): return trans_result(regex.search(get_arg(args))) return filtr STAT = object() ENTRIES = object() class SourceTreeRepresentation(object): meta_store = None substitution_patterns = None path_store = None source_tree = None monitor = None cache = None filters = None def __init__( self, meta_store, substitution_patterns, path_store, source_tree, monitor, cache = None, filters = (), debug = False, ): for substitution_pattern in substitution_patterns: if substitution_pattern.expression == '': raise ValueError('substitution pattern string cannot be empty') self.debug = debug self.meta_store = meta_store self.substitution_patterns = substitution_patterns self.path_store = path_store self.source_tree = source_tree self.monitor = monitor self.monitor.add_cb = self.add_cb self.monitor.remove_cb = self.remove_cb self.monitor.update_cb = self.update_cb self.cache = cache self.filters = [] for expr, real in filters: self.add_filter(expr, real) def start(self): self.monitor.start(debug = self.debug) self.populate() def stop(self): self.monitor.stop() def populate(self): log_info('populating source tree representation...') self.add_source_dir(self.source_tree.root) ################################################################################ def validate_source_path(self, real_path): self.validate_path(real_path) def validate_fake_path(self, fake_path): self.validate_path(fake_path) def validate_path(self, path): if type(path) is not unicode: raise AssertionError( u'path object %s is not a unicode string' % repr(path)) if not path.startswith(unicode_path_sep): raise AssertionError( u'path %s does not start with "%s"' % ( repr(path), unicode_path_sep)) if path.endswith(unicode_path_sep) and (path != unicode_path_sep): raise AssertionError( u'path %s ends with "%s"' % (repr(path), unicode_path_sep)) def fill_path(self, substitutions): log_debug(u'fill_path: substitutions = %r', substitutions) if isinstance(substitutions, Values): raise TypeError('substitutions must not be Values instance') fake_path_parts = [] for substitution_pattern in self.substitution_patterns: try: fake_path_part = substitution_pattern.fill(substitutions) except PatternError, e: raise UnrepresentablePath(unicode(e)) if fake_path_part == '': # This is potentially caused by a bad format string. We # need to handle it here because it could be caused by a # format string directory segment that is a single # conditional expression (and that is valid). If it is # caused by a segment that is empty ("//"), it is better to # handle the problem at initialization time by rejecting # the format string. raise UnrepresentablePath( u'fake path would have a path segment with length zero') if unicode_path_sep in fake_path_part: # The tag value has a slash in it. Proceeding would result # in a fake path that has too many levels of directories. raise UnrepresentablePath( u'fake path would have a path segment with a slash') fake_path_parts.append(fake_path_part) return join_path_abs(fake_path_parts) def add_source_dir(self, real_path): ''' Recursively add source directory ``real_path`` to the source tree representation. Fail silently if: * Path corresponds with a file that is not a directory. * Directory does not exist. If a directory with the same real path already exists in the source tree representation, it will be silently removed from the representation before the add operation is executed. ''' try: self.remove_source_dir(real_path) except PathNotFound: pass self.monitor.add_source_dir(self.source_tree.encode(real_path)) for dirpath, dirnames, filenames in self.source_tree.walk(real_path): if dirpath != real_path: break for dirname in dirnames: real_path = os.path.join(dirpath, dirname) self.add_source_dir(real_path) for filename in filenames: real_path = os.path.join(dirpath, filename) self.add_source_file(real_path) def remove_source_dir(self, real_path): ''' Recursively remove source directory ``real_path`` from the source tree representation. Do nothing if: * ``real_path`` was never added to the source tree representation. ''' for real_subpath in self.path_store.get_real_subpaths(real_path): self.remove_source_file(real_subpath) self.monitor.remove_source_dir(self.source_tree.encode(real_path)) def add_source_file(self, real_path): ''' Add source file ``real_path`` to the source tree representation. Do nothing if: * The file does not exist. * The target file is a directory. ''' # We want to filter out unreadable files and symlinks. These checks # are racey, of course. A symlink could be removed and replaced with # a real file immediately after our check. Likewise, a file that is # unreadable because of permissions could have its mode changed. # However, in either of these cases a new source tree monitor event # will be received and another attempt to add the source file will # be made. Thus, there is no serious consequence. # Note that if all MetaStore implementations pulled metadata from file # contents, the isreadable check would be unnecessary. But some # (PathMetaStore, for instance) do not read the source file to obtain # metadata. # Also note that if we handled symlinks correctly everywhere (in # getattr, populate, and in SourceTreeMonitor implementations), the # issymlink check could be dropped. Since we don't currently handle # them correctly, though, it is best to simply ignore them. if not self.source_tree.isreadable(real_path): log_debug( u'add_source_file: not readable, not adding: %s', real_path, ) return if self.source_tree.issymlink(real_path): log_debug( u'add_source_file: not adding symlink: %s', real_path, ) return try: self.remove_source_file(real_path) except PathNotFound: pass values = self.meta_store.get(real_path) fake_paths = [] splitter_groups = [] for substitutions in values.iter_permutations(): try: fake_path = self.fill_path(substitutions) except UnrepresentablePath, e: log_info(u'Unrepresentable file: %s', real_path) log_info(unicode(e)) return if fake_path not in fake_paths: fake_paths.append(fake_path) splitters = self._create_splitters(fake_path, substitutions) splitter_groups.append(splitters) try: existing_fake_paths = set(self.get_fake_paths(real_path)) except PathNotFound: pass else: index = 0 for fake_path in list(fake_paths): if fake_path in existing_fake_paths: log_debug( u'Path mapping already exists, not adding: %s -> %s', real_path, fake_path, ) del fake_paths[index] del splitter_groups[index] else: index = index + 1 for fake_path, splitters in zip(fake_paths, splitter_groups): if not self.filter_path( self.source_tree.get_relative_path(real_path), fake_path ): log_debug( u'Explicitly excluded fake path: %s; real path: %s', fake_path, real_path, ) return self.monitor.add_source_file(self.source_tree.encode(real_path)) log_debug(u'add_source_file: adding %r, %r', fake_path, real_path) self.path_store.add_file(fake_path, real_path) self._set_splitters(fake_path, splitters) self._cache_prune_branch_to(fake_path) def remove_source_file(self, real_path): try: fake_paths = self.get_fake_paths(real_path) except PathNotFound: log_debug(u'remove_source_file: PathNotFound: %s', real_path) return for fake_path in fake_paths: log_debug( u'remove_source_file: removing %r, %r', fake_path, real_path, ) try: self.path_store.remove(fake_path, real_path) except PathNotFound: log_traceback() self._cache_prune_branch_to(fake_path) self.monitor.remove_source_file(self.source_tree.encode(real_path)) def update_source_file(self, real_path): self.add_source_file(real_path) def add_source_path(self, real_path): self.add_source_file(real_path) self.add_source_dir(real_path) def remove_source_path(self, real_path): self.remove_source_file(real_path) self.remove_source_dir(real_path) def update_source_path(self, real_path): # Note: there is no update_source_dir. Nobody cares if directory # permissions or timestamps change. We only care about files. self.update_source_file(real_path) ################################################################################ def add_filter(self, expr, real): self.filters.append(_make_filter(expr, real)) def filter_path(self, real_path, fake_path): for filtr in self.filters: if not filtr(real_path, fake_path): return False return True ################################################################################ def rename_path(self, old_fake_path, new_fake_path): self.validate_fake_path(old_fake_path) self.validate_fake_path(new_fake_path) log_info( u'SourceTreeRepresentation.rename_path: renaming %s to %s', old_fake_path, new_fake_path, ) old_path_parts = split_path(old_fake_path) new_path_parts = split_path(new_fake_path) if len(old_path_parts) != len(new_path_parts): log_error( ( u'rename_path: old path and new path have ' u'differing directory depths: %s, %s' ), old_fake_path, new_fake_path, ) raise InvalidArgument # Find the index of the path segment that changed: for index, (old_path_part, new_path_part) in enumerate( zip(old_path_parts, new_path_parts)): if old_path_part != new_path_part: break old_node_path = join_path_abs(old_path_parts[:index+1]) # Here's our approach: # 1. Separate the affected end points into files and directories. # 2. For each directory end point, remove the old directory and add the # new one. # 3. For each file end point: # a. We know which path segment changed, so we can use that # information to get old tag values for that segment and new tag # values for that segment. These values represent the total tag # change for that particular end point. # b. Group the values by real path and then combine each group. # c. For each affected real path, use Values.diff3 to calculate a # final values delta and apply it to the real path. end_points = self.path_store.get_end_points(old_fake_path) file_end_points = [] directory_end_points = [] for end_point in end_points: if self.is_file(end_point): file_end_points.append(end_point) else: directory_end_points.append(end_point) del end_points # Handle directory end points: for end_point in directory_end_points: self.remove_directory(end_point) end_point_parts = split_path(end_point) end_point_parts[index] = new_path_parts[index] self.add_directory_with_parents(join_path_abs(end_point_parts)) del directory_end_points # Get old values, new values for each file end point: old_values_by_end_point = {} new_values_by_end_point = {} for end_point in file_end_points: meta_data = self.path_store.get_meta_data(end_point) end_point_splitters = meta_data['splitters'] splitter = end_point_splitters[index] old_values = Values.from_flat_dict(splitter.split(old_path_part)) try: new_values = Values.from_flat_dict( splitter.split(new_path_part)) except PatternError, e: log_error(u'rename_path: %s', e) raise InvalidArgument old_values_by_end_point[end_point] = old_values new_values_by_end_point[end_point] = new_values # Group file end points by real path: end_points_by_real_path = {} for end_point in file_end_points: real_path = self.get_real_path(end_point) try: l = end_points_by_real_path[real_path] except KeyError: l = [] end_points_by_real_path[real_path] = l l.append(end_point) # Combine old values and new values for each real path: old_values_by_real_path = {} new_values_by_real_path = {} for real_path, end_points in end_points_by_real_path.items(): old_values_by_real_path[real_path] = Values.combine([ old_values_by_end_point[end_point] for end_point in end_points]) new_values_by_real_path[real_path] = Values.combine([ new_values_by_end_point[end_point] for end_point in end_points]) # Calculate a final values delta for each real path and apply it: for real_path in end_points_by_real_path.keys(): current_values = self.meta_store.get(real_path) old_values = old_values_by_real_path[real_path] new_values = new_values_by_real_path[real_path] apply_values = Values.diff3(current_values, old_values, new_values) log_debug(u'rename: real_path = %r', real_path) log_debug(u'rename: current_values = %r', current_values) log_debug(u'rename: old_values = %r', old_values) log_debug(u'rename: new_values = %r', new_values) log_debug(u'rename: apply_values = %r', apply_values) try: self.meta_store.set(real_path, apply_values) except UnsettableKeyError: log_debug(u'rename: %r', UnsettableKeyError) raise InvalidArgument def add_directory_with_parents(self, fake_path): parts = split_path(fake_path) path = unicode_path_sep for part in parts: path = os.path.join(path, part) if not self.is_dir(path): self.add_directory(path) def add_directory(self, fake_path): self.validate_fake_path(fake_path) parts = split_path(fake_path) len_parts = len(parts) if len_parts >= len(self.substitution_patterns): log_error( 'add_directory: too many directories: %r', fake_path, ) raise InvalidArgument splitters = self._create_splitters(fake_path, {}) splitter = splitters[-1] try: splitter.split(parts[-1]) except PatternError, e: log_info(u'add_directory: %s', e) raise InvalidArgument self.path_store.add_directory(fake_path) self._set_splitters(fake_path, splitters) self._cache_prune_branch_to(fake_path) def remove_directory(self, fake_path): self.validate_fake_path(fake_path) self.path_store.remove(fake_path) self._cache_prune_branch_to(fake_path) def get_real_path(self, fake_path): self.validate_fake_path(fake_path) return self.path_store.get_real_path(fake_path) def get_fake_paths(self, real_path): self.validate_source_path(real_path) return self.path_store.get_fake_paths(real_path) def get_entries(self, fake_path): self.validate_fake_path(fake_path) try: return self._cache_get(fake_path, ENTRIES) except KeyError: pass entries = self.path_store.get_entries(fake_path) self.cache_put(fake_path, ENTRIES, entries) return entries def path_exists(self, fake_path): self.validate_fake_path(fake_path) return self.path_store.path_exists(fake_path) def is_file(self, fake_path): self.validate_fake_path(fake_path) return self.path_store.is_file(fake_path) def is_dir(self, fake_path): self.validate_fake_path(fake_path) return self.path_store.is_dir(fake_path) def is_empty_dir(self, fake_path): return self.is_dir(fake_path) and not self.get_entries(fake_path) def supports_threads(self): return ( self.path_store.supports_threads() and ( self.monitor is None or self.monitor.supports_threads() ) ) def can_handle_fork(self): return self.monitor.can_handle_fork() def getattr(self, fake_path): self.validate_fake_path(fake_path) try: return self._cache_get(fake_path, STAT) except KeyError: pass stat_result = self._getattr(fake_path) self.cache_put(fake_path, STAT, stat_result) return stat_result def _getattr(self, fake_path): try: real_path = self.get_real_path(fake_path) except (IsADirectory, PathNotFound): pass else: return self.source_tree.lstat(real_path) # Files should've been handled above. Now we're just dealing with # directories and non-existent paths. # If fake_path doesn't exist, the exception will be raised here and # caught be our caller. subdirs = self._get_subdirectories(fake_path) source_root_statinfo = self.source_tree.lstat(self.source_tree.root) if not isinstance(source_root_statinfo, os.stat_result): # FIXME: I don't think this is being handled correctly. Should we # be negating the value before returning it? Identify when and # where this actually happens and write a test for it. I think I # only saw this once or twice when testing on OSX. It may be a bug # in os.lstat. # source_root_statinfo is actually an integer indicating an error. log_error( u'SourceTreeRepresentation._getattr: source_root_statinfo = %r', source_root_statinfo, ) return source_root_statinfo st_mode = stat.S_IFDIR | (stat.S_IMODE(source_root_statinfo.st_mode)) st_ino = 0 st_dev = 0 st_nlink = 2 + len(subdirs) st_uid = source_root_statinfo.st_uid st_gid = source_root_statinfo.st_gid st_size = 0 st_atime = self._get_directory_atime(fake_path) st_mtime = self._get_directory_mtime(fake_path) st_ctime = self._get_directory_ctime(fake_path) if st_atime == 0: st_atime = source_root_statinfo.st_atime if st_mtime == 0: st_mtime = source_root_statinfo.st_mtime if st_ctime == 0: st_ctime = source_root_statinfo.st_ctime return os.stat_result(( st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime, st_mtime, st_ctime, )) def utime(self, fake_path, times): self.validate_fake_path(fake_path) if self.is_file(fake_path): log_debug(u'utime: updating source file') real_path = self.get_real_path(fake_path) self.source_tree.utime(real_path, times) self._cache_prune_branch_to(fake_path, STAT) elif self.is_empty_dir(fake_path): log_debug(u'utime: updating source tree root') self.source_tree.utime(self.source_tree.root, times) else: log_debug(u'utime: updating all end-points') # May raise FakePathNotFound: for end_point in self.path_store.get_end_points(fake_path): self.utime(end_point, times) def _get_subdirectories(self, fake_path): entries = self.get_entries(fake_path) subdirs = [] for entry in entries: entry_path = os.path.join(fake_path, entry) try: if self.is_dir(entry_path): subdirs.append(entry_path) except PathNotFound: log_traceback() log_error( u'PathNotFound calling is_dir on previously known entry' ) pass return subdirs def _get_file_time_attr(self, fake_path, attr_name): return getattr(self.getattr(fake_path), attr_name) def _get_directory_time_attr(self, fake_path, attr_name): entries = self.get_entries(fake_path) entry_paths = [os.path.join(fake_path, e) for e in entries] # FIXME: This could be more efficient. subdirs = [ entry_path for entry_path in entry_paths if self.is_dir(entry_path) ] files = [ entry_path for entry_path in entry_paths if self.is_file(entry_path) ] subdir_times = [] for subdir in subdirs: try: subdir_times.append( self._get_directory_time_attr(subdir, attr_name)) except (IOError, OSError), e: log_error( ( u'_get_directory_time_attr: ' u'caught %r getting %r for subdir %r' ), e, attr_name, subdir, ) file_times = [] for file in files: try: file_times.append( self._get_file_time_attr(file, attr_name)) except (IOError, OSError), e: log_error( ( u'_get_directory_time_attr: ' u'caught %r getting %r for file %r' ), e, attr_name, file, ) times = list(chain(subdir_times, file_times)) if not times: return 0 return max(times) def _get_file_atime(self, fake_path): return self._get_file_time_attr(fake_path, 'st_atime') def _get_directory_atime(self, fake_path): return self._get_directory_time_attr(fake_path, 'st_atime') def _get_file_mtime(self, fake_path): return self._get_file_time_attr(fake_path, 'st_mtime') def _get_directory_mtime(self, fake_path): return self._get_directory_time_attr(fake_path, 'st_mtime') def _get_file_ctime(self, fake_path): return self._get_file_time_attr(fake_path, 'st_ctime') def _get_directory_ctime(self, fake_path): return self._get_directory_time_attr(fake_path, 'st_ctime') ################################################################################ def _create_splitters(self, fake_path, values): fake_path_parts = split_path(fake_path) splitters = [ sp.get_splitter(values) for sp in self.substitution_patterns[:len(fake_path_parts)] ] return splitters def _set_splitters(self, fake_path, splitters): self.path_store.set_meta_data(fake_path, {'splitters': splitters}) ################################################################################ def add_cb(self, event_path, is_dir = None): real_path = self.source_tree.decode(event_path).rstrip(unicode_path_sep) self.validate_source_path(real_path) if is_dir is None: self.add_source_path(real_path) elif is_dir: self.add_source_dir(real_path) else: self.add_source_file(real_path) def remove_cb(self, event_path, is_dir = None): real_path = self.source_tree.decode(event_path).rstrip(unicode_path_sep) self.validate_source_path(real_path) if is_dir is None: self.remove_source_path(real_path) elif is_dir: self.remove_source_dir(real_path) else: self.remove_source_file(real_path) def update_cb(self, event_path, is_dir = None): real_path = self.source_tree.decode(event_path).rstrip(unicode_path_sep) self.validate_source_path(real_path) if is_dir is None: self.update_source_path(real_path) elif is_dir: return else: self.update_source_file(real_path) ################################################################################ def cache_put(self, fake_path, key, value): if self.cache is not None: return self.cache.put(fake_path, key, value) def _cache_get(self, fake_path, key): if self.cache is not None: return self.cache.get(fake_path, key) raise KeyError('no cache to get from') def _cache_prune(self, fake_path = None, key = None): if self.cache is not None: return self.cache.prune(fake_path, key) raise KeyError('no cache to prune') def _cache_prune_branch_to(self, fake_path, key = None): while True: try: self._cache_prune(fake_path, key) except KeyError: pass if fake_path == unicode_path_sep: break fake_path = os.path.dirname(fake_path) pytagsfs-0.9.2/modules/pytagsfs/file.py0000644000175000017500000001250111315711421017544 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os from pytagsfs.exceptions import ( PathNotFound, InvalidArgument, ) from pytagsfs.util import ref_self from pytagsfs.multithreading import token_exchange # Note: A token refering to a specific file instance is used to protect the # file's open file descriptor. It should *not* be acquired when accessing # other attributes. That would break assumptions made by code that relies on # the global lock for data consistency. truncate_to is of special concern # because of how it is used in pytagsfs.fs. class File(object): filesystem = None fake_path = None real_path = None flags = None truncate_to = None def __init__( self, filesystem, fake_path, flags, truncate_to = None, ): self.filesystem = filesystem self.fake_path = fake_path self.real_path = filesystem.source_tree_rep.get_real_path(fake_path) self.flags = flags self.truncate_to = truncate_to def fgetattr(self): raise NotImplementedError def flush(self): raise NotImplementedError def fsync(self, datasync): raise NotImplementedError def ftruncate(self, len): raise NotImplementedError def read(self, length, offset): raise NotImplementedError def release(self, flags): pass def write(self, buf, offset): raise NotImplementedError def set_truncate_to(self, truncate_to): # Note: We deliberately keep the global token here. self.truncate_to = truncate_to def del_truncate_to(self): # Note: We deliberately keep the global token here. del self.truncate_to class ReadOnlyFile(File): fd = None file = None def __init__(self, *args, **kwargs): super(ReadOnlyFile, self).__init__(*args, **kwargs) self.open_file() @token_exchange.token_pushed(ref_self) def open_file(self): real_path = self.filesystem.encode_real_path(self.real_path) self.file = os.fdopen(os.open(real_path, self.flags), 'r') ################################################################################ def fgetattr(self): token_exchange.push_token(self) try: fd = self.file.fileno() stat_result = os.fstat(fd) finally: token_exchange.pop_token() st_size = stat_result.st_size if (self.truncate_to is not None) and (st_size > self.truncate_to): st_size = self.truncate_to return os.stat_result(( stat_result.st_mode, stat_result.st_ino, stat_result.st_dev, stat_result.st_nlink, stat_result.st_uid, stat_result.st_gid, st_size, stat_result.st_atime, stat_result.st_mtime, stat_result.st_ctime, )) def ftruncate(self, len): raise InvalidArgument def read(self, length, offset): if self.truncate_to is not None: length = self.truncate_to - offset if length < 0: length = 0 token_exchange.push_token(self) try: self.file.seek(offset) return self.file.read(length) finally: token_exchange.pop_token() @token_exchange.token_pushed(ref_self) def release(self, flags): self.file.close() def write(self, buf, offset): raise InvalidArgument class ReadWriteFile(File): fd = None def __init__(self, *args, **kwargs): super(ReadWriteFile, self).__init__(*args, **kwargs) self.open_file() def open_file(self): # Note: get value of truncate_to before pushing a new token. truncate_to = self.truncate_to real_path = self.filesystem.encode_real_path(self.real_path) token_exchange.push_token(self) try: self.fd = os.open(real_path, self.flags) if truncate_to is not None: os.ftruncate(self.fd, truncate_to) finally: token_exchange.pop_token() ################################################################################ @token_exchange.token_pushed(ref_self) def read(self, length, offset): os.lseek(self.fd, offset, 0) return os.read(self.fd, length) @token_exchange.token_pushed(ref_self) def release(self, flags): return os.close(self.fd) @token_exchange.token_pushed(ref_self) def write(self, buf, offset): os.lseek(self.fd, offset, 0) return os.write(self.fd, buf) @token_exchange.token_pushed(ref_self) def fgetattr(self): return os.fstat(self.fd) @token_exchange.token_pushed(ref_self) def flush(self): return os.close(os.dup(self.fd)) @token_exchange.token_pushed(ref_self) def fsync(self, datasync): if datasync and hasattr(os, 'fdatasync'): return os.fdatasync(self.fd) else: return os.fsync(self.fd) @token_exchange.token_pushed(ref_self) def ftruncate(self, len): return os.ftruncate(self.fd, len) pytagsfs-0.9.2/modules/pytagsfs/regex.py0000644000175000017500000000675711315711421017757 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import re from cStringIO import StringIO class SegmentContainer(list): def __str__(self): return repr(self) def __unicode__(self): return repr(self).decode() def __repr__(self): return '%s(%s)' % ( self.__class__.__name__, super(SegmentContainer, self).__repr__(), ) class Regex(SegmentContainer): def __str__(self): return self.get_string().encode('utf-8') def __unicode__(self): return self.get_string() def get_string(self): context = Context() for segment in self: context.add(segment) return context.get_value() def get_regex(self): return re.compile(self.get_string()) class Context(object): encoding = 'utf-8' named_group_start_regex = re.compile(r'(?.*?[^\\])\>') group_start_regex = re.compile(r'(?' % self.name) super(NamedGroup, self).eval(context) context.write(')') pytagsfs-0.9.2/modules/pytagsfs/main.py0000644000175000017500000000143111315711421017551 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import sys, os.path def main(argv): if os.path.basename(argv[0]) == 'pymailtagsfs': print >>sys.stderr, ( 'Warning: ' 'using mail extension; ' 'invocation may change in the future (see NEWS)' ) from pytagsfs.fs.mail import PyMailTagsFileSystem fs = PyMailTagsFileSystem() else: from pytagsfs.fs import PyTagsFileSystem fs = PyTagsFileSystem() return fs.main(argv) pytagsfs-0.9.2/modules/pytagsfs/pytags.py0000644000175000017500000001271411315711421020142 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. # Import locale from sclapp before all other imports to work around bug in # stdlib. # See http://www.selenic.com/mercurial/wiki/index.cgi/Character_Encoding_On_OSX. from sclapp import locale import sys, os from optparse import OptionParser, OptionValueError import sclapp from sclapp import CriticalError from pytagsfs.subspat import SubstitutionPattern, Error as PatternError from pytagsfs.metastore.mutagen_ import MutagenFileMetaStore from pytagsfs import __version__ as version def print_tags(filenames): failed_filenames = [] for filename in filenames: print filename try: f = MutagenFileMetaStore.tags_class(filename) if f is None: raise IOError('Invalid file: %s' % filename) except Exception, e: sclapp.printCritical(unicode(e)) failed_filenames.append(filename) print continue print f.pprint() print if failed_filenames: return 1 return 0 def apply_substitution_pattern(tags, substitution_pattern): if substitution_pattern: current_values = MutagenFileMetaStore.extract(tags) splitter = substitution_pattern.get_splitter(current_values) pattern_tags = substitution_pattern.split(filename) else: pattern_tags = {} MutagenFileMetaStore.inject(tags, pattern_tags) def apply_operations(tags, operations): for opname, arg in operations: if opname == 'add': name, value = arg.split('=') tags[name] = tags.get(name, []) + [value] elif opname == 'set': name, value = arg.split('=') tags[name] = [value] elif opname == 'remove': try: del tags[arg] except KeyError: sclapp.printWarning(u'No such tag: %s' % arg) def update_tags(format, operations, filenames): substitution_pattern = None if format: substitution_pattern = SubstitutionPattern(format) failed_filenames = [] for filename in filenames: print filename try: tags = MutagenFileMetaStore.tags_class(filename) if tags is None: raise IOError('Invalid file: %s' % filename) except (OSError, IOError), e: sclapp.printCritical(unicode(e)) failed_filenames.append(filename) continue try: apply_substitution_pattern(tags, substitution_pattern) except PatternError, e: sclapp.printCritical(unicode(e)) failed_filenames.append(filename) continue apply_operations(tags, operations) tags.save() if failed_filenames: sclapp.printCritical('Failed to process the following files:') for filename in failed_filenames: sclapp.printCritical(filename) if failed_filenames: return 1 return 0 def parse_set_values(set_exprs): set_values = {} for expr in set_exprs: try: k, v = expr.split('=') except (TypeError, ValueError): raise CriticalError(1, 'Invalid set expression: %s' % expr) set_values[k] = v return set_values class PyTagsOptionParser(OptionParser): def __init__(self): OptionParser.__init__( self, usage = '%prog [options] {file} [file...]', version = '%%prog version %s' % version, ) self.defaults['operations'] = [] self.add_option( '--format', action = 'callback', type = 'str', callback = self.cb_set_format, help = ( 'tag files using meta-data parsed from filenames according to PATTERN; ' 'see the manual page for more information.' ), ) self.add_option( '--set', action = 'callback', type = 'str', callback = self.cb_append_operation, metavar = 'FOO=BAR', help = 'set tag named FOO to value BAR', ) self.add_option( '--remove', action = 'callback', type = 'str', callback = self.cb_append_operation, metavar = 'FOO', help = 'unset tag named FOO', ) self.add_option( '--add', action = 'callback', type = 'str', callback = self.cb_append_operation, metavar = 'FOO=BAR', help = 'add value BAR as new value for tag FOO', ) def cb_set_format(self, option, opt_str, value, parser): if parser.values.operations: raise OptionValueError("--format must be specified first") setattr(parser.values, option.dest, value) def cb_append_operation(self, option, opt_str, value, parser): parser.values.operations.append((opt_str.lstrip('-'), value)) @sclapp.main_function def main(argv): parser = PyTagsOptionParser() values, args = parser.parse_args(argv[1:]) if len(args) < 1: raise CriticalError(1, 'Too few arguments.') if not (values.format or values.operations): return print_tags(args) else: return update_tags(values.format, values.operations, args) pytagsfs-0.9.2/modules/pytagsfs/__init__.py0000644000175000017500000000072111315711421020365 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. try: from pytagsfs import version except ImportError: __version__ = '0.0.0' else: __version__ = version.version pytagsfs-0.9.2/modules/pytagsfs/fuselib.py0000644000175000017500000004232311315711421020263 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import errno import traceback import fuse from fuse import ( Fuse as _Fuse, FuseFileInfo as _FileInfo, Stat as _Stat, Direntry as _Direntry, StatVfs as _StatVfs, ) from pytagsfs.debug import log_debug, log_critical from pytagsfs.util import ( LazyByteString, wraps, ) from pytagsfs.exceptions import FuseError from pytagsfs.profiling import profiled from pytagsfs.multithreading import token_exchange, GLOBAL fuse.fuse_python_api = (0, 2) MAX_LEN_REPR_ARG = 512 def repr_arg(arg): retval = repr(arg) try: retval[MAX_LEN_REPR_ARG] except IndexError: return retval return ''.join([retval[:(MAX_LEN_REPR_ARG - 3)], '...']) def repr_args(args): return ', '.join([repr_arg(arg) for arg in args]) def lazy_repr_args(args): return LazyByteString(repr_args, args) def timespec_to_float(timespec): return float(timespec.tv_sec) + (float(timespec.tv_nsec) / 1000000000.0) class FuseReprMixin(object): def __repr__(self): d = {} for name in dir(self): if not (name.startswith('__') and name.endswith('__')): d[name] = getattr(self, name) return '%s(%s)' % ( self.__class__.__name__, repr(d), ) class FileInfo(FuseReprMixin, _FileInfo): pass class Stat(FuseReprMixin, _Stat): pass class Direntry(FuseReprMixin, _Direntry): pass class StatVfs(FuseReprMixin, _StatVfs): pass def fsmethod(func): @wraps(func) def wrapper(*args, **kwargs): try: ret = func(*args, **kwargs) if ret is None: ret = 0 except FuseError, e: if e.errno is not None: ret = -e.errno else: ret = -errno.EFAULT except: log_critical(traceback.format_exc()) ret = -errno.EFAULT return ret return wrapper def logged(func): @wraps(func) def wrapper(self, *args, **kwargs): log_debug(u'%s(%s)', func.__name__, lazy_repr_args(args)) ret = func(self, *args, **kwargs) log_debug(u'%s(...) -> %r', func.__name__, ret) return ret return wrapper def logged_noargs(func): @wraps(func) def wrapper(self, *args, **kwargs): log_debug(u'%s(???)', func.__name__) ret = func(self, *args, **kwargs) log_debug(u'%s(...) -> %r', func.__name__, ret) return ret return wrapper def logged_noret(func): @wraps(func) def wrapper(self, *args, **kwargs): log_debug(u'%s(%s)', func.__name__, lazy_repr_args(args)) ret = func(self, *args, **kwargs) log_debug(u'%s(...) -> ???', func.__name__) return ret return wrapper class Fuse(_Fuse): def __init__(self, filesystem, *args, **kwargs): self.filesystem = filesystem kwargs.setdefault('dash_s_do', 'setsingle') super(Fuse, self).__init__(*args, **kwargs) def main(self): try: return super(Fuse, self).main() finally: # See comment regarding fsdestroy. self.filesystem.destroy() @profiled @logged @fsmethod def access(self, path, mode): return self.filesystem.access(path, mode) @profiled @logged @fsmethod def bmap(self, path, blocksize, idx): return self.filesystem.bmap(path, blocksize, idx) @profiled @logged @fsmethod def chmod(self, path, mode): return self.filesystem.chmod(path, mode) @profiled @logged @fsmethod def chown(self, path, uid, gid): return self.filesystem.chown(path, uid, gid) @profiled @logged @fsmethod def create(self, path, flags, mode): return self.filesystem.create(path, flags, mode) # FIXME # This clean-up is performed at the end of main to work around what appears # to be a bug in python-fuse that prevents exit due to a GIL deadlock. The # bug is fixed upstream, but the fix may not have been released yet. Once # it is long gone, we can re-enabled this and remove the destroy call from # main. #@profiled #@logged #@fsmethod #def fsdestroy(self): # self.filesystem.destroy() @profiled @logged @fsmethod def fgetattr(self, path, fi): return self._fgetattr(path, fi) def _fgetattr(self, path, fi): if fi is None: stat_result = self.filesystem.getattr(path) else: stat_result = self.filesystem.fgetattr(path, fi.fh) # This is a little bit complicated due to different handling in various # python-fuse versions: # # * Some versions do not handle None values; attributes should not be # specified. # * Some versions do not handle missing attributes. # # Eventually, we should be able to return stat_result directly, but # only after python-fuse versions that don't support None for attribute # values have been phased out. In the meantime, for maximum # compatibility we should always set a non-None value for all # attributes. Thus, for some attributes we must guess a default using # the same heuristics that python-fuse uses for None/missing # attributes. st = Stat( st_dev = stat_result.st_dev, st_ino = stat_result.st_ino, st_mode = stat_result.st_mode, st_nlink = stat_result.st_nlink, st_uid = stat_result.st_uid, st_gid = stat_result.st_gid, #st_rdev = stat_result.st_rdev, st_size = stat_result.st_size, #st_blksize = stat_result.st_blksize, #st_blocks = stat_result.st_blocks, st_atime = stat_result.st_atime, st_mtime = stat_result.st_mtime, st_ctime = stat_result.st_ctime, ) if stat_result.st_rdev is None: # I believe this should work with all systems. st.st_rdev = 0 else: st.st_rdev = stat_result.st_rdev if stat_result.st_blksize is None: # Default value used by python-fuse. st.st_blksize = 4096 else: st.st_blksize = stat_result.st_blksize if stat_result.st_blocks is None: # Default value used by python-fuse. st.st_blocks = ((stat_result.st_size + 511) / 512) else: st.st_blocks = stat_result.st_blocks return st @profiled @logged @fsmethod def flush(self, path, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.flush(path, fh) @profiled @logged @fsmethod def fsync(self, path, datasync, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.fsync(path, datasync, fh) @profiled @logged @fsmethod def fsyncdir(self, path, datasync, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.fsyncdir(path, datasync, fh) @profiled @logged @fsmethod def ftruncate(self, path, length, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.ftruncate(path, length, fh) @profiled @logged @fsmethod def getattr(self, path): return self._fgetattr(path, None) @profiled @logged @fsmethod def getxattr(self, path, name, size): return self.filesystem.getxattr(path, name, size) @profiled @logged @fsmethod def fsinit(self): self.filesystem.init() @profiled @logged @fsmethod def link(self, source, target): return self.filesystem.link(source, target) @profiled @logged @fsmethod def listxattr(self, path, size): return self.filesystem.listxattr(path, size) @profiled @logged @fsmethod def lock(self, path, cmd, owner, fi = None, **kwargs): # kwargs: l_type, l_start, l_len, l_pid fh = getattr(fi, 'fh', None) return self.filesystem.lock(path, cmd, owner, fh, **kwargs) @profiled @logged @fsmethod def mkdir(self, path, mode): return self.filesystem.mkdir(path, mode) @profiled @logged @fsmethod def mknod(self, path, mode, dev): return self.filesystem.mknod(path, mode, dev) @profiled @logged @fsmethod def open(self, path, flags): fh = self.filesystem.open(path, flags) # Note: keep_cache is only specified to avoid AttributeErrors in # python-fuse, which doesn't handle missing attributes well. I think # that python-fuse's FileInfo class is supposed to specify a default # value as a class attribute but it is incorrectly named "keep" instead # of "keep_cache". Bug not yet filed. return FileInfo(fh = fh, keep_cache = None) @profiled @logged @fsmethod def opendir(self, path): return self.filesystem.opendir(path) @profiled @logged_noret @fsmethod def read(self, path, size, offset, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.read(path, size, offset, fh) @profiled @logged @fsmethod def readdir(self, path, offset): # FIXME: Our FUSE bindings don't give us fi for readdir, so we fake # this as always None. fh = None entries = [] for name in self.filesystem.readdir(path, fh): entries.append(Direntry(name)) return entries @profiled @logged @fsmethod def readlink(self, path): return self.filesystem.readlink(path) @profiled @logged @fsmethod def release(self, path, flags, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.release(path, flags, fh) @profiled @logged @fsmethod def releasedir(self, path, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.releasedir(path, fh) @profiled @logged @fsmethod def removexattr(self, path, name): return self.filesystem.removexattr(path, name) @profiled @logged @fsmethod def rename(self, old, new): return self.filesystem.rename(old, new) @profiled @logged @fsmethod def rmdir(self, path): return self.filesystem.rmdir(path) @profiled @logged @fsmethod def setxattr(self, path, name, value, size, flags): return self.filesystem.setxattr(path, name, value, size, flags) @profiled @logged @fsmethod def statfs(self): statfs_result = self.filesystem.statfs() return StatVfs( f_bsize = statfs_result.f_bsize, f_frsize = statfs_result.f_frsize, f_blocks = statfs_result.f_blocks, f_bfree = statfs_result.f_bfree, f_bavail = statfs_result.f_bavail, f_files = statfs_result.f_files, f_ffree = statfs_result.f_ffree, f_favail = statfs_result.f_favail, f_flag = statfs_result.f_flag, f_namemax = statfs_result.f_namemax, ) @profiled @logged @fsmethod def symlink(self, source, target): return self.filesystem.symlink(source, target) @profiled @logged @fsmethod def truncate(self, path, length): return self.filesystem.truncate(path, length) @profiled @logged @fsmethod def unlink(self, path): return self.filesystem.unlink(path) @profiled @logged @fsmethod def utimens(self, path, ts_atime, ts_mtime): atime = timespec_to_float(ts_atime) mtime = timespec_to_float(ts_mtime) return self.filesystem.utimens(path, (atime, mtime)) @profiled @logged_noargs @fsmethod def write(self, path, buf, offset, fi = None): fh = getattr(fi, 'fh', None) return self.filesystem.write(path, buf, offset, fh) class TokenFuse(Fuse): def main(self): try: # Note: calling super with parent class to skip Fuse.main. We're # overriding, not extending. return super(Fuse, self).main() finally: token_exchange.push_token(GLOBAL) try: # See comment regarding fsdestroy. self.filesystem.destroy() finally: token_exchange.pop_token() access = token_exchange.token_pushed(GLOBAL)(Fuse.access) bmap = token_exchange.token_pushed(GLOBAL)(Fuse.bmap) chmod = token_exchange.token_pushed(GLOBAL)(Fuse.chmod) chown = token_exchange.token_pushed(GLOBAL)(Fuse.chown) create = token_exchange.token_pushed(GLOBAL)(Fuse.create) # XXX: Enable this when Fuse.fsdestroy is enabled. #fsdestroy = token_exchange.token_pushed(GLOBAL)(Fuse.fsdestroy) fgetattr = token_exchange.token_pushed(GLOBAL)(Fuse.fgetattr) flush = token_exchange.token_pushed(GLOBAL)(Fuse.flush) fsync = token_exchange.token_pushed(GLOBAL)(Fuse.fsync) fsyncdir = token_exchange.token_pushed(GLOBAL)(Fuse.fsyncdir) ftruncate = token_exchange.token_pushed(GLOBAL)(Fuse.ftruncate) getattr = token_exchange.token_pushed(GLOBAL)(Fuse.getattr) getxattr = token_exchange.token_pushed(GLOBAL)(Fuse.getxattr) fsinit = token_exchange.token_pushed(GLOBAL)(Fuse.fsinit) link = token_exchange.token_pushed(GLOBAL)(Fuse.link) listxattr = token_exchange.token_pushed(GLOBAL)(Fuse.listxattr) lock = token_exchange.token_pushed(GLOBAL)(Fuse.lock) mkdir = token_exchange.token_pushed(GLOBAL)(Fuse.mkdir) mknod = token_exchange.token_pushed(GLOBAL)(Fuse.mknod) open = token_exchange.token_pushed(GLOBAL)(Fuse.open) opendir = token_exchange.token_pushed(GLOBAL)(Fuse.opendir) read = token_exchange.token_pushed(GLOBAL)(Fuse.read) readdir = token_exchange.token_pushed(GLOBAL)(Fuse.readdir) readlink = token_exchange.token_pushed(GLOBAL)(Fuse.readlink) release = token_exchange.token_pushed(GLOBAL)(Fuse.release) releasedir = token_exchange.token_pushed(GLOBAL)(Fuse.releasedir) removexattr = token_exchange.token_pushed(GLOBAL)(Fuse.removexattr) rename = token_exchange.token_pushed(GLOBAL)(Fuse.rename) rmdir = token_exchange.token_pushed(GLOBAL)(Fuse.rmdir) setxattr = token_exchange.token_pushed(GLOBAL)(Fuse.setxattr) statfs = token_exchange.token_pushed(GLOBAL)(Fuse.statfs) symlink = token_exchange.token_pushed(GLOBAL)(Fuse.symlink) truncate = token_exchange.token_pushed(GLOBAL)(Fuse.truncate) unlink = token_exchange.token_pushed(GLOBAL)(Fuse.unlink) utimens = token_exchange.token_pushed(GLOBAL)(Fuse.utimens) write = token_exchange.token_pushed(GLOBAL)(Fuse.write) class FileSystem(object): def access(self, path, mode): return 0 def bmap(self, path, blocksize, idx): raise FuseError(errno.ENOSYS) def chmod(self, path, mode): raise FuseError(errno.ENOSYS) def chown(self, path, uid, gid): raise FuseError(errno.ENOSYS) def create(self, path, flags, mode): raise FuseError(errno.ENOSYS) def destroy(self): pass def fgetattr(self, path, fh): raise FuseError(errno.ENOSYS) def flush(self, path, fh): raise FuseError(errno.ENOSYS) def fsync(self, path, datasync, fh): raise FuseError(errno.ENOSYS) def fsyncdir(self, path, datasync, fh): raise FuseError(errno.ENOSYS) def ftruncate(self, path, length, fh): raise FuseError(errno.ENOSYS) def getattr(self, path): raise FuseError(errno.ENOSYS) def getxattr(self, path, name, size): raise FuseError(errno.ENOSYS) def init(self): pass def link(self, source, target): raise FuseError(errno.ENOSYS) def listxattr(self, path, size): raise FuseError(errno.ENOSYS) def lock(self, path, cmd, owner, fh, **kwargs): raise FuseError(errno.ENOSYS) def mkdir(self, path, mode): raise FuseError(errno.ENOSYS) def mknod(self, path, mode, dev): raise FuseError(errno.ENOSYS) def open(self, path, mode): return 0 def opendir(self, path): return 0 def read(self, path, size, offset, fh): raise FuseError(errno.ENOSYS) def readdir(self, path, readdir, fh): raise FuseError(errno.ENOSYS) def readlink(self, path): raise FuseError(errno.ENOSYS) def release(self, path, fh): return 0 def releasedir(self, path, fh): return 0 def removexattr(self, path, name): raise FuseError(errno.ENOSYS) def rename(self, old, new): raise FuseError(errno.ENOSYS) def rmdir(self, path): raise FuseError(errno.ENOSYS) def setxattr(self, path, name, value, size, flags): raise FuseError(errno.ENOSYS) def statfs(self): raise FuseError(errno.ENOSYS) def symlink(self, source, target): raise FuseError(errno.ENOSYS) def truncate(self, path, length): raise FuseError(errno.ENOSYS) def unlink(self, path): raise FuseError(errno.ENOSYS) def utimens(self, path, times): raise FuseError(errno.ENOSYS) def write(self, path, data, offset, fh): raise FuseError(errno.ENOSYS) pytagsfs-0.9.2/modules/pytagsfs/values.py0000644000175000017500000000602311315711421020126 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. class Values(dict): def __init__(self, *args, **kwargs): super(Values, self).__init__(*args, **kwargs) for k, v in self.items(): self[k] = list(self[k]) def __setitem__(self, k, v): v = list(v) super(Values, self).__setitem__(k, v) def __repr__(self): return '%s(%s)' % ( self.__class__.__name__, super(Values, self).__repr__(), ) @classmethod def from_flat_dict(cls, d): result = cls() for k, v in d.items(): if v is None: result[k] = [] else: result[k] = [v] return result @classmethod def combine(cls, list_of_values): merged = cls() for values in list_of_values: for k, value in values.items(): if k in merged: merged[k].extend(value) else: merged[k] = list(value) for k, l in merged.items(): if not l: continue if l == (len(l) * [l[0]]): merged[k] = [l[0]] return merged @classmethod def diff2(cls, old, new): difference = cls(new) for k, v in old.items(): if k in difference: if set(difference[k]) == set(v): del difference[k] else: difference[k] = [] return difference @classmethod def diff3(cls, base, old, new): difference = cls.diff2(old, new) merged = cls(base) for k in base: if k not in difference: del merged[k] for k in difference: if k not in base: merged[k] = list(difference[k]) else: base_values = list(base[k]) old_values = list(old[k]) difference_values = list(difference[k]) merged_values = list(base_values) for old_value in old_values: try: merged_values.remove(old_value) except ValueError: pass merged_values.extend(difference_values) merged[k] = merged_values return merged def to_flat_dict(self): d = {} for k in self: d[k] = self[k][0] return d def iter_permutations(self): copy_self = Values(self) if not copy_self: yield {} return key, values = copy_self.popitem() for d in copy_self.iter_permutations(): for value in values: d = dict(d) d[key] = value yield d pytagsfs-0.9.2/modules/pytagsfs/fs/0000755000175000017500000000000011315711421016664 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/fs/__init__.py0000644000175000017500000010241111315711421020774 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. # Import locale from sclapp before all other imports to work around bug in # stdlib. # See http://www.selenic.com/mercurial/wiki/index.cgi/Character_Encoding_On_OSX. from sclapp import locale import sys, os, re, platform try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps from optparse import OptParseError, SUPPRESS_HELP from pytagsfs.fuselib import ( TokenFuse, FileSystem, ) from pytagsfs.optgroup import GroupingOptionParser from pytagsfs.subspat import SubstitutionPattern from pytagsfs.sourcetree import SourceTree from pytagsfs.metastore import DelegateMultiMetaStore from pytagsfs.sourcetreemon import ( SOURCE_TREE_MONITORS, get_source_tree_monitor, ) from pytagsfs.exceptions import ComponentError from pytagsfs.pathpropcache import PathPropCache from pytagsfs.debug import ( log_debug, log_warning, set_log_level, DEBUG, INFO, WARNING, ERROR, CRITICAL, enable_stderr, set_logsize, ) from pytagsfs.util import ( get_obj_by_dotted_name, return_errno, split_path, unicode_path_sep, ftruncate_path, ) from pytagsfs.file import ReadOnlyFile, ReadWriteFile from pytagsfs.specialfile import SpecialFileFileSystemMixin from pytagsfs.specialfile.logfile import VirtualLogFile from pytagsfs.profiling import enable_profiling from pytagsfs.multithreading import token_exchange from pytagsfs import __version__ as version DEFAULT_VERBOSITY = 'warning' PLATFORM = platform.system() if PLATFORM in ('FreeBSD', 'NetBSD', 'OpenBSD', 'Darwin'): READ_ONLY_MOUNT_OPTION = 'rdonly' UMOUNT_COMMAND = u'umount %s' else: READ_ONLY_MOUNT_OPTION = 'ro' UMOUNT_COMMAND = u'fusermount -u %s' def append_filter(option, opt_str, value, parser, *args, **kwargs): if not hasattr(parser.values, 'filters'): parser.values.filters = [] if 'src' in opt_str: which = 'src' else: which = 'dst' parser.values.filters.append((which, value)) def operation_on_one_real_path(real_op): @return_errno @wraps(real_op) def wrapper(self, fake_path, *args, **kwargs): fake_path = self.decode_fake_path(fake_path) real_path = self.encode_real_path(self.get_real_path(fake_path)) return real_op(real_path, *args, **kwargs) return wrapper def operation_on_two_real_paths(real_op): @return_errno @wraps(real_op) def wrapper(self, fake_path1, fake_path2, *args, **kwargs): fake_path1 = self.decode_fake_path(fake_path1) fake_path2 = self.decode_fake_path(fake_path2) real_path1 = self.encode_real_path(self.get_real_path(fake_path1)) real_path2 = self.encode_real_path(self.get_real_path(fake_path2)) return real_op(real_path1, real_path2, *args, **kwargs) return wrapper class FileSystemMappingToRealFilesOptionParser(GroupingOptionParser): DEFAULT_OPTIONS = {} DEFAULT_OPTIONS['-d'] = { 'default': False, 'action': 'store_true', 'help': 'debug mode; implies -f', } DEFAULT_OPTIONS['-f'] = { 'default': False, 'action': 'store_true', 'help': 'stay in foreground', } DEFAULT_OPTIONS['-s'] = { 'default': False, 'action': 'store_true', 'help': 'disable multi-threaded operation', } DEFAULT_OPTIONS['-r'] = { 'default': False, 'action': 'store_true', 'help': 'mount read-only', } DEFAULT_OPTION_ORDER = ('-f', '-d', '-s') DEFAULT_MOUNT_OPTIONS = {} DEFAULT_MOUNT_OPTIONS[READ_ONLY_MOUNT_OPTION] = dict(DEFAULT_OPTIONS['-r']) DEFAULT_MOUNT_OPTIONS['iocharset'] = { 'default': 'utf-8', 'metavar': 'ENCODING', 'help': 'set mounted tree character encoding to ENCODING (default: %default)', } DEFAULT_MOUNT_OPTIONS['source_iocharset'] = { 'default': 'utf-8', 'metavar': 'ENCODING', 'help': 'set source directory character encoding to ENCODING ' '(default: %default)', } DEFAULT_MOUNT_OPTIONS['srcfilter'] = { 'action': 'callback', 'type': 'str', 'callback': append_filter, 'metavar': 'EXPR', 'help': 'add a source path filter as specified by EXPR', } DEFAULT_MOUNT_OPTIONS['dstfilter'] = { 'action': 'callback', 'type': 'str', 'callback': append_filter, 'metavar': 'EXPR', 'help': 'add a destination path filter as specified by EXPR', } DEFAULT_MOUNT_OPTIONS['debug'] = { 'default': False, 'action': 'store_true', 'help': 'synonym for -d', } DEFAULT_MOUNT_OPTIONS['verbosity'] = { 'default': 'warning', 'help': 'log file verbosity; one of debug, info, warning, error, critical ' '(default: %default)', } DEFAULT_MOUNT_OPTIONS['logsize'] = { 'type': 'int', 'default': (1024 * 1024), 'help': 'length of log file ring buffer, in bytes', } DEFAULT_MOUNT_OPTIONS['allow_other'] = { 'action': 'store_true', 'default': False, 'help': 'allow access to other users', } DEFAULT_MOUNT_OPTIONS['allow_root'] = { 'action': 'store_true', 'default': False, 'help': 'allow access to root', } DEFAULT_MOUNT_OPTIONS['nonempty'] = { 'action': 'store_true', 'default': False, 'help': 'allow mounts over non-empty file/dir', } DEFAULT_MOUNT_OPTIONS['uid'] = {'help': 'set owner to UID (if supported)'} DEFAULT_MOUNT_OPTIONS['gid'] = {'help': 'set group to GID (if supported)'} DEFAULT_MOUNT_OPTIONS['profile'] = { 'action': 'store_true', 'default': False, 'help': 'log profiling data', } DEFAULT_MOUNT_OPTION_ORDER = ( 'srcfilter', 'dstfilter', 'iocharset', 'source_iocharset', READ_ONLY_MOUNT_OPTION, 'allow_other', 'allow_root', 'nonempty', 'uid', 'gid', 'verbosity', 'logsize', 'debug', 'profile', ) def __init__(self, *args, **kwargs): kwargs['usage'] = '%prog [OPTIONS] {source} {mountpoint}' kwargs['version'] = '%%prog version %s' % version GroupingOptionParser.__init__(self, *args, **kwargs) self.add_default_options() def add_default_options(self): for opt in self.DEFAULT_OPTION_ORDER: kwargs = self.DEFAULT_OPTIONS[opt] self.add_option(opt, **kwargs) for opt, kwargs in self.DEFAULT_OPTIONS.items(): if opt not in self.DEFAULT_OPTION_ORDER: self.add_option(opt, **kwargs) self.add_group( '-o', title = 'Mount Options', help = "mount options (see `Mount Options')", ) for opt in self.DEFAULT_MOUNT_OPTION_ORDER: kwargs = self.DEFAULT_MOUNT_OPTIONS[opt] self.add_mount_option(opt, **kwargs) for opt, kwargs in self.DEFAULT_MOUNT_OPTIONS.items(): if opt not in self.DEFAULT_MOUNT_OPTION_ORDER: self.add_mount_option(opt, **kwargs) def add_mount_option(self, option, **kwargs): if 'group' in kwargs: raise AssertionError return self.add_option(option, group = '-o', **kwargs) def parse_args(self, *args, **kwargs): retval = GroupingOptionParser.parse_args(self, *args, **kwargs) if not hasattr(self.values.o, 'filters'): self.values.o.filters = [] return retval class FrozenPath(object): real_path = None count = None def __init__(self, real_path): self.real_path = real_path self.count = 0 def increment(self): self.count = self.count + 1 return self.count def decrement(self): if self.count == 0: raise AssertionError('Will not decrement count below zero.') self.count = self.count - 1 return self.count class FileSystemMappingToRealFiles(FileSystem): argv = None user_encoding = None cmdline_arguments = None cmdline_parser = None debug = None foreground = None verbosity = None allow_other = None allow_root = None nonempty = None uid = None gid = None readonly = None multithreaded = None logsize = None iocharset = None source_iocharset = None profile = None path_filters = None source_tree_path = None mount_point = None fuse_cmdline_arguments = None source_tree_rep = None truncated_paths = None frozen_path_mappings = None max_open_files = 1024 open_files = None read_only_files_by_fake_path = None subtype = None verbosities = { 'debug': DEBUG, 'info': INFO, 'warning': WARNING, 'error': ERROR, 'critical': CRITICAL, } def __init__(self): self.truncated_paths = {} self.frozen_path_mappings = {} self.open_files = (self.max_open_files + 1) * [None] self.read_only_files_by_fake_path = {} self.cmdline_parser = self.get_cmdline_parser() super(FileSystemMappingToRealFiles, self).__init__() def get_cmdline_parser(self): return FileSystemMappingToRealFilesOptionParser() def main(self, argv): self.argv = argv try: self.parse() except OptParseError, e: self.cmdline_parser.error(unicode(e)) self.pre_init() fuse = TokenFuse(self) fuse.parse(self.fuse_cmdline_arguments) return fuse.main() def parse(self): # locale.getpreferredencoding is not necessarily thread-safe, so we # call it here before any threads might be forked: self.user_encoding = locale.getpreferredencoding() self.cmdline_arguments = self.argv[1:] opts, args = self.cmdline_parser.parse_args(self.cmdline_arguments) if len(args) < 2: raise OptParseError('too few arguments') if len(args) > 2: raise OptParseError('too many arguments') self.process_options(opts, args) self.build_fuse_cmdline_arguments() def build_fuse_cmdline_arguments(self): self.fuse_cmdline_arguments = [ '-o', 'default_permissions', '-o', 'entry_timeout=0', '-o', 'negative_timeout=0', '-o', 'attr_timeout=0', ] if PLATFORM == 'Darwin': self.fuse_cmdline_arguments.extend([ '-o', 'nolocalcaches', '-o', 'noreadahead', '-o', 'noubc', '-o', 'novncache', ]) else: self.fuse_cmdline_arguments.extend([ '-o', 'max_readahead=0', ]) if self.subtype: self.fuse_cmdline_arguments.extend( ['-o', 'subtype=%s' % self.subtype]) if self.readonly: self.fuse_cmdline_arguments.extend(['-o', READ_ONLY_MOUNT_OPTION]) if self.debug: self.fuse_cmdline_arguments.append('-d') if self.foreground: self.fuse_cmdline_arguments.append('-f') if not self.multithreaded: self.fuse_cmdline_arguments.append('-s') if self.allow_other: self.fuse_cmdline_arguments.extend(['-o', 'allow_other']) if self.allow_root: self.fuse_cmdline_arguments.extend(['-o', 'allow_root']) if self.nonempty: self.fuse_cmdline_arguments.extend(['-o', 'nonempty']) if self.uid is not None: self.fuse_cmdline_arguments.extend( ['-o', 'uid=%s' % str(self.uid)]) if self.gid is not None: self.fuse_cmdline_arguments.extend( ['-o', 'gid=%s' % str(self.gid)]) self.fuse_cmdline_arguments.extend([ '-o', 'fsname=%s' % self.source_tree_path.encode(self.user_encoding)]) self.fuse_cmdline_arguments.append( self.mount_point.encode(self.user_encoding)) def process_options(self, opts, args): self.debug = (opts.d or opts.o.debug) self.allow_other = opts.o.allow_other self.allow_root = opts.o.allow_root self.nonempty = opts.o.nonempty self.uid = opts.o.uid self.gid = opts.o.gid if not self.debug: self.foreground = opts.f else: self.foreground = True self.readonly = (opts.r or getattr(opts.o, READ_ONLY_MOUNT_OPTION)) self.multithreaded = (not opts.s) if opts.o.verbosity is not None: if self.debug: log_warning( u'warning: option debug overrides user-specified verbosity' ) self.verbosity = self.verbosities['debug'] else: try: self.verbosity = self.verbosities[opts.o.verbosity] except KeyError: raise OptParseError( 'verbosity should be one of %s' % ', '.join( self.verbosities.keys()) ) elif not self.debug: self.verbosity = self.verbosities[DEFAULT_VERBOSITY] self.logsize = opts.o.logsize self.iocharset = opts.o.iocharset self.source_iocharset = opts.o.source_iocharset self.profile = opts.o.profile self.path_filters = [] for which, expr in opts.o.filters: real = (which == 'src') self.path_filters.append((expr, real)) self.source_tree_path = os.path.abspath( unicode(args[0], self.user_encoding)) self.mount_point = os.path.abspath( unicode(args[1], self.user_encoding)) def pre_init(self): if self.profile: enable_profiling() set_logsize(self.logsize) set_log_level(self.verbosity) if self.foreground: enable_stderr() log_warning(u'pytagsfs version %s', version) log_warning(u'command-line arguments: %s', str(self.cmdline_arguments)) log_warning( u'fuse command-line arguments: %s', unicode(self.fuse_cmdline_arguments), ) self.source_tree_rep = self.build_source_tree_rep() self.multithreaded = ( self.multithreaded and self.source_tree_rep.supports_threads() ) log_warning(u'multithreaded = %s', self.multithreaded) # See note in init. if self.source_tree_rep.can_handle_fork(): log_warning( u'source tree representation can handle fork, ' u'calling source_tree_rep.start in pre_init' ) self.source_tree_rep.start() def build_source_tree_rep(self): raise NotImplementedError def encode_fake_path(self, s): return s.encode(self.iocharset) def decode_fake_path(self, s): return s.decode(self.iocharset) def encode_real_path(self, s): return self.source_tree_rep.source_tree.encode(s) def decode_real_path(self, s): return self.source_tree_rep.source_tree.decode(s) def get_next_fh(self): for fh, file_instance in enumerate(self.open_files): if file_instance is None: return fh raise ValueError def post_process_stat_result(self, stat_result): # Set st_ino and st_dev to zero since they are meaningless for us. return os.stat_result(( stat_result.st_mode, 0, 0, stat_result.st_nlink, stat_result.st_uid, stat_result.st_gid, stat_result.st_size, stat_result.st_atime, stat_result.st_mtime, stat_result.st_ctime, )) def post_process_statvfs_result(self, statvfs_result): return os.statvfs_result(( statvfs_result.f_bsize, statvfs_result.f_frsize, statvfs_result.f_blocks, statvfs_result.f_bfree, statvfs_result.f_bavail, statvfs_result.f_files, statvfs_result.f_ffree, statvfs_result.f_favail, # f_flag 0, statvfs_result.f_namemax, )) def get_real_path(self, fake_path): try: return self.frozen_path_mappings[fake_path].real_path except KeyError: return self.source_tree_rep.get_real_path(fake_path) def get_read_only_file_instance(self, fake_path, flags, truncate_to): return ReadOnlyFile(self, fake_path, flags, truncate_to = truncate_to) def get_read_write_file_instance(self, fake_path, flags, truncate_to): return ReadWriteFile(self, fake_path, flags, truncate_to = truncate_to) ################################################################################ # access # bmap chmod = operation_on_one_real_path(token_exchange.token_released(os.chmod)) chown = operation_on_one_real_path(token_exchange.token_released(os.chown)) # create def destroy(self): self.source_tree_rep.stop() @return_errno def fgetattr(self, fake_path, fh): return self.post_process_stat_result(self.open_files[fh].fgetattr()) @return_errno def flush(self, fake_path, fh): return self.open_files[fh].flush() @return_errno def fsync(self, fake_path, datasync, fh): return self.open_files[fh].fsync(datasync) # fsyncdir @return_errno def ftruncate(self, fake_path, len, fh): return self.open_files[fh].ftruncate(len) @return_errno def getattr(self, fake_path): fake_path = self.decode_fake_path(fake_path) try: real_path = self.frozen_path_mappings[fake_path].real_path except KeyError: # Path is not frozen. stat_result = self.source_tree_rep.getattr(fake_path) st_size = stat_result.st_size try: truncate_to = self.truncated_paths[fake_path] except KeyError: pass else: if st_size > truncate_to: st_size = truncate_to stat_result = os.stat_result(( stat_result.st_mode, stat_result.st_ino, stat_result.st_dev, stat_result.st_nlink, stat_result.st_uid, stat_result.st_gid, st_size, stat_result.st_atime, stat_result.st_mtime, stat_result.st_ctime, )) else: # Path is frozen. token_exchange.release_token() try: stat_result = os.lstat(real_path) finally: token_exchange.reacquire_token() return self.post_process_stat_result(stat_result) # getxattr def init(self): # We prefer to call source_tree_rep.start prior to the filesystem # process detaching from the user's shell, since the initial scan of # the source files can take some time and detaching before it is # complete leads to confusion as to whether the filesystem is hung or # not. Some SourceTreeMonitor implementations can't carry across the # fork call, though, so this provides a mechanism for start to be called # after that transition occurs. If this is not the case, # source_tree_rep.start is called at the end of pre_init, rather than # here. if not self.source_tree_rep.can_handle_fork(): log_warning( u"source tree representation can't handle fork, " u'calling source_tree_rep.start in init' ) self.source_tree_rep.start() # link # listxattr # lock @return_errno def mkdir(self, fake_path, mode): fake_path = self.decode_fake_path(fake_path) self.source_tree_rep.add_directory(fake_path) return 0 # mknod @return_errno def open(self, fake_path, flags): # When opening a file for writing, the virtual path is "frozen" so # that, if a write will cause the path to change, the same source # file continues to be accessible via the same virtual path. Once # the file is closed (i.e. is not open for writing by any processes), # the path is "thawed" and the virtual path may change at that point. fake_path = self.decode_fake_path(fake_path) is_writable = (os.O_RDWR | os.O_WRONLY) & flags if is_writable: truncate_to = self.truncated_paths.pop(fake_path, None) file_instance = self.get_read_write_file_instance( fake_path, flags, truncate_to) if truncate_to is not None: for _file_instance in ( self.read_only_files_by_fake_path.get(fake_path, ()) ): _file_instance.del_truncate_to() else: truncate_to = self.truncated_paths.get(fake_path, None) file_instance = self.get_read_only_file_instance( fake_path, flags, truncate_to, ) fh = self.get_next_fh() self.open_files[fh] = file_instance if is_writable: if fake_path not in self.frozen_path_mappings: log_debug( u'open: freezing path: %s, %s', fake_path, file_instance.real_path, ) self.frozen_path_mappings[fake_path] = FrozenPath( file_instance.real_path ) log_debug( u'open: incrementing count for frozen path: %s, %s', fake_path, file_instance.real_path, ) self.frozen_path_mappings[fake_path].increment() else: self.read_only_files_by_fake_path.setdefault( fake_path, [], ).append(file_instance) return fh # opendir @return_errno def read(self, fake_path, length, offset, fh): return self.open_files[fh].read(length, offset) @return_errno def readdir(self, fake_path, fh): fake_path = self.decode_fake_path(fake_path) entries = [ self.encode_fake_path(e) for e in self.source_tree_rep.get_entries(fake_path) ] return entries # readlink @return_errno def release(self, fake_path, flags, fh): fake_path = self.decode_fake_path(fake_path) is_writable = (os.O_RDWR | os.O_WRONLY) & flags file_instance = self.open_files[fh] self.open_files[fh] = None if is_writable: log_debug( 'release: decrementing count for frozen path: %s, %s', fake_path, file_instance.real_path, ) if not self.frozen_path_mappings[fake_path].decrement(): log_debug( 'release: thawing path: %s, %s', fake_path, file_instance.real_path, ) del self.frozen_path_mappings[fake_path] else: self.read_only_files_by_fake_path[fake_path].remove(file_instance) if not self.read_only_files_by_fake_path[fake_path]: del self.read_only_files_by_fake_path[fake_path] file_instance.release(flags) return 0 # releasedir # removexattr @return_errno def rename(self, old_fake_path, new_fake_path): old_fake_path = self.decode_fake_path(old_fake_path) new_fake_path = self.decode_fake_path(new_fake_path) self.source_tree_rep.rename_path(old_fake_path, new_fake_path) return 0 @return_errno def rmdir(self, fake_path): fake_path = self.decode_fake_path(fake_path) self.source_tree_rep.remove_directory(fake_path) return 0 # setxattr @return_errno def statfs(self): # Interestingly, os.statvfs seems to be converting unicode paths to # ASCII/sys.getdefaultencoding(). Other os.* functions seem to deal # with this differently, as they don't fail with unicode paths (but # os.statvfs does). This may vary from one Python version to the next. statvfs_result = os.statvfs( self.source_tree_rep.source_tree.encode( self.source_tree_rep.source_tree.root)) return self.post_process_statvfs_result(statvfs_result) # symlink @return_errno def truncate(self, fake_path, len): # truncate semantics are designed to accomodate programs that truncate # files before opening them for writing. Generally speaking, this is # poor form (as it is better to open the file for writing and then use # ftruncate), but shell scripts (for instance) may not have a lot of # choice on the matter. If the source file were immediately truncated, # the virtual file might change paths at once, and the program would # not have an opportunity to write the new file content. # # Thus, if a file that has not been opened for writing is truncated, # the truncation length is stored and filesystem operations behave as # though that is the file's length (if it is shorter than the real # length). When the file has been opened for writing, the source file # is actually truncated (but note that the path is now "frozen", so # the file will continue to be accessible from the same virtual path # until it is closed -- see the open method). # # Note that if the file has already been opened for writing (even by a # different process), the source file is truncated immediately. There # is one case that is not handled well due to an unavoidable race # condition. If the file is opened for writing by process A, # process B truncates the file (preparing to write to it), but A closes # it before B can open it, the virtual path may no longer be # accessible by the time B finally does open the file. fake_path = self.decode_fake_path(fake_path) # If the path is frozen, we truncate the source file immediately. try: real_path = self.frozen_path_mappings[fake_path].real_path except KeyError: pass else: real_path_encoded = self.encode_real_path(real_path) token_exchange.release_token() try: ftruncate_path(real_path_encoded, len) finally: token_exchange.reacquire_token() return # Otherwise, save the new length (if shorter than the existing value). truncate_to = self.truncated_paths.get(fake_path, None) if (truncate_to is None) or (len < truncate_to): self.truncated_paths[fake_path] = len for file_instance in ( self.read_only_files_by_fake_path.get(fake_path, ()) ): file_instance.set_truncate_to(len) # unlink @return_errno def utimens(self, fake_path, times): fake_path = self.decode_fake_path(fake_path) self.source_tree_rep.utime(fake_path, times) return 0 @return_errno def write(self, fake_path, buf, offset, fh): return self.open_files[fh].write(buf, offset) ################################################################################ class PyTagsFileSystemOptionParser(FileSystemMappingToRealFilesOptionParser): DEFAULT_MOUNT_OPTIONS = dict( FileSystemMappingToRealFilesOptionParser.DEFAULT_MOUNT_OPTIONS) DEFAULT_MOUNT_OPTIONS['sourcetreerep'] = { 'default': 'pytagsfs.sourcetreerep.pollinline.PollInLineSourceTreeRepresentation', 'help': SUPPRESS_HELP, } DEFAULT_MOUNT_OPTIONS['pathstore'] = { 'default': 'pytagsfs.pathstore.pytypes.PyTypesPathStore', 'help': SUPPRESS_HELP, } DEFAULT_MOUNT_OPTIONS['sourcetreemon'] = { 'default': None, 'help': SUPPRESS_HELP, } DEFAULT_MOUNT_OPTIONS['metastores'] = { 'default': ';'.join([ 'pytagsfs.metastore.path.PathMetaStore', 'pytagsfs.metastore.mutagen_.MutagenFileMetaStore', ]), 'help': SUPPRESS_HELP, } DEFAULT_MOUNT_OPTIONS['format'] = { 'default': u'%s%%f' % unicode_path_sep, 'metavar': 'FORMAT', 'help': 'set destination path format string (default: %default)', } DEFAULT_MOUNT_OPTIONS['nocache'] = { 'action': 'store_true', 'default': False, 'help': 'disable path property caching', } DEFAULT_MOUNT_OPTION_ORDER = ( 'format', 'srcfilter', 'dstfilter', 'iocharset', 'source_iocharset', READ_ONLY_MOUNT_OPTION, 'allow_other', 'allow_root', 'nonempty', 'uid', 'gid', 'nocache', 'verbosity', 'logsize', 'debug', 'profile', ) class PyTagsFileSystem( SpecialFileFileSystemMixin, FileSystemMappingToRealFiles, ): special_file_classes = [VirtualLogFile] source_tree_rep_cls_dotted_name = None path_store_cls_dotted_name = None source_tree_mon_cls_dotted_name = None meta_store_cls_dotted_names = None nocache = None format_string = None format_string_parts = None subtype = 'pytagsfs' def get_cmdline_parser(self): return PyTagsFileSystemOptionParser() def process_options(self, opts, args): super(PyTagsFileSystem, self).process_options(opts, args) self.source_tree_rep_cls_dotted_name = opts.o.sourcetreerep self.path_store_cls_dotted_name = opts.o.pathstore self.source_tree_mon_cls_dotted_name = opts.o.sourcetreemon self.meta_store_cls_dotted_names = opts.o.metastores self.nocache = opts.o.nocache self.format_string = opts.o.format # format string must not end with a / self.format_string = self.format_string.rstrip(unicode_path_sep) # format_string must start with a / if not self.format_string.startswith(unicode_path_sep): self.format_string = '%s%s' % ( unicode_path_sep, self.format_string) # format_string should not contain multiple consecutive /'s self.format_string = re.sub( ur'%s{2,}' % unicode_path_sep, unicode_path_sep, self.format_string) self.format_string_parts = split_path(self.format_string) @classmethod def get_meta_store(cls, meta_store_cls_dotted_names): meta_store_cls_dotted_names = meta_store_cls_dotted_names.split(';') meta_store_classes = [ get_obj_by_dotted_name(cls_name) for cls_name in meta_store_cls_dotted_names ] if len(meta_store_classes) == 1: meta_store = meta_store_classes[0]() else: meta_store = DelegateMultiMetaStore([ cls() for cls in meta_store_classes]) return meta_store def build_source_tree_rep(self): substitution_patterns = [ SubstitutionPattern(p) for p in self.format_string_parts ] source_tree_rep_cls = get_obj_by_dotted_name( self.source_tree_rep_cls_dotted_name) path_store_cls = get_obj_by_dotted_name( self.path_store_cls_dotted_name) if self.source_tree_mon_cls_dotted_name is not None: source_tree_mon_cls_dotted_names = [ self.source_tree_mon_cls_dotted_name] else: source_tree_mon_cls_dotted_names = list(SOURCE_TREE_MONITORS) monitor = None for source_tree_mon_cls_dotted_name in ( source_tree_mon_cls_dotted_names): log_debug( 'trying source tree monitor class %s', source_tree_mon_cls_dotted_name, ) try: monitor = get_source_tree_monitor( source_tree_mon_cls_dotted_name) except ComponentError, e: log_warning( u'WARNING: failed to initialize source tree monitor %s: %s', source_tree_mon_cls_dotted_name, unicode(e), ) else: break if monitor is None: raise OptParseError('No supported source tree monitor found.') meta_store = self.get_meta_store(self.meta_store_cls_dotted_names) if self.nocache: cache = None else: cache = PathPropCache() log_warning( u'source_tree_rep_cls: %s.%s', source_tree_rep_cls.__module__, source_tree_rep_cls.__name__, ) log_warning( u'path_store_cls: %s.%s', path_store_cls.__module__, path_store_cls.__name__, ) log_warning( u'source_tree_mon_cls: %s.%s', monitor.__class__.__module__, monitor.__class__.__name__, ) if not self.readonly: if not monitor.supports_writes(): raise OptParseError( ('Source tree monitor does not support writes. ' 'You must mount read-only with -o %s.' ) % READ_ONLY_MOUNT_OPTION ) return source_tree_rep_cls( meta_store = meta_store, substitution_patterns = substitution_patterns, path_store = path_store_cls(), source_tree = SourceTree( root = self.source_tree_path, iocharset = self.source_iocharset, ), monitor = monitor, cache = cache, filters = self.path_filters, debug = self.debug, ) pytagsfs-0.9.2/modules/pytagsfs/fs/mail.py0000644000175000017500000000446311315711421020167 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os from pytagsfs.util import return_errno from pytagsfs.fs import PyTagsFileSystemOptionParser, PyTagsFileSystem class PyMailTagsFileSystemOptionParser(PyTagsFileSystemOptionParser): DEFAULT_MOUNT_OPTIONS = dict( PyTagsFileSystemOptionParser.DEFAULT_MOUNT_OPTIONS) DEFAULT_MOUNT_OPTIONS['format']['default'] = u'/cur/%{maildir_tag}/%f' DEFAULT_MOUNT_OPTIONS['metastores']['default'] = ';'.join([ 'pytagsfs.metastore.path.PathMetaStore', 'pytagsfs.metastore.maildir.MaildirMetaStore', ]) class PyMailTagsFileSystem(PyTagsFileSystem): subtype = 'pymailtagsfs' def get_cmdline_parser(self): return PyMailTagsFileSystemOptionParser() def readdir(self, fake_path, fh): if fake_path in ('/tmp', '/new'): return [] entries = super(PyMailTagsFileSystem, self).readdir(fake_path, fh) if fake_path == '/': if 'cur' not in entries: entries.append('cur') entries.append('tmp') entries.append('new') return entries def getattr(self, fake_path): if fake_path in ('/tmp', '/new'): stat_result = super(PyMailTagsFileSystem, self).getattr('/cur') else: stat_result = super(PyMailTagsFileSystem, self).getattr(fake_path) st_nlink = stat_result.st_nlink if fake_path == '/': st_nlink = 5 elif fake_path in ('/tmp', '/new'): st_nlink = 2 return os.stat_result(( stat_result.st_mode, stat_result.st_ino, stat_result.st_dev, st_nlink, stat_result.st_uid, stat_result.st_gid, stat_result.st_size, stat_result.st_atime, stat_result.st_mtime, stat_result.st_ctime, )) @return_errno def rmdir(self, fake_path): if old_fake_path.count('/') == 1: raise InvalidArgument() return super(PyMailTagsFileSystem, self).rmdir(fake_path) pytagsfs-0.9.2/modules/pytagsfs/subspat.py0000644000175000017500000003316011315711421020312 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import re, copy from pytagsfs.regex import ( Regex, Group, SimpleExpression, CompoundSegment, NamedGroup, ) from pytagsfs.exceptions import ErrorSupportingUnicode from pytagsfs.util import sorted_items class Error(ErrorSupportingUnicode): pass class PatternSyntaxError(Error): problem_area_length = 10 problem_area_suffix = u'...' def __init__(self, pattern, offset): self.pattern = pattern self.offset = offset def __unicode__(self): problem_area = self.pattern[ self.offset:self.offset + self.problem_area_length] if len(self.pattern) > ( self.offset + self.problem_area_length + len(self.problem_area_suffix) ): problem_area = '%s%s' % (problem_area, self.problem_area_suffix) return u'syntax error in %s near %s' % ( repr(self.pattern), repr(problem_area), ) class SplitError(Error): def __init__(self, regex_string, split_string): self.regex_string = regex_string self.split_string = split_string def __unicode__(self): return u'failed to split string %s with regex %s' % ( repr(self.split_string), repr(self.regex_string)) class FillError(Error): def __init__(self, expression, substitutions, parameters = ()): self.expression = expression self.substitutions = substitutions self.parameters = list(parameters) def __unicode__(self): s = u'failed to fill expression %s with substitutions %s' % ( repr(self.expression), repr(self.substitutions)) if self.parameters is not None: s = u'%s (undefined parameters: %s)' % (s, ', '.join([ repr(p) for p in self.parameters])) return s class Node(object): expression = None def __init__(self, expression): self.expression = expression def fill(self, substitutions): raise NotImplementedError def get_regex_segment(self, substitutions): raise NotImplementedError @classmethod def consume(cls, s): raise NotImplementedError class SectionNode(Node): # class attributes child_node_types = [] # instance attributes child_nodes = None def __init__(self, expression): self.expression = expression self.child_nodes = self.get_child_nodes() super(SectionNode, self).__init__(expression) @classmethod def register_child_node_type(cls, child_node_type): if child_node_type not in cls.child_node_types: cls.child_node_types.append(child_node_type) def get_regex_segment(self, substitutions): segment = CompoundSegment() for child_node in self.child_nodes: segment.append(child_node.get_regex_segment(substitutions)) return segment def get_contents(self): return self.expression def get_child_nodes(self): return self.get_nodes_from_expression(self.get_contents()) def get_nodes_from_expression(self, s): orig_s = s child_nodes = [] while True: if s == '': break previous_number_of_child_nodes = len(child_nodes) for child_node_type in self.child_node_types: child_node, s = child_node_type.consume(s) if child_node is not None: child_nodes.append(child_node) break if s == '': break if len(child_nodes) == previous_number_of_child_nodes: raise PatternSyntaxError(orig_s, (len(orig_s) - len(s))) return child_nodes @classmethod def consume(cls, s): return cls(s), '' def fill(self, substitutions): return ''.join([ child_node.fill(substitutions) for child_node in self.child_nodes]) def get_split_regex(self, substitutions): regex = Regex() regex.append(SimpleExpression('^')) for child_node in self.child_nodes: regex.append(child_node.get_regex_segment(substitutions)) regex.append(SimpleExpression('$')) return regex def get_splitter(self, substitutions): regex = self.get_split_regex(substitutions) return Splitter(regex.get_regex(), regex.get_string()) def iter_child_nodes_recursive(self, nodes = None): if nodes is None: nodes = self.child_nodes for node in nodes: yield node if hasattr(node, 'iter_child_nodes_recursive'): for _node in node.iter_child_nodes_recursive(): yield _node class Splitter(object): regex = None string = None def __init__(self, regex, string): self.regex = regex self.string = string def split(self, s): mo = self.regex.match(s) if mo is None: raise SplitError(self.string, s) return mo.groupdict() def __eq__(self, other): if hasattr(other, 'string'): return (self.string == other.string) return super(Splitter, self).__eq__(other) class TextNode(Node): def fill(self, substitutions): if self.expression is None: raise AssertionError return self.expression def get_regex_segment(self, substitutions): return SimpleExpression(re.escape(self.expression)) @classmethod def consume(cls, s): index = 0 while True: try: char = s[index] except IndexError: break try: next_char = s[index + 1] except IndexError: next_char = None if (char == '%') and (next_char != '%'): break index = index + 1 if (char == '%') and (next_char == '%'): index = index + 1 if index == 0: return None, s return cls(s[:index]), s[index:] class VariableNode(Node): # class attributes parse_regex_string = None parse_regex = None modifiers = { None: lambda s: s, '_': lambda s: s.lower(), '^': lambda s: s.upper(), '!': lambda s: s.title(), } # instance attributes match_object = None variable_name = None modifier = None def __init__(self, expression, match_object = False): super(VariableNode, self).__init__(expression) self.match_object = self.create_match_object(match_object) self.variable_name = self.parse_variable_name() self.modifier = self.parse_modifier() def create_match_object(self, match_object): if match_object is False: match_object = self.parse_regex.search(self.expression) return match_object @classmethod def consume(cls, s): mo = cls.parse_regex.search(s) if mo is not None: end = mo.end() if end > 0: return cls(mo.group(0), match_object = mo), s[end:] return None, s def parse_variable_name(self): if self.match_object is None: # FIXME raise PatternSyntaxError(self.expression) try: return self.match_object.group('name') except IndexError: # FIXME raise PatternSyntaxError(self.expression) def parse_modifier(self): if self.match_object is None: # FIXME raise PatternSyntaxError(self.expression) try: return self.match_object.group('modifier') except IndexError: return None def get_regex_segment(self, substitutions): return NamedGroup(self.variable_name, [SimpleExpression('.+?')]) def fill(self, substitutions): value = substitutions.get(self.variable_name, None) if value is None: raise FillError( self.expression, substitutions, [self.variable_name]) return self.modify(value) def modify(self, s): return self.modifiers[self.modifier](s) class LongKeyVariableNode(VariableNode): parse_regex_string = r'^%(?P[_^!])?{(?P[^}]+?)}' parse_regex = re.compile(parse_regex_string) class ShortKeyVariableNode(VariableNode): parse_regex_string = r'^%(?P[_^!])?(?P[A-Za-z])' parse_regex = re.compile(parse_regex_string) class ConditionalNode(SectionNode): def get_regex_segment(self, substitutions): segment = CompoundSegment() segment.append(SimpleExpression('(?:')) for child_node in self.child_nodes: segment.append(child_node.get_regex_segment(substitutions)) segment.append(SimpleExpression(')?')) return segment def get_contents(self): return self.expression[2:-2] @classmethod def consume(cls, s): if s.startswith('%?'): try: end_index = s.index('%?', 2) + 2 except ValueError: pass else: return cls(s[:end_index]), s[end_index:] return None, s def fill(self, substitutions): try: return super(ConditionalNode, self).fill(substitutions) except FillError: return '' class IfElseNode(SectionNode): left_side_child_nodes = None right_side_child_nodes = None def __init__(self, expression): self.expression = expression self.left_side_child_nodes = self.get_left_side_child_nodes() self.right_side_child_nodes = self.get_right_side_child_nodes() super(IfElseNode, self).__init__(expression) def get_regex_segment(self, substitutions): node_groups = ( self.left_side_child_nodes, self.right_side_child_nodes) variable_node_groups = tuple( tuple( n for n in self.iter_child_nodes_recursive(node_group) if isinstance(n, VariableNode) ) for node_group in node_groups ) unknown_node_groups = tuple( tuple(n for n in node_group if n.variable_name not in substitutions) for node_group in variable_node_groups ) number_of_unknowns = tuple( len(node_group) for node_group in unknown_node_groups) unknowns_left, unknowns_right = number_of_unknowns if unknowns_left < unknowns_right: regex_node_groups = ( self.left_side_child_nodes, self.right_side_child_nodes) elif unknowns_left > unknowns_right: regex_node_groups = ( self.right_side_child_nodes, self.left_side_child_nodes) else: number_of_variables = tuple( len(node_group) for node_group in variable_node_groups) variables_left, variables_right = number_of_variables if variables_left <= variables_right: regex_node_groups = ( self.left_side_child_nodes, self.right_side_child_nodes) elif variables_left > variables_right: regex_node_groups = ( self.right_side_child_nodes, self.left_side_child_nodes) regex_segments = tuple( CompoundSegment( [n.get_regex_segment(substitutions) for n in node_group]) for node_group in regex_node_groups ) segment = CompoundSegment() segment.append(SimpleExpression('(?:')) segment.append(regex_segments[0]) segment.append(SimpleExpression('|')) segment.append(regex_segments[1]) segment.append(SimpleExpression(')')) return segment def get_child_nodes(self): return self.right_side_child_nodes + self.left_side_child_nodes def get_left_side_child_nodes(self): return self.get_nodes_from_expression(self.get_left_side_expression()) def get_right_side_child_nodes(self): return self.get_nodes_from_expression(self.get_right_side_expression()) def get_left_side_expression(self): return self.expression[2:self.expression.index('%:')] def get_right_side_expression(self): return self.expression[self.expression.index('%:') + 2:-2] @classmethod def consume(cls, s): if s.startswith('%?'): try: end_index = s.index('%?', 2) + 2 except ValueError: pass else: expression = s[:end_index] try: middle_index = expression.index('%:') + 2 except ValueError: pass else: return cls(s[:end_index]), s[end_index:] return None, s def fill(self, substitutions): try: return ''.join([ child_node.fill(substitutions) for child_node in self.left_side_child_nodes ]) except FillError, e1: pass try: return ''.join([ child_node.fill(substitutions) for child_node in self.right_side_child_nodes ]) except FillError, e2: pass raise FillError( self.expression, substitutions, e1.parameters + e2.parameters) SectionNode.register_child_node_type(IfElseNode) SectionNode.register_child_node_type(ConditionalNode) SectionNode.register_child_node_type(TextNode) SectionNode.register_child_node_type(LongKeyVariableNode) SectionNode.register_child_node_type(ShortKeyVariableNode) class SubstitutionPattern(SectionNode): pass pytagsfs-0.9.2/modules/pytagsfs/specialfile/0000755000175000017500000000000011315711421020534 5ustar forestforestpytagsfs-0.9.2/modules/pytagsfs/specialfile/__init__.py0000644000175000017500000001651011315711421022650 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os from pytagsfs.file import File from pytagsfs.util import ( return_errno, join_path_abs, ) from pytagsfs.exceptions import InvalidArgument from pytagsfs.debug import log_debug def delegated_class_method(name): def fn(self, fake_path, *args, **kwargs): try: cls = self._special_file_classes_by_path[fake_path] except KeyError: return getattr(super(SpecialFileFileSystemMixin, self), name)( fake_path, *args, **kwargs) log_debug( u'delegated_class_method: name=%r, fake_path=%r: delegating to %s', name, fake_path, cls.__name__, ) return getattr(cls, name)(fake_path, *args, **kwargs) return fn class SpecialFileFileSystemMixin(object): special_file_classes = None _special_file_classes_by_path = None def get_read_only_file_instance(self, fake_path, flags, truncate_to): try: cls = self._special_file_classes_by_path[fake_path] except KeyError: return super( SpecialFileFileSystemMixin, self ).get_read_only_file_instance(fake_path, flags, truncate_to) return cls.ReadOnly(self, fake_path, flags, truncate_to) def get_read_write_file_instance(self, fake_path, flags, truncate_to): try: cls = self._special_file_classes_by_path[fake_path] except KeyError: return super( SpecialFileFileSystemMixin, self ).get_read_write_file_instance(fake_path, flags, truncate_to) return cls.ReadWrite(self, fake_path, flags, truncate_to) ################################################################################ access = return_errno(delegated_class_method('access')) # bmap: TBD chmod = return_errno(delegated_class_method('chmod')) chown = return_errno(delegated_class_method('chown')) create = return_errno(delegated_class_method('create')) # destroy: not needed # fgetattr: handled by sub-class -> file instance # flush: handled by sub-class -> file instance # fsync: handled by sub-class -> file instance # fsyncdir: handled by sub-class -> file instance # ftruncate: handled by sub-class -> file instance _getattr = delegated_class_method('getattr') @return_errno def getattr(self, fake_path): stat_result = self._getattr(fake_path) if fake_path == os.path.sep: # Increase st_nlink by len(self.special_file_classes). # Can't use any fancy tricks treating stat_result as a tuple # because we'd lose atime, mtime, ctime floats. stat_result = os.stat_result(( stat_result.st_mode, #st_mode stat_result.st_ino, #st_ino stat_result.st_dev, #st_dev ( #st_nlink stat_result.st_nlink + len(self.special_file_classes) ), stat_result.st_uid, #st_uid stat_result.st_gid, #st_gid stat_result.st_size, #st_size stat_result.st_atime, #st_atime stat_result.st_mtime, #st_mtime stat_result.st_ctime, #st_ctime )) return stat_result getxattr = return_errno(delegated_class_method('getxattr')) def init(self): self._special_file_classes_by_path = {} for cls in self.special_file_classes: self._special_file_classes_by_path[ join_path_abs([cls.filename])] = cls cls.filesystem = self log_debug( 'SpecialFileFileSystemMixin: _special_file_classes_by_path = %r', self._special_file_classes_by_path, ) return super(SpecialFileFileSystemMixin, self).init() # link: not relevant listxattr = return_errno(delegated_class_method('listxattr')) # lock: TBD # mkdir: not relevant # mknod: not relevant # open: handled by sub-class -> file instance # opendir: not relevant # read: handled by sub-class -> file instance _readdir = delegated_class_method('readdir') @return_errno def readdir(self, fake_path, fh): result = self._readdir(fake_path, fh) if fake_path == os.path.sep: new_result = [ self.encode_fake_path(cls.filename) for cls in self.special_file_classes ] new_result.extend(result) result = new_result return result readlink = return_errno(delegated_class_method('readlink')) # release: handled by sub-class -> file instance # releasedir: not relevant removexattr = return_errno(delegated_class_method('removexattr')) rename = return_errno(delegated_class_method('rename')) rmdir = return_errno(delegated_class_method('rmdir')) setxattr = return_errno(delegated_class_method('setxattr')) # statfs: not relevant # symlink: not relevant truncate = return_errno(delegated_class_method('truncate')) # unlink: not relevant utimens = return_errno(delegated_class_method('utimens')) # write: handled by sub-class -> file instance def not_implemented(*args, **kwargs): raise NotImplementedError class SpecialFile(File): filename = None filesystem = None def __init__(self, filesystem, fake_path, flags, truncate_to): self.filesystem = filesystem self.fake_path = fake_path self.flags = flags self.truncate_to = truncate_to @classmethod def ReadOnly(cls, filesystem, fake_path, flags, truncate_to): return cls(filesystem, fake_path, flags, truncate_to) @classmethod def ReadWrite(cls, filesystem, fake_path, flags, truncate_to): return cls(filesystem, fake_path, flags, truncate_to) ################################################################################ access = classmethod(return_errno(not_implemented)) # bmap: TBD chmod = classmethod(return_errno(not_implemented)) chown = classmethod(return_errno(not_implemented)) # create: not relevant # destroy: not relevant # fgetattr: inherited # flush: inherited # fsync: inherited # ftruncate: inherited getattr = classmethod(return_errno(not_implemented)) getxattr = classmethod(return_errno(not_implemented)) # init: not relevant listxattr = classmethod(return_errno(not_implemented)) # lock: TBD # mkdir: not relevant # mknod: not relevant # open: inherited # opendir: not relevant # read: inherited # readdir: not relevant readlink = classmethod(return_errno(not_implemented)) # release: inherited # releasedir: not relevant removexattr = classmethod(return_errno(not_implemented)) # rename: not relevant # rmdir: not relevant setxattr = classmethod(return_errno(not_implemented)) # statfs: not relevant # symlink: not relevant truncate = classmethod(return_errno(not_implemented)) # unlink: not relevant utimens = classmethod(return_errno(not_implemented)) # write: inherited pytagsfs-0.9.2/modules/pytagsfs/specialfile/logfile.py0000644000175000017500000001116611315711421022534 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, errno, stat, traceback, sys try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps from pytagsfs.util import ( now, join_path_abs, ) from pytagsfs.exceptions import InvalidArgument from pytagsfs.specialfile import SpecialFile class RingCharacterBuffer(object): max_length = None buffer = None len = None def __init__(self, max_length): self.max_length = max_length self.buffer = [] self.len = 0 def write(self, s): if not isinstance(s, str): raise AssertionError( 'RingCharacterBuffer.write: argument should be a byte string.' ) self.buffer.extend(list(s)) self.len = self.len + len(s) if self.len > self.max_length: del self.buffer[0:self.len - self.max_length] self.len = self.max_length self.__class__ = FullRingCharacterBuffer def tell(self): return self.len def getvalue(self): return ''.join(self.buffer) class FullRingCharacterBuffer(RingCharacterBuffer): def write(self, s): if not isinstance(s, str): raise AssertionError( 'RingCharacterBuffer.write: argument should be a byte string.') self.buffer.extend(list(s)) del self.buffer[0:len(s)] class VirtualLogFile(SpecialFile): # class filename = u'.log' encoding = 'utf-8' file_obj = RingCharacterBuffer(1024 * 1024) init_time = now() atime = init_time mtime = init_time ctime = init_time log_file_highest_fd = 0 log_file_open_files = {} ################################################################################ @classmethod def set_max_length(cls, bytes): cls.file_obj.max_length = bytes @classmethod def log_write(cls, s): if isinstance(s, unicode): s = s.encode(cls.encoding) cls.file_obj.write(s) cls.mtime = now() @classmethod def ReadOnly(cls, filesystem, fake_path, flags, truncate_to): if truncate_to is not None: raise InvalidArgument() return super(VirtualLogFile, cls).ReadOnly( filesystem, fake_path, flags, truncate_to, ) @classmethod def ReadWrite(cls, filesystem, fake_path, flags, truncate_to): raise InvalidArgument() ################################################################################ # access # bmap: TBD # chmod # chown # create: not relevant # destroy: not relevant def fgetattr(self): return self.getattr(join_path_abs([self.filename])) def flush(self): pass def fsync(self, datasync): pass # ftruncate @classmethod def getattr(cls, path): root_statinfo = cls.filesystem.getattr(os.path.sep) st_dev = root_statinfo.st_dev st_uid = root_statinfo.st_uid st_gid = root_statinfo.st_gid return os.stat_result(( (stat.S_IFREG | 0444), #st_mode 0, #st_ino st_dev, #st_dev 1, #st_nlink st_uid, #st_uid st_gid, #st_gid cls.file_obj.tell(), #st_size cls.atime, #st_atime cls.mtime, #st_mtime cls.ctime, #st_ctime )) # getxattr # init: not relevant # listxattr # lock: TBD # mkdir: not relevant # mknod: not relevant # open: inherited # opendir: not relevant def read(self, length, offset): try: return self.file_obj.getvalue()[offset:offset+length] except: print >>sys.stderr, traceback.format_exc() raise # readdir: not relevant # readlink # release: inherited # releasedir: not relevant # removexattr # rename: not relevant # rmdir: not relevant # setxattr # statfs: not relevant # symlink: not relevant # truncate # unlink: not relevant @classmethod def utimens(cls, path, times): try: cls.atime, cls.mtime = times except (TypeError, ValueError): cls.atime = now() cls.mtime = cls.atime # write pytagsfs-0.9.2/modules/pytagsfs/pathpropcache.py0000644000175000017500000000177411315711421021460 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. class PathPropCache(object): d = None def __init__(self): self.d = {} def put(self, path, key, value): try: path_d = self.d[path] except KeyError: path_d = {} self.d[path] = path_d path_d[key] = value def get(self, path, key): return self.d[path][key] def prune(self, path = None, key = None): if key is not None: if path is None: raise ValueError('Must specify path if key is specified.') del self.d[path][key] return if path is not None: del self.d[path] return self.d.clear() pytagsfs-0.9.2/modules/pytagsfs/util.py0000644000175000017500000001267011315711421017611 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os.path, errno try: from functools import wraps except ImportError: from sclapp.legacy_support import wraps from pytagsfs.exceptions import ( PathNotFound, NotADirectory, PathExists, DirectoryNotEmpty, InvalidArgument, ) from pytagsfs.exceptions import FuseError unicode_path_sep = unicode(os.path.sep) def now(): import time return int(time.time()) def unique(iter): ''' Generator; iterates over iter and yields each item that has not been seen already. This algorithm prefers items toward the beginning of the list. >>> list(unique([1, 2, 5, 4, 5, 2, 3, 6, 2])) [1, 2, 5, 4, 3, 6] ''' seen = [] for item in iter: if item not in seen: yield item seen.append(item) def last_unique(iter): ''' Like unique, but prefer items toward the end of the list. Also, returns a list rather than an iterator object. Given a list l, last_unique(l) is functionally equivalent to list(reversed(list(unique(reversed(l))))). >>> last_unique([1, 2, 5, 4, 5, 2, 3, 6, 2]) [1, 4, 5, 3, 6, 2] ''' result = [] for item in iter: try: result.remove(item) except ValueError: pass result.append(item) return result def sorted_items(d): return [(k, d[k]) for k in sorted(d.keys())] def merge_dicts(*dicts): ''' >>> d1 = {'a': 'x', 'b': 'y'} >>> d2 = {'b': 'm', 'c': 'n'} >>> sorted_items(merge_dicts(d1, d2)) [('a', 'x'), ('b', 'm'), ('c', 'n')] ''' result = {} for d in dicts: result.update(d) return result def ref_self(self, *args, **kwargs): return self def rpartition(s, by): ''' In Python 2.4, str's have no method "rpartition". This function tries to use Python 2.5's str method, and falls back to a custom implementation. ''' if ( isinstance(s, unicode) and not isinstance(by, unicode) ) or ( isinstance(by, unicode) and not isinstance(s, unicode) ): raise TypeError('both arguments must be unicode or str') try: return s.rpartition(by) except AttributeError: pass parts = s.split(by) if len(parts) == 1: return ('', '', s) return (by.join(parts[:-1]), by, parts[-1]) def get_obj_by_dotted_name(dotted_name): from sclapp.util import importName # Note: both arguments to rpartition must be of same type (unicode, str). modname, dot, objname = rpartition(dotted_name, type(dotted_name)('.')) mod = importName(modname) return getattr(mod, objname) def return_errno(fn): @wraps(fn) def wrapper(*args, **kwargs): try: return fn(*args, **kwargs) except PathNotFound: raise FuseError(errno.ENOENT) except NotADirectory: raise FuseError(errno.ENOTDIR) except PathExists: raise FuseError(errno.EEXIST) except DirectoryNotEmpty: raise FuseError(errno.ENOTEMPTY) except InvalidArgument: raise FuseError(errno.EINVAL) except NotImplementedError: raise FuseError(errno.ENOSYS) except (IOError, OSError), e: if hasattr(e, 'errno') and e.errno > 0: raise FuseError(e.errno) raise return wrapper def split_path(path): if path.endswith(unicode_path_sep): raise ValueError(path) parts = [] while True: path, part = os.path.split(path) if not part: break parts.append(part) return list(reversed(parts)) def join_path(path_parts): return os.path.join(*path_parts) def join_path_rel(path_parts): path = os.path.join(*path_parts) return path.lstrip(unicode_path_sep) def join_path_abs(path_parts): all_path_parts = [unicode_path_sep] all_path_parts.extend(path_parts) return os.path.join(*all_path_parts) class LazyString(object): evaluator = None args = None kargs = None def __init__(self, evaluator, *args, **kwargs): self.evaluator = evaluator self.args = args self.kwargs = kwargs def __str__(self): raise NotImplementedError def __unicode__(self): raise NotImplementedError class LazyByteString(LazyString): def __str__(self): return self.evaluator(*self.args, **self.kwargs) def __unicode__(self): return unicode(str(self)) class LazyUnicodeString(LazyString): def __str__(self): return str(unicode(self)) def __unicode__(self): return self.evaluator(*self.args, **self.kwargs) def ftruncate_path(path, length): # See unsafe_truncate to understand why this exists. f = open(path, 'r+') try: f.truncate(length) finally: f.close() def unsafe_truncate(path, length): import ctypes from ctypes.util import find_library libc = ctypes.CDLL(find_library('libc')) # XXX: This is the unsafe assumption here. c_off_t = ctypes.c_int64 path_type = type(path) if path_type is not str: raise TypeError('path must be of type str, not %s' % repr(path_type)) libc.truncate(path, c_off_t(length)) pytagsfs-0.9.2/setup.py0000755000175000017500000002142511315711421014465 0ustar forestforest#!/usr/bin/env python # Author: Forest Bond # This file is in the public domain. import os, sys, commands from distutils.command.build import build as _build from distutils.command.clean import clean as _clean from distutils.command.build_py import build_py from distutils.core import setup, Command from distutils.spawn import spawn from distutils import log from distutils.dir_util import remove_tree from distutils.dist import Distribution project_dir = os.path.dirname(__file__) modules_dir = os.path.join(project_dir, 'modules') sys.path.insert(0, modules_dir) sys.path.insert(0, project_dir) from tests.common import TEST_DATA_DIR ################################################################################ class test(Command): description = 'run tests' user_options = [ ('tests=', None, 'names of tests to run'), ('print-only', None, "don't run tests, just print their names"), ('coverage', None, "print coverage analysis (requires coverage.py)"), ] def initialize_options(self): self.tests = None self.print_only = False self.coverage = False def finalize_options(self): if self.tests is not None: self.tests = self.tests.split(',') def run(self): from tests import main main( test_names = self.tests, print_only = self.print_only, coverage = self.coverage, ) ################################################################################ class clean(_clean): temporary_files = [] nontemporary_files = [] temporary_dirs = [] nontemporary_dirs = [] def clean_file(self, filename): if not os.path.exists(filename): log.info("'%s' does not exist -- can't clean it", filename) return log.info("removing '%s'" % filename) if not self.dry_run: try: os.unlink(filename) except (IOError, OSError): log.warn("failed to remove '%s'" % filename) def clean_dir(self, dirname): if not os.path.exists(dirname): log.info("'%s' does not exist -- can't clean it", dirname) return log.info("removing '%s' (and everything under it)" % dirname) if not self.dry_run: try: remove_tree(dirname) except (IOError, OSError): log.warn("failed to remove '%s'" % dirname) def clean_test_data(self): from pytagsfs.fs import UMOUNT_COMMAND try: dirs = os.listdir(TEST_DATA_DIR) except (IOError, OSError): log.warn( "not cleaning '%s': failed to read directory" % TEST_DATA_DIR) else: for dir in dirs: full_dir = os.path.join(TEST_DATA_DIR, dir) mnt_dir = os.path.join(full_dir, 'mnt') log.info("unmounting '%s'" % mnt_dir) status, output = commands.getstatusoutput( UMOUNT_COMMAND % mnt_dir) if status != 0: print >>sys.stderr, output self.clean_dir(full_dir) self.clean_dir(TEST_DATA_DIR) def run(self): self.clean_test_data() remove_files = list(self.temporary_files) if self.all: remove_files = remove_files + self.nontemporary_files for filename in remove_files: if callable(filename): filename = filename(self.distribution) self.clean_file(filename) remove_dirs = list(self.temporary_dirs) if self.all: remove_dirs = remove_dirs + self.nontemporary_dirs for dirname in remove_dirs: if callable(dirname): dirname = dirname(self.distribution) self.clean_dir(dirname) _clean.run(self) ################################################################################ def find_docbook_manpage_stylesheet(): from libxml2 import catalogResolveURI return catalogResolveURI( 'http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl' ) class build_manpages(Command): xsltproc = ['xsltproc', '--nonet', '--novalid', '--xinclude'] description = 'Build manual pages from docbook XML.' user_options = [] man_build_dir = 'build/man' stylesheet = find_docbook_manpage_stylesheet() def initialize_options(self): pass def finalize_options(self): if self.distribution.manpage_sources is not None: self.docbook_files = [ os.path.abspath(p) for p in self.distribution.manpage_sources if p.endswith('.xml') ] def build_manpage_from_docbook(self, docbook_file): assert self.stylesheet is not None, 'failed to find stylesheet' command = self.xsltproc + [self.stylesheet, docbook_file] orig_wd = os.getcwd() os.chdir(self.man_build_dir) try: spawn(command, dry_run = self.dry_run) finally: os.chdir(orig_wd) def run(self): if self.stylesheet is None: log.warn( 'Warning: missing docbook XSL stylesheets; ' 'manpages will not be built.\n' 'Please install the docbook XSL stylesheets from ' 'http://docbook.org/.' ) manpage_sources = self.docbook_files if manpage_sources: if not os.path.exists(self.man_build_dir): os.mkdir(self.man_build_dir) for docbook_file in self.docbook_files: self.build_manpage_from_docbook(docbook_file) clean.nontemporary_dirs.append('build/man') Distribution.manpage_sources = None ################################################################################ class build_version_file(build_py): def initialize_options(self): build_py.initialize_options(self) self.version = None self.version_file = None def finalize_options(self): build_py.finalize_options(self) self.packages = self.distribution.packages self.py_modules = [self.distribution.version_module] self.version = self.distribution.get_version() self.version_file = self.distribution.version_file def check_module(self, *args, **kwargs): pass def build_modules(self, *args, **kwargs): log.info("creating version file '%s'" % self.version_file) if not self.dry_run: f = open(self.version_file, 'w') f.write('version = %s\n' % repr(self.version)) f.close() build_py.build_modules(self, *args, **kwargs) clean.temporary_files.append(lambda distribution: distribution.version_file) Distribution.version_module = None Distribution.release_file = None def get_bzr_version(): status, output = commands.getstatusoutput('bzr revno') return 'bzr%s' % output.strip() def get_version(release_file): try: f = open(release_file, 'r') try: version = f.read().strip() finally: f.close() except (IOError, OSError): version = get_bzr_version() return version def get_version_file(version_module): return '%s.py' % os.path.join( *(['modules'] + version_module.split('.')) ) def wrap_init(fn): def __init__(self, *args, **kwargs): fn(self, *args, **kwargs) self.version_file = get_version_file(self.version_module) self.metadata.version = get_version(self.release_file) return __init__ Distribution.__init__ = wrap_init(Distribution.__init__) ################################################################################ class build(_build): sub_commands = _build.sub_commands + [ ('build_version_file', (lambda self: True)), ('build_manpages', (lambda self: True)), ] ################################################################################ data_files = [] manpage_sources = [] if build_manpages.stylesheet is not None: manpage_sources = ['pytagsfs.xml', 'pytags.xml'] manpages = [ os.path.join( 'build', 'man', s.replace('xml', '1'), ) for s in manpage_sources ] data_files.append(('share/man/man1', manpages)) setup( cmdclass = { 'test': test, 'build': build, 'build_version_file': build_version_file, 'build_manpages': build_manpages, 'clean': clean, }, name = 'pytagsfs', version_module = 'pytagsfs.version', package_dir = { 'pytagsfs': os.path.join('modules', 'pytagsfs') }, packages = [ 'pytagsfs', 'pytagsfs.fs', 'pytagsfs.metastore', 'pytagsfs.pathstore', 'pytagsfs.sourcetreemon', 'pytagsfs.sourcetreerep', 'pytagsfs.specialfile', ], scripts = [ 'pytagsfs', 'pytags', ], manpage_sources = manpage_sources, release_file = 'release', data_files = data_files, ) pytagsfs-0.9.2/util/0000755000175000017500000000000011315711421013721 5ustar forestforestpytagsfs-0.9.2/util/monitor-directory0000755000175000017500000000630611315711421017345 0ustar forestforest#!/usr/bin/env python # Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import sys, os, stat, time, optparse, signal from sclapp import main_function from pytagsfs.sourcetreemon import ( get_source_tree_monitor, SOURCE_TREE_MONITORS, ) from pytagsfs.exceptions import MissingDependency def add_source_dir(stm, path): stm.add_source_dir(path) try: names = os.listdir(path) except (OSError, IOError): return for name in names: sub_path = os.path.join(path, name) stm.add_cb(sub_path) def make_add_cb(stm): def add_cb(path, is_dir = None): print 'ADD', path, is_dir if is_dir is None: add_source_dir(stm, path) stm.add_source_file(path) elif is_dir: add_source_dir(stm, path) else: stm.add_source_file(path) return add_cb def make_remove_cb(stm): def remove_cb(path, is_dir = None): print 'REMOVE', path, is_dir if is_dir is None: stm.remove_source_dir(path) stm.remove_source_file(path) elif is_dir: stm.remove_source_dir(path) else: stm.remove_source_file(path) return remove_cb def make_update_cb(stm): def update_cb(path, is_dir = None): print 'UPDATE', path, is_dir return update_cb def choose_source_tree_monitor(stm_dotted_name = None): if stm_dotted_name is not None: candidates = [stm_dotted_name] else: candidates = SOURCE_TREE_MONITORS for candidate in candidates: try: stm = get_source_tree_monitor(candidate) except MissingDependency, e: print >>sys.stderr, ( 'source tree monitor %s unsupported ' 'due to missing dependency %s' ) % (candidate, str(e)) else: print >>sys.stderr, 'using source tree monitor %s' % candidate return stm raise AssertionError('unable to find a usable source tree monitor') def handle_argv(argv): parser = optparse.OptionParser(usage = '%prog [OPTIONS] {directory}') parser.add_option( '--source-tree-monitor', default = None, help = 'use SOURCE_TREE_MONITOR as source tree monitor class', ) opts, args = parser.parse_args(argv[1:]) stm_dotted_name = opts.source_tree_monitor stm = choose_source_tree_monitor(stm_dotted_name) dir_name = os.path.abspath(args[0]) return stm, dir_name @main_function( exit_signals = [signal.SIGINT, signal.SIGTERM, signal.SIGHUP, signal.SIGPIPE], ) def main(argv): stm, dir_name = handle_argv(argv) stm.set_add_cb(make_add_cb(stm)) stm.set_remove_cb(make_remove_cb(stm)) stm.set_update_cb(make_update_cb(stm)) stm.start() add_source_dir(stm, dir_name) try: while True: stm.process_events() time.sleep(0.1) finally: stm.stop() if __name__ == '__main__': sys.exit(main()) pytagsfs-0.9.2/util/profile0000755000175000017500000002423711315711421015317 0ustar forestforest#!/usr/bin/env python # Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, sys, time, uuid, subprocess from optparse import OptionParser from pytagsfs.fs import UMOUNT_COMMAND project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) python_executable = sys.executable pytagsfs_executable = os.path.join(project_dir, 'pytagsfs') PROF = 'PROF ' def parse_pytagsfs_output(output): result = {} for line in output.split('\n'): if 'PROF' not in line: continue try: line = line[line.index(PROF) + len(PROF):] parts = line.split(' ') duration = int(parts[0]) operation = parts[1] except (TypeError, ValueError), e: print >>sys.stderr, repr(e) print >>sys.stderr, 'Invalid line: %s' % repr(line) if operation not in result: result[operation] = {'ncalls': 0, 'cumtime': 0} result[operation]['ncalls'] += 1 result[operation]['cumtime'] += duration for operation in result: result[operation]['percall'] = ( float(result[operation]['cumtime']) / float(result[operation]['ncalls']) ) return result def print_profile_result(result): print 'ncalls\tcumtime\tpercall\toperation' for operation, stats in result.items(): d = dict(stats) d['operation'] = operation print '%(ncalls)u\t%(cumtime)u\t%(percall).3f\t%(operation)s' % d def quote_arg(arg): return "'%s'" % arg.replace("'", r"'\''") def unique_id(): return str(uuid.uuid1()) def iter_permutations(choice_groups, prefix = None): try: first_choice_group = choice_groups[0] except IndexError: yield prefix return for choice in first_choice_group: if prefix is None: new_prefix = [choice] else: new_prefix = list(prefix) new_prefix.append(choice) for permutation in iter_permutations( choice_groups[1:], prefix = new_prefix): yield permutation def iter_choice_groups(depth, breadth): for x in range(depth): choice_group = [] for y in range(breadth): choice_group.append(unique_id()) yield choice_group def create_source_file(source_dir, permutation, blksize, nblocks): filename = os.path.join(source_dir, unique_id()) f = open(filename, 'w') try: try: f.write('\n'.join(permutation)) f.write('\n') data = blksize * '\0' for i in range(nblocks): f.write(data) finally: f.close() except Exception: os.unlink(filename) raise return filename def build_source_tree(source_dir, depth, breadth, blocksize, nblocks): choice_groups = list(iter_choice_groups(depth, breadth)) permutations = list(iter_permutations(choice_groups)) filenames = [] os.mkdir(source_dir) try: try: for permutation in permutations: filenames.append(create_source_file( source_dir, permutation, blocksize, nblocks, )) except: for filename in filenames: os.unlink(filename) raise except: os.rmdir(source_dir) raise return filenames def make_format(depth): parts = [] for x in range(depth): parts.append('%%%s' % (chr(ord('a') + x))) return '/%s' % '/'.join(parts) def remove_source_tree(source_dir, filenames): for filename in filenames: os.unlink(filename) os.rmdir(source_dir) def mount(options, source_dir, mount_point): parts = [ python_executable, pytagsfs_executable, '-o', options, source_dir, mount_point, ] cmdline = ' '.join([quote_arg(part) for part in parts]) os.system(cmdline) def umount(mount_point): for retry in range(5): time.sleep(2) if os.system(UMOUNT_COMMAND % quote_arg(mount_point)) == 0: break def run_benchmark( benchmark, mount_point, source_dir, mount_options, reps, depth, breadth, blocksize, nblocks, ): # logsize must be large enough to hold all of the profiling messages. # Otherwise, we'll get jumbled messages as a result of the log data being # shifted back to make room for new data. If log file parsing fails, that # is probably the cause (but it could also indicate bad concurrent writes # to the log buffer). options = ','.join([ 'profile', 'metastores=pytagsfs.metastore.testlines.TestLinesMetaStore', 'format=%s' % make_format(depth), 'logsize=%u' % (10 * 1024 * 1024), ]) if mount_options is not None: options = ','.join([options, mount_options]) if reps is None: reps = benchmark.reps print '=== %s: %u reps' % (benchmark.__name__, reps) rep_times = [] os.mkdir(mount_point) try: filenames = build_source_tree( source_dir, depth, breadth, blocksize, nblocks, ) try: mount(options, source_dir, mount_point) try: benchmark_start_time = time.time() for rep in range(reps): rep_start_time = time.time() benchmark(mount_point, source_dir) rep_end_time = time.time() rep_times.append( 1000 * (rep_end_time - rep_start_time) ) benchmark_end_time = time.time() benchmark_time = ( 1000 * (benchmark_end_time - benchmark_start_time) ) stat_result = os.stat(os.path.join(mount_point, '.log')) f = open(os.path.join(mount_point, '.log')) try: output = f.read(stat_result.st_size) finally: f.close() finally: umount(mount_point) finally: remove_source_tree(source_dir, filenames) finally: os.rmdir(mount_point) print '' print_profile_result(parse_pytagsfs_output(output)) print '' print 'benchmark: %.2f' % benchmark_time print 'average rep: %.2f' % (sum(rep_times) / len(rep_times)) print 'slowest rep: %.2f' % max(rep_times) print 'fastest rep: %.2f' % min(rep_times) print '' print '' def benchmark_stat_mount_point(mount_point, source_dir): os.stat(mount_point) benchmark_stat_mount_point.reps = 1000 def benchmark_listdir_mount_point(mount_point, source_dir): os.listdir(mount_point) benchmark_listdir_mount_point.reps = 1000 def benchmark_find(mount_point, source_dir): os.system('find %s >/dev/null' % quote_arg(mount_point)) benchmark_find.reps = 10 def benchmark_read_all(mount_point, source_dir): os.system( "find %s -type f ! -name '.log' -exec cat '{}' \; >/dev/null" % quote_arg(mount_point) ) benchmark_read_all.reps = 10 def benchmark_read_all_concurrent(mount_point, source_dir): paths = [] for dirpath, dirnames, filenames in os.walk(mount_point): for filename in filenames: if filename != '.log': paths.append(os.path.join(dirpath, filename)) popens = [] dev_null = open('/dev/null', 'w') try: for path in paths: popen = subprocess.Popen( ['cat', path], stdout = dev_null, ) popens.append(popen) finally: dev_null.close() for popen in popens: popen.wait() benchmark_read_all_concurrent.reps = 10 BENCHMARKS = [ benchmark_stat_mount_point, benchmark_listdir_mount_point, benchmark_find, benchmark_read_all, benchmark_read_all_concurrent, ] def main(argv = None): if argv is None: argv = sys.argv parser = OptionParser() parser.add_option('--benchmark', action = 'store_true', default = False) parser.add_option('--parse', action = 'store_true', default = False) parser.add_option('--list-benchmarks', action = 'store_true', default = False) parser.add_option('--mount-point', default = 'mnt') parser.add_option('--source-dir', default = 'src') parser.add_option('--mount-options', default = None) parser.add_option('--reps', type = 'int', default = None) parser.add_option('--depth', type = 'int', default = 2) parser.add_option('--breadth', type = 'int', default = 10) parser.add_option('--blocksize', type = 'int', default = 1024) parser.add_option('--nblocks', type = 'int', default = 200) opts, args = parser.parse_args(argv[1:]) if not any([opts.benchmark, opts.parse, opts.list_benchmarks]): parser.error('must specify one of --benchmark, --parse, --list-benchmarks') if opts.benchmark: if len(args) == 0: benchmarks = BENCHMARKS else: benchmarks = [] for arg in args: found = False for benchmark in BENCHMARKS: if benchmark.__name__ == arg: benchmarks.append(benchmark) found = True break if not found: parser.error('no such benchmark: %s' % arg) for benchmark in benchmarks: run_benchmark( benchmark, opts.mount_point, opts.source_dir, mount_options = opts.mount_options, reps = opts.reps, depth = opts.depth, breadth = opts.breadth, blocksize = opts.blocksize, nblocks = opts.nblocks, ) elif opts.parse: print_profile_result(parse_pytagsfs_output(sys.stdin.read())) elif opts.list_benchmarks: print '\n'.join([bm.__name__ for bm in BENCHMARKS]) return 0 if __name__ == '__main__': sys.exit(main()) pytagsfs-0.9.2/pymailtagsfs0000777000175000017500000000000011315711421017152 2pytagsfsustar forestforestpytagsfs-0.9.2/pytags0000755000175000017500000000071011315711421014177 0ustar forestforest#!/usr/bin/env python # Copyright (c) 2007 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import sys if __name__ == '__main__': from pytagsfs.pytags import main sys.exit(main()) pytagsfs-0.9.2/BUGS0000644000175000017500000000036611315711421013434 0ustar forestforestPlease report bugs here: https://bugs.launchpad.net/pytagsfs/+filebug When you see a bug, copy the file named ".log" under the pytagsfs mount point *before* unmounting the filesystem. This file will contain information critical for debugging. pytagsfs-0.9.2/COPYING0000644000175000017500000004313311315711421014003 0ustar forestforest GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. pytagsfs-0.9.2/release0000644000175000017500000000000611315711421014303 0ustar forestforest0.9.2 pytagsfs-0.9.2/NEWS0000644000175000017500000010002611315711421013442 0ustar forestforest====================== pytagsfs Release Notes ====================== .. contents:: pytagsfs 0.9.2 2009-12-27 ========================= * Fixed pytagsfs manpage references to format string variables "number", "NUMBER". The correct variable names are "tracknumber", "TRACKNUMBER". Thanks to Sebastian Pipping for the report. (Forest Bond) pytagsfs 0.9.2rc2 2009-12-06 ============================ * Added missing encode calls in SourceTree methods isreadable, issymlink, lstat, and utime. (Forest Bond) * Fixed bad assumption in tests.blackbox that a subprocess failed if it produced output on stderr. (Forest Bond) * Added dependencies for running test suite to README. (Forest Bond) pytagsfs 0.9.2rc1 2009-12-05 ============================ * Fixed AttributeError on getattr due to missing Stat attributes and interaction with python-fuse bugs. The presence of this issue is dependent on python-fuse version, but the implemented fix should be compatible with many. The exception would likely occur on the filesystem operation following the getattr call due to python-fuse bugs. This bug could lead to data corruption if files are opened for writing, but problems would likely be seen before that point. (Forest Bond) * Fixed AttributeError on open due to missing FileInfo attribute (a bug in python-fuse). The exception would likely occur on the filesystem operation following the open call due to python-fuse bugs. This bug could lead to data corruption if files are opened for writing, but problems would likely be seen before that point. (Forest Bond) * Fixed unmatched increment/decrement count for frozen paths. This would manifest itself as follows: - KeyErrors may be seen in the log. - Writes may fail in situations where multiple processes are attempting to write to the same file concurrently. - A virtual path may persist after a file is modified such that the path should change. This could possibly lead to data corruption if the a virtual file is opened for writing by more than one process simultaneously. In that case, inconsistent data is likely in the absence of this bug. (Forest Bond) * util/profile: Added benchmark read_all_concurrent. (Forest Bond) * ``TestLinesMetaStore`` was modified to support a data section. All bytes after the last newline character in the file are treated as arbitrary data. (Forest Bond) * util/profile: Files are now created with a data section of arbitrary size that can be specified with command-line options --blocksize, --nblocks. These default to 1024 and 200, respectively. (Forest Bond) * Implemented the beginnings of a token-style locking mechanism (this doesn't appear to be widely used -- maybe I invented it). At present, this effectively implements a global lock such that most pytagsfs code need not be thread safe, but will evolve to allow limited multithreading through judicious token releases around blocking I/O. This resolves serious deadlocks resulting from locking calls scattered throughout pytagsfs code. It is possible that these deadlocks could have resulted in data corruption since the filesystem could have deadlocked with files opened for writing, but only in situations where the filesystem was being accessed concurrently, in which case a deadlock is likely before the user has a chance to open a file for writing. (Forest Bond) * Removed a variety of locks that were rendered useless by the introduction of token-style locking. (Forest Bond) * Extended token-style locking with the addition of tokens that protect specific data structures. This improves performance by exchanging the global token for a secondary one around code sections that would cause a thread to block on I/O. (Forest Bond) * Debug logging of filesystem operations no longer includes method arguments or return values that are too large to justify logging them. This improves performance with debug logging enabled. (Forest Bond) * Introduced FUSE option max_readahead=0. This has no impact on OS X because MacFUSE-specific option noreadahead was already being used. Since the underlying source files can change at any time, no in-kernel caching can be permitted. Otherwise, reads may return old data. This makes read performance worse by a factor of about two on my machine (but correctness is more important than performance by a factor of greater than two ;). The previous behavior could lead to data inconsistencies if a virtual file and its corresponding real file were being written to simultaneously. However, data inconsistencies would occur under those circumstances even in the absence of this issue. (Forest Bond) * Symlinks in the source tree are now completely ignored. Previously, they were represented as virtual symlinks but readlink calls would fail. In the future, we'd like to follow symlinks and handle them correctly. (Forest Bond) * Fixed AttributeError when a file is opened for writing twice after being either opened for reading and subsequently truncated or truncated and subsequently opened for reading. The second attempt to open the file for writing would fail. This bug could not cause data corruption. (Forest Bond) pytagsfs 0.9.1 2009-10-18 ========================= * Removed spurious log messages about late events from inotifyx source tree monitor. IN_IGNORED messages are always "late". (Forest Bond) * Support format string short key "%c" as an alias for "%{composer}". Patch by Michael Helmling. (Forest Bond) * Fixed DeprecationWarning: object.__init__() takes no parameters in pytypes.py. (Forest Bond) * Fixed usage of deprecated os.popen2 in ``tests.blackbox`` that actually caused deadlocks during testing on some systems. (Forest Bond) pytagsfs 0.9.1rc1 2009-04-26 ============================ * Note: pyinotify has been dropped in favor of inotifyx, so this change is no longer relevant. I'll leave it for its historical value. Updated pyinotify source tree monitor to be compatible with new 0.8.6 pyinotify release. This is getting ugly. Thanks to Ritesh Raj Sarraf for the report and patch. Fixes #364586. (Forest Bond) * Dropped pyinotify in favor of inotifyx. Fixes #364586 better. Linux users should install inotifyx, available from http://www.alittletooquiet.net/software/inotifyx/ . (Forest Bond) pytagsfs 0.9.0 2009-03-05 ========================= * Fixed test failures due to bad assumptions about source filesystems, environment variables. Thanks to "Tomtom". Fixes #312999. (Forest Bond) pytagsfs 0.9.0rc1 2009-01-26 ============================ * Note: The ctypes-based bindings mentioned here were replaced with ``pytagsfs.fuselib``, a new FUSE layer based on the previous python-fuse bindings. This entry has been left for historical value. See further entries below. Moved to new FUSE library bindings based on fuse.py by Giorgos Verigakis. A modified version of this module now ships with pytagsfs as ``pytagsfs.fuse``. The previous dependency on external Python FUSE bindings no longer exists, however, the ctypes module is required and is an external dependency with Python 2.4. Python 2.5 includes the ctypes module in the standard library. (Forest Bond) * Fixed incorrect mtime, atime for files whose timestamps were updated while they were opened for writing. Previously, timestamps from the .pytagsfs. file would be copied to the new source file after the file was closed. (Forest Bond) * Fixed incorrect st_ino, st_dev from fgetattr. Previously, values for the underlying source file were returned directly. Now, these are adjusted properly. (Forest Bond) * Implemented a new approach to source tree writes: - Files can be opened for writing multiple times. Management of concurrent writes is pushed off to the source tree filesystem(s). - Writes to the mount tree are immediately reflected. Thus, both writers and readers get the same view of the pytagsfs mount. This allows us to disable FUSE option direct_io. - Writing to a virtual file does not cause that virtual path to disappear until after the file has been closed. If opened for writing multiple times concurrently, the virtual path continues to exist until all writers have closed the file. New virtual paths may appear while the file is still opened for writing since writes affect source files immediately. - Truncating a virtal file does not affect the source file until the virtual file is opened for writing. Truncating a virtual file that is already opened for writing affects the source file immediately. (Forest Bond) * mmap is now fully supported and write support is now enabled by default on all platforms. This can be done because FUSE option direct_io is no longer used. (Forest Bond) * Dropped option --force-write-support. This option is no longer necessary since write support is enabled by default on all systems. (Forest Bond) * Fixed traceback on invalid mount option. (Forest Bond) * Fixed util/profile to only read portion of log written while running benchmarks. This problem was masked when direct_io was in use due to fewer log entries caused by larger reads. (Forest Bond) * Fixed spurious logging of tracebacks due to normal filesystem errors. (Forest Bond) * Logging is now performed in the FUSE bindings layer (pytagsfs.fuse) instead of using decorators in the filesystem layer (pytagsfs.fs). This improves performance and simplifies the code a bit. (Forest Bond) * Reduced performance impact of logging calls that do not actually produce an log output due to current verbosity settings by passing values for interpolation to the logging layer instead of pre-interpolating log messages. (Forest Bond) * Fixed KeyError tracebacks (only visible with -o debug) on release of .log. (Forest Bond) * Added mail extension, a minor extension to pytagsfs to permit tagging of mail messages in Maildir format. This is currently invoked via new executable ``pymailtagsfs``, but this may change in the future. For instance invocation may at some point be via ``pytagsfs -o extension=mail``. Tags are stored in e-mail messages using header ``X-Pytagsfs-Tag``. (Forest Bond) * Fixed handling of ``X-Pytagsfs-Tag`` header contents to be compliant with RFC 2822 (MIME encoded-word syntax). (Forest Bond) * Fixed pymailtagsfs mailbox accesses to correctly lock mailboxes while modifying messages. (Forest Bond) * Fixed failing tests in ``tests.fs`` due to filesystem API change (argv is no longer passed to the initializer). (Forest Bond) * Fixed poor error handling when trying to build manpages on a system missing the docbook XSL stylesheets. Thanks to "lunch". Fixes #307950. (Forest Bond) * Modified setup.py to not install pymailtagsfs, as it is considered experimental. Users wishing to experiment with it can create a symlink "pymailtagsfs" to existing script "pytagsfs". (Forest Bond) * Fixed bad truncation behavior on Mac OSX (and possibly other systems, too), due to incorrect calls to libc's truncate (via ctypes). Correctly casting the length argument seems to fix this problem. (Forest Bond) * util/profile handles badly formatted log lines by reporting them to stderr. This problem can be triggered if the log file overflows, resulting in read discontinuity. (Forest Bond) * Fixed util/profile to not read the virtual log file while profiling. Naturally, doing so massively inflates profiling numbers, and also causes the log file to overflow. (Forest Bond) * Fixed -o profile to correctly report filesystem method names. This was broken in the transition from python-fuse to the ctypes-based fuse.py binding. All methods were being profile with name "wrapper". (Forest Bond) * Replaced ctypes-based FUSE bindings with a compatibility layer, ``pytagsfs.fuselib``, on top of the standard python-fuse bindings. The decision to move away from ctypes was made to avoid platform compatibility issues with types defined in system header files (which ctypes has no access to). The new compatibility layer provides a simpler API for filesystems (like those implemented in ``pytagsfs.fs``) similar to that provided by the ctypes-based bindings. (Forest Bond) * Implemented statfs. This probably used to work, because Darwin appears to depend on it being implemented for all operations. It's not clear to me why it would've worked in the past, but a complete implemention is now provided. (Forest Bond) * Improved speed and reliability of blackbox tests by using sleep_until instead of sleep. (Forest Bond) * Fixed -s (broken with introduction of ``pytagsfs.fuselib``). (Forest Bond) pytagsfs 0.8.0 2008-10-21 ========================= * Fixed out-of-date documentation of command-line options in pytags manual page. (Forest Bond) * Fixed broken pytagsfs option -s. (Forest Bond) pytagsfs 0.8.0rc1 2008-10-09 ============================ * Fixed hard-coded path to docbook stylesheet for building manpages in setup.py. Thanks to Zong Sharo. Fixes #258362. (Forest Bond) * Fixed rather serious bug that would have prevented pytagsfs mounts from working correctly when the mount point directory depth was smaller than the virtual path directory depth (as defined by the format string). (Forest Bond) * Re-work ``PathStore`` interface: - ``create_directory`` was renamed to ``add_directory``, and it is no longer an optional method for sub-classes to implement. - ``remove_file`` and ``remove_directory`` have been replaced with a single method, ``remove``. - ``rename_file`` and ``rename_directory`` have been replaced with a single method, ``rename``. - Method ``get_real_subpaths`` was added (actually it was added previously, but the addition wasn't mentioned here). Most users won't care about these changes. (Forest Bond) * Renames to paths containing too many levels of directories now fail with EINVAL. (Forest Bond) * Re-implemented ``pytagsfs.subspat`` and re-worked ``pytagsfs.sourcetreerep`` to use the new API. Fixes #259928. (Forest Bond) * Added ``PathStore`` meta-data methods: ``get_meta_data``, ``set_meta_data``, ``unset_meta_data``. These are currently being used by ``SourceTreeRepresentation`` to store per-path ``Splitter`` objects. (Forest Bond) * Fixed some errors with getattr (stat): - Instead of returning zero for atime, ctime, and mtime for empty directories, return times as for the source tree root directory. - st_dev was being read from the source tree root for empty directories, or the source file for virtual files, but now is always set to zero. This is probably most correct given that our filesystem is virtual and those parameters are consequently meaningless. (Forest Bond) * Fixed a bug in utime, which previously assumed that its argument was always a file end point. The new implementation updates the times on the source tree root if the argument is an empty directory, or updates all contained end points if the argument is a non-empty directory. (Forest Bond) * Files with tags containing slashes are not represented in the virtual directory tree. Log messages should indicate when this is the case. Change your tags if you want to see them. Fixes #267650. (Forest Bond) * PathStore implementations can now expect all paths to be specified as unicode strings (previously, ASCII byte strings were allowed). (Forest Bond) * Tags with multiple values are now supported. Files with multiple tag values will appear under multiple directories. Renames are supported. (Forest Bond) * pytags command-line options have changed: - Option --pattern was renamed to --format to be consistent with pytagsfs itself. - Option --add was added. - The order of options is now important. --format must be specified first, if at all. --set, --add, and --remove are then process in order, with each option affecting tags as it is processed. (Forest Bond) * Tags that mutagen does not treat as lists or tuples are ignored. I'm currently aware of some mp4 tags that are like this (cpil, pgap, pcst, tmpo). Other mp4 tags were already being handled specially to translate to mp4-specific representations (tracknumber/trkn). (Forest Bond) * Renamed test module "integration" to "blackbox". (Forest Bond) * Simplified many blackbox tests, and removed some that primarily tested functionality at a layer that is now being thoroughly unit tested. (Forest Bond) * Removed filesystem implementation of access method. We use -o default_permissions, anyway, so this method was probably not even being called (and would return incorrect results for directories if it was). (Forest Bond) * Fixed buggy handling of mutagen track number tag leading to an attempt to convert a list to an integer rather than converting each list member to an integer. (Forest Bond) * Renamed long version of mutagen substitution pattern "N" from "NUMBER" to "TRACKNUMBER" in order to be consistent with pair "n", "tracknumber". (Forest Bond) * Added mount option "-o nocache", which disables caching of stat results and other virtual path properties. (Forest Bond) * Added mount option "-o profile". This turns on some additional profiling output in the log file. (Forest Bond) * Implemented util/profile, a utility that can analyze profiling information in the log, as well as run standardized benchmarks. (Forest Bond) * In order to support benchmarking, a new meta store implementation was added: ``TestLinesMetaStore``. This meta store implementation should not be used with real data files, as it has the potential to destory file data via renames. It is for testing and benchmarking only. (Forest Bond) * Added mount option "-o metastores", which allows the user to specify which meta store implementation(s) to use. This option is currently undocumented, and was primarily introduced to support standardized benchmarking. In the future, though, it will likely be useful for mounting directories containing non-media source files using alternative tag formats. (Forest Bond) pytagsfs 0.7.1 2008-07-24 ========================= * Fix filesystem dying with removal of last sub-directory of the root directory. PyTypesPathStore was undefining the root directory with the removal of its last sub-directory. (Forest Bond) * Fix out-of-order handling of events for multiple paths when using DeferredPyInotifySourceTreeMonitor, DeferredGaminSourceTreeMonitor, or DeferredKqueueSourceTreeMonitor. This bug might have caused the mount tree to become out-of-sync with the source tree under some circumstances. (Forest Bond) * Fix duplicate directory removal events from GaminSourceTreeMonitor and DeferredGaminSourceTreeMonitor. This bug may have caused slight performance and/or source tree/mount tree synchronization issues. (Forest Bond) * setup.py test command now accepts command-line option --print-only. If specified, test identifiers for tests that would have been run are printed rather than being run. (Forest Bond) * Only call ``locale.getpreferredencoding`` once prior to thread initialization, since this function is not thread-safe on some platforms. (Forest Bond) * Fixed a bug where renaming a directory in the source tree and subsequently modifying tags on files contained by that directory resulted in "phantom" files and directories under the mount point. These files appear in directory listings but no longer correspond to any existing source files. Reading from them gives "No such file or directory" errors. (Forest Bond) * Fixed "No such file or directory" errors for ``getattr`` calls on virtual directories whose sub-trees contain files corresponding with source files that no longer exist. Under normal operating conditions, this would be the rare outcome of a race condition. (Forest Bond) * Fixed mishandling of nested directory removals by KqueueSourceTreeMonitor and DeferredKqueueSourceTreeMonitor (the default source tree monitor on Mac OSX and other BSDs). (Forest Bond) pytagsfs 0.7.0 2008-06-03 ========================= * Documentation updates. (Forest Bond) pytagsfs 0.7.0rc1 2008-05-19 ============================ * Fix setup.py not installing sub-package specialfile. This bug was unreleased. (Forest Bond) * Handle conditional expressions in format strings better with respect to renames. Previously, renaming files such that a path component matches the alternate content of a conditional expression resulted in that alternate content being set as a tag value. Now, the tag is removed, instead. For example, with format string '/%?%g%:Unknown Genre%?/%a/%t.%e', moving a file into directory "Unknown Genre" will unset the genre tag for that file, rather than setting the genre to "Unknown Genre". (Forest Bond) * Long keys are now supported in format strings. For instance, "%{artist}" is equivalent to "%a". This can also be used to access arbitrary tags that have no short key version (like "%{composer}"). (Forest Bond) * Created an experimental implementation of KqueueSourceTreeMonitor with the ultimate goal of achieving full Mac OSX compatibility. More work must be done before such support is complete. (Forest Bond) * Fixed Python 2.4 incompatibilities in test/integration.py. (Forest Bond) * Fixed broken kqueue support when not run in foreground mode (via -f/-d). (Forest Bond) * Fixed breakage in test/integration.py that would prevent test mounts from being un-mounted correctly. (Forest Bond) * Fixed bad handling of boolean tag values. (Forest Bond) * Fixed incorrect handling of mount options uid, gid. (Forest Bond) * Set fstype to source directory path, subtype to "pytagsfs". Previously, fstype was set to "pytagsfs". The new arrangement is more semantically correct. (Forest Bond) * Fix kqueue handling of file replacements. (Forest Bond) * Fixed MacFUSE caching issues by passing mount option "nolocalcaches". (Forest Bond) * Fix renames on mounts with format string key redundancy (mounts that have the same tag appear more than once in the format string). (Forest Bond) * Detect platform and inform user about potential mmap problems, if they exist. Require --force-write-support if appropriate. (Forest Bond) * Provide -o ro on Linux, -o rdonly on OSX and other BSD's. Provide -r on all systems. (Forest Bond) * Correctly handle errors from FUSE main function. Thanks to Y Giridhar Appaji Nag for submitting a patch. (Forest Bond) * Correctly handle moves of directories containing (directly or via sub-trees) both empty directories as well as virtual files. (Forest Bond) * Try to handle MP4 keys in a useful way by translating from keys to those used more commonly by other formats. The keys seem to mostly have been defined by iTunes, and are not well documented (nor are they very sane). Variations in the field may cause problems here, but the iTunes-created files that I have here appear to be handled correctly. (Forest Bond) * Integrate tests into setup.py. Tests can now be run with ``./setup.py test``. (Forest Bond) * Import the locale module from sclapp, rather than importing it directly. This fixes some Unicode issues on Darwin. sclapp version 0.5.2 is now required. (Forest Bond) * Provide ``--tests`` option to setup.py test sub-command to enable specific tests to be run, rather than always running the entire test suite. (Forest Bond) * Implement substitution parameter %{NUMBER}, a synonym for %N. (Forest Bond) pytagsfs version 0.6.0 2008-04-04 ================================= * Pretty-up log format a bit: - Include time stamps. - Use prettier description of function for "Entering x" and "Leaving x" messages. (Forest Bond) * Rewrote command-line option parsing. Options are now handled completely independently from the underlying FUSE library. The following options are no longer supported: - -o default_permissions - -o fsname - -o large_read - -o max_read - -o hard_remove - -o use_ino - -o readdir_ino - -o direct_io - -o kernel_cache - -o umask - -o entry_timeout - -o negative_timeout - -o attr_timeout In general, the options for which support was removed are now considered implementation details, as they should have been previously. (Forest Bond) * Fix incompatibility with python-fuse 0.2 by returning fuse.Stat instances instead of os.stat_result instances from getattr, fgetattr. This issue did not exist with python-fuse 0.2pre3. Previously, users of 0.2 would see EINVAL from stat calls. Reported by Chris Pickel, Jeremy Jones. (Forest Bond) pytagsfs 0.6.0rc2 2008-03-26 ============================ * Improve performance for readdir by changing post-processing list of entries in PyTypesPathStore.get_entries_for_directory to use new function last_unique instead of unique. Thanks to Chris Pickel. (Forest Bond) * Improve performance for readdir when debug logging is turned on by decorating FileSystemMappingToRealFiles.readdir with @logged instead of @verbosely_logged. (Forest Bond) * Cache directory entries. This provides a significant performance improvement for readdir calls after the first. (Forest Bond) pytagsfs 0.6.0rc1 2008-03-24 ============================ * Keep order of directory entries the same across renames, collisions, etc. Implementation happens to improve performance for source tree file updates, as well. (Forest Bond) * Support simple renames of files under mount point. Renaming virtual files and directories causes the meta-data of the underlying source files to be updated appropriately. Files can be moved from one directory to another, or files and directories can be renamed. (Forest Bond) * Fix bug preventing stat results from actually being cached. This likely had impact on performance of directory listings. (Forest Bond) * Fix TypeError from readdir due to poor handling in VirtualLogFile. (Forest Bond) * Fix cache not pruned due to rename. (Forest Bond) * Directory permissions now taken from source tree root directory (previously arbitrary). (Forest Bond) * Fix broken directory mtime, ctime, atime. (Forest Bond) * Fix partial stat cache invalidation when full path branch should be invalidated. This would cause directory mtime, ctime, atime to not be updated when it should. (Forest Bond) * Fix partial stat cache pruning in response to source file updates. (Forest Bond) * Support mkdir, rmdir. (Forest Bond) * Fix bad handling of updates to previously unrepresentable source files. (Forest Bond) * Fix rmdir not completely removing the target directory. While the directory was no longer returned by readdir on parent, stat still indicated its presence. (Forest Bond) pytagsfs 0.5.0 2008-03-08 ========================= * pytagsfs is now compatible with Python 2.4. (Forest Bond) pytagsfs 0.5.0rc2 2008-03-07 ============================ * Initial scanning of files was taking place after filesystem process detached from the user's shell. This causes the initial population delay to be observed when the filesystem is first accessed, leading to confusion as to whether the filesystem had hung. Now, the files are scanned before the process detaches. (Forest Bond) * Fixed log spamming after each open of log file (".log"). (Forest Bond) pytagsfs 0.5.0rc1 2008-03-06 ============================ * Added option -o verbosity=VERBOSITY; VERBOSITY should be one of debug, info, warning, error, critical. -d/-o debug overrides this, and forces verbosity to debug. (Forest Bond) * With -d/-o debug, log to both .log and stderr. Otherwise, log to .log only. (Forest Bond) * Limit size of in-memory log file (.log) to 1MB. (Forest Bond) * Allow size of in-memory log file to be overridden via -o logsize. (Forest Bond) * Fixed bug preventing addition of tags to previously untagged mp3 files. (Forest Bond) * Improved inotify performance for case where source files are updated numerous times between event processing calls; DeferredInotifySourceTreeMonitor. (Forest Bond) * Improved performance by only processing add, remove, and update events for sources files after initialization (post populate) and prior to getattr calls. (Forest Bond) * Fix bug causing reads on a recently truncated fd to return the removed content by using direct_io = True for ReadWriteFile's. (Forest Bond) * Fix bug (sort of) where getattr calls for a file currently open for writing return the size of the file before being opened. Now, we defer to fgetattr on the open file object. This would cause, for instance, mutagen to badly truncate OGG files. (Forest Bond) * Fix broken setup.py that forgets to install sub-packages. (Forest Bond) * Fix missing import log_traceback in pytagsfs.sourcetree. (Forest Bond) * Fix handling of transient conflicts. Previously, when two or more source files map to the same file name under the mount point, and one of those source files was either removed or modified such that it mapped to a different path, the mount path became a "dead" file, with zero links. Now, that path will become reassociated with the next source file candidate. (Forest Bond) * Fix pytags, pytagsfs always exiting with zero status, despite errors. (Forest Bond) * Log to stderr when option -f/-o foreground is specified. (Forest Bond) * Introduced fallback mechanism for source tree change monitoring backends. Source tree monitors are tried in the following order: pyinotify, gamin, dummy. - pyinotify only works on Linux, but is faster than gamin. - gamin possibly works on other Unix-like systems (like the BSD's). - The dummy backend doesn't actually do anything, so changes to the source tree are not reflected in the mount tree. Non-Linux users should report success or failure with the gamin backend. (Forest Bond) pytagsfs 0.3.0 2008-01-17 ========================= * Added BUGS. (Forest Bond) * A virtual log file (".log") is created under the moint point. The contents of this file are stored in memory. In the event of a (detected) bug, tracebacks and other critical debugging data will be accessible by reading this file. (Forest Bond) * If a file is truncated (directly, without being opened), the effects of this are not immediately visible. Reads will continue to return the file contents prior to truncation. However, if the file is opened in write-only or read-write mode, the truncation will be apparent to the opener. Once the file is closed, reads will return the new content. This makes it possible to successfully re-tag files in such a way that the file path changes. (Forest Bond) * Write support is now considered reliable. (Forest Bond) * Removed support for the following filesystem functions, which were either incorrect or irrelevant given currently supported features: - readlink - mknod - mkdir - unlink - symlink - rename - link (Forest Bond) * Fixed incorrect stat results due to out of date cache values. This also corrects issue where writes would not show up in mounted tree. (Forest Bond) * Drastic performance improvement via stat() result caching. (Forest Bond) * Fixed bug in setup.py causing version information to be excluded from generated .egg file. (Forest Bond) pytagsfs 0.2.0 2007-12-15 ========================= * Added NEWS file; sorry for the previous absence. (Forest Bond) * [NEWS file not present] pytagsfs 0.1.0 2007-12-06 ========================= * [NEWS file not present] pytagsfs-0.9.2/pytagsfs.xml0000644000175000017500000003512111315711421015330 0ustar forestforest pytagsfs"> ]> ForestBond
forest@alittletooquiet.net
2007 2008 2009 2009-12-14 pytagsfs 1 pytagsfs filesystem mapping media files to an arbitrary directory structure &pytagsfs; OPTIONS sourcedir mountpoint Description pytagsfs is a FUSE filesystem that was designed to present multiple views of tagged media files. For instance, a directory tree containing audio files could be mapped to a new directory structure organizing those same files by album, genre, release date, etc. To get a feel for what's possible, see . Log messages are kept in a limited-size ring buffer in memory, and can be read from the virtual file named ".log", under the mount point root. Options show version of program and exit , show summary of options and exit foreground operation enable debug output (implies -f) disable multi-threaded operation mount read-only opt[,opt...] mount options format=FORMAT format string for destination paths (see ) srcfilter=EXPR adds a source path filter; may be specified more than once (see ) dstfilter=EXPR adds a destination path filter; may be specified more than once (see ) iocharset=ENCODING mounted tree character encoding (default utf-8) source_iocharset=ENCODING source directory character encoding (default utf-8) ro synonym for -r (Linux) rdonly synonym for -r (Darwin, FreeBSD, NetBSD, OpenBSD) allow_other allow access to other users allow_root allow access to root nonempty allow mounts over non-empty file/dir uid=UID set file owner gid=GID set file group verbosity=VERBOSITY log level; must be one of "debug", "info", "warning", "error", "critical"; defaults to "warning" logsize=LOGSIZE length of log file ring buffer debug synonym for -d force_write_support Force write support on systems that are not known to have correct mmap semantics. This option is dangerous and can lead to file corruption with some applications on some systems! Format Strings A format string must be specified for each pytagsfs mount. The format string specifies the structure of the virtual filesystem mount by defining a template for virtual paths. For instance, the following format string defines a virtual filesystem layout that organizes media files by artist, then by album, and, finally, by track name: /%{artist}/%{album}/%{track}.%{extension} Substitutions The format string should contain zero or more substitution sequences. Each such sequence begins with a percent sign (%). Substitution sequences may be specified in either long or short forms. Long-form substitution sequences are written as "%{KEY}", where KEY corresponds with a meta-data key. The set of available keys varies from file to file, however, many media files feature some or all of the following long keys: filename name of the original file parent name of the original file's parent directory extension extension of the original file tracknumber track number; concise (like 7) TRACKNUMBER track number; two digits with leading zeros (like 07) artist artist composer composer title track title album album title year year of release genre genre Short-form substitution sequences are written as "%X". Each such sequence is an abbreviation for a long-form sequence, as indicated below: f filename p parent e extension n number N NUMBER a artist c composer t title l album y year g genre Modifiers Format strings can be further extended to perform string translations on parameters prior to substitution. Such translations are indicated by the inclusion of a modifier character after the percent sign. For instance, "%^a" indicates an all-caps version of the artist name, as does "%^{artist}". The full list of modifier characters follows: ^ UPPERCASE _ lowercase ! Title Case Conditional Expressions Normally, any file for which a parameter required by the format string cannot be determined is implicitly excluded from the resulting filesystem. Conditionals can be used to express that these files should be included, but that those portions of the format string that cannot be rendered should be omitted or replaced. Two types of conditional expressions may be used: "if" expressions and "if-else" expressions. The contents of an "if" expression are omitted unless all parameters within that expressions can be successfully evaluated. An "if-else" expression is similar, except that, if the expression does not evaluate, an alternative will be used instead. Use the following syntax: %?expr%? %?expr%:alt%? Path Filters Path filters can be used to limit the set of files presented by the filesystem using regular expressions. Files are filtered by source path or by destination path, inclusively (limiting the set of paths to those that match the regular expression) or exclusively (limiting the set of paths to those that do not match the regular expression). Use the mount options and to filter by source path and destination path, respectively. Filters are inclusive unless the filter parameter starts with an exclamation point, in which case the regular expression is assumed to be the part of the parameter following the exclamation point. Multiple filters of any kind may be used, and are applied in the order that they are specified on the command line. See for some sample filters. Examples View media files in src, with original filenames in a flat directory structure: $ pytagsfs -o format='/%f' src mnt View media files in src by album on mnt: $ pytagsfs -o format='/%a/%f' src mnt A more complex album-based view: $ pytagsfs -o format='/%a - %l/%N %a - %t [%l].%e' This is like above, but filters the result. I use this to display my files by album, but exclude compilations (which I've tagged to include a hyphen in the album name, like "various - album"): $ pytagsfs -o \ format='/%a - %l/%N %a - %t [%l].%e',\ dstfilter='!^/[^/]* - [^/]* - [^/]*/' \ src albums I use this to display the compilations: $ pytagsfs -o \ format='/%l/%N %a - %t [%l].%e',\ dstfilter='^/[^/]* - [^/]*/' \ src compilations Maybe you only want to see files that start with "a" and end in ".mp3"? $ pytagsfs -o \ format='/%f',dstfilter='^/a',dstfilter='\.mp3$' \ src mnt Unmounting To unmount the filesystem on Linux use fusermount 1 : $ fusermount -u mnt To unmount the filesystem on OS X or *BSD use umount 1 : $ umount mnt Bugs Please report bugs on launchpad at http://launchpad.net/products/pytagsfs/+bugs. See Also fusermount 1 , mount 8 , umount 8 , pytags 1 pytagsfs-0.9.2/AUTHORS0000644000175000017500000000007411315711421014015 0ustar forestforestPrimary Author: Forest Bond pytagsfs-0.9.2/pytags.xml0000644000175000017500000001300011315711421014767 0ustar forestforest pytags"> ]> ForestBond
forest@alittletooquiet.net
2007 2008 2009 2009-12-04 pytags 1 pytags set and remove tags on media files from filename and options &pytags; OPTIONS file file... Description &pytags; is a simple, general-purpose tool for setting and removing media file tags. With no options, &pytags; prints a tag summary for all files specified on the command line. Options can be used to set and remove tags on files. Using , it is easy to change or create tags on by parsing metadata from filenames according to an arbitrary format string. This makes it simple to tag files that are consistently named. Additionally, tags can be manipulated directly with the , , and options. These options are processed in order, so options specified later on the command-line may cause values set by earlier options to be overwritten. These options must appear after the , if it is used. Options =EXPR Append a tag value all files according to EXPR. EXPR should be an expression like “artist=Foo”. May be specified multiple times to add multiple values. =FORMAT Tag files with metadata extrapolated from filenames using format string FORMAT; see . This option must be specified before , , or . =EXPR Set a single tag on all files according to EXPR. EXPR should be an expression like “artist=Foo”. May be specified multiple times to set multiple tags. cannot be used to specify multiple values for a single tag. To do that, use followed by multiple options. =TAG Remove tags named TAG. May be specified more than once to remove multiple tags. , Show summary of options and exit. , Show version of program and exit. Format Strings The format string expected by is the same as that for pytagsfs. See the pytagsfs manual page for more information. Examples Remove the genre tag from all .ogg files in the current directory. $ pytags --remove genre *.ogg Set the artist and album tag on all .mp3 files, and remove the genre tag. $ pytags --set artist=Foo --set album=Bar --remove genre *.mp3 Tag all of the .flac files in the current directory. All such files are assumed to be in the format "tracknum artist - trackname [album].flac". $ pytags --format '%n %a - %t [%l].flac' *.flac Bugs Please report bugs on launchpad at http://launchpad.net/products/pytagsfs/+bugs. pytags relies on mutagen (the underlying Python tags library) to choose an appropriate tag format for the files being tagged. This cannot currently be overridden. See Also pytagsfs 1 pytagsfs-0.9.2/TODO0000644000175000017500000000341411315711421013436 0ustar forestforestBugs ==== * Right now, collisions are handled such that the most recently added file overrides previously added files. I'm not sure that this is correct. * Some tests fail intermittently because gamin doesn't seem to maintain the order of certain events (removing nested directories, for instance). It's not really a big deal because very few people likely use gamin with pytagsfs (since we support inotify and kqueue, either of which is generally preferred over gamin), and pytagsfs has provisions to work around the incorrect behavior (cofirm this). Enhancements ============ * Reduce startup time. One way to do this is to implement PathStore persistence across sessions with verification and updating of persisted data at mount time. * Improve performance of most filesystem operations. * It should be possible for write support to work with the dummy source tree monitor. * Allow source tree monitors to be specified on the command-line by nick-name ("dummy"), instead of class name. * Implement source tree monitor based on python-fam? * Add more special files: - .collisions: lists virtual paths that collide and the source files they corespond with. - .missing: lists source paths that are not representable as virtual files. * Should verbosity=debug include library debug messages (normally sent to stderr)? * Re-examine format string conditional expression syntax. I've received complaints that the %?foo%:bar%? syntax is overly verbose and awkward. This is probably true, but it also prevents nested conditionals, which is nice. * Warn user of performance penalty associated -d/-o debug? Testing ======= * Test dummy source tree monitor. * Test -o uid, -o gid. * Test -r, -o ro, -o rdonly. * Test pytags utility. pytagsfs-0.9.2/pytagsfs0000755000175000017500000000071311315711421014533 0ustar forestforest#!/usr/bin/env python # Copyright (c) 2007 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import sys from pytagsfs.main import main if __name__ == '__main__': sys.exit(main(sys.argv)) pytagsfs-0.9.2/tests/0000755000175000017500000000000011315711421014106 5ustar forestforestpytagsfs-0.9.2/tests/sourcetreerep.py0000644000175000017500000013141511315711421017354 0ustar forestforest# coding: utf-8 # Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, sys, stat try: from hashlib import md5 except ImportError: from md5 import md5 from pytagsfs.metastore import ( MetaStore, DelegateMultiMetaStore, UnsettableKeyError, ) from pytagsfs.values import Values from pytagsfs.metastore.path import PathMetaStore from pytagsfs.metastore.mutagen_ import MutagenFileMetaStore from pytagsfs.subspat import SubstitutionPattern from pytagsfs.sourcetree import SourceTree from pytagsfs.sourcetreemon import SourceTreeMonitor from pytagsfs.sourcetreerep import SourceTreeRepresentation from pytagsfs.pathstore.pytypes import PyTypesPathStore from pytagsfs.exceptions import ( PathNotFound, IsADirectory, NotADirectory, UnrepresentablePath, ) from pytagsfs.pathpropcache import PathPropCache from pytagsfs.util import ( unicode_path_sep, split_path, join_path, join_path_abs, ) from manager import manager from common import ( TEST_DATA_DIR, mixin_unicode, TestWithDir, ) class MockSourceTreeMonitor(SourceTreeMonitor): pass class NullMetaStore(MetaStore): keys = () def get(self, path): return Values() def set(self, path, values): return [] class ContentMetaStore(MetaStore): keys = ('c', 'content') def get(self, path): values = Values() try: f = open(path, 'r') try: values['c'] = values['content'] = [ l.rstrip('\n').decode('utf-8') for l in f.readlines()] finally: f.close() except (OSError, IOError): pass return values def set(self, path, values): set_keys = [] for key in self.keys: if key in values: if key in self.keys: f = open(path, 'w') try: for line in values[key]: f.write(line.encode('utf-8')) f.write('\n') finally: f.close() set_keys.append(key) return set_keys class _BaseSourceTreeRepresentationTestCase(TestWithDir): test_dir_prefix = 'str' source_tree_rep = None def p(self, s): return unicode(s) def _init(self, meta_store = None, format_string = None, **kwargs): kwargs = dict(kwargs) if meta_store is not None: kwargs['meta_store'] = meta_store if format_string is not None: substitution_patterns = [ SubstitutionPattern(s) for s in split_path(format_string) ] kwargs['substitution_patterns'] = substitution_patterns self.source_tree_rep = self._create_source_tree_rep(**kwargs) def _create_source_tree_rep(self, **kwargs): kwargs = dict(kwargs) if 'meta_store' not in kwargs: kwargs['meta_store'] = NullMetaStore() if 'substitution_patterns' not in kwargs: kwargs['substitution_patterns'] = [] if 'path_store' not in kwargs: kwargs['path_store'] = PyTypesPathStore() if 'source_tree' not in kwargs: kwargs['source_tree'] = SourceTree(self.test_dir) if 'monitor' not in kwargs: kwargs['monitor'] = MockSourceTreeMonitor() meta_store = kwargs.pop('meta_store') substitution_patterns = kwargs.pop('substitution_patterns') path_store = kwargs.pop('path_store') source_tree = kwargs.pop('source_tree') monitor = kwargs.pop('monitor') args = (meta_store, substitution_patterns, path_store, source_tree, monitor) return SourceTreeRepresentation(*args, **kwargs) def assertEqualPlusOrMinus(self, first, second, n, msg = None): if msg is None: msg = '%s and %s are more than %s apart' % (first, second, n) difference = abs(first - second) if difference > n: raise AssertionError(msg) class _PathPropCacheMixin(object): def _create_source_tree_rep(self, **kwargs): kwargs = dict(kwargs) kwargs['cache'] = PathPropCache() return super(_PathPropCacheMixin, self)._create_source_tree_rep( **kwargs) def mixin_pathpropcache(cls): newcls = type( '%sPathPropCache' % cls.__name__, (_PathPropCacheMixin, cls), {}) newcls.__module__ = cls.__module__ return newcls class SourceTreeRepresentationTestCase(_BaseSourceTreeRepresentationTestCase): def test(self): self._init(PathMetaStore(), u'/%p/%f') dirs = [ os.path.join(self.test_dir, u'a'), os.path.join(self.test_dir, u'•'), ] files = [ os.path.join(self.test_dir, u'c'), os.path.join(self.test_dir, u'a', u'b'), os.path.join(self.test_dir, u'•', u'x'), ] self._create_dirs(dirs) try: self._create_files(files) try: self.source_tree_rep.start() try: self.assertEqual( self.source_tree_rep.get_real_path( os.path.join(unicode_path_sep, u'•', u'x')), os.path.join(self.test_dir, u'•', u'x'), ) self.assertEqual( self.source_tree_rep.get_fake_paths( os.path.join(self.test_dir, u'•/x')), [os.path.join(unicode_path_sep, u'•', u'x')], ) self.assertRaises( PathNotFound, self.source_tree_rep.get_real_path, os.path.join(unicode_path_sep, u'a', u'x'), ) # Order of entries is dependent upon the order that files # were read from the source filesystem. This can vary # depending on the filesystem type, so we use set(...) # to compare irrespective of order. self.assertEqual( set(self.source_tree_rep.get_entries(unicode_path_sep)), set([u'a', u'•', os.path.basename(self.test_dir)]), ) self.assertEqual( self.source_tree_rep.get_entries(u'/a'), [u'b'], ) self.assertEqual( self.source_tree_rep.get_entries(u'/•'), [u'x'], ) finally: self.source_tree_rep.stop() finally: self._remove_files(files) finally: self._remove_dirs(dirs) def test_updates_to_renamed_files_in_a_renamed_directory(self): a_content = self.p('boing') a_source_path = os.path.join(self.test_dir, u'a', u'b') y_source_path = os.path.join(self.test_dir, u'x', u'y') meta_store = DelegateMultiMetaStore([ ContentMetaStore(), PathMetaStore()]) self._init(meta_store, u'/%p/%c') directory_path = os.path.join(self.test_dir, u'a') file_path = os.path.join(self.test_dir, u'a', u'b') self._create_dir(directory_path) try: self._create_file(file_path, content = a_content.encode('utf-8')) try: self.source_tree_rep.start() try: self.assertEqual( self.source_tree_rep.get_fake_paths(file_path), [os.path.join(u'/', u'a', a_content)], ) new_directory_path = os.path.join(self.test_dir, u'x') os.rename(directory_path, new_directory_path) old_directory_path = directory_path directory_path = new_directory_path file_path = os.path.join( directory_path, os.path.basename(file_path)) new_file_path = os.path.join(directory_path, u'y') os.rename(file_path, new_file_path) old_file_path = file_path file_path = new_file_path self.source_tree_rep.remove_cb( old_directory_path, is_dir = True) self.source_tree_rep.add_cb(directory_path, is_dir = True) self.source_tree_rep.remove_cb( old_file_path, is_dir = False) self.source_tree_rep.add_cb(file_path, is_dir = False) self.source_tree_rep.remove_cb(file_path, is_dir = False) self.source_tree_rep.add_cb(file_path, is_dir = False) self.assertEqual( self.source_tree_rep.get_entries(unicode_path_sep), [u'x'], ) finally: self.source_tree_rep.stop() finally: self._remove_file(file_path) finally: self._remove_dir(directory_path) ################################################################################ def test_stat_fake_directory_with_not_found_file(self): dir_path = join_path([self.test_dir, self.p(u'foo')]) file_path = join_path([dir_path, self.p(u'bar')]) self._create_dir(dir_path) try: self._create_file(file_path) self._init(PathMetaStore(), u'/%p/%f') self.source_tree_rep.start() try: self._remove_file(file_path) self.source_tree_rep.getattr(unicode_path_sep) finally: self.source_tree_rep.stop() finally: self._remove_dir(dir_path) ################################################################################ def test_fill_path(self): self._init(NullMetaStore(), u'/%a/%b/%c') values = { 'a': self.p('foo'), 'b': self.p('bar'), 'c': self.p('baz'), } self.assertEqual( self.source_tree_rep.fill_path(values), join_path_abs([self.p('foo'), self.p('bar'), self.p('baz')]), ) def test_fill_path_with_slash_in_values(self): self._init(NullMetaStore(), u'/%a/%b') values = { 'a': join_path([self.p('foo'), self.p('bar')]), } self.assertRaises( UnrepresentablePath, self.source_tree_rep.fill_path, values, ) def test_fill_path_with_missing_conditional(self): self._init(NullMetaStore(), u'/%a/%b/%?%c%:Default%?') values = {'a': self.p('foo'), 'b': self.p('bar')} self.assertEqual( self.source_tree_rep.fill_path(values), join_path_abs([self.p('foo'), self.p('bar'), u'Default']), ) def test_populate_with_files_only(self): filenames = [self.p('bar'), self.p('baz')] file_paths = [ join_path([self.test_dir, filename]) for filename in filenames ] self._create_files(file_paths) try: self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: # Order of entries is dependent upon the order that files # were read from the source filesystem. This can vary # depending on the filesystem type, so we use set(...) # to compare irrespective of order. self.assertEqual( set(self.source_tree_rep.get_entries(u'/')), set(filenames), ) finally: self.source_tree_rep.stop() finally: self._remove_files(file_paths) def test_populate_with_one_subdir(self): dirname = join_path([self.test_dir, self.p('foo')]) filenames = [self.p('bar'), self.p('baz')] file_paths = [join_path([dirname, filename]) for filename in filenames] self._create_dir(dirname) try: self._create_files(file_paths) try: self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: # Order of entries is dependent upon the order that files # were read from the source filesystem. This can vary # depending on the filesystem type, so we use set(...) # to compare irrespective of order. self.assertEqual( set(self.source_tree_rep.get_entries(u'/')), set(filenames), ) finally: self.source_tree_rep.stop() finally: self._remove_files(file_paths) finally: self._remove_dir(dirname) def test_populate_with_multiple_subdirs(self): dirname = join_path([self.test_dir, self.p('foo')]) bar_dirname = join_path([dirname, self.p('bar')]) baz_dirname = join_path([dirname, self.p('baz')]) bar_paths = [ join_path([bar_dirname, filename]) for filename in [self.p('klink'), self.p('klank')] ] baz_paths = [ join_path([baz_dirname, filename]) for filename in [self.p('klonk'), self.p('klunk')] ] self._create_dirs([dirname, bar_dirname, baz_dirname]) try: self._create_files(bar_paths + baz_paths) try: self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: # We use set(...) here because we can't make assumptions # about the order in which files are added via populate. # This is dependent upon the source tree filesystem (HPFS+ # seems to always return them in alphabetical order, while # ext3 returns them in the order that they were added). self.assertEqual( set(self.source_tree_rep.get_entries(u'/')), set([ self.p('klink'), self.p('klank'), self.p('klonk'), self.p('klunk'), ]), ) finally: self.source_tree_rep.stop() finally: self._remove_files(bar_paths + baz_paths) finally: self._remove_dirs([bar_dirname, baz_dirname, dirname]) def test_file_end_point(self): filename = self.p('foo') real_path = join_path([self.test_dir, filename]) self._create_file(real_path) try: self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([filename, filename]) self.source_tree_rep.start() try: self.assertEqual( self.source_tree_rep.get_real_path(fake_path), real_path) self.assertEqual( self.source_tree_rep.get_fake_paths(real_path), [fake_path]) self.assertRaises( NotADirectory, self.source_tree_rep.get_entries, fake_path) self.assertTrue( self.source_tree_rep.path_exists(fake_path)) self.assertTrue( self.source_tree_rep.is_file(fake_path)) self.assertFalse( self.source_tree_rep.is_dir(fake_path)) self.assertFalse( self.source_tree_rep.is_empty_dir(fake_path)) finally: self.source_tree_rep.stop() finally: self._remove_file(real_path) def test_directory_mid_point(self): filename = self.p('foo') real_path = join_path([self.test_dir, filename]) self._create_file(real_path) try: self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([filename]) self.source_tree_rep.start() try: self.assertRaises( IsADirectory, self.source_tree_rep.get_real_path, fake_path) self.assertEqual( self.source_tree_rep.get_entries(fake_path), [filename]) self.assertTrue( self.source_tree_rep.path_exists(fake_path)) self.assertFalse( self.source_tree_rep.is_file(fake_path)) self.assertTrue( self.source_tree_rep.is_dir(fake_path)) self.assertFalse( self.source_tree_rep.is_empty_dir(fake_path)) finally: self.source_tree_rep.stop() finally: self._remove_file(real_path) def test_directory_end_point(self): self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: self.source_tree_rep.add_directory(fake_path) self.assertRaises( IsADirectory, self.source_tree_rep.get_real_path, fake_path) self.assertEqual( self.source_tree_rep.get_entries(fake_path), []) self.assertTrue( self.source_tree_rep.path_exists(fake_path)) self.assertFalse( self.source_tree_rep.is_file(fake_path)) self.assertTrue( self.source_tree_rep.is_dir(fake_path)) self.assertTrue( self.source_tree_rep.is_empty_dir(fake_path)) finally: self.source_tree_rep.stop() def test_non_existent_path(self): self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: self.assertRaises( PathNotFound, self.source_tree_rep.get_real_path, fake_path) self.assertRaises( PathNotFound, self.source_tree_rep.get_entries, fake_path) self.assertFalse( self.source_tree_rep.path_exists(fake_path)) self.assertFalse( self.source_tree_rep.is_file(fake_path)) self.assertFalse( self.source_tree_rep.is_dir(fake_path)) self.assertFalse( self.source_tree_rep.is_empty_dir(fake_path)) finally: self.source_tree_rep.stop() def test_get_fake_path_with_directory(self): real_path = join_path([self.test_dir, self.p('foo')]) self._init(PathMetaStore(), u'/%f/%f') self._create_dir(real_path) try: self.source_tree_rep.start() try: self.assertRaises( PathNotFound, self.source_tree_rep.get_fake_paths, real_path) finally: self.source_tree_rep.stop() finally: self._remove_dir(real_path) def test_add_remove_source_dir_with_files_only(self): dirname = join_path([self.test_dir, self.p('foo')]) filenames = [self.p('bar'), self.p('baz')] file_paths = [join_path([dirname, filename]) for filename in filenames] self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: self._create_dir(dirname) self._create_files(file_paths) self.source_tree_rep.add_source_dir(dirname) # Seems like there is some variability in the order of entries # here on different systems. It must be related to the source # filesystem type, even though I would think it would only depend # on the order the files are added (above). It is not critical # that the order is what we'd expect, so we use set(...) here # to accomodate the variability. self.assertEqual( set(self.source_tree_rep.get_entries(u'/')), set(filenames), ) self._remove_files(file_paths) self._remove_dir(dirname) self.source_tree_rep.remove_source_dir(dirname) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self.source_tree_rep.stop() def test_add_remove_source_dir_with_subdirs(self): dirname = join_path([self.test_dir, self.p('foo')]) bar_dirname = join_path([dirname, self.p('bar')]) baz_dirname = join_path([dirname, self.p('baz')]) bar_paths = [ join_path([bar_dirname, filename]) for filename in [self.p('klink'), self.p('klank')] ] baz_paths = [ join_path([baz_dirname, filename]) for filename in [self.p('klonk'), self.p('klunk')] ] self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: self._create_dirs([dirname, bar_dirname, baz_dirname]) self._create_files(bar_paths + baz_paths) self.source_tree_rep.add_source_dir(dirname) # We use set(...) here because we can't make assumptions # about the order in which files are added via populate. # This is dependent upon the source tree filesystem (HPFS+ # seems to always return them in alphabetical order, while # ext3 returns them in the order that they were added). self.assertEqual( set(self.source_tree_rep.get_entries(u'/')), set([ self.p('klink'), self.p('klank'), self.p('klonk'), self.p('klunk'), ]), ) self._remove_files(bar_paths + baz_paths) self._remove_dirs([bar_dirname, baz_dirname, dirname]) self.source_tree_rep.remove_source_dir(dirname) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self.source_tree_rep.stop() def test_add_remove_source_file(self): file_path = join_path([self.test_dir, self.p('foo')]) self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: self._create_file(file_path) self.source_tree_rep.add_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [self.p('foo')], ) self._remove_file(file_path) self.source_tree_rep.remove_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self.source_tree_rep.stop() def test_add_source_file_nonexistent(self): file_path = join_path([self.test_dir, self.p('foo')]) self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: self.source_tree_rep.add_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self.source_tree_rep.stop() def test_add_source_file_unrepresentable(self): file_path = join_path([self.test_dir, self.p('foo')]) self._init(MutagenFileMetaStore(), u'/%t') self.source_tree_rep.start() try: self._create_file(file_path) try: self.source_tree_rep.add_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self._remove_file(file_path) finally: self.source_tree_rep.stop() def test_add_source_file_excluded_by_fake_path(self): file_path = join_path([self.test_dir, self.p('foo')]) content = self.p('bar') self._init( ContentMetaStore(), u'/%c', filters = [ (r'!^/%s$' % content, False), ], ) self.source_tree_rep.start() try: self._create_file(file_path, content) try: self.source_tree_rep.add_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self._remove_file(file_path) finally: self.source_tree_rep.stop() def test_add_source_file_excluded_by_real_path(self): file_path = join_path([self.test_dir, self.p('foo')]) content = u'bar' self._init( ContentMetaStore(), u'/%c', filters = [ (self.p(r'!^/%s$' % self.p('foo')), True), ], ) self.source_tree_rep.start() try: self._create_file(file_path, content) try: self.source_tree_rep.add_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self._remove_file(file_path) finally: self.source_tree_rep.stop() def test_add_remove_source_file_same_real_path_twice(self): file_path = join_path([self.test_dir, self.p('foo')]) self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: self._create_file(file_path) try: self.source_tree_rep.add_source_file(file_path) self.source_tree_rep.add_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [self.p('foo')], ) self.source_tree_rep.remove_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self._remove_file(file_path) finally: self.source_tree_rep.stop() def test_remove_source_file_nonexistent(self): file_path = join_path([self.test_dir, self.p('foo')]) self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: self.source_tree_rep.remove_source_file(file_path) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self.source_tree_rep.stop() def test_update_source_file_causing_path_rename(self): file_path = join_path([self.test_dir, self.p('foo')]) content = self.p('foo') new_content = self.p('bar') self._create_file(file_path, content) self._init(ContentMetaStore(), u'/%c') self.source_tree_rep.start() try: f = open(file_path, 'w') try: f.write(new_content.encode('utf-8')) finally: f.close() self.source_tree_rep.update_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [new_content], ) finally: self.source_tree_rep.stop() self._remove_file(file_path) def test_update_source_file_causing_no_path_rename(self): filename = self.p('foo') file_path = join_path([self.test_dir, filename]) content = 'foo' new_content = 'bar' self._create_file(file_path, content) self._init(PathMetaStore(), u'/%f') self.source_tree_rep.start() try: f = open(file_path, 'w') try: f.write(new_content.encode('utf-8')) finally: f.close() self.source_tree_rep.update_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [self.p(filename)], ) finally: self.source_tree_rep.stop() self._remove_file(file_path) def test_rename_path_with_file_end_point(self): file_path = join_path([self.test_dir, self.p('foo')]) content_old = self.p('bar\n') content_new = self.p('baz\n') self._create_file(file_path, content_old) self._init(ContentMetaStore(), u'/%c') self.source_tree_rep.start() try: self.source_tree_rep.rename_path( join_path_abs([content_old.rstrip(u'\n')]), join_path_abs([content_new.rstrip(u'\n')]), ) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [content_old.rstrip(u'\n')], ) self.assertEqual(self._get_file_content(file_path), content_new) finally: self.source_tree_rep.stop() self._remove_file(file_path) def test_rename_path_with_empty_directory_end_point(self): self._init(ContentMetaStore(), u'/%c/%c') self.source_tree_rep.start() try: self.source_tree_rep.add_directory(join_path_abs([self.p('foo')])) self.source_tree_rep.rename_path( join_path_abs([self.p('foo')]), join_path_abs([self.p('bar')]), ) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [self.p('bar')]) self.assertEqual( self.source_tree_rep.get_entries(self.p(u'/bar')), []) finally: self.source_tree_rep.stop() def test_rename_path_with_directory_containing_file_end_points(self): file_path = join_path([self.test_dir, self.p('foo')]) content_old = self.p('klink\n') content_new = self.p('klank\n') self._create_file(file_path, content_old) self._init( DelegateMultiMetaStore([ContentMetaStore(), PathMetaStore()]), u'/%c/%f', ) self.source_tree_rep.start() try: self.source_tree_rep.rename_path( join_path_abs([content_old.rstrip(u'\n')]), join_path_abs([content_new.rstrip(u'\n')]), ) self.source_tree_rep.update_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [content_new.rstrip(u'\n')], ) self.assertEqual( self.source_tree_rep.get_entries(join_path_abs([content_new.rstrip(u'\n')])), [self.p('foo')], ) self.assertEqual(self._get_file_content(file_path), content_new) finally: self.source_tree_rep.stop() self._remove_file(file_path) def test_rename_path_with_nonexistent_path(self): self._init(ContentMetaStore(), u'/%c') self.source_tree_rep.start() try: self.assertRaises( PathNotFound, self.source_tree_rep.rename_path, join_path_abs([self.p('foo')]), join_path_abs([self.p('bar')]), ) finally: self.source_tree_rep.stop() def test_rename_path_causing_value_change_on_first_of_two_values(self): self._init(ContentMetaStore(), u'/%c') file_path = join_path([self.test_dir, self.p('foo')]) self._create_file(file_path, self.p('bar\nbaz\n')) try: self.source_tree_rep.start() self.source_tree_rep.rename_path(self.p('/bar'), self.p('/qux')) self.source_tree_rep.update_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [self.p('baz'), self.p('qux')], ) finally: self._remove_file(file_path) def test_rename_path_causing_value_change_on_last_of_two_values(self): self._init(ContentMetaStore(), u'/%c') file_path = join_path([self.test_dir, self.p('foo')]) self._create_file(file_path, self.p('bar\nbaz\n')) try: self.source_tree_rep.start() self.source_tree_rep.rename_path(self.p('/baz'), self.p('/qux')) self.source_tree_rep.update_source_file(file_path) self.assertEqual( self.source_tree_rep.get_entries(u'/'), [self.p('bar'), self.p('qux')], ) finally: self._remove_file(file_path) def test_add_remove_directory(self): self._init(ContentMetaStore(), u'/%c/%c') self.source_tree_rep.start() try: self.source_tree_rep.add_directory(join_path_abs([self.p('foo')])) self.source_tree_rep.remove_directory(join_path_abs([self.p('foo')])) self.assertEqual(self.source_tree_rep.get_entries(u'/'), []) finally: self.source_tree_rep.stop() def test_supports_threads(self): self._init() value = self.source_tree_rep.supports_threads() self.assertTrue((value is True) or (value is False)) def test_can_handle_fork(self): self._init() value = self.source_tree_rep.can_handle_fork() self.assertTrue((value is True) or (value is False)) def _assert_lstat_getattr_attrs_are_equal( self, attr, lstat_result, getattr_result): lstat_value = getattr(lstat_result, attr) getattr_value = getattr(getattr_result, attr) self.assertEqual( lstat_value, getattr_value, '%s is not equal: %s != %s' % ( attr, lstat_value, getattr_value), ) def _assert_lstat_getattr_attrs_are_equal_plus_or_minus( self, attr, lstat_result, getattr_result, n): lstat_value = getattr(lstat_result, attr) getattr_value = getattr(getattr_result, attr) self.assertEqualPlusOrMinus( lstat_value, getattr_value, n, '%s: %s and %s are more than %s apart' % ( attr, lstat_value, getattr_value, n), ) def test_getattr_with_file_end_point(self): filename = self.p('foo') real_path = join_path([self.test_dir, filename]) self._create_file(real_path) try: self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([filename, filename]) self.source_tree_rep.start() try: lstat_result = os.lstat(real_path) getattr_result = self.source_tree_rep.getattr(fake_path) self.assertTrue(isinstance(getattr_result, os.stat_result)) self.assertTrue(stat.S_ISREG(getattr_result.st_mode)) self.assertEqual( stat.S_IMODE(lstat_result.st_mode), stat.S_IMODE(getattr_result.st_mode), ) for attr in ('st_nlink', 'st_uid', 'st_gid', 'st_size'): self._assert_lstat_getattr_attrs_are_equal( attr, lstat_result, getattr_result) for attr in ('st_atime', 'st_mtime', 'st_ctime'): self._assert_lstat_getattr_attrs_are_equal_plus_or_minus( attr, lstat_result, getattr_result, 2) finally: self.source_tree_rep.stop() finally: self._remove_file(real_path) def test_getattr_with_directory_end_point(self): self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: self.source_tree_rep.add_directory(fake_path) lstat_result = os.lstat(self.test_dir) getattr_result = self.source_tree_rep.getattr(fake_path) self.assertTrue(isinstance(getattr_result, os.stat_result)) self.assertEqual(getattr_result.st_size, 0) # Empty directories have two links. self.assertEqual(getattr_result.st_nlink, 2) self.assertTrue(stat.S_ISDIR(getattr_result.st_mode)) self.assertEqual( stat.S_IMODE(lstat_result.st_mode), stat.S_IMODE(getattr_result.st_mode), ) for attr in ('st_uid', 'st_gid'): self._assert_lstat_getattr_attrs_are_equal( attr, lstat_result, getattr_result) for attr in ('st_atime', 'st_mtime', 'st_ctime'): self._assert_lstat_getattr_attrs_are_equal_plus_or_minus( attr, lstat_result, getattr_result, 2) finally: self.source_tree_rep.stop() def test_getattr_with_directory_mid_point(self): filename = self.p('foo') real_path = join_path([self.test_dir, filename]) self._create_file(real_path) try: self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) fake_path_parent = os.path.dirname(fake_path) self.source_tree_rep.start() try: for test_path in (fake_path_parent, fake_path): dir_lstat_result = os.lstat(self.test_dir) file_lstat_result = os.lstat(real_path) getattr_result = self.source_tree_rep.getattr(test_path) self.assertTrue(isinstance(getattr_result, os.stat_result)) self.assertEqual(getattr_result.st_size, 0) if test_path == fake_path: # A directory containing one file has two links. self.assertEqual(getattr_result.st_nlink, 2) else: # A directory containing one subdirectory has three links. self.assertEqual(getattr_result.st_nlink, 3) self.assertTrue(stat.S_ISDIR(getattr_result.st_mode)) self.assertEqual( stat.S_IMODE(dir_lstat_result.st_mode), stat.S_IMODE(getattr_result.st_mode), ) # Ownership should be the same as the source directory. for attr in ('st_uid', 'st_gid'): self._assert_lstat_getattr_attrs_are_equal( attr, dir_lstat_result, getattr_result) # Times should be the same as the contained file. for attr in ('st_atime', 'st_mtime', 'st_ctime'): self._assert_lstat_getattr_attrs_are_equal_plus_or_minus( attr, file_lstat_result, getattr_result, 2) finally: self.source_tree_rep.stop() finally: self._remove_file(real_path) def test_getattr_with_non_existent_path(self): self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: self.assertRaises( PathNotFound, self.source_tree_rep.getattr, fake_path) finally: self.source_tree_rep.stop() def test_utime_with_file_end_point(self): filename = self.p('foo') real_path = join_path([self.test_dir, filename]) self._create_file(real_path) self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([filename, filename]) self.source_tree_rep.start() try: times = (1, 2) self.source_tree_rep.utime(fake_path, times) lstat_result = os.lstat(real_path) self.assertEqual(lstat_result.st_atime, times[0]) self.assertEqual(lstat_result.st_mtime, times[1]) finally: self.source_tree_rep.stop() self._remove_file(real_path) def test_utime_with_directory_end_point(self): self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: self.source_tree_rep.add_directory(fake_path) times = (1, 2) self.source_tree_rep.utime(fake_path, times) lstat_result = os.lstat(self.test_dir) self.assertEqual(lstat_result.st_atime, times[0]) self.assertEqual(lstat_result.st_mtime, times[1]) finally: self.source_tree_rep.stop() def test_utime_with_directory_mid_point(self): filename = self.p('foo') real_path = join_path([self.test_dir, filename]) self._create_file(real_path) try: self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: times = (1, 2) self.source_tree_rep.utime(fake_path, times) lstat_result = os.lstat(real_path) self.assertEqual(lstat_result.st_atime, times[0]) self.assertEqual(lstat_result.st_mtime, times[1]) finally: self.source_tree_rep.stop() finally: self._remove_file(real_path) def test_utime_with_non_existent_path(self): self._init(PathMetaStore(), u'/%f/%f') fake_path = join_path_abs([self.p('foo')]) self.source_tree_rep.start() try: self.assertRaises( PathNotFound, self.source_tree_rep.utime, fake_path, (1, 2)) finally: self.source_tree_rep.stop() def test_path_conflict_then_remove_first(self): self._init(PathMetaStore(), u'/%f') filename = self.p('foo') real_path1 = join_path([self.test_dir, self.p('bar'), filename]) real_path2 = join_path([self.test_dir, self.p('baz'), filename]) files = (real_path1, real_path2) dirs = [os.path.dirname(p) for p in files] fake_path = join_path_abs([filename]) self.source_tree_rep.start() try: self._create_dirs(dirs) try: self._create_files(files) self.source_tree_rep.add_source_file(real_path1) self.source_tree_rep.add_source_file(real_path2) self._remove_file(real_path1) self.source_tree_rep.remove_source_file(real_path1) self.assertEqual( self.source_tree_rep.get_real_path(fake_path), real_path2, ) self._remove_file(real_path2) self.source_tree_rep.remove_source_file(real_path2) self.assertRaises( PathNotFound, self.source_tree_rep.get_real_path, fake_path, ) finally: self._remove_dirs(dirs) finally: self.source_tree_rep.stop() def test_path_conflict_then_remove_second(self): self._init(PathMetaStore(), u'/%f') filename = self.p('foo') real_path1 = join_path([self.test_dir, self.p('bar'), filename]) real_path2 = join_path([self.test_dir, self.p('baz'), filename]) files = (real_path1, real_path2) dirs = [os.path.dirname(p) for p in files] fake_path = join_path_abs([filename]) self.source_tree_rep.start() try: self._create_dirs(dirs) try: self._create_files(files) self.source_tree_rep.add_source_file(real_path1) self.source_tree_rep.add_source_file(real_path2) self._remove_file(real_path2) self.source_tree_rep.remove_source_file(real_path2) self.assertEqual( self.source_tree_rep.get_real_path(fake_path), real_path1, ) self._remove_file(real_path1) self.source_tree_rep.remove_source_file(real_path1) self.assertRaises( PathNotFound, self.source_tree_rep.get_real_path, fake_path, ) finally: self._remove_dirs(dirs) finally: self.source_tree_rep.stop() def test_real_path_with_multiple_tag_values(self): real_path = join_path([self.test_dir, self.p('foo')]) content = self.p('bar\nbaz\nqux\n') fake_path1 = join_path_abs([self.p('bar')]) fake_path2 = join_path_abs([self.p('baz')]) fake_path3 = join_path_abs([self.p('qux')]) self._create_file(real_path, content) try: self._init(ContentMetaStore(), u'/%c') self.source_tree_rep.start() try: self.assertEqual( self.source_tree_rep.get_real_path(fake_path1), real_path) self.assertEqual( self.source_tree_rep.get_real_path(fake_path2), real_path) self.assertEqual( self.source_tree_rep.get_real_path(fake_path3), real_path) self.assertEqual( self.source_tree_rep.get_fake_paths( real_path), [fake_path1, fake_path2, fake_path3]) finally: self.source_tree_rep.stop() finally: self._remove_file(real_path) manager.add_test_case_class(SourceTreeRepresentationTestCase) manager.add_test_case_class(mixin_unicode(SourceTreeRepresentationTestCase)) manager.add_test_case_class( mixin_pathpropcache(SourceTreeRepresentationTestCase)) manager.add_test_case_class( mixin_unicode(mixin_pathpropcache(SourceTreeRepresentationTestCase))) manager.add_doc_test_cases_from_module(__name__, 'pytagsfs.sourcetree') pytagsfs-0.9.2/tests/sourcetreemon.py0000644000175000017500000002572711315711421017367 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, time, stat from pytagsfs.sourcetreemon.inotifyx_ import ( InotifyxSourceTreeMonitor, DeferredInotifyxSourceTreeMonitor, ) from pytagsfs.sourcetreemon.gamin_ import ( GaminSourceTreeMonitor, DeferredGaminSourceTreeMonitor, ) from pytagsfs.sourcetreemon.kqueue_ import ( KqueueSourceTreeMonitor, DeferredKqueueSourceTreeMonitor, ) from common import ( PLATFORM, NO_INOTIFY_PLATFORMS, NO_GAMIN_PLATFORMS, NO_KQUEUE_PLATFORMS, TEST_DATA_DIR, TestWithDir, ) from manager import manager ADD = 'ADD' REMOVE = 'REMOVE' UPDATE = 'UPDATE' class StopLooking(Exception): pass class _SourceTreeMonitorTestCase(TestWithDir): test_dir_prefix = 'stm' sourcetreemoncls = None sets_is_dir = False def setUp(self): super(_SourceTreeMonitorTestCase, self).setUp() self.events = [] self.stm = self.sourcetreemoncls() self.stm.set_add_cb(self.add_cb) self.stm.set_remove_cb(self.remove_cb) self.stm.set_update_cb(self.update_cb) self.stm.start() self.stm.add_source_dir(self.test_dir) # FIXME: Is this necessary? time.sleep(2) def tearDown(self): self.stm.stop() del self.stm super(_SourceTreeMonitorTestCase, self).tearDown() def add_cb(self, path, is_dir = None): self.events.append((ADD, path, is_dir)) try: names = os.listdir(path) except (IOError, OSError): names = [] if is_dir is None: self.stm.add_source_dir(path) self.stm.add_source_file(path) elif is_dir: self.stm.add_source_dir(path) else: self.stm.add_source_file(path) for name in names: self.stm.add_cb(os.path.join(path, name)) def remove_cb(self, path, is_dir = None): self.events.append((REMOVE, path, is_dir)) if is_dir is None: self.stm.remove_source_dir(path) self.stm.remove_source_file(path) elif is_dir: self.stm.remove_source_dir(path) else: self.stm.remove_source_file(path) def update_cb(self, path, is_dir = None): self.events.append((UPDATE, path, is_dir)) def clearEvents(self): while self.events: self.events.pop() def waitForEvents(self, *expected_events, **kwargs): expected_events = list(expected_events) expect_is_dir = kwargs.get('expect_is_dir', True) try: for count in range(10): self.clearEvents() self.stm.process_events() for event in self.events: for expected_event in expected_events: if expect_is_dir and self.sets_is_dir: if event == expected_event: expected_events.remove(expected_event) if not expected_events: raise StopLooking else: if event[0:2] == expected_event[0:2]: expected_events.remove(expected_event) if not expected_events: raise StopLooking time.sleep(1) except StopLooking: pass if expected_events: raise AssertionError( 'did not receive events: %s' % str(expected_events)) def writeFileContents(self, filename, contents): f = open(filename, 'w') try: f.write(contents) finally: f.close() def test_create_file(self): test_file = os.path.join(self.test_dir, 'foo') self.writeFileContents(test_file, 'foo\n') try: self.waitForEvents((ADD, test_file, False)) finally: os.unlink(test_file) def test_create_directory(self): test_dir = os.path.join(self.test_dir, 'foo') os.mkdir(test_dir) try: self.waitForEvents((ADD, test_dir, True)) finally: os.rmdir(test_dir) def test_remove_file(self): test_file = os.path.join(self.test_dir, 'foo') self.writeFileContents(test_file, 'foo\n') try: self.waitForEvents((ADD, test_file, False)) except: os.unlink(test_file) raise os.unlink(test_file) self.waitForEvents((REMOVE, test_file, False)) def test_remove_directory(self): test_dir = os.path.join(self.test_dir, 'foo') os.mkdir(test_dir) try: self.waitForEvents((ADD, test_dir, True)) except: os.rmdir(test_dir) raise os.rmdir(test_dir) self.waitForEvents((REMOVE, test_dir, True)) def test_rename_file(self): test_file = os.path.join(self.test_dir, 'foo') test_file_renamed = os.path.join(self.test_dir, 'bar') self.writeFileContents(test_file, 'foo\n') try: self.waitForEvents((ADD, test_file, False)) except: os.unlink(test_file) raise os.rename(test_file, test_file_renamed) try: self.waitForEvents( (REMOVE, test_file, False), (ADD, test_file_renamed, False), ) finally: os.unlink(test_file_renamed) def test_rename_directory(self): test_dir = os.path.join(self.test_dir, 'foo') test_dir_renamed = os.path.join(self.test_dir, 'bar') os.mkdir(test_dir) try: self.waitForEvents((ADD, test_dir, True)) except: os.rmdir(test_dir) raise os.rename(test_dir, test_dir_renamed) try: self.waitForEvents( (REMOVE, test_dir, True), (ADD, test_dir_renamed, True), ) finally: os.rmdir(test_dir_renamed) def test_update_file(self): test_file = os.path.join(self.test_dir, 'foo') self.writeFileContents(test_file, 'foo\n') try: self.waitForEvents((ADD, test_file, False)) except: os.unlink(test_file) raise f = open(test_file, 'a+') try: f.write('bar\n') finally: f.close() try: self.waitForEvents((UPDATE, test_file, False)) finally: os.unlink(test_file) def test_replace_file(self): test_file = os.path.join(self.test_dir, 'foo') replacement_source_file = 'bar' self.writeFileContents(test_file, 'foo\n') try: self.waitForEvents((ADD, test_file, False)) except: os.unlink(test_file) raise self.writeFileContents(replacement_source_file, 'bar\n') os.rename(replacement_source_file, test_file) try: self.waitForEvents( # On replacements, we need not receive a remove event. Some # SourceTreeMonitor implementations do not provide this easily, # and SourceTreeRepresentation does an update when a path is added # twice, anyway. #(REMOVE, test_file, False), (ADD, test_file, False), ) finally: os.unlink(test_file) def test_remove_nested_directories(self): test_dir_base = os.path.join(self.test_dir, 'a') test_dir = os.path.join(test_dir_base, 'b', 'c', 'd', 'e', 'f') dirs = [] dir = test_dir while dir != self.test_dir: dirs.append(dir) dir = os.path.dirname(dir) def remove_dirs(): for dir in dirs: os.rmdir(dir) os.makedirs(test_dir) try: self.waitForEvents((ADD, test_dir, True), expect_is_dir = False) except: remove_dirs() raise remove_dirs() # Test that removals are received in the right order for nested # directories: removals = [] count = 0 while len(removals) < len(dirs): self.stm.process_events() while self.events: event = self.events.pop(0) if event[0] == REMOVE: removals.append(event[1]) time.sleep(1) count = count + 1 if count > len(dirs) + 1: raise AssertionError('waited too long for events') self._check_removals(removals, dirs) def _check_removals(self, removals, dirs): self.assertEqual(removals, dirs) if PLATFORM not in NO_INOTIFY_PLATFORMS: class InotifyxSourceTreeMonitorTestCase(_SourceTreeMonitorTestCase): sourcetreemoncls = InotifyxSourceTreeMonitor sets_is_dir = True manager.add_test_case_class(InotifyxSourceTreeMonitorTestCase) class DeferredInotifyxSourceTreeMonitorTestCase(_SourceTreeMonitorTestCase): sourcetreemoncls = DeferredInotifyxSourceTreeMonitor sets_is_dir = True manager.add_test_case_class(DeferredInotifyxSourceTreeMonitorTestCase) if PLATFORM not in NO_GAMIN_PLATFORMS: class GaminSourceTreeMonitorTestCase(_SourceTreeMonitorTestCase): sourcetreemoncls = GaminSourceTreeMonitor sets_is_dir = False def _check_removals(self, removals, dirs): # Gamin does not return these events in a reliable order. This # situation is handled fine, even though it is inappropriate. As # an exception, we don't fail this test if that happens. self.assertEqual(set(removals), set(dirs)) manager.add_test_case_class(GaminSourceTreeMonitorTestCase) class DeferredGaminSourceTreeMonitorTestCase(_SourceTreeMonitorTestCase): sourcetreemoncls = DeferredGaminSourceTreeMonitor sets_is_dir = False def _check_removals(self, removals, dirs): # Gamin does not return these events in a reliable order. This # situation is handled fine, even though it is inappropriate. As # an exception, we don't fail this test if that happens. self.assertEqual(set(removals), set(dirs)) manager.add_test_case_class(DeferredGaminSourceTreeMonitorTestCase) if PLATFORM not in NO_KQUEUE_PLATFORMS: class KqueueSourceTreeMonitorTestCase(_SourceTreeMonitorTestCase): sourcetreemoncls = KqueueSourceTreeMonitor sets_is_dir = False manager.add_test_case_class(KqueueSourceTreeMonitorTestCase) class DeferredKqueueSourceTreeMonitorTestCase(_SourceTreeMonitorTestCase): sourcetreemoncls = DeferredKqueueSourceTreeMonitor sets_is_dir = False manager.add_test_case_class(DeferredKqueueSourceTreeMonitorTestCase) pytagsfs-0.9.2/tests/mutagen_meta_store.py0000644000175000017500000000145611315711421020350 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from unittest import TestCase from pytagsfs.metastore.mutagen_ import MutagenFileMetaStore from manager import manager class MutagenFileMetaStoreTestCase(TestCase): def test_post_process(self): store = MutagenFileMetaStore() tags = {'n': ['1']} store.post_process(tags) self.assertEqual( tags, {'n': ['1'], 'N': ['01'], 'TRACKNUMBER': ['01']}, ) manager.add_test_case_class(MutagenFileMetaStoreTestCase) pytagsfs-0.9.2/tests/pytypes.py0000644000175000017500000000162711315711421016203 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from manager import manager from pytagsfs.pathstore.pytypes import PyTypesPathStore from pathstore import _PathStoreTestCase from common import _UnicodePathsMixin class PyTypesPathStoreTestCase(_PathStoreTestCase): path_store_class = PyTypesPathStore manager.add_test_case_class(PyTypesPathStoreTestCase) class PyTypesPathStoreUnicodeTestCase(_UnicodePathsMixin, _PathStoreTestCase): path_store_class = PyTypesPathStore manager.add_test_case_class(PyTypesPathStoreUnicodeTestCase) manager.add_doc_test_cases_from_module(__name__, 'pytagsfs.pathstore.pytypes') pytagsfs-0.9.2/tests/sourcetree.py0000644000175000017500000000462711315711421016651 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os from unittest import TestCase from pytagsfs.sourcetree import SourceTree from pytagsfs.util import unicode_path_sep from manager import manager class SourceTreeTestCase(TestCase): root = os.path.join(unicode_path_sep, u'foo', u'bar') def setUp(self): self.source_tree = SourceTree(self.root) def tearDown(self): del self.source_tree def test_get_relative_path(self): self.assertEqual( self.source_tree.get_relative_path( os.path.join(self.root, u'a')), os.path.join(unicode_path_sep, u'a'), ) self.assertEqual( self.source_tree.get_relative_path(self.root), unicode_path_sep, ) # Paths must begin with a slash. self.assertRaises( ValueError, self.source_tree.get_relative_path, u'a', ) # Paths must not end with a slash. path = os.path.join(unicode_path_sep, u'a', u'') self.assertTrue(path.endswith(unicode_path_sep)) self.assertRaises( ValueError, self.source_tree.get_relative_path, path, ) def test_get_absolute_path(self): self.assertEqual( self.source_tree.get_absolute_path( os.path.join(unicode_path_sep, u'a')), os.path.join(self.root, u'a'), ) self.assertEqual( self.source_tree.get_absolute_path(unicode_path_sep), self.root, ) # Paths must begin with a slash. self.assertRaises( ValueError, self.source_tree.get_absolute_path, u'a', ) # Paths must not end with a slash. path = os.path.join(unicode_path_sep, u'a', u'') self.assertTrue(path.endswith(unicode_path_sep)) self.assertRaises( ValueError, self.source_tree.get_absolute_path, path, ) manager.add_test_case_class(SourceTreeTestCase) class RootSourceTreeTestCase(SourceTreeTestCase): root = unicode_path_sep manager.add_test_case_class(RootSourceTreeTestCase) pytagsfs-0.9.2/tests/optgroup.py0000644000175000017500000000067011315711421016342 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from manager import manager manager.add_doc_test_cases_from_module(__name__, 'pytagsfs.optgroup') pytagsfs-0.9.2/tests/pathstore.py0000644000175000017500000004720211315711421016476 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from unittest import TestCase from pytagsfs.exceptions import ( PathNotFound, NotADirectory, IsADirectory, PathExists, NoMetaDataExists, NotAnEndPoint, ) from common import _UnicodePathsMixin from manager import manager # Note: We don't actually run any tests in this module. We only define a base # class for specific implementations to sub-class test cases from. class _PathStoreTestCase(TestCase): path_store_class = None def p(self, s): if not isinstance(s, unicode): s = unicode(s) return s def test_add_file_end_point_flat(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) self.assertEqual(store.get_real_path(self.p('/foo')), self.p('/bar')) self.assertEqual(store.get_entries(self.p('/')), [self.p('foo')]) def test_add_file_end_point_deep(self): store = self.path_store_class() store.add_file(self.p('/foo/bar/baz'), self.p('/klink/klank')) self.assertEqual(store.get_real_path(self.p('/foo/bar/baz')), self.p('/klink/klank')) self.assertEqual(store.get_entries(self.p('/')), [self.p('foo')]) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('bar')]) self.assertEqual(store.get_entries(self.p('/foo/bar')), [self.p('baz')]) def test_add_directory_end_point_flat(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), [self.p('foo')]) self.assertEqual(store.get_entries(self.p('/foo')), []) def test_add_directory_end_point_deep(self): store = self.path_store_class() store.add_directory(self.p('/foo/bar/baz')) self.assertEqual(store.get_entries(self.p('/')), [self.p('foo')]) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('bar')]) self.assertEqual(store.get_entries(self.p('/foo/bar')), [self.p('baz')]) self.assertEqual(store.get_entries(self.p('/foo/bar/baz')), []) def test_add_file_with_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertRaises(PathExists, store.add_file, self.p('/foo'), self.p('/bar')) def test_add_directory_with_file_end_point(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) self.assertRaises(PathExists, store.add_directory, self.p('/foo')) def test_add_directory_with_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertRaises(PathExists, store.add_directory, self.p('/foo')) def test_get_real_path_with_non_existent_fake_path(self): store = self.path_store_class() self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo')) def test_get_fake_paths_with_non_existent_real_path(self): store = self.path_store_class() self.assertRaises(PathNotFound, store.get_fake_paths, self.p('/foo')) def test_get_entries_with_non_existent_fake_path(self): store = self.path_store_class() self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) def test_get_real_path_with_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertRaises(IsADirectory, store.get_real_path, self.p('/foo')) def test_remove_file_end_point_flat(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) store.remove(self.p('/foo')) self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), []) def test_remove_file_end_point_deep(self): store = self.path_store_class() store.add_file(self.p('/foo/bar/baz'), self.p('/klink/bonk')) store.remove(self.p('/foo/bar/baz')) self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo/bar/baz')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), []) def test_remove_directory_end_point_flat(self): store = self.path_store_class() store.add_directory(self.p('/foo')) store.remove(self.p('/foo')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), []) def test_remove_directory_end_point_deep(self): store = self.path_store_class() store.add_directory(self.p('/foo/bar/baz')) store.remove(self.p('/foo/bar/baz')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo/bar/baz')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), []) def test_rename_file_end_point_flat_to_flat(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) store.rename(self.p('/foo'), self.p('/baz')) self.assertEqual(store.get_real_path(self.p('/baz')), self.p('/bar')) self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), [self.p('baz')]) def test_rename_file_end_point_deep_to_deep(self): store = self.path_store_class() store.add_file(self.p('/foo/bar/baz'), self.p('/bink/bonk')) store.rename(self.p('/foo/bar/baz'), self.p('/klink/klank/klonk')) self.assertEqual( store.get_real_path(self.p('/klink/klank/klonk')), self.p('/bink/bonk')) self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo/bar/baz')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), [self.p('klink')]) self.assertEqual(store.get_entries(self.p('/klink')), [self.p('klank')]) self.assertEqual(store.get_entries(self.p('/klink/klank')), [self.p('klonk')]) def test_rename_file_end_point_flat_to_deep(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bink/bonk')) store.rename(self.p('/foo'), self.p('/klink/klank/klonk')) self.assertEqual( store.get_real_path(self.p('/klink/klank/klonk')), self.p('/bink/bonk')) self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo/bar/baz')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), [self.p('klink')]) self.assertEqual(store.get_entries(self.p('/klink')), [self.p('klank')]) self.assertEqual(store.get_entries(self.p('/klink/klank')), [self.p('klonk')]) def test_rename_file_end_point_deep_to_flat(self): store = self.path_store_class() store.add_file(self.p('/foo/bar/baz'), self.p('/klank/klonk')) store.rename(self.p('/foo/bar/baz'), self.p('/klink')) self.assertEqual(store.get_real_path(self.p('/klink')), self.p('/klank/klonk')) self.assertRaises(PathNotFound, store.get_real_path, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), [self.p('klink')]) def test_rename_directory_end_point_within_root(self): store = self.path_store_class() store.add_directory(self.p('/foo')) store.rename(self.p('/foo'), self.p('/bar')) self.assertEqual(store.get_entries(self.p('/bar')), []) self.assertEqual(store.get_entries(self.p('/')), [self.p('bar')]) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) def test_rename_directory_end_point_within_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) store.add_directory(self.p('/foo/bar')) store.rename(self.p('/foo/bar'), self.p('/foo/baz')) self.assertEqual(store.get_entries(self.p('/foo/baz')), []) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('baz')]) self.assertEqual(store.get_entries(self.p('/')), [self.p('foo')]) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo/bar')) def test_rename_directory_containing_file_end_point(self): # Only end-points can be renamed. store = self.path_store_class() store.add_file(self.p('/foo/bar/baz'), self.p('/klink/klank')) self.assertRaises( NotAnEndPoint, store.rename, self.p('/foo/bar'), self.p('/foo/klonk')) def test_rename_directory_containing_directory_end_point(self): # Only end-points can be renamed. store = self.path_store_class() store.add_directory(self.p('/foo/bar/baz')) self.assertRaises( NotAnEndPoint, store.rename, self.p('/foo/bar'), self.p('/foo/klink')) def test_rename_directory_containing_non_empty_directory(self): # Only end-points can be renamed. store = self.path_store_class() store.add_file(self.p('/foo/bar/baz'), self.p('/klink/klank')) self.assertRaises( NotAnEndPoint, store.rename, self.p('/foo'), self.p('/klonk')) def test_add_file_with_file_end_point(self): # This creates a simple path collision. store = self.path_store_class() store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) store.add_file(self.p('/foo/bar'), self.p('/biz/baz')) self.assertEqual(store.get_real_path(self.p('/foo/bar')), self.p('/biz/baz')) store.remove(self.p('/foo/bar')) self.assertEqual(store.get_real_path(self.p('/foo/bar')), self.p('/klink/klank')) def test_order_of_entries_matches_order_added(self): store = self.path_store_class() store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) store.add_file(self.p('/foo/baz'), self.p('/klink/klonk')) store.add_file(self.p('/foo/qux'), self.p('/klink/klonk')) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('bar'), self.p('baz'), self.p('qux')]) def test_order_of_entries_with_collision(self): # Order of entries must still match the order added, even after a # collision has been created and subsequently resolved. store = self.path_store_class() store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) store.add_file(self.p('/foo/qux'), self.p('/klink/klonk')) store.add_file(self.p('/foo/bar'), self.p('/klink/klunk')) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('qux'), self.p('bar')]) store.remove(self.p('/foo/bar')) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('bar'), self.p('qux')]) def test_order_of_entries_with_rename(self): store = self.path_store_class() store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) store.add_file(self.p('/biz/baz'), self.p('/klink/boink')) store.add_file(self.p('/foo/qux'), self.p('/klink/klonk')) store.add_file(self.p('/foo/clunk'), self.p('/klink/klunk')) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('bar'), self.p('qux'), self.p('clunk')]) store.rename(self.p('/foo/bar'), self.p('/foo/point')) self.assertEqual(store.get_entries(self.p('/foo')), [self.p('point'), self.p('qux'), self.p('clunk')]) def test_remove_directory(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), [self.p('foo')]) self.assertEqual(store.get_entries(self.p('/foo')), []) store.remove(self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), []) def test_add_file_in_empty_directory_and_then_removing_removes_directory( self): store = self.path_store_class() store.add_directory(self.p('/foo')) store.add_file(self.p('/foo/bar'), self.p('/baz')) store.remove(self.p('/foo/bar')) self.assertRaises(PathNotFound, store.get_entries, self.p('/foo')) self.assertEqual(store.get_entries(self.p('/')), []) def test_removing_file_removes_real_paths(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) store.remove(self.p('/foo')) self.assertRaises(PathNotFound, store.get_fake_paths, self.p('/bar')) def test_is_dir_with_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertTrue(store.is_dir(self.p('/foo'))) def test_is_dir_with_directory_containing_file_end_point(self): store = self.path_store_class() store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) self.assertTrue(store.is_dir(self.p('/foo'))) def test_is_dir_with_directory_containing_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo/bar')) self.assertTrue(store.is_dir(self.p('/foo'))) def test_is_dir_with_nonexistent_path(self): store = self.path_store_class() self.assertFalse(store.is_dir(self.p('/foo'))) def test_is_file_with_file_end_point(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) self.assertTrue(store.is_file(self.p('/foo'))) def test_is_file_with_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertFalse(store.is_file(self.p('/foo'))) def test_path_exists_with_file_end_point(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) self.assertTrue(store.path_exists(self.p('/foo'))) def test_path_exists_with_directory_end_point(self): store = self.path_store_class() store.add_directory(self.p('/foo')) self.assertTrue(store.path_exists(self.p('/foo'))) def test_path_exists_with_non_existent_path(self): store = self.path_store_class() self.assertFalse(store.path_exists(self.p('/foo'))) def test_get_entries_with_file_end_point(self): store = self.path_store_class() store.add_file(self.p('/foo'), self.p('/bar')) self.assertRaises(NotADirectory, store.get_entries, self.p('/foo')) def test_get_entries_with_empty_path_store(self): store = self.path_store_class() self.assertEqual(store.get_entries(self.p('/')), []) def test_get_real_subpaths(self): store = self.path_store_class() store.add_file(self.p('/klink'), self.p('/foo/bar/baz')) store.add_file(self.p('/klank'), self.p('/foo/bar/qux')) self.assertEqual( store.get_real_subpaths(self.p('/foo')), [self.p('/foo/bar/baz'), self.p('/foo/bar/qux')], ) def test_meta_data_with_file_end_point(self): store = self.path_store_class() a = {1: 2, 3: 4} b = {5: 6, 7: 8} store.add_file(self.p('/foo/bar'), self.p('/bink/bonk')) self.assertRaises(NoMetaDataExists, store.get_meta_data, self.p('/foo/bar')) store.set_meta_data(self.p('/foo/bar'), a) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), a) store.set_meta_data(self.p('/foo/bar'), b) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), b) store.unset_meta_data(self.p('/foo/bar')) self.assertRaises(NoMetaDataExists, store.get_meta_data, self.p('/foo/bar')) def test_meta_data_with_directory_end_point(self): store = self.path_store_class() a = {1: 2, 3: 4} b = {5: 6, 7: 8} store.add_directory(self.p('/foo/bar')) self.assertRaises(NoMetaDataExists, store.get_meta_data, self.p('/foo/bar')) store.set_meta_data(self.p('/foo/bar'), a) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), a) store.set_meta_data(self.p('/foo/bar'), b) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), b) store.unset_meta_data(self.p('/foo/bar')) self.assertRaises(NoMetaDataExists, store.get_meta_data, self.p('/foo/bar')) def test_meta_data_with_directory_containing_file_end_point(self): store = self.path_store_class() a = {1: 2, 3: 4} store.add_file(self.p('/foo/bar/baz'), self.p('/bink/bonk')) self.assertRaises(NotAnEndPoint, store.get_meta_data, self.p('/foo/bar')) self.assertRaises(NotAnEndPoint, store.set_meta_data, self.p('/foo/bar'), a) self.assertRaises(NotAnEndPoint, store.get_meta_data, self.p('/foo/bar')) self.assertRaises(NotAnEndPoint, store.unset_meta_data, self.p('/foo/bar')) self.assertRaises(NotAnEndPoint, store.get_meta_data, self.p('/foo/bar')) def test_meta_data_with_directory_containing_directory_end_point(self): store = self.path_store_class() a = {1: 2, 3: 4} store.add_directory(self.p('/foo/bar/baz')) self.assertRaises(NotAnEndPoint, store.get_meta_data, self.p('/foo/bar')) self.assertRaises(NotAnEndPoint, store.set_meta_data, self.p('/foo/bar'), a) self.assertRaises(NotAnEndPoint, store.get_meta_data, self.p('/foo/bar')) self.assertRaises(NotAnEndPoint, store.unset_meta_data, self.p('/foo/bar')) self.assertRaises(NotAnEndPoint, store.get_meta_data, self.p('/foo/bar')) def test_meta_data_with_non_existent_path(self): store = self.path_store_class() a = {1: 2, 3: 4} self.assertRaises(PathNotFound, store.get_meta_data, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.set_meta_data, self.p('/foo/bar'), a) self.assertRaises(PathNotFound, store.get_meta_data, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.unset_meta_data, self.p('/foo/bar')) self.assertRaises(PathNotFound, store.get_meta_data, self.p('/foo/bar')) def test_meta_data_with_overridden_file_end_point(self): store = self.path_store_class() a = {1: 2, 3: 4} b = {5: 6, 7: 8} store.add_file(self.p('/foo/bar'), self.p('/bink/bonk')) store.set_meta_data(self.p('/foo/bar'), a) # Add a new end point that overrides the first. Conceptually, this end # point is a blank slate. store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) self.assertRaises( NoMetaDataExists, store.get_meta_data, self.p('/foo/bar')) store.set_meta_data(self.p('/foo/bar'), b) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), b) # Removing the new end point gives us the old end point back, including # meta-data. store.remove(self.p('/foo/bar')) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), a) store.add_file(self.p('/foo/bar'), self.p('/klink/klank')) self.assertRaises( NoMetaDataExists, store.get_meta_data, self.p('/foo/bar')) store.set_meta_data(self.p('/foo/bar'), b) store.unset_meta_data(self.p('/foo/bar')) store.remove(self.p('/foo/bar')) self.assertEqual(store.get_meta_data(self.p('/foo/bar')), a) def test_supports_threads(self): store = self.path_store_class() self.assertTrue(store.supports_threads() in (True, False)) pytagsfs-0.9.2/tests/data/0000755000175000017500000000000011315711421015017 5ustar forestforestpytagsfs-0.9.2/tests/data/silence.mp30000644000175000017500000004135711315711421017074 0ustar forestforestDInfo(B  &&&,,33399@@@FFLLLSSYYY``fffllsssyy9LAME3.97 -$|NBZ$8DwJHLpaKl7L l穓 ph! ( hѣF @cDC&L2d AFwI%6%t"D((((0PPPV 6RȪϺ-/o'w՗/nU7S i- ˂P((((0PPPP((((0PPQD P[hХBT 6y۞#ck%ֿNyLzBEkƪ!EM,_]YȺp]jxљ_XdLGKr^%h#K#aa," 8 @jwI^,-bnjntЎn?&Ct5'gnx;`h<xM`,Jbg DAu2Nl[E^NyMaC>| ~ lU43uo{-ޗ.=r@=WVS屋#B -8 㛠u!h23nk9}35 Zlsc˒{ DB<#$~P, a$y))!e8cǖXY|2dBꑑjS<8or݋9\O/R<ш\[YbBg('ֱ4|sE\*4Fqnn`= d@ăpX&hL}9aAc bű B1.lToSfRRiۮ0KrF@෽. 0Ĵ<}{ZDBD/T)H9#ħlNdg/]y͛TϢ v- *SKI/C(]Ui@qSBspju{͘V۱m8KLh33ϲ \ԋB]ȌgXf>43g2,#"j!Y(kZ ˜t1.8 j*0B)8'KHL@ U:3 .3kfXwQRoߊSH{w㱜]$'74U*WʃR*>atd S)1lx9X]bNKR[qd)OEb] 4#ha'ce=\/LIo>̌v'mGQ3wPB"AY}ōl-U+qS( #8!@In˄e̢78٪4- ٣#ňD?$ğ|n}]C{{7 q.έRYf3 Zpd:(J~d caGQ# L%aqճ 9g8 5 q'֐ dwWi+Kgt+!N32#ފBl,1E}sA-Ru3hǬ [$H|ee(GBIeN|F%Ey3''y@@'LiV rΐ$ٱUt;ӬpȾd|3 joHl[uJ$CA%=d8]A'xt\ng90<-׺ MyGFXXE}}z2)u/pK/l?sX?H"y]VRF`Dz d #R`m# L}.af#eE]uQ, -/`?oimKs ΩH_k0lvnK` 5BA-}7ZvT `Quxzd_G>\)om"Jn3h N! 7v]lX?SnJ$etƔcC#P%P)da1Q43Yw3-љ"D^L\{ *#stkMD$Z'Cf2NaD u;w&TP;9~rn؋si$wFX?ls6-[pV8|7* 2'*Vc⊾d 5éd(l K[7bc = )!2lI{"+jv|3>y8Sx0i9 3?ҸoWнZ$FD);QedA5GCZP4=f]]a;JO,T.6S 7n=?:OD5:LȎ-~hgx]W0LȚMh[كW.v=ws-'ڧɬtd~<\#ʑy~Ds^/f[l`Apj Daz)ZrΛ;g4.z}uE*S[|DSB`TҘ𶇐3Qm;yNKImpA/Pu)bMYH53p1H:nihd 7]$m# L{.al e %3nD}:i0iW4bdUM0@Hمe1Dȭ[ӕ7_ wlw"G3RJax.tj֬ڧ A‘v-,mv?Ը4TmsT}MIOʧhҫdPZlmƒ,y8IqZDU+2j@>v;oXLc )8mhgS:12y>kxDU)hB7l w7I-P+%\ Mڿ@՝ƃbtCQa3{հ(g"NQ{>i,r_]h+ö|])K;u]%J3%F]d  DZ]9D#K.aI~╳ 1:U,ć_)æ:#Err&$$eA>PyKVN$2.5g;OW Z`xvwke+Q 82| 4ά%aٝ9,x11L=Rk[KPq[f<nD-'HOIrU,y1i)ia18TU:~!qT5^dlߜ + 'kzyn#;+zi=N)5]_7wcH$~$(e J ; 0:0%!&db5Ungpѧ{ q~`T:cs:X趒Mo[ hQz6Ǒgad 5˦R]el L-{.` |" 9ɴ2jyԟΖfq 7X˅]8~eZY3᩷5uWHdo127=ZC1sмڽRFRGԡZEY Lp.Tjط=w8fnC&}.~?z< ]s/);;BVx*Q cϖ }m\ JWt %>HQ܊uv:mVI59:ݝwf +y<:+O-? MυFDFnn]U>OI*KYǚC_ȩhy 4 __Om# HhE X 8X=# >}T87z5 .kd728Ru2oܗ,eR&ƇOi )-bxB_k31)뱁я?"E%&QV8WXc Ԟ6Ejl.B~O24;`@"JCF.lXVd&+QCl Ee1Rd 2:-{B A\"qa}ݡ~fQϙ**[YGKLL?TW@Q4* 0^8{&A;;EV,ԫgͯ /gw.e4"XSH:R!9~ VtwV$%Ė kBsKI ++BuI)z|?c1HdE>@SjUѥS5fwz/ B.?}5q53&a:nS4MgՎߩe}sC yjAmKbxm(Mj^A \8ЁݦvD>12\&&@N(:ml}Я v4擁+m]7rag?o`l]26d_FK`WblK#.`)Mf= MIPE;G3r(Xa hٯzY|)-k}5f@Io&я s aΙ[!Uv1buShLkN$+c[Za$mrb)pN~[ǹ׵wLR[_hwvw=cRM L^;Ij:_<٠L Щ#"rX%3'F4M+kѲeL8j[}yxE|lGM{6aHf3>dDJu FUtx_}RB;)zYB5CƲ44)Xt$#A6Ԭӎ>yD9qHbdkBcVl a.`^0߂ƖH ^ƻE?o~^lw.cZUu쾊ܑ0FQ"BQܫ{y~/Y$m1 cn"qfrwc6G_߫MxnI#0QG7W;kp%$G٘&MMs<掯iT.CKjTٝw_I^f;/~1o? Y W<M=`مW߽d؈b)i6;(ފmE7T'DuV+9 6O֔^04D6b qJ4~r$,XE*t7T~FOrե<3C5!cm(?X}d{. RSl Έ` qb nSo*,NƘx9g)3 Ι[6rZhd λ2ې ~B Z29MžBKJHzߛ绊|*HXBB Ela3ee.ŃxD1BxuK:K32~giJ0[&,&e,>~Lj3$Ǣ#jwxxwnA5 ))Lk,FeHV\Ȼ l2^6({\c.JX˂eʠ3PMr.wR;_O[} .UyI sb.faM!ә~_4 &*8\,-f=Tmv2$d1Ep]'ʯ˴.aT bճ 0@fDFH,Ak1%ǂTt($4&@0yq3o;ZW ~LG,_uT/[W흰]95Y?! nKɬA"10ފAQX92'N+`,eSx?`SNkԞע^U?i-g|~R:'yMljⱭϢ\ې +#1oZuJOK6|Lrjr`S8XaU[Ta[JM V.ޅq6>)6y|h2=/(TMuDN+#}̩%/Lzm d.F˩Y hcJc_ճ 0(DR]ni}4(C(H69v@RWDOr25+Y\"BpqM'm2lOqw>$¶^2-~$hpȶ:{gxݗGZOߟɰ-xGT OODEfNͤ 2uUH2C C1QՙN<7P21WX}[uyJTgd2FX*),d aUc9ûwnyۅ~IT Uhl5ҍJ)$.z[ЮGլez8: 8uMOUhf:1qs(8TФI$6a7 J`],кMi):?OzXnkһ,xyflG-'@S §&gdnT8DUwxۅ} $d"UyY%l c`[Ԍ(ӴAIYkL:NIQOf 9Un*lg(7FX͢g Z/L´*"0F =p+dsKK\k# :E0_:?ZXyyW| Q&2<{㛯7~>2bn~Dlܫ>ŒR(‘B8WbMHFJq/y#1Y^nfnF1)uIJR!tE#wlӍ+ҹăs4go[D"蹸No][GSm4TjRvT!1QcgQtUgw{I@ٜ]8OG:$,8^{d%yY(TCK`aVu-TReJ矗at&r~UFDITh OSwT^z qR<bmՄf@SQ>Kғdp𛪘5_p^9i'ΐ1Ϣtxu@ewvR3nA  ESN)`.ٺ!g2|EҚivb?t)2qi?汵fm;̞g/"}-mU!C"DR\#U1ascMLb MWȱ/"f7A3r2W"4$39G>mҘL"&[F&.HZLTC041lWlijܡ}gH,&ZA\B*iEqs؉R8rf hpe>GKcaA>u 02dRјHiU, Yuik"בQ-8mu pA\\ M4y+bP9!< _5O Zjqa•Dd_f?dͭN8UQS'f#d'c XlKgO1be K{&gGqר iR7eQR4ZXť͐ u"DCSZ4PNw ԭI.N U A2 䄄d}Frőj+OWw{<~nfPX UnmC)2UkZd2HGRhַ|M;m/QTxn(BT/}d3.G<Ji_m +95kkgsfC3Iz d?_ECrj8lK!.acQlߛ]=qci1*4ek7#HHy\E*ҵmBzBL@vb2d4sd*CVmL# iΘa"մ!#1b+A%ۂ``*PS"Hw#e^:Rը~lR]2=K|"IZ`>M`ޣJ ׯ\@ióԒqQ,:^UrSĢB&gMae{3^L^|rBȽ*[g3heܖ*jd)e0b*1b؃ ̥^yLRUa `E"dӊUBАýD+FHRG :o2]횞G uZتW,rY yҖ:rt6UicFIqnhP9u*4dH^>kN„1qH+>7k6힧ڟC|=~gNdB(ūbbfȥm# L).e&b iq l#8xJ9ƅT͇ U ZVE7&6Ќ>XcЮDE-Q'qVѳ?!Nas\I9*m @U*bCLFaiV3Cjs$f9R&7&&GWQmNSP'uWNo7{6gՖI}|%[lUX"2$H8dn:crA1mJ8y˅>DW,2[EE.t J7ve8W=L U )*F 9WBGAۄL6WtsC_\8)Yް_>Ts xq]r'weûjdB2˦RfGإlK.aɊ-#% ) UeyЂNPs#ŝ|r9~gn I8iXFAEdlDB =>έA2d b#?hMщFFJ)dL(U,]vT{'kC/bsyG%D]-/K}4N^Yeg XD`^&cYmW$&<EV/e-|<ނ?<qgwc}Ϫ.wJ b!bเ JrWYWʼnLdNP2 ;ő4==(3i*@gUu>[Wg0^Xd=V+c'm# . Ad%0p'ss~ Q/"}*Ö,SZqo4.\+`2PCl'4C-9{3_B(BJwU g"IK=5P&"D` !GBCENR5LAME3.97UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUd>= 5b  4UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUpytagsfs-0.9.2/tests/data/silence.flac0000644000175000017500000011402611315711421017274 0ustar forestforestfLaC" * BD.&vgJr^( reference libFLAC 1.1.4 20070213  N!%$L- 5KhH(lA@jm 00BnZy8  CB0D'IJ:N_C(`M2ΣD(L ,0& uBIR)$ѓ Ir9[<9f$T5s*a`h=gdĬ)ɒ1P\Q<%w&a&KTUIvE8[MTTɤb-=q\+Jz*ũ.U-KJ)fEȸJIuN)Q'*/&W8Zʒ渍1MtBkG)L5 ~K*I#IwU[ID eF*4e^BR4'B*-\+촭M-FEܔ셽,T:jt/'Q$AmˤUE:5EU!_Jg BrRy[-U]DwDJK.$tZ*KJjč*JIQT[JQT&Dmd*8Z z-l& PBL%8T2$ ء:鈠b@ȨB'1Լ#8P M)4JCQȒbhKpaZX4#w@ "!D(n̢0"!؞Ha2t$RPX@#@ u(Y M R(D2MT)vf.y.p Hh[-R'xKiW(*U%m ],Z.N+VȝZU_HW⿙%l#+eI]9Q`Қ&TZ˧k?'ع>/*Ħr.S/ /+/-TA]ѩh]R\'K\)NLHҩ'l'Q8Ԣ\[MW݉R9<5ȺVG)*ɲKJEZ^[N?T..Jh|#,/rkbV]&STrOR+M}E(*m'R\S-1WҹŪT]rDY(E]&⸝4V_Jd ˥ڵ'&D)]4ėUD-DNr$rn-#+kSV|*ҕܙEɕ*&IUK/e:JYlF^Ue&9jqT䟊8Q'!;dNVjM.UʮT%ɔruIpRUK.ZG|NQ2b,bvGĜ1%a:TТm&\G* P'y%)ʡLB_A&EL{`r Cu$IkH$!v D4NRHB6edchC2P*p! 0##P, FI镌& BTG,oh^/KǐR6*UK_ՖԣI]DJI8:OZ3/2W诚JdJ8wPj1-1zF&ЧpS-."qZR_%b$M^Hrt^F/EMNRTӒЧ$RɎz'RMAcyHȚ$>IyCE{Dy&p]8OB1[$X-dN ԣHiVUs%jtZ.ڙ2JJ)6kj$G\'\yQ^캊]qed.$eڑTD6:#䫒8W"NMd\0zTxɉ,hrU,жG*tȇWE)!dGCR")*LM _(܄zZD3&&%5*CR< ӓdTQAWt)"dy"ZJOg!zE]=V.IREˆ-vHzTpN:RVԶ/qg"Іy0PȥDET#J "5-VUYCVB2P1u8KMh%'.TuuV'|96'.AUbף%BnWWt2Ӳ]T]5N'Sy4Tq/8'ĮDd#;ԩ #-R9YE{DO&ajn qxG+i2\/N! E %V &XJ9 А\ 9עqnIM\(^4FK*i=DYKJ\UM \%LW֜<"JKK-NiD)̙#M*ʹu%8 E/m/'JІpO%jh[J2ԟ I]5N):$C4J->ZRBr^d򺯄r&ָVY'e_">TNI}2T⪐_I.NEQO'vJI6TbZrQTKu˜\SUQ_Kt,I|)|ZImjeM]im1#)Cd,n:JWI.99zKk%d&\$I7ruGN]CnUt\[,ĪwFNe'W^eh,'ڔ,䵤nE$j4d֗ $}Uewi-R!X8'',Y0e6Łć6+e>d]uˉ)QVV1rOGZEd铔/|(Y,Sbt"]y ȡAS#؂U>/% tD8G'ࣗ(į(ˊM\GP4YRʯZpr|*%"Jզ/)>x8NdUP2tڢBfW=VMk].b> Vo#0K.H=1)˒oB$ aTL"e$S%`$+FX!FdDbT@<4JidT% C22*x$ &PD%a $ ؓ d K"CB,² P<fI T9%3(B(m`zeg$ l#ak,C12lԉ$ %%Q)M!䰨10B B$=B,p-CąB!bL). @W>#˓F,0ФlP%I4 J:(&b$=90,!URU!ErLEv\L##dT)N\]9)/Q.-&|FF`VTIC!"ȍ(L;3N.ND*Ҳ˕)(:R_\5uyJ[[%za|ZJ2ЎRɤ"WG|brlt$}FeT򤖑:^:"i:V'蔇TKJ+ ;+ˆ"S))'\SԙI.lʔ= #y(YW&tM*i{B;bZW=%2gD$HjW˒ŪGdS(؅Nl]&Mr>EbTꔓ$=z,\<+WER*:Dy 9R/z$࿢-D^핧FIlA/!*O+ȺLI4J륫Ji8AABē[Jdw)7I>T'HD9"=2KYD$GnKܩg%qf+ѧDgE+&qq-%'Ѝ,nFz*mQS2|]HTrAJM,YT(JIZ%9B1]K&$:hrCO-;ԈhL%J)|de$xJMrf̊)N*K+9JTؕu8['aLU³._!I6zduZj(^'dܬtJw)đnjKJUG'֋w^K_]ʬ[I]J|.5":KU˒^!M/Q-/%qg5U.uq-V\;Es//uINUj'RWuEW剥FKy|HEUBesг&Im'RJ&j]$S$WDֽJڊ4,dN%@&SpBD;Od E ^2B*2voQ!hBRQ B22$agU2; BH0( L*!xY*$B 8>r0qdYeo<&T O0sdl aD%TBDTPvJL  0<& ¹;Y!)8YKahiBp JZ,%Xd@"pf-@>HKiHP83 $)rTq@HfH',dCzB:;`]3T$"A0*DC9BCĐIV%VY WK`ipHgi) RdĸDa dy}i9HBD`q#2B%!%"X Бc9H)dT0a rx!,ed5# $iURu-IitOD"ܜ &U/p%yuwQF.dq+Z'' ~JISKܩ):Iyr9b*uTR%Hu]*hDA-i:zTE584ݤ%+_NHHNKȼ:Q]ޢNUrS.|˕<%k2JxZʕ򔼹:^iKJ^JR]2+B|&-%NW]IYrm)]EQ9jINS{u)f4G'Dҡ)QR3Ii9ɯ4$ČҖإ22[R螈H$ˁSҋr:DFbLOz.=$։7Ԓ>BԒޒoRJqgp[t/-I [YQH}V1y(ҨNܒjXDEtbqs)S2hWҽS ,Һ꿄b7#a9CRYII$pG[DŘT^I&tI,IӖN#9NGB} /Dl.^9 HAI78bƉ>nMFJbR"Kt_#Bd^UJգ4Z#TS䚪GJrV^EQQ)y-;U]p.ĵЧDڪ$5du |\RvG]I;#%rrSGTqB51HlUܓ2JanNR_'TƑWwE"YKD.O~_RZčxH$RӉ?UM-"c4=I ѥd2D &-.dtJފrjDI/k2HDpbz8Y^&lMS'}n\Qq K 蜤Jhb'qSA8]>V!F2GBKCB~YmQ!l_s%Uk2[)u+((ɩө&8^>Q1wpzJ2NfJ!8ʓbd_4b8\ORDem$[x5IBZZE&B8:)r8VM̯uRSMw[HSl_r J&_^xx&eW:z/^ԼIq4K,BgPZ,_YLKc/reY6.O.8)G"EUi.Vފ8Ljz2M"'GJV\C+VyNKȜIMTD:WºrD~]2EiW (GuLp*)7թb,̤K"K̬ȧ%*OWI2Rdר䈍#eՑ>)H֒Kl/"I;]ת_"/L uM/*RҤŚH1WNFZ+\&k}k-#](\o-l%SHbBa$Jg$2"@ 9KaL!$B6JȅퟄB0!VEaa"QA& "n\@t%BsXPLJT$DɁJ74JBV0D7 P4 0 VHf)-8PHT DC)#)$CR[xA*YD/ęzk&c% w)O`VR[3RJrt1<0M3iIs.M!"/C"PiPCD-iH 0ɲE0BD̯, HGЮJAe ȘE4iBBE_mJea M8\C­^SZk唫Z]ȻRԭT#{BpJN%ғcUWJ/+rq5r4/Mu"\W..-2qܫ=bhN|"Ӵ'RY5+-a?JZ#Ke#tq9t ޑ/RL[h]LrIYi4G&ҕGYJU)ԋ[*㬮EiQ&b]et $!6TIbrF44MUܒiF.y蹥ڢw&OJvm'yMU-L[V_dvӲ%r&JtG4*K]r$jB5L JJ'ٻ# @@%-1@5$! C#JW55!ʒd,trpBBjHAB,Td,)\B*V %$nYedzMŐ2DQNFY/'i9!-& %> FYdHPBAFx0 BDs;&F8Gjvd¦q`rr yʒ2c.fM2!AA "1 n+2 V^_R@"c YK 5%$ҩIBX"LN_-KH\`vD!LaSl:HU2m%ʐpӹ#%&&P*DH5I*w!mS$*n},Th&n+Rr\z6(T\/#2h$lKM\UmjŽWIu\$xIUWcJ˓PӒ$&^remR)5"^RZIgV5oPnf*2NRqvZjN֕xDn $M+W`i.5W)G&f TbYhe'%!dZch- =$!ܔ d)Cq *$r!/,)UD|([&RVMNM(nUY{PL)yt#1PDup=q5x]"_i|%K_?xDB_uҪR252y^Tr17 W}*]F1DutR2L'+>BO]2Q Q[xQpH^UL%UMdQ="i/ NIt-sDePdh^.VK*b):.NV$IܙpW-Uȑu4IԪ1cl-u$!u4|FJcIIkyn7EOUA}D4I׹4:TelUȅwˆm 5s& _M]d XrȼԔ#.'lLKBAn ]'TT%r#&GB&Jjf Rz 0bDIůdr.S$d[Eh/OHN2+h<HLUl\בK#$4uVF4ؒzLz]KRwp[JIC@42s#mc$^#UyRMPT.Fs=IH(ܑIZ[*s :IBrU:yJXE$)&$bfDI"I(9 'ʹ-R&*8(. !VTt'RMsSJ)L|Y>Ҋnir&[n%މnHEp|\,\GR&"4\$L(G'zwn J|YFU!yUԻYVO[Sg-TnjJʖm Zn&zNɰH҆Q3[(9ZY.fQ im%9.-aO;Pi}  Wi2/['ɵIb}\#OWΰdhZ=-؞kZmM_gcIJ/;UQ $Yt2+$:,Xi/-ʾ$X$*[Y:6Mp;Lш@hh6H%8@aY>) XCZ!aD* `l9( ddf&T2%">KdĈ BlT- R^H$g HaJ!ɰ*zQY#/tK;/"ebu0c!^YjD)Zt!D(  CXɕ$&%b@Q0q$HK$G2&dBZt:(>WLLȑ'YT) I 3P`Qg*I0|!  $XB!(\b $@lFL> 2B IćD%$Nn!z A2ˆ,B %&YF҇m2^ dLN}M͕SDRPl$K'!IIRb@#j' H#' vHt-,R}L&@P$$ &%6ɨ(FABH% ٠BG@eB!4$C!19L @B!rD ˑ%&$$D5Jq)(H!8<! D XW"ɒ dXSYCV%&a(!љnėʙg )A 0IrÉy"’%:$Ε([<,B0Z!C" m["$ "@%Lfp7G+zWq:W% &F'?Ui4(hJ"^.4OS\DJ1y+'H2jRbUuݢ|'\\對NYn"M(qzUW2Y-늪TIƄP[*N)JEЃ\4FMe'rqJL'lZdRJ,^+HKfZz SˤՊRMRuqfS(G%rO%z4IRDap:TOJU|SS^]U8rʓrž$ʼH2WHwj5j]~N[Iw$|r HRIԉ1KwMQ®KE_N%sJ^hD tQrmh֋WˋI0Fd֋VDr"<%bơI/1TXU|KR"\R˒)u%$}AzjVKdd\EZJJR[ KD_䜫dE.N)&Rd]Dl)$z%尻j]Qw΄VVʅzrjK]VG,6TTjUҩWK5k1RM%;W%IiuQi2"^Ō%8˅Qʒ#_#UzqK nKԏkuDI9T*2xUMN.%SjuH(U+ዕUEQ\Q ҫ>yq?B<$4$Tx')j`Z&ՔI#'ȋ.-kX'+|+wP4_Dl諟 ]l$ q' F+"q:h\J$KbKUWR i7!Q+% SS/T8Q44ȌB4,iETi?"/)q|ul',Ym17eRJu dUD^q&eJ]4bJ 4 -L[%14"̤qEb(Fž4 $uQ&8h_eT帼L$GRKpnHpq|vm_rr9k",[&Q9\8_hbO떊'͈qym:\ ILwE.|RD1.iO RShIkpY^6d#*G*1#q%b餩"::jJ!>t.4Сl鈺#\*tIQ1 ϫG\LE*mtN(_ + JhC&)ɴZ+GR"IJ==F'CJ'%o")*>h/D+J,cEIcEQ⦿)8FjtG^e(ȤS^ lVrEt]n\$HQ'M<;2$+ӒM %JQ-GM.$$e".M- "x=6zwxV $ ĵ=4Rl%ʉKpi]J6XSWT\,mhNVT_KȺNm qldIͤZeAhByq$pTRhR-i9-,-DRFɪVފU˅K(:NBKjf+!-O#W^(0ETrq2m&i.irK%VVhS jE|HqQWV)#%)Mb%urJ8\^դ'ON0ZZϦe-!QIh*/'KDz2$K.8$`K*!D&0GHD="d *p@ ) a&N@#9ꊏ(BfTjF\JNt[ZryM;-FT4NҪFJ;T[E]#].-ث*LT*DI[ˊR!5"5lIKjKUUܧqe>Zw)hWJl$LȾUԛ2ZwQuG*WsMZvB15Də#)BE 8K%r A]2RYBT%htID& y2p@i%d$ԕ YixˆhhxH36`\G4 >TK0y$|D$ $x0*I-3Aa0/# OG*7DH`S0C D0Hh! RI؁)$ԣ69QMRY1 5Iy YHA0($ADu1N+J9i*zdޖ&J\+NqjddR-+,#EU'KHuE9tn&J\eDTq)}Qz.$9\+kSG$%RwzD1oDGSeI+\J5NTE5UyxWkORIRq%]\WHH*:Ri~^*J -r j!M9>1mK%.]A1rYSm,䱥D/.œQ#lW̓bz$dFZاEԪb=2BE6RB3pɤ(UTb'$Ѩ N$F)MsBlH'6#֢r"o.Ӭ*Y!ԓSo^vUlQ2aRx~a&D8$T#IO~$MʉVThs%@U:eRBE'WYEOI"u(WS4"zRxTT'MQRFbz2O-˂Qq|]*"fPXҊJb M%TIOOz>-gZɜ]E:mqSw"M" 8/piBM5EӘ\Txh$Id #)qTFNbNإEY)NMVGе"vJT@s '%*¶DLŝxJIo*/ZNE'JwīRLȉ#*mDuTBНd'R+THZraZ.|'JK2#WDD 'Iʺlp*\S&i'ڸM&*be—+[pTWZR';It2XPDұIE='.3"YԠhFWltFXmFRfILQ>b Cʪ */W>/Dz-;/]p_%Me5nY-SEN;LQ%p!YɢdMD%]|'PO$=K'R~TFzj*NPO/+SI r'ʙLS'BA”! &_%N%3B7dGaxebz!ku*"QH\R`NIDlhʕ "zRȁȡ5J؏*R4M;_/zemAt8D'ڴe :^O.tTNZH8RHM|NJE&e䊤!tI ё>v%NE_W(S.%!eR.\(RAr(eM"H$" 1 xZ9!l&3k ,H8vfG&! N ʁBA0'dh$CR'LЂHB x'Hp"'i5 JH(LaDHffOF’$Ł$3(!"i\hu-8U#tI5"m:DlnSD\15nN4K*nRe(즢z;bdMJ]F,ū%b*VE*q2)֨dTE%Fœօ\Ud# 2EԬJudp$bTk֤M#MV P5 ]Dd ӅגYN26+:hUC rt#Nק& *WOMQ9)41#8KWdXYR2tm {%(2+\UX,"D' j"$r\VޱH\X=+ZrhT'}/$UCoV'+*E1' d˓ʧ4SZnR1\t\^^btiByj8ORl[\IU.VމĢW!/'DNJP_YIFDzu^h^W*K>G.Hj")#!ȥZ13k+bJR)> Įv]JqLN@ea$twlJ[Bq$fZ2MQ?C,WtJ52GR1DN(x%'LbZ+|I/ 9kV).R W)QXEVbնA5kMq} ʩ%VNob#Wl*M5$TI؜)m{%OAA^0DrFB$ I4)W]B&c za'Q_IVyFM;"bmUFe>(S3ź%[\jTJkJI. #V%䵷-aQėwk$]1)M"2]*ܸ%Z83%<]-b'"&).xEմT\HGN$r*_4![JINRLW}\2,[}[EEb |h.DڕqM-J$-;JhCҮ"z6$^drA%D?.TG&ITNSp$D \FN8S8b*EhGDI#čKf\Uև"DN+irk%D؍HM1&O.LZ&кPȯLՉu HD3M"E\Dž8ȳl}V+rd(Y!'׊4&O)+J>1fY8Z"+,M/%%RAU}zKԆx2ĞNICUI;L5GuiXte_uY-iFb4@ϋdDd^A1k1:M.u2dYr%dIqOb&.UA/Ж-V/h8O-\6yXTl* Yr'E)Ң\]G1 j9^bLe)ҥR6#*'IGҩII#d8Dָ=֦N]D8$%5a[+dbn#%+MJ˸Q§.]DȥܔʛYpQC ̪2蕽 12}B̞DTTHhG'(LyK&NUɔ)(8Hp^9V\]3fI&RE6%* /4 d5edF_"K&X9D.+Цʅu&,ک#I1Hr). ZV]YDZ%Zq*_:TBt#.%#%U(ȵkD'5(9A.\v8i6.R,8*2\hзPH)غˆA%Gran%rDIqzC%$O58IZ_N&fGDrazlK4Pr&څIYnޢ#W2Rj1?L"5I[A'BTS%21$-ʨ2?#K(}Ĥq %z׊|Et>)Iqz yeӨY&z0-S'%C^K5%^g uj|*-q Tz|\R%ɋCJ1#Jhȴ4%ZT(b%}bGZ-.[LSF/V #0S/4!zS ·&'5į Z9-$Ǫ$lItBΉT!¼>WȇbEw2\w Qjl .KwAUZH1z~"i.-fI8˄i$¸UNJ_ {p4,IfY}ג.thMkZ##Z(YjjKZ HqtMdY:U4=kM/:^!/!hR.#D9ND9]EKi<5f%د+R!I%يe~Jw*DMi&IR('N  aEnFP'BEy!6'9:E Ka$@,x(6L  "JRJB "@@*I!%'h|Q./k4RI[qV+W4G"hG$K'Z$ SK%<)9eW*VJjI9WEMIy-"U*uIWY;VD)&ʓCZ\\\uܥVVMImQ +5.Vk+hM-Mj*ry*/D (E/:!i$*2˫Ut_JTSR}Ҝr`]Q>Q>U*R+Vd_DZFr%y)_RZR*rj4*_I%u['*$]I4N՗˞Z.J)H3&ŷ'#XjU$Q^y&M^I$0-Ԫw$|i!:e*GQT/J_)[V ITtiӒdtTWi  +Wt]-$\\kR*E^V/\-7LTb̊Kx^cDhʸ^N7%b.I.]KO%xKSUU 薮Hk/Ť,PWi\VGsq #%F^We2RҚ˓f$Kq,ДbŪ*rʗ$h#uUkSZ}+Gb5&M)y_Yw)y5&.u)JdLND$Z>j"vM")4qhGb/WȺ+iErR{hOVxR5iQ&i%&)MvLk[|0I5Rr'+GQq(e9}ԸYH/&W MZ6dH]EpI^AYFd1B Q ILȃC`FM1LؓtȏR-w.Q:EGEz%T#DvONYCZGЋVfʤl\=&.ф4VrDڒNTfA:ȃ!#z?$q['k$J'Tkbh/NuĞ/hU<)~NWrꋔ=b/)Iw)I)$P$I ܮ8TYg4.eDXY$Ng N1q6RU5r뤳I/Iz(8[DFbB'$d.EZO %*S(#Hr0,¸NNiBCe2LiꑅG3x#EU1LQM+KT#IԍZ'O[4IR6>^4VN]ӡQi# 2ZW'h "I\AeXjJRZ)CĺGYGfYZSI²[JlbS BPTazm1BBȩQ+-IxKUT.VRMsNXҴ!{M ]]IFк|!ʚiTDhஷ\,q+X8LEnkDn&~)dGtSrP-Ɓ.#eayDd1p •4U\*lHpq]\U,eirVtd\-_Uʋ=+bUɒ9#T^ե6F!>Nt&9^C2/DO򧤌y*\q)$)ܢfE0IʥF\!M$/$lD}'.#NQd|-\8##9zD_2yԪ\ҫu@AlBC**VH1~ȸU80')>F4KZ(rQ3DxJhEJeEI $yS!SkМO%-4!,d酯V.H%־r.%]E輖2T//\~^ .IOT Jej>$^S1ZUklNZ=%NO/+u%2H^u]Tע#.|^kzWeʌHijRK5UԫK\J|WJT}TR%.zBmJ'|'CD^&u&(M\[JUTJFp)}$ZץYʉn6ғIҾCbUIHb)Xk=&WYTQR:_*.I}SBzu2doI-OVLʱ*e&.d4O*4ԧVĤb앒dIZ4Čˬ+q/i,]'> sY~RRK4\kJ$+)ڎ&+d'UfrRF%vJWr\^Zr갎ӋkjIˊEk}UDiiUz/트jW'ԚMRC%j˨GI)UDw#Q4t/ԑ+VTVJl+){*$Q-Yut4*I%˗Jr:l[)/}-iuP..W8$4y.^:IQbRDTSiRi9/ L(J$fLS:Mw);)]JU4r.j/I-$Ө#NNO0+uI>P⿤UK\_.dOS ̳J\W4|]xuP4)Ke?Ih)#R;D+zrw&^F(J%I몮$%%Um 5kKN*KJBUujHGIV6Jt/Rҽ%O,Mz T&Ue+4-(1- _CK)Tus!Z"%U'VbJI*hLG4-OsŤjkVĕTFE=R]e4Q'WuyzL8.r,[&I9[VVhĵݢt(경rpu#%#䫺di$U^I󂵥Y6$Uu]_y])J\Y -%#xQO)mW+rDMf[N$Z9EJ%LZA[KtQC hӳo0^YNISG;ODY'Jc@Gŝ/vgFfDҢVi;-}dM$˭KV&b.EK f1D%*$}!;RE3Y]RYӴHYW_$&l̕nUđ TƊZrd'}BTTtDj!n^0W] ľ[y U2U*ud-rz [49H-nr+FĞ&#i$rhG[GHT:HɢuG(؄P0MP/J-/RSȆz y.1h.jf$BlՅTeK2Qgq)tU.FVLUEt#B9F-&<'YW4ф+iM%uEʹCBJ-Jk)*PhT1$WQwe—NQԹ"[Hԓ4dIζ!#"}죕/˭YY\a?EW/Bi( FHɪFQ4&:#D,kEvz%LSxJEo" 눖h.ye [EK%S'Vܲ|D: $W9T2a,vRir&X.;e*)m eHkŴd,"f):/(OVʚ=%l.ZfK.GK+<[%e%ӽ4c$iEةS@#0Qw N%A咞&cQ4ψԨN\p8"\Wdq#f&R1y_Ayq+ܹ[eO,C"5!fme $pVL*Yi.Z2!u* e]E)&-npytagsfs-0.9.2/tests/data/silence.wav0000644000175000017500000053047411315711421017175 0ustar forestforestRIFF4WAVEfmt Ddata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pytagsfs-0.9.2/tests/data/silence.ogg0000644000175000017500000003777111315711421017156 0ustar forestforestOggSi7¸,vorbisDOggSiycb-vorbisXiph.Org libVorbis I 20070622vorbis%BCV@$s*FsBPBkBL2L[%s!B[(АU@AxA!%=X'=!9xiA!B!B!E9h'A08 8E9X'A B9!$5HP9,(05(0ԃ BI5gAxiA!$AHAFAX9A*9 4d((  @Qqɑɱ  YHHH$Y%Y%Y扪,˲,˲,2 HPQ Eq Yd8Xh爎4CSR,1\wD3$ R1s9R9sBT1ƜsB!1sB!RJƜsB!RsB!J)sB!B)B!J(B!BB!RB(!R!B)%R !RBRJ)BRJ)J %R))J!RJJ)TJ J)%RJ!J)8A'Ua BCVdR)-E"KFsPZr RͩR $1T2B BuL)-BrKsA3stG DfDBpxP S@bB.TX\]\@.!!A,pox N)*u \adhlptx||$%@DD4s !"#$ OggS@6i2524+ &o{<.w@) 5@FM]jϯ&ESKuW>Z׼ݧU y}A^WW̤RPUUj2 2Rp1UzglrtI-,?}?;>z~ j3UI}w䩃zMxhf'"9vQ9=eu* Iݩ6 Y}5L%?v;l `N((IETn%gtrd dq[jub3_cFMGkeF SަΞ=xXf%ܩh#@1`l^|] |{ M_+?.[NgFMpUUUjnt/{:ZjtӀB:ejC݌~{};þs)Kzg:b&{枽ɩe*U3>ꮺ*qRξMrlm,?y}ru2s8>fF~5WݭD2Ta#pK:멼-b\Nbx Ժp`vy'JH~(>R`$AȲ ^|zE/*@qQE'33U AF `0eoJyϏzRp+E ]Kzvwy޽ׁ}~9SSaDF0ToǽtVIkS̉wrFw3xIK9EMTśjzawL{C Ȗ$KcI\J.ruo몏㋧nw'`-Jxsp%~W9 PFOthNYQM`+^׼?R%[ Pt( C UU~{yunRoil [67e;B⭟}~>Vflx6̇ܕ9ԩ=t73t9UhfZ4vS?{4/?Cb`n=;q<ԩfcoy$K^vHT8 #ҶO^DGl~L}ӲutFPt.>p0t02l^|z'@y ?v(LVUEBtBTw[]kT{?<gfp)UH39o{R>ɪ̦P_ʓm$/Iů$HB/xabl$sjgЙYPUU P|[?N>qi ` Ŷ1֣珌"W8hCuN<칏8S$x@_sQr'NUy*N3}2n4͕*{L'M>] ")emEQ㹛y1GvEB2r=Xt u/˶w7e]ӧ+Sr1'V>r'#ON<>zqQ+/ :>ZÁ5!3ƨ 0^|>  O_3̌PUUHPwX~4+M7 "BzrE%n6~^%>Gng<;)_Wt[]?C)"L żlkHG?3(y؛IX]&Üi0/Q}7Κ''d8K 6wj;qOu@`b ,|ޏo~.e{jOtvfL08$(>|\z  ?N#dFpfUUUj4QhK;t- ]r/99~qEsV?"(o:^s>ѺUY6E oA: 7Uܻ=r3Iwfw|貒?5s\ o8u4ds&4+n3d7},}9"x*9m$: wMWB[2W]օӴ.Ơ%x\p+ 'W+4;;r4 (^|o{>s |`(3TUUUjn^H)ld&S)^=yOcN1e^ڷq{{6|{t^Wf} 6&{E 2uMo EEOCg+AO9pH,胻v&?əm:]݃Ly?ntҤF$sQk7Ԩ!HƂL0kP ^|zHO{ޯs7'3ʤ#2TUUH40H¾<偣Uy'Oϧh2+gX5L-q]NLg֚[Ű3E닓3wgyZ KX>3k&>nnaT59l^ Ji} CvrI[\._HRK2ȋń9W'n42ڱvgMT;~;D, Z~>_=j:R*!-C3ہ&@^| ym"_;L:P5~[szt.'(kKjAͭF:#OPkH>u~3'ɩJMhoO̮_+3\h&uNNuӹqzirڕjR߈,fɻSyz ;|#)a$;WU$z>p͵_~\ sm H$Ǻt$oP,@l-x@`>|l1R PNfTjXE je8kx{ݸMn yZ)C0,Z>eY_Zzf߹}:Ż o~9OsY$]/ަfO%硫Uxc=O̚!hNNN~?NN%*jz3;:5byީ1D[[cݶrܗ {Ar1m+cR7WpROggS@riKN &( !Ifyd ^׼=yuOQv*MJ0E(DS\bw~Џ/wJxZ,l?ɇ?^ȼ)cn~x.^I0 2??9!4wn[w5_rcuN?`0CWR?|cTNuC 'bDM-2m;\}kiHHz@ȸU+n] J r'7~yu8oc XJFuӿ$+ hNM@Q^׼抧'@~_*hd ;=UUU?ػ޸L44qBjgE&3g_:]߇W\vEPҘ6ȓ*TVHqcMʺg͗Ԝ?<:dv|=la搂zkRD:h؉ezNҪW{w[ݯ]qo{芣PoǮ;<ĂaM|nP%& G^|{6Vo'LΈPUUEt AН^TW_}{+;, _ϩErSR?>߄ZgG:&r~MsGb`L;(N~b:mg:dj?c*9IgpAͥrؙeWvD*S}O;2h G}bDY2߹N[c/]lcκhuv=(f;k=A^|ܦH X #IԌ塪DP|6-Ybj{j$pPbϷ|+z:Xo~|vσX;dYC)NR}iwhV3ps%|" q}Ƽgr`lk(j5;_d05UOn'h#ɂXf40@/Z@iɃull[[ vs%>vW Zh\>CP93-ptj8^|<o{>sE'ؙtDgWBPM-"<L׻#?oU˯?ߖTnii/_.ϹR#kӧXNƿ ~ŏ 43WCPs/]ّ$\Uu2ۇlȪ9LV2[kz>Ω*d~ԩ?tUW^WwӑX_}bƫ/CrQ1F7=,BA\ 8^d'<2vp?H'd$5TUUUP#tӀBETh<_gsx.hK]}>ۿ|>/9+s6^qMOVe>]nibe[IWVȷ7nz|8g/g7?'RTNU]~e;&3cl(={t L oԬ?B>*M*76zBh/-?#Q$~|џL}4-|#ɛOfWuФΫj69W՝ 4V4,c6 s<>u{rNm52NyKVT ?+b>M!`AP8d0^|=9 pOŦVPtg(U덤|pJ{k޲v{lXk@l_u:GMY챌&sz,bi(14L5sA2d59j%.&g=ӷMurkT>_/0ua[kO`m~hnNYBTs-rq$85ͤq!6 pAYx@vq ^|]{H?i0>VH_xxAsw3"9檪HǭF~n*0^^z/O7 H>zi̧?םfãMT0$Y$5ltt29 ^}wǓ륇I9`3PkrgQ")x_U[ [ ,[ _]-3iյ$^Mոw0A-&Fe^|{xx#K ݣ%5 C*d{';M |?|\$|;~X~cx|۸q4תLItv;_M垓j+s!qlvrH7WDMu2-5:g~UgUq0vs4XBd {tVmm/,3=2A\ lV_+kw2d (@" ^| y},;` pzDgFI*Tnj!KZo˘:xp{>87O7kIA2EKuo]nھy2d *+Ut1sON9'ww azW ޠ=*)ڤ(,۟Or" %Ha0% \Fޓt~[ߎBo(0mt]WrLvݪؚ٘Vs YdBkz#F^|^B 6W4H${ٳ jjZAHGѢ,n&kS^/ioSAVXMigy[ryv߳ITszw d5 8TuG6s1'w2:{WF3L&Bj{+3ǜvډ/c Fvq===:jh"L=22`~UlzI9u=*ZH\ sX84Ų - p4`[^|{|>zp#a':I P#zc t "N>;Yc-zĹ۷O8=|LkYw~ 9!,V]$93&U^D{n3vi -.9y. aTw_0.-ۋұ:{H5| TD :xu0΁HS-WEDJZu r WaW}`4>|d{>ocaI_҂3iZ@ `^s Ivr5-w=8;O?<~N}^gM=~^gݞ&a!LwnDzptjv 3 m 8?SýeC>3~_Lqb۽_26zM뫓-u0w,>cZݲ>9'S7Nü4?dOggSDiX \?cvؠ4i^׼_玦7 {>sE'eR*$TB8: E]㫏>>14nO]8ܛo<3q=Uɻbsr7f4Lg6r'6 Sum mRw<];/4l&@Uk|fPo7};qt*ْ@deJm0$=|hǿbzDzjimX0 ܆ݚC49B|Ka&ý }adЀ^|T!`cft6NW߯ך `GVK+߿16_Wװ9?]^KNm}u\'w[[ct6vp.n&}4ϜZ^qT3[mn@yQS0d计s3!0͔ȵIK{X]Bh5^7OL a x9l~ gk]Ϙj06 ^|\ y}ވ'(3tS EJZU\m~~m=[wn>w/n8:?o3u]i\lL>6I{ y~35TURPfn!AOӯG~qn}es9meW?Ӧճϡ jݗTkQ}>u1)Q NLUDM%T%Om?'C9C_ݳBfeԟWT% xXuj&FqTCŵ: gUgLO"l (BaC ~|ݦX{p)I媪P~35^Z^H'đvY{AgCwWYȥdrmޣZU_eta1[=sNrXTɁfĽ6J}CfԦO5DDUz`hH_М| ;_HcP~q3=p?*}<^'$>鉈+5#qZ0HGWqX#;вԀ2&8@ ^|@x@y+/8tfFjVd#7yo Upb=&/-WymdVi%uq^~^5̜Nvq04v$M{̀NOE<'b ]>T>yTSȮ> 0u5,T3Wף{]u3)W\8]ca%CYYYУ]mƺ??A{gjD6r 5f+&a^|\ 1|~4M'U%TU5L7t"a]|}gA\vxײz{/͝m_{k׬_Kw9q~NIQzO7]vu#[dzI/e^El:Eݽdd]U֔ԃbI" ~_Lz#o4zV z, ;G[ݹmF pzEơՅ8}-p4&>׼7 i;' 9BgE*XPVz<0d9HVUަzl\ϯQ5䗯)%x3+|00Lu^I.ns8>j]t-6/s!|Ťr3Dy5LLudwÿ9C2eoK^/#S~Һhd![vUG;5{RrM2=יw$6: Q(cY>׼_<6@ZEITQ6O/x5S9ݯVl-oYZ+vX_ svIUye7te?_~~Wes|5y>ܫwߤϜyNbj$}D-Oy3O]'_G7pf?m @Ke_RM}_{k-%Xݞ0h?[>Z7s=ddXcL !%!d)揍6^|\{E/Ǽ6~t$Ƅ jMm٨۷l. ?Z}6/k\\g>η=*kv=Ihh6LRL%znH 'P7m~}fjs<'0( C[k^j+:_6= 6/R0N_yIzuVA$!_>gO}{̇Fϗj;@0ŤEdv []lh^|^ {cY ӓrUU!Pvc/[ -#px$EoGo=u΍uq/㻼a.v3s~s*~콛CT#u6=E L1Lcֆ Mah#- N<>FYݔ,yۗdlYpK'Ukټ$}txwW#BOzߔ{7M^{wXj 8B^׼_X@x# P<>pz&MGrUUE262 Guc;(7۹R-5=uoka_?ynIyp8UE1ק1Ʉd[{Gۇ@<Iu/`e9Ɇg7RK#,\u ⲃv29]/^7k_~ԙuBY0FB(PfN)pA'vb͵# ^׼ݦ**}Q!'ISHf!HLFD^z^%xص}J?SͿxZ箿/uo5N~kS'd9qCYۆaW;7p济H¿_Nj}U᥺j*7 5yOӂI(3UUEJ# &BF԰6}>.?|s0>#۵gߺy晬YeUWrv')y9uRvGuםXVee%}='}veMjg,UBVVOS{?os?ҚeMmXk dEX\/2RB^yԖK"bar)').get_named_group_names()), ['foo'], ) def test_get_number_of_groups(self): self.assertEqual( Context(r'()(?Pbar(baz))\(x\)').get_number_of_groups(), 3, ) manager.add_test_case_class(ContextTestCase) class SimpleExpressionTestCase(TestCase): def test_in_regex(self): regex = Regex() regex.append(SimpleExpression('foo')) self.assertEqual(regex.get_string(), 'foo') manager.add_test_case_class(SimpleExpressionTestCase) class GroupTestCase(TestCase): def test_in_regex(self): regex = Regex() regex.append(Group([SimpleExpression('foo')])) self.assertEqual(regex.get_string(), '(foo)') manager.add_test_case_class(GroupTestCase) class NamedGroupTestCase(TestCase): def test_in_regex(self): regex = Regex() regex.append(NamedGroup('foo', [SimpleExpression('bar')])) self.assertEqual(regex.get_string(), '(?Pbar)') regex.append(NamedGroup('bink', [SimpleExpression('bonk')])) self.assertEqual(regex.get_string(), '(?Pbar)(?Pbonk)') regex.append(NamedGroup('foo')) self.assertEqual( regex.get_string(), '(?Pbar)(?Pbonk)(?P=foo)') manager.add_test_case_class(NamedGroupTestCase) pytagsfs-0.9.2/tests/pytagsfs_meta_store.py0000644000175000017500000000515511315711421020550 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, shutil from unittest import TestCase from pytagsfs.fs import PyTagsFileSystem, PyTagsFileSystemOptionParser from pytagsfs.metastore import UnsettableKeyError from pytagsfs.metastore.mutagen_ import SimpleMutagenFile from manager import manager from common import DATA_DIR, TestWithDir class PyTagsFileSystemMetaStoreTestCase(TestWithDir): test_dir_prefix = 'mts' filename = 'silence.ogg' test_data_path = None def setUp(self): super(PyTagsFileSystemMetaStoreTestCase, self).setUp() self.test_data_path = os.path.join(self.test_dir, self.filename) shutil.copyfile( os.path.join(DATA_DIR, self.filename), self.test_data_path, ) def tearDown(self): os.unlink(self.test_data_path) super(PyTagsFileSystemMetaStoreTestCase, self).tearDown() def get_meta_store(self): return PyTagsFileSystem.get_meta_store( PyTagsFileSystemOptionParser.DEFAULT_MOUNT_OPTIONS[ 'metastores']['default'] ) def test_parse_tags(self): f = SimpleMutagenFile(self.test_data_path) f['artist'] = 'foo' f['title'] = 'bar' f.save() p = self.get_meta_store() d = p.get(self.test_data_path) self.assertEqual(d['artist'], ['foo']) self.assertEqual(d['title'], ['bar']) def test_apply_tags(self): p = self.get_meta_store() p.set(self.test_data_path, {'artist': 'foo', 'title': 'bar'}) f = SimpleMutagenFile(self.test_data_path) self.assertEqual(f['artist'], ['foo']) self.assertEqual(f['title'], ['bar']) def test_apply_does_not_apply_path_name_based_tags(self): path_name_based_tags = ( 'extension', 'e', 'filename', 'f', 'parent', 'p') p = self.get_meta_store() d = p.get(self.test_data_path) for t in path_name_based_tags: assert t in d self.assertRaises(UnsettableKeyError, p.set, self.test_data_path, d) def test_apply_does_apply_arbitrary_non_path_name_based_tags(self): p = self.get_meta_store() p.set(self.test_data_path, {'bizz': 'buzz'}) f = SimpleMutagenFile(self.test_data_path) self.assertEqual(f['bizz'], ['buzz']) manager.add_test_case_class(PyTagsFileSystemMetaStoreTestCase) pytagsfs-0.9.2/tests/__init__.py0000644000175000017500000000065311315711421016223 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. def main(**kwargs): from tests.manager import manager manager.main(**kwargs) pytagsfs-0.9.2/tests/common.py0000644000175000017500000001551611315711421015760 0ustar forestforest# coding: utf-8 # Copyright (c) 2005-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. # A lot of this code was ripped out of sclapp's test/common.py import doctest, os, platform, errno, glob, time from unittest import ( TestSuite, defaultTestLoader, TextTestRunner, TestCase as _TestCase, ) # These are used to determine which SourceTreeMonitor implementations should be # tested on the current platform: NO_INOTIFY_PLATFORMS = ('Darwin', 'FreeBSD', 'NetBSD', 'OpenBSD') NO_GAMIN_PLATFORMS = ('Darwin',) NO_KQUEUE_PLATFORMS = ('Linux',) PLATFORM = platform.system() TEST_DIR = os.path.abspath(os.path.dirname(__file__)) DATA_DIR = os.path.abspath(os.path.join(TEST_DIR, 'data')) TEST_DATA_DIR = os.path.abspath(os.path.join(TEST_DIR, 'test-data')) class _UnicodePathsMixin(object): replacements = { 'foo': u'ζοο', 'bar': u'βαρ', 'baz': u'βαω', 'qux': u'ςυχ', 'klink': u'κλινκ', 'klank': u'κλανκ', 'klonk': u'κλονκ', 'klunk': u'κλυνκ', 'bink': u'βινκ', 'bonk': u'βονκ', } def p(self, s): s = super(_UnicodePathsMixin, self).p(s) for k, v in self.replacements.items(): s = s.replace(k, v) return s def mixin_unicode(cls): newcls = type('%sUnicode' % cls.__name__, (_UnicodePathsMixin, cls), {}) newcls.__module__ = cls.__module__ return newcls def sleep_until(predicate, timeout = 10): count = 0 while not predicate(): time.sleep(1) count = count + 1 if count > timeout: raise AssertionError('timeout reached') class TestCase(_TestCase): def assertIn(self, candidate, collection): if not candidate in collection: raise AssertionError('%s not in %s' % ( repr(candidate), repr(collection))) class TestThatUsesRealFiles(TestCase): def _create_file(self, filename, content = ''): self._set_file_content(filename, content) def _set_file_content(self, filename, content): if isinstance(content, unicode): content = content.encode('utf-8') f = open(filename, 'w') try: f.write(content) finally: f.close() def _get_file_content(self, filename): f = open(filename, 'r') try: return f.read().decode('utf-8') finally: f.close() def _create_files(self, filenames, contents = None): if contents is None: contents = ['' for filename in filenames] for filename, content in zip(filenames, contents): self._create_file(filename, content) def _remove_file(self, filename): os.unlink(filename) def _remove_files(self, filenames): for filename in filenames: self._remove_file(filename) def _create_dir(self, dirname): os.mkdir(dirname) def _create_dirs(self, dirnames): for dirname in dirnames: self._create_dir(dirname) def _create_dir_if_not_exists(self, dirname): try: os.mkdir(dirname) except OSError, e: if e.errno != errno.EEXIST: raise def _remove_dir(self, dirname): os.rmdir(dirname) def _remove_dirs(self, dirnames): for dirname in dirnames: self._remove_dir(dirname) def _remove_dir_if_empty(self, dirname): try: os.rmdir(dirname) except OSError, e: if e.errno != errno.ENOTEMPTY: raise def assertFileExists(self, filename, mode = 'r'): try: f = open(filename, mode) except (OSError, IOError), e: raise AssertionError(str(e)) else: f.close() def assertFileDoesNotExist(self, filename, mode = 'r'): def test_fn(): f = open(filename, mode) f.close() self.assertRaises(IOError, test_fn) def assertFileContent(self, filename, expected, mode = 'r'): f = open(filename, mode) try: actual = f.read().decode('utf-8', 'replace') finally: f.close() assert (actual == expected), ( u'Expected: %s\nGot: %s' % (repr(expected), repr(actual)) ) def assertFileContains(self, filename, s, mode = 'r'): f = open(filename, mode) try: content = f.read().decode('utf-8', 'replace') finally: f.close() assert (s in content), ( u'Expected to find %r in file %r.' % (s, filename) ) def assertFileDoesNotContain(self, filename, s, mode = 'r'): f = open(filename, mode) try: content = f.read().decode('utf-8', 'replace') finally: f.close() assert (s not in content), ( u'Expected not to find %r in file %r.' % (s, filename) ) def _assertFilePredicate(self, filename1, filename2, predicate, mode = 'r'): f1 = open(filename1, mode) try: f2 = open(filename2, mode) try: assert predicate(f1, f2) finally: f2.close() finally: f1.close() def assertFilesAreSame(self, filename1, filename2): self._assertFilePredicate( filename1, filename2, (lambda f1, f2: f1.read() == f2.read())) def assertFilesAreDifferent(self, filename1, filename2): self._assertFilePredicate( filename1, filename2, (lambda f1, f2: f1.read() != f2.read())) def assertDirectoryExists(self, dirname): try: os.listdir(dirname) except (IOError, OSError), e: raise AssertionError(unicode(e)) def assertDirectoryDoesNotExist(self, dirname): def test_fn(): os.listdir(dirname) self.assertRaises((IOError, OSError), test_fn) class TestWithDir(TestThatUsesRealFiles): test_dir = None test_dir_prefix = None def setUp(self): self._create_dir_if_not_exists(TEST_DATA_DIR) self.test_dir = self._get_next_test_dir() os.mkdir(self.test_dir) def tearDown(self): self._remove_dir(self.test_dir) self._remove_dir_if_empty(TEST_DATA_DIR) def _get_next_test_dir(self): num = 1 existing_test_dirs = glob.glob(os.path.join( TEST_DATA_DIR, '%s-[0-9][0-9][0-9]' % self.test_dir_prefix, )) existing_test_dirs.sort() if existing_test_dirs != []: num = int(existing_test_dirs[-1][-3:]) + 1 return unicode(os.path.join( TEST_DATA_DIR, '%s-%03u' % (self.test_dir_prefix, num), )) pytagsfs-0.9.2/tests/manager.py0000644000175000017500000001437711315711421016106 0ustar forestforest# Copyright (c) 2008-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, sys, glob, inspect from doctest import DocTestCase, DocTestFinder, DocTestParser from unittest import TestSuite, TextTestRunner, TestLoader class ListTestLoader(TestLoader): suiteClass = list class TestManager(object): tests = None loader = None def __init__(self): self.tests = [] self.loader = ListTestLoader() def get_test_modules(self): for name in glob.glob(os.path.join(os.path.dirname(__file__), '*.py')): if name == '__init__': continue module = os.path.basename(name)[:-3] yield module def load(self): for module in self.get_test_modules(): __import__('tests', {}, {}, [module]) def find_modules(self, package): modules = [package] for name in dir(package): value = getattr(package, name) if (inspect.ismodule(value)) and ( value.__name__.rpartition('.')[0] == package.__name__): modules.extend(self.find_modules(value)) return modules def main(self, test_names = None, print_only = False, coverage = False): result = self.run( test_names = test_names, print_only = print_only, coverage = coverage, ) if (not print_only) and (not result.wasSuccessful()): sys.exit(1) sys.exit(0) def run(self, test_names = None, print_only = False, coverage = False): if 'pytagsfs' in sys.modules: raise AssertionError( 'pytagsfs already imported; ' 'this interferes with coverage analysis' ) if coverage: import coverage as _coverage if int(_coverage.__version__.split('.')[0]) < 3: print >>sys.stderr, ( 'warning: coverage versions < 3 ' 'are known to produce imperfect results' ) _coverage.use_cache(False) _coverage.start() try: self.load() suite = TestSuite() runner = TextTestRunner(verbosity = 2) for test in self.tests: if self.should_run_test(test, test_names): if print_only: print test.id() else: suite.addTest(test) if not print_only: return runner.run(suite) finally: if coverage: _coverage.stop() import pytagsfs _coverage.report(self.find_modules(pytagsfs)) def should_run_test(self, test, test_names): if test_names is None: return True for test_name in test_names: test_name_parts = test_name.split('.') relevant_id_parts = test.id().split('.')[:len(test_name_parts)] if test_name_parts == relevant_id_parts: return True return False def add_test_suite(self, test_suite): self.tests.extend(self.flatten_test_suite(test_suite)) def flatten_test_suite(self, test_suite): tests = [] if isinstance(test_suite, TestSuite): for test in list(test_suite): tests.extend(self.flatten_test_suite(test)) else: tests.append(test_suite) return tests def add_test_case_class(self, test_case_class): self.tests.extend( self.loader.loadTestsFromTestCase(test_case_class)) def make_doc_test_case(self, test): def __init__(self, *args, **kwargs): DocTestCase.__init__(self, test) return type( '%s_TestCase' % test.name.split('.')[-1], (DocTestCase,), {'__init__': __init__}, ) def get_doc_test_cases_from_string( self, string, name = '', filename = '', globs = None, ): if globs is None: globs = {} # Make sure __name__ == '__main__' checks fail: globs = dict(globs) globs['__name__'] = None parser = DocTestParser() test = parser.get_doctest( string, globs = globs, name = name, filename = filename, lineno = 0, ) test_case = self.make_doc_test_case(test) return [test_case] def add_doc_test_cases_from_string(self, *args, **kwargs): for test_case in self.get_doc_test_cases_from_string(*args, **kwargs): self.add_test_case_class(test_case) def import_dotted_name(self, name): mod = __import__(name) components = name.split('.') for component in components[1:]: try: mod = getattr(mod, component) except AttributeError: raise ImportError('%r has no attribute %s' % (mod, component)) return mod def get_doc_test_cases_from_module(self, name): mod = self.import_dotted_name(name) finder = DocTestFinder() tests = finder.find(mod) doc_test_cases = [] for test in tests: doc_test_cases.append(self.make_doc_test_case(test)) return doc_test_cases def add_doc_test_cases_from_module(self, dst_name, src_name = None): if src_name is None: src_name = dst_name for test_case in self.get_doc_test_cases_from_module(src_name): test_case.__module__ = dst_name self.add_test_case_class(test_case) def get_doc_test_cases_from_text_file(self, filename, *args, **kwargs): f = open(filename, 'r') try: data = f.read() finally: f.close() return self.get_doc_test_cases_from_string(data, *args, **kwargs) def add_doc_test_cases_from_text_file(self, *args, **kwargs): for test_case in self.get_doc_test_cases_from_text_file( *args, **kwargs ): self.add_test_case_class(test_case) manager = TestManager() pytagsfs-0.9.2/tests/values.py0000644000175000017500000000307411315711421015763 0ustar forestforest# Copyright (c) 2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from unittest import TestCase from pytagsfs.values import Values from manager import manager class TestValues(TestCase): def test_diff2_with_value_removal(self): old = Values({'a': [u'foo'], 'b': [u'baz']}) new = Values({'b': [u'baz']}) self.assertEqual(Values.diff2(old, new), Values({'a': []})) def test_diff3_with_partial_value_removal(self): base = Values({'a': [u'foo', u'bar'], 'b': [u'baz'], 'd': [u'qux']}) old = Values({'a': [u'foo'], 'b': [u'baz']}) new = Values({'b': [u'baz']}) self.assertEqual(Values.diff3(base, old, new), Values({'a': [u'bar']})) def test_diff2_with_value_change(self): old = Values({'a': [u'foo'], 'b': [u'baz']}) new = Values({'a': [u'boink'], 'b': [u'baz']}) self.assertEqual(Values.diff2(old, new), Values({'a': [u'boink']})) def test_diff3_with_partial_value_change(self): base = Values({'a': [u'foo', u'bar'], 'b': [u'baz'], 'd': [u'qux']}) old = Values({'a': [u'foo'], 'b': [u'baz']}) new = Values({'a': [u'boink'], 'b': [u'baz']}) self.assertEqual( Values.diff3(base, old, new), Values({'a': [u'bar', u'boink']}), ) manager.add_test_case_class(TestValues) pytagsfs-0.9.2/tests/blackbox.py0000644000175000017500000014105511315711421016253 0ustar forestforest# coding: utf-8 # Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from sclapp import locale import sys, os, time, traceback, stat, shutil, errno, random, glob, string from subprocess import ( Popen, PIPE, STDOUT, ) from threading import Thread from sclapp.shell import ( Shell, CommandFailed, shinterp, ) from sclapp.processes import BackgroundCommand from pytagsfs.fs import UMOUNT_COMMAND from pytagsfs.metastore.mutagen_ import MutagenFileMetaStore from pytagsfs.util import unsafe_truncate from pytagsfs.fuselib import Fuse from common import ( PLATFORM, DATA_DIR, TestWithDir, mixin_unicode, sleep_until, ) from manager import manager PACKAGE_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) MODULES_ROOT = os.path.join(PACKAGE_ROOT, 'modules') PYTHON_EXECUTABLE = sys.executable PYTAGSFS_EXECUTABLE = os.path.join(PACKAGE_ROOT, 'pytagsfs') UMOUNT_RETRY_COUNT = 5 UMOUNT_RETRY_DELAY = 5 user_encoding = locale.getpreferredencoding() def get_returncode_output(args): popen = Popen(args, stdout = PIPE, stderr = STDOUT) output = popen.stdout.read() returncode = popen.wait() return returncode, output class ErrorOnError(Exception): def __init__(self, original_traceback, new_traceback): self.original_traceback = original_traceback self.new_traceback = new_traceback Exception.__init__(self, original_traceback, new_traceback) def __str__(self): return '\n'.join([ '*** Caught an exception while cleaning up after an exception. ***', '', '=== Traceback for original exception ===', self.original_traceback, '', '=== Traceback for new exception ===', self.new_traceback, ]) mount_parameters = None class FileNotTaggableError(Exception): pass def add_blackbox_test_class(cls): manager.add_test_case_class(cls) manager.add_test_case_class(mixin_singlethreaded(cls)) class AudioFormatMixin(object): def assertFilesHaveSameAudioContent(self, filename1, filename2): if self.get_audio_data(filename1) != self.get_audio_data(filename2): raise AssertionError def get_audio_data(self, filename): f = open(filename, 'rb') try: data = f.read() finally: f.close() return self.decode_audio_data(data) def decode_audio_data(self, data): popen = Popen( self.decode_args, stdin = PIPE, stdout = PIPE, stderr = PIPE, ) stdoutdata, stderrdata = popen.communicate(data) if popen.returncode != 0: raise AssertionError( 'subprocess failed (%u, %r)' % (popen.returncode, stderrdata) ) if stderrdata: sys.stderr.write(stderrdata) return stdoutdata def p(self, s): s = super(AudioFormatMixin, self).p(s) return s.replace(u'ext', self.ext) class OggMixin(AudioFormatMixin): ext = 'ogg' decode_args = [ 'ogg123', '--quiet', '--device', 'raw', '--file', '-', '-', ] class FlacMixin(AudioFormatMixin): ext = 'flac' decode_args = [ 'flac', '--silent', '--decode', '--stdout', '-', ] class Mp3Mixin(AudioFormatMixin): ext = 'mp3' decode_args = [ 'madplay', '--quiet', '--output', 'raw:-', '-', ] class SingleThreadedMixin(object): def get_extra_options(self): return ['-s'] def mixin_singlethreaded(cls): newcls = type( 'SingleThreaded%s' % cls.__name__, (SingleThreadedMixin, cls), {}, ) newcls.__module__ = cls.__module__ return newcls class _BaseBlackboxTestCase(TestWithDir): test_dir_prefix = 'blk' sh = None umount_cmd = None # Indicates that the TestCase requires that the system has non-broken mmap # semantics: requires_nonbroken_mmap = False test_method_name = None filesystem_process = None def __init__(self, methodName = 'runTest'): # The unittest module in Python 2.4 saves methodName as # __testMethodName, but in Python 2.5, it is _testMethodName. We skirt # this incompatible change by saving it under our own name, # test_method_name. self.test_method_name = methodName super(_BaseBlackboxTestCase, self).__init__(methodName = methodName) def setUp(self): super(_BaseBlackboxTestCase, self).setUp() shell = '/bin/sh' returncode, output = get_returncode_output([shell, '--version']) if (returncode == 0) and ('bash' in output): shell = '%s --posix --noediting' % shell python_path_parts = [MODULES_ROOT] if 'PYTHONPATH' in os.environ: python_path_parts.append(os.environ['PYTHONPATH']) os.environ['PYTHONPATH'] = ':'.join(python_path_parts) # sh inherits os.environ self.sh = Shell(shell = shell, delaybeforesend = 0) returncode, output = get_returncode_output(['which', 'fusermount']) if returncode == 0: self.umount_cmd = 'fusermount -u' else: returncode, output = get_returncode_output(['which', 'umount']) if returncode == 0: self.umount_cmd = 'umount' else: raise AssertionError( 'no valid umount command could be determined' ) # Some systems (Mac OSX, for example), have somewhat small limitations # on the length of mount point paths. This caused problems in the past # when the test name (which can be quite long) was used as the # directory name. Consequently, our test directory ($PWD, here, # created via TestWithDir) must have a reasonably short path. test_name = '%s.%s' % (self.__class__.__name__, self.test_method_name) self.test_name_file = os.path.join(self.test_dir, 'test_name') # Store the test name in a file so that the test tree can be linked # to the test that failed for debugging. self.sh.execute('echo ? >?', test_name, self.test_name_file) self.wd = os.getcwd() os.chdir(self.test_dir) self.sh.pushd(self.test_dir) self.sh.execute('mkdir -p mnt source') self.build_tree() def tearDown(self): os.chdir(self.wd) self.sh.popd() self.sh.exit() del self.sh super(_BaseBlackboxTestCase, self).tearDown() def p(self, s): return unicode(s) def get_audio_data(self, filename): raise NotImplementedError @classmethod def get_tags(cls, filename): return MutagenFileMetaStore.tags_class(filename) @classmethod def get_tag(cls, filename, tag): return cls.get_tags(filename)[tag] @classmethod def set_tag(cls, filename, tag, value): tags = cls.get_tags(filename) if tags is None: raise FileNotTaggableError(filename) tags[tag] = value tags.save() def assertFilesHaveSameTags(self, filename1, filename2): self.assertEqual(self.get_tags(filename1), self.get_tags(filename2)) def get_options(self): options = [ '-o', ','.join(self.get_mount_options()), os.path.join(self.test_dir, 'source'), os.path.join(self.test_dir, 'mnt'), ] options.extend(self.get_extra_options()) return options def get_mount_options(self): mount_parameters = dict(self.get_mount_parameters()) mount_options = ['debug'] if mount_parameters.get('sourcetreerep', None): mount_options.append( 'sourcetreerep=%s' % mount_parameters['sourcetreerep'] ) if mount_parameters.get('sourcetreemon', None): mount_options.append( 'sourcetreemon=%s' % mount_parameters['sourcetreemon'] ) if mount_parameters.get('pathstore', None): mount_options.append( 'pathstore=%s' % mount_parameters['pathstore'] ) mount_options.extend(self.get_extra_mount_options()) return mount_options def get_extra_options(self): return [] def get_extra_mount_options(self): return [] def get_mount_parameters(self): return {} def mount(self): args = [PYTHON_EXECUTABLE, PYTAGSFS_EXECUTABLE] args.extend(self.get_options()) mount_cmd = shinterp.interpolate(' '.join(len(args) * '?'), *args) self.sh.execute('mount_cmd=?', mount_cmd) self.sh.execute('echo "${mount_cmd}" >mount_cmd') self.filesystem_process = BackgroundCommand( PYTHON_EXECUTABLE, args, stderr = 'logfile', stdout = 'logfile', ) self.filesystem_process.run() sleep_until(lambda: ( os.path.exists('mnt/.log') )) self.assertTrue(self.filesystem_process.isRunning()) # Check that mnt is accessible: os.stat('mnt') def umount(self): # FIXME: If umount cannot be completed, we should probably send SIGKILL # to the filesystem process and make sure the umount succeeds after # that. Otherwise, filesystem processes can persist uncleanly. try: # Filesystem process should still be running. self.assertTrue(self.filesystem_process.isRunning()) # Check that mnt is accessible: os.stat('mnt') # Check for spurious tracebacks: self.assertFileDoesNotContain('logfile', 'Traceback') finally: try: self.sh.execute(UMOUNT_COMMAND % '"${PWD}/mnt"') except CommandFailed: for i in range(UMOUNT_RETRY_COUNT): e = None time.sleep(UMOUNT_RETRY_DELAY) try: self.sh.execute(UMOUNT_COMMAND % '"${PWD}/mnt"') except CommandFailed, e: pass else: break if e is not None: raise sleep_until(lambda: ( not self.filesystem_process.isRunning() )) self.assertEqual(self.filesystem_process.getExitStatus(), 0) self.assertEqual(self.filesystem_process.getExitSignal(), None) def clean_up(self): self.sh.execute('rm -f mount_cmd') self.sh.execute('rm -f logfile') self.sh.execute('rmdir mnt') self.sh.execute('rm -fR source') self.sh.execute('rm ?', self.test_name_file) ################################################################################ class _BasePathPatternBlackboxTestCase(_BaseBlackboxTestCase): def build_tree(self): self.sh.execute(u'mkdir -p source/a/b source/a source/x') self.sh.execute(u'touch source/a/b/c source/a/• source/x/y') self.sh.execute(u'chmod 0644 source/a/b/c source/a/• source/x/y') class SimpleFilenamePatternTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%f'] def test_read_dir(self): self.mount() try: self.assertEqual( set(f for f in os.listdir(u'mnt') if not f.startswith('.')), set([u'c', u'y', u'•']), ) finally: self.umount() self.clean_up() def test_add_empty_file(self): self.mount() try: self.sh.execute('touch source/a/b/d') sleep_until(lambda: ( os.path.exists('mnt/d') )) self.assertFileExists('mnt/d') finally: self.umount() self.clean_up() add_blackbox_test_class(SimpleFilenamePatternTestCase) class SourceExcludeTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%f', 'srcfilter=!\/c$'] def test_source_exclusion(self): self.mount() try: filenames = os.listdir(u'mnt') assert (u'c' not in filenames), repr(filenames) finally: self.umount() self.clean_up() add_blackbox_test_class(SourceExcludeTestCase) class DestExcludeTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%f', 'srcfilter=!\/c$'] def test_dest_exclusion(self): self.mount() try: filenames = os.listdir(u'mnt') assert (u'c' not in filenames), repr(filenames) finally: self.umount() self.clean_up() add_blackbox_test_class(DestExcludeTestCase) class _BasePathPatternUpdatesTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%p/%f'] class PathPatternSourceTreeUpdatesTestCase(_BasePathPatternUpdatesTestCase): def test_update_file_contents(self): self.mount() try: content = 'foo\n' orig_mtime = os.stat('mnt/b/c').st_mtime f = open('source/a/b/c', 'w') try: f.write(content) finally: f.close() sleep_until(lambda: ( os.stat('mnt/b/c').st_mtime != orig_mtime )) self.assertFileContent('mnt/b/c', content) finally: self.umount() self.clean_up() def test_update_mtime(self): self.mount() try: stat_a_src = os.stat('source/a/b/c') stat_a_dst = os.stat('mnt/b/c') stat_a_dst_dir = os.stat('mnt/b') self.assertEqual(stat_a_src.st_mtime, stat_a_dst.st_mtime) self.assertEqual(stat_a_src.st_mtime, stat_a_dst_dir.st_mtime) # Make sure enough time passes for timestamps to change. time.sleep(1) os.utime('source/a/b/c', None) # Wait for dest file mtime to change: sleep_until(lambda: ( os.stat('mnt/b/c').st_mtime != stat_a_dst.st_mtime )) stat_b_src = os.stat('source/a/b/c') stat_b_dst = os.stat('mnt/b/c') stat_b_dst_dir = os.stat('mnt/b') self.assertEqual(stat_b_src.st_mtime, stat_b_dst.st_mtime) self.assertEqual(stat_b_src.st_mtime, stat_b_dst_dir.st_mtime) assert stat_a_src.st_mtime < stat_b_src.st_mtime assert stat_a_dst.st_mtime < stat_b_dst.st_mtime finally: self.umount() self.clean_up() def test_update_mode(self): self.mount() try: stat_a_src = os.stat('source/a/b/c') stat_a_dst = os.stat('mnt/b/c') mode_a_src = stat.S_IMODE(stat_a_src.st_mode) mode_a_dst = stat.S_IMODE(stat_a_dst.st_mode) self.assertEqual(mode_a_src, 0644) self.assertEqual(mode_a_dst, 0644) new_mode = (mode_a_src & 0000) | 0600 os.chmod('source/a/b/c', new_mode) # Wait for dest file mode to change: sleep_until(lambda: ( stat.S_IMODE(os.stat('mnt/b/c').st_mode) != mode_a_dst )) stat_b_src = os.stat('source/a/b/c') stat_b_dst = os.stat('mnt/b/c') mode_b_src = stat.S_IMODE(stat_b_src.st_mode) mode_b_dst = stat.S_IMODE(stat_b_dst.st_mode) self.assertEqual(mode_b_src, 0600) self.assertEqual(mode_b_dst, 0600) finally: self.umount() self.clean_up() def test_simple_rename(self): self.mount() try: os.makedirs('source/m/n') os.rename('source/a/b/c', 'source/m/n/o') sleep_until(lambda: ( os.path.exists('mnt/n/o') )) self.assertFileDoesNotExist('mnt/b/c') self.assertFileExists('mnt/n/o') finally: self.umount() self.clean_up() add_blackbox_test_class(PathPatternSourceTreeUpdatesTestCase) # FIXME: Unicode version of this TestCase is necessary. class PathPatternDestTreeUpdatesTestCase(_BasePathPatternUpdatesTestCase): def test_write_truncate(self): self.mount() try: f = open('mnt/b/c', 'w') f.write('foo\n') f.close() self.assertFileContent('mnt/b/c', 'foo\n') finally: self.umount() self.clean_up() def test_append(self): self.mount() try: f = open('mnt/b/c', 'w') f.write('foo\nbar\nbaz\n') f.close() self.assertFileContent('mnt/b/c', 'foo\nbar\nbaz\n') f = open('mnt/b/c', 'a') f.write('buz\n') f.close() self.assertFileContent('mnt/b/c', 'foo\nbar\nbaz\nbuz\n') finally: self.umount() self.clean_up() def test_overwrite_section(self): self.mount() try: f = open('mnt/b/c', 'w') f.write('foo\nbar\nbaz\n') f.close() self.assertFileContent('mnt/b/c', 'foo\nbar\nbaz\n') fd = os.open('mnt/b/c', os.O_RDWR) os.lseek(fd, 4, 0) os.write(fd, 'biz\n') os.close(fd) self.assertFileContent('mnt/b/c', 'foo\nbiz\nbaz\n') finally: self.umount() self.clean_up() def test_ftruncate(self): initial = 'foo\nbar\nbaz\nbiz\nbang\nboom' final = initial[:8] f = open('source/a/m', 'w') f.write(initial) f.close() self.mount() try: self.assertFileContent('mnt/a/m', initial) f = open('mnt/a/m', 'r+') try: self.assertEqual(f.read(), initial) f.truncate(8) f.seek(0) self.assertEqual(f.read(), final) finally: f.close() self.assertFileContent('mnt/a/m', final) finally: self.umount() self.clean_up() def test_seek_to_end(self): content = 'foo\nbar\nbaz\nbiz\nbang\nboom' f = open('source/a/m', 'w') try: f.write(content) finally: f.close() self.mount() try: self.assertFileContent('mnt/a/m', content) f = open('mnt/a/m', 'rb+') try: self.assertEqual(f.read(), content) f.seek(0, 2) self.assertEqual(f.tell(), len(content)) finally: f.close() self.assertFileContent('mnt/a/m', content) finally: self.umount() self.clean_up() def test_write_past_end_and_seek_to_end(self): content = 'foo\nbar\n' last = 'baz\n' final = content + last f = open('source/a/m', 'w') try: f.write(content) finally: f.close() self.mount() try: self.assertFileContent('mnt/a/m', content) f = open('mnt/a/m', 'rb+') try: self.assertEqual(f.read(), content) f.seek(0, 2) f.write(last) f.seek(0) self.assertEqual(f.read(), final) f.seek(0, 2) self.assertEqual(f.tell(), len(final)) finally: f.close() self.assertFileContent('mnt/a/m', final) finally: self.umount() self.clean_up() def test_update_mtime(self): self.mount() try: stat_a_src = os.stat('source/a/b/c') stat_a_dst = os.stat('mnt/b/c') stat_a_dst_dir = os.stat('mnt/b') self.assertEqual(stat_a_src.st_mtime, stat_a_dst.st_mtime) self.assertEqual(stat_a_src.st_mtime, stat_a_dst_dir.st_mtime) # Make sure enough time passes for timestamps to change. time.sleep(1) os.utime('mnt/b/c', None) stat_b_src = os.stat('source/a/b/c') stat_b_dst = os.stat('mnt/b/c') stat_b_dst_dir = os.stat('mnt/b') self.assertEqual(stat_b_src.st_mtime, stat_b_dst.st_mtime) self.assertEqual(stat_b_src.st_mtime, stat_b_dst_dir.st_mtime) assert stat_a_src.st_mtime < stat_b_src.st_mtime assert stat_a_dst.st_mtime < stat_b_dst.st_mtime finally: self.umount() self.clean_up() def test_update_mode(self): self.mount() try: stat_a_src = os.stat('source/a/b/c') stat_a_dst = os.stat('mnt/b/c') mode_a_src = stat.S_IMODE(stat_a_src.st_mode) mode_a_dst = stat.S_IMODE(stat_a_dst.st_mode) self.assertEqual(mode_a_src, 0644) self.assertEqual(mode_a_dst, 0644) new_mode = (mode_a_src & 0000) | 0600 os.chmod('mnt/b/c', new_mode) stat_b_src = os.stat('source/a/b/c') stat_b_dst = os.stat('mnt/b/c') mode_b_src = stat.S_IMODE(stat_b_src.st_mode) mode_b_dst = stat.S_IMODE(stat_b_dst.st_mode) self.assertEqual(mode_b_src, 0600) self.assertEqual(mode_b_dst, 0600) finally: self.umount() self.clean_up() add_blackbox_test_class(PathPatternDestTreeUpdatesTestCase) ################################################################################ class _BaseOperationTestCase(_BaseBlackboxTestCase): filename = None source_file = None dest_file = None content = None def build_tree(self): self.filename = self.p('foo') self.source_file = os.path.join('source', self.filename) self.dest_file = os.path.join('mnt', self.filename) self.content = 'foo\nbar\nbaz\n' f = open(self.source_file, 'w') try: f.write(self.content) finally: f.close() def get_extra_mount_options(self): return ['format=/%f'] class TruncateTestCase(_BaseOperationTestCase): def test_read_from_read_only_file(self): self.mount() try: # We use unsafe_truncate to guarantee use of truncate, not # ftruncate. unsafe_truncate(self.dest_file.encode(user_encoding), 4) # truncate does not affect the source file until the fake path has # been opened for writing. self.assertFileContent(self.source_file, self.content) # truncate should affect dest file immediately. self.assertFileContent(self.dest_file, self.content[:4]) # truncate should not affect the source file even now, because the # fake path has not been opened for writing. self.assertFileContent(self.source_file, self.content) finally: self.umount() self.clean_up() def test_read_from_read_write_file(self): self.mount() try: # We use unsafe_truncate to guarantee use of truncate, not # ftruncate. unsafe_truncate(self.dest_file.encode(user_encoding), 4) # truncate does not affect source file until fake path has been # opened for writing. self.assertFileContent(self.source_file, self.content) # truncate should affect the fake path immediately. self.assertFileContent( self.dest_file, self.content[:4], mode = 'rb+') # truncate should affect the source file now because the fake path # was opened for writing. self.assertFileContent(self.source_file, self.content[:4]) finally: self.umount() self.clean_up() add_blackbox_test_class(TruncateTestCase) add_blackbox_test_class(mixin_unicode(TruncateTestCase)) class FtruncateTestCase(_BaseOperationTestCase): def test(self): self.mount() try: f = open(self.dest_file.encode(user_encoding), 'rb+') try: os.ftruncate(f.fileno(), 4) self.assertFileContent(self.dest_file, self.content[:4]) self.assertFileContent(self.source_file, self.content[:4]) finally: f.close() finally: self.umount() self.clean_up() add_blackbox_test_class(FtruncateTestCase) add_blackbox_test_class(mixin_unicode(FtruncateTestCase)) ################################################################################ class _BaseSourceTreeUpdatesTestCase(_BaseBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%{artist} - %t.%e'] def build_tree(self): self.data_file = self.p(os.path.join(DATA_DIR, 'silence.ext')) shutil.copy(self.data_file, self.p('source/foo.ext')) self.set_tag(self.p('source/foo.ext'), 'artist', self.p('bar')) self.set_tag(self.p('source/foo.ext'), 'title', self.p('baz')) def test_tag_change_causing_path_change(self): self.mount() try: self.set_tag(self.p('source/foo.ext'), 'artist', self.p('qux')) sleep_until(lambda: ( os.path.exists(self.p('mnt/qux - baz.ext')) )) self.assertEqual( self.get_tag(self.p('mnt/qux - baz.ext'), 'artist'), [self.p('qux')], ) self.assertFilesHaveSameAudioContent( self.data_file, self.p('mnt/qux - baz.ext')) finally: self.umount() self.clean_up() def test_tag_change_causing_new_fake_path(self): self.set_tag(self.p('source/foo.ext'), 'artist', []) self.mount() try: self.assertEqual(os.listdir('mnt'), ['.log']) self.set_tag(self.p('source/foo.ext'), 'artist', self.p('qux')) sleep_until(lambda: ( os.path.exists(self.p('mnt/qux - baz.ext')) )) self.assertEqual( self.get_tag(self.p('mnt/qux - baz.ext'), 'artist'), [self.p('qux')], ) self.assertFilesHaveSameAudioContent( self.data_file, self.p('mnt/qux - baz.ext')) finally: self.umount() self.clean_up() class OggSourceTreeUpdatesTestCase(OggMixin, _BaseSourceTreeUpdatesTestCase): pass add_blackbox_test_class(OggSourceTreeUpdatesTestCase) add_blackbox_test_class(mixin_unicode(OggSourceTreeUpdatesTestCase)) class FlacSourceTreeUpdatesTestCase(FlacMixin, _BaseSourceTreeUpdatesTestCase): pass add_blackbox_test_class(FlacSourceTreeUpdatesTestCase) add_blackbox_test_class(mixin_unicode(FlacSourceTreeUpdatesTestCase)) class Mp3SourceTreeUpdatesTestCase(Mp3Mixin, _BaseSourceTreeUpdatesTestCase): pass add_blackbox_test_class(Mp3SourceTreeUpdatesTestCase) add_blackbox_test_class(mixin_unicode(Mp3SourceTreeUpdatesTestCase)) class _BaseDestTreeUpdatesTestCase(_BaseBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%{artist} - %t.%e'] def build_tree(self): self.data_file = self.p(os.path.join(DATA_DIR, 'silence.ext')) shutil.copy(self.data_file, self.p('source/foo.ext')) self.set_tag(self.p('source/foo.ext'), 'artist', self.p('bar')) self.set_tag(self.p('source/foo.ext'), 'title', self.p('baz')) def test_tag_change_causing_path_change(self): self.mount() try: self.set_tag(self.p('mnt/bar - baz.ext'), 'artist', self.p('qux')) self.assertEqual( self.get_tag(self.p('source/foo.ext'), 'artist'), [self.p('qux')], ) self.assertFilesHaveSameAudioContent( self.data_file, self.p('mnt/qux - baz.ext')) finally: self.umount() self.clean_up() def test_remove_file(self): self.mount() try: os.unlink(self.p('source/foo.ext')) sleep_until(lambda: ( not os.path.exists(self.p('mnt/bar - baz.ext')) )) self.assertEqual(os.listdir('mnt'), ['.log']) finally: self.umount() self.clean_up() class OggDestTreeUpdatesTestCase(OggMixin, _BaseDestTreeUpdatesTestCase): pass add_blackbox_test_class(OggDestTreeUpdatesTestCase) add_blackbox_test_class(mixin_unicode(OggDestTreeUpdatesTestCase)) class FlacDestTreeUpdatesTestCase(FlacMixin, _BaseDestTreeUpdatesTestCase): pass add_blackbox_test_class(FlacDestTreeUpdatesTestCase) add_blackbox_test_class(mixin_unicode(FlacDestTreeUpdatesTestCase)) class Mp3DestTreeUpdatesTestCase(Mp3Mixin, _BaseDestTreeUpdatesTestCase): pass add_blackbox_test_class(Mp3DestTreeUpdatesTestCase) add_blackbox_test_class(mixin_unicode(Mp3DestTreeUpdatesTestCase)) ################################################################################ class _BaseRenameTestCase(_BaseBlackboxTestCase): def build_tree(self): shutil.copy( self.p(os.path.join(DATA_DIR, 'silence.ext')), self.p('source/foo.ext'), ) self.set_tag(self.p('source/foo.ext'), 'artist', self.p('bar')) self.set_tag(self.p('source/foo.ext'), 'title', self.p('baz')) def get_extra_mount_options(self): return ['format=/%a/%t.%e'] def test_simple_rename(self): self.mount() try: os.rename( self.p(os.path.join('mnt', 'bar', 'baz.ext')), self.p(os.path.join('mnt', 'bar', 'qux.ext')), ) self.assertFilesHaveSameAudioContent( self.p(os.path.join(DATA_DIR, 'silence.ext')), self.p(os.path.join('mnt', 'bar', 'qux.ext')), ) tags = self.get_tags(self.p(os.path.join('mnt', 'bar', 'qux.ext'))) self.assertEqual(tags['artist'], [self.p('bar')]) self.assertEqual(tags['title'], [self.p('qux')]) finally: self.umount() self.clean_up() def test_rename_across_directories(self): self.mount() try: os.mkdir(self.p(os.path.join('mnt', 'qux'))) os.rename( self.p(os.path.join('mnt', 'bar', 'baz.ext')), self.p(os.path.join('mnt', 'qux', 'baz.ext')), ) self.assertFilesHaveSameAudioContent( self.p(os.path.join(DATA_DIR, 'silence.ext')), self.p(os.path.join('mnt', 'qux', 'baz.ext')), ) tags = self.get_tags(self.p(os.path.join('mnt', 'qux', 'baz.ext'))) self.assertEqual(tags['artist'], [self.p('qux')]) self.assertEqual(tags['title'], [self.p('baz')]) finally: self.umount() self.clean_up() def test_directory_rename(self): self.mount() try: os.rename( self.p(os.path.join('mnt', 'bar')), self.p(os.path.join('mnt', 'qux')), ) self.assertFilesHaveSameAudioContent( self.p(os.path.join(DATA_DIR, 'silence.ext')), self.p(os.path.join('mnt', 'qux', 'baz.ext')), ) tags = self.get_tags(self.p(os.path.join('mnt', 'qux', 'baz.ext'))) self.assertEqual(tags['artist'], [self.p('qux')]) self.assertEqual(tags['title'], [self.p('baz')]) finally: self.umount() self.clean_up() def test_invalid_rename(self): self.mount() try: try: os.rename( self.p(os.path.join('mnt', 'bar', 'baz.ext')), self.p(os.path.join('mnt', 'bar', 'qux.boink')), ) except OSError, e: self.assertEqual(e.errno, errno.EINVAL) finally: self.umount() self.clean_up() class OggRenameTestCase(OggMixin, _BaseRenameTestCase): pass add_blackbox_test_class(OggRenameTestCase) add_blackbox_test_class(mixin_unicode(OggRenameTestCase)) class FlacRenameTestCase(FlacMixin, _BaseRenameTestCase): pass add_blackbox_test_class(FlacRenameTestCase) add_blackbox_test_class(mixin_unicode(FlacRenameTestCase)) class Mp3RenameTestCase(Mp3Mixin, _BaseRenameTestCase): pass add_blackbox_test_class(Mp3RenameTestCase) add_blackbox_test_class(mixin_unicode(Mp3RenameTestCase)) ################################################################################ class MkdirRmdirTagsTestCase(_BaseBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%g/%{artist}/%t.%e'] def build_tree(self): data_file = os.path.join(DATA_DIR, 'silence.flac') for num in (1, 2, 3, 4): self.sh.execute('cp ? ?', data_file, 'source/silence%u.flac' % num) for num, artist, title, genre in ( (1, 'foo', 'bar', 'Rock'), (2, 'foo', 'baz', 'Rock'), (3, 'bink', 'bonk', 'Rap'), (4, 'fink', 'fonk', 'Country'), ): file = 'source/silence%u.flac' % num self.set_tag(file, 'artist', artist) self.set_tag(file, 'title', title) self.set_tag(file, 'genre', genre) def test_mkdir_rmdir(self): self.mount() try: dir = 'mnt/Honky Tonk' self.sh.execute('mkdir ?', dir) self.assertDirectoryExists(dir) self.sh.execute('rmdir ?', dir) self.assertDirectoryDoesNotExist(dir) finally: self.umount() self.clean_up() def test_rename_empty_dir(self): self.mount() try: dir = 'mnt/Honky Tonk' dir2 = 'mnt/Soul' self.sh.execute('mkdir ?', dir) self.assertDirectoryExists(dir) self.sh.execute('mv ? ?', dir, dir2) self.assertDirectoryDoesNotExist(dir) self.sh.execute('ls ?', dir2) self.assertRaises(CommandFailed, self.sh.execute, 'ls ?/*', dir2) self.sh.execute('rmdir ?', dir2) self.assertDirectoryDoesNotExist(dir2) finally: self.umount() self.clean_up() def test_move_files_into_new_directory(self): self.mount() try: self.sh.execute('mkdir mnt/Rock/biz') self.assertDirectoryExists('mnt/Rock/biz') self.sh.execute('mv mnt/Rock/foo/* mnt/Rock/biz/') self.assertDirectoryDoesNotExist('mnt/Rock/foo') filenames = os.listdir(u'mnt/Rock/biz') self.assertEqual(len(filenames), 2) for filename in filenames: tags = self.get_tags(os.path.join(u'mnt/Rock/biz', filename)) self.assertEqual(tags['artist'], [u'biz']) finally: self.umount() self.clean_up() add_blackbox_test_class(MkdirRmdirTagsTestCase) ################################################################################ class StatvfsTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['format=/%f'] def assertAlmostEqualInt(self, a, b): self.assertTrue(int(0.9 * b) <= a <= int(1.1 * b)) def test(self): # Some statvfs values may be slightly different because they may have # changed between statvfs calls on source and mnt (mostly those related # to free space). For these, we use assertAlmostEqualInt instead of # assertEqual. self.mount() try: statvfs_source = os.statvfs('source') statvfs_mnt = os.statvfs('mnt') self.assertEqual(statvfs_source.f_bsize, statvfs_mnt.f_bsize) self.assertEqual(statvfs_source.f_frsize, statvfs_mnt.f_frsize) self.assertEqual(statvfs_source.f_blocks, statvfs_mnt.f_blocks) self.assertAlmostEqualInt( statvfs_mnt.f_bfree, statvfs_source.f_bfree, ) self.assertAlmostEqualInt( statvfs_mnt.f_bavail, statvfs_source.f_bavail, ) self.assertEqual(statvfs_source.f_files, statvfs_mnt.f_files) self.assertAlmostEqualInt( statvfs_mnt.f_ffree, statvfs_source.f_ffree, ) self.assertAlmostEqualInt( statvfs_mnt.f_favail, statvfs_source.f_favail, ) #f_fsid is not supported by os.statvfs_result self.assertTrue(type(statvfs_mnt.f_flag), int) self.assertEqual(statvfs_source.f_namemax, statvfs_mnt.f_namemax) finally: self.umount() self.clean_up() add_blackbox_test_class(StatvfsTestCase) ################################################################################ class LogFileTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['verbosity=debug'] def test_log_file_exists(self): self.mount() try: self.assertFileExists('mnt/.log') finally: self.umount() self.clean_up() def test_log_file_receives_messages(self): self.mount() try: from pytagsfs import __version__ as version self.assertFileContains('mnt/.log', 'pytagsfs version %s' % version) finally: self.umount() self.clean_up() add_blackbox_test_class(LogFileTestCase) class LogSizeTestCase(_BasePathPatternBlackboxTestCase): logsize = 8 def get_extra_mount_options(self): return ['verbosity=debug', 'logsize=%u' % self.logsize] def test_log_size(self): self.mount() try: f = open('mnt/.log', 'r') length = len(f.read()) try: assert length == self.logsize, ( 'Expected length to be %u, got %u instead.' % ( self.logsize, length)) finally: f.close() finally: self.umount() self.clean_up() add_blackbox_test_class(LogSizeTestCase) class ProfilingTestCase(_BasePathPatternBlackboxTestCase): def get_extra_mount_options(self): return ['profile'] def test(self): self.mount() try: f = open('mnt/.log', 'r') length = os.stat('mnt/.log').st_size try: content = f.read(length).decode('utf-8', 'replace') finally: f.close() lines = content.split('\n') for line in reversed(lines): if 'PROF' in line: break parts = line.split() self.assertEqual(parts[1], 'PROF') self.assertTrue(hasattr(Fuse, parts[3])) finally: self.umount() self.clean_up() add_blackbox_test_class(ProfilingTestCase) ################################################################################ class _BaseMmapTestCase(_BaseBlackboxTestCase): content = 'foo\nbar\n' file_obj = None map = None def get_extra_mount_options(self): return ['format=/%f'] def build_tree(self): f = open('source/foo.txt', 'w') try: f.write(self.content) finally: f.close() def _open_file(self): raise NotImplementedError def _mmap(self, fileno, filesize): raise NotImplementedError def _init_mmap(self): self.file_obj = self._open_file() try: self.file_obj.seek(0, 2) filesize = self.file_obj.tell() self.map = self._mmap( self.file_obj.fileno(), filesize, ) except: self._de_init_mmap() raise def _de_init_mmap(self): try: if self.map: self.map.close() del self.map finally: if self.file_obj: self.file_obj.close() del self.file_obj class ReadOnlyMmapTestCase(_BaseMmapTestCase): def _open_file(self): return open('mnt/foo.txt', 'rb') def _mmap(self, fileno, filesize): import mmap return mmap.mmap( fileno, filesize, access = mmap.ACCESS_READ, ) def test_read(self): self.mount() try: self._init_mmap() try: self.assertEqual(self.map[:], self.content) finally: self._de_init_mmap() finally: self.umount() self.clean_up() add_blackbox_test_class(ReadOnlyMmapTestCase) class _BaseReadWriteMmapTestCase(_BaseMmapTestCase): def _open_file(self): return open('mnt/foo.txt', 'rb+') def test_range_assignment(self): self.mount() try: self._init_mmap() try: content = self.map[:] self.assertEqual(content, self.content) self.map[0:4] = 'baz\n' self.assertEqual(self.map[:], 'baz\nbar\n') finally: self._de_init_mmap() finally: self.umount() self.clean_up() class CopyOnWriteReadWriteMmapTestCase(_BaseReadWriteMmapTestCase): def _mmap(self, fileno, filesize): import mmap return mmap.mmap( fileno, filesize, access = mmap.ACCESS_COPY, ) add_blackbox_test_class(CopyOnWriteReadWriteMmapTestCase) # I don't know of any platforms that support this currently, but it # should be implemented on most eventually. class WriteThroughReadWriteMmapTestCase(_BaseReadWriteMmapTestCase): def _mmap(self, fileno, filesize): import mmap return mmap.mmap( fileno, filesize, access = mmap.ACCESS_WRITE, ) class WriteThroughNoSuchDeviceMmapTestCase(_BaseMmapTestCase): def _open_file(self): return open('mnt/foo.txt', 'rb+') def _mmap(self, fileno, filesize): import mmap return mmap.mmap( fileno, filesize, access = mmap.ACCESS_WRITE, ) def test_init_mmap(self): self.mount() try: try: try: self._init_mmap() except EnvironmentError, e: if e.errno != errno.ENODEV: raise finally: self._de_init_mmap() finally: self.umount() self.clean_up() if PLATFORM in ('Linux', 'Darwin', 'BSD'): add_blackbox_test_class(WriteThroughNoSuchDeviceMmapTestCase) else: add_blackbox_test_class(WriteThroughReadWriteMmapTestCase) class MutagenMmapTestCase(_BaseMmapTestCase): def _open_file(self): return open('mnt/foo.txt', 'r+') def _mmap(self, fileno, filesize): return None def test_insert_bytes(self): from mutagen._util import insert_bytes expected_content = 'foo\nbaz\nbar\n' self.mount() try: self._init_mmap() try: insert_bytes(self.file_obj, 4, 4) self.file_obj.seek(4) self.file_obj.write('baz\n') self.file_obj.seek(0) content = self.file_obj.read() self.assertEqual(content, expected_content) self.file_obj.close() self.file_obj = self._open_file() content = self.file_obj.read() self.assertEqual(content, expected_content) finally: self._de_init_mmap() finally: self.umount() self.clean_up() def test_delete_bytes(self): from mutagen._util import delete_bytes expected_content = 'foo\n' self.mount() try: self._init_mmap() try: delete_bytes(self.file_obj, 4, 4) self.file_obj.seek(0) content = self.file_obj.read() self.assertEqual(content, expected_content) self.file_obj.close() self.file_obj = self._open_file() content = self.file_obj.read() self.assertEqual(content, expected_content) finally: self._de_init_mmap() finally: self.umount() self.clean_up() add_blackbox_test_class(MutagenMmapTestCase) class FuzzThread(Thread): _killed = None def kill(self): self._killed = True def sleep_random(self): time.sleep(random.random()) def _select_random_path(self, root, predicate = (lambda path: True)): root = root.rstrip('/') all_files = [] for dirpath, dirnames, filenames in os.walk(root): paths = [os.path.join(dirpath, dirname) for dirname in dirnames] paths.extend([ os.path.join(dirpath, filename) for filename in filenames ]) for path in paths: if predicate(path): all_files.append(path) return random.choice(all_files) def select_random_virtual_file(self): return self._select_random_path( 'mnt', (lambda path: ((path != 'mnt/.log') and os.path.isfile(path))), ) def select_random_real_file(self): return self._select_random_path( 'source', (lambda path: os.path.isfile(path)), ) def select_random_virtual_directory(self): return self._select_random_path( 'mnt', (lambda path: os.path.isdir(path)), ) def select_random_real_directory(self): return self._select_random_path( 'source', (lambda path: os.path.isdir(path)), ) def run(self): while True: self.sleep_random() self.do_action() if self._killed: break class StatFuzzThread(FuzzThread): def do_action(self): filename = self.select_random_virtual_file() try: os.stat(filename) except (OSError, IOError): pass class ReadFuzzThread(FuzzThread): def do_action(self): filename = self.select_random_virtual_file() try: f = open(filename, 'r') try: f.seek(0, 2) size = f.tell() f.seek(random.randint(0, 2 * size)) f.read(random.randint(0, 2 * size)) finally: f.close() except (OSError, IOError): pass class UtimeFuzzThread(FuzzThread): def do_action(self): filename = self.select_random_virtual_file() try: os.utime(filename, None) except (OSError, IOError): pass class SetTagFuzzThread(FuzzThread): tags = ('artist', 'album', 'title') def do_action(self): filename = self.get_filename() try: _BaseBlackboxTestCase.set_tag( filename, random.choice(self.tags), ConcurrentFuzzTestCase.get_random_string(), ) except (OSError, IOError, FileNotTaggableError): pass class SetTagOnVirtualFileFuzzThread(SetTagFuzzThread): def get_filename(self): return self.select_random_virtual_file() class SetTagOnRealFileFuzzThread(SetTagFuzzThread): def get_filename(self): return self.select_random_real_file() class ConcurrentFuzzTestCase(_BaseBlackboxTestCase): num_threads = 10 duration = 10 thread_classes = ( StatFuzzThread, ReadFuzzThread, UtimeFuzzThread, SetTagOnVirtualFileFuzzThread, SetTagOnRealFileFuzzThread, ) def get_opts(self): return 'format=/%a/%l/%t.%e' @classmethod def get_random_string(cls): return ''.join([random.choice(string.letters) for i in range(16)]) def build_tree(self): for source_path in glob.glob(os.path.join(DATA_DIR, '*')): dest_path = os.path.join( 'source', os.path.basename(source_path), ) shutil.copy(source_path, dest_path) try: self.set_tag(dest_path, 'artist', self.get_random_string()) self.set_tag(dest_path, 'album', self.get_random_string()) self.set_tag(dest_path, 'title', self.get_random_string()) except FileNotTaggableError: # Note: file is left in place even though it won't appear in # mount tree. pass def test(self): self.mount() try: threads = [] for i in range(self.num_threads): thread_cls = random.choice(self.thread_classes) threads.append(thread_cls()) for thread in threads: thread.start() time.sleep(self.duration) for thread in threads: thread.kill() thread.join() finally: self.umount() self.clean_up() add_blackbox_test_class(ConcurrentFuzzTestCase) pytagsfs-0.9.2/tests/subspat.py0000644000175000017500000002731111315711421016145 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from unittest import TestCase from pytagsfs.subspat import SubstitutionPattern from manager import manager class SubstitutionPatternTestMixin(object): pattern_cls = SubstitutionPattern def setUp(self): self.pattern = self.pattern_cls(self.pattern_string) def tearDown(self): del self.pattern def test_split(self): splitter = self.pattern.get_splitter(self.substitution_pattern_mapping) self.assertEqual( splitter.split(self.substitution_pattern_filled_string), self.substitution_pattern_mapping, ) def test_fill(self): self.assertEqual( self.pattern.fill(self.substitution_pattern_mapping), self.substitution_pattern_filled_string, ) class ShortKeySubstitutionPatternTestCase( SubstitutionPatternTestMixin, TestCase, ): pattern_string = '%a %b %c' substitution_pattern_mapping = {'a': 'foo', 'b': 'bar', 'c': 'baz'} substitution_pattern_filled_string = 'foo bar baz' manager.add_test_case_class(ShortKeySubstitutionPatternTestCase) class LongKeySubstitutionPatternTestCase( SubstitutionPatternTestMixin, TestCase, ): pattern_string = '%{aye} %{bee} %{see}' substitution_pattern_mapping = {'aye': 'foo', 'bee': 'bar', 'see': 'baz'} substitution_pattern_filled_string = 'foo bar baz' manager.add_test_case_class(LongKeySubstitutionPatternTestCase) class MixedKeySubstitutionPatternTestCase( SubstitutionPatternTestMixin, TestCase, ): pattern_string = '%a %{bee} %c %{dee}' substitution_pattern_mapping = { 'a': 'foo', 'bee': 'bar', 'c': 'baz', 'dee': 'boink'} substitution_pattern_filled_string = 'foo bar baz boink' manager.add_test_case_class(MixedKeySubstitutionPatternTestCase) class ConditionalSubstitutionPatternTestMixin(object): def test_conditional_split_true(self): splitter = self.pattern.get_splitter( self.conditional_pattern_mapping_true) self.assertEqual( splitter.split(self.conditional_pattern_filled_string_true), self.conditional_pattern_mapping_true, ) def test_conditional_split_false(self): splitter = self.pattern.get_splitter( self.conditional_pattern_mapping_false) self.assertEqual( splitter.split(self.conditional_pattern_filled_string_false), self.conditional_pattern_mapping_false, ) def test_conditional_fill_true(self): self.assertEqual( self.pattern.fill(self.conditional_pattern_mapping_true), self.conditional_pattern_filled_string_true, ) def test_conditional_fill_false(self): self.assertEqual( self.pattern.fill(self.conditional_pattern_mapping_false), self.conditional_pattern_filled_string_false, ) class ShortKeyConditionalSubstitutionPatternTestCase( ConditionalSubstitutionPatternTestMixin, ShortKeySubstitutionPatternTestCase, ): pattern_string = '%a %b%? %c%?' conditional_pattern_mapping_true = {'a': 'foo', 'b': 'bar', 'c': 'baz'} conditional_pattern_mapping_false = {'a': 'foo', 'b': 'bar', 'c': None} conditional_pattern_filled_string_true = 'foo bar baz' conditional_pattern_filled_string_false = 'foo bar' manager.add_test_case_class(ShortKeyConditionalSubstitutionPatternTestCase) class LongKeyConditionalSubstitutionPatternTestCase( ConditionalSubstitutionPatternTestMixin, LongKeySubstitutionPatternTestCase, ): pattern_string = '%{aye} %{bee}%? %{see}%?' conditional_pattern_mapping_true = { 'aye': 'foo', 'bee': 'bar', 'see': 'baz'} conditional_pattern_mapping_false = { 'aye': 'foo', 'bee': 'bar', 'see': None} conditional_pattern_filled_string_true = 'foo bar baz' conditional_pattern_filled_string_false = 'foo bar' manager.add_test_case_class(LongKeyConditionalSubstitutionPatternTestCase) class MixedKeyConditionalSubstitutionPatternTestCase( ConditionalSubstitutionPatternTestMixin, MixedKeySubstitutionPatternTestCase, ): pattern_string = '%a %{bee} %c%? %{dee}%?' conditional_pattern_mapping_true = { 'a': 'foo', 'bee': 'bar', 'c': 'baz', 'dee': 'boink'} conditional_pattern_mapping_false = { 'a': 'foo', 'bee': 'bar', 'c': 'baz', 'dee': None} conditional_pattern_filled_string_true = 'foo bar baz boink' conditional_pattern_filled_string_false = 'foo bar baz' manager.add_test_case_class(MixedKeyConditionalSubstitutionPatternTestCase) class ShortKeyIfElseSubstitutionPatternTestCase( ShortKeyConditionalSubstitutionPatternTestCase, ): pattern_string = '%a %b %?%c%:Unknown%?' conditional_pattern_filled_string_false = 'foo bar Unknown' manager.add_test_case_class(ShortKeyIfElseSubstitutionPatternTestCase) class ShortKeyIfElseSubstitutionPatternWithDynamicElsePartTestCase( ShortKeyConditionalSubstitutionPatternTestCase, ): pattern_string = '%a %b %?%c%:%a%?' conditional_pattern_filled_string_false = 'foo bar foo' conditional_pattern_mapping_false = {'a': 'foo', 'b': 'bar', 'c': 'foo'} manager.add_test_case_class( ShortKeyIfElseSubstitutionPatternWithDynamicElsePartTestCase) class LongKeyIfElseSubstitutionPatternTestCase( LongKeyConditionalSubstitutionPatternTestCase, ): pattern_string = '%{aye} %{bee} %?%{see}%:Unknown%?' conditional_pattern_filled_string_false = 'foo bar Unknown' manager.add_test_case_class(LongKeyIfElseSubstitutionPatternTestCase) class LongKeyIfElseSubstitutionPatternWithDynamicElsePartTestCase( LongKeyConditionalSubstitutionPatternTestCase, ): pattern_string = '%{aye} %{bee} %?%{see}%:%{aye}%?' conditional_pattern_filled_string_false = 'foo bar foo' conditional_pattern_mapping_false = { 'aye': 'foo', 'bee': 'bar', 'see': 'foo'} manager.add_test_case_class( LongKeyIfElseSubstitutionPatternWithDynamicElsePartTestCase) class MixedKeyIfElseSubstitutionPatternTestCase( MixedKeyConditionalSubstitutionPatternTestCase, ): pattern_string = '%a %{bee} %c %?%{dee}%:Unknown%?' conditional_pattern_filled_string_false = 'foo bar baz Unknown' manager.add_test_case_class(MixedKeyIfElseSubstitutionPatternTestCase) class MixedKeyIfElseSubstitutionPatternWithDynamicElsePartTestCase( MixedKeyConditionalSubstitutionPatternTestCase, ): pattern_string = '%a %{bee} %c %?%{dee}%:%a%?' conditional_pattern_filled_string_false = 'foo bar baz foo' conditional_pattern_mapping_false = { 'a': 'foo', 'bee': 'bar', 'c': 'baz', 'dee': 'foo'} manager.add_test_case_class( MixedKeyIfElseSubstitutionPatternWithDynamicElsePartTestCase) class ModifiedSubstitutionPatternTestMixin(object): def test_modified_fill_lower_case_input(self): mapping_lower = {} for k, v in self.substitution_pattern_mapping.items(): mapping_lower[k] = v.lower() self.assertEqual( self.pattern.fill(mapping_lower), self.substitution_pattern_filled_string, ) def test_modified_fill_upper_case_input(self): mapping_upper = {} for k, v in self.substitution_pattern_mapping.items(): mapping_upper[k] = v.upper() self.assertEqual( self.pattern.fill(mapping_upper), self.substitution_pattern_filled_string, ) def test_modified_fill_title_case_input(self): mapping_title = {} for k, v in self.substitution_pattern_mapping.items(): mapping_title[k] = v.title() self.assertEqual( self.pattern.fill(mapping_title), self.substitution_pattern_filled_string, ) def test_modified_fill_changes_case_none(self): p = self.pattern_cls('%%%s' % self.modified_fill_test_expr) self.assertEqual(p.fill({self.modified_fill_test_key: 'foo'}), 'foo') def test_modified_fill_changes_case_upper(self): p = self.pattern_cls('%%^%s' % self.modified_fill_test_expr) self.assertEqual(p.fill({self.modified_fill_test_key: 'foo'}), 'FOO') def test_modified_fill_changes_case_lower(self): p = self.pattern_cls('%%_%s' % self.modified_fill_test_expr) self.assertEqual(p.fill({self.modified_fill_test_key: 'FOO'}), 'foo') def test_modified_fill_changes_case_title(self): p = self.pattern_cls('%%!%s' % self.modified_fill_test_expr) self.assertEqual(p.fill({self.modified_fill_test_key: 'fOo'}), 'Foo') class ShortKeyModifiedSubstitutionPatternTestCase( ModifiedSubstitutionPatternTestMixin, ShortKeySubstitutionPatternTestCase, ): pattern_string = '%^a %_b %!c' substitution_pattern_mapping = {'a': 'FOO', 'b': 'bar', 'c': 'Baz'} substitution_pattern_filled_string = 'FOO bar Baz' modified_fill_test_key = 'a' modified_fill_test_expr = modified_fill_test_key manager.add_test_case_class(ShortKeyModifiedSubstitutionPatternTestCase) class LongKeyModifiedSubstitutionPatternTestCase( ModifiedSubstitutionPatternTestMixin, LongKeySubstitutionPatternTestCase, ): pattern_string = '%^{aye} %_{bee} %!{see}' substitution_pattern_mapping = {'aye': 'FOO', 'bee': 'bar', 'see': 'Baz'} substitution_pattern_filled_string = 'FOO bar Baz' modified_fill_test_key = 'aye' modified_fill_test_expr = '{%s}' % modified_fill_test_key manager.add_test_case_class(LongKeyModifiedSubstitutionPatternTestCase) class MixedKeyModifiedSubstitutionPatternTestCase( ModifiedSubstitutionPatternTestMixin, MixedKeySubstitutionPatternTestCase, ): pattern_string = '%^a %_{bee} %!c %_{dee}' substitution_pattern_mapping = { 'a': 'FOO', 'bee': 'bar', 'c': 'Baz', 'dee': 'boink'} substitution_pattern_filled_string = 'FOO bar Baz boink' modified_fill_test_key = 'aye' modified_fill_test_expr = '{%s}' % modified_fill_test_key manager.add_test_case_class(MixedKeyModifiedSubstitutionPatternTestCase) class ShortKeyModifedIfElseSubstitutionPatternTestCase( ShortKeyModifiedSubstitutionPatternTestCase, ShortKeyIfElseSubstitutionPatternTestCase, ): pattern_string = '%^a %_b %?%!c%:Unknown%?' conditional_pattern_mapping_true = {'a': 'FOO', 'b': 'bar', 'c': 'Baz'} conditional_pattern_mapping_false = {'a': 'FOO', 'b': 'bar', 'c': None} conditional_pattern_filled_string_true = 'FOO bar Baz' conditional_pattern_filled_string_false = 'FOO bar Unknown' manager.add_test_case_class(ShortKeyModifedIfElseSubstitutionPatternTestCase) class LongKeyModifedIfElseSubstitutionPatternTestCase( LongKeyModifiedSubstitutionPatternTestCase, LongKeyIfElseSubstitutionPatternTestCase, ): pattern_string = '%^{aye} %_{bee} %?%!{see}%:Unknown%?' conditional_pattern_mapping_true = { 'aye': 'FOO', 'bee': 'bar', 'see': 'Baz'} conditional_pattern_mapping_false = { 'aye': 'FOO', 'bee': 'bar', 'see': None} conditional_pattern_filled_string_true = 'FOO bar Baz' conditional_pattern_filled_string_false = 'FOO bar Unknown' manager.add_test_case_class(LongKeyModifedIfElseSubstitutionPatternTestCase) class MixedKeyModifedIfElseSubstitutionPatternTestCase( MixedKeyModifiedSubstitutionPatternTestCase, MixedKeyIfElseSubstitutionPatternTestCase, ): pattern_string = '%^a %_{bee} %!c %?%_{dee}%:Unknown%?' conditional_pattern_mapping_true = { 'a': 'FOO', 'bee': 'bar', 'c': 'Baz', 'dee': 'boink'} conditional_pattern_mapping_false = { 'a': 'FOO', 'bee': 'bar', 'c': 'Baz', 'dee': None} conditional_pattern_filled_string_true = 'FOO bar Baz boink' conditional_pattern_filled_string_false = 'FOO bar Baz Unknown' manager.add_test_case_class(MixedKeyModifedIfElseSubstitutionPatternTestCase) pytagsfs-0.9.2/tests/test_lines_meta_store.py0000644000175000017500000000173011315711421021054 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os from unittest import TestCase from pytagsfs.metastore.testlines import TestLinesMetaStore from pytagsfs.values import Values from manager import manager from common import TestWithDir class TestLinesMetaStoreTestCase(TestWithDir): test_dir_prefix = 'mts' def test(self): filename = os.path.join(self.test_dir, 'foo') store = TestLinesMetaStore() store.set(filename, Values.from_flat_dict({'a': 'qux'})) try: self.assertEqual(store.get(filename), Values({'a': ['qux']})) finally: os.unlink(filename) manager.add_test_case_class(TestLinesMetaStoreTestCase) pytagsfs-0.9.2/tests/util.py0000644000175000017500000000066411315711421015443 0ustar forestforest# Copyright (c) 2007-2008 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. from manager import manager manager.add_doc_test_cases_from_module(__name__, 'pytagsfs.util') pytagsfs-0.9.2/tests/fs.py0000644000175000017500000007331611315711421015102 0ustar forestforest# Copyright (c) 2007-2009 Forest Bond. # This file is part of the pytagsfs software package. # # pytagsfs is free software; you can redistribute it and/or modify it under the # terms of the GNU General Public License version 2 as published by the Free # Software Foundation. # # A copy of the license has been included in the COPYING file. import os, errno, stat, time from pytagsfs.fs import PyTagsFileSystem from pytagsfs.util import join_path_abs from pytagsfs.exceptions import FuseError from manager import manager from common import mixin_unicode, TestWithDir ENCODING = 'utf-8' class _BaseFileSystemTestCase(TestWithDir): test_dir_prefix = 'fs' filesystem = None source_dir = None def p(self, s): return unicode(s) def setUp(self): super(_BaseFileSystemTestCase, self).setUp() self.build_source_tree() self.filesystem = self.create_filesystem() self.filesystem.parse() self.filesystem.pre_init() self.filesystem.init() def tearDown(self): self.filesystem.destroy() del self.filesystem self.remove_source_tree() super(_BaseFileSystemTestCase, self).tearDown() def build_source_tree(self): self.source_dir = os.path.join(self.test_dir, 'source') os.mkdir(self.source_dir) def remove_source_tree(self): os.rmdir(self.source_dir) del self.source_dir def create_filesystem(self): raise NotImplementedError def read_virtual_file(self, fake_path, flags = os.O_RDONLY): fh = self.filesystem.open(fake_path, flags) try: content = self.filesystem.read(fake_path, 1024, 0, fh) finally: self.assertEqual(self.filesystem.release(fake_path, flags, fh), 0) return content def assertVirtualFileContent( self, fake_path, content, flags = os.O_RDONLY): self.assertEqual(self.read_virtual_file(fake_path, flags), content) class _BasePyTagsFileSystemTestCase(_BaseFileSystemTestCase): def create_filesystem(self): fs = PyTagsFileSystem() fs.argv = self.get_argv() return fs def get_argv(self): return [ 'pytagsfs', '-o', 'format=/%f', self.source_dir.encode(ENCODING), 'mnt', ] class _BaseSingleFileOperationTestCase(_BasePyTagsFileSystemTestCase): filename = None source_file = None dest_file = None dest_file_encoded = None content = None def build_source_tree(self): super(_BaseSingleFileOperationTestCase, self).build_source_tree() self.filename = self.p('foo') self.source_file = os.path.join(self.source_dir, self.filename) self.dest_file = join_path_abs([self.filename]) self.dest_file_encoded = self.dest_file.encode(ENCODING) self.content = self.get_content() f = open(self.source_file, 'w') try: f.write(self.content) finally: f.close() def get_content(self): return 'foo\nbar\nbaz\n' def remove_source_tree(self): os.unlink(self.source_file) del self.content del self.dest_file del self.source_file del self.filename super(_BaseSingleFileOperationTestCase, self).remove_source_tree() class _BaseDirectoryOperationTestCase(_BasePyTagsFileSystemTestCase): def get_argv(self): return [ 'pytagsfs', '-o', 'format=/%f/%f', self.source_dir.encode(ENCODING), 'mnt', ] class AccessTestCase(_BaseSingleFileOperationTestCase): def test_not_supported(self): self.assertEqual(self.filesystem.access(self.dest_file, os.F_OK), 0) manager.add_test_case_class(AccessTestCase) manager.add_test_case_class(mixin_unicode(AccessTestCase)) class BmapTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.bmap(None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(BmapTestCase) manager.add_test_case_class(mixin_unicode(BmapTestCase)) class ChmodTestCase(_BaseSingleFileOperationTestCase): def test(self): stat_result = os.stat(self.source_file) self.filesystem.chmod( self.dest_file_encoded, (stat_result.st_mode & stat.S_IWRITE), ) stat_result = os.stat(self.source_file) assert stat_result.st_mode & stat.S_IWRITE self.filesystem.chmod( self.dest_file_encoded, (stat_result.st_mode & ~stat.S_IWRITE), ) stat_result = os.stat(self.source_file) assert not (stat_result.st_mode & stat.S_IWRITE) manager.add_test_case_class(ChmodTestCase) manager.add_test_case_class(mixin_unicode(ChmodTestCase)) class ChownTestCase(_BaseSingleFileOperationTestCase): def test(self): # We can't really test side effects of chown, but we can test that it # doesn't blow up. stat_result = os.stat(self.source_file) self.filesystem.chown( self.dest_file_encoded, stat_result.st_uid, stat_result.st_gid, ) manager.add_test_case_class(ChownTestCase) manager.add_test_case_class(mixin_unicode(ChownTestCase)) class CreateTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.create(None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(CreateTestCase) manager.add_test_case_class(mixin_unicode(CreateTestCase)) class FgetattrTestCase(_BaseSingleFileOperationTestCase): def test(self): flags = os.O_RDONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: real_stat_result = os.stat(self.source_file) fake_stat_result = self.filesystem.fgetattr( self.dest_file_encoded, fh) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) self.assertEqual(real_stat_result.st_mode, fake_stat_result.st_mode) self.assertEqual(real_stat_result.st_size, fake_stat_result.st_size) self.assertEqual(real_stat_result.st_uid, fake_stat_result.st_uid) self.assertEqual(real_stat_result.st_gid, fake_stat_result.st_gid) self.assertEqual(real_stat_result.st_ctime, fake_stat_result.st_ctime) self.assertEqual(real_stat_result.st_mtime, fake_stat_result.st_mtime) self.assertEqual(real_stat_result.st_atime, fake_stat_result.st_atime) self.assertEqual(fake_stat_result.st_dev, 0) self.assertEqual(fake_stat_result.st_ino, 0) manager.add_test_case_class(FgetattrTestCase) manager.add_test_case_class(mixin_unicode(FgetattrTestCase)) class FlushTestCase(_BaseSingleFileOperationTestCase): def test(self): # We can only really test that flush doesn't blow up. flags = os.O_WRONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.write(self.dest_file_encoded, 'qux\n', 0, fh) self.filesystem.flush(self.dest_file_encoded, fh) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) manager.add_test_case_class(FlushTestCase) manager.add_test_case_class(mixin_unicode(FlushTestCase)) class FsyncTestCase(_BaseSingleFileOperationTestCase): def test(self): # We can only really test that fsync doesn't blow up. flags = os.O_WRONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.write(self.dest_file_encoded, 'qux\n', 0, fh) self.filesystem.fsync(self.dest_file_encoded, False, fh) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) manager.add_test_case_class(FsyncTestCase) manager.add_test_case_class(mixin_unicode(FsyncTestCase)) class FsyncdirTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.fsyncdir(None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(FsyncdirTestCase) manager.add_test_case_class(mixin_unicode(FsyncdirTestCase)) class FtruncateTestCase(_BaseSingleFileOperationTestCase): def test(self): flags = os.O_WRONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.ftruncate(self.dest_file_encoded, 4, fh) stat_result = self.filesystem.fgetattr(self.dest_file_encoded, fh) self.assertEqual(stat_result.st_size, 4) self.assertFileContent(self.source_file, self.content[:4]) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) def test_ftruncate_affects_open_rdonly_file(self): fh_rdonly = self.filesystem.open(self.dest_file_encoded, os.O_RDONLY) try: fh_wronly = self.filesystem.open( self.dest_file_encoded, os.O_WRONLY) try: self.filesystem.ftruncate(self.dest_file_encoded, 4, fh_wronly) content = self.filesystem.read( self.dest_file_encoded, 1024, 0, fh_rdonly) finally: self.filesystem.release( self.dest_file_encoded, os.O_WRONLY, fh_wronly) finally: self.filesystem.release( self.dest_file_encoded, os.O_RDONLY, fh_rdonly) self.assertEqual(content, self.content[:4]) manager.add_test_case_class(FtruncateTestCase) manager.add_test_case_class(mixin_unicode(FtruncateTestCase)) class GetattrTestCase(_BaseSingleFileOperationTestCase): def test(self): real_stat_result = os.stat(self.source_file) fake_stat_result = self.filesystem.getattr(self.dest_file_encoded) self.assertEqual(real_stat_result.st_mode, fake_stat_result.st_mode) self.assertEqual(real_stat_result.st_size, fake_stat_result.st_size) self.assertEqual(real_stat_result.st_uid, fake_stat_result.st_uid) self.assertEqual(real_stat_result.st_gid, fake_stat_result.st_gid) self.assertEqual(real_stat_result.st_ctime, fake_stat_result.st_ctime) self.assertEqual(real_stat_result.st_mtime, fake_stat_result.st_mtime) self.assertEqual(real_stat_result.st_atime, fake_stat_result.st_atime) self.assertEqual(fake_stat_result.st_dev, 0) self.assertEqual(fake_stat_result.st_ino, 0) # If not None, st_blksize must be correct. if fake_stat_result.st_blksize is not None: self.assertEqual( real_stat_result.st_blksize, fake_stat_result.st_blksize) # If not None, st_blocks must be correct. if fake_stat_result.st_blocks is not None: self.assertEqual( real_stat_result.st_blocks, fake_stat_result.st_blocks) manager.add_test_case_class(GetattrTestCase) manager.add_test_case_class(mixin_unicode(GetattrTestCase)) class GetxattrTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.getxattr(None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(GetxattrTestCase) manager.add_test_case_class(mixin_unicode(GetxattrTestCase)) class LinkTestCase(_BaseSingleFileOperationTestCase): def test(self): try: self.filesystem.link(None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(LinkTestCase) manager.add_test_case_class(mixin_unicode(LinkTestCase)) class ListxattrTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.listxattr(None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(ListxattrTestCase) manager.add_test_case_class(mixin_unicode(ListxattrTestCase)) class LockTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.lock(None, None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(LockTestCase) manager.add_test_case_class(mixin_unicode(LockTestCase)) class MkdirTestCase(_BaseDirectoryOperationTestCase): def test(self): path = self.p('/foo').encode(ENCODING) self.filesystem.mkdir(path, 0) stat_result = self.filesystem.getattr(path) assert stat.S_ISDIR(stat_result.st_mode) manager.add_test_case_class(MkdirTestCase) manager.add_test_case_class(mixin_unicode(MkdirTestCase)) class MknodTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.mknod(None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) manager.add_test_case_class(MknodTestCase) manager.add_test_case_class(mixin_unicode(MknodTestCase)) class OpenTestCase(_BaseSingleFileOperationTestCase): # Open is tested extensively elsewhere. Just target specific corner cases # here. def test_non_existent_file(self): try: self.filesystem.open( self.p('/qux').encode(ENCODING), os.O_RDONLY) except FuseError, e: self.assertEqual(e.errno, errno.ENOENT) else: assert False manager.add_test_case_class(OpenTestCase) manager.add_test_case_class(mixin_unicode(OpenTestCase)) class OpendirTestCase(_BasePyTagsFileSystemTestCase): def test(self): self.assertEqual(self.filesystem.opendir(None), 0) manager.add_test_case_class(OpendirTestCase) manager.add_test_case_class(mixin_unicode(OpendirTestCase)) class ReadTestCase(_BaseSingleFileOperationTestCase): # This test is somewhat superfluous, but I'd rather have something here # than nothing at all. def test(self): flags = os.O_RDONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: content = self.filesystem.read( self.dest_file_encoded, 1024, 0, fh) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) self.assertEqual(content, self.content) manager.add_test_case_class(ReadTestCase) manager.add_test_case_class(mixin_unicode(ReadTestCase)) class ReaddirTestCase(_BasePyTagsFileSystemTestCase): files = None def build_source_tree(self): super(ReaddirTestCase, self).build_source_tree() self.files = [self.p(x) for x in ('foo', 'bar', 'baz')] for file in self.files: self._create_file(os.path.join(self.source_dir, file)) def remove_source_tree(self): for file in self.files: os.unlink(os.path.join(self.source_dir, file)) del self.files super(ReaddirTestCase, self).remove_source_tree() def test(self): entries = self.filesystem.readdir('/', None) for entry in entries: self.assertEqual(type(entry), str) self.assertEqual( set(entries), set(['.log'] + [f.encode(ENCODING) for f in self.files]), ) manager.add_test_case_class(ReaddirTestCase) manager.add_test_case_class(mixin_unicode(ReaddirTestCase)) class ReadlinkTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.readlink(None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) else: assert False manager.add_test_case_class(ReadlinkTestCase) manager.add_test_case_class(mixin_unicode(ReadlinkTestCase)) class ReleaseTestCase(_BaseSingleFileOperationTestCase): # Nothing to test. See ConcurrentFilesTestCase. pass manager.add_test_case_class(ReleaseTestCase) manager.add_test_case_class(mixin_unicode(ReleaseTestCase)) class ReleasedirTestCase(_BasePyTagsFileSystemTestCase): def test(self): self.assertEqual(self.filesystem.releasedir(None, None), 0) manager.add_test_case_class(ReleasedirTestCase) manager.add_test_case_class(mixin_unicode(ReleasedirTestCase)) class RemovexattrTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.removexattr(None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) else: assert False manager.add_test_case_class(RemovexattrTestCase) manager.add_test_case_class(mixin_unicode(RemovexattrTestCase)) class RenameTestCase(_BaseSingleFileOperationTestCase): def get_argv(self): return [ 'pytagsfs', '-o', ( 'metastores=pytagsfs.metastore.testlines.TestLinesMetaStore,' 'format=/%a' ), self.source_dir.encode(ENCODING), 'mnt', ] def get_content(self): return '%s\n' % self.p('foo').encode(ENCODING) def test(self): qux = self.p(u'qux').encode(ENCODING) path = '/%s'.encode(ENCODING) % qux self.filesystem.rename(self.dest_file_encoded, path) self.assertVirtualFileContent( self.dest_file_encoded, ''.join([qux, self.content[len(qux):]]), ) manager.add_test_case_class(RenameTestCase) manager.add_test_case_class(mixin_unicode(RenameTestCase)) class RmdirTestCase(_BaseDirectoryOperationTestCase): def test(self): path = self.p('/foo').encode(ENCODING) self.filesystem.mkdir(path, 0) self.filesystem.rmdir(path) try: self.filesystem.getattr(path) except FuseError, e: self.assertEqual(e.errno, errno.ENOENT) else: assert False manager.add_test_case_class(RmdirTestCase) manager.add_test_case_class(mixin_unicode(RmdirTestCase)) class SetxattrTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.setxattr(None, None, None, None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) else: assert False manager.add_test_case_class(SetxattrTestCase) manager.add_test_case_class(mixin_unicode(SetxattrTestCase)) class StatfsTestCase(_BasePyTagsFileSystemTestCase): copied_attributes = ( 'f_bsize', 'f_frsize', 'f_bavail', 'f_files', 'f_ffree', 'f_favail', 'f_namemax', ) other_attributes = ( 'f_fsid', 'f_flag', ) def get_argv(self): return [ 'pytagsfs', '-o', 'format=/%f/%f', self.source_dir.encode(ENCODING), 'mnt', ] def test(self): statfs_result = self.filesystem.statfs() statvfs_result = os.statvfs(self.source_dir.encode(ENCODING)) for name in self.copied_attributes: self.assertEqual( getattr(statfs_result, name), getattr(statvfs_result, name), ) self.assertTrue(type(statfs_result.f_flag), int) manager.add_test_case_class(StatfsTestCase) manager.add_test_case_class(mixin_unicode(StatfsTestCase)) class SymlinkTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.symlink(None, None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) else: assert False manager.add_test_case_class(SymlinkTestCase) manager.add_test_case_class(mixin_unicode(SymlinkTestCase)) class TruncateTestCase(_BaseSingleFileOperationTestCase): def test_read_from_read_only_file(self): self.filesystem.truncate(self.dest_file_encoded, 4) stat_result = self.filesystem.getattr(self.dest_file_encoded) self.assertEqual(stat_result.st_size, 4) self.assertFileContent(self.source_file, self.content) self.assertVirtualFileContent( self.dest_file_encoded, self.content[:4]) # Another read should give the same result. self.assertVirtualFileContent( self.dest_file_encoded, self.content[:4]) def test_read_from_read_write_file(self): self.filesystem.truncate(self.dest_file_encoded, 4) stat_result = self.filesystem.getattr(self.dest_file_encoded) self.assertEqual(stat_result.st_size, 4) self.assertFileContent(self.source_file, self.content, mode = 'rb+') self.assertVirtualFileContent( self.dest_file_encoded, self.content[:4], os.O_RDWR, ) # Another read should give the same result. self.assertVirtualFileContent( self.dest_file_encoded, self.content[:4], os.O_RDWR, ) def test_truncate_affects_open_rdonly_file(self): flags = os.O_RDONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.truncate(self.dest_file_encoded, 4) content = self.filesystem.read(self.dest_file_encoded, 1024, 0, fh) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) self.assertEqual(content, self.content[:4]) def test_truncate_affects_source_file_if_virtual_file_is_opened_for_writing( self): flags = os.O_RDWR fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.truncate(self.dest_file_encoded, 4) self.assertFileContent(self.source_file, self.content[:4]) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) def test_write_affects_truncated_open_rdonly_file(self): self.filesystem.truncate(self.dest_file_encoded, 4) fh_rdonly = self.filesystem.open(self.dest_file_encoded, os.O_RDONLY) try: fh_wronly = self.filesystem.open( self.dest_file_encoded, os.O_WRONLY | os.O_APPEND) try: self.filesystem.write( self.dest_file_encoded, 'qux\n', 0, fh_wronly) content = self.filesystem.read( self.dest_file_encoded, 1024, 0, fh_rdonly) finally: self.filesystem.release( self.dest_file_encoded, os.O_WRONLY, fh_wronly) finally: self.filesystem.release( self.dest_file_encoded, os.O_RDONLY, fh_rdonly) self.assertEqual(content, self.content[:4] + 'qux\n') def test_read_from_already_open_read_write_file(self): flags = os.O_RDONLY fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.truncate(self.dest_file_encoded, 4) self.assertEqual( self.filesystem.read(self.dest_file_encoded, 1024, 0, fh), self.content[:4], ) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) def test_truncate_open_rdonly_open_wronly_twice(self): self.filesystem.truncate(self.dest_file_encoded, 4) fh_rdonly = self.filesystem.open(self.dest_file_encoded, os.O_RDONLY) try: fh_wronly1 = self.filesystem.open( self.dest_file_encoded, os.O_WRONLY, ) try: fh_wronly2 = self.filesystem.open( self.dest_file_encoded, os.O_WRONLY, ) self.filesystem.release( self.dest_file_encoded, os.O_WRONLY, fh_wronly2, ) finally: self.filesystem.release( self.dest_file_encoded, os.O_WRONLY, fh_wronly1, ) finally: self.filesystem.release( self.dest_file_encoded, os.O_RDONLY, fh_rdonly, ) manager.add_test_case_class(TruncateTestCase) manager.add_test_case_class(mixin_unicode(TruncateTestCase)) class UnlinkTestCase(_BasePyTagsFileSystemTestCase): def test_not_supported(self): try: self.filesystem.unlink(None) except FuseError, e: self.assertEqual(e.errno, errno.ENOSYS) else: assert False manager.add_test_case_class(UnlinkTestCase) manager.add_test_case_class(mixin_unicode(UnlinkTestCase)) class UtimensTestCase(_BaseSingleFileOperationTestCase): def test(self): now = time.time() self.filesystem.utimens(self.dest_file_encoded, (now, 0)) stat_result = os.stat(self.source_file) self.assertEqual(int(stat_result.st_mtime), 0) self.assertEqual(int(stat_result.st_atime), int(now)) now = time.time() self.filesystem.utimens(self.dest_file_encoded, (0, now)) stat_result = os.stat(self.source_file) self.assertEqual(int(stat_result.st_mtime), int(now)) self.assertEqual(int(stat_result.st_atime), 0) manager.add_test_case_class(UtimensTestCase) manager.add_test_case_class(mixin_unicode(UtimensTestCase)) class WriteTestCase(_BaseSingleFileOperationTestCase): def test(self): content = 'abc\ndef\nghi\n' flags = os.O_RDWR fh = self.filesystem.open(self.dest_file_encoded, flags) try: self.filesystem.write( self.dest_file_encoded, content, 0, fh, ) read_content = self.filesystem.read( self.dest_file_encoded, 1024, 0, fh, ) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) self.assertEqual(content, read_content) manager.add_test_case_class(WriteTestCase) manager.add_test_case_class(mixin_unicode(WriteTestCase)) ### class FrozenPathTestCase(_BaseSingleFileOperationTestCase): def get_argv(self): return [ 'pytagsfs', '-o', ( 'metastores=pytagsfs.metastore.testlines.TestLinesMetaStore,' 'format=/%a' ), self.source_dir.encode(ENCODING), 'mnt', ] def get_content(self): return '%s\n' % self.p('foo').encode(ENCODING) def test_open_writable_once(self): flags = os.O_RDWR qux = self.p(u'qux').encode(ENCODING) fh = self.filesystem.open(self.dest_file_encoded, flags) try: # File should be reachable via old fake path. self.filesystem.getattr(self.dest_file_encoded) # Write the new content -- will eventually cause the file's fake # path to change. self.filesystem.write( self.dest_file_encoded, '%s\n' % qux, 0, fh, ) # The file can now be reached via two different fake paths. # One is frozen, the other is the new fake path. self.filesystem.getattr(self.dest_file_encoded) self.filesystem.getattr('/%s' % qux) finally: self.filesystem.release(self.dest_file_encoded, flags, fh) # Now the file can only be reached via the new fake path. self.assertRaises( FuseError, self.filesystem.getattr, self.dest_file_encoded, ) self.filesystem.getattr('/%s' % qux) def test_open_writable_twice(self): flags = os.O_RDWR qux = self.p(u'qux').encode(ENCODING) fh1 = self.filesystem.open(self.dest_file_encoded, flags) try: fh2 = self.filesystem.open(self.dest_file_encoded, flags) try: # File should be reachable via old fake path. self.filesystem.getattr(self.dest_file_encoded) # Write the new content -- will eventually cause the file's # fake path to change. self.filesystem.write( self.dest_file_encoded, '%s\n' % qux, 0, fh2, ) # The file can now be reached via two different fake paths. # One is frozen, the other is the new fake path. self.filesystem.getattr(self.dest_file_encoded) self.filesystem.getattr('/%s' % qux) finally: self.filesystem.release(self.dest_file_encoded, flags, fh2) # The file can now be reached via two different fake paths. # One is frozen, the other is the new fake path. self.filesystem.getattr(self.dest_file_encoded) self.filesystem.getattr('/%s' % qux) finally: self.filesystem.release(self.dest_file_encoded, flags, fh1) # Now the file can only be reached via the new fake path. self.assertRaises( FuseError, self.filesystem.getattr, self.dest_file_encoded, ) self.filesystem.getattr('/%s' % qux) manager.add_test_case_class(FrozenPathTestCase) manager.add_test_case_class(mixin_unicode(FrozenPathTestCase)) class GetattrWithSymlinkTestCase(_BasePyTagsFileSystemTestCase): filename = None source_file = None dest_file = None dest_file_encoded = None def build_source_tree(self): super(GetattrWithSymlinkTestCase, self).build_source_tree() self.filename = self.p('foo') self.source_file = os.path.join(self.source_dir, self.filename) self.dest_file = join_path_abs([self.filename]) self.dest_file_encoded = self.dest_file.encode(ENCODING) os.symlink('/dev/null', self.source_file) def remove_source_tree(self): os.unlink(self.source_file) super(GetattrWithSymlinkTestCase, self).remove_source_tree() def test(self): # Symlinks are rejected. This file should not appear in the virtual # tree. self.assertRaises( FuseError, self.filesystem.getattr, self.dest_file_encoded, ) manager.add_test_case_class(GetattrWithSymlinkTestCase) manager.add_test_case_class(mixin_unicode(GetattrWithSymlinkTestCase)) pytagsfs-0.9.2/README0000644000175000017500000000572611315711421013636 0ustar forestforest=============== pytagsfs README =============== ----------------------- http://www.pytagsfs.org ----------------------- pytagsfs is a FUSE filesystem that arranges media files in a virtual directory structure based on the file tags. For instance, a set of audio files could be mapped to a new directory structure organizing them hierarchically by album, genre, release date, etc. File tags can be changed by moving and renaming virtual files and directories. The virtual files can also be modified directly, and, of course, can be opened and played just like regular files. This file may be distributed under the same license as pytagsfs itself. Dependencies ============ pytagsfs has the following dependencies: * Python (2.4, 2.5, or 2.6): http://www.python.org/ * sclapp (>= 0.5.2): http://www.alittletooquiet.net/software/sclapp * python-fuse (>= 0.2): http://fuse.sourceforge.net/wiki/index.php/FusePython * mutagen: http://www.sacredchao.net/quodlibet/wiki/Development/Mutagen One of the following filesystem monitoring libraries should also be installed: * inotifyx (Linux only): http://www.alittletooquiet.net/software/inotifyx/ * py-kqueue (Darwin, FreeBSD, NetBSD, OpenBSD): http://pypi.python.org/packages/source/p/py-kqueue/ * gamin (many Unix-like systems, inotifyx and py-kqueue are preferred): http://www.gnome.org/~veillard/gamin/ To run the test suite, the following additional dependencies must be fulfilled: * madplay: http://www.underbit.com/products/mad/ * vorbis-tools (for ogg123): http://www.vorbis.com/ * flac: http://flac.sourceforge.net/ * ctypes (Python 2.4 only): http://python.net/crew/theller/ctypes/ Installing ========== Before installing from source, check if your distribution has packages available. It is not normally recommended that you install packages from source in system-wide directories, unless you know what you're doing. To build:: ./setup.py build To install:: ./setup.py install To clean up temporary files created while building or testing:: ./setup.py clean To clean all files, including built files that are required for installation:: ./setup.py clean --all Documentation ============= Manual pages for both the pytagsfs and pytags commands are built via ``setup.py build``. Please refer to those, as well as the pytagsfs website, for documentation. Running Tests ============= Tests can be run via setup.py:: ./setup.py test Specific tests can be specified on the command-line. For instance, to only run tests defined in module tests.subspat:: ./setup.py test --tests tests.subspat To only run tests defined by test case ShortKeySubstitutionPatternTestCase:: ./setup.py test --tests tests.subspat.ShortKeySubstitutionPatternTestCase To only run a specific test defined by that test case:: ./setup.py test --tests tests.subspat.ShortKeySubstitutionPatternTestCase.testSplit Multiple identifiers can be specified using a comma-separated list. See Also ======== * AUTHORS * BUGS * COPYING * NEWS * TODO