def test_calendar_query_bogus_timezone_id(self): """ Partial retrieval of events by time range. (CalDAV-access-09, section 7.6.1) """ TimezoneCache.create() self.addCleanup(TimezoneCache.clear) calendar_properties = ( davxml.GETETag(), caldavxml.CalendarData(), ) query_timerange = caldavxml.TimeRange( start="%04d1001T000000Z" % (DateTime.getToday().getYear(), ), end="%04d1101T000000Z" % (DateTime.getToday().getYear(), ), ) query = caldavxml.CalendarQuery( davxml.PropertyContainer(*calendar_properties), caldavxml.Filter( caldavxml.ComponentFilter( caldavxml.ComponentFilter( query_timerange, name="VEVENT", ), name="VCALENDAR", ), ), caldavxml.TimeZoneID.fromString("bogus"), ) result = yield self.calendar_query( query, got_xml=None, expected_code=responsecode.FORBIDDEN) self.assertTrue("valid-timezone" in result)
def __init__(self, store, options, output, reactor, config): super(PodMigrationService, self).__init__(store) self.options = options self.output = output self.reactor = reactor self.config = config TimezoneCache.create()
def test_copyPackage(self): """ Test that copying of the tz package works. """ self.patch(config, "UsePackageTimezones", True) TimezoneCache.clear() TimezoneCache.create() self.assertFalse( os.path.exists(os.path.join(config.DataRoot, "zoneinfo"))) self.assertFalse( os.path.exists( os.path.join(config.DataRoot, "zoneinfo", "America", "New_York.ics"))) pkg_tz = readTZ("America/New_York") self.patch(config, "UsePackageTimezones", False) TimezoneCache.clear() TimezoneCache.create() self.assertTrue( os.path.exists(os.path.join(config.DataRoot, "zoneinfo"))) self.assertTrue( os.path.exists( os.path.join(config.DataRoot, "zoneinfo", "America", "New_York.ics"))) copy_tz = readTZ("America/New_York") self.assertEqual(str(pkg_tz), str(copy_tz))
def test_calendar_query_bogus_timezone_id(self): """ Partial retrieval of events by time range. (CalDAV-access-09, section 7.6.1) """ TimezoneCache.create() self.addCleanup(TimezoneCache.clear) calendar_properties = ( davxml.GETETag(), caldavxml.CalendarData(), ) query_timerange = caldavxml.TimeRange( start="%04d1001T000000Z" % (DateTime.getToday().getYear(),), end="%04d1101T000000Z" % (DateTime.getToday().getYear(),), ) query = caldavxml.CalendarQuery( davxml.PropertyContainer(*calendar_properties), caldavxml.Filter( caldavxml.ComponentFilter( caldavxml.ComponentFilter( query_timerange, name="VEVENT", ), name="VCALENDAR", ), ), caldavxml.TimeZoneID.fromString("bogus"), ) result = yield self.calendar_query(query, got_xml=None, expected_code=responsecode.FORBIDDEN) self.assertTrue("valid-timezone" in result)
def __init__(self, records, populator, random, parameters, reactor, servers, principalPathTemplate, serializationPath, workerIndex=0, workerCount=1): self._records = records self.populator = populator self._random = random self.reactor = reactor self.servers = servers self.principalPathTemplate = principalPathTemplate self.serializationPath = serializationPath self._pop = self.populator.populate(parameters) self._user = 0 self._stopped = False self.workerIndex = workerIndex self.workerCount = workerCount self.clients = [] TimezoneCache.create()
def __init__(self, store, options, reactor, config): super(ImporterService, self).__init__(store) self.options = options self.reactor = reactor self.config = config self._directory = self.store.directoryService() TimezoneCache.create()
def _calendarTimezoneUpgrade_setup(self): TimezoneCache.create() self.addCleanup(TimezoneCache.clear) tz1 = Component(None, pycalendar=readVTZ("Etc/GMT+1")) tz2 = Component(None, pycalendar=readVTZ("Etc/GMT+2")) tz3 = Component(None, pycalendar=readVTZ("Etc/GMT+3")) # Share user01 calendar with user03 calendar = (yield self.calendarUnderTest(name="calendar_1", home="user01")) home3 = yield self.homeUnderTest(name="user03") shared_name = yield calendar.shareWith(home3, _BIND_MODE_WRITE) user_details = ( ("user01", "calendar_1", tz1), ("user02", "calendar_1", tz2), ("user03", "calendar_1", None), ("user03", shared_name, tz3), ) # Set dead properties on calendars for user, calname, tz in user_details: calendar = (yield self.calendarUnderTest(name=calname, home=user)) if tz: calendar.properties()[PropertyName.fromElement(caldavxml.CalendarTimeZone)] = caldavxml.CalendarTimeZone.fromString(str(tz)) # Force data version to previous home = (yield self.homeUnderTest(name=user)) ch = home._homeSchema yield Update( {ch.DATAVERSION: 4}, Where=ch.RESOURCE_ID == home._resourceID, ).on(self.transactionUnderTest()) yield self.commit() for user, calname, tz in user_details: calendar = (yield self.calendarUnderTest(name=calname, home=user)) self.assertEqual(calendar.getTimezone(), None) self.assertEqual(PropertyName.fromElement(caldavxml.CalendarTimeZone) in calendar.properties(), tz is not None) yield self.commit() # Create "fake" entry for non-existent share txn = self.transactionUnderTest() calendar = (yield self.calendarUnderTest(name="calendar_1", home="user01")) rp = schema.RESOURCE_PROPERTY yield Insert( { rp.RESOURCE_ID: calendar._resourceID, rp.NAME: PropertyName.fromElement(caldavxml.CalendarTimeZone).toString(), rp.VALUE: caldavxml.CalendarTimeZone.fromString(str(tz3)).toxml(), rp.VIEWER_UID: "user04", } ).on(txn) yield self.commit() returnValue(user_details)
def test_truncatedDec(self): """ Custom VTZ valid from 2007. Daylight 2007 OK. """ TimezoneCache.create(empty=True) TimezoneCache.clear() self.doTest("TruncatedDec10.ics", DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone), DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone))
def test_truncatedApr(self): """ Custom VTZ with truncated standard time - 2006. Daylight 2007 OK. """ TimezoneCache.create(empty=True) TimezoneCache.clear() self.doTest("TruncatedApr01.ics", DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone), DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone))
def test_truncatedDec(self): """ Properties in components """ TimezoneCache.create("") TimezoneCache.clear() self.doTest( "TruncatedDec10.ics", PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)) )
def test_truncatedDec(self): """ Custom VTZ valid from 2007. Daylight 2007 OK. """ TimezoneCache.create(empty=True) TimezoneCache.clear() self.doTest( "TruncatedDec10.ics", PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)) )
def test_truncatedApr(self): """ Custom VTZ with truncated standard time - 2006. Daylight 2007 OK. """ TimezoneCache.create(empty=True) TimezoneCache.clear() self.doTest( "TruncatedApr01.ics", PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)) )
def test_truncatedApr(self): """ Properties in components """ TimezoneCache.create("") TimezoneCache.clear() self.doTest( "TruncatedApr01.ics", PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)) )
def test_truncatedDecThenApr(self): """ Custom VTZ valid from 2007 loaded first. Daylight 2007 OK. """ TimezoneCache.create(empty=True) TimezoneCache.clear() self.doTest("TruncatedDec10.ics", DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone), DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone)) self.doTest("TruncatedApr01.ics", DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone), DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone))
def test_truncatedAprThenDecOK(self): """ Properties in components """ TimezoneCache.create() self.doTest( "TruncatedApr01.ics", PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)), ) self.doTest( "TruncatedDec10.ics", PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)), )
def __init__(self, records, populator, parameters, reactor, server, principalPathTemplate, serializationPath, workerIndex=0, workerCount=1): self._records = records self.populator = populator self.reactor = reactor self.server = server self.principalPathTemplate = principalPathTemplate self.serializationPath = serializationPath self._pop = self.populator.populate(parameters) self._user = 0 self._stopped = False self.workerIndex = workerIndex self.workerCount = workerCount self.clients = [] TimezoneCache.create()
def test_copyPackage_missingVersion(self): """ Test that tz data is updated if the version is missing. """ self.patch(config, "UsePackageTimezones", False) TimezoneCache.clear() TimezoneCache.create() self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo"))) self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "version.txt"))) os.remove(os.path.join(config.DataRoot, "zoneinfo", "version.txt")) self.assertFalse(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "version.txt"))) TimezoneCache.create() self.assertTrue(os.path.exists(os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
def test_not_in_cache(self): TimezoneCache.create() data = """BEGIN:VCALENDAR VERSION:2.0 BEGIN:VTIMEZONE TZID:US-Eastern LAST-MODIFIED:19870101T000000Z BEGIN:STANDARD DTSTART:19671029T020000 RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10 TZOFFSETFROM:-0400 TZOFFSETTO:-0500 TZNAME:Eastern Standard Time (US & Canada) END:STANDARD BEGIN:DAYLIGHT DTSTART:19870405T020000 RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4 TZOFFSETFROM:-0500 TZOFFSETTO:-0400 TZNAME:Eastern Daylight Time (US & Canada) END:DAYLIGHT END:VTIMEZONE BEGIN:VEVENT UID:12345-67890 DTSTART;TZID="US-Eastern":20071225T000000 DTEND;TZID="US-Eastern":20071225T010000 ATTENDEE:mailto:[email protected] ATTENDEE:mailto:[email protected] END:VEVENT END:VCALENDAR """ calendar = Component.fromString(data) if calendar.name() != "VCALENDAR": self.fail("Calendar is not a VCALENDAR") instances = calendar.expandTimeRanges(DateTime(2100, 1, 1)) for key in instances: instance = instances[key] start = instance.start end = instance.end self.assertEqual( start, DateTime(2007, 12, 25, 05, 0, 0, Timezone.UTCTimezone)) self.assertEqual( end, DateTime(2007, 12, 25, 06, 0, 0, Timezone.UTCTimezone)) break
def test_truncatedAprThenDecFail(self): """ Custom VTZ with truncated standard time - 2006 loaded first. Daylight 2007 OK, standard 2007 wrong. """ TimezoneCache.create(empty=True) TimezoneCache.clear() self.doTest( "TruncatedApr01.ics", DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone), DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone), ) self.doTest("TruncatedDec10.ics", DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone), DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone), testEqual=False)
def test_truncatedAprThenDecOK(self): """ VTZ loaded from std timezone DB. 2007 OK. """ TimezoneCache.create() self.doTest( "TruncatedApr01.ics", DateTime(2007, 04, 01, 16, 0, 0, Timezone.UTCTimezone), DateTime(2007, 04, 01, 17, 0, 0, Timezone.UTCTimezone), ) self.doTest( "TruncatedDec10.ics", DateTime(2007, 12, 10, 17, 0, 0, Timezone.UTCTimezone), DateTime(2007, 12, 10, 18, 0, 0, Timezone.UTCTimezone), )
def test_truncatedAprThenDecOK(self): """ VTZ loaded from std timezone DB. 2007 OK. """ TimezoneCache.create() self.doTest( "TruncatedApr01.ics", PyCalendarDateTime(2007, 04, 01, 16, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 04, 01, 17, 0, 0, PyCalendarTimezone(utc=True)), ) self.doTest( "TruncatedDec10.ics", PyCalendarDateTime(2007, 12, 10, 17, 0, 0, PyCalendarTimezone(utc=True)), PyCalendarDateTime(2007, 12, 10, 18, 0, 0, PyCalendarTimezone(utc=True)), )
def test_calendar_query_timezone(self): """ Partial retrieval of events by time range. (CalDAV-access-09, section 7.6.1) """ TimezoneCache.create() self.addCleanup(TimezoneCache.clear) tzid1 = "Etc/GMT+1" tz1 = Component(None, pycalendar=readVTZ(tzid1)) calendar_properties = ( davxml.GETETag(), caldavxml.CalendarData(), ) query_timerange = caldavxml.TimeRange( start="%04d1001T000000Z" % (DateTime.getToday().getYear(), ), end="%04d1101T000000Z" % (DateTime.getToday().getYear(), ), ) query = caldavxml.CalendarQuery( davxml.PropertyContainer(*calendar_properties), caldavxml.Filter( caldavxml.ComponentFilter( caldavxml.ComponentFilter( query_timerange, name="VEVENT", ), name="VCALENDAR", ), ), caldavxml.TimeZone.fromCalendar(tz1), ) def got_xml(doc): if not isinstance(doc.root_element, davxml.MultiStatus): self.fail( "REPORT response XML root element is not multistatus: %r" % (doc.root_element, )) return self.calendar_query(query, got_xml)
def test_calendar_query_wrong_timezone_elements(self): """ Partial retrieval of events by time range. (CalDAV-access-09, section 7.6.1) """ TimezoneCache.create() self.addCleanup(TimezoneCache.clear) tzid1 = "Etc/GMT+1" tz1 = Component(None, pycalendar=readVTZ(tzid1)) calendar_properties = ( davxml.GETETag(), caldavxml.CalendarData(), ) query_timerange = caldavxml.TimeRange( start="%04d1001T000000Z" % (DateTime.getToday().getYear(), ), end="%04d1101T000000Z" % (DateTime.getToday().getYear(), ), ) query = caldavxml.CalendarQuery( davxml.PropertyContainer(*calendar_properties), caldavxml.Filter( caldavxml.ComponentFilter( caldavxml.ComponentFilter( query_timerange, name="VEVENT", ), name="VCALENDAR", ), ), caldavxml.TimeZone.fromCalendar(tz1), ) query.children += (caldavxml.TimeZoneID.fromString(tzid1), ) result = yield self.calendar_query( query, got_xml=None, expected_code=responsecode.BAD_REQUEST) self.assertTrue("Only one of" in result)
def test_copyPackage_missingVersion(self): """ Test that tz data is updated if the version is missing. """ self.patch(config, "UsePackageTimezones", False) TimezoneCache.clear() TimezoneCache.create() self.assertTrue( os.path.exists(os.path.join(config.DataRoot, "zoneinfo"))) self.assertTrue( os.path.exists( os.path.join(config.DataRoot, "zoneinfo", "version.txt"))) os.remove(os.path.join(config.DataRoot, "zoneinfo", "version.txt")) self.assertFalse( os.path.exists( os.path.join(config.DataRoot, "zoneinfo", "version.txt"))) TimezoneCache.create() self.assertTrue( os.path.exists( os.path.join(config.DataRoot, "zoneinfo", "version.txt")))
def _calendarTimezoneUpgrade_setup(self): TimezoneCache.create() self.addCleanup(TimezoneCache.clear) tz1 = Component(None, pycalendar=readVTZ("Etc/GMT+1")) tz2 = Component(None, pycalendar=readVTZ("Etc/GMT+2")) tz3 = Component(None, pycalendar=readVTZ("Etc/GMT+3")) # Share user01 calendar with user03 calendar = (yield self.calendarUnderTest(name="calendar_1", home="user01")) home3 = yield self.homeUnderTest(name="user03") shared_name = yield calendar.shareWith(home3, _BIND_MODE_WRITE) user_details = ( ("user01", "calendar_1", tz1), ("user02", "calendar_1", tz2), ("user03", "calendar_1", None), ("user03", shared_name, tz3), ) # Set dead properties on calendars for user, calname, tz in user_details: calendar = (yield self.calendarUnderTest(name=calname, home=user)) if tz: calendar.properties()[PropertyName.fromElement( caldavxml.CalendarTimeZone )] = caldavxml.CalendarTimeZone.fromString(str(tz)) # Force data version to previous home = (yield self.homeUnderTest(name=user)) ch = home._homeSchema yield Update( { ch.DATAVERSION: 4 }, Where=ch.RESOURCE_ID == home._resourceID, ).on(self.transactionUnderTest()) yield self.commit() for user, calname, tz in user_details: calendar = (yield self.calendarUnderTest(name=calname, home=user)) self.assertEqual(calendar.getTimezone(), None) self.assertEqual( PropertyName.fromElement(caldavxml.CalendarTimeZone) in calendar.properties(), tz is not None) yield self.commit() # Create "fake" entry for non-existent share txn = self.transactionUnderTest() calendar = (yield self.calendarUnderTest(name="calendar_1", home="user01")) rp = schema.RESOURCE_PROPERTY yield Insert({ rp.RESOURCE_ID: calendar._resourceID, rp.NAME: PropertyName.fromElement(caldavxml.CalendarTimeZone).toString(), rp.VALUE: caldavxml.CalendarTimeZone.fromString(str(tz3)).toxml(), rp.VIEWER_UID: "user04", }).on(txn) yield self.commit() returnValue(user_details)
for urlpiece in urlbits[:-1]: child = parent.getChild(urlpiece) if child is None: child = Resource() parent.putChild(urlpiece, child) parent = child if parent.getChild(urlbits[-1]) is not None: log.error("Invalid alias: URL: {url} Path: {path} already exists", url=url, path=path) continue resource = FileResource(path) parent.putChild(urlbits[-1], resource) log.info("Added alias {url} -> {path}", url=url, path=path) # Need timezone cache before setting up any timezone service log.info("Setting up Timezone Cache") TimezoneCache.create() # Timezone service is optional if config.EnableTimezoneService: log.info("Setting up time zone service resource: {cls}", cls=timezoneServiceResourceClass) timezoneService = timezoneServiceResourceClass( root, ) root.putChild("timezones", timezoneService) # Standard Timezone service is optional if config.TimezoneService.Enabled: log.info("Setting up standard time zone service resource: {cls}", cls=timezoneStdServiceResourceClass)
def utilityMain( configFileName, serviceClass, reactor=None, serviceMaker=None, patchConfig=None, onShutdown=None, verbose=False, loadTimezones=False ): """ Shared main-point for utilities. This function will: - Load the configuration file named by C{configFileName}, - launch a L{CalDAVServiceMaker}'s with the C{ProcessType} of C{"Utility"} - run the reactor, with start/stop events hooked up to the service's C{startService}/C{stopService} methods. It is C{serviceClass}'s responsibility to stop the reactor when it's complete. @param configFileName: the name of the configuration file to load. @type configuration: C{str} @param serviceClass: a 1-argument callable which takes an object that provides L{ICalendarStore} and/or L{IAddressbookStore} and returns an L{IService}. @param patchConfig: a 1-argument callable which takes a config object and makes and changes necessary for the tool. @param onShutdown: a 0-argument callable which will run on shutdown. @param reactor: if specified, the L{IReactorTime} / L{IReactorThreads} / L{IReactorTCP} (etc) provider to use. If C{None}, the default reactor will be imported and used. """ from calendarserver.tap.caldav import CalDAVServiceMaker, CalDAVOptions if serviceMaker is None: serviceMaker = CalDAVServiceMaker # We want to validate that the actual service is always an instance of WorkerService, so wrap the # service maker callback inside a function that does that check def _makeValidService(store): service = serviceClass(store) assert isinstance(service, WorkerService) return service # Install std i/o observer observers = [] if verbose: observers.append(FileLogObserver(sys.stdout, lambda event: formatEventAsClassicLogText(event))) if reactor is None: from twisted.internet import reactor try: config = loadConfig(configFileName) if patchConfig is not None: patchConfig(config) checkDirectories(config) utilityLogFile = LogFile.fromFullPath( config.UtilityLogFile, rotateLength=config.ErrorLogRotateMB * 1024 * 1024, maxRotatedFiles=config.ErrorLogMaxRotatedFiles ) utilityLogObserver = FileLogObserver(utilityLogFile, lambda event: formatEventAsClassicLogText(event)) utilityLogObserver._encoding = "utf-8" observers.append(utilityLogObserver) Logger.beginLoggingTo(observers, redirectStandardIO=False) config.ProcessType = "Utility" config.UtilityServiceClass = _makeValidService autoDisableMemcached(config) maker = serviceMaker() # Only perform post-import duties if someone has explicitly said to maker.doPostImport = getattr(maker, "doPostImport", False) options = CalDAVOptions service = maker.makeService(options) reactor.addSystemEventTrigger("during", "startup", service.startService) reactor.addSystemEventTrigger("before", "shutdown", service.stopService) if onShutdown is not None: reactor.addSystemEventTrigger("before", "shutdown", onShutdown) if loadTimezones: TimezoneCache.create() except (ConfigurationError, OSError), e: sys.stderr.write("Error: %s\n" % (e,)) return
def setUp(self): super(TestQueryFilter, self).setUp() TimezoneCache.create()
def tearDown(self): TimezoneCache.clear() TimezoneCache.create()
def _try(n): try: TimezoneCache.create() except: f = Failure() ex[n] = str(f)
def setUp(self): super(Dateops, self).setUp() TimezoneCache.create()
def setUp(self): super(TimezonePackageTest, self).setUp() TimezoneCache.clear() TimezoneCache.create()
def setUp(self): super(LocalizationTests, self).setUp() TimezoneCache.create()
def test_basic(self): TimezoneCache.create() self.assertTrue(readTZ("America/New_York")) self.assertTrue(readTZ("US/Eastern"))
def setUp(self): TimezoneCache.create()