def test_nonAsciiLog(self): """ Make sure that the file based error log can write non ascii data """ logpath = self.mktemp() service = ErrorLoggingMultiService( True, logpath, 10000, 10, False, ) app = Application("non-ascii") service.setServiceParent(app) observer = app.getComponent(ILogObserver, None) self.assertTrue(observer is not None) log = Logger(observer=observer) log.error(u"Couldn\u2019t be wrong") with open(logpath) as f: logentry = f.read() self.assertIn("Couldn\xe2\x80\x99t be wrong", logentry)
log.error(msg) if not ignoreIPLookupFailures: raise ValueError(msg) else: actual_ips.update(ips) else: actual_ips.add(item) self.allowed_from_ips = actual_ips for uri in self.partitions.values(): parsed_uri = urlparse.urlparse(uri) try: ips = getIPsFromHost(parsed_uri.hostname) except socket.gaierror, e: msg = "Unable to lookup ip-addr for partition '%s': %s" % (parsed_uri.hostname, str(e)) log.error(msg) if ignoreIPLookupFailures: ips = () else: raise ValueError(msg) self.partitions_ips.update(ips) def checkThisIP(self, ip): """ Check that the passed in IP address corresponds to this server or one of its partitions. """ return (ip in self.ips) or (ip in self.partitions_ips) def hasAllowedFromIP(self):
# Read request body # doc = waitForDeferred(davXMLFromStream(request.stream)) yield doc try: doc = doc.getResult() except ValueError, e: log.error("Error while handling ACL body: %s" % (e,)) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, str(e))) # # Set properties # if doc is None: error = "Request XML body is required." log.error("Error: {err}", err=error) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, error)) # # Parse request # acl = doc.root_element if not isinstance(acl, davxml.ACL): error = ("Request XML body must be an acl element." % (davxml.PropertyUpdate.sname(),)) log.error("Error: {err}", err=error) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, error)) # # Do ACL merger #
try: response = (yield agent.request(method, url, headers, None)) except Exception, e: log.err(str(e)) response = None else: if response.code in (MOVED_PERMANENTLY, FOUND, TEMPORARY_REDIRECT,): if redirect > 3: log.err("Too many redirects") else: location = response.headers.getRawHeaders("location") if location: newresponse = (yield getURL(location[0], method=method, redirect=redirect + 1)) if response.code == MOVED_PERMANENTLY: scheme, netloc, url, _ignore_params, _ignore_query, _ignore_fragment = urlparse(location[0]) newresponse.location = urlunparse((scheme, netloc, url, None, None, None,)) returnValue(newresponse) else: log.err("Redirect without a Location header") if response is not None and response.code / 100 == 2: protocol = AccumulatingProtocol() response.deliverBody(protocol) whenFinished = protocol.closedDeferred = Deferred() yield whenFinished response.data = protocol.data else: log.error("Failed getURL: %s" % (url,)) returnValue(response)
def getURL(url, method="GET", redirect=0): if isinstance(url, unicode): url = url.encode("utf-8") agent = Agent(reactor) headers = http_headers.Headers({}) try: response = (yield agent.request(method, url, headers, None)) except Exception, e: log.error(str(e)) response = None else: if response.code in (MOVED_PERMANENTLY, FOUND, TEMPORARY_REDIRECT,): if redirect > 3: log.error("Too many redirects") else: location = response.headers.getRawHeaders("location") if location: newresponse = (yield getURL(location[0], method=method, redirect=redirect + 1)) if response.code == MOVED_PERMANENTLY: scheme, netloc, url, _ignore_params, _ignore_query, _ignore_fragment = urlparse(location[0]) newresponse.location = urlunparse((scheme, netloc, url, None, None, None,)) returnValue(newresponse) else: log.error("Redirect without a Location header") if response is not None and response.code / 100 == 2: protocol = AccumulatingProtocol() response.deliverBody(protocol) whenFinished = protocol.closedDeferred = Deferred()
# Read request body # try: doc = (yield davXMLFromStream(request.stream)) yield self.createCalendar(request) except ValueError, e: log.error("Error while handling MKCALENDAR: %s" % (e,)) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, str(e))) set_supported_component_set = False if doc is not None: makecalendar = doc.root_element if not isinstance(makecalendar, caldavxml.MakeCalendar): error = ("Non-%s element in MKCALENDAR request body: %s" % (caldavxml.MakeCalendar.name, makecalendar)) log.error("Error: {err}", err=error) raise HTTPError(StatusResponse(responsecode.UNSUPPORTED_MEDIA_TYPE, error)) errors = PropertyStatusResponseQueue("PROPPATCH", request.uri, responsecode.NO_CONTENT) got_an_error = False if makecalendar.children: # mkcalendar -> set -> prop -> property* for property in makecalendar.children[0].children[0].children: try: if property.qname() == (caldavxml.caldav_namespace, "supported-calendar-component-set"): yield self.setSupportedComponentSet(property) set_supported_component_set = True else: yield self.writeProperty(property, request) except HTTPError:
Determine how many process to spawn based on installed RAM and CPUs, returning at least "mininum" """ if cpuCount is None: try: cpuCount = getNCPU() except NotImplementedError, e: log.error("Unable to detect number of CPUs: %s" % (str(e),)) return minimum if memSize is None: try: memSize = getMemorySize() except NotImplementedError, e: log.error("Unable to detect amount of installed RAM: %s" % (str(e),)) return minimum countByCore = perCPU * cpuCount countByMemory = perGB * (memSize / (1024 * 1024 * 1024)) # Pick the smaller of the two: count = min(countByCore, countByMemory) # ...but at least "minimum" return max(count, minimum) ## # Module management ##
port = config.SSLPort else: scheme = "http" port = config.HTTPPort wellKnownResource.putChild( wellknown_name, SimpleRedirectResource( principalCollections=(principalCollection,), isdir=False, defaultACL=SimpleResource.allReadACL, scheme=scheme, port=port, path=redirected_to) ) for name, info in config.Aliases.iteritems(): if os.path.sep in name or not info.get("path", None): log.error("Invalid alias: %s" % (name,)) continue log.info("Adding alias %s -> %s" % (name, info["path"])) resource = FileResource(info["path"]) root.putChild(name, resource) # Timezone service is optional if config.EnableTimezoneService: log.info("Setting up time zone service resource: %r" % (timezoneServiceResourceClass,)) timezoneService = timezoneServiceResourceClass( root, ) root.putChild("timezones", timezoneService)
except ValueError, e: log.error("Error while handling PROPFIND body: {ex}", ex=e) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, str(e))) if doc is None: # No request body means get all properties. search_properties = "all" else: # # Parse request # find = doc.root_element if not isinstance(find, davxml.PropertyFind): error = ("Non-%s element in PROPFIND request body: %s" % (davxml.PropertyFind.sname(), find)) log.error("Error: {err}", err=error) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, error)) container = find.children[0] if isinstance(container, davxml.AllProperties): # Get all properties search_properties = "all" elif isinstance(container, davxml.PropertyName): # Get names only search_properties = "names" elif isinstance(container, davxml.PropertyContainer): properties = container.children search_properties = properties else: raise AssertionError("Unexpected element type in %s: %s" %
for attr, value in xattr.xattr(calPath).iteritems(): if attr == xattrname("{urn:ietf:params:xml:ns:caldav}calendar-free-busy-set"): value = yield updateFreeBusySet(value, directory) if value is not None: # Need to write the xattr back to disk xattr.setxattr(calPath, attr, value) except IOError, ioe: if ioe.errno == errno.EOPNOTSUPP: # On non-native xattr systems we cannot do this, # but those systems will typically not be migrating # from pre-v1 pass except: raise except Exception, e: log.error("Failed to upgrade calendar home %s: %s" % (homePath, e)) raise returnValue(errorOccurred) @inlineCallbacks def upgrade_to_1(config, directory): """ Upconvert data from any calendar server version prior to data format 1. """ errorOccurred = [] def setError(f=None): if f is not None:
Determine how many process to spawn based on installed RAM and CPUs, returning at least "mininum" """ if cpuCount is None: try: cpuCount = getNCPU() except NotImplementedError, e: log.error("Unable to detect number of CPUs: %s" % (str(e), )) return minimum if memSize is None: try: memSize = getMemorySize() except NotImplementedError, e: log.error("Unable to detect amount of installed RAM: %s" % (str(e), )) return minimum countByCore = perCPU * cpuCount countByMemory = perGB * (memSize / (1024 * 1024 * 1024)) # Pick the smaller of the two: count = min(countByCore, countByMemory) # ...but at least "minimum" return max(count, minimum) ## # Module management ##
): value = yield updateFreeBusySet(value, directory) if value is not None: # Need to write the xattr back to disk xattr.setxattr(calPath, attr, value) except IOError, ioe: if ioe.errno == errno.EOPNOTSUPP: # On non-native xattr systems we cannot do this, # but those systems will typically not be migrating # from pre-v1 pass except: raise except Exception, e: log.error("Failed to upgrade calendar home {path}: {ex}", path=homePath, ex=e) raise returnValue(errorOccurred) @inlineCallbacks def upgrade_to_1(config, directory): """ Upconvert data from any calendar server version prior to data format 1. """ errorOccurred = [] def setError(f=None): if f is not None:
scheme = "http" port = config.HTTPPort wellKnownResource.putChild( wellknown_name, SimpleRedirectResource( principalCollections=(principalCollection,), isdir=False, defaultACL=SimpleResource.allReadACL, scheme=scheme, port=port, path=redirected_to) ) for alias in config.Aliases: url = alias.get("url", None) path = alias.get("path", None) if not url or not path or url[0] != "/": log.error("Invalid alias: URL: {url} Path: {path}", url=url, path=path) continue urlbits = url[1:].split("/") parent = root 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)
try: method = getattr(self, method_name) # Also double-check via supported-reports property reports = self.supportedReports() test = lookupElement((namespace, name)) if not test: raise AttributeError() test = davxml.Report(test()) if test not in reports: raise AttributeError() except AttributeError: # # Requested report is not supported. # log.error("Unsupported REPORT {name} for resource {resource} (no method {method})", name=encodeXMLName(namespace, name), resource=self, method=method_name) raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, davxml.SupportedReport(), "Report not supported on this resource", )) # # Check authentication and access controls # privileges = (davxml.Read(),) if method_name == "report_urn_ietf_params_xml_ns_caldav_free_busy_query": privileges = (caldavxml.ReadFreeBusy(),) yield self.authorize(request, privileges)
for attr, value in xattr.xattr(calPath).iteritems(): if attr == xattrname("{urn:ietf:params:xml:ns:caldav}calendar-free-busy-set"): value = updateFreeBusySet(value, directory) if value is not None: # Need to write the xattr back to disk xattr.setxattr(calPath, attr, value) except IOError, ioe: if ioe.errno == errno.EOPNOTSUPP: # On non-native xattr systems we cannot do this, # but those systems will typically not be migrating # from pre-v1 pass except: raise except Exception, e: log.error("Failed to upgrade calendar home %s: %s" % (homePath, e)) raise return errorOccurred class UpgradeOneHome(Command): arguments = [('path', String())] response = [('succeeded', Boolean())] class To1Driver(AMP): """ Upgrade driver which runs in the parent process.
except ValueError, e: log.error("Error while handling PROPFIND body: %s" % (e,)) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, str(e))) if doc is None: # No request body means get all properties. search_properties = "all" else: # # Parse request # find = doc.root_element if not isinstance(find, davxml.PropertyFind): error = ("Non-%s element in PROPFIND request body: %s" % (davxml.PropertyFind.sname(), find)) log.error("Error: {err}", err=error) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, error)) container = find.children[0] if isinstance(container, davxml.AllProperties): # Get all properties search_properties = "all" elif isinstance(container, davxml.PropertyName): # Get names only search_properties = "names" elif isinstance(container, davxml.PropertyContainer): properties = container.children search_properties = [(p.namespace, p.name) for p in properties] else: raise AssertionError("Unexpected element type in %s: %s"
wellKnownResource = SimpleResource( principalCollections=(principalCollection,), isdir=True, defaultACL=SimpleResource.allReadACL ) root.putChild(".well-known", wellKnownResource) for enabled, wellknown_name in ( (config.EnableCalDAV, "caldav",), (config.EnableCardDAV, "carddav"), ): if enabled: wellKnownResource.putChild(wellknown_name, RedirectResource(path="/")) for name, info in config.Aliases.iteritems(): if os.path.sep in name or not info.get("path", None): log.error("Invalid alias: %s" % (name,)) continue log.info("Adding alias %s -> %s" % (name, info["path"])) resource = FileResource(info["path"]) root.putChild(name, resource) # Timezone service is optional if config.EnableTimezoneService: log.info("Setting up time zone service resource: %r" % (timezoneServiceResourceClass,)) timezoneService = timezoneServiceResourceClass( root, ) root.putChild("timezones", timezoneService)
# Also double-check via supported-reports property reports = self.supportedReports() test = lookupElement((namespace, name)) if not test: raise AttributeError() test = davxml.Report(test()) if test not in reports: raise AttributeError() except AttributeError: # # Requested report is not supported. # log.error( "Unsupported REPORT {name} for resource {resource} (no method {method})", name=encodeXMLName(namespace, name), resource=self, method=method_name, ) raise HTTPError( ErrorResponse(responsecode.FORBIDDEN, davxml.SupportedReport(), "Report not supported on this resource") ) # # Check authentication and access controls # privileges = (davxml.Read(),) if method_name == "report_urn_ietf_params_xml_ns_caldav_free_busy_query": privileges = (caldavxml.ReadFreeBusy(),) yield self.authorize(request, privileges)
Determine how many process to spawn based on installed RAM and CPUs, returning at least "mininum" """ if cpuCount is None: try: cpuCount = getNCPU() except NotImplementedError, e: log.error("Unable to detect number of CPUs: {ex}", ex=str(e)) return minimum if memSize is None: try: memSize = getMemorySize() except NotImplementedError, e: log.error("Unable to detect amount of installed RAM: {ex}", ex=str(e)) return minimum countByCore = perCPU * cpuCount countByMemory = perGB * (memSize / (1024 * 1024 * 1024)) # Pick the smaller of the two: count = min(countByCore, countByMemory) # ...but at least "minimum" return max(count, minimum) ## # Module management ##
log_traceback() log.error("ImplicitProcessing - originator '%s' to recipient '%s' with UID: '%s' - exception raised will try to fix: %s" % (self.originator.cuaddr, self.recipient.cuaddr, self.uid, e)) result = (yield self.doImplicitAttendeeEventFix(e)) if result: log.error("ImplicitProcessing - originator '%s' to recipient '%s' with UID: '%s' - restored organizer's copy" % (self.originator.cuaddr, self.recipient.cuaddr, self.uid)) try: result = (yield self.doImplicitAttendee()) except Exception, e: log_traceback() log.error("ImplicitProcessing - originator '%s' to recipient '%s' with UID: '%s' - exception raised after fix: %s" % (self.originator.cuaddr, self.recipient.cuaddr, self.uid, e)) raise ImplicitProcessorException("5.1;Service unavailable") else: log.error("ImplicitProcessing - originator '%s' to recipient '%s' with UID: '%s' - could not fix" % (self.originator.cuaddr, self.recipient.cuaddr, self.uid)) raise ImplicitProcessorException("5.1;Service unavailable") else: log.error("METHOD:%s not supported for implicit scheduling." % (self.method,)) raise ImplicitProcessorException("3.14;Unsupported capability") returnValue(result) def extractCalendarData(self): # Some other useful things self.method = self.message.propertyValue("METHOD") self.uid = self.message.resourceUID() def isOrganizerReceivingMessage(self): return self.method in ("REPLY", "REFRESH")
request.submethod = name try: method = getattr(self, method_name) # Also double-check via supported-reports property reports = self.supportedReports() test = lookupElement((namespace, name)) if not test: raise AttributeError() test = davxml.Report(test()) if test not in reports: raise AttributeError() except AttributeError: # # Requested report is not supported. # log.error("Unsupported REPORT %s for resource %s (no method %s)" % (encodeXMLName(namespace, name), self, method_name)) raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, davxml.SupportedReport() )) d = waitForDeferred(method(request, doc.root_element)) yield d yield d.getResult() http_REPORT = deferredGenerator(http_REPORT)
agent = Agent(reactor) headers = http_headers.Headers({}) try: response = (yield agent.request(method, url, headers, None)) except Exception, e: log.error(str(e)) response = None else: if response.code in ( MOVED_PERMANENTLY, FOUND, TEMPORARY_REDIRECT, ): if redirect > 3: log.error("Too many redirects") else: location = response.headers.getRawHeaders("location") if location: newresponse = (yield getURL(location[0], method=method, redirect=redirect + 1)) if response.code == MOVED_PERMANENTLY: scheme, netloc, url, _ignore_params, _ignore_query, _ignore_fragment = urlparse( location[0]) newresponse.location = urlunparse(( scheme, netloc, url, None, None,
log.debug("Wiki ACL result: user [%s], wiki [%s], FAULT [%s]" % (userID, wikiID, fault)) if fault.faultCode == 2: # non-existent user raise HTTPError(StatusResponse(responsecode.FORBIDDEN, fault.faultString)) elif fault.faultCode == 12: # non-existent wiki raise HTTPError(StatusResponse(responsecode.NOT_FOUND, fault.faultString)) else: # Unknown fault returned from wiki server. Log the error and # return 503 Service Unavailable to the client. log.error("Wiki ACL error: user [%s], wiki [%s], FAULT [%s]" % (userID, wikiID, fault)) raise HTTPError(StatusResponse(responsecode.SERVICE_UNAVAILABLE, fault.faultString)) except WebError, w: status = int(w.status) log.debug("Wiki ACL result: user [%s], wiki [%s], status [%s]" % (userID, wikiID, status)) if status == responsecode.FORBIDDEN: # non-existent user raise HTTPError(StatusResponse(responsecode.FORBIDDEN, "Unknown User")) elif status == responsecode.NOT_FOUND: # non-existent wiki raise HTTPError(StatusResponse(responsecode.NOT_FOUND,
except ValueError, e: log.error("Error while handling PROPFIND body: %s" % (e, )) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, str(e))) if doc is None: # No request body means get all properties. search_properties = "all" else: # # Parse request # find = doc.root_element if not isinstance(find, davxml.PropertyFind): error = ("Non-%s element in PROPFIND request body: %s" % (davxml.PropertyFind.sname(), find)) log.error("Error: {err}", err=error) raise HTTPError(StatusResponse(responsecode.BAD_REQUEST, error)) container = find.children[0] if isinstance(container, davxml.AllProperties): # Get all properties search_properties = "all" elif isinstance(container, davxml.PropertyName): # Get names only search_properties = "names" elif isinstance(container, davxml.PropertyContainer): properties = container.children search_properties = [(p.namespace, p.name) for p in properties] else: raise AssertionError("Unexpected element type in %s: %s" %
request.submethod = name try: method = getattr(self, method_name) # Also double-check via supported-reports property reports = self.supportedReports() test = lookupElement((namespace, name)) if not test: raise AttributeError() test = davxml.Report(test()) if test not in reports: raise AttributeError() except AttributeError: # # Requested report is not supported. # log.error("Unsupported REPORT %s for resource %s (no method %s)" % (encodeXMLName(namespace, name), self, method_name)) raise HTTPError( ErrorResponse(responsecode.FORBIDDEN, davxml.SupportedReport())) d = waitForDeferred(method(request, doc.root_element)) yield d yield d.getResult() http_REPORT = deferredGenerator(http_REPORT)
returnValue(True) # Run report taking depth into account try: depth = request.headers.getHeader("depth", "0") yield report_common.applyToCalendarCollections(self, request, request.uri, depth, doQuery, (davxml.Read(),)) except TooManyInstancesError, ex: log.error("Too many instances need to be computed in calendar-query report") raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, MaxInstances.fromString(str(ex.max_allowed)), "Too many instances", )) except NumberOfMatchesWithinLimits: log.error("Too many matching components in calendar-query report") raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, davxml.NumberOfMatchesWithinLimits(), "Too many components", )) except TimeRangeLowerLimit, e: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, caldavxml.MinDateTime(), "Time-range value too far in the past. Must be on or after %s." % (str(e.limit),) )) except TimeRangeUpperLimit, e: raise HTTPError(ErrorResponse( responsecode.FORBIDDEN, caldavxml.MaxDateTime(),
@inlineCallbacks def run(self): methodName = "task_%s" % (self.taskName,) method = getattr(self, methodName, None) if method: try: log.warn("Running task '%s'" % (self.taskName)) yield method() log.warn("Completed task '%s'" % (self.taskName)) except Exception, e: log.error("Failed task '%s' (%s)" % (self.taskName, e)) os.remove(self.taskFile) raise else: log.error("Unknown task requested: '%s'" % (self.taskName)) os.remove(self.taskFile) returnValue(None) @inlineCallbacks def task_scheduleinboxes(self): calendars = self.service.root.getChild("calendars") uidDir = calendars.getChild("__uids__") inboxItems = set() with open(self.taskFile) as input: for inboxItem in input: inboxItem = inboxItem.strip() inboxItems.add(inboxItem)