PHP 和 python 节俭

Question

我是 thrift apache 的新手。我正在使用 API edenremote。当 thrift 调用函数 readMessageBegin 时，它进入循环，我没有收到任何响应，请求正在进行中

请帮我解决这个问题。

@Edit:从昨天开始，我调试它并发现了以下内容。

我在 PHP 中的主要代码如下

$result = json_decode(exec('./Authenticator.py'));
    //var_dump($result);
    $socket = new TSocket('localhost', 9090);
    $socket->setSendTimeout(50);
    $socket->setRecvTimeout(50);
    $transport = new TFramedTransport($socket, 1024, 1024);
    $protocol = new TBinaryProtocol($transport);
    $client = new \edenremotephp\pub\EdenRemote\EdenRemoteClient($protocol);
    $transport->open();
    $client->openSession($result->sessionID, 1);

PHP 中的响应是针对 openSession 的

/home/abbas/www/local.edenremote.com/index.php:56:string 'TSocket: timed out reading 4 bytes from localhost:9090' (length=54)

并且在服务器(Python)中得到了这个响应

127.0.0.1 - - [24/Apr/2017 20:00:22] "POST /response HTTP/1.1" 200 -
127.0.0.1 - - [24/Apr/2017 20:00:22] code 400, message Bad request version ('\x00\x01\x00\x00\x00$3633e905-28dd-11e7-a104-b4b67605b5e0\x08\x00\x02\x00\x00\x00\x01\x00')
127.0.0.1 - - [24/Apr/2017 20:00:22] "J�
                                        openSession
                                                   $3633e905-28dd-11e7-a104-b4b67605b5e" 400 -

我希望它能帮助您理解我的主要问题。谢谢。

Python Server Handler(不完整，完整的文件很大。如果你想了解更多请告诉我):

class myHandler(BaseHTTPRequestHandler):

    #Handler for the GET requests
    def do_GET(self):
        if self.path=="/":
            self.path="/testData/index.html"

        try:
            #Check the file extension required and
            #set the right mime type

            sendReply = False
            if self.path.endswith(".html"):
                mimetype='text/html'
                sendReply = True
            if self.path.endswith(".jpg"):
                mimetype='image/jpg'
                sendReply = True
            if self.path.endswith(".gif"):
                mimetype='image/gif'
                sendReply = True
            if self.path.endswith(".js"):
                mimetype='application/javascript'
                sendReply = True
            if self.path.endswith(".css"):
                mimetype='text/css'
                sendReply = True

            if sendReply == True:
                #Open the static file requested and send it
                filePath = os.path.realpath(curdir + self.path)
                print "Debug - filePath:", filePath
                f = open(filePath) 
                self.send_response(200)
                self.send_header('Content-type',mimetype)
                self.end_headers()
                self.wfile.write(f.read())
                f.close()
            return

        except IOError:
            self.send_error(404,'File Not Found: %s' % self.path)

    #---------------------------------------------------------------------------
    # Handler for the POST requests
    def do_POST(self):
        if self.path=="/send":
            form = cgi.FieldStorage(
                fp=self.rfile, 
                headers=self.headers,
                environ={'REQUEST_METHOD':'POST',
                         'CONTENT_TYPE':self.headers['Content-Type'],
            })

            print "Your access key ID is: %s" % form["accessKeyId"].value

            self.send_response(200)
            self.end_headers()
            self.wfile.write("Thanks %s !" % form["accessKeyId"].value)
            return          

        if self.path=="/authenticate":
            print "authenticate post happened"
            form = cgi.FieldStorage(
                fp=self.rfile, 
                headers=self.headers,
                environ={'REQUEST_METHOD':'POST',
                         'CONTENT_TYPE':self.headers['Content-Type'],
            })

            xml = self.handleServerAuthChallenge(form)
            self.send_response(200)
            self.end_headers()
            self.wfile.write(xml)
            return          

        if self.path=="/response":
            form = cgi.FieldStorage(
                fp=self.rfile, 
                headers=self.headers,
                environ={'REQUEST_METHOD':'POST',
                         'CONTENT_TYPE':self.headers['Content-Type'],
            })

            xml = self.handleServerAuthResult(form)
            self.send_response(200)
            self.end_headers()
            self.wfile.write(xml)
            return                      

    #---------------------------------------------------------------------------
    def handleServerAuthChallenge(self, form):
        global gAuthRequests
        global gDebug

        if gDebug:
            print gWebSeparator

        # Instance the XML object to return to the auth requester
        serverAuthChallenge = AuthXml.ServerAuthChallenge()

        # Make sure that the required parameters are present
        error = False
        for requiredParam in kAuthPhase1_QueryNames:
            if requiredParam not in form:
                error = True
                serverAuthChallenge.setResultCode(str(AuthResultCode.kAuthResultCode_MissingQueryParameter))
                serverAuthChallenge.setResultMessage("You must provide the following query parameter: " + requiredParam)
                if gDebug:
                    print "Missing query parameter"
                    print "  " + serverAuthChallenge.getResultMessage()
                    print

        # If all the parameters are present, then process them
        if not error:
            clientVersion = form[kAuthPhase1_QueryName_ClientVersion].value
            accessKeyId = form[kAuthPhase1_QueryName_AccessKeyId].value
            if gDebug:
                print "handleServerAuthChallenge called with these form values:"
                print "  clientVersion: " + clientVersion
                print "  accessKeyId:   " + accessKeyId
                print

            # If the client is too old, then return an error
            clientVersionInt = int(clientVersion)
            if clientVersionInt < kClientAuthVersion_Minimum:
                serverAuthChallenge.setResultCode(str(AuthResultCode.kAuthResultCode_ClientUpdateNeeded))
                serverAuthChallenge.setResultMessage("The specified client version (" + clientVersion + ") is too old to use this service. Please update your client side library to the latest version.")
            else:
                # First see if the key ID from the client is in our disabled list. If it is,
                # then return the disabled error
                if accessKeyId in gDisabledAccessKeyHelpers:
                    serverAuthChallenge.setResultCode(str(AuthResultCode.kAuthResultCode_AccessKeyDisabled))
                    serverAuthChallenge.setResultMessage("The specified " + kAuthPhase1_QueryName_AccessKeyId + " is disabled and cannot be used: " + accessKeyId)

                # See if the specified key ID from the client can be found in our test dictionary.
                # If it can't, then return an error. Otherwise, provide the challenge XML to the
                # client so that it can take the next steps.
                elif accessKeyId in gValidAccessKeyHelpers:
                    serverAuthChallenge.setNextUrl("http://" + str(TEST_SERVER_HOST_NAME) + ":" + str(PORT_NUMBER) + "/response")
                    requestId = str(uuid.uuid1())
                    authRequest = AuthRequest(accessKeyId)
                    gAuthRequests[requestId] = authRequest
                    serverAuthChallenge.setRequestId(requestId)
                    challenge = base64.b64encode(authRequest.getChallenge())
                    serverAuthChallenge.setChallenge(challenge)
                else:
                    serverAuthChallenge.setResultCode(str(AuthResultCode.kAuthResultCode_InvalidKeyIdentifier))
                    serverAuthChallenge.setResultMessage("The specified " + kAuthPhase1_QueryName_AccessKeyId + " is unknown: " + accessKeyId)

        # Get the XML string that we'll return to the caller
        xml = serverAuthChallenge.getXml()
        if gDebug:
            print "About to provide this XML response to the client:"
            print
            print serverAuthChallenge.getXml(pretty=True)

        return xml

    #---------------------------------------------------------------------------
    def handleServerAuthResult(self, form):
        global gSessions
        global gDebug

        if gDebug:
            print gWebSeparator

        # Instance the XML object to return to the auth requester
        serverAuthResult = AuthXml.ServerAuthResult()

        # Make sure that the required parameters are present
        error = False
        for requiredParam in kAuthPhase2_QueryNames:
            if requiredParam not in form:
                error = True
                serverAuthResult.setResultCode(str(AuthResultCode.kAuthResultCode_MissingQueryParameter))
                serverAuthResult.setResultMessage("You must provide the following query parameter: " + requiredParam)
                if gDebug:
                    print "Missing query parameter"
                    print "  " + serverAuthResult.getResultMessage()
                    print

        # If all the parameters are present, then process them
        if not error:
            requestId = form[kAuthPhase2_QueryName_RequestId].value
            response = form[kAuthPhase2_QueryName_Response].value
            initializationVector = form[kAuthPhase2_QueryName_InitializationVector].value   

            if gDebug:
                print "serverAuthResult called with these form values:"
                print "  requestId:            " + requestId
                print "  response:             " + response
                print "  initializationVector: " + initializationVector
                print

            # Find the key identifier associated with the incoming request, and use it
            # to get the server access key that we will use to decrypt the incoming response
            # and check it against the challenge originally provided.
            if requestId in gAuthRequests:
                # Remove the request from our dictionary so that we won't accidentally find it again
                authRequest = gAuthRequests.pop(requestId, None)

                # Get the services access key associated with the auth request, then decrypt the
                # response and compare it to the original challenge.
                helper = gValidAccessKeyHelpers[authRequest.getAccessKeyId()]
                decryptedChallenge = helper.decodeAndDecrypt(response, inIv=base64.b64decode(initializationVector))
                if gDebug:
                    print "decryptedChallenge:   " + base64.b64encode(decryptedChallenge)
                if decryptedChallenge == authRequest.getChallenge():
                    # Give the authenticated URL to the client. In a real server implementation, this
                    # would be a randomized URL, not static.
                    serverAuthResult.setNextUrl("http://" + str(TEST_SERVER_HOST_NAME) + ":" + str(THRIFT_PORT_NUMBER))

                    # Return a randomized session ID. Again, in the real server, this could be the same
                    # as the random component of the returned URL.
                    session = Session()
                    sessionId = session.getSessionId()
                    gSessions[sessionId] = session
                    serverAuthResult.setSessionId(sessionId)
                else:
                    serverAuthResult.setResultCode(str(AuthResultCode.kAuthResultCode_InvalidResponse))
                    serverAuthResult.setResultMessage("The specified response is not valid: " + response)
            else:
                serverAuthResult.setResultCode(str(AuthResultCode.kAuthResultCode_InvalidRequestId))
                serverAuthResult.setResultMessage("The specified requestId is not valid: " + requestId)
            print

        # Get the XML string that we'll return to the caller
        xml = serverAuthResult.getXml()
        if gDebug:
            print "About to provide this XML response to the client:"
            print
            print serverAuthResult.getXml(pretty=True)

        return xml

try:
    # Initialize the dictionary of valid server access keys that will work with this test
    # server.
    for curAccessKeyString in gValidAccessKeyStrings:
        helper = AccessKeyHelper.AccessKeyHelper(curAccessKeyString)
        gValidAccessKeyHelpers[helper.getAccessKeyIdentifier()] = helper

    # Initialize the dictionary of disabled server access keys that will work with this test
    # server.
    for curAccessKeyString in gDisabledAccessKeyStrings:
        helper = AccessKeyHelper.AccessKeyHelper(curAccessKeyString)
        gDisabledAccessKeyHelpers[helper.getAccessKeyIdentifier()] = helper

    # Start the Thrift server in a separate thread
    startThriftServer()

    # Create a web server and define the handler to manage incoming requests
    server = HTTPServer(('', PORT_NUMBER), myHandler)
    print 'Started http server on port ' , PORT_NUMBER

    # Wait forever for incoming http requests
    server.serve_forever()

except KeyboardInterrupt:
    print
    print '^C received, shutting down the web server...'
    closeHttpServer(server)
    print '  Http server closed; Done processing control C'

if gThriftServer:
    print '  Calling the thrift server\'s server_close...'
    closeHttpServer(gThriftServer.httpd)
    print '  Thrift server closed'

if gThriftServerThread:
    print "Waiting for the thrift server thread to stop..."
    gThriftServerThread.join()

print "All servers stopped. Exiting..."

sys.exit(0)

startThriftServer() 代码是这样的

def startThriftServer():
    global gThriftServer
    global gThriftServerThread

    handler = EdenRemoteHandler()
    processor = EdenRemote.Processor(handler)
    pfactory = TBinaryProtocol.TBinaryProtocolFactory()
    gThriftServer = THttpServer.THttpServer(processor, (TEST_SERVER_HOST_NAME, THRIFT_PORT_NUMBER), pfactory)

    # Start the Thrift server in a separate thread
    gThriftServerThread = threading.Thread(target=serveFromThread, args=(gThriftServer, ))
    gThriftServerThread.start()

Answer 1

宾果。

客户端代码:

 $socket = new TSocket('localhost', 9090);
 $transport = new TFramedTransport($socket, 1024, 1024);
 $protocol = new TBinaryProtocol($transport);

服务器代码:

handler = EdenRemoteHandler()
processor = EdenRemote.Processor(handler)
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
gThriftServer = THttpServer.THttpServer(processor, ..., pfactory)

那有什么问题呢？

客户端使用 TFramedTransport 而服务器不使用。尽管某些服务器类型确实暗示了 TFramedTransport，但 THttpServer 却没有。

因此解决方案是

• 也可以在服务器端添加 TFramedTransport(推荐)
• 如果无法更改服务器，则从客户端删除它

如果您必须选择第二种情况，请考虑将 TFramedTransport 替换为 TBufferedTransport，这几乎同样高效，但对有线格式没有任何影响。