def testSingleProc(self):
r = cg.Receiver()
r.addHandler(1, cg.self().send, "one")
proc = cg.spawn(self.receive, r)
proc.send(1)
r = cg.Receiver()
r.addHandler("one", lambda: "success")
assert r.receive(1000) == "success"
cg.exit(proc, "kill")
def testReset(self):
# test that Receiver resets pointer back to front of mailbox after switching
# to another process
r1 = cg.Receiver()
r1.addHandler(1, cg.self().send, "one")
proc1 = cg.spawn(self.receive, r1)
proc1.send(2)
proc1.send(1)
r = cg.Receiver()
r.addHandler("one", lambda: "success")
assert r.receive(1000) == "success"
proc2 = cg.spawn(self.receive, r1)
proc2.send(1)
assert r.receive(1000) == "success"
cg.exit(proc1, "kill")
cg.exit(proc2, "kill")
def tearDown(self):
# Remove any spurrious messages from mailbox
r = cg.Receiver()
timeout = object()
r.addHandler(cg.Any)
while r.receive(0, lambda: timeout) is not timeout:
pass
def main(argv):
if len(argv) != 4:
print "Usage: portscan_cg.py localhost 1 80"
return 1
host = argv[1]
start = int(argv[2])
end = int(argv[3])
r = cg.Receiver()
r[Result] = lambda m: m, cg.Message
scanners = [cg.spawn(scan) for i in range(0, NUM_OF_WORKERS)]
i = 0
for port in range(start, end + 1):
scanners[i] | (cg.self(), Target(host, port))
i += 1
if i == NUM_OF_WORKERS:
i = 0
port_count = end - start + 1
ports = []
j = 0
while j != port_count:
result = r.receive()
j += 1
if result.is_success:
ports.append(result.port)
ports.sort()
for port in ports:
print "Connected to port %s" % port
return 0
def __init__(self):
# Don't bind a custom notification event to wx.App at this point, since
# a wx.App shouldn't be instantiated yet. We bind to the wx.App, instead,
# when the first time send() is called.
cg.Process.__init__(self)
self.__app = None
self.__notifyEventType = None
self.receiver = cg.Receiver()
def testSpawnMyProcess(self):
proc = cg.spawn(echo, cg.self(), _processClass=MyProcess)
assert isinstance(proc, MyProcess)
proc.send("test")
r = cg.Receiver()
r.addHandler(cg.Any, lambda m: m, cg.Message)
assert r.receive() == ("MyProcess", "test")
cg.exit(proc, "kill")
def testMultiProc(self):
r1 = cg.Receiver()
r1.addHandler(1, cg.self().send, "one")
proc1 = cg.spawn(self.receive, r1)
proc2 = cg.spawn(self.receive, r1)
proc1.send(1)
proc2.send(1)
r = cg.Receiver()
r.addHandler("one", lambda: "success")
assert r.receive(1000) == "success"
assert r.receive(1000) == "success"
proc3 = cg.spawn(self.receive, r1)
proc3.send(1)
assert r.receive(1000) == "success"
cg.exit(proc1, "kill")
cg.exit(proc2, "kill")
cg.exit(proc3, "kill")
def run(self):
"""Entry point of thread."""
# Register the handler functions for various messages:
r = cg.Receiver()
r.addHandler('increment', self.increment)
r.addHandler((cg.Process, 'value'), self.sendVal, cg.Message)
r.addHandler('stop', self.setStop)
# Keep handling new messages until the stop flag is set.
while not self.stop:
r.receive()
def run(self):
""" 线程的入口点 """
#Register the handle functions for various messages:
r = cg.Receiver()
r.addHandler('increment', self.increment)
r.addHandler((cg.Process, 'value'), self.sendVal, cg.Message)
r.addHandler('stop', self.setStop)
#断续处理新消息，直到被要求结束
while self.running:
r.receive()
def testRemoveHandlers(self):
r1 = cg.Receiver()
ref1 = r1.addHandler(1)
ref2 = r1.addHandler(2)
ref3 = r1.addHandler(3)
r2 = cg.Receiver()
r2.addHandler(4)
r2.addHandler(5)
r2.addHandler(6)
refs = r2.addHandlers(r1)
assert len(r2._Receiver__handlers), 6
cg.self().send(2)
assert r2.receive(0, lambda: "to") == None
r2.removeHandler(refs[1])
assert len(r2._Receiver__handlers), 5
cg.self().send(2)
assert r2.receive(0, lambda: "to") == "to"
with pytest.raises(cg.ExitError):
r2.removeHandler(refs[1])
def run(self):
""" The entry point of the thread. """
# Register the handler functions for various messages:
r = cg.Receiver()
r.addHandler('increment', self.increment)
r.addHandler((cg.Process, 'value'), self.sendVal, cg.Message)
r.addHandler('stop', self.setStop)
# Keep handling new messages until a stop has been requested
while self.running:
r.receive()
def testRemoveHandler(self):
r = cg.Receiver()
ref1 = r.addHandler(1)
ref2 = r.addHandler(2)
ref3 = r.addHandler(3)
assert len(r._Receiver__handlers), 3
cg.self().send(2)
assert r.receive(0, lambda: "to") == None
r.removeHandler(ref2)
assert len(r._Receiver__handlers), 2
cg.self().send(2)
assert r.receive(0, lambda: "to") == "to"
with pytest.raises(cg.ExitError):
r.removeHandler(ref2)
def test(dict):
r = cg.Receiver()
r.addHandler("alarm", lambda: "beep")
start = time.time()
proc = dict["timeout"](1000, "alarm")
assert r.receive() == "beep"
time.sleep(PAUSE)
assert not proc.isAlive()
start = time.time()
proc = dict["timeout"](1000, "alarm")
time.sleep(0.5)
dict["cancel"](proc)
time.sleep(0.1)
assert not proc.isAlive()
assert time.time() - start < 1.0
def sampleSpawn():
"""Start GUI event loop in separate process"""
# Unique value used to acknowledge that the wx.App has been created:
ack = object()
# Unique value used to signal a receive() timeout:
timeout = object()
# Spawn a new wxProcess, calling mainLoop():
proc = cg.spawn(mainLoop, cg.self(), ack, _processClass=wxProcess)
# We wait for acknowledgement from the spawned process before proceeding,
# since we should make sure that the wx.App has been instantiated before
# allowing anyone to send messages to the process.
r = cg.Receiver()
r.addHandler(ack)
# Wait at most 30 seconds.
result = r.receive(30000, lambda: timeout)
assert result is not timeout
return proc
def scan():
r = cg.Receiver()
r[(cg.Process, Target)] = try_connect, cg.Message
while 1:
r.receive()
def setUp(self):
self.r = cg.Receiver()
def proc_func():
r = cg.Receiver()
r.addHandler("land shark", shut_door, cg.Message)
r.addHandler("candygram", open_door, cg.Message)
for message in r:
print >> self.out, message
"""Entry point of thread."""
# Register the handler functions for various messages:
r = cg.Receiver()
r.addHandler('increment', self.increment)
r.addHandler((cg.Process, 'value'), self.sendVal, cg.Message)
r.addHandler('stop', self.setStop)
# Keep handling new messages until the stop flag is set.
while not self.stop:
r.receive()
# end while
# Create new thread.
counter = cg.spawn(Thread().run)
# Define a receiver that will return the thread's response values:
response = cg.Receiver()
response.addHandler((counter, int), lambda msg: msg[1], cg.Message)
# Tell thread to increment twice.
counter.send('increment')
counter.send('increment')
# Request thread's current value.
counter.send((cg.self(), 'value'))
# Print the response
print response.receive()
# Tell thread to increment one more time.
counter.send('increment')
# And print it's current value.
counter.send((cg.self(), 'value'))
print response.receive()
# Tell thread to stop.
counter.send('stop')
def echo(proc):
r = cg.Receiver()
r.addHandler(cg.Any, proc.send, cg.Message)
r.receive()