git.notmuchmail.org Git - notmuch/blob - bindings/python/notmuch/database.py

   1 """
   2 This file is part of notmuch.
   3
   4 Notmuch is free software: you can redistribute it and/or modify it
   5 under the terms of the GNU General Public License as published by the
   6 Free Software Foundation, either version 3 of the License, or (at your
   7 option) any later version.
   8
   9 Notmuch is distributed in the hope that it will be useful, but WITHOUT
  10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with notmuch.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 Copyright 2010 Sebastian Spaeth <Sebastian@SSpaeth.de>
  18 """
  19
  20 import os
  21 import codecs
  22 from ctypes import c_char_p, c_void_p, c_uint, byref, POINTER
  23 from notmuch.globals import (
  24     nmlib,
  25     Enum,
  26     _str,
  27     NotmuchDatabaseP,
  28     NotmuchDirectoryP,
  29     NotmuchMessageP,
  30     NotmuchTagsP,
  31 )
  32 from .errors import (
  33     STATUS,
  34     FileError,
  35     NotmuchError,
  36     NullPointerError,
  37     NotInitializedError,
  38     ReadOnlyDatabaseError,
  39 )
  40 from notmuch.message import Message
  41 from notmuch.tag import Tags
  42 from .query import Query
  43 from .directory import Directory
  44
  45 class Database(object):
  46     """The :class:`Database` is the highest-level object that notmuch
  47     provides. It references a notmuch database, and can be opened in
  48     read-only or read-write mode. A :class:`Query` can be derived from
  49     or be applied to a specific database to find messages. Also adding
  50     and removing messages to the database happens via this
  51     object. Modifications to the database are not atmic by default (see
  52     :meth:`begin_atomic`) and once a database has been modified, all
  53     other database objects pointing to the same data-base will throw an
  54     :exc:`XapianError` as the underlying database has been
  55     modified. Close and reopen the database to continue working with it.
  56
  57     :class:`Database` objects implement the context manager protocol
  58     so you can use the :keyword:`with` statement to ensure that the
  59     database is properly closed.
  60
  61     .. note::
  62
  63         Any function in this class can and will throw an
  64         :exc:`NotInitializedError` if the database was not intitialized
  65         properly.
  66
  67     .. note::
  68
  69         Do remember that as soon as we tear down (e.g. via `del db`) this
  70         object, all underlying derived objects such as queries, threads,
  71         messages, tags etc will be freed by the underlying library as well.
  72         Accessing these objects will lead to segfaults and other unexpected
  73         behavior. See above for more details.
  74     """
  75     _std_db_path = None
  76     """Class attribute to cache user's default database"""
  77
  78     MODE = Enum(['READ_ONLY', 'READ_WRITE'])
  79     """Constants: Mode in which to open the database"""
  80
  81     """notmuch_database_get_directory"""
  82     _get_directory = nmlib.notmuch_database_get_directory
  83     _get_directory.argtypes = [NotmuchDatabaseP, c_char_p]
  84     _get_directory.restype = NotmuchDirectoryP
  85
  86     """notmuch_database_get_path"""
  87     _get_path = nmlib.notmuch_database_get_path
  88     _get_path.argtypes = [NotmuchDatabaseP]
  89     _get_path.restype = c_char_p
  90
  91     """notmuch_database_get_version"""
  92     _get_version = nmlib.notmuch_database_get_version
  93     _get_version.argtypes = [NotmuchDatabaseP]
  94     _get_version.restype = c_uint
  95
  96     """notmuch_database_open"""
  97     _open = nmlib.notmuch_database_open
  98     _open.argtypes = [c_char_p, c_uint]
  99     _open.restype = NotmuchDatabaseP
 100
 101     """notmuch_database_upgrade"""
 102     _upgrade = nmlib.notmuch_database_upgrade
 103     _upgrade.argtypes = [NotmuchDatabaseP, c_void_p, c_void_p]
 104     _upgrade.restype = c_uint
 105
 106     """ notmuch_database_find_message"""
 107     _find_message = nmlib.notmuch_database_find_message
 108     _find_message.argtypes = [NotmuchDatabaseP, c_char_p,
 109                               POINTER(NotmuchMessageP)]
 110     _find_message.restype = c_uint
 111
 112     """notmuch_database_find_message_by_filename"""
 113     _find_message_by_filename = nmlib.notmuch_database_find_message_by_filename
 114     _find_message_by_filename.argtypes = [NotmuchDatabaseP, c_char_p,
 115                                           POINTER(NotmuchMessageP)]
 116     _find_message_by_filename.restype = c_uint
 117
 118     """notmuch_database_get_all_tags"""
 119     _get_all_tags = nmlib.notmuch_database_get_all_tags
 120     _get_all_tags.argtypes = [NotmuchDatabaseP]
 121     _get_all_tags.restype = NotmuchTagsP
 122
 123     """notmuch_database_create"""
 124     _create = nmlib.notmuch_database_create
 125     _create.argtypes = [c_char_p]
 126     _create.restype = NotmuchDatabaseP
 127
 128     def __init__(self, path = None, create = False,
 129                  mode = MODE.READ_ONLY):
 130         """If *path* is `None`, we will try to read a users notmuch
 131         configuration and use his configured database. The location of the
 132         configuration file can be specified through the environment variable
 133         *NOTMUCH_CONFIG*, falling back to the default `~/.notmuch-config`.
 134
 135         If *create* is `True`, the database will always be created in
 136         :attr:`MODE`.READ_WRITE mode. Default mode for opening is READ_ONLY.
 137
 138         :param path:   Directory to open/create the database in (see
 139                        above for behavior if `None`)
 140         :type path:    `str` or `None`
 141         :param create: Pass `False` to open an existing, `True` to create a new
 142                        database.
 143         :type create:  bool
 144         :param mode:   Mode to open a database in. Is always
 145                        :attr:`MODE`.READ_WRITE when creating a new one.
 146         :type mode:    :attr:`MODE`
 147         :raises: :exc:`NotmuchError` or derived exception in case of
 148             failure.
 149         """
 150         self._db = None
 151         self.mode = mode
 152         if path is None:
 153             # no path specified. use a user's default database
 154             if Database._std_db_path is None:
 155                 #the following line throws a NotmuchError if it fails
 156                 Database._std_db_path = self._get_user_default_db()
 157             path = Database._std_db_path
 158
 159         if create == False:
 160             self.open(path, mode)
 161         else:
 162             self.create(path)
 163
 164     _destroy = nmlib.notmuch_database_destroy
 165     _destroy.argtypes = [NotmuchDatabaseP]
 166     _destroy.restype = None
 167
 168     def __del__(self):
 169         if self._db:
 170             self._destroy(self._db)
 171
 172     def _assert_db_is_initialized(self):
 173         """Raises :exc:`NotInitializedError` if self._db is `None`"""
 174         if not self._db:
 175             raise NotInitializedError()
 176
 177     def create(self, path):
 178         """Creates a new notmuch database
 179
 180         This function is used by __init__() and usually does not need
 181         to be called directly. It wraps the underlying
 182         *notmuch_database_create* function and creates a new notmuch
 183         database at *path*. It will always return a database in :attr:`MODE`
 184         .READ_WRITE mode as creating an empty database for
 185         reading only does not make a great deal of sense.
 186
 187         :param path: A directory in which we should create the database.
 188         :type path: str
 189         :raises: :exc:`NotmuchError` in case of any failure
 190                     (possibly after printing an error message on stderr).
 191         """
 192         if self._db is not None:
 193             raise NotmuchError(message="Cannot create db, this Database() "
 194                                        "already has an open one.")
 195
 196         res = Database._create(_str(path), Database.MODE.READ_WRITE)
 197
 198         if not res:
 199             raise NotmuchError(
 200                 message="Could not create the specified database")
 201         self._db = res
 202
 203     def open(self, path, mode=0):
 204         """Opens an existing database
 205
 206         This function is used by __init__() and usually does not need
 207         to be called directly. It wraps the underlying
 208         *notmuch_database_open* function.
 209
 210         :param status: Open the database in read-only or read-write mode
 211         :type status:  :attr:`MODE`
 212         :raises: Raises :exc:`NotmuchError` in case of any failure
 213                     (possibly after printing an error message on stderr).
 214         """
 215         res = Database._open(_str(path), mode)
 216
 217         if not res:
 218             raise NotmuchError(message="Could not open the specified database")
 219         self._db = res
 220
 221     _close = nmlib.notmuch_database_close
 222     _close.argtypes = [NotmuchDatabaseP]
 223     _close.restype = None
 224
 225     def close(self):
 226         '''
 227         Closes the notmuch database.
 228         '''
 229         if self._db:
 230             self._close(self._db)
 231
 232     def __enter__(self):
 233         '''
 234         Implements the context manager protocol.
 235         '''
 236         return self
 237
 238     def __exit__(self, exc_type, exc_value, traceback):
 239         '''
 240         Implements the context manager protocol.
 241         '''
 242         self.close()
 243
 244     def get_path(self):
 245         """Returns the file path of an open database"""
 246         self._assert_db_is_initialized()
 247         return Database._get_path(self._db).decode('utf-8')
 248
 249     def get_version(self):
 250         """Returns the database format version
 251
 252         :returns: The database version as positive integer
 253         """
 254         self._assert_db_is_initialized()
 255         return Database._get_version(self._db)
 256
 257     _needs_upgrade = nmlib.notmuch_database_needs_upgrade
 258     _needs_upgrade.argtypes = [NotmuchDatabaseP]
 259     _needs_upgrade.restype = bool
 260
 261     def needs_upgrade(self):
 262         """Does this database need to be upgraded before writing to it?
 263
 264         If this function returns `True` then no functions that modify the
 265         database (:meth:`add_message`,
 266         :meth:`Message.add_tag`, :meth:`Directory.set_mtime`,
 267         etc.) will work unless :meth:`upgrade` is called successfully first.
 268
 269         :returns: `True` or `False`
 270         """
 271         self._assert_db_is_initialized()
 272         return self._needs_upgrade(self._db)
 273
 274     def upgrade(self):
 275         """Upgrades the current database
 276
 277         After opening a database in read-write mode, the client should
 278         check if an upgrade is needed (notmuch_database_needs_upgrade) and
 279         if so, upgrade with this function before making any modifications.
 280
 281         NOT IMPLEMENTED: The optional progress_notify callback can be
 282         used by the caller to provide progress indication to the
 283         user. If non-NULL it will be called periodically with
 284         'progress' as a floating-point value in the range of [0.0..1.0]
 285         indicating the progress made so far in the upgrade process.
 286
 287         :TODO: catch exceptions, document return values and etc...
 288         """
 289         self._assert_db_is_initialized()
 290         status = Database._upgrade(self._db, None, None)
 291         #TODO: catch exceptions, document return values and etc
 292         return status
 293
 294     _begin_atomic = nmlib.notmuch_database_begin_atomic
 295     _begin_atomic.argtypes = [NotmuchDatabaseP]
 296     _begin_atomic.restype = c_uint
 297
 298     def begin_atomic(self):
 299         """Begin an atomic database operation
 300
 301         Any modifications performed between a successful
 302         :meth:`begin_atomic` and a :meth:`end_atomic` will be applied to
 303         the database atomically.  Note that, unlike a typical database
 304         transaction, this only ensures atomicity, not durability;
 305         neither begin nor end necessarily flush modifications to disk.
 306
 307         :returns: :attr:`STATUS`.SUCCESS or raises
 308         :raises: :exc:`NotmuchError`: :attr:`STATUS`.XAPIAN_EXCEPTION
 309                     Xapian exception occurred; atomic section not entered.
 310
 311         *Added in notmuch 0.9*"""
 312         self._assert_db_is_initialized()
 313         status = self._begin_atomic(self._db)
 314         if status != STATUS.SUCCESS:
 315             raise NotmuchError(status)
 316         return status
 317
 318     _end_atomic = nmlib.notmuch_database_end_atomic
 319     _end_atomic.argtypes = [NotmuchDatabaseP]
 320     _end_atomic.restype = c_uint
 321
 322     def end_atomic(self):
 323         """Indicate the end of an atomic database operation
 324
 325         See :meth:`begin_atomic` for details.
 326
 327         :returns: :attr:`STATUS`.SUCCESS or raises
 328
 329         :raises:
 330             :exc:`NotmuchError`:
 331                 :attr:`STATUS`.XAPIAN_EXCEPTION
 332                     A Xapian exception occurred; atomic section not
 333                     ended.
 334                 :attr:`STATUS`.UNBALANCED_ATOMIC:
 335                     end_atomic has been called more times than begin_atomic.
 336
 337         *Added in notmuch 0.9*"""
 338         self._assert_db_is_initialized()
 339         status = self._end_atomic(self._db)
 340         if status != STATUS.SUCCESS:
 341             raise NotmuchError(status)
 342         return status
 343
 344     def get_directory(self, path):
 345         """Returns a :class:`Directory` of path,
 346         (creating it if it does not exist(?))
 347
 348         :param path: An unicode string containing the path relative to the path
 349               of database (see :meth:`get_path`), or else should be an absolute
 350               path with initial components that match the path of 'database'.
 351         :returns: :class:`Directory` or raises an exception.
 352         :raises: :exc:`FileError` if path is not relative database or absolute
 353                  with initial components same as database.
 354         :raises: :exc:`ReadOnlyDatabaseError` if the database has not been
 355                  opened in read-write mode
 356         """
 357         self._assert_db_is_initialized()
 358
 359         # work around libnotmuch calling exit(3), see
 360         # id:20120221002921.8534.57091@thinkbox.jade-hamburg.de
 361         # TODO: remove once this issue is resolved
 362         if self.mode != Database.MODE.READ_WRITE:
 363             raise ReadOnlyDatabaseError('The database has to be opened in '
 364                                         'read-write mode for get_directory')
 365
 366         # sanity checking if path is valid, and make path absolute
 367         if path and path[0] == os.sep:
 368             # we got an absolute path
 369             if not path.startswith(self.get_path()):
 370                 # but its initial components are not equal to the db path
 371                 raise FileError('Database().get_directory() called '
 372                                 'with a wrong absolute path')
 373             abs_dirpath = path
 374         else:
 375             #we got a relative path, make it absolute
 376             abs_dirpath = os.path.abspath(os.path.join(self.get_path(), path))
 377
 378         dir_p = Database._get_directory(self._db, _str(path))
 379
 380         # return the Directory, init it with the absolute path
 381         return Directory(abs_dirpath, dir_p, self)
 382
 383     _add_message = nmlib.notmuch_database_add_message
 384     _add_message.argtypes = [NotmuchDatabaseP, c_char_p,
 385                              POINTER(NotmuchMessageP)]
 386     _add_message.restype = c_uint
 387
 388     def add_message(self, filename, sync_maildir_flags=False):
 389         """Adds a new message to the database
 390
 391         :param filename: should be a path relative to the path of the
 392             open database (see :meth:`get_path`), or else should be an
 393             absolute filename with initial components that match the
 394             path of the database.
 395
 396             The file should be a single mail message (not a
 397             multi-message mbox) that is expected to remain at its
 398             current location, since the notmuch database will reference
 399             the filename, and will not copy the entire contents of the
 400             file.
 401
 402         :param sync_maildir_flags: If the message contains Maildir
 403             flags, we will -depending on the notmuch configuration- sync
 404             those tags to initial notmuch tags, if set to `True`. It is
 405             `False` by default to remain consistent with the libnotmuch
 406             API. You might want to look into the underlying method
 407             :meth:`Message.maildir_flags_to_tags`.
 408
 409         :returns: On success, we return
 410
 411            1) a :class:`Message` object that can be used for things
 412               such as adding tags to the just-added message.
 413            2) one of the following :attr:`STATUS` values:
 414
 415               :attr:`STATUS`.SUCCESS
 416                   Message successfully added to database.
 417               :attr:`STATUS`.DUPLICATE_MESSAGE_ID
 418                   Message has the same message ID as another message already
 419                   in the database. The new filename was successfully added
 420                   to the list of the filenames for the existing message.
 421
 422         :rtype:   2-tuple(:class:`Message`, :attr:`STATUS`)
 423
 424         :raises: Raises a :exc:`NotmuchError` with the following meaning.
 425               If such an exception occurs, nothing was added to the database.
 426
 427               :attr:`STATUS`.FILE_ERROR
 428                       An error occurred trying to open the file, (such as
 429                       permission denied, or file not found, etc.).
 430               :attr:`STATUS`.FILE_NOT_EMAIL
 431                       The contents of filename don't look like an email
 432                       message.
 433               :attr:`STATUS`.READ_ONLY_DATABASE
 434                       Database was opened in read-only mode so no message can
 435                       be added.
 436         """
 437         self._assert_db_is_initialized()
 438         msg_p = NotmuchMessageP()
 439         status = self._add_message(self._db, _str(filename), byref(msg_p))
 440
 441         if not status in [STATUS.SUCCESS, STATUS.DUPLICATE_MESSAGE_ID]:
 442             raise NotmuchError(status)
 443
 444         #construct Message() and return
 445         msg = Message(msg_p, self)
 446         #automatic sync initial tags from Maildir flags
 447         if sync_maildir_flags:
 448             msg.maildir_flags_to_tags()
 449         return (msg, status)
 450
 451     _remove_message = nmlib.notmuch_database_remove_message
 452     _remove_message.argtypes = [NotmuchDatabaseP, c_char_p]
 453     _remove_message.restype = c_uint
 454
 455     def remove_message(self, filename):
 456         """Removes a message (filename) from the given notmuch database
 457
 458         Note that only this particular filename association is removed from
 459         the database. If the same message (as determined by the message ID)
 460         is still available via other filenames, then the message will
 461         persist in the database for those filenames. When the last filename
 462         is removed for a particular message, the database content for that
 463         message will be entirely removed.
 464
 465         :returns: A :attr:`STATUS` value with the following meaning:
 466
 467              :attr:`STATUS`.SUCCESS
 468                The last filename was removed and the message was removed
 469                from the database.
 470              :attr:`STATUS`.DUPLICATE_MESSAGE_ID
 471                This filename was removed but the message persists in the
 472                database with at least one other filename.
 473
 474         :raises: Raises a :exc:`NotmuchError` with the following meaning.
 475              If such an exception occurs, nothing was removed from the
 476              database.
 477
 478              :attr:`STATUS`.READ_ONLY_DATABASE
 479                Database was opened in read-only mode so no message can be
 480                removed.
 481         """
 482         self._assert_db_is_initialized()
 483         return self._remove_message(self._db, _str(filename))
 484
 485     def find_message(self, msgid):
 486         """Returns a :class:`Message` as identified by its message ID
 487
 488         Wraps the underlying *notmuch_database_find_message* function.
 489
 490         :param msgid: The message ID
 491         :type msgid: unicode or str
 492         :returns: :class:`Message` or `None` if no message is found.
 493         :raises:
 494             :exc:`OutOfMemoryError`
 495                   If an Out-of-memory occured while constructing the message.
 496             :exc:`XapianError`
 497                   In case of a Xapian Exception. These exceptions
 498                   include "Database modified" situations, e.g. when the
 499                   notmuch database has been modified by another program
 500                   in the meantime. In this case, you should close and
 501                   reopen the database and retry.
 502             :exc:`NotInitializedError` if
 503                     the database was not intitialized.
 504         """
 505         self._assert_db_is_initialized()
 506         msg_p = NotmuchMessageP()
 507         status = Database._find_message(self._db, _str(msgid), byref(msg_p))
 508         if status != STATUS.SUCCESS:
 509             raise NotmuchError(status)
 510         return msg_p and Message(msg_p, self) or None
 511
 512     def find_message_by_filename(self, filename):
 513         """Find a message with the given filename
 514
 515         :returns: If the database contains a message with the given
 516             filename, then a class:`Message:` is returned.  This
 517             function returns None if no message is found with the given
 518             filename.
 519
 520         :raises: :exc:`OutOfMemoryError` if an Out-of-memory occured while
 521                  constructing the message.
 522         :raises: :exc:`XapianError` in case of a Xapian Exception.
 523                  These exceptions include "Database modified"
 524                  situations, e.g. when the notmuch database has been
 525                  modified by another program in the meantime. In this
 526                  case, you should close and reopen the database and
 527                  retry.
 528         :raises: :exc:`NotInitializedError` if the database was not
 529                  intitialized.
 530         :raises: :exc:`ReadOnlyDatabaseError` if the database has not been
 531                  opened in read-write mode
 532
 533         *Added in notmuch 0.9*"""
 534         self._assert_db_is_initialized()
 535
 536         # work around libnotmuch calling exit(3), see
 537         # id:20120221002921.8534.57091@thinkbox.jade-hamburg.de
 538         # TODO: remove once this issue is resolved
 539         if self.mode != Database.MODE.READ_WRITE:
 540             raise ReadOnlyDatabaseError('The database has to be opened in '
 541                                         'read-write mode for get_directory')
 542
 543         msg_p = NotmuchMessageP()
 544         status = Database._find_message_by_filename(self._db, _str(filename),
 545                                                     byref(msg_p))
 546         if status != STATUS.SUCCESS:
 547             raise NotmuchError(status)
 548         return msg_p and Message(msg_p, self) or None
 549
 550     def get_all_tags(self):
 551         """Returns :class:`Tags` with a list of all tags found in the database
 552
 553         :returns: :class:`Tags`
 554         :execption: :exc:`NotmuchError` with :attr:`STATUS`.NULL_POINTER
 555                     on error
 556         """
 557         self._assert_db_is_initialized()
 558         tags_p = Database._get_all_tags(self._db)
 559         if tags_p == None:
 560             raise NullPointerError()
 561         return Tags(tags_p, self)
 562
 563     def create_query(self, querystring):
 564         """Returns a :class:`Query` derived from this database
 565
 566         This is a shorthand method for doing::
 567
 568           # short version
 569           # Automatically frees the Database() when 'q' is deleted
 570
 571           q  = Database(dbpath).create_query('from:"Biene Maja"')
 572
 573           # long version, which is functionally equivalent but will keep the
 574           # Database in the 'db' variable around after we delete 'q':
 575
 576           db = Database(dbpath)
 577           q  = Query(db,'from:"Biene Maja"')
 578
 579         This function is a python extension and not in the underlying C API.
 580         """
 581         return Query(self, querystring)
 582
 583     def __repr__(self):
 584         return "'Notmuch DB " + self.get_path() + "'"
 585
 586     def _get_user_default_db(self):
 587         """ Reads a user's notmuch config and returns his db location
 588
 589         Throws a NotmuchError if it cannot find it"""
 590         try:
 591             # python3.x
 592             from configparser import SafeConfigParser
 593         except ImportError:
 594             # python2.x
 595             from ConfigParser import SafeConfigParser
 596
 597         config = SafeConfigParser()
 598         conf_f = os.getenv('NOTMUCH_CONFIG',
 599                            os.path.expanduser('~/.notmuch-config'))
 600         config.readfp(codecs.open(conf_f, 'r', 'utf-8'))
 601         if not config.has_option('database', 'path'):
 602             raise NotmuchError(message="No DB path specified"
 603                                        " and no user default found")
 604         return config.get('database', 'path')
 605
 606     @property
 607     def db_p(self):
 608         """Property returning a pointer to `notmuch_database_t` or `None`
 609
 610         This should normally not be needed by a user (and is not yet
 611         guaranteed to remain stable in future versions).
 612         """
 613         return self._db