#!/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 datetime import datetime from imiptools.config import STORE_DIR, PUBLISH_DIR from imiptools.data import make_calendar, parse_object, to_stream 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=STORE_DIR):         FileBase.__init__(self, 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)      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.         """          self.acquire_lock(user)         try:             f = codecs.open(filename, "rb", encoding="utf-8")             try:                 l = []                 for line in f.readlines():                     t = line.strip().split("\t")                     if empty_defaults:                         t = self._set_defaults(t, empty_defaults)                     l.append(tuple(t))                 return l             finally:                 f.close()         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.         """          self.acquire_lock(user)         try:             f = codecs.open(filename, "wb", encoding="utf-8")             try:                 for item in items:                     if empty_defaults:                         item = self._set_defaults(list(item), empty_defaults)                     f.write("\t".join(item) + "\n")             finally:                 f.close()                 fix_permissions(filename)         finally:             self.release_lock(user)      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      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_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.         """          if recurrenceid:             return self.get_recurrence(user, uid, recurrenceid)         else:             return self.get_complete_event(user, uid)      def get_complete_event(self, user, uid):          "Get the event for the given 'user' with the given 'uid'."          filename = self.get_object_in_store(user, "objects", uid)         if not filename or not exists(filename):             return None          return 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'.         """          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_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_object_in_store(user, "recurrences", uid, recurrenceid)         if not filename or not exists(filename):             return None          return 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      def get_freebusy(self, user):          "Get free/busy details for the given 'user'."          filename = self.get_object_in_store(user, "freebusy")         if not filename or not exists(filename):             return []         else:             return map(lambda t: FreeBusyPeriod(*t), self._get_table(user, filename, [(4, None)]))      def get_freebusy_for_other(self, user, other):          "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), self._get_table(user, filename, [(4, None)]))      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          self._set_table(user, filename, map(lambda fb: fb.as_tuple(), freebusy),             [(3, "OPAQUE"), (4, "")])         return True      def set_freebusy_for_other(self, user, freebusy, other):          "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          self._set_table(user, filename, map(lambda fb: fb.as_tuple(), freebusy),             [(2, ""), (3, "OPAQUE"), (4, ""), (5, ""), (6, "")])         return True      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(user, filename, [(1, None)])      def get_requests(self, user):          "Get requests for the given 'user'."          return self._get_requests(user, "requests")      def get_cancellations(self, user):          "Get cancellations for the given 'user'."          return self._get_requests(user, "cancellations")      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.acquire_lock(user)         try:             f = open(filename, "w")             try:                 for request in requests:                     print >>f, "\t".join([value or "" for value in request])             finally:                 f.close()                 fix_permissions(filename)         finally:             self.release_lock(user)          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_cancellations(self, user, cancellations):          "For the given 'user', set the list of queued 'cancellations'."          return self._set_requests(user, cancellations, "cancellations")      def _set_request(self, user, uid, recurrenceid, queue):          """         For the given 'user', set the queued 'uid' and 'recurrenceid' in the         given 'queue'.         """          filename = self.get_object_in_store(user, queue)         if not filename:             return False          self.acquire_lock(user)         try:             f = open(filename, "a")             try:                 print >>f, "\t".join([uid, recurrenceid or ""])             finally:                 f.close()                 fix_permissions(filename)         finally:             self.release_lock(user)          return True      def set_request(self, user, uid, recurrenceid=None):          "For the given 'user', set the queued 'uid' and 'recurrenceid'."          return self._set_request(user, uid, recurrenceid, "requests")      def set_cancellation(self, user, uid, recurrenceid=None):          "For the given 'user', set the queued 'uid' and 'recurrenceid'."          return self._set_request(user, uid, recurrenceid, "cancellations")      def queue_request(self, user, uid, recurrenceid=None):          """         Queue a request for 'user' having the given 'uid'. If the optional         'recurrenceid' is specified, the request refers to a specific instance         or occurrence of an event.         """          requests = self.get_requests(user) or []          if (uid, recurrenceid) not in requests:             return self.set_request(user, uid, recurrenceid)          return False      def dequeue_request(self, user, uid, recurrenceid=None):          """         Dequeue a request for 'user' having the given 'uid'. If the optional         'recurrenceid' is specified, the request refers to a specific instance         or occurrence of an event.         """          requests = self.get_requests(user) or []          try:             requests.remove((uid, recurrenceid))             self.set_requests(user, requests)         except ValueError:             return False         else:             return True      def cancel_event(self, user, uid, recurrenceid=None):          """         Queue an event for cancellation for 'user' having the given 'uid'. If         the optional 'recurrenceid' is specified, a specific instance or         occurrence of an event is cancelled.         """          cancellations = self.get_cancellations(user) or []          if (uid, recurrenceid) not in cancellations:             return self.set_cancellation(user, uid, recurrenceid)          return False  class FilePublisher(FileBase):      "A publisher of objects."      def __init__(self, store_dir=PUBLISH_DIR):         FileBase.__init__(self, store_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([fb.start, fb.end])))          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