def __init__(self, openSocket=None):
self.evhandler = erl_eventhandler.GetEventHandler()
if openSocket == None:
self._Init()
else:
self._Init()
self._SetConnectionOpen(openSocket)
def main(argv):
global mb, quiet, node_to_connect_to
try:
opts, args = getopt.getopt(argv[1:], "?dn:c:qr:")
except getopt.error as info:
print(info)
sys.exit(1)
hostName = "localhost"
ownNodeName = "py_interface_test"
cookie = "cookie"
doDebug = 0
for (optchar, optarg) in opts:
if optchar == "-?":
print("Usage: %s erlnode" % argv[0])
sys.exit(1)
elif optchar == "-c":
cookie = optarg
elif optchar == "-d":
doDebug = 1
elif optchar == "-q":
quiet = 1
elif optchar == "-n":
ownNodeName = optarg
elif optchar == "-r":
global res_pidname
res_pidname = optarg
if len(args) >= 4:
node_to_connect_to = args[0]
mod = args[1]
fn = args[2]
args = eval(args[3])
else:
print("Error: missing args: " + "node_to_connect_to mod fn args")
sys.exit(1)
if doDebug:
erl_common.DebugOnAll()
print("Creating node...")
n = erl_node.ErlNode(ownNodeName, erl_opts.ErlNodeOpts(cookie=cookie))
n.SetEpmdConnectedOkCb(
erl_common.Callback(__EpmdConnectedOk, node_to_connect_to, mod, fn,
args, __RpcResult))
print("Publishing node...")
n.Publish()
print("Creating mbox...")
mb = n.CreateMBox(None)
m = n.CreateMBox(__TestMBoxCallback)
evhand = erl_eventhandler.GetEventHandler()
evhand.PushReadEvent(sys.stdin, __FlushStdout)
print("-GOING LOOPING-") # Erlang side will pick this text up
sys.stdout.flush()
evhand.Loop()
def __msg_handler_list_queues(msg):
data_lines = [ ]
for q in msg:
name = q[0][1][-1].contents
for atoms_tuple in q[1:]:
data_lines.append("%s.%s.%s %d" % \
(METRIC_PREFIX, name, atoms_tuple[0].atomText,
atoms_tuple[1]))
print data_lines
pub.publish(data_lines)
erl_eventhandler.GetEventHandler().AddTimerEvent(60,
rpc_list_queues, mbox=mbox)
def __init__(self, netTickTime, timeToTickCb, noResponseCb):
"""Constructor
NET-TICK-TIME = integer
the net-tick-time (in seconds).
TIME-TO-TICK-CB = <function(): void>
callback to call when it's time to tick.
NO-RESPONSE-CB = <function(): void>
callback to call when the other end has been
silent for too long.
Throws: nothing
"""
self._netTickTime = netTickTime
self._evhandler = erl_eventhandler.GetEventHandler()
self._InitStartResponseTimer(netTickTime, noResponseCb)
self._InitStartTickTimer(netTickTime, timeToTickCb)
def main(argv):
global mb, quiet
try:
opts, args = getopt.getopt(argv[1:], "?dn:c:q")
except getopt.error as info:
print(info)
sys.exit(1)
hostName = "localhost"
ownNodeName = "py_interface_test"
cookie = "cookie"
doDebug = 0
for (optchar, optarg) in opts:
if optchar == "-?":
print("Usage: %s erlnode" % argv[0])
sys.exit(1)
elif optchar == "-c":
cookie = optarg
elif optchar == "-d":
doDebug = 1
elif optchar == "-q":
quiet = 1
elif optchar == "-n":
ownNodeName = optarg
if doDebug:
erl_common.DebugOnAll()
print("Creating node...")
n = erl_node.ErlNode(ownNodeName, erl_opts.ErlNodeOpts(cookie=cookie))
print("Publishing node...")
n.Publish()
print("Creating mbox...")
mb = n.CreateMBox(None)
m = n.CreateMBox(__TestMBoxCallback)
print("Registering mbox as p...")
m.RegisterName("p")
evhand = erl_eventhandler.GetEventHandler()
evhand.PushReadEvent(sys.stdin, __FlushStdout)
print("-GOING LOOPING-") # Erlang side will pick this text up
sys.stdout.flush()
evhand.Loop()
def start_looping(own_node_name, cookie, debug_on_all):
if debug_on_all:
erl_common.DebugOnAll()
LOGGER.debug("Creating node...")
node = erl_node.ErlNode(own_node_name, erl_opts.ErlNodeOpts(cookie=cookie))
LOGGER.debug("Publishing node...")
node.Publish()
LOGGER.debug("Creating mbox...")
mbox = node.CreateMBox(__TestMBoxCallback)
LOGGER.debug("Registering mbox as p...")
mbox.RegisterName("p")
event_handler = erl_eventhandler.GetEventHandler()
event_thread = Thread(target=event_handler.Loop, args=())
# not necessary to flag as daemon since thread will end when stopping loop
event_thread.daemon = True
event_thread.start()
return node, mbox, event_handler
def run_erlang_event_handler():
global evhand
evhand = erl_eventhandler.GetEventHandler()
evhand.Loop()
for atoms_tuple in q[1:]:
data_lines.append("%s.%s.%s %d" % \
(METRIC_PREFIX, name, atoms_tuple[0].atomText,
atoms_tuple[1]))
print data_lines
pub.publish(data_lines)
erl_eventhandler.GetEventHandler().AddTimerEvent(60,
rpc_list_queues,
mbox=mbox)
def start_pyrabbitmqctl_node():
node = erl_node.ErlNode("pyrabbitmqctl%d" % os.getpid(),
ErlNodeOpts(cookie=COOKIE))
mbox = node.CreateMBox()
return node, mbox
def rpc_list_queues(mbox, vhost="/"):
mbox.SendRPC(ErlAtom(RABBIT_NODE), ErlAtom('rabbit_amqqueue'),
ErlAtom('info_all'), [ErlBinary(vhost), rpc_args],
__msg_handler_list_queues)
global pub
pub = GraphiteRabbitMQPublisher()
node, mbox = start_pyrabbitmqctl_node()
rpc_list_queues(mbox)
erl_eventhandler.GetEventHandler().Loop()
elif optchar == "-c":
cookie = optarg
elif optchar == "-d":
doDebug = 1
elif optchar == "-n":
ownNodeName = optarg
if doDebug:
erl_common.DebugOnAll()
print "Creating node..."
n = erl_node.ErlNode(ownNodeName, erl_opts.ErlNodeOpts(cookie=cookie))
print "Publishing node..."
n.Publish()
print "Creating mbox..."
mb = n.CreateMBox(None)
m = n.CreateMBox(__TestMBoxCallback)
print "Registering mbox as p..."
m.RegisterName("p")
print "Looping..."
evhand = erl_eventhandler.GetEventHandler()
evhand.Loop()
try:
main(sys.argv)
except KeyboardInterrupt:
print "Interrupted. Exiting."
sys.exit(1)
def __init__(self, top, node, mbox):
self.node = node
self.mbox = mbox
self.evhand = erl_eventhandler.GetEventHandler()
if sys.stdin.isatty():
# only useful if stdin might generate KeyboardInterrupt
self.__CheckKbdInterrupt()
f1 = Frame(top)
self.destVar = StringVar()
self.msgVar = StringVar()
self.destVar.set("(\"xxsh\",\"address@%s\")" % socket.gethostname())
self.msgVar.set("\"hej\"")
b = Button(f1, text="Send", borderwidth=1, command=self.Send)
b.pack(side=LEFT)
dg = Label(f1, text="Dest:")
de = Entry(f1, borderwidth=1, textvariable=self.destVar)
mg = Label(f1, text="Msg:")
me = Entry(f1, borderwidth=1, textvariable=self.msgVar)
dg.pack(side=LEFT)
de.pack(side=LEFT)
mg.pack(side=LEFT)
me.pack(side=LEFT)
f1.pack()
f2 = Frame(top)
b2 = Button(f2, text="SendRPC", borderwidth=1, command=self.SendRPC)
b2.pack(side=LEFT)
self.remoteNodeVar = StringVar()
self.modVar = StringVar()
self.funVar = StringVar()
self.argsVar = StringVar()
self.remoteNodeVar.set("\"'address@%s'\"" % socket.gethostname())
self.modVar.set("\"'io'\"")
self.funVar.set("\"'format'\"")
self.argsVar.set("[\"hej!~nhopp!~n\", []]")
rnl = Label(f2, text="remotenode:")
rne = Entry(f2, borderwidth=1, textvariable=self.remoteNodeVar)
modl = Label(f2, text="mod:")
mode = Entry(f2, borderwidth=1, width=10, textvariable=self.modVar)
funl = Label(f2, text="fun:")
fune = Entry(f2, borderwidth=1, width=10, textvariable=self.funVar)
argsl = Label(f2, text="args:")
argse = Entry(f2, borderwidth=1, textvariable=self.argsVar)
rnl.pack(side=LEFT)
rne.pack(side=LEFT)
modl.pack(side=LEFT)
mode.pack(side=LEFT)
funl.pack(side=LEFT)
fune.pack(side=LEFT)
argsl.pack(side=LEFT)
argse.pack(side=LEFT)
f2.pack()
f3 = Frame(top)
b3 = Button(f3,
text="Dump node connections",
borderwidth=1,
command=self.NDump)
b3.pack(side=LEFT)
f3.pack()
