class Server():
def __init__(self, port):
self.port = port
self.app = Flask(__name__,
static_folder='assets/static',
static_url_path='/static',
template_folder='assets/templates')
self.app.register_blueprint(routes)
self.socketio = SocketIO(self.app)
# Log to stdout.
sh = logging.StreamHandler(sys.stdout)
self.app.logger.addHandler(sh)
@self.socketio.on('connect')
def on_connect():
"""
This seems necessary to get
the SocketIO emitting working properly...
"""
pass
def start(self):
self.app.logger.debug('starting the nomadic server...')
self.socketio.run(self.app, port=self.port)
def refresh_clients(self):
self.socketio.emit('refresh')
class Server():
def __init__(self, port):
self.port = port
self.app = Flask(__name__,
static_folder='assets/static',
static_url_path='/static',
template_folder='assets/templates')
self.app.register_blueprint(routes)
self.socketio = SocketIO(self.app)
# Log to stdout.
sh = logging.StreamHandler(sys.stdout)
self.app.logger.addHandler(sh)
@self.socketio.on('connect')
def on_connect():
"""
This seems necessary to get
the SocketIO emitting working properly...
"""
pass
def start(self):
self.app.logger.debug('starting the nomadic server...')
self.socketio.run(self.app, port=self.port)
def refresh_clients(self):
self.socketio.emit('refresh')
def ansible_server(send_queue, recv_queue):
app = Flask(__name__)
socketio = SocketIO(app)
@socketio.on('message')
def receive_message(msg):
data = json.loads(msg)
# Special channel for gamepad data
if data['header']['msg_type'] == 'gamepad':
mc.set('gamepad', data['content'])
else:
recv_queue.put_nowait(data)
@socketio.on('connect')
def on_connect():
print 'Connected to Dawn.'
@socketio.on_error()
def on_error(e):
print e
def send_process(send_queue):
while True:
try:
msg = send_queue.get_nowait()
socketio.emit('message', msg)
time.sleep(.02)
except Empty:
time.sleep(.02)
send_p = Thread(target=send_process, args=(send_queue,))
send_p.daemon = True
send_p.start()
socketio.run(app, host='0.0.0.0')
def ansible_server(send_queue, recv_queue):
app = Flask(__name__)
socketio = SocketIO(app)
@socketio.on('message')
def receive_message(msg):
data = json.loads(msg)
# Special channel for gamepad data
if data['header']['msg_type'] == 'gamepad':
mc.set('gamepad', data['content'])
else:
recv_queue.put_nowait(data)
@socketio.on('connect')
def on_connect():
print 'Connected to Dawn.'
@socketio.on_error()
def on_error(e):
print e
def send_process(send_queue):
while True:
try:
msg = send_queue.get_nowait()
socketio.emit('message', msg)
time.sleep(.02)
except Empty:
time.sleep(.02)
send_p = Thread(target=send_process, args=(send_queue, ))
send_p.daemon = True
send_p.start()
socketio.run(app, host='0.0.0.0')
class Server(Thread):
def __init__(self, __name__):
Thread.__init__(self)
self.app = Flask(__name__)
self.app.config['SECRET_KEY'] = 'secret!'
self.app.config['DEBUG'] = False
self.socketio = SocketIO(self.app)
def run(self):
print 'starting run in Server'
self.socketio.run(self.app, port=5001, host='0.0.0.0')
print 'ERROR ---------------------socket io exited'
def main():
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
db.init_app(app)
init_login(app)
init_admin_view(app, db)
with app.app_context():
db.create_all()
main_view = views.create_views()
app.register_blueprint(url_prefix = '/', blueprint = main_view)
socketio = SocketIO(app)
socketio.run(app, '0.0.0.0', 8080)
def main(argv):
global app, socketio, gpio_controller, rgb_controller
handle_args(argv)
gpio_controller = GPIOController();
rgb_controller = RGBController(gpio_controller)
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
app.debug = conf['server']['debug']
socketio = SocketIO(app)
server_conf = conf['server']
socketio.run(app,
use_reloader=server_conf['reload'],
host=server_conf['host'],
port=server_conf['port'])
def socketServer():
app = Flask(__name__)
socketio = SocketIO(app)
@socketio.on('appConnected')
def app_connected(json):
print('received json: ' + str(json))
@socketio.on('connect', namespace="/main")
def startSocket():
print "test message2"
@app.route('/')
def load():
return render_template("betaIndex.html")
@app.route('/launch')
def loadLaunch():
return render_template("testLaunch.html")
if __name__ == "__main__":
socketio.run(app, "localhost", 80)
@socketio.on('my event', namespace='/test')
def test_message(message):
pass
@socketio.on('connect', namespace='/test')
def test_connect():
pass
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
pass
# Start MQTT (Mosquitto)
mqttc = mosquitto.Mosquitto()
mqttc.on_message = on_message
mqttc.connect("127.0.0.1", 1883, 60, True)
mqttc.subscribe("log", 0)
signal.signal(signal.SIGINT, signal_handler)
if __name__ == '__main__':
mqtt_thread = MQTT_Thread()
mqtt_thread.start()
socketio.run(app, host='0.0.0.0', port=8000)
@socketio.on_error()
def error_handler(e):
print e
def join_into_room(id):
data = False
if id is not None:
join_room(id)
data = True
return data
# app.threaded=True
socketio.run(app, host="127.0.0.1", port=8000, policy_server=False)
# server sent events section
"""from redis import Redis
redis = Redis()
pubsub = redis.pubsub()
import time
from datetime import datetime
p = redis.pipeline()
app.config['ONLINE_LAST_MINUTES'] = 5
def mark_online(user_id):
global p
now = int(time.time())
host = get_ip_address_from_interface("eth0")
port = 8000
p_host = "localhost"
p_port = 9000
@app.route('/')
def index():
return render_template("synth", host=host, port=port)
@socketio.on('connect', namespace='/pendulum')
def test_connect():
print "Client connected"
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((p_host, p_port))
f = sock.makefile()
while True:
line = f.readline()
emit('data', {'data': line.strip() })
finally:
sock.close()
@socketio.on('disconnect', namespace='/pendulum')
def test_disconnect():
print('Client disconnected')
if __name__ == '__main__':
socketio.run(app, host=host, port=port)
'id': int(m['data'])
}, room='1')
else:
socketio.emit('new mail', {
'data': "Содержание %s" % cnt,
'date': datetime.now().strftime("%H:%M:%S"),
'title': 'Письмо №%s' % cnt,
'image': '',
'is_new': True
}, room='1')
def wr(fnc):
"""
Оборачиваем запуск сервера - запускаем тред для редиса.
"""
def f(*args, **kwargs):
import threading
t = threading.Thread(target=redis_thread)
t.daemon = True
t.start()
return fnc(*args, **kwargs)
return f
from socketio.sgunicorn import NginxGeventSocketIOWorker
NginxGeventSocketIOWorker.run = wr(NginxGeventSocketIOWorker.run)
if __name__ == "__main__":
socketio.run(app, port=8100)
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('disconnect')
@socketio.on('my room event', namespace='/test')
def on_join(data):
room = data['room']
msg = data['data']
emit('my response', {'data': msg}, room=room)
@socketio.on('join', namespace='/test')
def on_join(data):
room = data['room']
join_room(room)
# emit('my response',{'data':' He has entered the room.'}, room=room)
print('join')
@socketio.on('leave')
def on_leave(data):
room = data['room']
leave_room(room)
send(username + ' has left the room.', room=room)
print('leave')
if __name__ == "__main__":
socketio.run(app, '0.0.0.0', 8080)
rc_interface.clockwise(int(message))
emit('server-message', {'data': "clockwise"})
@socketio.on('counterclockwise', namespace='/test')
def counterclockwiseResponse(message):
rc_interface.counterclockwise(int(message))
emit('server-message', {'data': "counterclockwise"})
@socketio.on('left', namespace='/test')
def leftResponse(message):
rc_interface.left(int(message))
emit('server-message', {'data': "left"})
@socketio.on('right', namespace='/test')
def rightResponse(message):
rc_interface.right(int(message))
emit('server-message', {'data': "right"})
@socketio.on('stop', namespace='/test')
def stopResponse(message):
rc_interface.stop()
emit('server-message', {'data': "stop"})
@socketio.on('connect', namespace='/test')
def test_connect():
emit('connection-status', {'data': 'Connected'})
print "control on 5001"
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=5001)
self.randomNumberGenerator()
@app.route('/')
def index():
#only by sending this page first will the client be connected to the socketio instance
return render_template('index.html')
@socketio.on('connect', namespace='/test')
def test_connect():
# need visibility of the global thread object
global thread
print('Client connected')
#Start the random number generator thread only if the thread has not been started before.
if not thread.isAlive():
print "Starting Thread"
thread = RandomThread()
thread.start()
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected')
thread_stop_event.clear()
if __name__ == '__main__':
app.debug=True
socketio.run(app, host='0.0.0.0', port=5001)
socketio = SocketIO(app)
@app.route('/')
def main():
return render_template('main.html')
@socketio.on('connect', namespace='/socket')
def ws_conn():
data = {
#'button_1': GPIO.input(pin_out_1)
}
socketio.emit('status_btn', data, namespace='/socket')
@socketio.on('button', namespace='/socket')
def ws_btn(message):
button = message.get('button')
if button == 1:
#GPIO.output(pin_out_1, not GPIO.input(pin_out_1))
#data = {
# 'button_1': GPIO.input(pin_out_1)
#}
data = 1
socketio.emit('status_btn', data, namespace='/socket')
if __name__ == '__main__':
socketio.run(app, "0.0.0.0", port=5678)
application = Flask(__name__)
socketio = SocketIO(application)
lds = LidarServer()
@application.route('/')
def get_root():
return render_template('index.html')
@application.route('/data/')
def index():
return render_template('data.html')
# when we get a post full of data, send it!
@application.route("/publish/", methods = ['POST'])
def publish_data():
response = lds.publish_data()
socketio.emit('force_update', lds.get_data())
return response
# when we get a request for data, send it!
@socketio.on('update')
def get_data():
d = lds.get_data()
return d
if __name__ == '__main__':
application.debug = True
socketio.run(application)
dog.check_alive()
return render_template('index.html')
@socketio.on('connect', namespace='/tweets')
def tweets_connect():
dog.check_alive()
uid = request.namespace.socket.sessid
print('Client %s connected' % uid)
while True:
try:
tweet = dog.streamer.queue.get(timeout=5)
except gevent.queue.Empty:
dog.check_alive()
else:
emit('tweet', tweet, broadcast=True)
@socketio.on('disconnect', namespace='/tweets')
def tweets_disconnect():
dog.check_alive()
uid = request.namespace.socket.sessid
print('Client %s disconnected' % uid)
if __name__ == '__main__':
try:
socketio.run(app, port=port, host="0.0.0.0")
except KeyboardInterrupt:
pass
cBeta = cdata[1].split('=')[1]
cAlpha = cdata[2].split('=')[1]
cHeading = cdata[3].split('=')[1]
cAccuracy = cdata[4].split('=')[1]
#print ('compass:'******'Heading:', cHeading)
y2 = scale_heading(cHeading)
pwm.setPWM(4, 0, y2)
@io.on('gyroUpdate')
def update_gyro(data):
#print("gyrodata:", data)
axis = data.split(';')
#split into pairs, grab out the data from the pair
ax = axis[0].split('=')[1]
ay = axis[1].split('=')[1]
az = axis[2].split('=')[1]
ra = axis[3].split('=')[1]
rb = axis[4].split('=')[1]
rg = axis[5].split('=')[1]
#print ('orientation:',ax,ay,az,ra,rb,rg)
if __name__ == '__main__':
app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension')
io.run(app, host='0.0.0.0')
quad = 0
print("vert:%s horiz:%s" % (horiz, vert))
if ((horiz > self.neutral) and (vert < self.neutral)):
quad = 1 # ahead right
print("Quad 1 vert:%s horiz:%s" % (horiz, vert))
if ((horiz < self.neutral) and (vert < self.neutral)):
quad = 2 # ahead left
print("Quad 2 vert:%s horiz:%s" % (horiz, vert))
if ((horiz < self.neutral) and (vert > self.neutral)):
quad = 3 # behind left
print("Quad 3 vert:%s horiz:%s" % (horiz, vert))
if ((horiz > self.neutral) and (vert > self.neutral)):
quad = 4 # behind right
print("Quad 4 vert:%s horiz:%s" % (horiz, vert))
if ((horiz < 20) and (vert > 115) and (vert < 140)):
quad = 5
print("Spin Left!")
if ((horiz > 230) and (vert > 115) and (vert < 140)):
quad = 6
print("Spin Right!")
if ((horiz > self.neutral_min) and (horiz < self.neutral_max)
and (vert > self.neutral_min) and (vert < self.neutral_max)):
quad = 0 # overwrite the neutral square
print("Quad 0 vert:%s horiz:%s" % (horiz, vert))
return quad
if __name__ == '__main__':
socketio.run(app, port=8081)
#!/usr/bin/env python
from flask import Flask, render_template
from flask.ext.socketio import SocketIO, emit
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
#event_name = "my_event"
#namespace = "/my_namespace"
event_name = "text"
#namespace = "/my_namespace"
#@socketio.on(event_name, namespace=namespace)
@socketio.on(event_name)
def test_message(message):
print("called!")
print("receive: ")
print(message)
#emit('my response', {'data': message['data']})
if __name__ == '__main__':
socketio.run(app, host='192.168.101.58', port=8011)
@app.route('/lp', methods=['GET'])
def landing_points():
print 'lps'
with open('data/landing_points.json') as f:
return f.read()
@socketio.on('connect', namespace='')
def connect():
print 'client connected'
emit('connect', {'data': 'Connected'})
@socketio.on('disconnect', namespace='')
def disconnect():
print 'Client disconnected'
def make_dir(dir):
if not os.path.exists(dir):
os.makedirs(dir)
# RUN APP
if __name__ == "__main__":
# app.run(host='0.0.0.0',debug=True)
socketio.run(app, host='0.0.0.0', debug=True)
# socketio.run(app,debug=False, host='0.0.0.0', port=8080)
from flask.ext.socketio import SocketIO,emit
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
messages=[]
@app.route('/')
def index():
return app.send_static_file('index.html')
@socketio.on('connect',namespace='/chat')
def makeConnection():
print "Connected"
for message in messages:
print message
emit('message',message)
@socketio.on('message',namespace='/chat')
def new_message(message,name):
tmp={'text':message,'name':name}
print ('\n\n'+ tmp['name']+' said: '+tmp['text']+'\n\n')
messages.append(tmp)
emit('message',tmp,broadcast=True)
if __name__ == '__main__':
socketio.run(app, debug=True)
# templates/runtime/dash-3-click-events
'leftgraph': [graph('bubbles')],
'rightgraph': [graph('line-chart')]
}, name
)
@app.route('/')
def index():
return render_template('layouts/layout_two_column_and_controls.html',
app_name=name)
@socketio.on('pong')
def onpong(app_state):
messages = dash.on_pong(app_state)
emit('postMessage', json.dumps(messages,
cls=plotly.utils.PlotlyJSONEncoder))
@socketio.on('replot')
def replot(app_state):
print app_state
messages = dash.replot(app_state)
emit('postMessage', json.dumps(messages,
cls=plotly.utils.PlotlyJSONEncoder))
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=9999)
#
# Work out logic to prevent people from rating movies twice.
#
if rating:
print("was the error here?")
cur.execute(insertRateQuery, (session['id'], movieID['id'], rating))
db.commit()
except Exception as e:
print(e)
else:
pass
if review:
try:
cur.execute(insertReviewQuery, (movieID['id'], session['id'], review))
except Exception as e:
print(e)
else:
pass
return redirect(url_for('index'))
# start the server
if __name__ == '__main__':
socketio.run(app, host=os.getenv('IP', '0.0.0.0'), port =int(os.getenv('PORT', 8080)), debug=True)
"""
@socketio.on('connect')
def test_connect():
emit('my response', {'data': 'Connected', 'count': 0})
"""
@socketio.on('disconnect')
def test_disconnect():
print('Client disconnected')
if __name__ == "__main__":
# ces treads seront à lancer lors de la connection du premier client (qui sera alors host auto-proclamé)
thread = None
thread2 = None
if thread is None:
thread = Thread(target=backup_thread)
thread.start()
if thread2 is None:
thread2 = Thread(target=fireflies_thread)
thread2.start()
#fireflies = []
#print fireflies
socketio.run(app, port=7777)
@socketio.on('temperatureChange', namespace='/gpio')
def handleTemperatureChange(data):
roomId = data['roomId']
state = data['state']
pins['temperature'][roomId][1]['overallState'] = state
emit('serverResponse', {
'type': 'temperature',
'roomId': roomId,
'state': pins['temperature'][roomId][1]['overallState']
},
broadcast=True)
print "Temp change!"
return
@app.route("/")
def index():
return render_template('index.html')
def signalHandler(signal, frame):
GPIO.cleanup()
sys.exit(0)
signal.signal(signal.SIGINT, signalHandler)
if __name__ == "__main__":
socketio.run(app, host='0.0.0.0')
# Load downloads module if enabled
if prem_config.getboolean('downloads', 'download_enabled'):
from pySmartDL import SmartDL
# Load copylinks to clipboard module if enabled
if prem_config.getboolean('downloads', 'copylink_toclipboard'):
import pyperclip
# Start the watchdog if watchdir is enabled
if prem_config.getboolean('upload', 'watchdir_enabled'):
observer = Observer()
observer.schedule(MyHandler(),
path=prem_config.get('upload', 'watchdir_location'))
observer.start()
# start the server with the 'run()' method
if __name__ == '__main__':
load_tasks()
scheduler = APScheduler(GeventScheduler())
scheduler.init_app(app)
scheduler.scheduler.add_job(update,
'interval',
id='update',
seconds=prem_config.getint(
'global', 'active_interval'),
max_instances=1)
scheduler.start()
socketio.run(app, port=prem_config.getint('global', 'server_port'))
@app.route('/')
def main():
return render_template('main.html')
@app.route('/pymeetups/')
def pymeetups():
return render_template('pymeetups.html')
@socketio.on('connect', namespace='/dd')
def ws_conn():
c = db.incr('connected')
socketio.emit('msg', {'count': c}, namespace='/dd')
@socketio.on('disconnect', namespace='/dd')
def ws_disconn():
c = db.decr('connected')
socketio.emit('msg', {'count': c}, namespace='/dd')
@socketio.on('city', namespace='/dd')
def ws_city(message):
print(message['city'])
socketio.emit('city', {'city': cgi.escape(message['city'])},
namespace="/dd")
if __name__ == '__main__':
socketio.run(app, "0.0.0.0", port=5000)
# store document
document = mongo.send(message, sender_pair, recipient, collection)
# send Updates
document_tidy = {
"sender": document['sender'],
"recipient": document['recipient'],
"data": document['data'],
"ts": document['ts']
}
util.emit_to_relevant_sockets(request, document_tidy, live_sockets)
@socketio.on('disconnect')
def disconnect():
# if socket is listening
if request.sid in all_listeners:
# remove from listeners
all_listeners[request.sid].connected = False
del all_listeners[request.sid]
### Here starts the admin-only functions. Make sure you check user['isAdmin']!
### Here ends the admin-only functions. Make sure you check user['isAdmin']!
### Here ends the auth-only functions. Make sure you check their session cookies!
if __name__ == "__main__":
# app.run(debug=True)
socketio.run(app, debug=True)
width=camera_size[0],
height=camera_size[1])
@socketio.on('stream')
def stream(camera_id):
if camera_id not in cameras:
cameras[camera_id] = Camera(camera_id=camera_id,
size=camera_size,
fps=config.get('cameras', 'fps'))
camera = cameras[camera_id]
data = {
'id': camera_id,
'raw':
'data:image/jpeg;base64,' + base64.b64encode(camera.get_frame()),
'timestamp': time.time()
}
emit('frame', data)
if __name__ == '__main__':
socketio.run(app,
host=config.get('server', 'host'),
port=config.getint('server', 'port'),
policy_server=False,
transports='websocket, xhr-polling, xhr-multipart')
emit('globe_data', [randint(0,90), randint(0,90)])
#print 'globe'
@socketio.on('input_broadcast_event', namespace='/app')
def word_cloud_broadcast(msg):
emit('input_broadcast', {'data': msg['data']})
@socketio.on('input_event', namespace='/app')
def word_cloud(msg):
if len(msg['data'].split()) == 1:
limit = 20 # Not more than `limit` antonyms and synonyms
antonyms = get_antonyms(msg['data'], limit)
synonyms = get_synonyms(msg['data'], limit)
words = map(lambda x: {'text': x, 'flag': 1, 'size': randint(10,50)}, synonyms)
words.extend(map(lambda x: {'text': x, 'size': randint(10,50)}, antonyms))
else:
words = map(lambda x: {'text': x, 'flag': choice([0, 1]), 'size': randint(10,50)}, re.findall("[a-zA-Z\d]+", msg['data']))
emit('input', {'words': words})
@socketio.on('input_broadcast_event', namespace='/app')
def test_message(msg):
emit('input_broadcast', {'data': msg['data']}, broadcast=True)
@socketio.on('disconnect', namespace='/app')
def disconnect():
print('Client disconnected!')
if __name__ == '__main__':
socketio.run(app, debug=True, port=port)
@socketio.on('disconnect', namespace='/deploy')
def deploy_disconnect():
pass
@app.before_first_request
def setup_logging():
logger = logging.getLogger('werkzeug')
logger.setLevel(logging.INFO)
for handler in logger.handlers:
logger.removeHandler(handler)
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("[shipui] %(levelname)s %(message)s"))
handler.setLevel(logging.INFO)
logger.addHandler(handler)
if __name__ == "__main__":
try:
# Start a new thread which sends the log by websockets
t = LogEmitter(app, socketio)
t.start()
socketio.run(app, host="0.0.0.0", debug=True)
except KeyboardInterrupt:
t.join()
print "bye"
info['publish_date'] = info['publish_date'].strftime('%Y-%m-%d')
return predict_power_info
@socketio.on('my model', namespace='/index')
def get_data_model():
data_model = gateway_model.get_gateway_model(session.get("gateway_id"))
admin_uri = None
env_str = os.getenv("VCAP_APPLICATION", "")
if data_model:
if env_str:
env_dict = json.loads(env_str)
uris = env_dict.get("application_uris", None)
if uris:
admin_uri = uris[0].split(".")
admin_uri[0] = "smarthome-adminportal"
admin_uri = ".".join(admin_uri)
else:
admin_uri = "localhost:4000"
emit(
'my model resp', "http://" + admin_uri + "/images/model/" +
data_model['data_model']['name'] +
".png" if data_model and admin_uri else data_model)
if __name__ == '__main__':
logger = logsettings.setup_log()
logger.info('init SMART HOME project ...')
port = os.getenv('PORT', '3000')
socketio.run(app, debug=False, port=int(port), host="0.0.0.0")
for i, alert in enumerate(HomeSurveillance.alerts):
with HomeSurveillance.alertsLock:
alertData = {'alert_id': alert.id , 'alert_message': "Alert if " + alert.alertString}
#print alertData
app.logger.info(alertData)
alerts.append(alertData)
systemData = {'camNum': len(HomeSurveillance.cameras) , 'people': HomeSurveillance.peopleDB, 'cameras': cameras, 'alerts': alerts, 'onConnect': True}
socketio.emit('system_data', json.dumps(systemData) ,namespace='/surveillance')
@socketio.on('disconnect', namespace='/surveillance')
def disconnect():
#print('Client disconnected')
app.logger.info("Client disconnected")
if __name__ == '__main__':
# Starts server on default port 5000 and makes socket connection available to other hosts (host = '0.0.0.0')
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler = RotatingFileHandler(LOG_FILE, maxBytes=1000000, backupCount=10)
handler.setLevel(logging.DEBUG)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
app.logger.setLevel(logging.DEBUG)
log = logging.getLogger('werkzeug')
log.setLevel(logging.DEBUG)
log.addHandler(handler)
socketio.run(app, host='0.0.0.0', debug=False, use_reloader=False)
'people': HomeSurveillance.peopleDB,
'cameras': cameras,
'alerts': alerts,
'onConnect': True
}
socketio.emit('system_data',
json.dumps(systemData),
namespace='/surveillance')
@socketio.on('disconnect', namespace='/surveillance')
def disconnect():
#print('Client disconnected')
app.logger.info("Client disconnected")
if __name__ == '__main__':
# Starts server on default port 5000 and makes socket connection available to other hosts (host = '0.0.0.0')
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler = RotatingFileHandler(LOG_FILE, maxBytes=1000000, backupCount=10)
handler.setLevel(logging.DEBUG)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
app.logger.setLevel(logging.DEBUG)
log = logging.getLogger('werkzeug')
log.setLevel(logging.DEBUG)
log.addHandler(handler)
socketio.run(app, host='0.0.0.0', debug=False, use_reloader=False)
rtk.readConfigBase()
@socketio.on("write config base", namespace="/test")
def writeConfigBase(json):
rtk.writeConfigBase(json)
@socketio.on("update reachview", namespace="/test")
def updateReachView():
print("Got signal to update!!!")
print("Server interrupted by user to update!!")
socketio.server.stop()
os.execl("/home/reach/ReachView/update.sh", "", str(os.getpid()))
if __name__ == "__main__":
try:
socketio.run(app, host = "0.0.0.0", port = 80)
except KeyboardInterrupt:
print("Server interrupted by user!!")
# clean up broadcast and blink threads
rtk.server_not_interrupted = False
rtk.led.blinker_not_interrupted = False
if rtk.coordinate_thread is not None:
rtk.coordinate_thread.join()
if rtk.satellite_thread is not None:
rtk.satellite_thread.join()
if rtk.led.blinker_thread is not None:
rtk.led.blinker_thread.join()
global shell
try:
cmd = msg['data'].lower()
output = '> %s\n' % cmd
output += shell.execute(cmd)
emit('client_recv', {'data': output})
except Exception as e:
emit('client_recv', {'data': 'ERROR: an exception occurred'})
shell.logging = False
print '[error]', e
@socketio.on('client_connect')
def term_connect():
emit('client_recv', {'data': '[connect]'})
if __name__ == '__main__':
if app.debug:
tests = [
'bin', '/bin', 'bin/', '/bin/', 'etc', '/etc', 'etc/', '/etc/'
'bin/..', '/bin/..', 'bin/../', '/bin/../', '..', '/..', '../',
'/../', '.', '/.', './', '/./', '/var/www/ecwi', '/var/www/ecwi/',
'/', '.flag', '/.flag', '.flag/', '/.flag/', 'bin/../.flag',
'/bin/../.flag', './.flag', '../termroot/.flag',
'/var/www/ecwi/term/termroot/.flag'
]
for t in tests:
sanitise_filename(t, True)
socketio.run(app, host='0.0.0.0', port=9447)
'state': None,
})
def run_game():
global worker_manager
print("Running game...")
my_map = map_generator.generate_map(10, 10, 0.1)
player_manager = AvatarManager()
game_state = GameState(my_map, player_manager)
turn_manager = TurnManager(game_state=game_state, end_turn_callback=send_world_update)
WorkerManagerClass = WORKER_MANAGERS[os.environ.get('WORKER_MANAGER', 'local')]
worker_manager = WorkerManagerClass(game_state=game_state, users_url=os.environ.get('GAME_API_URL', 'http://localhost:8000/players/api/games/'))
worker_manager.start()
turn_manager.start()
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
socketio.init_app(app, resource=os.environ.get('SOCKETIO_RESOURCE', 'socket.io'))
run_game()
socketio.run(
app,
debug=False,
host=sys.argv[1],
port=int(sys.argv[2]),
use_reloader=False,
)
#
#@app.route('/redis_key/<string:key>')
#def get_redis_key(key):
# return str(r.lrange(key,0,-1))
#
#@app.route('/redis_info')
#def redis_info():
# return jsonify(r.info())
#
#@app.route('/flush_all')
#def flush_all():
# r.flushall()
# return jsonify(r.info())
#
#@app.route('/info123')
#def info123():
# return os.environ['VCAP_SERVICES']
##
if os.environ.get('VCAP_SERVICES') is None: # running locally
PORT = 8080
DEBUG = True
redis_service_name = None
else: # running on CF
PORT = int(os.getenv("PORT"))
DEBUG = False
redis_service_name = 'rediscloud'
r = helper_functions.connect_redis_db(redis_service_name)
socketio.run(app, host='0.0.0.0', port=PORT, debug=DEBUG)
"""
@socketio.on('model::GYRO_STREAM', namespace='/model')
def heart_gyro_receiver(message):
r = redis.Redis(connection_pool=p)
# Publish data on Redis PUB-SUB Channel
r.publish('model::GYRO_STREAM', message)
# Broadcast data to all connected clients
emit('model::GYRO_STREAM', message, broadcast=True)
@socketio.on('model::ACCEL_STREAM', namespace='/model')
def heart_gyro_receiver(message):
r = redis.Redis(connection_pool=p)
# Publish data on Redis PUB-SUB Channel
r.publish('model::ACCEL_STREAM', message)
# Broadcast data to all connected clients
emit('model::ACCEL_STREAM', message, broadcast=True)
@socketio.on('model::COMMANDS', namespace='/model')
def heart_commands_receiver(message):
r = redis.Redis(connection_pool=p)
# Publish data on Redis PUB-SUB Channel
r.publish('model::COMMANDS', message)
# Broadcast data to all connected clients
emit('model::COMMANDS', message, broadcast=True)
if __name__ == '__main__':
socketio.run(app, host="0.0.0.0")
return link
@socketio.on('joined', namespace='/chat')
def joined(message):
"""Sent by clients when they enter a room.
A status message is broadcast to all people in the room."""
room = session.get('room')
join_room(room)
print "joined"
emit('status', {'msg': session.get('name') + ' has entered the room.'}, room=room,namespace='/chat')
@socketio.on('disp', namespace='/chat')
def ws_city(message):
print message['disp']
print "jouned new"
fina = check(message['disp'])
room = session.get('room')
print room
emit('disp', {'nam': session.get('name')+': ','disp' :fina},room = room,namespace='/chat')
@socketio.on("type",namespace='/chat')
def auto_print(message):
room = session.get('room')
print ">>>>>>>>>>>>>>>>>>>>>>"+str(room)
emit("atype",{'name':session.get('name')+" is typing ....",'press':message['press']},room=room,namespace='/chat')
if __name__ == '__main__' :
socketio.run(app,host='0.0.0.0',port=5000,debug=True)
#app.run(debug=True)
return render_template('rsvp.html', guests=results, username=username)
return render_template('rsvp2.html', guests=results, username=username)
@socketio.on('joinRoom', namespace='/chat')
def on_join(roomname):
print "Joining room"
oldroom = session['roomname']
username = session['username']
conn = connectToMessageDB()
cur = conn.cursor(cursor_factory=psycopg2.extras.DictCursor)
session['roomname'] = roomname
leave_room(oldroom)
join_room(roomname)
cur.execute("SELECT * FROM messages WHERE room = %s;", (roomname,))
messages = cur.fetchall()
for message in messages:
emit('message', message)
# start the server
if __name__ == '__main__':
socketio.run(app, host=os.getenv('IP', '0.0.0.0'), port =int(os.getenv('PORT', 8080)), debug=True)
def checkSerial():
while True:
try:
data = port.readline()
if data:
socketio.emit('my response', {'data':data}, namespace='/imin')
sleep(0.3)
sleep(0.1)
except UnicodeDecodeError:
print "uni error"
except Exception e:
print "exception"
@app.route('/')
def index():
return render_template('index.html')
@app.route('/scripts/<path:filename>')
def serve_js(filename):
return send_from_directory('./scripts', filename)
@socketio.on('connect', namespace='/imin')
def test_connect():
print "whooo"
emit('my response', {'data': 'Connected'})
if __name__ == "__main__":
t1 = Thread(target=checkSerial)
t1.start()
socketio.run(app,"0.0.0.0",5555)
state = data['state']
pins['temperature'][roomId][1]['overallState'] = state
emit('serverResponse', {
'type': 'temperature',
'roomId': roomId,
'state': pins['temperature'][roomId][1]['overallState']
},
broadcast=True)
print "Temp change!"
return
@app.route("/")
def index():
return render_template('index.html')
def signalHandler(signal, frame):
GPIO.cleanup()
sys.exit(0)
signal.signal(signal.SIGINT, signalHandler)
if __name__ == "__main__":
socketio.run(app, host='0.0.0.0')
# import json
app = Flask(__name__)
socketio = SocketIO(app)
event_name = 'tieba_dig'
@app.route('/')
def index():
return render_template('index.html')
@socketio.on(event_name)
def handle_search_para(para):
print para
print type(para['rep_num'])
posts = []
try:
query = Query(para)
print 'done'
posts = query.find()
except StandardError, e:
print e
emit(event_name, posts)
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=8888)
else:
from bae.core.wsgi import WSGIApplication
application = WSGIApplication(socketio)
@app.route('/api/query/<string:query_id>/free', methods=['PUT'])
@pyclient.decorators.api_err_handler(True)
def free_query(query_id):
client.free_query(query_id)
return json.dumps({'success': True})
@socketio.on('connect', namespace='/api/query/notifications')
def test_connect():
print('Client connected')
@socketio.on('disconnect', namespace='/api/query/notifications')
def test_disconnect():
print('Client disconnected')
##
@app.route('/')
def static_proxy_index():
return app.send_static_file(os.path.join('app', 'index.html'))
@app.route('/<path:path>')
def static_proxy(path):
# send_static_file will guess the correct MIME type
return app.send_static_file(os.path.join('app', path))
if __name__ == "__main__":
#app.run(processes=10, host='0.0.0.0', port=8915)
socketio.run(app, host='0.0.0.0', port=8915)
if password_sha == user.login(username):
gateway_id = user.user_gatewayid(username)
# url = user.user_url(username)
session['gateway_id'] = str(gateway_id)
session['username'] = username
info = 'Welcome ' + username
print info
resp = make_response(redirect(url_for('index'), code=302))
resp.set_cookie('JSESSIONID', 'Sticky session.')
return resp
else:
info = 'Username or password are incorrect'
return render_template('login.html', info=info,
static_url_prefix=static_url_prefix)
@app.route('/logout')
def logout():
session.pop('gateway_id', None)
session.pop('username', None)
resp = make_response(redirect(url_for('login'), code=302))
resp.set_cookie('__VCAP_ID__', '', expires=0)
return resp
if __name__ == '__main__':
logger = logsettings.setup_log()
logger.info('init SMART HOME project ...')
port = os.getenv('PORT', '3000')
socketio.run(app, debug=False, port=int(port), host="0.0.0.0")
@socketio.on('init_projection', namespace='/elderberry')
def initial_projection(message):
print('asd')
view,desc, imp,cs = get_random_view()
print(len(desc),len(view))
urls = get_urls()
data = [list(view[i])+[desc[i]] for i in range(len(view))]
ranking = [[int(imp[i][0]),float(imp[i][1])] for i in range(len(imp))]
#print(data, ranking)
print("ASAAAAA",cs)
emit('projection', {'data': data, 'ranking': ranking, 'urls':urls, 'classes':cs})
@socketio.on('request_points', namespace='/elderberry')
def request_points(message):
print(message)
emit('new_points', {'visible_indices': get_points(message['num'], message['visible_indices'], message['algorithm'])}, broadcast=True)
@socketio.on('connect', namespace='/elderberry')
def test_connect():
print('Client connected')
emit('my response', {'data': 'Connected'})
@socketio.on('disconnect', namespace='/elderberry')
def test_disconnect():
print('Client disconnected')
if __name__ == '__main__':
app.debug=True
socketio.run(app,host='0.0.0.0',port=3797)
target=alarm_state,
args=())
thread1.start()
if not thread2.isAlive():
print "Starting Thread2"
thread2 = threading.Thread(name='websocket_process_thread_',
target=update_faces,
args=())
thread2.start()
systemData = {
'camNum': len(Home_Surveillance.cameras),
'people': Home_Surveillance.peopleDB
}
socketio.emit('system_data', json.dumps(systemData), namespace='/test')
#emit('my response', {'data': 'Connected'})
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected')
if __name__ == '__main__':
# # app.run(host='0.0.0.0', debug=True)
socketio.run(
app, host='0.0.0.0', debug=True, use_reloader=False
) #starts server on default port 5000 and makes socket connection available to other hosts (host = '0.0.0.0')
if str(address) in addresses:
addresses[str(address)] += 1
else:
addresses[str(address)] = 1
if str(address) not in session['addresses']:
session['addresses'].append(str(address))
if len(addresses) > maxaddresses:
maxaddresses = len(addresses)
#speed up initial data load
balance_data = get_balancedata(address)
emit('address:' + address, balance_data, namespace='/balance')
@socketio.on("address:refresh", namespace='/balance')
def refresh_address(message):
global addresses
address = message['data']
if str(address) in addresses:
balance_data = get_balancedata(address)
emit('address:' + address, balance_data, namespace='/balance')
else:
add_address(message)
if __name__ == '__main__':
socketio.run(app, '127.0.0.1', 1091)
twit.login()
cityName = twit.getUserTweets()
print cityName
socketio.emit('newnumber', {'number': cityName}, namespace='/test')
sleep(self.delay)
def run(self):
self.tweetFinder()
@application.route('/')
def index():
return render_template('index.html')
@socketio.on('connect', namespace='/test')
def test_connect():
# need visibility of the global thread objects
print "We're working"
global thread
print('Client connected')
if not thread.isAlive():
print "Starting Thread"
thread = RandomThread()
thread.start()
if __name__ == '__main__':
socketio.run(application)
def get_env():
while True:
time.sleep(1)
socketio.emit('receive_weather', {'temperature': temperature, 'humidity': humidity, 'pressure': pressure}, namespace='receive_weather')
@app.route('/receive_weather')
def receive_weather():
threading = None
threading = Thread(target=get_env)
threading.run()
return render_template('get_env.html')
@app.route('/query')
def query():
env = Environment.query.all()
soil = Soil.query.all()
env_query = []
soil_query = {}
for r in range(len(env)):
env_query.append(env[r].serialize)
#env_query['Query '+str(r)] = env[r].serialize
for s in range(len(soil)):
soil_query['Query ' + str(s)] = soil[s].serialize
return render_template('query.html', Environment_data=env_query, Soil_data=soil_query)
if __name__ == '__main__':
socketio.run(app)
def which_quadrant(self, horiz, vert):
quad = 0
print("vert:%s horiz:%s" % (horiz, vert))
if ((horiz > self.neutral) and (vert < self.neutral)):
quad = 1 # ahead right
print("Quad 1 vert:%s horiz:%s" % (horiz, vert))
if ((horiz < self.neutral) and (vert < self.neutral)):
quad = 2 # ahead left
print("Quad 2 vert:%s horiz:%s" % (horiz, vert))
if ((horiz < self.neutral) and (vert > self.neutral)):
quad = 3 # behind left
print("Quad 3 vert:%s horiz:%s" % (horiz, vert))
if ((horiz > self.neutral) and (vert > self.neutral)):
quad = 4 # behind right
print("Quad 4 vert:%s horiz:%s" % (horiz, vert))
if ((horiz < 20) and (vert > 115) and (vert < 140)):
quad = 5
print("Spin Left!")
if ((horiz > 230) and (vert > 115) and (vert <140)):
quad = 6
print("Spin Right!")
if ((horiz > self.neutral_min) and (horiz < self.neutral_max) and (vert > self.neutral_min) and (vert < self.neutral_max)):
quad = 0 # overwrite the neutral square
print("Quad 0 vert:%s horiz:%s" % (horiz, vert))
return quad
if __name__ == '__main__':
socketio.run(app,port=8081)
def print_client_version(message):
print("client version:" + message["version"])
@socketio.on('disconnect')
def test_disconnect():
print('CLIENT DISCONNECTED')
@socketio.on("entites_received")
def entities_received():
print("CLIENT RECEIVED ENTITIES")
#------------------------------------------------------------
config = {
"consumer_key": consumer_key,
"consumer_secret": consumer_secret,
"access_token": access_token,
"access_token_secret": access_token_secret,
"keywords":
['acorn', 'stanford', 'midterm', 'lawnmower', 'fox news', 'usc'],
"languages": ["en"]
}
streamWorker = StreamWorker(config, socketio)
main = threading.Thread(target=streamWorker.run)
main.start()
if __name__ == "__main__":
socketio.run(app, host="0.0.0.0", port=8000)
## WEBSERVER STATIC ##
# make al /static/ folder available
@app.route('/')
def root():
return app.send_static_file('index.html')
@app.route('/<path:path>')
def static_proxy(path):
return app.send_static_file(path)
## SOCKET.IO CONNECTION ##
# make al /static/ folder available
@socketio.on('connect')
def connected():
print(">>>>>>>>>>>>>>>>>>>>>>>>>>> connect")
emit('msg', {'data': 'Conooooooooooooonected'})
# Data in from browser, JSON format
@socketio.on('api')
def api(data):
print('received api request ' + data)
# Message, info or debug information
@socketio.on('msg')
def message(message):
print('received message: ' + message)
if __name__ == '__main__':
app.debug = True
socketio.run(app, port=5000)
def get_public_events():
events = {}
for u in USERS:
hub_user = hub.get_user('mfwarren')
events[u] = hub_user.get_public_events()[0].raw_data
return events
def background_thread():
while True:
events = get_public_events()
socketio.emit('response', {'data': 'events', 'events': events}, namespace='')
time.sleep(30)
@app.route('/')
def index():
global thread
if thread is None:
thread = Thread(target=background_thread)
thread.start()
return render_template('github_index.html')
@socketio.on('event')
def message(message):
pass # need side effects from having this here
if __name__ == '__main__':
socketio.run(app)
class NickForm(Form):
name = StringField('Nickname: ', validators=[Required()])
submit = SubmitField('Set Nickname')
@app.route('/chat')
def chat():
if session.get('nick') != None:
return render_template('index.html', nickname=session.get('nick'))
else:
return redirect(url_for('index'))
@app.route('/', methods=['GET', 'POST'])
def index():
if session.get('nick') != None:
return redirect(url_for('chat'))
form = NickForm()
if form.validate_on_submit():
session['nick'] = form.name.data
form.name.data = ""
return redirect(url_for('chat'))
return render_template('nick.html', form=form)
@ws.on('message sent')
def message_sent(message):
emit('broadcast', message, broadcast=True)
if __name__ == '__main__':
ws.run(app)
data = {"error": "INVALID_CHALLENGE_ID"}
code = 400
else:
if request.form["accept"] == "true" or request.form["accept"] == True:
code = 200
data = {"msg": "OK"}
challenges[challengeID].status = "accepted"
elif request.form["accept"] == "false" or request.form["accept"] == False:
code = 200
data = {"msg": "OK"}
challenges[challengeID].status = "declined"
else:
data = {"error": "BAD_REQUEST"}
code = 400
return jsonify(data), code
@app.route("/api/challenges/<int:challengeID>", methods=["GET"])
def api_get_challenge_status(challengeID):
if challengeID not in challenges:
data = {"error": "INVALID_CHALLENGE_ID"}
code = 400
else:
challenge = challenges[challengeID]
data = {"challenge": challenge.__dict__}
code = 200
return jsonify(data), code
if __name__ == "__main__":
#check_keepalive_users()
socketio.run(app, host="0.0.0.0")
traci.init(PORT)
def sim():
step = 0
while step < 86400:
traci.simulationStep()
xy=[]
vehicles = traci.vehicle.getIDList()
for v in vehicles:
x=112.96771+(traci.vehicle.getPosition(v)[0]+1509.33)/98838.1145
y=28.193671+(traci.vehicle.getPosition(v)[1]-105.97)/106287.597
xy.append([x,y])
return xy
time.sleep(10)
step += 10
traci.close()
@socketio.on('update')
def update_view(message):
#print message[data]
emit('test', sim(), broadcast=True)
@app.route('/')
def sumo():
init()
return render_template('sumo2.html')
if __name__ == "__main__":
app.debug = True
socketio.run(app, host='127.0.0.1',port=5000)
