def __init__(self): mgr = socketio.AsyncRedisManager(constants.SOCKET_REDIS) # need this to define app self.sio = socketio.AsyncServer(async_mode='aiohttp', client_manager=mgr, cors_allowed_origins="*") self.aio_app = web.Application() self.sio.attach(self.aio_app)
async def _run_websocket_server(self): mgr = socketio.AsyncRedisManager('redis://{}:{}'.format( settings.REDIS_HOST, settings.REDIS_PORT)) sio_settings = dict(client_manager=mgr, async_mode='aiohttp') if settings.ENABLE_CORS: sio_settings['cors_allowed_origins'] = '*' self.sio_server = socketio.AsyncServer(**sio_settings) self.loop.create_task( _run_app(app, host='127.0.0.1', port=self.socketioport))
def init_websocket(app): from ws.live.events import LiveRoomNamespace mgr = socketio.AsyncRedisManager( f"redis://{settings.REDIS_HOST}:{settings.REDIS_PORT}/4") sio = socketio.AsyncServer( async_mode="aiohttp", ping_timeout=62, client_manager=mgr, cors_allowed_origins="*", ) sio.attach(app) sio.register_namespace(LiveRoomNamespace("/liveroom"))
def _server_init(settings=None): global sio, app, mq redis_url = parameter(settings, 'REDIS_BROKER_URL', None) if not sio: _logger.info("Redis Broker: '{}' CONNECTING...".format(redis_url)) mq = socketio.AsyncRedisManager(redis_url) if redis_url else None params = { 'async_mode': 'aiohttp', 'cors_allowed_origins': allowed_hosts(settings), 'client_manager': mq } # if mq: # params['client_manager'] = mq sio = socketio.AsyncServer(**params) app = web.Application() sio.attach(app) return sio, app, mq
def __init__(self, redis_host: str, host: Union[list, tuple], wsm_db: Dict): # init socket.io # use default manager if redis_host is "" self.sio_mgr = socketio.AsyncRedisManager(redis_host) if redis_host != "" else None self.skt = socketio.AsyncServer(client_manager=self.sio_mgr, async_mode='aiohttp', ping_timeout=10, ping_interval=5) self.skt_AsgiApp = aiohttp.web.Application() self.skt.attach(self.skt_AsgiApp) # set hosts and id self.host = host self.r_host = redis_host self.id = nd_utils.getRandomStr(32) # command executer # self.mExec = nd_msg.MsgExec(self.id) # socket.io events # # greeter # self.skt.on("connect", self._greeter_conn, namespace="/greeter") # self.skt.on("disconnect", self._greeter_disConn, namespace="/greeter") # self.skt.on("message", self._greeter_message, namespace="/greeter") # user self.skt.on("connect", self._user_conn, namespace="/user") self.skt.on("disconnect", self._user_disConn, namespace="/user") self.skt.on("message", self._user_message, namespace="/user") # worker self.skt.on("connect", self._worker_conn, namespace="/worker") self.skt.on("disconnect", self._worker_disConn, namespace="/worker") self.skt.on("message", self._worker_message, namespace="/worker") # workspaceManager self.wsmDbSettings = wsm_db self.fMan = nd_workspace_manager. \ WorkspaceManager(db_host=wsm_db["host"], db_port=wsm_db["port"], db_name=wsm_db["name"], files_dir=wsm_db["files"]) # taskPool self.taskPool = nd_task_pool.TaskPool() # userManager self.userMan = nd_user.UserManager()
# "message", packet.dict(), namespace=self.namespace # ) # Emit to name-space return PacketModel(content="Delivered", content_type="application/txt").dict() # Call-Back async def process_packet(self, packet: PacketModel): # some processing on packet # store in db # stream processing # upload chunks # etc pass mgr = socketio.AsyncRedisManager( "redis://localhost/0" ) # Message Queue is for working with distributed applications sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*") sio.register_namespace( GreyRookNameSpace("/GreyRook")) # register the namespace asgi = socketio.ASGIApp(sio) app.mount("/ws", asgi) # mount Socket.Io to FastApi with /ws path class SampleResponseModel(BaseModel): message: str class Sample400ResponseModel(BaseModel): detail: str
import socketio from app.core.config import settings from app.core.log import logger external_sio = socketio.AsyncRedisManager(settings.PUSHER_REDIS_DSN, write_only=True, logger=logger)
from fastapi import FastAPI from pydantic import BaseModel from starlette.middleware.cors import CORSMiddleware from starlette.responses import HTMLResponse from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware redis = Redis(settings.REDIS_HOST) class Broadcast(BaseModel): data : str app = FastAPI() app.add_middleware(CORSMiddleware, allow_origins=['*'], allow_methods=['GET', 'POST']) app.add_middleware(ProxyHeadersMiddleware) mgr = socketio.AsyncRedisManager('redis://%s' % settings.REDIS_HOST) sio = socketio.AsyncServer(async_mode='asgi', client_manager=mgr) app_sio = socketio.ASGIApp(sio, app) from shared.models import Address, Transaction, Block, Utxo from shared.settings import POOLS from peewee import RawQuery, fn from datetime import datetime, timedelta @sio.on('subscribe') async def subscribe(sid, room): sio.enter_room(sid, room) def get_latest_block(): return Block.select().order_by(Block.height.desc()).limit(1)[0]
import socketio from app.core.config import settings from socketio.asyncio_namespace import AsyncNamespace class SocketNameSpace(AsyncNamespace): # functions that have on_ prefix recognized as event async def on_connect(self, sid, *args, **kwargs): # on connect event print(f"{sid}: connected") async def on_disconnect(self, sid): # on disconnect event print(f"{sid}: disconnected") mgr = socketio.AsyncRedisManager(settings.REDIS_URI) sio = socketio.AsyncServer( async_mode="asgi", cors_allowed_origins=[], client_manager=mgr, logger=True, ) sio.register_namespace(SocketNameSpace("/ws")) # register the namespace asgi_socket = socketio.ASGIApp(sio)
} logger = logging.getLogger(__name__) # the game god receives prayers and appropriately changes the state # game_god = fastapi.FastAPI() # game_god.add_middleware( # cors.CORSMiddleware, # allow_origins=["*"], # allow_credentials=True, # allow_methods=["*"], # allow_headers=["*"], # ) games = dict() # from game id to game object sio = socketio.AsyncRedisManager("redis://socketio_pubsub", write_only=True) game_store = None # game_god = faust.App( # "game_god", # broker=f"kafka://{EVENTHUB_HOST}", # broker_credentials=faust.SASLCredentials( # username=EVENTHUB_USERNAME, # password=EVENTHUB_PASSWORD, # ssl_context=helpers.create_ssl_context() # ), # stream_wait_empty=False # ) game_god = faust.App("game_god", broker="kafka://kafka:9092",
from fastapi.param_functions import Body import schema from typing import List from fastapi import APIRouter, Depends from sqlalchemy.orm import Session from utils import get_db from core.config import settings import crud import socketio sio = socketio.AsyncRedisManager(settings.REDIS_URI, write_only=True) router = APIRouter() async def broadcast(word: str): await sio.emit("new word", data={"word": word.dict()}, namespace="/ws") @router.put("/", response_model=schema.WordInDB) async def create_word(word: schema.WordCreate, db: Session = Depends(get_db)): item = crud.word.create(db=db, obj_in=word) await broadcast(schema.WordInDB.from_orm(item)) return item @router.get("/", response_model=List[schema.WordInDB]) async def read_words(db: Session = Depends(get_db)): words = crud.word.get_multi(db=db, limit=None)
from anthill.framework.handlers.base import (TranslationHandlerMixin, LogExceptionHandlerMixin, SessionHandlerMixin, CommonRequestHandlerMixin) import socketio import logging __all__ = [ 'BaseSocketIOHandler', 'SocketIOHandler', 'socketio_server', 'socketio_client' ] logger = logging.getLogger('anthill.application') socketio_server = socketio.AsyncServer( client_manager=socketio.AsyncRedisManager('redis://', logger=logger), async_mode='tornado', engineio_logger=logger, logger=logger, ping_timeout=settings.WEBSOCKET_PING_TIMEOUT, ping_interval=settings.WEBSOCKET_PING_INTERVAL, max_http_buffer_size=settings.WEBSOCKET_MAX_MESSAGE_SIZE, cookie=settings.SESSION_COOKIE_NAME) socketio_client = socketio.AsyncClient(logger=logger, engineio_logger=logger, reconnection_delay=1, reconnection_delay_max=600) BaseSocketIOHandler = socketio.get_tornado_handler(socketio_server) class SocketIOHandler(TranslationHandlerMixin, LogExceptionHandlerMixin,
import os from aiohttp import web import motor.motor_asyncio import socketio from json import dumps, loads while (True): try: mgr = socketio.AsyncRedisManager('redis://redis') except: print("redis is not responding, trying again in 1 sec...") sleep(1) continue break mgr = socketio.AsyncRedisManager('redis://redis') sio = socketio.AsyncServer(client_manager=mgr) app = web.Application() sio.attach(app) client = motor.motor_asyncio.AsyncIOMotorClient("mongodb") db = client.messages logged_in_users = {} async def index(request): """Serve the client-side application.""" with open('index.html') as f: return web.Response(text="hello world", content_type='text/html') @sio.on('connect', namespace='/chat')
load_dotenv(find_dotenv()) static_files = { "/": { 'filename': 'index.html', 'content_type': 'text/html' }, } async def index(request): """Serve the client-side application.""" with open('index.html') as f: return web.Response(text=f.read(), content_type='text/html') mgr = socketio.AsyncRedisManager(os.getenv("REDIS")) sio = socketio.AsyncServer(client_manager=mgr) app = web.Application() sio.attach(app) app.router.add_get('/', index) httpServerEventLoop = asyncio.new_event_loop() ver = 0.1 UIUpdateInterval = 0.1 settings = None wst = None #WebSocketThread class SocketMessageTypes(Enum): CONNECTED = "Connected" DISCONNECTED = "Disconnected" CONTROL = "Control"
def create_socketClient(self): self.external_sio = socketio.AsyncRedisManager('redis://', write_only=True)
from sanic import Sanic, request from sanic.response import html, json from sanic_cors import CORS, cross_origin from db import ChatFactory import socketio from sqlalchemy.exc import IntegrityError mgr = socketio.AsyncRedisManager('redis://127.0.0.1:6379/1') #sio = socketio.AsyncServer(client_manager=mgr, async_mode='sanic') sio = socketio.AsyncServer(async_mode='sanic') app = Sanic() CORS(app, automatic_options=True) sio.attach(app) async def background_task(): """Example of how to send server generated events to clients.""" count = 0 while True: await sio.sleep(5) count += 1 await sio.emit('test', {'data': 'Server generated event:{}'.format(count)}, namespace='/test') @app.listener('before_server_start') def before_server_start(sanic, loop): sio.start_background_task(background_task)
import socketio from WebSocket.namespace.Chat import ChatNameSpace from settings.Settings import database_settings mgr = socketio.AsyncRedisManager(database_settings.REDIS_URL) sio = socketio.AsyncServer(client_manager=mgr, async_mode='asgi') sio.register_namespace(ChatNameSpace('/chat')) app = socketio.ASGIApp(sio)
game_server_fast = fastapi.FastAPI() # TODO: i don't need all of these game_server_fast.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) oauth2_scheme = fastapi.security.OAuth2PasswordBearer(tokenUrl="/token") game_server_sio = socketio.AsyncServer( async_mode="asgi", client_manager=socketio.AsyncRedisManager(f"redis://socketio_pubsub"), ping_timeout=300, ping_interval=20, cors_allowed_origins="*", ) game_server = socketio.ASGIApp(socketio_server=game_server_sio, other_asgi_app=game_server_fast) # the game store holds keys corresponding to the following: # - game id to game attributes (these are available in the # game browser) # - game id keys to sorted set used to manage game specific keys and # expirations # - sid to game id # - set of game_ids
import aioredis import socketio from app.core.config import settings from app.core.log import logger from app.pusher.namespaces import root_namespace, user_namespace mgr = socketio.AsyncRedisManager(settings.PUSHER_REDIS_DSN) sio = socketio.AsyncServer(async_mode="asgi", client_manager=mgr, logger=logger) sio.register_namespace(root_namespace) sio.register_namespace(user_namespace) async def on_startup(): sio.cache = await aioredis.create_redis_pool(settings.PUSHER_REDIS_DSN) async def on_shutdown(): sio.cache.close() await sio.cache.wait_closed() app = socketio.ASGIApp(sio, on_startup=on_startup, on_shutdown=on_shutdown)
PlayerSID, SpectatorSID, RoomId, PlayerId, ) from aiplayground.utils.broker import get_room_player from aiplayground.utils.expect import expect from aiplayground.logging import logger from redorm import InstanceNotFound # TODO: Confirm CORS isn't being problematic if settings.SOCKETIO_REDIS_URL is None: sio = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*") else: logger.info("Creating Redis Manager") sio_manager = socketio.AsyncRedisManager(settings.SOCKETIO_REDIS_URL) logger.info("Creating Socketio Server") sio = socketio.AsyncServer(async_mode="asgi", client_manager=sio_manager, cors_allowed_origins="*") logger.info("Created Socketio Server") class GameBroker(socketio.AsyncNamespace): async def acknowledge_join(self, room_id: RoomId, player_id: PlayerId) -> None: room = Room.get(room_id) await JoinAcknowledgementMessage( roomid=room_id, playerid=player_id).send(sio=self, to=room.server_sid)
import socketio import jwt from scripts.help_functions import JWT_ALGORITHM, JWT_SECRET sio = socketio.AsyncServer( async_handlers=True, client_manager=socketio.AsyncRedisManager('redis://*****:*****@sio.on('connect') async def connect(sid, environ): room = environ['QUERY_STRING'].split('&')[0].split('=')[1] token = environ['QUERY_STRING'].split('&')[1].split('=')[1] role = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM], options={'verify_exp': False})['role'] sio.enter_room(sid, room) #print("connect ", sid, role,room) if not list(set(role.split(';')) & set(['eventdashboard'])): return False #return True @sio.on('disconnect') async def disconnected(sid): pass #sio.leave_room(sid,'eventdashboard') #(sio.rooms(sid)) #print("disconnect ", sid)
world_repository = RedisDataRepository(async_redis_data, library_repository, map_repository) channels_repository = WebsocketChannelsRepository(strict_redis) redis_queues_service = RedisMultipleQueuesPublisher( async_redis_queue, num_queues=settings.WORKERS) websocket_channels_service = WebsocketChannelsService( channels_repository=channels_repository, data_repository=world_repository, redis_queue=redis_queues_service) pubsub_manager = PubSubManager(async_redis_queue) events_subscriber_service = RedisPubSubEventsSubscriberService(pubsub_manager) events_publisher_service = RedisPubSubEventsPublisherService(pubsub_manager) mgr = socketio.AsyncRedisManager('redis://{}:{}/{}'.format( settings.REDIS_HOST, settings.REDIS_PORT, settings.REDIS_SIO_DB)) transport = SocketioTransportInterface( socketio.AsyncServer(client_manager=mgr)) pubsub_observer = PubSubObserver(world_repository) async_redis_queues = get_redis_factory(RedisType.QUEUES) queue = RedisQueueConsumer(async_redis_queues, 0) worker_queue_manager = WorkerQueueService(queue) cmds_observer = commands_observer_factory(transport) connections_manager = ConnectionsManager() connections_observer = ConnectionsObserver(transport, pubsub_observer, world_repository, events_subscriber_service, connections_manager, cmds_observer)
#!/usr/bin/env python # coding:utf-8 # Copyright (C) dirlt import logging import socketio from aiohttp import web channel = socketio.AsyncRedisManager('redis://*****:*****@%(lineno)d: %(msg)s' logging.basicConfig(level=logging.WARN, format=DEFAULT_LOGGING_FORMAT) async def handle_fanout(request): return web.Response(text='query = "{}"'.format(request.query_string)) namespace = '/'
def __init__(self, bot, redis_uri): self.io = socketio.AsyncRedisManager(redis_uri, write_only=True, channel='flask-socketio') self.bot = bot
# producer = KafkaProducer(bootstrap_servers='rc1a-dv477guks4sitb1e.mdb.yandexcloud.net:9092', # value_serializer=lambda v: dumps(v).encode('utf-8'), # compression_type="lz4", # linger_ms=5) # producer = KafkaProducer( # bootstrap_servers=['rc1a-dv477guks4sitb1e.mdb.yandexcloud.net:9092','rc1b-k2eb8k0sebln2jsp.mdb.yandexcloud.net:9092','rc1c-nctc8hqesvbarhad.mdb.yandexcloud.net:9092'], # security_protocol="SASL_PLAINTEXT", # sasl_mechanism="SCRAM-SHA-512", # sasl_plain_password="******", # sasl_plain_username="******", # value_serializer=lambda v: dumps(v).encode('utf-8'), # compression_type="lz4", # linger_ms=5) mgr = socketio.AsyncRedisManager(Config.REDIS_URL) sio = socketio.AsyncServer(async_mode='asgi', client_manager=mgr, cors_allowed_origins=[]) socket_app = socketio.ASGIApp(sio) background_task_started = False async def background_task(): while True: await sio.sleep(10) await sio.emit('signal', {'status': 'ok'}) @sio.on("connect") async def test_connect(sid, environ): global background_task_started if not background_task_started: sio.start_background_task(background_task)