def ws_receive(message): """Receive a message from a websocket. As of now, that message should be either 'ping' or the REST session token. """ content = message.content['text'] if content != "ping": content = json.loads(content) token = content['token'] setup_logger("server").info("Registering client with token %r", token) CHANNEL_TO_TOKEN[message.reply_channel.name] = token
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get("layer", DEFAULT_CHANNEL_LAYER)] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer." ) # Check a handler is registered for http reqs # Serve static files if Django in debug mode if settings.DEBUG: self.channel_layer.router.check_default(http_consumer=StaticFilesConsumer()) else: self.channel_layer.router.check_default() # Launch a worker self.logger.info("Running worker against channel layer %s", self.channel_layer) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: worker = Worker( channel_layer=self.channel_layer, callback=callback, only_channels=options.get("only_channels", None), exclude_channels=options.get("exclude_channels", None), ) worker_ready.send(sender=worker) worker.run() except KeyboardInterrupt: pass
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) # Get the backend to use channel_backend = channel_backends[DEFAULT_CHANNEL_BACKEND] if channel_backend.local_only: raise CommandError( "You have a process-local channel backend configured, and so cannot run separate interface servers.\n" "Configure a network-based backend in CHANNEL_BACKENDS to use this command." ) # Run the interface port = int(options.get("port", None) or 9000) try: import asyncio # NOQA except ImportError: from channels.interfaces.websocket_twisted import WebsocketTwistedInterface self.logger.info("Running Twisted/Autobahn WebSocket interface server") self.logger.info(" Channel backend: %s", channel_backend) self.logger.info(" Listening on: ws://0.0.0.0:%i" % port) WebsocketTwistedInterface(channel_backend=channel_backend, port=port).run() else: from channels.interfaces.websocket_asyncio import WebsocketAsyncioInterface self.logger.info("Running asyncio/Autobahn WebSocket interface server") self.logger.info(" Channel backend: %s", channel_backend) self.logger.info(" Listening on: ws://0.0.0.0:%i", port) WebsocketAsyncioInterface(channel_backend=channel_backend, port=port).run()
def handle(self, *args, **options): self.verbosity = options.get('verbosity', 1) self.logger = setup_logger('django.channels', self.verbosity) self.honcho = OTreeHonchoManager() self.setup_honcho(options) self.honcho.loop() sys.exit(self.honcho.returncode)
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.http_timeout = options.get("http_timeout", 60) self.websocket_handshake_timeout = options.get( "websocket_handshake_timeout", 5) super(Command, self).handle(*args, **options)
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get("layer", DEFAULT_CHANNEL_LAYER)] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer." ) # Check a handler is registered for http reqs self.channel_layer.router.check_default() # Launch a worker self.logger.info("Running worker against channel layer %s", self.channel_layer) # Run the worker num_threads = options['num_threads'] if num_threads == 1: Worker(channel_layer=self.channel_layer).run() else: worker_threads = [] for _ in range(num_threads): worker = WorkerThread(self.channel_layer, self.logger) worker.daemon = True worker.start() worker_threads.append(worker) while True: time.sleep(5)
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) # Get the backend to use channel_backend = channel_backends[DEFAULT_CHANNEL_BACKEND] if channel_backend.local_only: raise CommandError( "You have a process-local channel backend configured, and so cannot run separate interface servers.\n" "Configure a network-based backend in CHANNEL_BACKENDS to use this command." ) # Run the interface port = int(options.get("port", None) or 9000) try: import asyncio # NOQA except ImportError: from channels.interfaces.websocket_twisted import WebsocketTwistedInterface self.logger.info( "Running Twisted/Autobahn WebSocket interface server") self.logger.info(" Channel backend: %s", channel_backend) self.logger.info(" Listening on: ws://0.0.0.0:%i" % port) WebsocketTwistedInterface(channel_backend=channel_backend, port=port).run() else: from channels.interfaces.websocket_asyncio import WebsocketAsyncioInterface self.logger.info( "Running asyncio/Autobahn WebSocket interface server") self.logger.info(" Channel backend: %s", channel_backend) self.logger.info(" Listening on: ws://0.0.0.0:%i", port) WebsocketAsyncioInterface(channel_backend=channel_backend, port=port).run()
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) channel_backend = channel_backends[DEFAULT_CHANNEL_BACKEND] if channel_backend.local_only: raise CommandError( "You have a process-local channel backend configured, and so cannot run separate workers.\n" "Configure a network-based backend in CHANNEL_BACKENDS to use this command." ) # Check a handler is registered for http reqs if not channel_backend.registry.consumer_for_channel("http.request"): # Register the default one channel_backend.registry.add_consumer(UrlConsumer(), ["http.request"]) # Launch a worker self.logger.info("Running worker against backend %s", channel_backend) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: Worker(channel_backend=channel_backend, callback=callback).run() except KeyboardInterrupt: pass
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get( "layer", DEFAULT_CHANNEL_LAYER)] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer.") # Check a handler is registered for http reqs # Serve static files if Django in debug mode if settings.DEBUG: self.channel_layer.router.check_default( http_consumer=StaticFilesConsumer()) else: self.channel_layer.router.check_default() # Launch a worker self.logger.info("Running worker against channel layer %s", self.channel_layer) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: Worker( channel_layer=self.channel_layer, callback=callback, only_channels=options.get("only_channels", None), exclude_channels=options.get("exclude_channels", None), ).run() except KeyboardInterrupt: pass
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger("django.channels", self.verbosity) self.http_timeout = options.get("http_timeout", None) self.websocket_handshake_timeout = options.get("websocket_handshake_timeout", 5) # Check Channels is installed right if not hasattr(settings, "ASGI_APPLICATION"): raise CommandError("You have not set ASGI_APPLICATION, which is needed to run the server.") # Dispatch upward super().handle(*args, **options)
def server(bind='127.0.0.1', port=8000, migrate_cmd=False, verbose=1): # pragma: no cover try: from channels.log import setup_logger from channels.management.commands import runserver logger = setup_logger('django.channels', 1) use_channels = True except ImportError: from django.contrib.staticfiles.management.commands import runserver use_channels = False logger = None if os.environ.get('RUN_MAIN') != 'true': _create_db(migrate_cmd) User = get_user_model() if not User.objects.filter(is_superuser=True).exists(): usr = create_user('admin', '*****@*****.**', 'admin', is_staff=True, is_superuser=True) print('') print('A admin user (username: %s, password: admin) ' 'has been created.' % usr.get_username()) print('') rs = runserver.Command() try: from django.core.management.base import OutputWrapper rs.stdout = OutputWrapper(sys.stdout) rs.stderr = OutputWrapper(sys.stderr) except ImportError: rs.stdout = sys.stdout rs.stderr = sys.stderr rs.use_ipv6 = False rs._raw_ipv6 = False rs.addr = bind rs.port = port if logger: rs.logger = logger if use_channels: rs.http_timeout = 60 rs.websocket_handshake_timeout = 5 autoreload.main( rs.inner_run, (), { 'addrport': '%s:%s' % (bind, port), 'insecure_serving': True, 'use_static_handler': True, 'use_threading': True, 'verbosity': verbose, 'use_reloader': True })
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger("django.channels", self.verbosity) self.http_timeout = options.get("http_timeout", 60) self.websocket_handshake_timeout = options.get( "websocket_handshake_timeout", 5) # Check Channels is installed right if not hasattr(settings, "ASGI_APPLICATION"): raise CommandError( "You have not set ASGI_APPLICATION, which is needed to run the server." ) # Dispatch upward super().handle(*args, **options)
def handle(self, *args, addr=None, port=None, addrport=None, verbosity=1, **options): self.verbosity = verbosity self.logger = setup_logger('django.channels', self.verbosity) self.honcho = OTreeHonchoManager() self.setup_honcho(addr=addr, port=port, addrport=addrport) self.honcho.loop() sys.exit(self.honcho.returncode)
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get( "layer", DEFAULT_CHANNEL_LAYER)] self.n_threads = options.get('threads', 1) # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer.") # Check a handler is registered for http reqs # Serve static files if Django in debug mode if settings.DEBUG: self.channel_layer.router.check_default( http_consumer=StaticFilesConsumer()) else: self.channel_layer.router.check_default() # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called self.callback = callback self.options = options # Choose an appropriate worker. worker_kwargs = {} if self.n_threads == 1: self.logger.info("Using single-threaded worker.") worker_cls = Worker else: self.logger.info( "Using multi-threaded worker, {} thread(s).".format( self.n_threads)) worker_cls = WorkerGroup worker_kwargs['n_threads'] = self.n_threads # Run the worker self.logger.info("Running worker against channel layer %s", self.channel_layer) try: worker = worker_cls( channel_layer=self.channel_layer, callback=self.callback, only_channels=self.options.get("only_channels", None), exclude_channels=self.options.get("exclude_channels", None), **worker_kwargs) worker_process_ready.send(sender=worker) worker.ready() worker.run() except KeyboardInterrupt: pass
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get("layer", DEFAULT_CHANNEL_LAYER)] self.n_threads = options.get('threads', 1) # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer." ) # Check a handler is registered for http reqs # Serve static files if Django in debug mode if settings.DEBUG: self.channel_layer.router.check_default(http_consumer=StaticFilesConsumer()) else: self.channel_layer.router.check_default() # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called self.callback = callback self.options = options # Choose an appropriate worker. worker_kwargs = {} if self.n_threads == 1: self.logger.info("Using single-threaded worker.") worker_cls = Worker else: self.logger.info("Using multi-threaded worker, {} thread(s).".format(self.n_threads)) worker_cls = WorkerGroup worker_kwargs['n_threads'] = self.n_threads # Run the worker self.logger.info("Running worker against channel layer %s", self.channel_layer) try: worker = worker_cls( channel_layer=self.channel_layer, callback=self.callback, only_channels=self.options.get("only_channels", None), exclude_channels=self.options.get("exclude_channels", None), **worker_kwargs ) worker_process_ready.send(sender=worker) worker.ready() worker.run() except KeyboardInterrupt: pass
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get( "layer", DEFAULT_CHANNEL_LAYER)] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer.") self.options = options self.logger.info("Running scheduler against channel layer %s", self.channel_layer) try: worker = Worker(channel_layer=self.channel_layer, ) worker.run() except KeyboardInterrupt: pass
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get("layer", DEFAULT_CHANNEL_LAYER)] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer." ) self.options = options self.logger.info("Running delay against channel layer %s", self.channel_layer) try: worker = Worker( channel_layer=self.channel_layer, ) worker.run() except KeyboardInterrupt: pass
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) # Get the channel layer they asked for (or see if one isn't configured) if "layer" in options: self.channel_layer = get_channel_layer(options["layer"]) else: self.channel_layer = get_channel_layer() if self.channel_layer is None: raise CommandError("You do not have any CHANNEL_LAYERS configured.") # Run the worker self.logger = setup_logger("django.channels", self.verbosity) self.logger.info("Running worker for channels %s", options["channels"]) worker = self.worker_class( application=get_default_application(), channels=options["channels"], channel_layer=self.channel_layer, ) worker.run()
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger("django.channels", self.verbosity) channel_layer = channel_layers[DEFAULT_CHANNEL_LAYER] # Check a handler is registered for http reqs if not channel_layer.registry.consumer_for_channel("http.request"): # Register the default one channel_layer.registry.add_consumer(ViewConsumer(), ["http.request"]) # Launch a worker self.logger.info("Running worker against backend %s", channel_layer.alias) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: Worker(channel_layer=channel_layer, callback=callback).run() except KeyboardInterrupt: pass
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) channel_layer = channel_layers[DEFAULT_CHANNEL_LAYER] # Check a handler is registered for http reqs if not channel_layer.registry.consumer_for_channel("http.request"): # Register the default one channel_layer.registry.add_consumer(ViewConsumer(), ["http.request"]) # Launch a worker self.logger.info("Running worker against backend %s", channel_layer.alias) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: Worker(channel_layer=channel_layer, callback=callback).run() except KeyboardInterrupt: pass
def server(bind='127.0.0.1', port=8000, migrate_cmd=False, verbose=1): # pragma: no cover from django.contrib.staticfiles.management.commands import runserver if os.environ.get('RUN_MAIN') != 'true': _create_db(migrate_cmd) User = get_user_model() if not User.objects.filter(is_superuser=True).exists(): usr = create_user('admin', '*****@*****.**', 'admin', is_staff=True, is_superuser=True) print('') print('A admin user (username: %s, password: admin) ' 'has been created.' % usr.get_username()) print('') rs = runserver.Command() try: from django.core.management.base import OutputWrapper rs.stdout = OutputWrapper(sys.stdout) rs.stderr = OutputWrapper(sys.stderr) except ImportError: rs.stdout = sys.stdout rs.stderr = sys.stderr rs.use_ipv6 = False rs._raw_ipv6 = False rs.addr = bind rs.port = port try: from channels.log import setup_logger rs.logger = setup_logger('django.channels', 1) except ImportError: pass autoreload.main(rs.inner_run, (), { 'addrport': '%s:%s' % (bind, port), 'insecure_serving': True, 'use_static_handler': True, 'use_threading': True, 'verbosity': verbose, 'use_reloader': True, })
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[options.get("layer", DEFAULT_CHANNEL_LAYER)] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer." ) # Check a handler is registered for http reqs self.channel_layer.registry.check_default() # Launch a worker self.logger.info("Running worker against channel layer %s", self.channel_layer) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: Worker(channel_layer=self.channel_layer, callback=callback).run() except KeyboardInterrupt: pass
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.channel_layer = channel_layers[DEFAULT_CHANNEL_LAYER] # Check that handler isn't inmemory if self.channel_layer.local_only(): raise CommandError( "You cannot span multiple processes with the in-memory layer. " + "Change your settings to use a cross-process channel layer.") # Check a handler is registered for http reqs self.channel_layer.registry.check_default() # Launch a worker self.logger.info("Running worker against backend %s", self.channel_layer) # Optionally provide an output callback callback = None if self.verbosity > 1: callback = self.consumer_called # Run the worker try: Worker(channel_layer=self.channel_layer, callback=callback).run() except KeyboardInterrupt: pass
def handle(self, *args, **options): # Get the backend to use self.verbosity = options.get("verbosity", 1) # Get the channel layer they asked for (or see if one isn't configured) if "layer" in options: self.channel_layer = get_channel_layer(options["layer"]) else: self.channel_layer = get_channel_layer() if self.channel_layer is None: raise CommandError( "You do not have any CHANNEL_LAYERS configured.") # Get beatconfig here. from beatserver.parser import Parser project_path = settings.SETTINGS_MODULE.replace('.settings', '') beat_config = Parser(project_path + '.beatconfig').get_beat_config() # Run the worker self.logger = setup_logger("django.channels", self.verbosity) self.logger.info("Starting beatserver...") server = self.server_class(application=get_default_application(), channel_layer=self.channel_layer, beat_config=beat_config) server.run()
def handle(self, *args, **options): self.verbosity = options.get('verbosity', 1) self.logger = setup_logger('django.channels', self.verbosity) manager = self.get_honcho_manager(options) manager.loop() sys.exit(manager.returncode)
def server(bind="127.0.0.1", port=8000, migrate_cmd=False, verbose=1): # pragma: no cover try: from channels.log import setup_logger from channels.management.commands import runserver logger = setup_logger("django.channels", 1) use_channels = True except ImportError: from django.contrib.staticfiles.management.commands import runserver use_channels = False logger = None if os.environ.get("RUN_MAIN") != "true": _create_db(migrate_cmd) User = get_user_model() # NOQA if not User.objects.filter(is_superuser=True).exists(): usr = create_user("admin", "*****@*****.**", "admin", is_staff=True, is_superuser=True) print("") print("A admin user (username: %s, password: admin) " "has been created." % usr.get_username()) print("") rs = runserver.Command() try: from django.core.management.base import OutputWrapper rs.stdout = OutputWrapper(sys.stdout) rs.stderr = OutputWrapper(sys.stderr) except ImportError: rs.stdout = sys.stdout rs.stderr = sys.stderr rs.use_ipv6 = False rs._raw_ipv6 = False rs.addr = bind rs.port = port if logger: rs.logger = logger if use_channels: rs.http_timeout = 60 rs.websocket_handshake_timeout = 5 try: autoreload.run_with_reloader( rs.inner_run, **{ "addrport": "%s:%s" % (bind, port), "insecure_serving": True, "use_static_handler": True, "use_threading": True, "verbosity": verbose, "use_reloader": True, }) except AttributeError: autoreload.main(rs.inner_run, kwargs={ "addrport": "%s:%s" % (bind, port), "insecure_serving": True, "use_static_handler": True, "use_threading": True, "verbosity": verbose, "use_reloader": True, })
def handle(self, *args, **options): self.verbosity = options.get('verbosity', 1) self.logger = setup_logger('django.channels', self.verbosity) return super(Command, self).handle(*args, **options)
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) super(Command, self).handle(*args, **options)
def handle(self, *args, **options): self.verbosity = options.get("verbosity", 1) self.logger = setup_logger('django.channels', self.verbosity) self.http_timeout = options.get("http_timeout", 60) self.websocket_handshake_timeout = options.get("websocket_handshake_timeout", 5) super(Command, self).handle(*args, **options)
def ws_disconnect(message): """Disconnect a websocket client, cleaning its session.""" if message.reply_channel.name in CHANNEL_TO_TOKEN: token = CHANNEL_TO_TOKEN[message.reply_channel.name] setup_logger("server").info("Cleaning session for client %r", token) close_session(token)
from datetime import datetime, date, timedelta from channels import Channel from channels.log import setup_logger from trading.models import Product, Code, Equity, Account, Entry, Exit logger = setup_logger(__name__) COMISSION = 7 #수수료 class post: @staticmethod def save(products): """ broker에서 넘어온 시장정보를 db에 업데이트""" for group in products.values(): #상품정보 업데이트 product, created = Product.objects.update_or_create( pk=group['group'], defaults={ 'name': group['name'], 'group': group['group'], 'market': group['market'], 'currency': group['currency'], 'open_margin': group['open_margin'], 'keep_margin': group['keep_margin'],
def handle(self, *args, verbosity=1, **options): self.verbosity = verbosity self.logger = setup_logger('django.channels', self.verbosity) manager = self.get_honcho_manager() manager.loop() sys_exit(manager.returncode)