def send_turtle_pose_erlang(data):
global mailbox
node_name_atom = erl_term.ErlAtom(ERLANG_REMOTE_NODE_NAME)
remote_pid = erl_term.ErlPid(node=node_name_atom,
id=38,
serial=0,
creation=1)
msg_data = erl_term.ErlNumber(data.x)
pose = [
erl_term.ErlNumber(data.x),
erl_term.ErlNumber(data.y),
erl_term.ErlNumber(data.theta),
erl_term.ErlNumber(data.linear_velocity),
erl_term.ErlNumber(data.angular_velocity)
]
msg_data = erl_term.ErlTuple(pose)
self_node_name = erl_term.ErlAtom("%s" % SELF_NODE_NAME)
self_reg_process = erl_term.ErlAtom("%s" % SELF_NODE_REGISTERED_PROCESS)
return_addr = erl_term.ErlTuple([self_node_name, self_reg_process])
msg = erl_term.ErlTuple([return_addr, msg_data])
remote_process_atom = erl_term.ErlAtom(
"%s" % ERLANG_REMOTE_NODE_REGISTERED_PROCESS)
dest = erl_term.ErlTuple([remote_process_atom, node_name_atom])
mailbox.Send(dest, msg)
if VERBOSE:
print "Sent message to (%s,%s)" % (
ERLANG_REMOTE_NODE_REGISTERED_PROCESS, ERLANG_REMOTE_NODE_NAME)
def _NodeDown(self, nodeStatus, nodeName):
if nodeName in self._pendingRPCs:
callbacks = self._pendingRPCs[nodeName]
self._pendingRPCs[nodeName] = []
for cb in callbacks:
cb((erl_term.ErlAtom("EXIT"), (erl_term.ErlAtom("nodedown"),
erl_term.ErlAtom(nodeName))))
def to_py_interface(value):
if value is None:
return erl_term.ErlAtom("undefined")
elif value is True:
return erl_term.ErlAtom("true")
elif value is False:
return erl_term.ErlAtom("false")
elif isinstance(value, int) or isinstance(value, long):
return erl_term.ErlNumber(value)
elif isinstance(value, float):
return erl_term.ErlNumber(value)
elif isinstance(value, Atom):
return erl_term.ErlAtom(value)
elif isinstance(value, String):
return erl_term.ErlTuple(['#S', erl_term.ErlList(value)])
elif isinstance(value, str):
return erl_term.ErlBinary(value)
elif isinstance(value, unicode):
return erl_term.ErlBinary(value)
elif isinstance(value, tuple):
return erl_term.ErlTuple([ to_py_interface(v) for v in list(value) ])
elif isinstance(value, list):
return erl_term.ErlList([ to_py_interface(v) for v in value ])
elif isinstance(value, dict):
l = [ erl_term.ErlTuple([to_py_interface(v), to_py_interface(v)]) for k, v in value.iteritems() ]
return erl_term.ErlTuple(['#T', erl_term.ErlList(l)])
else:
raise RuntimeError, 'unknown object ~s' % repr(value)
def SendRPC(self, remoteNode, mod, fun, args, cb):
"""Send an rpc to REMOTE-NODE, MOD, FUN, ARGS. Call CB for the answer.
REMOTE-NODE = string | <instance of ErlAtom>
The node to send the call to
MOD = string | <instance of ErlAtom>
The module
FUN = string | <instance of ErlAtom>
The name of the function to call
ARGS = list(<term>)
The argument list
CB = <function(RESULT): void>
REMOTE-NODE = string
RESULT = <term>
A callback function to be called when the answer
to the rpc callback receives. The callback is called
with one arg: the result. Its return value is ignored.
If the remote node goes down during execution, the
callback is called with this value:
tuple(<ErlAtom("EXIT")>,
tuple(<ErlAtom("nodedown")>,
<ErlAtom(<REMOTE-NODE-NAME>)>))
Returns: void
Throws: <<to-be-documented>>
Send an request to execute a function in a module on a remote node.
As for the Send method, this method returns immediately.
"""
if type(mod) == types.StringType:
mod = erl_term.ErlAtom(mod)
if type(fun) == types.StringType:
fun = erl_term.ErlAtom(fun)
# Handle queue of pending callbacks for the remote node
if type(remoteNode) == types.StringType:
remoteNodeName = remoteNode
elif erl_term.IsErlAtom(remoteNode):
remoteNodeName = remoteNode.atomText
if self._pendingRPCs.has_key(remoteNodeName):
self._pendingRPCs[remoteNodeName].append(cb)
else:
self._pendingRPCs[remoteNodeName] = [cb]
# Register a nodedown-callback for this node, so
# we can call any rpc callbacks in case the node goes down
if not self._nodeDownSubscriptions.has_key(remoteNodeName):
id = self._node.NodeDownSubscribe(self._NodeDown)
self._nodeDownSubscriptions[remoteNodeName] = id
# Now send the rpc-message
self.Send(("rex", remoteNode),
(self.Self(),
(erl_term.ErlAtom("call"),
mod, fun, args, erl_term.ErlAtom("user"))))
def expr_rebuild_atoms(expr):
"""
String is represented with "string"
Atom is represented with "'atom'"
"""
if type(expr) == types.StringType:
if len(expr) >= 2 and expr[0] == expr[-1] == "'":
atomText = expr[1:-1]
return erl_term.ErlAtom(atomText)
else:
return expr
elif type(expr) == types.ListType:
rebuiltList = []
for elem in expr:
rebuiltElem = expr_rebuild_atoms(elem)
rebuiltList.append(rebuiltElem)
return rebuiltList
elif type(expr) == types.TupleType:
rebuiltList = []
for elem in list(expr):
rebuiltElem = expr_rebuild_atoms(elem)
rebuiltList.append(rebuiltElem)
return tuple(rebuiltList)
else:
return expr
def __RpcResult(res):
global res_pidname, node_to_connect_to
print("RESULT:%s" % repr(res))
if res_pidname != None:
dest = (res_pidname, node_to_connect_to)
msg = (erl_term.ErlAtom("rpc_result"), res)
mb.Send(dest, msg)
def _CreatePid(self):
"""Returns: <instance of ErlPid>"""
## Code stolen from com/ericsson/otp/erlang/OtpLocalNode.java
global _serial, _pidCount
newPid = erl_term.ErlPid(erl_term.ErlAtom(self._nodeName), _pidCount,
_serial, self._creation)
_pidCount = _pidCount + 1
if _pidCount > 0x7fff:
_pidCount = 0
_serial = _serial + 1
if _serial > 0x07:
_serial = 0
return newPid
def _SendMsgToRemoteNode(self, pingResult, srcPid, destNode, destPid, msg):
"""This internal routine performs the actual sending."""
if pingResult != "pong":
return
destNodeName = destNode.atomText
if destNodeName not in self._connections:
return
conn = self._connections[destNodeName]
cookie = erl_term.ErlAtom("")
if erl_term.IsErlAtom(destPid):
ctrlMsg = (self.CTRLMSGOP_REG_SEND, srcPid, cookie, destPid)
else:
ctrlMsg = (self.CTRLMSGOP_SEND, cookie, destPid)
conn.SendMsg(ctrlMsg, msg)
def ExprRebuildAtoms(expr):
if type(expr) == types.StringType:
if len(expr) >= 2 and expr[0] == expr[-1] == "'":
atomText = expr[1:-1]
return erl_term.ErlAtom(atomText)
else:
return expr
elif type(expr) == types.ListType:
rebuiltList = []
for elem in expr:
rebuiltElem = ExprRebuildAtoms(elem)
rebuiltList.append(rebuiltElem)
return rebuiltList
elif type(expr) == types.TupleType:
rebuiltList = []
for elem in list(expr):
rebuiltElem = ExprRebuildAtoms(elem)
rebuiltList.append(rebuiltElem)
return tuple(rebuiltList)
else:
return expr
def atom(self, v):
return erl_term.ErlAtom(v)
def SendMsgFromMBox(self, sourceMBox, dest, msg):
"""This routine is intended to be called from an ErlMBox instance
SOURCE-MBOX = <instance of ErlMBox>
DEST = <instance of ErlPid> |
string |
<instance of ErlAtom> |
tuple(DEST-REGNAME, DEST-NODE)
DEST-REGNAME = DEST-NODE = string | <instance of ErlAtom>
MSG = <term>
Returns: void
THrows: <<to-be-documented>>
"""
## Possible dest types:
## - A tuple: (registered_name, node_name)
## - An atom: registered_name
## - A pid: <erlpid ...> (note: the pid contains the pid's node)
sourcePid = self._mboxes[sourceMBox]
## First check for strings in the dest argument.
## Convert any strings to to atoms.
if type(dest) == str or type(dest) == bytes:
dest = erl_term.ErlAtom(dest)
elif type(dest) == tuple:
destPidName = dest[0]
destNode = dest[1]
if type(destPidName) == str or type(destPidName) == bytes:
destPidName = erl_term.ErlAtom(destPidName)
if type(destNode) == str or type(destNode) == bytes:
destNode = erl_term.ErlAtom(destNode)
dest = (destPidName, destNode)
## Then split the dest into:
## destPid/destPidName and destNode
## depending on its type.
if type(dest) == tuple:
destPid = dest[0]
destNode = dest[1]
elif erl_term.IsErlAtom(dest):
destNode = self
name = dest.atomText
if name not in self._registeredNames:
return
destPid = self._registeredNames[name]
elif erl_term.IsErlPid(dest):
destPid = dest
destNode = dest.node
else:
return
## Now do the sending...
if destNode == self:
if destPid not in self._registeredPids:
return
mbox = self._registredPids[destPid]
mbox.Msg(msg)
else: # dest node is remote
# First make sure we are online
# FIXME: Will this really work???
# Publish might register callbacks, but
# this code continues after the Publish...
self.Publish()
destNodeName = destNode.atomText
if destNodeName not in self._connections:
# We don't have a connection to the destination
# We must open a connection.
# This is done by pinging with the ping-callback
# being a function that sends the message.
cb = erl_common.Callback(self._SendMsgToRemoteNode, sourcePid,
destNode, destPid, msg)
destNodeName = destNode.atomText
self.Ping(destNodeName, cb)
else:
## We have contact with the remote node. Send at once!
self._SendMsgToRemoteNode("pong", sourcePid, destNode, destPid,
msg)
import getopt
# expecting current dir to be test/
# so that we can find py_interface in ..
sys.path.insert(0, "..")
from py_interface import erl_term
from py_interface import erl_node
from py_interface import erl_opts
from py_interface import erl_common
from py_interface import erl_eventhandler
mb = None
quiet = False
deliberate_fail = erl_term.ErlAtom("do_deliberately_fail")
as_you_wish = erl_term.ErlAtom("ok_deliberately_failed_as_you_wished")
def __TestMBoxCallback(msg, *k, **kw):
global mb, quiet
if not quiet:
txt = "Incoming msg=%s (k=%s, kw=%s)" % (repr(msg), repr(k), repr(kw))
print(txt.encode("ascii", errors="backslashreplace"))
if type(msg) == tuple:
if len(msg) == 2:
if erl_term.IsErlPid(msg[0]):
dest = msg[0]
if not quiet:
print("Sending it back to %s" % (dest, ))
if msg[1] == deliberate_fail:
def __EpmdConnectedOk(dest, atom_to_send):
global mb
msg = (mb.Self(), erl_term.ErlAtom(atom_to_send))
mb.Send(dest, msg)