呼叫扭曲重铸者。运行（）Flask内app

Question

我在python flask中为jasminsgateway编写一个web服务来创建和删除网关中的用户。在POST请求的情况下，我调用runScenario（），然后启动反应器.运行（）将在网关中创建用户。这段代码在第一次web服务调用中运行得很好，但是在第二次调用时，它给了我一个错误：

raise error.ReactorNotRestartable()
ReactorNotRestartable

这是我的烧瓶应用程序：

^{pr2}$

我调用runScenario（），它在茉莉花综合.py在

#!/usr/bin/env python
import sys
import pickle
from flask import abort
from twisted.internet import defer, reactor
from jasmin.managers.proxies import SMPPClientManagerPBProxy
from jasmin.routing.proxies import RouterPBProxy
from jasmin.routing.Routes import DefaultRoute
from jasmin.routing.jasminApi import SmppClientConnector, User, Group, MtMessagingCredential, SmppsCredential
from jasmin.protocols.smpp.configs import SMPPClientConfig
from twisted.web.client import getPage


@defer.inlineCallbacks
def runScenario(Request):
    try:
        proxy_router = RouterPBProxy()
        yield proxy_router.connect('127.0.0.1', 8988, 'radmin', 'rpwd')

        if Request.method == 'POST':            
            smppUser = Request.json['username']
            smppPass = Request.json['password']
            smppThroughput = Request.json['tp']
            smppBindSessions = Request.json['sessions']

            if not smppUser:
                abort(400)

            if len(smppPass) == 0 or len(smppPass) > 8:
                abort(400)

            if not smppThroughput.isdigit():
                abort(400)

            if not smppBindSessions.isdigit():
                abort(400)

            # Provisiong router with users
            smpp_cred = SmppsCredential()
            yield smpp_cred.setQuota('max_bindings',int(smppBindSessions))

            mt_cred = MtMessagingCredential()
            yield mt_cred.setQuota('smpps_throughput' , smppThroughput)
            #yield mt_cred.setQuota('submit_sm_count' , 500)

            g1 = Group('clients')
            u1 = User(uid = smppUser, group = g1, username = smppUser, password = smppPass, mt_credential = mt_cred, smpps_credential = smpp_cred)
            yield proxy_router.group_add(g1)
            yield proxy_router.user_add(u1)

        if Request.method == 'DELETE':

            smppUser = Request.json['username']

            if not smppUser:
                abort(404)

            yield proxy_router.user_remove(smppUser) 
    except Exception, e:
        yield "%s" %str(e)

    finally:
        print "Stopping Reactor"
        reactor.stop()

请帮我解决这个问题：

Answer 1

Reactor在Twisted by design中是不可重启的，它执行不容易重启的初始化和终结。在

在所提供的示例中，您使用的是开发WSGI服务器（flask的默认服务器，http://werkzeug.pocoo.org/docs/0.11/serving/），默认情况下它是单线程的。在

如果您避免使用线程而改用多进程服务器，那么您的问题就会消失。 i、 e.如果您只是这样运行它就可以了（请参见processes=2=>；每个请求将在一个新的进程中处理，但不超过2个并发请求）：

if __name__ == '__main__':                                                      
    JasminWebservice.run(host="0.0.0.0", port=7034, debug=True, processes=2)

但我不相信这一点——编写单元测试时，您会遇到类似的问题，并将您的应用程序限制在多进程环境中运行不是一个好方法。在

但问题似乎源于你的应用程序设计——为什么你需要Flask和一个额外的WSGI服务器？ 您可以在twisted中完全构建restapi，最终只运行一个reactor，它将处理对API的查询和传入的请求。在

Answer 2

你不能让反应堆停下来再运转。你得到的错误是故意的。考虑使用klein，它使用werkzeug类似flask，并利用{}进行联网。语法甚至相似。将代码转换为klein将有点像这样：

import json
from klein import Klein
from exception werkzeug.exceptions import NotFound
from JasminIntegration import *

JasminWebservice = Klein()

@JasminWebservice.handle_errors(NotFound)
def not_found(request, error):
    request.setResponseCode(404)
    return json.dumps({'error': 'Not found'})

@JasminWebservice.route('/jsms/webservice', methods=['POST'])
def create_user(request):
    try:
        data = json.loads(request.content.read())
        if not data or if 'username' not in data:
            raise NotFound()
    except:     # yeah I know this isn't best practice
        raise NotFound()

    runScenario(request)
    request.setResponseCode(201)
    return json.dumps({'response':'Success'})

if __name__ == '__main__':    
    JasminWebservice.run("0.0.0.0", port=7034)

另外，除非您想完全退出应用程序，否则不应停止reactor。在

Answer 3

@f上次我也试着在twisted中做，但遇到了同样的问题，因为反应堆没有可重新启动。输入我做过这样的事：

#!/usr/bin/env python
from pprint import pprint
import json
from twisted.web import server, resource
from twisted.internet import reactor
from JasminIntegration import *
import ast

class Simple(resource.Resource):
    isLeaf = True
    def render_GET(self, request):
        return "<html>Hello, world!</html>"

    def render_POST(self, request):
        pprint(request.__dict__)
        newdata = request.content.getvalue()
        newdata = ast.literal_eval(newdata)
        ret = runScenario(newdata)
        #print  request.content
        #print newdata
        return ''
site = server.Site(Simple())
reactor.listenTCP(7034, site)
reactor.run()