def receive(self, text_data):
global max_id
obj = json.loads(text_data)
player = players[self.scope["session"]["player"]]
if obj["action"] == "move":
new_x = player.x + obj["deltaX"]
new_y = player.y + obj["deltaY"]
player.x = max(min(new_x, map_width / 2 - char_size / 2),
-map_width / 2 + char_size / 2)
player.y = max(min(new_y, map_height / 2 - char_size / 2),
-map_height / 2 + char_size / 2)
elif obj["action"] == "fire":
target = get_target(player, obj["rotation"])
if target is not None:
if target.is_player:
player.score += player_kill
database_sync_to_async(
updateScore(player.score,
self.scope["session"]["name"]))
target.reset()
else:
player.score -= bot_kill
database_sync_to_async(
updateScore(player.score,
self.scope["session"]["name"]))
del bots[target.uid]
new_c = Character(map_width, map_height, rand, max_id,
speed, False)
bots[max_id] = new_c
max_id += 1
async def poll_specifications(
self) -> Tuple['SandboxSpecs', 'ContainerSpecs']:
"""Poll the specifications of the sandbox's host and its containers.
The sandbox must be enabled, `SandboxDisabledError` will be raised
otherwise."""
if not self.enabled:
raise SandboxDisabledError(
"Cannot poll specifications of a disabled sandbox")
async with ASandbox(self.url) as asandbox:
raw_specs, libs = await asyncio.gather(asandbox.specifications(),
asandbox.libraries())
host, container = raw_specs["host"], raw_specs["container"]
aw1 = database_sync_to_async(
SandboxSpecs.objects.filter(sandbox=self).update)(
polled=True,
sandbox_version=host["sandbox_version"],
docker_version=host["docker_version"],
cpu_core=host["cpu"]["core"],
cpu_logical=host["cpu"]["logical"],
cpu_freq_min=host["cpu"]["freq_min"],
cpu_freq_max=host["cpu"]["freq_max"],
memory_ram=host["memory"]["ram"],
memory_swap=host["memory"]["swap"],
memory_storage=host["memory"]["storage"])
aw2 = database_sync_to_async(
ContainerSpecs.objects.filter(sandbox=self).update)(
polled=True,
working_dir_device=container["working_dir_device"],
count=container["count"],
process=container["process"],
cpu_count=container["cpu"]["count"],
cpu_period=container["cpu"]["period"],
cpu_shares=container["cpu"]["shares"],
cpu_quota=container["cpu"]["quota"],
memory_ram=container["memory"]["ram"],
memory_swap=container["memory"]["swap"],
memory_storage=container["memory"]["storage"],
writing_io=container["io"]["read_iops"],
writing_bytes=container["io"]["read_bps"],
reading_io=container["io"]["write_iops"],
reading_bytes=container["io"]["write_bps"],
libraries=libs["libraries"],
bin=libs["bin"])
await asyncio.gather(aw1, aw2)
host = await database_sync_to_async(SandboxSpecs.objects.get
)(sandbox=self)
container = await database_sync_to_async(ContainerSpecs.objects.get
)(sandbox=self)
return host, container
def __call__(self, scope):
database_sync_to_async(close_old_connections)()
if scope['headers'][0][0] == 'pytest':
return self.inner(dict(scope, user=scope['headers'][0][1]))
token = parse_qs(scope["query_string"].decode("utf8"))["token"][0]
# todo add token verification
decoded_data = jwt_decode(token,
settings.SECRET_KEY,
algorithms=["HS256"])
pk = decoded_data["user_id"]
return self.inner(dict(scope, user=pk))
async def receive_json(self, data):
# Incomming messages:
# {type: FOO, data: {...}}
type = data.get("type")
if not type:
return
if type == "ADD_PATH":
# {type: ADD_PATH, data: {points: [], color: foo, ...}}
path_data = data.get("data")
add_path = database_sync_to_async(Board.add_path)
new_version = await add_path(self.board_id, path_data)
# broadcast to other clients
await self.channel_layer.group_send(
self.group_name,
{
"type": "broadcast_path",
"message": {
"type": "REMOTE_CHANGE",
"data": {
"path": path_data,
"version": new_version,
},
"from": self.channel_name,
},
},
)
await self.send_json({
"type": "ACK",
"data": {
"version": new_version
}
})
if type == "REQ_INIT":
# await self.send_json({})
await self.init_data()
async def auth_by_api_key(self, api_key: str):
# Already authenticated
if self._authed:
return
if not api_key:
await self.send_json(
{
"code": 400,
"detail": _("No api key provided")
}, close=True)
async_is_valid = database_sync_to_async(APIKey.objects.is_valid)
result = await async_is_valid(api_key)
if result:
await self.send_json({"code": 200, "detail": _("ok")})
self._authed = True
else:
await self.send_json(
{
"code": 400,
"detail": _("Invalid api key")
},
close=True,
)
async def site_updated(self, event: Dict[str, Any]) -> None: # pylint: disable=unused-argument
if self.site is not None:
await database_sync_to_async(self.site.refresh_from_db)()
if not database_sync_to_async(self.site.can_be_edited_by)(
self.scope["user"]):
await self.close()
async def connect(self):
print(self.scope["user"])
# await self.addChannelToGroupsOnConnect('0706a3c0da537a63bdf372c7c32176d6c2c1ea1c')
grouplist = database_sync_to_async(
self.createGroupList)('0706a3c0da537a63bdf372c7c32176d6c2c1ea1c')
print(grouplist)
await self.channel_layer.group_add("mamad", self.channel_name)
await self.accept()
async def site_updated(self, event: Dict[str, Any]) -> None: # pylint: disable=unused-argument
for site_id in self.site_ids:
site = Site.objects.get(id=site_id)
await database_sync_to_async(site.refresh_from_db)()
if not database_sync_to_async(site.can_be_edited_by)(self.scope["user"]):
await self.close()
def __call__(self, scope):
user = None
database_sync_to_async(close_old_connections)()
parsed_qs = parse_qs(scope["query_string"].decode("utf8"))
if parsed_qs:
token = parsed_qs["token"][0]
try:
UntypedToken(token)
except (InvalidToken, TokenError) as e:
return self.inner(dict(scope, user=user))
else:
decoded_data = jwt_decode(token,
settings.SECRET_KEY,
algorithms=["HS256"])
user = database_sync_to_async(
User.objects.get)(id=decoded_data["user_id"])
return self.inner(dict(scope, user=user))
def __call__(self, scope):
database_sync_to_async(close_old_connections)()
if scope['headers'][0][0] == 'pytest':
return self.inner(dict(scope, user=scope['headers'][0][1]))
token = parse_qs(scope["query_string"].decode("utf8"))["token"][0]
try:
UntypedToken(token)
except (InvalidToken, TokenError):
return None
else:
decoded_data = jwt_decode(token,
settings.SECRET_KEY,
algorithms=["HS256"])
pk = decoded_data["user_id"]
return self.inner(dict(scope, user=pk))
async def get_daq(pk=None, name=None, tags=None):
# TODO: add ability to choose wanted daq
# for now, hardcoded
try:
daq = database_sync_to_async(DAQServer.objects.get(pk=1))
except ObjectDoesNotExist:
daq = None
return daq
async def auth(self, token: str):
# Already authenticated
if self.user.is_authenticated:
return
async_user_get = database_sync_to_async(User.objects.get)
try:
user = await async_user_get(auth_token__key=token)
self.user = user
await self.send_json({"code": 200, "detail": "认证成功"})
except User.DoesNotExist:
await self.send_json({"code": 400, "detail": "认证失败"}, close=True)
async def receive(self, text_data):
text_data_json = json.loads(text_data)
message_body = text_data_json['message_body']
user_id = self.scope['user'].id
creator = {
'id': self.member['id'],
'first_name': self.member['first_name'],
'last_name': self.member['last_name'],
'preferred_name': self.member['preferred_name']
}
if self.member['id'] == user_id:
create_message = database_sync_to_async(
lambda: Message.objects.create(creator_id=user_id,
message_body=message_body,
room_id=self.room_id))
messageObject = await create_message()
save_message = database_sync_to_async(lambda: messageObject.save())
await save_message()
await self.channel_layer.group_send(
self.room_group_name, {
'type':
'chat_message',
'id':
messageObject.id,
'message_body':
message_body,
'creator':
creator,
'datetime_created':
messageObject.datetime_created.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
})
else:
await self.channel_layer.group_discard(self.room_group_name,
self.channel_name)
async def connect(self):
self.room_name = self.scope['url_route']['kwargs']['room_name']
self.room_group_name = 'chat_%s' % self.room_name
# Join room group
await self.channel_layer.group_add(
self.room_group_name,
self.channel_name
)
await self.accept()
# note: アクセス権がある room つくって permission 確認とかいれたい
self.user = self.scope.get('user')
self.chat_room = database_sync_to_async(ChatRoom.objects.get)(room_id=self.room_name)
async def connect(self):
self.room_id = int(self.scope['url_route']['kwargs']['room_id'])
self.room_group_name = 'chat_%s' % str(self.room_id)
try:
user_id = self.scope['user'].id
get_user = database_sync_to_async(lambda: Room.objects.get(
id=self.room_id).members.get(id=user_id))
user = await get_user()
self.member = user.__dict__
await self.channel_layer.group_add(self.room_group_name,
self.channel_name)
await self.accept()
except ObjectDoesNotExist:
pass
async def receive_like(self, text_data_json: dict) -> dict:
message_id = text_data_json["message_id"]
is_liked = text_data_json["like"]
get_message = database_sync_to_async(
lambda: Message.objects.get(id=message_id))
message: Message = await get_message()
if is_liked:
await database_sync_to_async(
lambda: message.liked_users.add(self.scope["user"].id))()
else:
await database_sync_to_async(
lambda: message.liked_users.remove(self.scope["user"].id))()
return {
"type": "send_like",
"message_id": message_id,
"like": is_liked,
"user_id": self.scope["user"].id,
}
async def auth_by_auth_token(self, auth_token: str):
"""Authenticate by auth token."""
# Already authenticated
if self._authed:
return
async_token_get = database_sync_to_async(Token.objects.get)
try:
await async_token_get(key=auth_token)
except Token.DoesNotExist:
await self.send_json({
"code": 401,
"detail": _("Invalid auth token.")
})
return
await self.send_json({"code": 200, "detail": _("Authenticated.")})
self._authed = True
async def receive_message(self, text_data_json: dict) -> dict:
message_body = text_data_json["message_body"]
previous_message_id = text_data_json["previous_message_id"]
tagged_users = text_data_json["tagged_users"]
creator = {
"id": self.member["id"],
"first_name": self.member["first_name"],
"last_name": self.member["last_name"],
"preferred_name": self.member["preferred_name"],
}
previous_message = None
if previous_message_id is not None:
get_previous_message = database_sync_to_async(
lambda: Message.objects.get(id=previous_message_id))
previous_message_result = await get_previous_message()
get_previous_message_tagged_users = database_sync_to_async(
lambda: previous_message_result.tagged_users.values_list(
"id", flat=True))
tagged_users_previous = await get_previous_message_tagged_users()
previous_message = {
"id":
previous_message_id,
"message_body":
previous_message_result.content,
"creator_id":
previous_message_result.creator_id,
"datetime_created":
previous_message_result.datetime_created.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ"),
"tagged_users":
list(tagged_users_previous),
}
create_message = database_sync_to_async(lambda: Message.objects.create(
creator_id=self.scope["user"].id,
content=message_body,
room_id=self.room_id,
previous_message_id=previous_message_id,
))
message_object: Message = await create_message()
save_message = database_sync_to_async(lambda: message_object.save())
await save_message()
add_tagged_users = database_sync_to_async(
lambda: message_object.tagged_users.add(*tagged_users))
await add_tagged_users()
return {
"type":
"send_message",
"id":
message_object.id,
"message_body":
message_body,
"creator":
creator,
"previous_message":
previous_message,
"datetime_created":
message_object.datetime_created.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
"tagged_users":
tagged_users,
}
async def disconnect(self, code):
database_sync_to_async(logout)(self.scope)
def ensure_async(method: typing.Callable):
if asyncio.iscoroutinefunction(method):
return method
return database_sync_to_async(method)
external_source_video_id=external_source_video_id,
external_source_channel_id=external_source_channel_id,
video=video_record,
)
was_synced = True
video_record = media_services.mark_video_as_viewable_and_synced(
video=video_record)
shutil.rmtree(output_dir)
logger.info(
'Done syncing external video %s to Channel %s of user %s...',
external_source_video_id,
channel_id,
user.id,
)
else:
was_synced = False
video_record = synced_video.video
logger.info(
'Already synced external video %s to Channel %s of user %s...',
external_source_video_id,
channel_id,
user.id,
)
return was_synced, video_record
get_channel_syncs_which_are_syncing_async = database_sync_to_async(
get_channel_syncs_which_are_syncing, thread_sensitive=True)
get_channel_syncs_async = database_sync_to_async(get_channel_syncs,
thread_sensitive=True)
from base64 import b64encode import pytest from channels.db import database_sync_to_async from channels.layers import get_channel_layer from channels.testing import WebsocketCommunicator from dateutil.relativedelta import relativedelta from django.utils import timezone from rest_framework.authtoken.models import Token from karrot.subscriptions.consumers import WebsocketConsumer, TokenAuthMiddleware, get_auth_token_from_subprotocols from karrot.subscriptions.models import ChannelSubscription from karrot.subscriptions.routing import AllowedHostsAndFileOriginValidator from karrot.users.factories import UserFactory AsyncUserFactory = database_sync_to_async(UserFactory) # These async fixtures only work for python 3.6+ (needs async yield) # # @pytest.fixture # async def communicator(request): # communicator = WebsocketCommunicator(SyncWebsocketConsumer, '/') # yield communicator # await communicator.disconnect() # # @pytest.fixture # async def user(): # yield await AsyncUserFactory() # # # @pytest.fixture
def send_to_channel(self, name, event, datas={}, _from=None):
datas.update({'type': 'send.event', 'dispatch': event, 'uid': str(self.uid)})
if _from: datas['from'] = _from
logger.info('send room: %s, event: %s, datas %s' % (name, event, str(datas)), extra={'user': self.user})
database_sync_to_async(self.historize_channel)(name, event, datas)
async_to_sync(self.channel_layer.group_send)(name, datas)
def connect(self):
self.user = self.get_user_obj(self.scope)
database_sync_to_async(self.save_user_channel)()
self.accept()
def leave_channel(self, name):
if name in self.channels_list:
logger.info('leave room: %s' % name, extra={'user': self.user})
database_sync_to_async(self.disconnect_channel)(_type, name, self.id)
async_to_sync(self.channel_layer.group_discard)(name, self.channel_name)
def join_channel(self, _type, name):
if name not in self.channels_list:
logger.info('join channel: %s' % name, extra={'user': self.user})
database_sync_to_async(self.connect_channel)(_type, name, self.id)
async_to_sync(self.channel_layer.group_add)(name, self.channel_name)
