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)
