diff --git a/daphne/cli.py~ b/daphne/cli.py~ deleted file mode 100755 index eefb806..0000000 --- a/daphne/cli.py~ +++ /dev/null @@ -1,182 +0,0 @@ -import sys -import argparse -import logging -import importlib -import os - -from .server import Server -from .access import AccessLogGenerator - - -logger = logging.getLogger(__name__) - - -class CommandLineInterface(object): - """ - Acts as the main CLI entry point for running the server. - """ - - description = "Django HTTP/WebSocket server" - - def __init__(self): - self.parser = argparse.ArgumentParser( - description=self.description, - ) - self.parser.add_argument( - '-p', - '--port', - type=int, - help='Port number to listen on', - default=8000, - ) - self.parser.add_argument( - '-secure', - '--secure', - type= bool, - dest= 'is_secure', - help='Set it to True to make secure connection', - default=False, - ) - self.parser.add_argument( - '-cert', - '--certificate', - dest= 'certificate_path', - help='Setthe path to the SSL certificate for secure connection', - default=os.path.dirname(__file__) +"/certificates/server.crt", - ) - self.parser.add_argument( - '-key', - '--key', - dest= 'key_path', - help='Set the path to the SSL key for secure connection', - default=os.path.dirname(__file__) +"/certificates/server.key", - ) - self.parser.add_argument( - '-b', - '--bind', - dest='host', - help='The host/address to bind to', - default="127.0.0.1", - ) - self.parser.add_argument( - '--ping-timeout', - type=int, - help='The number of seconds before a WeSocket is closed if no response to a keepalive ping', - default=30, - ) - self.parser.add_argument( - '-u', - '--unix-socket', - dest='unix_socket', - help='Bind to a UNIX socket rather than a TCP host/port', - default=None, - ) - self.parser.add_argument( - '--fd', - type=int, - dest='file_descriptor', - help='Bind to a file descriptor rather than a TCP host/port or named unix socket', - default=None, - ) - self.parser.add_argument( - '-v', - '--verbosity', - type=int, - help='How verbose to make the output', - default=1, - ) - self.parser.add_argument( - '-t', - '--http-timeout', - type=int, - help='How long to wait for worker server before timing out HTTP connections', - default=120, - ) - self.parser.add_argument( - '--access-log', - help='Where to write the access log (- for stdout, the default for verbosity=1)', - default=None, - ) - self.parser.add_argument( - '--ping-interval', - type=int, - help='The number of seconds a WebSocket must be idle before a keepalive ping is sent', - default=20, - ) - self.parser.add_argument( - 'channel_layer', - help='The ASGI channel layer instance to use as path.to.module:instance.path', - ) - self.parser.add_argument( - '--ws-protocol', - nargs='*', - dest='ws_protocols', - help='The WebSocket protocols you wish to support', - default=None, - ) - self.parser.add_argument( - '--root-path', - dest='root_path', - help='The setting for the ASGI root_path variable', - default="", - ) - - @classmethod - def entrypoint(cls): - """ - Main entrypoint for external starts. - """ - cls().run(sys.argv[1:]) - - def run(self, args): - """ - Pass in raw argument list and it will decode them - and run the server. - """ - # Decode args - args = self.parser.parse_args(args) - # Set up logging - logging.basicConfig( - level = { - 0: logging.WARN, - 1: logging.INFO, - 2: logging.DEBUG, - }[args.verbosity], - format = "%(asctime)-15s %(levelname)-8s %(message)s" , - ) - # If verbosity is 1 or greater, or they told us explicitly, set up access log - access_log_stream = None - if args.access_log: - if args.access_log == "-": - access_log_stream = sys.stdout - else: - access_log_stream = open(args.access_log, "a") - elif args.verbosity >= 1: - access_log_stream = sys.stdout - # Import channel layer - sys.path.insert(0, ".") - module_path, object_path = args.channel_layer.split(":", 1) - channel_layer = importlib.import_module(module_path) - for bit in object_path.split("."): - channel_layer = getattr(channel_layer, bit) - # Run server - logger.info( - "Starting server at %s, channel layer %s", - (args.unix_socket if args.unix_socket else "%s:%s" % (args.host, args.port)), - args.channel_layer, - ) - Server( - channel_layer=channel_layer, - host=args.host, - port=args.port, - unix_socket=args.unix_socket, - file_descriptor=args.file_descriptor, - http_timeout=args.http_timeout, - ping_interval=args.ping_interval, - action_logger=AccessLogGenerator(access_log_stream) if access_log_stream else None, - ws_protocols=args.ws_protocols, - root_path=args.root_path, - secure=args.is_secure, - certificate = args.certificate_path, - key = args.key_path - ).run() diff --git a/daphne/server.py~ b/daphne/server.py~ deleted file mode 100755 index ff714b0..0000000 --- a/daphne/server.py~ +++ /dev/null @@ -1,147 +0,0 @@ -import logging -import socket -import os - -from twisted.internet import reactor, defer, ssl -from twisted.logger import globalLogBeginner - -from .http_protocol import HTTPFactory - -logger = logging.getLogger(__name__) - - -class Server(object): - - def __init__( - self, - channel_layer, - host="127.0.0.1", - port=8000, - unix_socket=None, - file_descriptor=None, - signal_handlers=True, - action_logger=None, - http_timeout=120, - websocket_timeout=None, - ping_interval=20, - ws_protocols=None, - root_path="", - secure=False, - certificate = os.path.dirname(__file__) +"/certificates/server.crt", - key = os.path.dirname(__file__) +"/certificates/server.key", - ): - self.channel_layer = channel_layer - self.host = host - self.port = port - self.unix_socket = unix_socket - self.file_descriptor = file_descriptor - self.signal_handlers = signal_handlers - self.action_logger = action_logger - self.http_timeout = http_timeout - self.ping_interval = ping_interval - self.ping_timeout = ping_timeout - # If they did not provide a websocket timeout, default it to the - # channel layer's group_expiry value if present, or one day if not. - self.websocket_timeout = websocket_timeout or getattr(channel_layer, "group_expiry", 86400) - self.ws_protocols = ws_protocols - self.root_path = root_path - self.secure = secure - self.certificate = certificate - self.key = key - - def run(self): - self.factory = HTTPFactory( - self.channel_layer, - self.action_logger, - timeout=self.http_timeout, - websocket_timeout=self.websocket_timeout, - ping_interval=self.ping_interval, - ws_protocols=self.ws_protocols, - root_path=self.root_path, - ) - # Redirect the Twisted log to nowhere - globalLogBeginner.beginLoggingTo([lambda _: None], redirectStandardIO=False, discardBuffer=True) - # Listen on a socket - if self.unix_socket: - reactor.listenUNIX(self.unix_socket, self.factory) - elif self.file_descriptor: - # socket returns the same socket if supplied with a fileno - sock = socket.socket(fileno=self.file_descriptor) - reactor.adoptStreamPort(self.file_descriptor, sock.family, self.factory) - else: - #secure connection request check - if self.secure : - - if os.path.isfile(self.key) and os.path.isfile(self.certificate): - - reactor.listenSSL(self.port, self.factory, ssl.DefaultOpenSSLContextFactory(self.key, self.certificate),interface=self.host) - - else : - logging.error("SSL key and certificate are not properly configured. \n It should be placed in " +os.path.dirname(__file__) +"/certificates " + "folder as server.key and server.crt. \n Or you have to pass key and certificate path in -key and -cert arguments along with secure argument." ) - - else : - reactor.listenTCP(self.port, self.factory, interface=self.host) - - if "twisted" in self.channel_layer.extensions: - logging.info("Using native Twisted mode on channel layer") - reactor.callLater(0, self.backend_reader_twisted) - else: - logging.info("Using busy-loop synchronous mode on channel layer") - reactor.callLater(0, self.backend_reader_sync) - reactor.callLater(2, self.timeout_checker) - reactor.run(installSignalHandlers=self.signal_handlers) - - def backend_reader_sync(self): - """ - Runs as an-often-as-possible task with the reactor, unless there was - no result previously in which case we add a small delay. - """ - channels = self.factory.reply_channels() - delay = 0.05 - # Quit if reactor is stopping - if not reactor.running: - logging.debug("Backend reader quitting due to reactor stop") - return - # Don't do anything if there's no channels to listen on - if channels: - delay = 0.01 - channel, message = self.channel_layer.receive_many(channels, block=False) - if channel: - delay = 0.00 - # Deal with the message - self.factory.dispatch_reply(channel, message) - reactor.callLater(delay, self.backend_reader_sync) - - @defer.inlineCallbacks - def backend_reader_twisted(self): - """ - Runs as an-often-as-possible task with the reactor, unless there was - no result previously in which case we add a small delay. - """ - while True: - if not reactor.running: - logging.debug("Backend reader quitting due to reactor stop") - return - channels = self.factory.reply_channels() - if channels: - channel, message = yield self.channel_layer.receive_many_twisted(channels) - # Deal with the message - if channel: - self.factory.dispatch_reply(channel, message) - else: - yield self.sleep(0.01) - else: - yield self.sleep(0.05) - - def sleep(self, delay): - d = defer.Deferred() - reactor.callLater(delay, d.callback, None) - return d - - def timeout_checker(self): - """ - Called periodically to enforce timeout rules on all connections. - Also checks pings at the same time. - """ - self.factory.check_timeouts() - reactor.callLater(2, self.timeout_checker)