使用Flask SocketIO实现WebSocket 实时计算

最新推荐文章于 2025-06-08 09:01:06 发布
最新推荐文章于 2025-06-08 09:01:06 发布
阅读量490 收藏 1
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songhao8080/article/details/103670130

使用Flask SocketIO实现WebSocket

使用 HTML 5 的 WebSocket 实现实时交互通信功能，替代 Ajax 轮训等方法，个人觉得比较适合实时监控类网站。我就尝试使用 Flask-SocketIO 实现支持 WebSocket 的服务器端，使用 socket.io 库实现客户端。

一个简单的 Flask-SocketIO 应用

仅完成就简单的通讯功能。

服务器端

使用 HTML 5 的 WebSocket 实现实时交互通信功能，替代 Ajax 轮训等方法，个人觉得比较适合实时监控类网站。我就尝试使用 Flask-SocketIO 实现支持 WebSocket 的服务器端，使用 socket.io 库实现客户端。

一个简单的 Flask-SocketIO 应用
仅完成就简单的通讯功能。

服务器端

Python
from flask import Flask, render_template from flask.ext.socketio import SocketIO, emit app = Flask(__name__) app.debug = True app.config['SECRET_KEY'] = 'windroc-nwpc-project' socketio = SocketIO(app) @app.route('/') def get_index_page(): return render_template('index.html') @socketio.on('connect', namespace='/test') def test_connect(): emit('my response', {'data': 'Connected', 'count': 0}) @socketio.on('my event', namespace='/test') def test_message(message): emit('my response', {'data': message['data'], 'count': 2}) if __name__ == "__main__": socketio.run(app, host='0.0.0.0', port=5101)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from flask import Flask , render_template
from flask . ext . socketio import SocketIO , emit
 
app = Flask ( __name__ )
app . debug = True
app . config [ 'SECRET_KEY' ] = 'windroc-nwpc-project'
 
socketio = SocketIO ( app )
 
@ app . route ( '/' )
def get_index_page ( ) :
     return render_template ( 'index.html' )
 
@ socketio . on ( 'connect' , namespace = '/test' )
def test_connect ( ) :
     emit ( 'my response' , { 'data' : 'Connected' , 'count' : 0 } )
 
@ socketio . on ( 'my event' , namespace = '/test' )
def test_message ( message ) :
     emit ( 'my response' , { 'data' : message [ 'data' ] , 'count' : 2 } )
 
 
if __name__ == "__main__" :
     socketio . run ( app , host = '0.0.0.0' , port = 5101 )
 

创建 Flask-SocketIO 应用的方法与 Flask 应用相似

Python
app = Flask(__name__) socketio = SocketIO(app)
1
2
3
app = Flask ( __name__ )
socketio = SocketIO ( app )
 

开发时简单运行的方法也与不同的 Flask 应用相同。

Python
if __name__ == "__main__": socketio.run(app, host='0.0.0.0', port=5101)
1
2
3
if __name__ == "__main__" :
     socketio . run ( app , host = '0.0.0.0' , port = 5101 )
 

SocketIO 使用 event 表示客户端和服务端接受到的消息。后面可以看到，客户端使用 Javascript 回调函数处理。服务器端使用类似视图的路由注册函数来处理事件。

Python
@socketio.on('connect', namespace='/test') def test_connect(): emit('my response', {'data': 'Connected', 'count': 0}) @socketio.on('my event', namespace='/test') def test_message(message): emit('my response', {'data': message['data'], 'count': 2})
1
2
3
4
5
6
7
8
@ socketio . on ( 'connect' , namespace = '/test' )
def test_connect ( ) :
     emit ( 'my response' , { 'data' : 'Connected' , 'count' : 0 } )
 
@ socketio . on ( 'my event' , namespace = '/test' )
def test_message ( message ) :
     emit ( 'my response' , { 'data' : message [ 'data' ] , 'count' : 2 } )
 

客户端
使用 socket.io 的客户端 js 库

Python
<script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js"></script>
1
2
<script type = "text/javascript" src = "//cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js" > </script>
 

监听 socket 事件的 js 代码：

Python
$(document).ready(function () { var socket = io.connect('http://127.0.0.1:5101/test'); socket.on('connect', function() { socket.emit('my event', {data: 'I\'m connected!'}); }); });
1
2
3
4
5
6
7
$ ( document ) . ready ( function ( ) {
     var socket = io . connect ( 'http://127.0.0.1:5101/test' ) ;
     socket . on ( 'connect' , function ( ) {
         socket . emit ( 'my event' , { data : 'I\'m connected!' } ) ;
     } ) ;
} ) ;
 

当 socket 连接成功时，向服务器发送 my event 事件，上一节的服务端使用 test_message 函数处理 my event 事件，向客户端发送 my response 事件。

下面看一个稍微复杂一些的应用，实现一个有实际价值的功能。

一个简单的实时监控应用
单位服务器使用 LoadLeveler 管理任务调度，绝大部分作业脚本都会提交到 LoadLeveler 上运行，很多时候需要运维使用 llq 命令查看 LoadLeveler 队列中的任务状态。或许可以开发一种可以实时获取信息的工具，以更直观的方式展示数据。

从最简单入手，实时获取 LoadLeveler 队列中任务数量和每种状态的任务数量。

数据生成
一个典型的 llq 输出如下：

Python
<br />Id Owner Submitted ST PRI Class Running On ------------------------ ---------- ----------- -- --- ------------ ----------- cma20n01.1737149.0 nwp_qu 5/11 03:20 R 100 serial_op cma18n05 cma20n02.2425650.0 nwp_qu 5/11 03:20 R 100 serial_op cma18n07 ... cma20n01.1738085.0 bcccsmxp 5/11 06:41 I 50 special2 ... 149 job step(s) in queue, 57 waiting, 0 pending, 92 running, 0 held, 0 preempted Id Owner Submitted ST PRI Class Running On ------------------------ ---------- ----------- -- --- ------------ ----------- cma20n01.1737149.0 nwp_qu 5/11 03:20 R 100 serial_op cma18n05 cma20n02.2425650.0 nwp_qu 5/11 03:20 R 100 serial_op cma18n07 ... cma20n01.1738085.0 bcccsmxp 5/11 06:41 I 50 special2 ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
< br / > Id                        Owner       Submitted   ST PRI Class          Running On
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - -- -- - -- -- -- -- -- -- -- -- -- -- -- -
cma20n01 . 1737149.0        nwp _qu        5 / 11 03 : 20 R    100 serial_op     cma18n05  
cma20n02 . 2425650.0        nwp _qu        5 / 11 03 : 20 R    100 serial_op     cma18n07   
. . .   
cma20n01 . 1738085.0        bcccsmxp      5 / 11 06 : 41 I    50    special2                                 
. . .
 
149 job step ( s ) in queue , 57 waiting , 0 pending , 92 running , 0 held , 0 preempted
 
Id                        Owner       Submitted   ST PRI Class          Running On
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - -- -- - -- -- -- -- -- -- -- -- -- -- -- -
cma20n01 . 1737149.0        nwp _qu        5 / 11 03 : 20 R    100 serial_op     cma18n05  
cma20n02 . 2425650.0        nwp _qu        5 / 11 03 : 20 R    100 serial_op     cma18n07   
. . .   
cma20n01 . 1738085.0        bcccsmxp      5 / 11 06 : 41 I    50    special2                                 
. . .
 

149 job step(s) in queue, 57 waiting, 0 pending, 92 running, 0 held, 0 preempted
其中…表示省略的条目。上述要求其实就是解析 llq 输出的最后一行，使用正则表达式解析。

Python
total_pattern = "^(\d+) job step\(s\) in queue, (\d+) waiting, (\d+) pending, (\d+) running, (\d+) held, (\d+) preempted" total_prog = re.compile(total_pattern) total_prog_result = total_prog.match(result_lines[-2]) llq_summary = dict() llq_summary['in_queue'] = total_prog_result.group(1) llq_summary['waiting'] = total_prog_result.group(2) llq_summary['pending'] = total_prog_result.group(3) llq_summary['running'] = total_prog_result.group(4) llq_summary['held'] = total_prog_result.group(6) llq_summary['preempted'] = total_prog_result.group(5)
1
2
3
4
5
6
7
8
9
10
11
total_pattern = "^(\d+) job step\(s\) in queue, (\d+) waiting, (\d+) pending, (\d+) running, (\d+) held, (\d+) preempted"
total_prog = re . compile ( total_pattern )
total_prog_result = total_prog . match ( result_lines [ - 2 ] )
llq_summary = dict ( )
llq_summary [ 'in_queue' ] = total_prog_result . group ( 1 )
llq_summary [ 'waiting' ] = total_prog_result . group ( 2 )
llq_summary [ 'pending' ] = total_prog_result . group ( 3 )
llq_summary [ 'running' ] = total_prog_result . group ( 4 )
llq_summary [ 'held' ] = total_prog_result . group ( 6 )
llq_summary [ 'preempted' ] = total_prog_result . group ( 5 )
 

另外，该程序不在单位的服务器上运行，需要用 ssh 连接到服务器。我使用 paramiko 库执行远程命令。

Python
bin_path = 'llq' bin_param = '' try: ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(hostname, port, username, password) ssh_command = bin_path + ' ' + bin_param ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command(ssh_command) except paramiko.SSHException, e: print e return "{'error':'error'}" result_lines = ssh_stdout.read().split("\n") ssh.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bin_path = 'llq'
bin_param = ''
try :
     ssh = paramiko . SSHClient ( )
     ssh . set_missing_host_key_policy ( paramiko . AutoAddPolicy ( ) )
     ssh . connect ( hostname , port , username , password )
     ssh_command = bin_path + ' ' + bin_param
     ssh_stdin , ssh_stdout , ssh_stderr = ssh . exec_command ( ssh_command )
except paramiko . SSHException , e :
     print e
     return "{'error':'error'}"
 
result_lines = ssh_stdout . read ( ) . split ( "\n" )
ssh . close ( )
 

如此可以得到数据。

应用结构
socket 服务器接受外界传来的 llq 队列消息，并将该消息发送给连接到 socket 服务器的所有客户端。因为对 socket 不够了解，我还是使用传统的 HTTP 方式传送消息到服务器，再使用 Flask-SocketIO 发送消息到客户端。

服务器端
添加一个 http 路由函数，Flask-SocketIO 对象可以使用 emit 函数直接向客户端发送消息。

Python
@app.route('/api/v1/hpc/llq/info', methods=['POST']) def get_hpc_llq_info(): r = request hpc_llq_info_message = json.loads(request.form['message']) print "Receive llq info:", hpc_llq_info_message socketio.emit('send_llq_info', hpc_llq_info_message, namespace='/hpc') result = { 'status': 'ok' } return jsonify(result)
1
2
3
4
5
6
7
8
9
10
11
@ app . route ( '/api/v1/hpc/llq/info' , methods = [ 'POST' ] )
def get_hpc_llq_info ( ) :
     r = request
     hpc_llq_info_message = json . loads ( request . form [ 'message' ] )
     print "Receive llq info:" , hpc_llq_info_message
     socketio . emit ( 'send_llq_info' , hpc_llq_info_message , namespace = '/hpc' )
     result = {
         'status' : 'ok'
     }
     return jsonify ( result )
 

数据收集
每隔一段时间收集一次数据：

Python
while True: quota_result = hpcloadleveler.get_llq(hostname, port, username, password) logging.info(quota_result['total']) post_data = { 'message': json.dumps(quota_result['total']) } requests.post(post_url, data=post_data) time.sleep(2)
1
2
3
4
5
6
7
8
9
while True :
     quota_result = hpcloadleveler . get_llq ( hostname , port , username , password )
     logging . info ( quota_result [ 'total' ] )
     post_data = {
         'message' : json . dumps ( quota_result [ 'total' ] )
     }
     requests . post ( post_url , data = post_data )
     time . sleep ( 2 )
 

客户端
接受数据后，更新界面显示

Python
var socket = io.connect('http://127.0.0.1:5101/hpc'); socket.on('connect', function() { console.log('I\'m connected!'); }); socket.on('send_llq_info', function(msg){ /*console.log(msg);*/ var total = parseInt(msg.in_queue); var waiting = parseInt(msg.waiting); var held = parseInt(msg.held); var running = parseInt(msg.running); var pending = parseInt(msg.pending); var preempted = parseInt(msg.preempted); var llq_info = [ {name: 'total', value: total}, {name: 'waiting', value: waiting}, {name: 'pending', value: pending}, {name: 'running', value: running}, {name: 'held', value: held}, {name: 'preempted', value: preempted} ]; update_llq_type_chart(llq_info); $('#total_llq_job_number').html(total); $('#waiting_llq_job_number').html(waiting); $('#held_llq_job_number').html(held); $('#running_llq_job_number').html(running); $('#pending_llq_job_number').html(pending); $('#preempted_llq_job_number').html(preempted); });
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
var socket = io . connect ( 'http://127.0.0.1:5101/hpc' ) ;
socket . on ( 'connect' , function ( ) {
     console . log ( 'I\'m connected!' ) ;
} ) ;
socket . on ( 'send_llq_info' , function ( msg ) {
     / * console . log ( msg ) ; * /
     var total = parseInt ( msg . in_queue ) ;
     var waiting = parseInt ( msg . waiting ) ;
     var held = parseInt ( msg . held ) ;
     var running = parseInt ( msg . running ) ;
     var pending = parseInt ( msg . pending ) ;
     var preempted = parseInt ( msg . preempted ) ;
 
     var llq_info = [
         { name : 'total' , value : total } ,
         { name : 'waiting' , value : waiting } ,
         { name : 'pending' , value : pending } ,
         { name : 'running' , value : running } ,
         { name : 'held' , value : held } ,
         { name : 'preempted' , value : preempted }
     ] ;
     update_llq_type_chart ( llq_info ) ;
 
     $ ( '#total_llq_job_number' ) . html ( total ) ;
     $ ( '#waiting_llq_job_number' ) . html ( waiting ) ;
     $ ( '#held_llq_job_number' ) . html ( held ) ;
     $ ( '#running_llq_job_number' ) . html ( running ) ;
     $ ( '#pending_llq_job_number' ) . html ( pending ) ;
     $ ( '#preempted_llq_job_number' ) . html ( preempted ) ;
} ) ;
 
 

创建 Flask-SocketIO 应用的方法与 Flask 应用相似

Python
app = Flask(__name__) socketio = SocketIO(app)
1
2
3
app = Flask ( __name__ )
socketio = SocketIO ( app )
 

开发时简单运行的方法也与不同的 Flask 应用相同。

Python
if __name__ == "__main__": socketio.run(app, host='0.0.0.0', port=5101)
1
2
3
if __name__ == "__main__" :
     socketio . run ( app , host = '0.0.0.0' , port = 5101 )
 

SocketIO 使用 event 表示客户端和服务端接受到的消息。后面可以看到，客户端使用 Javascript 回调函数处理。服务器端使用类似视图的路由注册函数来处理事件。

Python
@socketio.on('connect', namespace='/test') def test_connect(): emit('my response', {'data': 'Connected', 'count': 0}) @socketio.on('my event', namespace='/test') def test_message(message): emit('my response', {'data': message['data'], 'count': 2})
1
2
3
4
5
6
7
8
@ socketio . on ( 'connect' , namespace = '/test' )
def test_connect ( ) :
     emit ( 'my response' , { 'data' : 'Connected' , 'count' : 0 } )
 
@ socketio . on ( 'my event' , namespace = '/test' )
def test_message ( message ) :
     emit ( 'my response' , { 'data' : message [ 'data' ] , 'count' : 2 } )
 

客户端

使用 socket.io 的客户端 js 库

Python
<script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js"></script>
1
2
<script type = "text/javascript" src = "//cdnjs.cloudflare.com/ajax/libs/socket.io/0.9.16/socket.io.min.js" > </script>
 

监听 socket 事件的 js 代码：

Python
$(document).ready(function () { var socket = io.connect('http://127.0.0.1:5101/test'); socket.on('connect', function() { socket.emit('my event', {data: 'I\'m connected!'}); }); });
1
2
3
4
5
6
7
$ ( document ) . ready ( function ( ) {
     var socket = io . connect ( 'http://127.0.0.1:5101/test' ) ;
     socket . on ( 'connect' , function ( ) {
         socket . emit ( 'my event' , { data : 'I\'m connected!' } ) ;
     } ) ;
} ) ;
 

当 socket 连接成功时，向服务器发送 my event 事件，上一节的服务端使用 test_message 函数处理 my event 事件，向客户端发送 my response 事件。

下面看一个稍微复杂一些的应用，实现一个有实际价值的功能。

一个简单的实时监控应用

单位服务器使用 LoadLeveler 管理任务调度，绝大部分作业脚本都会提交到 LoadLeveler 上运行，很多时候需要运维使用 llq 命令查看 LoadLeveler 队列中的任务状态。或许可以开发一种可以实时获取信息的工具，以更直观的方式展示数据。

从最简单入手，实时获取 LoadLeveler 队列中任务数量和每种状态的任务数量。

数据生成

一个典型的 llq 输出如下：

Python
Id Owner Submitted ST PRI Class Running On ------------------------ ---------- ----------- -- --- ------------ ----------- cma20n01.1737149.0 nwp_qu 5/11 03:20 R 100 serial_op cma18n05 cma20n02.2425650.0 nwp_qu 5/11 03:20 R 100 serial_op cma18n07 ... cma20n01.1738085.0 bcccsmxp 5/11 06:41 I 50 special2 ... 149 job step(s) in queue, 57 waiting, 0 pending, 92 running, 0 held, 0 preempted
1
2
3
4
5
6
7
8
9
10
Id                        Owner       Submitted   ST PRI Class          Running On
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- - -- -- - -- -- -- -- -- -- -- -- -- -- -- -
cma20n01 . 1737149.0        nwp _qu        5 / 11 03 : 20 R    100 serial_op     cma18n05  
cma20n02 . 2425650.0        nwp _qu        5 / 11 03 : 20 R    100 serial_op     cma18n07   
. . .   
cma20n01 . 1738085.0        bcccsmxp      5 / 11 06 : 41 I    50    special2                                 
. . .
 
149 job step ( s ) in queue , 57 waiting , 0 pending , 92 running , 0 held , 0 preempted
 

其中…表示省略的条目。上述要求其实就是解析 llq 输出的最后一行，使用正则表达式解析。

Python
total_pattern = "^(\d+) job step\(s\) in queue, (\d+) waiting, (\d+) pending, (\d+) running, (\d+) held, (\d+) preempted" total_prog = re.compile(total_pattern) total_prog_result = total_prog.match(result_lines[-2]) llq_summary = dict() llq_summary['in_queue'] = total_prog_result.group(1) llq_summary['waiting'] = total_prog_result.group(2) llq_summary['pending'] = total_prog_result.group(3) llq_summary['running'] = total_prog_result.group(4) llq_summary['held'] = total_prog_result.group(6) llq_summary['preempted'] = total_prog_result.group(5)
1
2
3
4
5
6
7
8
9
10
11
total_pattern = "^(\d+) job step\(s\) in queue, (\d+) waiting, (\d+) pending, (\d+) running, (\d+) held, (\d+) preempted"
total_prog = re . compile ( total_pattern )
total_prog_result = total_prog . match ( result_lines [ - 2 ] )
llq_summary = dict ( )
llq_summary [ 'in_queue' ] = total_prog_result . group ( 1 )
llq_summary [ 'waiting' ] = total_prog_result . group ( 2 )
llq_summary [ 'pending' ] = total_prog_result . group ( 3 )
llq_summary [ 'running' ] = total_prog_result . group ( 4 )
llq_summary [ 'held' ] = total_prog_result . group ( 6 )
llq_summary [ 'preempted' ] = total_prog_result . group ( 5 )
 

另外，该程序不在单位的服务器上运行，需要用 ssh 连接到服务器。我使用 paramiko 库执行远程命令。

Python
bin_path = 'llq' bin_param = '' try: ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(hostname, port, username, password) ssh_command = bin_path + ' ' + bin_param ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command(ssh_command) except paramiko.SSHException, e: print e return "{'error':'error'}" result_lines = ssh_stdout.read().split("\n") ssh.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bin_path = 'llq'
bin_param = ''
try :
     ssh = paramiko . SSHClient ( )
     ssh . set_missing_host_key_policy ( paramiko . AutoAddPolicy ( ) )
     ssh . connect ( hostname , port , username , password )
     ssh_command = bin_path + ' ' + bin_param
     ssh_stdin , ssh_stdout , ssh_stderr = ssh . exec_command ( ssh_command )
except paramiko . SSHException , e :
     print e
     return "{'error':'error'}"
 
result_lines = ssh_stdout . read ( ) . split ( "\n" )
ssh . close ( )
 

如此可以得到数据。

应用结构

socket 服务器接受外界传来的 llq 队列消息，并将该消息发送给连接到 socket 服务器的所有客户端。因为对 socket 不够了解，我还是使用传统的 HTTP 方式传送消息到服务器，再使用 Flask-SocketIO 发送消息到客户端。

服务器端

添加一个 http 路由函数，Flask-SocketIO 对象可以使用 emit 函数直接向客户端发送消息

Python
@app.route('/api/v1/hpc/llq/info', methods=['POST']) def get_hpc_llq_info(): r = request hpc_llq_info_message = json.loads(request.form['message']) print "Receive llq info:", hpc_llq_info_message socketio.emit('send_llq_info', hpc_llq_info_message, namespace='/hpc') result = { 'status': 'ok' } return jsonify(result)
1
2
3
4
5
6
7
8
9
10
11
@ app . route ( '/api/v1/hpc/llq/info' , methods = [ 'POST' ] )
def get_hpc_llq_info ( ) :
     r = request
     hpc_llq_info_message = json . loads ( request . form [ 'message' ] )
     print "Receive llq info:" , hpc_llq_info_message
     socketio . emit ( 'send_llq_info' , hpc_llq_info_message , namespace = '/hpc' )
     result = {
         'status' : 'ok'
     }
     return jsonify ( result )
 

数据收集

每隔一段时间收集一次数据：

Python
while True: quota_result = hpcloadleveler.get_llq(hostname, port, username, password) logging.info(quota_result['total']) post_data = { 'message': json.dumps(quota_result['total']) } requests.post(post_url, data=post_data) time.sleep(2)
1
2
3
4
5
6
7
8
9
while True :
     quota_result = hpcloadleveler . get_llq ( hostname , port , username , password )
     logging . info ( quota_result [ 'total' ] )
     post_data = {
         'message' : json . dumps ( quota_result [ 'total' ] )
     }
     requests . post ( post_url , data = post_data )
     time . sleep ( 2 )
 

客户端

接受数据后，更新界面显示

Python
var socket = io.connect('http://127.0.0.1:5101/hpc'); socket.on('connect', function() { console.log('I\'m connected!'); }); socket.on('send_llq_info', function(msg){ /*console.log(msg);*/ var total = parseInt(msg.in_queue); var waiting = parseInt(msg.waiting); var held = parseInt(msg.held); var running = parseInt(msg.running); var pending = parseInt(msg.pending); var preempted = parseInt(msg.preempted); var llq_info = [ {name: 'total', value: total}, {name: 'waiting', value: waiting}, {name: 'pending', value: pending}, {name: 'running', value: running}, {name: 'held', value: held}, {name: 'preempted', value: preempted} ]; update_llq_type_chart(llq_info); $('#total_llq_job_number').html(total); $('#waiting_llq_job_number').html(waiting); $('#held_llq_job_number').html(held); $('#running_llq_job_number').html(running); $('#pending_llq_job_number').html(pending); $('#preempted_llq_job_number').html(preempted); });
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var socket = io . connect ( 'http://127.0.0.1:5101/hpc' ) ;
socket . on ( 'connect' , function ( ) {
     console . log ( 'I\'m connected!' ) ;
} ) ;
socket . on ( 'send_llq_info' , function ( msg ) {
     / * console . log ( msg ) ; * /
     var total = parseInt ( msg . in_queue ) ;
     var waiting = parseInt ( msg . waiting ) ;
     var held = parseInt ( msg . held ) ;
     var running = parseInt ( msg . running ) ;
     var pending = parseInt ( msg . pending ) ;
     var preempted = parseInt ( msg . preempted ) ;
 
     var llq_info = [
         { name : 'total' , value : total } ,
         { name : 'waiting' , value : waiting } ,
         { name : 'pending' , value : pending } ,
         { name : 'running' , value : running } ,
         { name : 'held' , value : held } ,
         { name : 'preempted' , value : preempted }
     ] ;
     update_llq_type_chart ( llq_info ) ;
 
     $ ( '#total_llq_job_number' ) . html ( total ) ;
     $ ( '#waiting_llq_job_number' ) . html ( waiting ) ;
     $ ( '#held_llq_job_number' ) . html ( held ) ;
     $ ( '#running_llq_job_number' ) . html ( running ) ;
     $ ( '#pending_llq_job_number' ) . html ( pending ) ;
     $ ( '#preempted_llq_job_number' ) . html ( preempted ) ;
} ) ;
 



  • zeropython 微信公众号 5868037 QQ号 5868037@qq.com QQ邮箱
songhao8080
关注
flask-socketio实现websocket通信
老司机的后备箱
08-02 1623
flask-socketio能够实现客户端和服务器之间的低延迟双向通信。客户端可以使用js/c++/等任何官方支持的客户端库建立与服务器的长连接。
python flask实现websocket
weixin_44519682的博客
05-13 1740
flask项目实现websocket 1.from flask_socketio import SocketIO 2.app = Flask(__name__) 3.socketio = SocketIO(app) 4.启动flask项目时候要用如下方式启动 socketio.run(app, host='', port=) 5.在启动项目的同一文件下，添加如下代码 WS = [] @socketio.on('connect' ,namespace = '/websocket') def connec
Flask-SocketIO 实现细节解析
gitblog_00740的博客
06-08 288
Flask-SocketIO 实现细节解析 Flask-SocketIO miguelgrinberg/Flask-SocketIO: Flask-SocketIO 是一个为 Flask 框架提供 Socket.IO 支持的扩展，使得开发者能够轻松地在 Flask 应用中实现实时双向通信功能。 ...
python flask websocket_Flask中使用websocket
weixin_39616367的博客
12-03 813
因为业务需求需要使用websocket，所以在flask中使用websocket。在网上很多的资料，本文只记录我使用的方法。首先是需要导入包pip install gevent-websocket导入包之后直接在项目中使用from flask import Flask, requestfrom geventwebsocket.handler import WebSocketHandler ...
python flask websocket_Flask实现websocket
weixin_39688035的博客
12-03 212
from flask importFlask,requestuser_socket_dict={}app= Flask(__name__)@app.route("/conn_ws")#http协议{'GATEWAY_INTERFACE': 'CGI/1.1', 'SERVER_SOFTWARE': 'gevent/1.3 Python/3.7', 'SCRIPT_NAME': '', 'wsgi....
Flask速成项目：Flask实现计算机资源的实时监控
weixin_30267691的博客
01-04 350
很多人都说使用Python开发WEB应用非常方便，那么对于WEB新手来说，到底有多方便呢？本文即将展示给你Python的魔法。 本文将通过一个实例：Flask实现计算机资源的实时监控，迅速带你入门Flask开发。 先说一下我的水平，博主的专业并不是做WEB开发的，对于WEB方面，只会写爬虫，因此，只能看懂html，略看得懂css与js，我估计有很多像我一样的小伙伴，因此，如果你的WEB掌握的水...
操作系统课设，基于Python flask_socketio 及 WebSocket的多人聊天室.zip
07-12
该资源内项目源码是个人的课程设计、毕业设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请...
基于Flask-SocketIO的简单实时聊天应用实现
资源摘要信息:"Flask-SocketIO-Chat是一个使用Flask和SocketIO库构建的...通过研究和理解这个项目，开发者可以掌握如何使用Flask和SocketIO搭建实时Web应用，并了解相关技术如何协同工作来满足复杂的网络交互需求。
Flask-SocketIO实现简易聊天应用教程
Flask-SocketIO-Chat项目演示了如何使用Flask框架和Socket.IO协议，后者是一个被广泛用于实现实时、双向和基于事件的通信功能的库。在Python中，Flask框架因其简单、灵活、轻量级的特性而受到许多开发者的喜爱，它...
Flask-SocketIO 实现每秒广播随机数
Flask-SocketIO 是一个用于 Flask 应用程序的实时通信库，它使用 WebSocket 实现了客户端与服务器之间的双向通信。该库支持异步消息传输，意味着服务器可以在不需要等待客户端响应的情况下发送数据。本示例程序通过 ...
(源码)基于 Flask 和 SocketIO 的情感驱动会话系统.zip
最新发布
06-22
# 基于 Flask 和 SocketIO 的情感驱动会话... 实时互动使用 WebSocket 实现用户与机器人的实时聊天互动。 ## 安装使用步骤 ### 1. 复制项目 bash cd EmoChat ### 2. 创建虚拟环境（可选） bash python m venv venv
python实现websocket
03-07
python，websocket实现，供大家学习 websocket，实现tcp通信，替代轮询，commit等技术 良心推荐
python-websockets-chat, 在 Flask 中，web sockets的一个示例实现.zip
09-18
python-websockets-chat, 在 Flask 中，web sockets的一个示例实现 python-web socket示例： 聊天这是一个简单的应用程序，用于使用 Flask 。瓶套套接口。Gevent和tmodel的用户。Mmmm 。查看演示或者阅读文档文档。
flask-socketio实现WebSocket的方法
01-01
【flask-socektio】 之前不知道在哪个场合下提到过如何从web后台向前台推送消息。听闻了反向ajax技术这种模式之后，大呼神奇，试了一下之后发现也确实可以用。不过，反向ajax的代价也很明显，只要客户端还和服务端要有信息交互，服务端就必须还维持客户端的这个请求，然后在合适的时候返回。当客户端一多，这么做的成本会比较大。 其他的后端推前端的技术还有类似于隐藏frame，Comet、长轮询等等，没有详细了解过，总之也是各有千秋但也各有利弊。 前不久在开发中碰到了这样一个场景，就是在后台执行一些代码，然后会根据执行的最新情况推送一些提示信息到前台让用户可以知道目前执行到哪一步了。典
python flask 实现 websocket 服务器
qq_27487739的博客
05-30 1539
事件处理程序将被调用，并打印’Client disconnected’。事件处理程序将被调用，并打印 ‘Client connected’。装饰器用于处理 WebSocket 客户端发送的各种事件。将提供客户端正在运行的服务器的 URL。在这个事件处理程序中，我们使用 Python 的内置。在这个例子中，你可以使用 JavaScript 的。方法连接到客户端指定的主机和端口。在这里，我们使用 WebSocket 连接的。事件处理程序将被调用，并打印接收到的消息。函数用于向所有已连接的客户端广播消息。
python flask websocket_websocket消息订阅 -- flask + flask-socketIO
weixin_29662775的博客
03-01 819
flask + websocket消息订阅Flask-SocketIO使Flask应用程序能够在客户端clients 和服务器server之间实现低延迟的全双工通信。 客户端应用程序可以使用JavaScript，C ++，Java和Swift中的任何SocketIO官方客户端库或任何兼容的客户端来建立到服务器的永久连接。安装pip install flask-socketioflask项目接入步骤...
python基于flask_sockets实现WebSocket
ieeso的博客
03-23 4592
WebSocket是啥？ WebSocket是HTML5引入的新的通信协议，主要由Web客户端和服务器实现，当然它也可以在Web之外实现。 与HTTP连接不同，WebSocket连接是客户端和服务器之间永久的双向通信通道，其中任何一个都可以启动交换。 一旦建立，连接一直有效，直到其中一方断开连接。 flask实现websocket的两种方式 flask 实现websocket有两种方式实现，一...
Python 基于 Flask 框架实现 Websocket 实时通信详细教程（待更新）
热门推荐
唤醒手腕
06-11 3万+
Websocket 和 Http WebSocket 是 HTML5 出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算） 首先HTTP有 1.1 和 1.0 之说，也就是所谓的 keep-alive ，把多个HTTP请求合并为一个，但是 Websocket 其实是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已，也就是说它是HTTP协议上的一种补充可以通过这样一张图理解： 有交集，但是并不是全部 GET /cha
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值