Exemple #1
0
def t2(pretty, factory):
    class Defiant(Process):
        def handle_SIGTERM(self, signum, frame):
            time.sleep(5)  # very poor behavior
            Process.handle_SIGTERM(self, signum, frame)

        def run(self):
            while True:
                time.sleep(1)

    class Spawner(Control):
        @Control.rpc
        def spawn(self):
            pids = []
            for i in range(500):
                d = Defiant()
                d.start()
                self.join_later(d)
                pids.append(d.pid)
            return pids

        @Control.rpc
        def list_orphans(self):
            return [p._pid for p in self.deferred_joins]

    sock, port = find_free_port()
    spawner = Spawner(port, None, sock)
    spawner.start()
    factory.processes.append(spawner)
    master = RemoteControl(('', port), None, 5)

    defiers = master.spawn()
    for pid in defiers:
        os.kill(pid, signal.SIGTERM)

    orphans = master.list_orphans()
    if len(orphans) != 500:
        print('FAIL %s: there are not 500 orphans: %s' % (pretty, orphans))
        return False

    for pid in defiers:
        os.kill(pid, signal.SIGKILL)

    for i in range(10):
        orphans = master.list_orphans()
        if not orphans:
            break
        time.sleep(0.3)
    if orphans:
        print('FAIL %s: some orphans survived: %d' % (pretty, len(orphans)))
        return False

    return True
Exemple #2
0
def t3(pretty, factory):
    class Defiant(Process):
        def run(self):
            while True:
                time.sleep(1)

    class Spawner(Control):
        def __init__(self, port, sock, not_a_child):
            Control.__init__(self, port, None, sock, logging=False)
            self.deferred_joins = [not_a_child]

        def run(self):
            self.join_later(not_a_child)
            Control.run(self)

        @Control.rpc
        def spawn(self):
            pids = []
            for i in range(5):
                d = Defiant()
                d.start()
                self.join_later(d)
                self.join_later(d)  # add twice
                pids.append(d.pid)
            return pids

        @Control.rpc
        def stillbirth(self):
            for i in range(5):
                d = Defiant()
                self.join_later(d)  # forgot to start

        @Control.rpc
        def list_orphans(self):
            return [p._pid for p in self.deferred_joins]

    not_a_child = Defiant()
    not_a_child.start()

    sock, port = find_free_port()
    spawner = Spawner(port, sock, not_a_child)
    spawner.start()
    factory.processes.append(spawner)
    master = RemoteControl(('', port), None, 5)

    master.stillbirth()
    defiers = master.spawn()
    orphans = master.list_orphans()

    # by now the deferred join should already have weeded out the impossible
    # processes and discarded them. that leaves the 5 double adds (10 procs).

    if len(orphans) != 10:
        print('FAIL %s: there are not 10 orphans: %s' % (pretty, orphans))
        return False

    for pid in defiers:
        os.kill(pid, signal.SIGTERM)

    for i in range(10):
        orphans = master.list_orphans()
        if not orphans:
            break
        time.sleep(0.3)
    if orphans:
        print('FAIL %s: some orphans survived: %d' % (pretty, len(orphans)))
        return False

    return True
Exemple #3
0
def t1(pretty, factory):
    class Defiant(Control):
        def handle_SIGTERM(self, signum, frame):
            pass  # go on living

        @Control.rpc
        def ping(self):
            return 'pong', self.pid

        @Control.rpc
        def stop(self):
            Control.stop(self)

    class Spawner(Control):
        children = None

        @Control.rpc
        def spawn(self):
            if not self.children:
                self.children = []
            sock, port = find_free_port()
            d = Defiant(port, None, sock)
            d.start()
            self.children.append(d)
            return [d.pid, port]

        @Control.rpc
        def orphanize(self):
            if not self.children:
                return None
            child, self.children = self.children[0], self.children[1:]
            child.terminate()
            self.join_later(child)

        @Control.rpc
        def list_orphans(self):
            return [p.pid for p in self.deferred_joins]

    sock, port = find_free_port()
    spawner = Spawner(port, None, sock)
    spawner.start()
    factory.processes.append(spawner)
    master = RemoteControl(('', port), None, 1)

    defiers = []
    for i in range(5):
        pid, port = master.spawn()
        remote = RemoteControl(('', port), None, 5)
        defiers.append(remote)

    orphans = master.list_orphans()
    if orphans:
        print('FAIL %s: there are orphans: %s' % (pretty, orphans))
        return False

    for i in range(5):
        master.orphanize()

    orphans = master.list_orphans()
    if len(orphans) != 5:
        print('FAIL %s: there are not 5 orphans: %s' % (pretty, orphans))
        return False

    for remote in defiers:
        try:
            remote.ping()
        except Exception, e:
            print('FAIL %s: orphan died too soon: %s' % (pretty, remote))
            return False
        remote.stop(__async__=True)