#!/usr/bin/env python  """ A simple filesystem-based store of calendar data.  Copyright (C) 2014, 2015 Paul Boddie <paul@boddie.org.uk>  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 3 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, see <http://www.gnu.org/licenses/>. """  from bisect import bisect_left from datetime import datetime from imiptools.config import STORE_DIR, PUBLISH_DIR from imiptools.data import make_calendar, parse_object, to_stream from imiptools.dates import format_datetime, get_datetime, to_timezone from imiptools.filesys import fix_permissions, FileBase from imiptools.period import FreeBusyPeriod from os.path import exists, isfile, join from os import listdir, remove, rmdir from time import sleep import codecs  class FileStore(FileBase):      "A file store of tabular free/busy data and objects."      def __init__(self, store_dir=None):         FileBase.__init__(self, store_dir or STORE_DIR)      def acquire_lock(self, user, timeout=None):         FileBase.acquire_lock(self, timeout, user)      def release_lock(self, user):         FileBase.release_lock(self, user)      # Utility methods.      def _set_defaults(self, t, empty_defaults):         for i, default in empty_defaults:             if i >= len(t):                 t += [None] * (i - len(t) + 1)             if not t[i]:                 t[i] = default         return t      def _get_table(self, user, filename, empty_defaults=None):          """         From the file for the given 'user' having the given 'filename', return         a list of tuples representing the file's contents.          The 'empty_defaults' is a list of (index, value) tuples indicating the         default value where a column either does not exist or provides an empty         value.         """          f = codecs.open(filename, "rb", encoding="utf-8")         try:             l = []             for line in f.readlines():                 t = line.strip(" \r\n").split("\t")                 if empty_defaults:                     t = self._set_defaults(t, empty_defaults)                 l.append(tuple(t))             return l         finally:             f.close()      def _get_table_atomic(self, user, filename, empty_defaults=None):          """         From the file for the given 'user' having the given 'filename', return         a list of tuples representing the file's contents.          The 'empty_defaults' is a list of (index, value) tuples indicating the         default value where a column either does not exist or provides an empty         value.         """          self.acquire_lock(user)         try:             return self._get_table(user, filename, empty_defaults)         finally:             self.release_lock(user)      def _set_table(self, user, filename, items, empty_defaults=None):          """         For the given 'user', write to the file having the given 'filename' the         'items'.          The 'empty_defaults' is a list of (index, value) tuples indicating the         default value where a column either does not exist or provides an empty         value.         """          f = codecs.open(filename, "wb", encoding="utf-8")         try:             for item in items:                 self._set_table_item(f, item, empty_defaults)         finally:             f.close()             fix_permissions(filename)      def _set_table_item(self, f, item, empty_defaults=None):          "Set in table 'f' the given 'item', using any 'empty_defaults'."          if empty_defaults:             item = self._set_defaults(list(item), empty_defaults)         f.write("\t".join(item) + "\n")      def _set_table_atomic(self, user, filename, items, empty_defaults=None):          """         For the given 'user', write to the file having the given 'filename' the         'items'.          The 'empty_defaults' is a list of (index, value) tuples indicating the         default value where a column either does not exist or provides an empty         value.         """          self.acquire_lock(user)         try:             self._set_table(user, filename, items, empty_defaults)         finally:             self.release_lock(user)      # Store object access.      def _get_object(self, user, filename):          """         Return the parsed object for the given 'user' having the given         'filename'.         """          self.acquire_lock(user)         try:             f = open(filename, "rb")             try:                 return parse_object(f, "utf-8")             finally:                 f.close()         finally:             self.release_lock(user)      def _set_object(self, user, filename, node):          """         Set an object for the given 'user' having the given 'filename', using         'node' to define the object.         """          self.acquire_lock(user)         try:             f = open(filename, "wb")             try:                 to_stream(f, node)             finally:                 f.close()                 fix_permissions(filename)         finally:             self.release_lock(user)          return True      def _remove_object(self, filename):          "Remove the object with the given 'filename'."          try:             remove(filename)         except OSError:             return False          return True      def _remove_collection(self, filename):          "Remove the collection with the given 'filename'."          try:             rmdir(filename)         except OSError:             return False          return True      # User discovery.      def get_users(self):          "Return a list of users."          return listdir(self.store_dir)      # Event and event metadata access.      def get_events(self, user):          "Return a list of event identifiers."          filename = self.get_object_in_store(user, "objects")         if not filename or not exists(filename):             return None          return [name for name in listdir(filename) if isfile(join(filename, name))]      def get_all_events(self, user):          "Return a set of (uid, recurrenceid) tuples for all events."          uids = self.get_events(user)         if not uids:             return set()          all_events = set()         for uid in uids:             all_events.add((uid, None))             all_events.update([(uid, recurrenceid) for recurrenceid in self.get_recurrences(user, uid)])          return all_events      def get_event_filename(self, user, uid, recurrenceid=None, dirname=None):          """         Get the filename providing the event for the given 'user' with the given         'uid'. If the optional 'recurrenceid' is specified, a specific instance         or occurrence of an event is returned.          Where 'dirname' is specified, the given directory name is used as the         base of the location within which any filename will reside.         """          if recurrenceid:             return self.get_recurrence_filename(user, uid, recurrenceid, dirname)         else:             return self.get_complete_event_filename(user, uid, dirname)      def get_event(self, user, uid, recurrenceid=None):          """         Get the event for the given 'user' with the given 'uid'. If         the optional 'recurrenceid' is specified, a specific instance or         occurrence of an event is returned.         """          filename = self.get_event_filename(user, uid, recurrenceid)         if not filename or not exists(filename):             return None          return filename and self._get_object(user, filename)      def get_complete_event_filename(self, user, uid, dirname=None):          """         Get the filename providing the event for the given 'user' with the given         'uid'.           Where 'dirname' is specified, the given directory name is used as the         base of the location within which any filename will reside.         """          return self.get_object_in_store(user, dirname, "objects", uid)      def get_complete_event(self, user, uid):          "Get the event for the given 'user' with the given 'uid'."          filename = self.get_complete_event_filename(user, uid)         if not filename or not exists(filename):             return None          return filename and self._get_object(user, filename)      def set_event(self, user, uid, recurrenceid, node):          """         Set an event for 'user' having the given 'uid' and 'recurrenceid' (which         if the latter is specified, a specific instance or occurrence of an         event is referenced), using the given 'node' description.         """          if recurrenceid:             return self.set_recurrence(user, uid, recurrenceid, node)         else:             return self.set_complete_event(user, uid, node)      def set_complete_event(self, user, uid, node):          "Set an event for 'user' having the given 'uid' and 'node'."          filename = self.get_object_in_store(user, "objects", uid)         if not filename:             return False          return self._set_object(user, filename, node)      def remove_event(self, user, uid, recurrenceid=None):          """         Remove an event for 'user' having the given 'uid'. If the optional         'recurrenceid' is specified, a specific instance or occurrence of an         event is removed.         """          if recurrenceid:             return self.remove_recurrence(user, uid, recurrenceid)         else:             for recurrenceid in self.get_recurrences(user, uid) or []:                 self.remove_recurrence(user, uid, recurrenceid)             return self.remove_complete_event(user, uid)      def remove_complete_event(self, user, uid):          "Remove an event for 'user' having the given 'uid'."          self.remove_recurrences(user, uid)          filename = self.get_object_in_store(user, "objects", uid)         if not filename:             return False          return self._remove_object(filename)      def get_recurrences(self, user, uid):          """         Get additional event instances for an event of the given 'user' with the         indicated 'uid'. Both active and cancelled recurrences are returned.         """          return self.get_active_recurrences(user, uid) + self.get_cancelled_recurrences(user, uid)      def get_active_recurrences(self, user, uid):          """         Get additional event instances for an event of the given 'user' with the         indicated 'uid'. Cancelled recurrences are not returned.         """          filename = self.get_object_in_store(user, "recurrences", uid)         if not filename or not exists(filename):             return []          return [name for name in listdir(filename) if isfile(join(filename, name))]      def get_cancelled_recurrences(self, user, uid):          """         Get additional event instances for an event of the given 'user' with the         indicated 'uid'. Only cancelled recurrences are returned.         """          filename = self.get_object_in_store(user, "cancelled", "recurrences", uid)         if not filename or not exists(filename):             return []          return [name for name in listdir(filename) if isfile(join(filename, name))]      def get_recurrence_filename(self, user, uid, recurrenceid, dirname=None):          """         For the event of the given 'user' with the given 'uid', return the         filename providing the recurrence with the given 'recurrenceid'.          Where 'dirname' is specified, the given directory name is used as the         base of the location within which any filename will reside.         """          return self.get_object_in_store(user, dirname, "recurrences", uid, recurrenceid)      def get_recurrence(self, user, uid, recurrenceid):          """         For the event of the given 'user' with the given 'uid', return the         specific recurrence indicated by the 'recurrenceid'.         """          filename = self.get_recurrence_filename(user, uid, recurrenceid)         if not filename or not exists(filename):             return None          return filename and self._get_object(user, filename)      def set_recurrence(self, user, uid, recurrenceid, node):          "Set an event for 'user' having the given 'uid' and 'node'."          filename = self.get_object_in_store(user, "recurrences", uid, recurrenceid)         if not filename:             return False          return self._set_object(user, filename, node)      def remove_recurrence(self, user, uid, recurrenceid):          """         Remove a special recurrence from an event stored by 'user' having the         given 'uid' and 'recurrenceid'.         """          filename = self.get_object_in_store(user, "recurrences", uid, recurrenceid)         if not filename:             return False          return self._remove_object(filename)      def remove_recurrences(self, user, uid):          """         Remove all recurrences for an event stored by 'user' having the given         'uid'.         """          for recurrenceid in self.get_recurrences(user, uid):             self.remove_recurrence(user, uid, recurrenceid)          recurrences = self.get_object_in_store(user, "recurrences", uid)         if recurrences:             return self._remove_collection(recurrences)          return True      # Free/busy period providers, upon extension of the free/busy records.      def _get_freebusy_providers(self, user):          """         Return the free/busy providers for the given 'user'.          This function returns any stored datetime and a list of providers as a         2-tuple. Each provider is itself a (uid, recurrenceid) tuple.         """          filename = self.get_object_in_store(user, "freebusy-providers")         if not filename or not exists(filename):             return None          # Attempt to read providers, with a declaration of the datetime         # from which such providers are considered as still being active.          t = self._get_table_atomic(user, filename, [(1, None)])         try:             dt_string = t[0][0]         except IndexError:             return None          return dt_string, t[1:]      def get_freebusy_providers(self, user, dt=None):          """         Return a set of uncancelled events of the form (uid, recurrenceid)         providing free/busy details beyond the given datetime 'dt'.          If 'dt' is not specified, all events previously found to provide         details will be returned. Otherwise, if 'dt' is earlier than the         datetime recorded for the known providers, None is returned, indicating         that the list of providers must be recomputed.          This function returns a list of (uid, recurrenceid) tuples upon success.         """          t = self._get_freebusy_providers(user)         if not t:             return None          dt_string, t = t          # If the requested datetime is earlier than the stated datetime, the         # providers will need to be recomputed.          if dt:             providers_dt = get_datetime(dt_string)             if not providers_dt or providers_dt > dt:                 return None          # Otherwise, return the providers.          return t[1:]      def _set_freebusy_providers(self, user, dt_string, t):          "Set the given provider timestamp 'dt_string' and table 't'."          filename = self.get_object_in_store(user, "freebusy-providers")         if not filename:             return False          t.insert(0, (dt_string,))         self._set_table_atomic(user, filename, t, [(1, "")])         return True      def set_freebusy_providers(self, user, dt, providers):          """         Define the uncancelled events providing free/busy details beyond the         given datetime 'dt'.         """          t = []          for obj in providers:             t.append((obj.get_uid(), obj.get_recurrenceid()))          return self._set_freebusy_providers(user, format_datetime(dt), t)      def append_freebusy_provider(self, user, provider):          "For the given 'user', append the free/busy 'provider'."          t = self._get_freebusy_providers(user)         if not t:             return False          dt_string, t = t         t.append((provider.get_uid(), provider.get_recurrenceid()))          return self._set_freebusy_providers(user, dt_string, t)      def remove_freebusy_provider(self, user, provider):          "For the given 'user', remove the free/busy 'provider'."          t = self._get_freebusy_providers(user)         if not t:             return False          dt_string, t = t         try:             t.remove((provider.get_uid(), provider.get_recurrenceid()))         except ValueError:             return False          return self._set_freebusy_providers(user, dt_string, t)      # Free/busy period access.      def get_freebusy(self, user, name=None, get_table=None):          "Get free/busy details for the given 'user'."          filename = self.get_object_in_store(user, name or "freebusy")         if not filename or not exists(filename):             return []         else:             return map(lambda t: FreeBusyPeriod(*t),                 (get_table or self._get_table_atomic)(user, filename, [(4, None)]))      def get_freebusy_for_other(self, user, other, get_table=None):          "For the given 'user', get free/busy details for the 'other' user."          filename = self.get_object_in_store(user, "freebusy-other", other)         if not filename or not exists(filename):             return []         else:             return map(lambda t: FreeBusyPeriod(*t),                 (get_table or self._get_table_atomic)(user, filename, [(4, None)]))      def set_freebusy(self, user, freebusy, name=None, set_table=None):          "For the given 'user', set 'freebusy' details."          filename = self.get_object_in_store(user, name or "freebusy")         if not filename:             return False          (set_table or self._set_table_atomic)(user, filename,             map(lambda fb: fb.as_tuple(strings_only=True), freebusy))         return True      def set_freebusy_for_other(self, user, freebusy, other, set_table=None):          "For the given 'user', set 'freebusy' details for the 'other' user."          filename = self.get_object_in_store(user, "freebusy-other", other)         if not filename:             return False          (set_table or self._set_table_atomic)(user, filename,             map(lambda fb: fb.as_tuple(strings_only=True), freebusy))         return True      # Tentative free/busy periods related to countering.      def get_freebusy_offers(self, user):          "Get free/busy offers for the given 'user'."          offers = []         expired = []         now = to_timezone(datetime.utcnow(), "UTC")          # Expire old offers and save the collection if modified.          self.acquire_lock(user)         try:             l = self.get_freebusy(user, "freebusy-offers")             for fb in l:                 if fb.expires and get_datetime(fb.expires) <= now:                     expired.append(fb)                 else:                     offers.append(fb)              if expired:                 self.set_freebusy_offers(user, offers)         finally:             self.release_lock(user)          return offers      def set_freebusy_offers(self, user, freebusy):          "For the given 'user', set 'freebusy' offers."          return self.set_freebusy(user, freebusy, "freebusy-offers")      # Requests and counter-proposals.      def _get_requests(self, user, queue):          "Get requests for the given 'user' from the given 'queue'."          filename = self.get_object_in_store(user, queue)         if not filename or not exists(filename):             return None          return self._get_table_atomic(user, filename, [(1, None), (2, None)])      def get_requests(self, user):          "Get requests for the given 'user'."          return self._get_requests(user, "requests")      def _set_requests(self, user, requests, queue):          """         For the given 'user', set the list of queued 'requests' in the given         'queue'.         """          filename = self.get_object_in_store(user, queue)         if not filename:             return False          self._set_table_atomic(user, filename, requests, [(1, ""), (2, "")])         return True      def set_requests(self, user, requests):          "For the given 'user', set the list of queued 'requests'."          return self._set_requests(user, requests, "requests")      def _set_request(self, user, request, queue):          """         For the given 'user', set the given 'request' in the given 'queue'.         """          filename = self.get_object_in_store(user, queue)         if not filename:             return False          self.acquire_lock(user)         try:             f = codecs.open(filename, "ab", encoding="utf-8")             try:                 self._set_table_item(f, request, [(1, ""), (2, "")])             finally:                 f.close()                 fix_permissions(filename)         finally:             self.release_lock(user)          return True      def set_request(self, user, uid, recurrenceid=None, type=None):          """         For the given 'user', set the queued 'uid' and 'recurrenceid',         indicating a request, along with any given 'type'.         """          return self._set_request(user, (uid, recurrenceid, type), "requests")      def queue_request(self, user, uid, recurrenceid=None, type=None):          """         Queue a request for 'user' having the given 'uid'. If the optional         'recurrenceid' is specified, the entry refers to a specific instance         or occurrence of an event. The 'type' parameter can be used to indicate         a specific type of request.         """          requests = self.get_requests(user) or []          if not self.have_request(requests, uid, recurrenceid):             return self.set_request(user, uid, recurrenceid, type)          return False      def dequeue_request(self, user, uid, recurrenceid=None, type=None):          """         Dequeue all requests for 'user' having the given 'uid'. If the optional         'recurrenceid' is specified, all requests for that specific instance or         occurrence of an event are dequeued.         """          requests = self.get_requests(user) or []          if not self.have_request(requests, uid, recurrenceid):             return False          i = bisect_left(requests, (uid, recurrenceid))         while i < len(requests) and requests[i][:2] == (uid, recurrenceid):              # Remove associated objects.              type = requests[i][2]             if type == "COUNTER":                 self.remove_counter(user, uid, recurrenceid)              # Remove the request.              del requests[i]             i += 1          self.set_requests(user, requests)         return True      def have_request(self, requests, uid, recurrenceid=None):         i = bisect_left(requests, (uid, recurrenceid))         return i < len(requests) and requests[i][:2] == (uid, recurrenceid)      def set_counter(self, user, node, uid, recurrenceid=None):          """         For the given 'user', store the given 'node' for the given 'uid' and         'recurrenceid' as a counter-proposal.         """          filename = self.get_event_filename(user, uid, recurrenceid, "counters")         if not filename:             return False          return self._set_object(user, filename, node)      def remove_counter(self, user, uid, recurrenceid=None):          """         For the given 'user', remove any counter-proposal associated with the         given 'uid' and 'recurrenceid'.         """          filename = self.get_event_filename(user, uid, recurrenceid, "counters")         if not filename:             return False          return self._remove_object(filename)      # Event cancellation.      def cancel_event(self, user, uid, recurrenceid=None):          """         Cancel an event for 'user' having the given 'uid'. If the optional         'recurrenceid' is specified, a specific instance or occurrence of an         event is cancelled.         """          filename = self.get_event_filename(user, uid, recurrenceid)         cancelled_filename = self.get_event_filename(user, uid, recurrenceid, "cancellations")          if filename and cancelled_filename and exists(filename):             return self.move_object(filename, cancelled_filename)          return False  class FilePublisher(FileBase):      "A publisher of objects."      def __init__(self, store_dir=None):         FileBase.__init__(self, store_dir or PUBLISH_DIR)      def set_freebusy(self, user, freebusy):          "For the given 'user', set 'freebusy' details."          filename = self.get_object_in_store(user, "freebusy")         if not filename:             return False          record = []         rwrite = record.append          rwrite(("ORGANIZER", {}, user))         rwrite(("UID", {}, user))         rwrite(("DTSTAMP", {}, datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")))          for fb in freebusy:             if not fb.transp or fb.transp == "OPAQUE":                 rwrite(("FREEBUSY", {"FBTYPE" : "BUSY"}, "/".join(                     map(format_datetime, [fb.get_start_point(), fb.get_end_point()]))))          f = open(filename, "wb")         try:             to_stream(f, make_calendar([("VFREEBUSY", {}, record)], "PUBLISH"))         finally:             f.close()             fix_permissions(filename)          return True  # vim: tabstop=4 expandtab shiftwidth=4