使用Chapel和Python的ZeroMQ在当前状态下无法应答

我不能确定错误在哪里，但我正在尝试在Python客户机和服务器之间传递消息。客户端代码是

import zmq

context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")

for request in range(10):
    print("Sending request %s ..." % request)
    socket.send(str("Yo"))
    message = socket.recv()
    print("OMG!! He said %s" % message)

礼拜堂的服务员是

use ZMQ;
var context: Context;
var socket = context.socket(ZMQ.REP);
socket.bind("tcp://*:5555");

while ( 1 < 2) {
  var msg = socket.recv(string);
  socket.recv(string);
  writeln("got something");
  socket.send("back from chapel");
}

我想双方都在发送/接收。最初的教堂示例运行良好，但我无法修改它

更新 在教堂团队的帮助下，这项工作现在开始运作

客户。py

import zmq

context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")

for request in range(10):
    message = "Hello %i from Python" % request
    print("[Python] Sending request: %s" % message)
    socket.send_string(message)
    message = socket.recv_string()
    print("[Python] Received response: %s" % message)

服务器。chpl

use ZMQ;

var context: Context;
var socket = context.socket(ZMQ.REP);
socket.bind("tcp://*:5555");

for i in 0..#10 {
  var msg = socket.recv(string);
  writeln("[Chapel] Received message: ", msg);
  socket.send("Hello %i from Chapel".format(i));
}

---

在团队解决并重新确认之前，请仅使用

int

有效负载测试任何ZMQ模块服务，并可能避免

PUB/SUB

原型（由于字符串匹配未决问题）

正如最近所做的那样，还有一条路要走，那就是提供

ZMQ

服务，以满足ZeroMQ API法规遵从性，并为异构分布式系统完全打开一扇交叉兼容的大门：

要发送字符串，Chapel发送一条具有字符串大小的消息，然后发送另一条具有字节缓冲区的消息；接收的工作原理类似。

这意味着您只需调用

由于目前的实施限制，在隐含的限制方面还需要付出更多的努力：

在Chapel中，通过
套接字
发送或接收消息时，尽可能使用多部分消息和
反射
模块序列化基本数据和用户定义的数据类型。目前，
ZMQ模块序列化由这些类型组成的基本数字类型、字符串和记录。字符串编码为长度（int），后跟字符数组（字节）

这在双方都会产生更多的问题，如果这些评论不仅仅是线路级的内部性，并且扩展到顶级的ZeroMQ消息/信令层，那么应该进行一些调整（参见管理订阅的详细信息，其中ZeroMQ主题筛选器匹配基于与接收到的消息的左侧精确匹配，等等）


侧面享有更大的设计自由度：
一些进一步的
try:/except:/finally:
构造应该用于无限
while（）
-loops等的
键盘中断
-s，但为了清楚起见，这里省略了这些构造


另一方面，我们将尽最大努力与API保持同步，如下所示：
目前，文档还不能帮助确定用户代码是否有控制选项，如果调用
.send（）
/
.recv（）
方法总是隐式地阻止或不阻止，而代码假定它是在阻止模式下运行的（对于任何分布式系统设计，我都强烈反对这种做法，阻塞是一种糟糕的做法）

虽然C级调用
zmq_send（）
可能是阻塞调用（取决于套接字类型和标志参数），但最好是对
socket.send（）进行语义阻塞调用允许在任务层支持的操作系统线程上调度其他任务。在内部，ZMQ模块使用对
ZMQ\u send（）
和
ZMQ\u recv（）
的非阻塞调用来传输数据，并在调用被阻塞时通过chpl\u task\u yield（）向任务层屈服


使用ZMQ；
使用反射；
var-context：上下文；
var dataBA=context.socket（ZMQ.REP），
heartB=context.socket（ZMQ.PUB）；
var WAITms=0；//设置为显式int
dataBA.setsockopt（ZMQ.LINGER，WAITms）；//必须
heartB.setsockopt（ZMQ.LINGER，WAITms）；//预防措施
dataBA.bind（“tcp://*：5555”）；//可以反转.bind（）/.connect（）
writeln（“INF:此代理使用ZeroMQ v.”，ZMQ.version（））；
// /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
配置变量MAX_LOOPS=120；/--MAX_LOOPS=10在cmdline上设置
var i=0；
while（i
在团队解决并重新确认之前，请仅使用
int
有效负载测试任何ZMQ模块服务，并可能避免
PUB/SUB
原型（由于字符串匹配未决问题）

正如最近所做的那样，还有一条路要走，那就是提供
ZMQ
服务，以满足ZeroMQ API法规遵从性，并为异构分布式系统完全打开一扇交叉兼容的大门：

要发送字符串，Chapel发送一条字符串大小的消息，然后发送另一条带有字节缓冲区的消息；接收的工作原理类似。

这意味着您对

更多的努力还需要花在隐含的限制上，这些限制是由当前的i
use ZMQ;

var context: Context;
var socket = context.socket(ZMQ.REP);
socket.bind("tcp://*:5555");

for i in 0..#10 {
  var msg = socket.recv(string);
  writeln("[Chapel] Received message: ", msg);
  socket.send("Hello %i from Chapel".format(i));
}

#
# python
# #########

import time
import zmq; context = zmq.Context()

print( "INF: This Agent uses ZeroMQ v.{0:}".format( zmq.__version__ ) )

dataAB = context.socket( zmq.REQ )
dataAB.setsockopt( zmq.LINGER, 0 )        # ( a must in pre v4.0+ )
dataAB.connect( "tcp://localhost:5555" )

heartB = context.socket( zmq.SUB )
heartB.setsockopt( zmq.LINGER,   0 )      # ( a must in pre v4.0+ )
heartB.setsockopt( zmq.CONFLATE, 0 )      # ( ignore history, keep just last )

heartB.connect( "tcp://localhost:6666" )
heartB.setsockopt( zmq.SUBSCRIBE, "[chapel2python.HB]" )
heartB.setsockopt( zmq.SUBSCRIBE, "" )    # in case [Chapel] complicates serialisation
# -------------------------------------------------------------------    
while ( True ):
      pass;             print( "INF: waiting for a [Chapel] HeartBeat-Message" )
      hbIN = heartB.recv( zmq.NOBLOCK );
      if len( hbIN ) > 0:
         pass;          print( "ACK: [Chapel] Heart-Beat-Message .recv()-ed" )
         break
      else:
         time.sleep( 0.5 )
# -------------------------------------------------------------------
for request in range(10):
    pass;               print( "INF: Sending a request %s to [Chapel] ..." % request )
    dataAB.send( str( "Yo" ) )
    pass;               print( "INF: a blocking .recv(), [Chapel] is to answer ..." )
    message = dataAB.recv()
    pass;               print( "INF: [Chapel] said %s" % message )
# -------------------------------------------------------------------
dataAB.close()
heartB.close()
context.term()
# -------------------------------------------------------------------

use ZMQ;
use Reflection;

var context: Context;
var dataBA = context.socket( ZMQ.REP ),
    heartB = context.socket( ZMQ.PUB );
var WAITms = 0;                             // setup as explicit int
    dataBA.setsockopt( ZMQ.LINGER, WAITms );// a must
    heartB.setsockopt( ZMQ.LINGER, WAITms );// a preventive step

    dataBA.bind( "tcp://*:5555" );          // may reverse .bind()/.connect()

    writeln( "INF: This Agent uses ZeroMQ v.", ZMQ.version() );

// /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
config var   MAX_LOOPS  = 120;              //  --MAX_LOOPS = 10 set on cmdline
       var            i =   0;

while ( i < MAX_LOOPS ) {
 // --------------------------------------- // .send HeartBeat
    heartB.send( "[chapel2python.HB]" );
    i += 1;
    writeln( "INF: Sent HeartBeat # ", i );
 // --------------------------------------- // .send HeartBeat

    var msg = dataBA.recv( string );        // .recv() from python
 // - - - - - - - - - - - - - - - - - - - - // - - - - -WILL-[BLOCK]!!!
                                            //          ( ref. src )
    writeln( "INF: [Chapel] got: ",
              getField( msg, 1 )
              );

    dataBA.send( "back from chapel" );      // .send() to   python
}
writeln( "INF: MAX_LOOPS were exhausted,",
             " will exit-{} & .close()",
             " channels' sockets before",
             " [Chapel] exits to system."
             );
// /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
dataBA.close( WAITms );                     // explicit graceful termination
heartB.close( WAITms );                     // explicit graceful termination
context.deinit();                           // explicit context  termination
                                            //       as not yet sure
                                            //       on auto-termination
                                            //       warranties