#!/usr/bin/env python  """ Quota-related scheduling functionality.  Copyright (C) 2016 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 imiptools.dates import get_duration, to_utc_datetime from imiptools.data import get_uri from imiptools.period import Endless from datetime import timedelta  # Quota maintenance.  def check_quota(handler, args):      """     Check the current object of the given 'handler' against the applicable     quota.     """      quota, group = _get_quota_and_group(handler, args)      # Obtain the journal entries and check the balance.      journal = handler.get_journal()     entries = journal.get_entries(quota, group)     limits = journal.get_limits(quota)      # Obtain a limit for the group or any general limit.     # Decline invitations if no limit has been set.      limit = limits.get(group) or limits.get("*")     if not limit:         return "DECLINED"      # Decline events whose durations exceed the balance.      total = _get_duration(handler)      if total == Endless():         return "DECLINED"      balance = get_duration(limit) - _get_usage(entries)      if total > balance:         return "DECLINED"     else:         return "ACCEPTED"  def add_to_quota(handler, args):      """     Record details of the current object of the given 'handler' in the     applicable quota.     """      quota, group = _get_quota_and_group(handler, args)      total = _get_duration(handler)     expiry = _get_expiry_time(handler)      # Reject indefinitely recurring events.      if total == Endless() or not expiry:         return      # Update the journal entries.      journal = handler.get_journal()     entries = journal.get_entries_for_update(quota, group)     handler.update_freebusy(entries, group, False)     journal.set_entries(quota, group, entries)  def remove_from_quota(handler, args):      """     Remove details of the current object of the given 'handler' from the     applicable quota.     """      quota, group = _get_quota_and_group(handler, args)      total = _get_duration(handler)      # Allow indefinitely recurring events.      if total == Endless():         total = None      # Update the journal entries.      journal = handler.get_journal()     entries = journal.get_entries_for_update(quota, group)     handler.remove_from_freebusy(entries)     journal.set_entries(quota, group, entries)  def _get_quota_and_group(handler, args):      """     Combine information about the current object from the 'handler' with the     given 'args' to return a tuple containing the quota group and the user     identity or group involved.     """      quota = args and args[0] or handler.user      # Obtain the identity to whom the quota will apply.      organiser = get_uri(handler.obj.get_value("ORGANIZER"))      # Obtain any user group to which the quota will apply instead.      journal = handler.get_journal()     groups = journal.get_groups(quota)      return quota, groups.get(organiser) or organiser  def _get_duration(handler):      "Return the duration of the current object provided by the 'handler'."      # Reject indefinitely recurring events.      if handler.obj.possibly_recurring_indefinitely():         return Endless()      # Otherwise, return a sum of the period durations.      total = timedelta(0)      for period in handler.get_periods(handler.obj):         duration = period.get_duration()          # Decline events whose period durations are endless.          if duration == Endless():             return duration         else:             total += duration      return total  def _get_expiry_time(handler):      """     Return the expiry time for quota purposes of the current object provided by     the 'handler'.     """      # Reject indefinitely recurring events.      if handler.obj.possibly_recurring_indefinitely():         return None      periods = handler.get_periods(handler.obj)     return periods and to_utc_datetime(periods[-1].get_end_point()) or None  def _get_usage(entries):      "Return the usage total according to the given 'entries'."      total = timedelta(0)     for period in entries:         total += period.get_duration()     return total  # Collective free/busy maintenance.  def schedule_across_quota(handler, args):      """     Check the current object of the given 'handler' against the schedules     managed by the quota.     """      quota, organiser = _get_quota_and_identity(handler, args)      # If newer than any old version, discard old details from the     # free/busy record and check for suitability.      periods = handler.get_periods(handler.obj)     freebusy = handler.get_journal().get_freebusy(quota, organiser)     scheduled = handler.can_schedule(freebusy, periods)      return scheduled and "ACCEPTED" or "DECLINED"  def add_to_quota_freebusy(handler, args):      """     Record details of the current object of the 'handler' in the applicable     free/busy resource.     """      quota, organiser = _get_quota_and_identity(handler, args)      journal = handler.get_journal()     freebusy = journal.get_freebusy_for_update(quota, organiser)     handler.update_freebusy(freebusy, organiser, True)     journal.set_freebusy(quota, organiser, freebusy)  def remove_from_quota_freebusy(handler, args):      """     Remove details of the current object of the 'handler' from the applicable     free/busy resource.     """      quota, organiser = _get_quota_and_identity(handler, args)      journal = handler.get_journal()     freebusy = journal.get_freebusy_for_update(quota, organiser)     handler.remove_from_freebusy(freebusy)     journal.set_freebusy(quota, organiser, freebusy)  def _get_quota_and_identity(handler, args):      """     Combine information about the current object from the 'handler' with the     given 'args' to return a tuple containing the quota group and the user     identity involved.     """      quota = args and args[0] or handler.user      # Obtain the identity for whom the scheduling will apply.      organiser = get_uri(handler.obj.get_value("ORGANIZER"))      return quota, organiser  # Locking and unlocking.  def lock_journal(handler, args):      "Using the 'handler' and 'args', lock the journal for the quota."      handler.get_journal().acquire_lock(_get_quota(handler, args))  def unlock_journal(handler, args):      "Using the 'handler' and 'args', unlock the journal for the quota."      handler.get_journal().release_lock(_get_quota(handler, args))  def _get_quota(handler, args):      "Return the quota using the 'handler' and 'args'."      return args and args[0] or handler.user  # Registry of scheduling functions.  scheduling_functions = {     "check_quota" : check_quota,     "schedule_across_quota" : schedule_across_quota,     }  # Registries of locking and unlocking functions.  locking_functions = {     "check_quota" : lock_journal,     "schedule_across_quota" : lock_journal,     }  unlocking_functions = {     "check_quota" : unlock_journal,     "schedule_across_quota" : unlock_journal,     }  # Registries of listener functions.  confirmation_functions = {     "check_quota" : add_to_quota,     "schedule_across_quota" : add_to_quota_freebusy,     }  retraction_functions = {     "check_quota" : remove_from_quota,     "schedule_across_quota" : remove_from_quota_freebusy,     }  # vim: tabstop=4 expandtab shiftwidth=4