#!/usr/bin/env python

# Set this variable to "threading", "eventlet" or "gevent" to test the

# different async modes, or leave it set to None for the application to choose

# the best option based on available packages.

async_mode = None

if async_mode is None:

try:

import eventlet

async_mode = 'eventlet'

except ImportError:

pass

if async_mode is None:

try:

from gevent import monkey

async_mode = 'gevent'

except ImportError:

pass

if async_mode is None:

async_mode = 'threading'

print('async_mode is ' + async_mode)

# monkey patching is necessary because this application uses a background

# thread

if async_mode == 'eventlet':

import eventlet

eventlet.monkey_patch()

elif async_mode == 'gevent':

from gevent import monkey

monkey.patch_all()

import time

import random

import datetime

import uuid

from threading import Thread

from flask import Flask, render_template, session, request

from flask_socketio import SocketIO, emit, join_room, leave_room, \

close_room, rooms, disconnect

from room import Room

from draft.draft_type import Draft_type

import boto3

#dynamodb = boto3.resource('dynamodb')

#table = dynamodb.Table('spypartydraft_test')

table = None

app = Flask(__name__)

app.config['SECRET_KEY'] = 'secret!'

socketio = SocketIO(app, async_mode=async_mode)

thread = None

dynamo_db_table_name = "spypartydraft_test"

ROOM_LENGTH = 5

room_map = {}

draft_types = Draft_type.get_draft_type('config/draft_types.json')

def generate_room_id():

return 'sp' + ''.join(random.choice('0123456789abcdef') for i in range(ROOM_LENGTH))

def create_room(id, draft_type_id):

room_map[id] = Room(id, broadcast_to_room, broadcast_to_spectator, draft_types[draft_type_id])

def broadcast_to_spectator(spectator_id, data):

emit('spectator_update', data, room=spectator_id)

def tell_clients_draft_has_started(room):

}, room=room.id)

def background_thread():

print "should really clean things up here"

@app.route('/')

def index():

return render_template('index.html')

@socketio.on('my event', namespace='/test')

def test_message(message):

session['receive_count'] = session.get('receive_count', 0) + 1

emit('my response',

{'data': message['data'], 'count': session['receive_count']})

@socketio.on('my broadcast event', namespace='/test')

def test_broadcast_message(message):

broadcast=True)

@socketio.on('create', namespace='/test')

def create(message):

broadcast_to_room(id, "Players currently in room: {}".format(' and '.join(room_map[id].player_list)))

def broadcast_to_room(room_id, msg):

room=room_id)

@socketio.on('join_draft', namespace='/test')

def join_draft(message):

tell_clients_draft_has_started(room)

@socketio.on('join', namespace='/test')

def join(message):

'count': session['receive_count']})

@socketio.on('leave', namespace='/test')

def leave(message):

'count': session['receive_count']})

@socketio.on('close room', namespace='/test')

def close(message):

close_room(message['room'])

@socketio.on('coin_flip', namespace='/test')

def coin_flip(message):

}, room=room.id)

@socketio.on('get_draft_types', namespace='/test')

def get_draft_types():

emit('draft_types_update', dts)

def ask_spy_order(room, msg):

emit('select_spy_order', data, room=room.id)

def ask_pick_order(room, msg):

emit('select_pick_order', data, room=room.id)

def persist_draft(room):

print "persisted item for room: {}".format(room.id)

def dump_draft(room):

emit(response_type, room.serialize(), room=room.id)

@socketio.on('second_option_pick', namespace='/test')

def second_option_pick(message):

dump_draft(room)

@socketio.on('second_option_spy', namespace='/test')

def second_option_spy(message):

dump_draft(room)

@socketio.on('first_option_form', namespace='/test')

def first_option_form(message):

}, room=room.id)

@socketio.on('disconnect_request', namespace='/test')

def disconnect_request(message):

print 'disconnecting'

disconnect()

@socketio.on('draft_map', namespace='/test')

def draft_map(message):

dump_draft(room)

@socketio.on('connect', namespace='/test')

def test_connect():

emit('my response', {'data': 'Connected', 'count': 0})

@socketio.on('disconnect', namespace='/test')

def test_disconnect():

print('Client disconnected', request.sid)

@socketio.on('spectate_draft', namespace='/test')

def spectate_draft(message):

broadcast_to_spectator(request.sid, room.get_spectator_data())

@socketio.on('chat_message', namespace='/test')

def chat_message(message):

emit('chat_event', data, room=room.id)

if __name__ == '__main__':

socketio.run(app)