def test_pipe(Poller): m = Manager() + Poller() a, b = Pipe("a", "b") a.register(m) b.register(m) a = Client(channel=a.channel).register(m) b = Client(channel=b.channel).register(m) m.start() try: assert pytest.wait_for(a, "ready") assert pytest.wait_for(b, "ready") a.fire(write(b"foo")) assert pytest.wait_for(b, "data", b"foo") b.fire(write(b"foo")) assert pytest.wait_for(a, "data", b"foo") a.fire(close()) assert pytest.wait_for(a, "disconnected") b.fire(close()) assert pytest.wait_for(b, "disconnected") finally: m.stop()
def test_complex(): m = Manager() a = A() b = B() a.register(m) b.register(a) assert a in m assert a.root == m assert a.parent == m assert b in a assert b.root == m assert b.parent == a a.unregister() while len(m): m.flush() assert b.informed assert a not in m assert a.root == a assert a.parent == a assert b in a assert b.root == a assert b.parent == a
def after_properties_set(self): """ Run by Spring Python after all the JMS container's properties have been set. """ for idx in range(self.concurrent_listeners): # Create as many Circuits managers as there are JMS listeners. manager = Manager() manager.start() # A pool of handler threads for each listener. handlers_pool = ThreadPool(self.handlers_per_listener) # Each manager gets assigned its own listener. listener = WebSphereMQListener() # Assign the listener and a debugger component to the manager. manager += listener manager += Debugger(logger=self.logger) listener.factory = self.factory listener.destination = self.destination listener.handler = self.handler listener.handlers_pool = handlers_pool listener.wait_interval = self.wait_interval listener.start()
def main(): opts, args = parse_options() if ":" in opts.bind: address, port = opts.bind.split(":") port = int(port) else: address, port = opts.bind, 8000 if args: x = args[0].split(":") if len(x) > 1: nodes = [(x[0], int(x[1]))] else: nodes = [(x[0], 8000)] else: nodes = [] manager = Manager() debugger = Debugger() debugger.IgnoreEvents.extend(["Read", "Write"]) manager += debugger bridge = Bridge(port, address=address, nodes=nodes) manager += bridge manager.run()
def main(): setprocname(basename(sys.argv[0])) config = Config() chdir(config["rootdir"]) logger = setup_logging(config) manager = Manager() Worker(channel="workers").register(manager) if config["debug"]: Debugger( logger=logger, events=config["verbose"], ).register(manager) Core(config).register(manager) try: manager.run() finally: config.save()
def test_removeHandler(): m = Manager() m.start() method = m.addHandler(on_foo) waiter = pytest.WaitEvent(m, "foo") x = m.fire(foo()) waiter.wait() s = x.value assert s == "Hello World!" m.removeHandler(method) waiter = pytest.WaitEvent(m, "foo") x = m.fire(foo()) waiter.wait() assert x.value is None assert on_foo not in dir(m) assert "foo" not in m._handlers m.stop()
def test_main(): id = "%s:%s" % (os.getpid(), current_thread().getName()) m = Manager() assert repr(m) == "<Manager/ %s (queued=0) [S]>" % id app = App() app.register(m) s = repr(m) assert s == "<Manager/ %s (queued=1) [S]>" % id m.start() pytest.wait_for(m, "_running", True) sleep(0.1) s = repr(m) assert s == "<Manager/ %s (queued=0) [R]>" % id m.stop() pytest.wait_for(m, "_Manager__thread", None) s = repr(m) assert s == "<Manager/ %s (queued=0) [S]>" % id
def start(self): # Create a new circuits Manager #ignevents = [Update, MouseMove] ignchannames = [ 'update', 'started', 'on_mousemove', 'on_mousedrag', 'on_keydown', 'on_input', 'on_mouseclick', 'on_entityupdated', 'on_exit', 'on_keyup', 'on_login', 'on_inboundnetwork', 'on_genericmessage', 'on_scene', 'on_entity_visuals_modified', 'on_logout', 'on_worldstreamready', 'on_sceneadded' ] ignchannels = [('*', n) for n in ignchannames] # Note: instantiating Manager with debugger causes severe lag when running as a true windowed app (no console), so instantiate without debugger # Fix attempt: give the circuits Debugger a logger which uses Naali logging system, instead of the default which writes to sys.stderr # Todo: if the default stdout is hidden, the py stdout should be changed # to something that shows e.g. in console, so prints from scripts show # (people commonly use those for debugging so they should show somewhere) d = Debugger(IgnoreChannels=ignchannels, logger=NaaliLogger()) #IgnoreEvents = ignored) self.m = Manager() + d #self.m = Manager() #or __all__ in pymodules __init__ ? (i.e. import pymodules would do that) if self.firstrun: import autoload self.firstrun = False else: #reload may cause something strange sometimes, so better not do it always in production use, is just a dev tool. #print "reloading autoload" import autoload autoload = reload(autoload) #print "Autoload module:", autoload autoload.load(self.m) self.m.push(Started( self.m, None)) #webserver requires this now, temporarily XXX
def test_tcp_reconnect(Poller, ipv6): # XXX: Apparently this doesn't work on Windows either? # XXX: UPDATE: Apparently Broken on Windows + Python 3.2 # TODO: Need to look into this. Find out why... if pytest.PLATFORM == "win32" and pytest.PYVER[:2] >= (3, 2): pytest.skip("Broken on Windows on Python 3.2") m = Manager() + Poller() if ipv6: tcp_server = TCP6Server(("::1", 0)) tcp_client = TCP6Client() else: tcp_server = TCPServer(0) tcp_client = TCPClient() server = Server() + tcp_server client = Client() + tcp_client server.register(m) client.register(m) m.start() try: assert pytest.wait_for(client, "ready") assert pytest.wait_for(server, "ready") wait_host(server) # 1st connect client.fire(connect(server.host, server.port)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") # disconnect client.fire(close()) assert pytest.wait_for(client, "disconnected") # 2nd reconnect client.fire(connect(server.host, server.port)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "disconnected") assert pytest.wait_for(server, "disconnected") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop()
def main(): opts, args = parse_options() bind = parse_bind(opts.bind) if opts.validate: application = (Application() + Root()) app = validator(application) httpd = make_server(bind[0], bind[1], app) httpd.serve_forever() raise SystemExit(0) manager = Manager() opts.debug and Debugger().register(manager) Poller = select_poller(opts.poller.lower()) Poller().register(manager) if opts.server.lower() == "base": BaseServer(bind).register(manager) HelloWorld().register(manager) else: Server(bind).register(manager) Root().register(manager) docroot = os.getcwd() if not args else args[0] Static(docroot=docroot, dirlisting=True).register(manager) opts.passwd and Authentication(passwd=opts.passwd).register(manager) opts.logging and Logger().register(manager) if opts.profile and hotshot: profiler = hotshot.Profile(".profile") profiler.start() if opts.debug: print(graph(manager, name="circuits.web")) print() print(inspect(manager)) for i in range(opts.jobs): manager.start(process=True) manager.run() if opts.profile and hotshot: profiler.stop() profiler.close() stats = hotshot.stats.load(".profile") stats.strip_dirs() stats.sort_stats("time", "calls") stats.print_stats(20)
def __init__(self): Manager.__init__(self) self += GtkDriver() self += Debugger() self.server = BaseServer(9999) self.server += wsgi.Gateway(dummy_app) self += self.server
def main(): config = Config() manager = Manager() if config.get("debug"): manager += Debugger(events=config.get("verbose"), file=config.get("errorlog")) environ = Environment(config) SignalHandler(environ).register(environ) manager += environ if config.get("sock") is not None: bind = config.get("sock") elif ":" in config.get("bind"): address, port = config.get("bind").split(":") bind = (address, int(port)) else: bind = (config.get("bind"), config.get("port")) server = Server(bind) + Sessions() + Root(environ) + CacheControl(environ) + ErrorHandler(environ) if MemoryMonitor is not None: MemoryMonitor(channel="/memory").register(server) if not config.get("disable-logging"): server += Logger(file=config.get("accesslog", sys.stdout)) if not config.get("disable-static"): server += Static(docroot=os.path.join(config.get("theme"), "htdocs")) if not config.get("disable-hgweb"): baseui = ui() baseui.setconfig("web", "prefix", "/+hg") baseui.setconfig("web", "style", "gitweb") baseui.setconfig("web", "allow_push", "*") baseui.setconfig("web", "push_ssl", False) baseui.setconfig("web", "allow_archive", ["bz2", "gz", "zip"]) baseui.setconfig("web", "description", config.get("description")) server += Gateway({"/+hg": hgweb(environ.storage.repo_path, config.get("name"), baseui)}) if not config.get("disable-compression"): server += Compression(environ) if config.get("daemon"): manager += Daemon(config.get("pidfile")) server.register(manager) manager.run()
def test_basic(): m = Manager() app = App() app.register(m) assert app.test in app._handlers.get("test", set()) app.unregister() while len(m): m.flush() assert not m._handlers
def manager(request): manager = Manager() def finalizer(): manager.stop() request.addfinalizer(finalizer) manager.start() if request.config.option.verbose: Debugger().register(manager) return manager
def manager(request): manager = Manager() def finalizer(): manager.stop() request.addfinalizer(finalizer) waiter = WaitEvent(manager, "started") manager.start() assert waiter.wait() Debugger(events=request.config.option.verbose).register(manager) return manager
def test_tcp_bind(Poller, ipv6): m = Manager() + Poller() if ipv6: sock = socket(AF_INET6, SOCK_STREAM) sock.bind(("::1", 0)) sock.listen(5) _, bind_port, _, _ = sock.getsockname() sock.close() server = Server() + TCP6Server(("::1", 0)) client = Client() + TCP6Client() else: sock = socket(AF_INET, SOCK_STREAM) sock.bind(("", 0)) sock.listen(5) _, bind_port = sock.getsockname() sock.close() server = Server() + TCPServer(0) client = Client() + TCPClient() server.register(m) client.register(m) m.start() try: assert pytest.wait_for(client, "ready") assert pytest.wait_for(server, "ready") wait_host(server) client.fire(connect(server.host, server.port)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") # assert server.client[1] == bind_port client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "disconnected") assert pytest.wait_for(server, "disconnected") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop()
def init(self, quality=3, rate_limit=None): self.manager = Manager() script_dir = get_script_dir() save_dir = os.path.join(script_dir, 'songs') if not os.path.exists(save_dir): os.mkdir(save_dir) print('Script Dir: {}'.format(script_dir)) print('Saving to: {}'.format(save_dir)) self.save_dir = save_dir self.options = [ '--extract-audio', '--prefer-ffmpeg', '--audio-format mp3', '--ffmpeg {}'.format(script_dir), '--audio-quality {}'.format(quality) ] if rate_limit: try: rate_limit = float(rate_limit) except ValueError as e: raise ValueError('rate_limit should be a float.') self.options.append( '--limit-rate {}'.format(str(rate_limit) + 'M')) else: rate_limit = 1 # Make timeout to cancel download relative to rate limiting self.timeout = 2 * self.EXPECTED_MAX_SIZE / rate_limit self.queue = deque() self.downloading = None self.process = None self.yt_dl = 'youtube-dl' if sys.platform.startswith('win'): self.yt_dl += '.exe' self.timer = None self.start_time = None
def start(self): # Create a new circuits Manager #ignevents = [Update, MouseMove] ignchannames = ['update', 'started', 'on_mousemove', 'on_mousedrag', 'on_keydown', 'on_input', 'on_mouseclick', 'on_entityupdated', 'on_exit', 'on_keyup', 'on_login', 'on_inboundnetwork', 'on_genericmessage', 'on_scene', 'on_entity_visuals_modified', 'on_logout', 'on_worldstreamready', 'on_sceneadded'] ignchannels = [('*', n) for n in ignchannames] # Note: instantiating Manager with debugger causes severe lag when running as a true windowed app (no console), so instantiate without debugger # Fix attempt: give the circuits Debugger a logger which uses Naali logging system, instead of the default which writes to sys.stderr # Todo: if the default stdout is hidden, the py stdout should be changed # to something that shows e.g. in console, so prints from scripts show # (people commonly use those for debugging so they should show somewhere) d = Debugger(IgnoreChannels = ignchannels, logger=NaaliLogger()) #IgnoreEvents = ignored) self.m = Manager() + d #self.m = Manager() #or __all__ in pymodules __init__ ? (i.e. import pymodules would do that) if self.firstrun: import autoload self.firstrun = False else: #reload may cause something strange sometimes, so better not do it always in production use, is just a dev tool. #print "reloading autoload" import autoload autoload = reload(autoload) #print "Autoload module:", autoload autoload.load(self.m) self.m.push(Started(self.m, None)) #webserver requires this now, temporarily XXX
def manager(request): manager = Manager() def finalizer(): manager.stop() request.addfinalizer(finalizer) waiter = WaitEvent(manager, "started") manager.start() assert waiter.wait() if request.config.option.verbose: Debugger().register(manager) return manager
def main(**kwargs): """Client CLI utility""" set_color() user = kwargs.get('username') if user != 'anonymous' and kwargs.get('password') == '': kwargs['password'] = ask_password() log(kwargs, pretty=True) manager = Manager() if kwargs.get('debug'): debugger = Debugger().register(manager) client = IsomerClient(**kwargs).register(manager) manager.run()
def test_tcp_connect_closed_port(Poller, ipv6): ### FIXME: This test is wrong. ### We need to figure out the sequence of events on Windows ### for this scenario. I think if you attempt to connect to ### a shutdown listening socket (tcp server) you should get ### an error event as response. if pytest.PLATFORM == "win32": pytest.skip("Broken on Windows") m = Manager() + Poller() if ipv6: tcp_server = TCP6Server(("::1", 0)) tcp_client = TCP6Client() else: tcp_server = TCPServer(0) tcp_client = TCPClient() server = Server() + tcp_server client = Client() + tcp_client server.register(m) client.register(m) m.start() try: assert pytest.wait_for(client, "ready") assert pytest.wait_for(server, "ready") wait_host(server) host, port = server.host, server.port tcp_server._sock.close() # 1st connect client.fire(connect(host, port)) assert pytest.wait_for(client, "connected") assert isinstance(client.error, SocketError) client.fire(write(b"foo")) assert pytest.wait_for(client, "disconnected") client.disconnected = False client.fire(write(b"foo")) assert pytest.wait_for(client, "disconnected", timeout=1.0) is None finally: m.stop()
def test_addHandler(): m = Manager() m.start() m.addHandler(on_foo) waiter = pytest.WaitEvent(m, "foo") x = m.fire(foo()) waiter.wait() s = x.value assert s == "Hello World!" m.stop()
def main(): config = Config() logger = setup_logging(config) db = setup_database(config, logger) manager = Manager() Worker(channel="threadpool").register(manager) if config["debug"]: Debugger(logger=logger, events=config["verbose"]).register(manager) if config["daemon"]: Daemon(config["pidfile"]).register(manager) Core(config, db).register(manager) manager.run()
def test_unregister(): name = "test_unregister" m = Manager() c = pytest.TestComponent(uniquename=name) c.register(m) assert name in pytest.TestComponent.names c.unregister() assert name not in pytest.TestComponent.names
def test_unix(tmpfile, Poller): m = Manager() + Poller() server = Server() + UNIXServer(tmpfile) client = Client() + UNIXClient() server.register(m) client.register(m) m.start() try: assert pytest.wait_for(server, "ready") assert pytest.wait_for(client, "ready") client.fire(connect(tmpfile)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "disconnected") assert pytest.wait_for(server, "disconnected") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop()
def test_close(Poller, ipv6): m = Manager() + Poller() server = Server() + UDPServer(0) server.register(m) m.start() try: assert pytest.wait_for(server, "ready") wait_host(server) host, port = server.host, server.port server.fire(close()) assert pytest.wait_for(server, "disconnected") server.unregister() def test(obj, attr): return attr not in obj.components assert pytest.wait_for(m, server, value=test) server = Server() + UDPServer((host, port)) server.register(m) assert pytest.wait_for(server, "ready", timeout=30.0) finally: m.stop()
def test_tcp_lookup_failure(Poller, ipv6): m = Manager() + Poller() if ipv6: tcp_client = TCP6Client() else: tcp_client = TCPClient() client = Client() + tcp_client client.register(m) m.start() try: assert pytest.wait_for(client, "ready") client.fire(connect("foo", 1234)) assert pytest.wait_for( client, "error", lambda obj, attr: isinstance(getattr(obj, attr), SocketError)) if pytest.PLATFORM == "win32": assert client.error.errno == 11004 else: assert client.error.errno in (EAI_NODATA, EAI_NONAME,) finally: m.stop()
def test_tcps_basic(Poller, ipv6): from circuits import Debugger m = Manager() + Debugger() + Poller() if ipv6: tcp_server = TCP6Server(("::1", 0), secure=True, certfile=CERT_FILE) tcp_client = TCP6Client() else: tcp_server = TCPServer(0, secure=True, certfile=CERT_FILE) tcp_client = TCPClient() server = Server() + tcp_server client = Client() + tcp_client server.register(m) client.register(m) m.start() try: assert pytest.wait_for(client, "ready") assert pytest.wait_for(server, "ready") wait_host(server) client.fire(connect(server.host, server.port, secure=True)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") assert pytest.wait_for(client, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "disconnected") assert pytest.wait_for(server, "disconnected") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop()
def test_basic(Poller, ipv6): m = Manager() + Poller() if ipv6: udp_server = UDP6Server(("::1", 0)) udp_client = UDP6Client(("::1", 0), channel="client") else: udp_server = UDPServer(0) udp_client = UDPClient(0, channel="client") server = Server() + udp_server client = Client() + udp_client server.register(m) client.register(m) m.start() try: assert pytest.wait_for(server, "ready") assert pytest.wait_for(client, "ready") wait_host(server) client.fire(write((server.host, server.port), b"foo")) assert pytest.wait_for(server, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "closed") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop()
def test_unix(tmpdir, Poller): m = Manager() + Poller() sockpath = tmpdir.ensure("test.sock") filename = str(sockpath) server = Server() + UNIXServer(filename) client = Client() + UNIXClient() server.register(m) client.register(m) m.start() try: assert pytest.wait_for(server, "ready") assert pytest.wait_for(client, "ready") client.fire(connect(filename)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "disconnected") assert pytest.wait_for(server, "disconnected") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop() os.remove(filename)
def test_tcp_basic(Poller, ipv6): m = Manager() + Poller() if ipv6: tcp_server = TCP6Server(("::1", 0)) tcp_client = TCP6Client() else: tcp_server = TCPServer(0) tcp_client = TCPClient() server = Server() + tcp_server client = Client() + tcp_client server.register(m) client.register(m) m.start() try: assert pytest.wait_for(client, "ready") assert pytest.wait_for(server, "ready") wait_host(server) client.fire(connect(server.host, server.port)) assert pytest.wait_for(client, "connected") assert pytest.wait_for(server, "connected") assert pytest.wait_for(client, "data", b"Ready") client.fire(write(b"foo")) assert pytest.wait_for(server, "data", b"foo") assert pytest.wait_for(client, "data", b"foo") client.fire(close()) assert pytest.wait_for(client, "disconnected") assert pytest.wait_for(server, "disconnected") server.fire(close()) assert pytest.wait_for(server, "closed") finally: m.stop()
def main(): setprocname(basename(sys.argv[0])) config = Config() manager = Manager() Worker(channel="workerthreads").register(manager) Worker(channel="workerprocesses").register(manager) if config.get("debug"): Debugger( events=config.get("verbose"), file=config.get("errorlog") ).register(manager) if config.get("daemon"): manager += Daemon(config.get("pidfile")) Core(config).register(manager) manager.run()
def main(): config = Config() logger = setup_logging(config) db = setup_database(config, logger) manager = Manager() Worker(channel="threadpool").register(manager) if config["debug"]: Debugger( logger=logger, events=config["verbose"], ).register(manager) if config["daemon"]: Daemon(config["pidfile"]).register(manager) Core(config, db).register(manager) manager.run()
def test_unregister(): """Test if component cleanly unregisters from namespace""" name = "test_unregister" m = Manager() c = pytest.TestComponent(name) c.register(m) assert name in pytest.TestComponent.names c.unregister() assert name not in pytest.TestComponent.names
def ors_standalone(ctx, api_key, debug, host, port): from circuits import Manager, Debugger from circuits.web import Server set_logfile('/tmp', 'mini') set_verbosity(5) app = Manager() if debug: debugger = Debugger().register(app) ors_controller = RESTORSService(api_key=api_key, no_db=True).register(app) try: server = Server( (host, port), display_banner=False, secure=False, ).register(app) except PermissionError as e: if port <= 1024: log( "Could not open privileged port (%i), check permissions!" % port, e, lvl=critical, ) else: log("Could not open port (%i):" % port, e, lvl=critical) except OSError as e: if e.errno == 98: log("Port (%i) is already opened!" % port, lvl=critical) else: log("Could not open port (%i):" % port, e, lvl=critical) app.run()
def test_tcp_connect_closed_port(Poller, ipv6): if pytest.PLATFORM == "win32": pytest.skip("Broken on Windows") m = Manager() + Poller() + Debugger() if ipv6: tcp_server = TCP6Server(("::1", 0)) tcp_client = TCP6Client(connect_timeout=1) else: tcp_server = TCPServer(0) tcp_client = TCPClient(connect_timeout=1) server = Server() + tcp_server client = Client() + tcp_client server.register(m) client.register(m) m.start() try: assert pytest.wait_for(client, "ready") assert pytest.wait_for(server, "ready") wait_host(server) host, port = server.host, server.port tcp_server._sock.close() # 1st connect client.fire(connect(host, port)) waiter = WaitEvent(m, "unreachable", channel='client') assert waiter.wait() finally: server.unregister() client.unregister() m.stop()
def manager(request): """Component testing manager/fixture""" manager = Manager() def finalizer(): """Stop the testing""" manager.stop() request.addfinalizer(finalizer) waiter = WaitEvent(manager, "started") manager.start() assert waiter.wait() if request.config.option.verbose: verbose = True else: verbose = False Debugger(events=verbose).register(manager) return manager
def manager(request): manager = Manager() watcher = Watcher().register(manager) def finalizer(): manager.stop() request.addfinalizer(finalizer) watcher.wait("started") watcher.unregister() if request.config.option.verbose: Debugger().register(manager) return manager
def test_main(): m = Manager() loader = Loader(paths=[dirname(__file__)]).register(m) m.start() loader.load("app") x = m.fire(test()) assert pytest.wait_for(x, "result") s = x.value assert s == "Hello World!" m.stop()
def test(): m = Manager() poller = Poller().register(m) TCPServer(0).register(m) TCPClient().register(m) m.start() try: pollers = findtype(m, BasePoller, all=True) assert len(pollers) == 1 assert pollers[0] is poller finally: m.stop()