def makeService(self, options):
#
# Configure Memcached Client Pool
#
memcachepool.installPools(
config.Memcached.Pools,
config.Memcached.MaxClients,
)
multiService = service.MultiService()
notifiers = []
for key, settings in config.Notifications.Services.iteritems():
if settings["Enabled"]:
notifier = namedClass(settings["Service"])(settings)
notifier.setServiceParent(multiService)
notifiers.append(notifier)
internet.TCPServer(
config.Notifications.InternalNotificationPort,
InternalNotificationFactory(notifiers,
delaySeconds=config.Notifications.CoalesceSeconds),
interface=config.Notifications.BindAddress
).setServiceParent(multiService)
return multiService
def setupMemcached(config):
#
# Connect to memcached
#
memcachepool.installPools(config.Memcached.Pools,
config.Memcached.MaxClients)
autoDisableMemcached(config)
def setupMemcached(config):
#
# Connect to memcached
#
memcachepool.installPools(
config.Memcached.Pools,
config.Memcached.MaxClients
)
autoDisableMemcached(config)
def makeService(self, options):
memcachepool.installPools(
config.Memcached.Pools,
config.Memcached.MaxClients,
)
multiService = service.MultiService()
settings = config.Scheduling['iMIP']
if settings['Enabled']:
mailer = MailHandler()
mailType = settings['Receiving']['Type']
if mailType.lower().startswith('pop'):
self.log_info("Starting Mail Gateway Service: POP3")
client = POP3Service(settings['Receiving'], mailer)
elif mailType.lower().startswith('imap'):
self.log_info("Starting Mail Gateway Service: IMAP4")
client = IMAP4Service(settings['Receiving'], mailer)
else:
# TODO: raise error?
self.log_error("Invalid iMIP type in configuration: %s" %
(mailType,))
return multiService
client.setServiceParent(multiService)
# Set up /inbox -- server POSTs to it to send out iMIP invites
IScheduleService(settings, mailer).setServiceParent(multiService)
else:
self.log_info("Mail Gateway Service not enabled")
return multiService
def makeService(self, options):
"""
Return a service
"""
try:
from setproctitle import setproctitle
except ImportError:
pass
else:
setproctitle("CalendarServer Directory Proxy Service")
# Setup default logging behavior
multiService = ErrorLoggingMultiService(False, "", 0, 0, False)
try:
pool, txnFactory = getDBPool(config)
store = storeFromConfigWithDPSServer(config, txnFactory)
pool.setServiceParent(multiService)
except Exception as e:
log.error("Failed to create directory service", error=e)
raise
#
# Configure Memcached Client Pool
#
memcachepool.installPools(
config.Memcached.Pools,
config.Memcached.MaxClients,
)
log.info("Created directory service")
dpsService = strPortsService(
"unix:{path}:mode=660".format(
path=config.DirectoryProxy.SocketPath),
DirectoryProxyAMPFactory(store.directoryService()))
dpsService.setServiceParent(multiService)
if config.Manhole.Enabled:
try:
from twisted.conch.manhole_tap import (makeService as
manholeMakeService)
portString = "tcp:{:d}:interface=127.0.0.1".format(
config.Manhole.DPSPortNumber)
manholeService = manholeMakeService({
"sshPort":
portString if config.Manhole.UseSSH is True else None,
"telnetPort":
portString if config.Manhole.UseSSH is False else None,
"sshKeyDir":
config.DataRoot,
"sshKeyName":
"manhole.key",
"sshKeySize":
4096,
"passwd":
config.Manhole.PasswordFilePath,
"namespace": {
"config": config,
"service": dpsService,
"store": store,
"directory": store.directoryService(),
},
})
manholeService.setServiceParent(multiService)
# Using print(because logging isn't ready at this point)
print("Manhole access enabled:", portString)
except ImportError:
print("Manhole access could not enabled because "
"manhole_tap could not be imported")
return multiService
def getRootResource(config, resources=None):
"""
Set up directory service and resource hierarchy based on config.
Return root resource.
Additional resources can be added to the hierarchy by passing a list of
tuples containing: path, resource class, __init__ args list, and optional
authentication scheme ("basic" or "digest").
"""
# FIXME: this is only here to workaround circular imports
doBind()
#
# Default resource classes
#
rootResourceClass = RootResource
principalResourceClass = DirectoryPrincipalProvisioningResource
calendarResourceClass = DirectoryCalendarHomeProvisioningResource
iScheduleResourceClass = IScheduleInboxResource
timezoneServiceResourceClass = TimezoneServiceResource
webCalendarResourceClass = WebCalendarResource
webAdminResourceClass = WebAdminResource
addressBookResourceClass = DirectoryAddressBookHomeProvisioningResource
directoryBackedAddressBookResourceClass = DirectoryBackedAddressBookResource
#
# Setup the Directory
#
directories = []
directoryClass = namedClass(config.DirectoryService.type)
log.info("Configuring directory service of type: %s"
% (config.DirectoryService.type,))
baseDirectory = directoryClass(config.DirectoryService.params)
# Wait for the directory to become available
while not baseDirectory.isAvailable():
sleep(5)
directories.append(baseDirectory)
#
# Setup the Locations and Resources Service
#
if config.ResourceService.Enabled:
resourceClass = namedClass(config.ResourceService.type)
log.info("Configuring resource service of type: %s" % (resourceClass,))
resourceDirectory = resourceClass(config.ResourceService.params)
resourceDirectory.realmName = baseDirectory.realmName
directories.append(resourceDirectory)
#
# Add sudoers directory
#
sudoDirectory = None
if config.SudoersFile and os.path.exists(config.SudoersFile):
log.info("Configuring SudoDirectoryService with file: %s"
% (config.SudoersFile,))
sudoDirectory = SudoDirectoryService(config.SudoersFile)
sudoDirectory.realmName = baseDirectory.realmName
CalDAVResource.sudoDirectory = sudoDirectory
directories.insert(0, sudoDirectory)
else:
log.info( "Not using SudoDirectoryService; file doesn't exist: %s"
% (config.SudoersFile,)
)
#
# Add wiki directory service
#
if config.Authentication.Wiki.Enabled:
wikiDirectory = WikiDirectoryService()
wikiDirectory.realmName = baseDirectory.realmName
directories.append(wikiDirectory)
#
# Add internal directory service
# Right now we only use this for CardDAV
#
if config.EnableCardDAV:
internalDirectory = InternalDirectoryService(baseDirectory.realmName)
directories.append(internalDirectory)
directory = AggregateDirectoryService(directories)
if sudoDirectory:
directory.userRecordTypes.insert(0,
SudoDirectoryService.recordType_sudoers)
#
# Use system-wide realm on OSX
#
try:
import ServerFoundation
realmName = ServerFoundation.XSAuthenticator.defaultRealm().encode("utf-8")
directory.setRealm(realmName)
except ImportError:
pass
#
# Setup the Augment Service
#
augmentClass = namedClass(config.AugmentService.type)
log.info("Configuring augment service of type: %s" % (augmentClass,))
try:
augment.AugmentService = augmentClass(**config.AugmentService.params)
except IOError:
log.error("Could not start augment service")
raise
#
# Setup the ProxyDB Service
#
proxydbClass = namedClass(config.ProxyDBService.type)
log.info("Configuring proxydb service of type: %s" % (proxydbClass,))
try:
calendaruserproxy.ProxyDBService = proxydbClass(**config.ProxyDBService.params)
except IOError:
log.error("Could not start proxydb service")
raise
#
# Configure Memcached Client Pool
#
memcachepool.installPools(
config.Memcached.Pools,
config.Memcached.MaxClients,
)
#
# Configure the Site and Wrappers
#
credentialFactories = []
portal = Portal(auth.DavRealm())
portal.registerChecker(directory)
realm = directory.realmName or ""
log.info("Configuring authentication for realm: %s" % (realm,))
for scheme, schemeConfig in config.Authentication.iteritems():
scheme = scheme.lower()
credFactory = None
if schemeConfig["Enabled"]:
log.info("Setting up scheme: %s" % (scheme,))
if scheme == "kerberos":
if not NegotiateCredentialFactory:
log.info("Kerberos support not available")
continue
try:
principal = schemeConfig["ServicePrincipal"]
if not principal:
credFactory = NegotiateCredentialFactory(
type="HTTP",
hostname=config.ServerHostName,
)
else:
credFactory = NegotiateCredentialFactory(
principal=principal,
)
except ValueError:
log.info("Could not start Kerberos")
continue
elif scheme == "digest":
credFactory = QopDigestCredentialFactory(
schemeConfig["Algorithm"],
schemeConfig["Qop"],
realm,
)
elif scheme == "basic":
credFactory = BasicCredentialFactory(realm)
elif scheme == "wiki":
pass
else:
log.error("Unknown scheme: %s" % (scheme,))
if credFactory:
credentialFactories.append(credFactory)
#
# Setup Resource hierarchy
#
log.info("Setting up document root at: %s"
% (config.DocumentRoot,))
log.info("Setting up principal collection: %r"
% (principalResourceClass,))
principalCollection = principalResourceClass("/principals/", directory)
#
# Configure NotifierFactory
#
if config.Notifications.Enabled:
notifierFactory = NotifierFactory(
config.Notifications.InternalNotificationHost,
config.Notifications.InternalNotificationPort,
)
else:
notifierFactory = None
if config.UseDatabase:
_dbRoot = CachingFilePath(config.DatabaseRoot)
_postgresService = PostgresService(_dbRoot, None, v1_schema, "caldav",
logFile=config.PostgresLogFile)
_newStore = CommonSQLDataStore(_postgresService.produceConnection,
notifierFactory, _dbRoot.child("attachments"), config.EnableCalDAV, config.EnableCardDAV)
else:
_newStore = CommonFileDataStore(FilePath(config.DocumentRoot),
notifierFactory, config.EnableCalDAV, config.EnableCardDAV)
if config.EnableCalDAV:
log.info("Setting up calendar collection: %r" % (calendarResourceClass,))
calendarCollection = calendarResourceClass(
directory,
"/calendars/",
_newStore,
)
if config.EnableCardDAV:
log.info("Setting up address book collection: %r" % (addressBookResourceClass,))
addressBookCollection = addressBookResourceClass(
directory,
"/addressbooks/",
_newStore,
)
directoryPath = os.path.join(config.DocumentRoot, config.DirectoryAddressBook.name)
if config.DirectoryAddressBook.Enabled and config.EnableSearchAddressBook:
log.info("Setting up directory address book: %r" % (directoryBackedAddressBookResourceClass,))
directoryBackedAddressBookCollection = directoryBackedAddressBookResourceClass(
principalCollections=(principalCollection,)
)
addSystemEventTrigger("after", "startup", directoryBackedAddressBookCollection.provisionDirectory)
else:
# remove /directory from previous runs that may have created it
try:
FilePath(directoryPath).remove()
log.info("Deleted: %s" % directoryPath)
except (OSError, IOError), e:
if e.errno != errno.ENOENT:
log.error("Could not delete: %s : %r" % (directoryPath, e,))
def makeService(self, options):
"""
Return a service
"""
try:
from setproctitle import setproctitle
except ImportError:
pass
else:
setproctitle("CalendarServer Directory Proxy Service")
multiService = MultiService()
try:
pool, txnFactory = getDBPool(config)
store = storeFromConfigWithDPSServer(config, txnFactory)
pool.setServiceParent(multiService)
except Exception as e:
log.error("Failed to create directory service", error=e)
raise
#
# Configure Memcached Client Pool
#
memcachepool.installPools(
config.Memcached.Pools,
config.Memcached.MaxClients,
)
log.info("Created directory service")
dpsService = strPortsService(
"unix:{path}:mode=660".format(
path=config.DirectoryProxy.SocketPath
),
DirectoryProxyAMPFactory(store.directoryService())
)
dpsService.setServiceParent(multiService)
if config.Manhole.Enabled:
try:
from twisted.conch.manhole_tap import (
makeService as manholeMakeService
)
portString = "tcp:{:d}:interface=127.0.0.1".format(
config.Manhole.DPSPortNumber
)
manholeService = manholeMakeService({
"sshPort": None,
"telnetPort": portString,
"namespace": {
"config": config,
"service": dpsService,
"store": store,
"directory": store.directoryService(),
},
"passwd": config.Manhole.PasswordFilePath,
})
manholeService.setServiceParent(multiService)
# Using print(because logging isn't ready at this point)
print("Manhole access enabled:", portString)
except ImportError:
print(
"Manhole access could not enabled because "
"manhole_tap could not be imported"
)
return multiService
