def handle(self, *args, **options):
"""
This function prepares the options for running the service
and if needed delegates the whole procedure to `runserver`
"""
runserver = Runserver()
runserver.stdout = sys.stdout
runserver.handle('0.0.0.0:8000', *args, **options)
def inner_run(self, *args, **options):
# Maybe they want the wsgi one?
if not options.get("use_asgi", True) or DEFAULT_CHANNEL_LAYER not in channel_layers:
return RunserverCommand.inner_run(self, *args, **options)
# Check a handler is registered for http reqs; if not, add default one
self.channel_layer = channel_layers[DEFAULT_CHANNEL_LAYER]
self.channel_layer.router.check_default(
http_consumer=self.get_consumer(*args, **options),
)
# Run checks
self.stdout.write("Performing system checks...\n\n")
self.check(display_num_errors=True)
self.check_migrations()
# Print helpful text
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C'
now = datetime.datetime.now().strftime('%B %d, %Y - %X')
if six.PY2:
now = now.decode(get_system_encoding())
self.stdout.write(now)
self.stdout.write((
"Django version %(version)s, using settings %(settings)r\n"
"Starting Channels development server at http://%(addr)s:%(port)s/\n"
"Channel layer %(layer)s\n"
"Quit the server with %(quit_command)s.\n"
) % {
"version": self.get_version(),
"settings": settings.SETTINGS_MODULE,
"addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr,
"port": self.port,
"quit_command": quit_command,
"layer": self.channel_layer,
})
# Launch workers as subthreads
if options.get("run_worker", True):
worker_count = 4 if options.get("use_threading", True) else 1
for _ in range(worker_count):
worker = WorkerThread(self.channel_layer, self.logger)
worker.daemon = True
worker.start()
# Launch server in 'main' thread. Signals are disabled as it's still
# actually a subthread under the autoreloader.
self.logger.debug("Daphne running, listening on %s:%s", self.addr, self.port)
try:
Server(
channel_layer=self.channel_layer,
host=self.addr,
port=int(self.port),
signal_handlers=not options['use_reloader'],
action_logger=self.log_action,
http_timeout=self.http_timeout,
ws_protocols=getattr(settings, 'CHANNELS_WS_PROTOCOLS', None),
root_path=getattr(settings, 'FORCE_SCRIPT_NAME', ''),
).run()
self.logger.debug("Daphne exited")
except KeyboardInterrupt:
shutdown_message = options.get('shutdown_message', '')
if shutdown_message:
self.stdout.write(shutdown_message)
return
def inner_run(self, *args, **options):
# Maybe they want the wsgi one?
if not options.get("use_asgi", True):
if hasattr(RunserverCommand, "server_cls"):
self.server_cls = RunserverCommand.server_cls
return RunserverCommand.inner_run(self, *args, **options)
# Run checks
self.stdout.write("Performing system checks...\n\n")
self.check(display_num_errors=True)
self.check_migrations()
# Print helpful text
quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C"
now = datetime.datetime.now().strftime("%B %d, %Y - %X")
self.stdout.write(now)
self.stdout.write(
(
"Django version %(version)s, using settings %(settings)r\n"
"Starting ASGI/Channels version %(channels_version)s development server"
" at %(protocol)s://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n"
)
% {
"version": self.get_version(),
"channels_version": __version__,
"settings": settings.SETTINGS_MODULE,
"protocol": self.protocol,
"addr": "[%s]" % self.addr if self._raw_ipv6 else self.addr,
"port": self.port,
"quit_command": quit_command,
}
)
# Launch server in 'main' thread. Signals are disabled as it's still
# actually a subthread under the autoreloader.
logger.debug("Daphne running, listening on %s:%s", self.addr, self.port)
# build the endpoint description string from host/port options
endpoints = build_endpoint_description_strings(host=self.addr, port=self.port)
try:
self.server_cls(
application=self.get_application(options),
endpoints=endpoints,
signal_handlers=not options["use_reloader"],
action_logger=self.log_action,
http_timeout=self.http_timeout,
root_path=getattr(settings, "FORCE_SCRIPT_NAME", "") or "",
websocket_handshake_timeout=self.websocket_handshake_timeout,
).run()
logger.debug("Daphne exited")
except KeyboardInterrupt:
shutdown_message = options.get("shutdown_message", "")
if shutdown_message:
self.stdout.write(shutdown_message)
return
def inner_run(self, *args, **options):
# Maybe they want the wsgi one?
if not options.get("use_asgi", True):
if hasattr(RunserverCommand, "server_cls"):
self.server_cls = RunserverCommand.server_cls
return RunserverCommand.inner_run(self, *args, **options)
# Run checks
self.stdout.write("Performing system checks...\n\n")
self.check(display_num_errors=True)
self.check_migrations()
# Print helpful text
quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C"
now = datetime.datetime.now().strftime("%B %d, %Y - %X")
self.stdout.write(now)
self.stdout.write(
("Django version %(version)s, using settings %(settings)r\n"
"Starting ASGI/Channels version %(channels_version)s development server"
" at %(protocol)s://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n") % {
"version": self.get_version(),
"channels_version": __version__,
"settings": settings.SETTINGS_MODULE,
"protocol": self.protocol,
"addr": "[%s]" % self.addr if self._raw_ipv6 else self.addr,
"port": self.port,
"quit_command": quit_command,
})
# Launch server in 'main' thread. Signals are disabled as it's still
# actually a subthread under the autoreloader.
self.logger.debug("Daphne running, listening on %s:%s", self.addr,
self.port)
# build the endpoint description string from host/port options
endpoints = build_endpoint_description_strings(host=self.addr,
port=self.port)
try:
self.server_cls(
application=self.get_application(options),
endpoints=endpoints,
signal_handlers=not options["use_reloader"],
action_logger=self.log_action,
http_timeout=self.http_timeout,
root_path=getattr(settings, "FORCE_SCRIPT_NAME", "") or "",
websocket_handshake_timeout=self.websocket_handshake_timeout,
).run()
self.logger.debug("Daphne exited")
except KeyboardInterrupt:
shutdown_message = options.get("shutdown_message", "")
if shutdown_message:
self.stdout.write(shutdown_message)
return
def inner_run(self, *args, **options):
# Maybe they want the wsgi one?
if not options.get(
"use_asgi",
True) or DEFAULT_CHANNEL_LAYER not in channel_layers:
return RunserverCommand.inner_run(self, *args, **options)
# Check a handler is registered for http reqs; if not, add default one
self.channel_layer = channel_layers[DEFAULT_CHANNEL_LAYER]
self.channel_layer.router.check_default(
http_consumer=self.get_consumer(*args, **options), )
# Run checks
self.stdout.write("Performing system checks...\n\n")
self.check(display_num_errors=True)
self.check_migrations()
# Print helpful text
quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C'
now = datetime.datetime.now().strftime('%B %d, %Y - %X')
if six.PY2:
now = now.decode(get_system_encoding())
self.stdout.write(now)
self.stdout.write(
("Django version %(version)s, using settings %(settings)r\n"
"Starting Channels development server at http://%(addr)s:%(port)s/\n"
"Channel layer %(layer)s\n"
"Quit the server with %(quit_command)s.\n") % {
"version": self.get_version(),
"settings": settings.SETTINGS_MODULE,
"addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr,
"port": self.port,
"quit_command": quit_command,
"layer": self.channel_layer,
})
# Launch workers as subthreads
if options.get("run_worker", True):
worker_count = 4 if options.get("use_threading", True) else 1
for _ in range(worker_count):
worker = WorkerThread(self.channel_layer, self.logger)
worker.daemon = True
worker.start()
# Launch server in 'main' thread. Signals are disabled as it's still
# actually a subthread under the autoreloader.
self.logger.debug("Daphne running, listening on %s:%s", self.addr,
self.port)
# build the endpoint description string from host/port options
endpoints = build_endpoint_description_strings(host=self.addr,
port=self.port)
try:
Server(
channel_layer=self.channel_layer,
endpoints=endpoints,
signal_handlers=not options['use_reloader'],
action_logger=self.log_action,
http_timeout=self.http_timeout,
ws_protocols=getattr(settings, 'CHANNELS_WS_PROTOCOLS', None),
root_path=getattr(settings, 'FORCE_SCRIPT_NAME', '') or '',
).run()
self.logger.debug("Daphne exited")
except KeyboardInterrupt:
shutdown_message = options.get('shutdown_message', '')
if shutdown_message:
self.stdout.write(shutdown_message)
return
def start_emulators(
persist_data: bool,
project_id: str = DEFAULT_PROJECT_ID,
emulators: Sequence[str] = _ALL_EMULATORS,
datastore_port: int = DATASTORE_PORT,
datastore_dir: Optional[str] = None,
tasks_port: int = TASKS_PORT,
task_target_port: Optional[int] = None,
autodetect_task_port: bool = True,
storage_port: int = STORAGE_PORT,
storage_dir: Optional[str] = None,
):
# This prevents restarting of the emulators when Django code reload kicks in
if os.environ.get(DJANGO_AUTORELOAD_ENV) == 'true':
return
storage_dir = storage_dir or os.path.join(get_application_root(), ".storage")
enable_test_environment_variables()
if "datastore" in emulators:
if not port_is_open(SERVICE_HOST, datastore_port):
# If start_emulators is call explicitly passing the Datastore Emulator port
# and the port is not available raise and Runtime exception.
if datastore_port != DATASTORE_PORT:
raise RuntimeError(f"Unable to start Cloud Datastore Emulator at port {datastore_port}.")
else:
datastore_port = get_next_available_port(SERVICE_HOST, datastore_port)
os.environ["DATASTORE_EMULATOR_HOST"] = f"{SERVICE_HOST}:{datastore_port}"
os.environ["DATASTORE_PROJECT_ID"] = project_id
# Start the cloud datastore emulator
command = f"gcloud beta emulators datastore start --user-output-enabled=false --consistency=1.0 --quiet --project={project_id}" # noqa
command += f" --host-port={SERVICE_HOST}:{datastore_port}"
if datastore_dir:
command += " --data-dir=%s" % datastore_dir
if not persist_data:
command += " --no-store-on-disk"
_ACTIVE_EMULATORS["datastore"] = _launch_process(command)
_wait_for_datastore(datastore_port)
if "tasks" in emulators:
# If start_emulators is call explicitly passing the Cloud Task emulator port
# and the port is not available raise and Runtime exception.
if not port_is_open(SERVICE_HOST, tasks_port):
if tasks_port != TASKS_PORT:
raise RuntimeError(f"Unable to start Cloud Tasks Emulator at port {tasks_port}.")
else:
tasks_port = get_next_available_port(SERVICE_HOST, tasks_port)
from djangae.tasks import cloud_tasks_location, cloud_tasks_parent_path, cloud_tasks_project
default_queue = "%s/queues/default" % cloud_tasks_parent_path()
if task_target_port is None:
if sys.argv[1] == "runserver" and autodetect_task_port:
from django.core.management.commands.runserver import Command as RunserverCommand
parser = RunserverCommand().create_parser('django', 'runserver')
args = parser.parse_args(sys.argv[2:])
if args.addrport:
task_target_port = args.addrport.split(":")[-1]
else:
task_target_port = _DJANGO_DEFAULT_PORT
else:
task_target_port = _DJANGO_DEFAULT_PORT
command = "gcloud-tasks-emulator start -q --port=%s --target-port=%s --default-queue=%s" % (
tasks_port, task_target_port, default_queue
)
# If the project contains a queue.yaml, pass it to the Tasks Emulator so that those queues
# can be created (needs version >= 0.4.0)
queue_yaml = os.path.join(get_application_root(), "queue.yaml")
if os.path.exists(queue_yaml):
command += " --queue-yaml=%s --queue-yaml-project=%s --queue-yaml-location=%s" % (
queue_yaml, cloud_tasks_project(), cloud_tasks_location()
)
os.environ["TASKS_EMULATOR_HOST"] = f"{SERVICE_HOST}:{tasks_port}"
_ACTIVE_EMULATORS["tasks"] = _launch_process(command)
_wait_for_tasks(tasks_port)
if "storage" in emulators:
# If start_emulators is call explicitly passing the Cloud Storage emulator port
# and the port is not available raise and Runtime exception.
if not port_is_open(SERVICE_HOST, storage_port):
if storage_port != STORAGE_PORT:
raise RuntimeError(f"Unable to start Cloud Storage Emulator at port {storage_port}.")
else:
storage_port = get_next_available_port(SERVICE_HOST, storage_port)
os.environ["STORAGE_EMULATOR_HOST"] = f"http://{SERVICE_HOST}:{storage_port}"
command = "gcloud-storage-emulator start -q --port=%s --default-bucket=%s" % (
storage_port, DEFAULT_BUCKET)
if not persist_data:
command += " --no-store-on-disk"
_ACTIVE_EMULATORS["storage"] = _launch_process(command)
_wait_for_storage(storage_port)
def start_emulators(persist_data,
emulators=None,
storage_dir=None,
task_target_port=None,
autodetect_task_port=True):
# This prevents restarting of the emulators when Django code reload
# kicks in
if os.environ.get(DJANGO_AUTORELOAD_ENV) == 'true':
return
emulators = emulators or _ALL_EMULATORS
storage_dir = storage_dir or os.path.join(get_application_root(),
".storage")
enable_test_environment_variables()
if "datastore" in emulators:
os.environ["DATASTORE_EMULATOR_HOST"] = "127.0.0.1:%s" % DATASTORE_PORT
os.environ["DATASTORE_PROJECT_ID"] = DEFAULT_PROJECT_ID
# Start the cloud datastore emulator
command = "gcloud beta emulators datastore start --consistency=1.0 --quiet --project=example"
command += " --host-port=127.0.0.1:%s" % DATASTORE_PORT
if not persist_data:
command += " --no-store-on-disk"
_ACTIVE_EMULATORS["datastore"] = _launch_process(command)
_wait_for_datastore(DATASTORE_PORT)
if "tasks" in emulators:
from djangae.tasks import cloud_tasks_parent_path, cloud_tasks_project, cloud_tasks_location
default_queue = "%s/queues/default" % cloud_tasks_parent_path()
if task_target_port is None:
if sys.argv[1] == "runserver" and autodetect_task_port:
from django.core.management.commands.runserver import Command as RunserverCommand
parser = RunserverCommand().create_parser(
'django', 'runserver')
args = parser.parse_args(sys.argv[2:])
if args.addrport:
task_target_port = args.addrport.split(":")[-1]
else:
task_target_port = _DJANGO_DEFAULT_PORT
else:
task_target_port = _DJANGO_DEFAULT_PORT
command = "gcloud-tasks-emulator start -q --port=%s --target-port=%s --default-queue=%s" % (
TASKS_PORT, task_target_port, default_queue)
# If the project contains a queue.yaml, pass it to the Tasks Emulator so that those queues
# can be created (needs version >= 0.4.0)
queue_yaml = os.path.join(get_application_root(), "queue.yaml")
if os.path.exists(queue_yaml):
command += " --queue-yaml=%s --queue-yaml-project=%s --queue-yaml-location=%s" % (
queue_yaml, cloud_tasks_project(), cloud_tasks_location())
os.environ["TASKS_EMULATOR_HOST"] = "127.0.0.1:%s" % TASKS_PORT
_ACTIVE_EMULATORS["tasks"] = _launch_process(command)
_wait_for_tasks(TASKS_PORT)
if "storage" in emulators:
os.environ[
"STORAGE_EMULATOR_HOST"] = "http://127.0.0.1:%s" % STORAGE_PORT
command = "gcloud-storage-emulator start -q --port=%s --default-bucket=%s" % (
STORAGE_PORT, DEFAULT_BUCKET)
if not persist_data:
command += " --no-store-on-disk"
_ACTIVE_EMULATORS["storage"] = _launch_process(command)
_wait_for_storage(STORAGE_PORT)
def main_run_server():
"""runserver localhost:8000"""
from django.core.management.commands.runserver import Command
Command().execute()
def run_server(self, port=8000):
from django.core.management.commands.runserver import Command
return Command().execute(addrport=str(port))
def start_emulators(
persist_data: bool,
project_id: str = DEFAULT_PROJECT_ID,
emulators: Sequence[str] = _ALL_EMULATORS,
datastore_port: int = DEFAULT_DATASTORE_PORT,
datastore_dir: Optional[str] = None,
tasks_port: int = DEFAULT_TASKS_PORT,
task_target_port: Optional[int] = None,
task_queue_yaml: Optional[str] = None,
autodetect_task_port: bool = True,
storage_port: int = DEFAULT_STORAGE_PORT,
storage_dir: Optional[str] = None,
):
# This prevents restarting of the emulators when Django code reload kicks in
if os.environ.get(DJANGO_AUTORELOAD_ENV) == 'true':
return
# If storage_dir and datastore_dir are specified, we just
# use them verbatim, otherwise we do some guesswork
if not (storage_dir and datastore_dir):
# sys.path[0] is nearly always the parent path of the
# executed script (e.g. manage.py)
base_path = sys.path[0]
# Fall-back to the application root with a warning
if not base_path:
logging.warn(
"Unable to determine script path, using "
"application root for storage directories"
)
base_path = get_application_root()
storage_dir = storage_dir or os.path.join(base_path, ".clouddata", "storage")
datastore_dir = datastore_dir or os.path.join(base_path, ".clouddata", "datastore")
os.makedirs(storage_dir, exist_ok=True)
os.makedirs(datastore_dir, exist_ok=True)
enable_test_environment_variables()
if "datastore" in emulators:
if not port_is_open(SERVICE_HOST, datastore_port):
# If start_emulators is call explicitly passing the Datastore Emulator port
# and the port is not available raise and Runtime exception.
if datastore_port != DEFAULT_DATASTORE_PORT:
raise RuntimeError(f"Unable to start Cloud Datastore Emulator at port {datastore_port}.")
else:
datastore_port = get_next_available_port(SERVICE_HOST, datastore_port)
os.environ["DATASTORE_EMULATOR_HOST"] = f"{SERVICE_HOST}:{datastore_port}"
os.environ["DATASTORE_PROJECT_ID"] = project_id
# Start the cloud datastore emulator
command = f"gcloud beta emulators datastore start --user-output-enabled=false --consistency=1.0 --quiet --project={project_id}" # noqa
command += f" --host-port={SERVICE_HOST}:{datastore_port}"
if datastore_dir:
command += " --data-dir=%s" % datastore_dir
if not persist_data:
command += " --no-store-on-disk"
_ACTIVE_EMULATORS["datastore"] = _launch_process(command)
_wait_for_datastore(datastore_port)
if "tasks" in emulators:
# If start_emulators is call explicitly passing the Cloud Task emulator port
# and the port is not available raise and Runtime exception.
if not port_is_open(SERVICE_HOST, tasks_port):
if tasks_port != DEFAULT_TASKS_PORT:
raise RuntimeError(f"Unable to start Cloud Tasks Emulator at port {tasks_port}.")
else:
tasks_port = get_next_available_port(SERVICE_HOST, tasks_port)
from djangae.tasks import cloud_tasks_location, cloud_tasks_parent_path, cloud_tasks_project
default_queue = "%s/queues/default" % cloud_tasks_parent_path()
if task_target_port is None:
if sys.argv[1] == "runserver" and autodetect_task_port:
from django.core.management.commands.runserver import Command as RunserverCommand
parser = RunserverCommand().create_parser('django', 'runserver')
args = parser.parse_args(sys.argv[2:])
if args.addrport:
task_target_port = args.addrport.split(":")[-1]
else:
task_target_port = _DJANGO_DEFAULT_PORT
else:
task_target_port = _DJANGO_DEFAULT_PORT
command = "gcloud-tasks-emulator start -q --port=%s --target-port=%s --default-queue=%s" % (
tasks_port, task_target_port, default_queue
)
# If the project contains a queue.yaml, pass it to the Tasks Emulator so that those queues
# can be created (needs version >= 0.4.0)
if task_queue_yaml and os.path.exists(task_queue_yaml):
command += " --queue-yaml=%s --queue-yaml-project=%s --queue-yaml-location=%s" % (
task_queue_yaml, cloud_tasks_project(), cloud_tasks_location()
)
elif task_queue_yaml:
logger.warn("task_queue_yaml was passed, but the file does not exist. Ignoring.")
os.environ["TASKS_EMULATOR_HOST"] = f"{SERVICE_HOST}:{tasks_port}"
_ACTIVE_EMULATORS["tasks"] = _launch_process(command)
_wait_for_tasks(tasks_port)
if "storage" in emulators:
# If start_emulators is call explicitly passing the Cloud Storage emulator port
# and the port is not available raise and Runtime exception.
if not port_is_open(SERVICE_HOST, storage_port):
if storage_port != DEFAULT_STORAGE_PORT:
raise RuntimeError(f"Unable to start Cloud Storage Emulator at port {storage_port}.")
else:
storage_port = get_next_available_port(SERVICE_HOST, storage_port)
os.environ["STORAGE_EMULATOR_HOST"] = f"http://{SERVICE_HOST}:{storage_port}"
command = "gcloud-storage-emulator start -q --port=%s --default-bucket=%s" % (
storage_port, DEFAULT_BUCKET)
if storage_dir:
command += " --data-dir=%s" % storage_dir
if not persist_data:
command += " --no-store-on-disk"
_ACTIVE_EMULATORS["storage"] = _launch_process(command)
_wait_for_storage(storage_port)