def setup(self):
"""Setup function for each test."""
self.colpath = tempfile.mkdtemp()
from radicale.storage import filesystem
filesystem.FOLDER = self.colpath
filesystem.GIT_REPOSITORY = None
self.application = radicale.Application()
def test_custom(self):
config.set("auth", "type", "custom")
config.set("auth", "custom_handler", "tests.custom.auth")
self.application = radicale.Application()
status, headers, answer = self.request(
"GET", "/", HTTP_AUTHORIZATION=self.userpass)
assert status == 200
assert "Radicale works!" in answer
def setup(self):
"""Setup function for each test."""
self.colpath = tempfile.mkdtemp()
config.set("storage", "type", self.storage_type)
config.set("storage", "custom_handler", "tests.custom.storage")
from tests.custom import storage
storage.FOLDER = self.colpath
storage.GIT_REPOSITORY = None
self.application = radicale.Application()
def setup(self):
super(TestDataBaseSystem, self).setup()
radicale.config.set("storage", "database_url", "sqlite://")
from radicale.storage import database
database.Session = sessionmaker()
database.Session.configure(bind=create_engine("sqlite://"))
session = database.Session()
for st in get_file_content("schema.sql").split(";"):
session.execute(st)
session.commit()
self.application = radicale.Application()
def setup(self):
self.colpath = tempfile.mkdtemp()
htpasswd_file_path = os.path.join(self.colpath, ".htpasswd")
with open(htpasswd_file_path, "wb") as fd:
fd.write(b"tmp:{SHA}" +
base64.b64encode(hashlib.sha1(b"bepo").digest()))
config.set("auth", "type", "htpasswd")
self.userpass = "******"
self.application = radicale.Application()
htpasswd.FILENAME = htpasswd_file_path
htpasswd.ENCRYPTION = "sha1"
def get_app():
config = radicale.config.load(())
config.set('storage', 'filesystem_folder', str(tmpdir))
config.set('rights', 'type', 'owner_only')
app = radicale.Application(config, logger)
def is_authenticated(user, password):
return user == 'bob' and password == 'bob'
app.is_authenticated = is_authenticated
return app
def test_root(self):
self.colpath = tempfile.mkdtemp()
htpasswd_file_path = os.path.join(self.colpath, ".htpasswd")
with open(htpasswd_file_path, "wb") as fd:
fd.write(b"tmp:{SHA}" +
base64.b64encode(hashlib.sha1(b"bepo").digest()))
config.set("auth", "type", "htpasswd")
htpasswd.FILENAME = htpasswd_file_path
htpasswd.ENCRYPTION = "sha1"
self.application = radicale.Application()
status, headers, answer = self.request(
"GET", "/", HTTP_AUTHORIZATION=self.userpass)
assert status == 200
assert "Radicale works!" in answer
def setup(self):
"""Setup function for each test."""
self.application = radicale.Application()
def run():
"""Run Radicale as a standalone server."""
# Get command-line options
parser = optparse.OptionParser(version=radicale.VERSION)
parser.add_option(
"-d", "--daemon", action="store_true",
default=radicale.config.getboolean("server", "daemon"),
help="launch as daemon")
parser.add_option(
"-p", "--pid",
default=radicale.config.get("server", "pid"),
help="set PID filename for daemon mode")
parser.add_option(
"-f", "--foreground", action="store_false", dest="daemon",
help="launch in foreground (opposite of --daemon)")
parser.add_option(
"-H", "--hosts",
default=radicale.config.get("server", "hosts"),
help="set server hostnames and ports")
parser.add_option(
"-s", "--ssl", action="store_true",
default=radicale.config.getboolean("server", "ssl"),
help="use SSL connection")
parser.add_option(
"-S", "--no-ssl", action="store_false", dest="ssl",
help="do not use SSL connection (opposite of --ssl)")
parser.add_option(
"-k", "--key",
default=radicale.config.get("server", "key"),
help="set private key file")
parser.add_option(
"-c", "--certificate",
default=radicale.config.get("server", "certificate"),
help="set certificate file")
parser.add_option(
"-D", "--debug", action="store_true",
default=radicale.config.getboolean("logging", "debug"),
help="print debug information")
options = parser.parse_args()[0]
# Update Radicale configuration according to options
for option in parser.option_list:
key = option.dest
if key:
section = "logging" if key == "debug" else "server"
value = getattr(options, key)
radicale.config.set(section, key, str(value))
# Start logging
radicale.log.start()
# Fork if Radicale is launched as daemon
if options.daemon:
pid = os.fork()
if pid:
try:
if options.pid:
open(options.pid, 'w').write(str(pid))
finally:
sys.exit()
sys.stdout = sys.stderr = open(os.devnull, "w")
# Register exit function
def cleanup():
"""Remove the PID files."""
radicale.log.LOGGER.debug("Cleaning up")
# Remove PID file
if options.pid and options.daemon:
os.unlink(options.pid)
atexit.register(cleanup)
radicale.log.LOGGER.info("Starting Radicale")
# Create collection servers
servers = []
server_class = radicale.HTTPSServer if options.ssl else radicale.HTTPServer
shutdown_program = threading.Event()
for host in options.hosts.split(','):
address, port = host.strip().rsplit(':', 1)
address, port = address.strip('[] '), int(port)
servers.append(
make_server(address, port, radicale.Application(),
server_class, radicale.RequestHandler))
# SIGTERM and SIGINT (aka KeyboardInterrupt) should just mark this for
# shutdown
signal.signal(signal.SIGTERM, lambda *_: shutdown_program.set())
signal.signal(signal.SIGINT, lambda *_: shutdown_program.set())
def serve_forever(server):
"""Serve a server forever, cleanly shutdown when things go wrong."""
try:
server.serve_forever()
finally:
shutdown_program.set()
# Start the servers in a different loop to avoid possible race-conditions,
# when a server exists but another server is added to the list at the same
# time
for server in servers:
radicale.log.LOGGER.debug(
"Listening to %s port %s" % (
server.server_name, server.server_port))
if options.ssl:
radicale.log.LOGGER.debug("Using SSL")
threading.Thread(target=serve_forever, args=(server,)).start()
radicale.log.LOGGER.debug("Radicale server ready")
# Main loop: wait until all servers are exited
try:
# We must do the busy-waiting here, as all ``.join()`` calls completly
# block the thread, such that signals are not received
while True:
# The number is irrelevant, it only needs to be greater than 0.05
# due to python implementing its own busy-waiting logic
shutdown_program.wait(5.0)
if shutdown_program.is_set():
break
finally:
# Ignore signals, so that they cannot interfere
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
radicale.log.LOGGER.info("Stopping Radicale")
for server in servers:
radicale.log.LOGGER.debug(
"Closing server listening to %s port %s" % (
server.server_name, server.server_port))
server.shutdown()
# Taken from https://github.com/Kozea/Radicale/blob/1.1.x/radicale.wsgi
import logging
import radicale
import radicale.log
import waitress
def wsgi(environ, start_response):
try:
return APP(environ, start_response)
except Exception:
logging.error('Uncaught exception', exc_info=True)
radicale.log.start()
APP = radicale.Application()
waitress.serve(wsgi, threads=4, listen='localhost:7076')
def setup(self):
"""Setup function for each test."""
self.colpath = tempfile.mkdtemp()
from radicale import storage
storage.FOLDER = self.colpath
self.application = radicale.Application()
