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 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 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 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 __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 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_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_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_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 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 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 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_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 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()
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_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()
