def launch_write(self, filename, bot, rule):
# launch file actor if needed
try:
wfile = self.writers[filename]
except KeyError:
wactor, wargs = self.wactors[0]
wfile = ZActor(self.ctx, wactor, filename, wargs)
waddr = wfile.pipe.recv_string()
if not waddr:
err = f"ruleset: failed to bind any {self.addrpat} for {filename}"
log.error(err)
raise RuntimeError(err)
wfile.addr = waddr # copascetic?
log.debug(f"ruleset: made writer actor for {filename}")
self.writers[filename] = wfile
# the client handler
wactor, wargs = self.wactors[1]
actor = ZActor(self.ctx, wactor,
bot, rule,
wfile.addr, *wargs)
self.handlers.append(actor)
return True
def test_broker():
ctx = zmq.Context()
# note: normally, app goes through zio.Node
sport = zio.Port("server", zmq.SERVER);
sport.bind(server_address)
sport.do_binds()
sport.online()
client = ZActor(ctx, client_actor)
factory = Factory(server_address)
backend = ZActor(ctx, spawner, factory)
broker = Broker(sport, backend.pipe)
for count in range(30):
print (f"main: poll [{count}]")
ok = broker.poll(1000) # client->handler
if not ok:
break
print ("main: stopping")
broker.stop()
client.pipe.signal()
def test_dumper():
ctx = zmq.Context()
node = zio.Node("dumper")
server = node.port("server", zmq.SERVER)
server_address = "tcp://127.0.0.1:5678"
server.bind(server_address)
node.online()
client = ZActor(ctx, client_actor, server_address)
factory = Factory(server_address)
broker = Broker(server, factory)
for count in range(10):
log.debug (f"main: poll [{count}]")
try:
broker.poll(1000)
except TimeoutError as te:
log.info('broker is lonely, quitting')
break
log.debug (f"main: stop broker")
broker.stop()
log.debug (f"main: node offline")
node.offline()
log.debug (f"main: stop client")
client.pipe.signal()
def __call__(self, bot):
fobj = bot.label_object
if fobj['direction'] == 'extract': # my direction.
return # only handle inject
actor = ZActor(self.ctx, dumper, bot, self.address)
self.handlers.append(actor)
return True
def __init__(self):
self.dont_ip = os.environ.get('DONT_IP', '').split(' ')
self.other_repeaters = []
self.consul = Consul(sys.argv[1])
self.ctx = zmq.Context()
self.poller = zmq.Poller()
self.repeater_pub_port = REPEATER_PUB_PORT
self.pub = self.ctx.socket(zmq.PUB)
self.pub.bind('tcp://*:%d' % self.repeater_pub_port)
self.sub = self.ctx.socket(zmq.SUB)
self.sub.setsockopt(zmq.SUBSCRIBE, b'')
self.poller.register(self.sub, zmq.POLLIN)
self.beacon = ZActor(self.ctx, ZBeacon)
self.beacon.send_unicode('CONFIGURE', zmq.SNDMORE)
self.beacon.send(struct.pack('I', ZRE_DISCOVERY_PORT))
self.address = self.beacon.recv_unicode() # Hostname
filter_ = struct.pack('ccc', b'Z', b'R', b'E')
self.beacon.send_unicode('SUBSCRIBE',zmq.SNDMORE)
self.beacon.send(filter_)
self.beacon_socket = self.beacon.resolve()
self.poller.register(self.beacon_socket, zmq.POLLIN)
def test_cbsfhwf():
ctx = zmq.Context()
server_address = "tcp://127.0.0.1:5678"
ruleset = [
dict(
attr=dict(testname="cbsfhwf"), # just because
rw="w",
rule='(= stream "client1")',
filepat="test-{testname}.hdf",
grouppat="{stream}"),
]
client1 = ZActor(ctx, flow_depos, 10, "client1", server_address)
broker = make_broker(ctx, ruleset, server_address)
log.debug("start broker poll")
while True:
ok = broker.poll(1000)
if ok is None:
log.debug(f'broker is too lonely')
break
log.debug("broker stop")
broker.stop()
log.debug("client1 pipe signal")
client1.pipe.signal()
log.debug("test done")
def launch_read(self, filename, bot, rule):
# fixme: for now assume file format allows for simultaneous
# reading so file and client handlers are merged into one.
ractor, rargs = self.ractor
log.debug(f'launch_read: {ractor}, {rargs}')
actor = ZActor(self.ctx, ractor, bot, rule, filename, *rargs)
self.handlers.append(actor)
return True
def setUp(self, *args, **kwargs):
ctx = zmq.Context()
ctx = zmq.Context()
# two beacon frames
self.transmit1 = struct.pack('cccb16sH', b'Z', b'R', b'E', 1,
uuid.uuid4().bytes, socket.htons(9999))
self.transmit2 = struct.pack('cccb16sH', b'Z', b'R', b'E', 1,
uuid.uuid4().bytes, socket.htons(9999))
self.node1 = ZActor(ctx, ZBeacon)
self.node1.send_unicode("VERBOSE")
self.node1.send_unicode("CONFIGURE", zmq.SNDMORE)
self.node1.send(struct.pack("I", 9999))
print("Hostname 1:", self.node1.recv_unicode())
self.node2 = ZActor(ctx, ZBeacon)
self.node2.send_unicode("VERBOSE")
self.node2.send_unicode("CONFIGURE", zmq.SNDMORE)
self.node2.send(struct.pack("I", 9999))
print("Hostname 2:", self.node2.recv_unicode())
def spawn(self, actor_func, bot):
'''
Spawn actor function.
Function must take a flow and the BOT.
'''
port = Port("handler", zmq.CLIENT,'')
port.connect(self.server_address)
port.online(None)
flow = Flow(port)
actor = ZActor(self.ctx, actor_func, flow, bot)
return actor
def setUp(self, *args, **kwargs):
ctx = zmq.Context()
self.actor = ZActor(ctx, zactor.echo_actor, "Hello, World")
