path: root/rpki/sundial.py

# $Id$
#
# Copyright (C) 2009--2012  Internet Systems Consortium ("ISC")
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.
#
# Portions copyright (C) 2007--2008  American Registry for Internet Numbers ("ARIN")
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND ARIN DISCLAIMS ALL WARRANTIES WITH
# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS.  IN NO EVENT SHALL ARIN BE LIABLE FOR ANY SPECIAL, DIRECT,
# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
# PERFORMANCE OF THIS SOFTWARE.

"""
Unified RPKI date/time handling, based on the standard Python datetime module.

Module name chosen to sidestep a nightmare of import-related errors
that occur with the more obvious module names.

List of arithmetic methods that require result casting was derived by
inspection of the datetime module, to wit:

  >>> import datetime
  >>> for t in (datetime.datetime, datetime.timedelta):
  ...  for k in t.__dict__.keys():
  ...   if k.startswith("__"):
  ...    print "%s.%s()" % (t.__name__, k)
"""

import datetime as pydatetime
import re

def now():
    """
    Get current timestamp.
    """

    return datetime.utcnow()

class ParseFailure(Exception):
    """
    Parse failure constructing timedelta.
    """

class datetime(pydatetime.datetime):
    """
    RPKI extensions to standard datetime.datetime class.  All work here
    is in UTC, so we use naive datetime objects.
    """

    def totimestamp(self):
        """
        Convert to seconds from epoch (like time.time()).  Conversion
        method is a bit silly, but avoids time module timezone whackiness.
        """

        return int(self.strftime("%s"))

    @classmethod
    def fromXMLtime(cls, x):
        """
        Convert from XML time representation.
        """

        if x is None:
            return None
        else:
            return cls.strptime(x, "%Y-%m-%dT%H:%M:%SZ")

    def toXMLtime(self):
        """
        Convert to XML time representation.
        """

        return self.strftime("%Y-%m-%dT%H:%M:%SZ")

    def __str__(self):
        return self.toXMLtime()

    @classmethod
    def from_datetime(cls, x):
        """
        Convert a datetime.datetime object into this subclass.  This is
        whacky due to the weird constructors for datetime.
        """

        return cls.combine(x.date(), x.time())

    def to_datetime(self):
        """
        Convert to a datetime.datetime object.  In most cases this
        shouldn't be necessary, but convincing SQL interfaces to use
        subclasses of datetime can be hard.
        """

        return pydatetime.datetime(year = self.year, month = self.month, day = self.day,
                                   hour = self.hour, minute = self.minute, second = self.second,
                                   microsecond = 0, tzinfo = None)


    @classmethod
    def fromOpenSSL(cls, x):
        """
        Convert from the format OpenSSL's command line tool uses into this
        subclass.  May require rewriting if we run into locale problems.
        """

        if x.startswith("notBefore=") or x.startswith("notAfter="):
            x = x.partition("=")[2]
        return cls.strptime(x, "%b %d %H:%M:%S %Y GMT")

    @classmethod
    def from_sql(cls, x):
        """
        Convert from SQL storage format.
        """

        return cls.from_datetime(x)

    def to_sql(self):
        """
        Convert to SQL storage format.
        """

        return self.to_datetime()

    def later(self, other):
        """
        Return the later of two timestamps.
        """

        return other if other > self else self

    def earlier(self, other):
        """
        Return the earlier of two timestamps.
        """

        return other if other < self else self

    def __add__(self, y):
        return _cast(pydatetime.datetime.__add__(self, y))

    def __radd__(self, y):
        return _cast(pydatetime.datetime.__radd__(self, y))

    def __rsub__(self, y):
        return _cast(pydatetime.datetime.__rsub__(self, y))

    def __sub__(self, y):
        return _cast(pydatetime.datetime.__sub__(self, y))

    @classmethod
    def DateTime_or_None(cls, s):
        """
        MySQLdb converter.  Parse as this class if we can, let the default
        MySQLdb DateTime_or_None() converter deal with failure cases.
        """

        for sep in " T":
            d, _, t = s.partition(sep)        # pylint: disable=W0612
            if t:
                try:
                    return cls(*[int(x) for x in d.split("-") + t.split(":")])
                except:
                    break

        from rpki.mysql_import import MySQLdb
        return MySQLdb.times.DateTime_or_None(s)

class timedelta(pydatetime.timedelta):
    """
    Timedelta with text parsing.  This accepts two input formats:

    - A simple integer, indicating a number of seconds.

    - A string of the form "uY vW wD xH yM zS" where u, v, w, x, y, and z
      are integers and Y, W, D, H, M, and S indicate years, weeks, days,
      hours, minutes, and seconds.  All of the fields are optional, but
      at least one must be specified.  Eg,"3D4H" means "three days plus
      four hours".

    There is no "months" format, because the definition of a month is too
    fuzzy to be useful (what day is six months from August 30th?)

    Similarly, the "years" conversion may produce surprising results, as
    "one year" in conventional English does not refer to a fixed interval
    but rather a fixed (and in some cases undefined) offset within the
    Gregorian calendar (what day is one year from February 29th?)  1Y as
    implemented by this code refers to a specific number of seconds.
    If you mean 365 days or 52 weeks, say that instead.
    """

    ## @var regexp
    # Hideously ugly regular expression to parse the complex text form.
    # Tags are intended for use with re.MatchObject.groupdict() and map
    # directly to the keywords expected by the timedelta constructor.

    regexp = re.compile("\\s*".join(("^",
                                     "(?:(?P<years>\\d+)Y)?",
                                     "(?:(?P<weeks>\\d+)W)?",
                                     "(?:(?P<days>\\d+)D)?",
                                     "(?:(?P<hours>\\d+)H)?",
                                     "(?:(?P<minutes>\\d+)M)?",
                                     "(?:(?P<seconds>\\d+)S)?",
                                     "$")),
                        re.I)

    ## @var years_to_seconds
    # Conversion factor from years to seconds (value furnished by the
    # "units" program).

    years_to_seconds = 31556926

    @classmethod
    def parse(cls, arg):
        """
        Parse text into a timedelta object.
        """

        if not isinstance(arg, str):
            return cls(seconds = arg)
        elif arg.isdigit():
            return cls(seconds = int(arg))
        else:
            match = cls.regexp.match(arg)
            if match:
                #return cls(**dict((k, int(v)) for (k, v) in match.groupdict().items() if v is not None))
                d = match.groupdict("0")
                for k, v in d.iteritems():
                    d[k] = int(v)
                d["days"]    += d.pop("weeks") * 7
                d["seconds"] += d.pop("years") * cls.years_to_seconds
                return cls(**d)
            else:
                raise ParseFailure("Couldn't parse timedelta %r" % (arg,))

    def convert_to_seconds(self):
        """
        Convert a timedelta interval to seconds.
        """

        return self.days * 24 * 60 * 60 + self.seconds

    @classmethod
    def fromtimedelta(cls, x):
        """
        Convert a datetime.timedelta object into this subclass.
        """

        return cls(days = x.days, seconds = x.seconds, microseconds = x.microseconds)

    def __abs__(self):
        return _cast(pydatetime.timedelta.__abs__(self))

    def __add__(self, x):
        return _cast(pydatetime.timedelta.__add__(self, x))

    def __div__(self, x):
        return _cast(pydatetime.timedelta.__div__(self, x))

    def __floordiv__(self, x):
        return _cast(pydatetime.timedelta.__floordiv__(self, x))

    def __mul__(self, x):
        return _cast(pydatetime.timedelta.__mul__(self, x))

    def __neg__(self):
        return _cast(pydatetime.timedelta.__neg__(self))

    def __pos__(self):
        return _cast(pydatetime.timedelta.__pos__(self))

    def __radd__(self, x):
        return _cast(pydatetime.timedelta.__radd__(self, x))

    def __rdiv__(self, x):
        return _cast(pydatetime.timedelta.__rdiv__(self, x))

    def __rfloordiv__(self, x):
        return _cast(pydatetime.timedelta.__rfloordiv__(self, x))

    def __rmul__(self, x):
        return _cast(pydatetime.timedelta.__rmul__(self, x))

    def __rsub__(self, x):
        return _cast(pydatetime.timedelta.__rsub__(self, x))

    def __sub__(self, x):
        return _cast(pydatetime.timedelta.__sub__(self, x))

def _cast(x):
    """
    Cast result of arithmetic operations back into correct subtype.
    """

    if isinstance(x, pydatetime.datetime):
        return datetime.from_datetime(x)
    if isinstance(x, pydatetime.timedelta):
        return timedelta.fromtimedelta(x)
    return x

if __name__ == "__main__":

    def test(t):
        print
        print "str:                ", t
        print "repr:               ", repr(t)
        print "seconds since epoch:", t.strftime("%s")
        print "XMLtime:            ", t.toXMLtime()
        print

    print
    print "Testing time conversion routines"
    test(now())
    test(now() + timedelta(days = 30))
    test(now() + timedelta.parse("3d5s"))
    test(now() + timedelta.parse(" 3d 5s "))
    test(now() + timedelta.parse("1y3d5h"))