def rrun():
reactor.removeAll()
port = random.randrange(8000, 8100)
print "Listening: %s" % port
resource = File('web')
factory = Site(resource)
reactor.callLater(25, rrun)
reactor.listenTCP(port, factory)
def stop(s, nargs):
s.logger.info("[*] Player %s stopped the server." % s.display_name)
s.factory.send_chat("Stopping..")
s.close("Server have been stopped.")
reactor.removeAll()
reactor.iterate()
reactor.stop()
os._exit(0)
def tearDown(self):
yield self.client.remove('test', CF)
yield self.client.remove('test2', CF)
yield self.client.remove('test', SCF)
yield self.client.remove('test2', SCF)
self.cmanager.shutdown()
for c in reactor.getDelayedCalls():
c.cancel()
reactor.removeAll()
def process(self):
#self.reason = " (" + "".join(self.cmdobj['args_raw'][-1:]) + ")"
#self.osc = self.cmdobj['scope']
#chat(self.osc, "\u00A7o\u00A78[" + self.osc.username + ": Stopping the server" + self.reason + "]\u00A7r", 1)
#for plindex in self.osc.eobj_byid:
# kick(self.osc.eobj_byid[plindex], "\u00A7cThe server was shut down" + self.reason + ".\u00A7r")
#sleep(1)
print("Mineserver (INFO/warn)> The server is shutting down from /stop command signal.")
reactor.removeAll()
reactor.iterate()
reactor.stop()
def stop(self, *args):
"""
Called when the DSLink is going to stop.
Override this if you start any threads you need to stop.
Be sure to call the super function.
:param args: Signal arguments.
"""
if self.wsp is not None:
reactor.callFromThread(self.wsp.sendClose)
reactor.removeAll()
reactor.iterate()
reactor.stop()
def stop(self, *args):
"""
Called when the DSLink is going to stop.
Override this if you start any threads you need to stop.
Be sure to call the super function.
:param args: Signal arguments.
"""
if self.wsp is not None:
reactor.callFromThread(self.wsp.sendClose)
reactor.removeAll()
reactor.iterate()
reactor.stop()
def checkReactor(self, phase, *_):
has_network_selectables = False
for item in reactor.getReaders() + reactor.getWriters():
if isinstance(item, HTTPChannel) or isinstance(item, Client):
has_network_selectables = True
break
if has_network_selectables:
# TODO(Martijn): we wait a while before we continue the check since network selectables
# might take some time to cleanup. I'm not sure what's causing this.
yield deferLater(reactor, 0.2, lambda: None)
# This is the same check as in the _cleanReactor method of Twisted's Trial
selectable_strings = []
for sel in reactor.removeAll():
if interfaces.IProcessTransport.providedBy(sel):
self._logger.error("Sending kill signal to %s", repr(sel))
sel.signalProcess('KILL')
selectable_strings.append(repr(sel))
self.assertFalse(selectable_strings,
"The reactor has leftover readers/writers during %s: %r" % (phase, selectable_strings))
# Check whether we have closed all the sockets
open_readers = reactor.getReaders()
for reader in open_readers:
self.assertNotIsInstance(reader, BasePort)
# Check whether the threadpool is clean
tp_items = len(reactor.getThreadPool().working)
if tp_items > 0: # Print all stacks to debug this issue
self.watchdog.print_all_stacks()
self.assertEqual(tp_items, 0, "Still items left in the threadpool")
def cleanReactor(cls):
"""
Remove all delayed calls, readers and writers from the reactor.
"""
if not reactor:
return
try:
reactor.removeAll()
except (RuntimeError, KeyError):
# FIXME:863:
# When running threads the reactor is cleaned from multiple places
# and removeAll will fail since it detects that internal state
# is changed from other source.
pass
reactor.threadCallQueue = []
for delayed_call in reactor.getDelayedCalls():
if delayed_call.active():
delayed_call.cancel()
def _cleanSelectables(self):
"""Remove all selectables and return their string representation.
Kill any of them that were processes.
"""
for sel in reactor.removeAll():
if interfaces.IProcessTransport.providedBy(sel):
sel.signalProcess("KILL")
yield sel
def _cleanReactor(self):
"""
Remove all selectables from the reactor, kill any of them that were
processes, and return their string representation.
"""
reactor = self._getReactor()
selectableStrings = []
for sel in reactor.removeAll():
if interfaces.IProcessTransport.providedBy(sel):
sel.signalProcess('KILL')
selectableStrings.append(repr(sel))
return selectableStrings
def do_cleanReactor(cls):
s = []
from twisted.internet import reactor
removedSelectables = reactor.removeAll()
if removedSelectables:
s.append(DIRTY_REACTOR_MSG)
for sel in removedSelectables:
if interfaces.IProcessTransport.providedBy(sel):
sel.signalProcess('KILL')
s.append(repr(sel))
if s:
raise DirtyReactorError(' '.join(s))
def do_cleanReactor(cls):
s = []
from twisted.internet import reactor
removedSelectables = reactor.removeAll()
if removedSelectables:
s.append(DIRTY_REACTOR_MSG)
for sel in removedSelectables:
if interfaces.IProcessTransport.providedBy(sel):
sel.signalProcess('KILL')
s.append(repr(sel))
if s:
raise DirtyReactorError(' '.join(s))
def cleanup_reactor(force=False):
log.debug('comptest', 'running cleanup_reactor...')
delayed = reactor.getDelayedCalls()
for dc in delayed:
dc.cancel()
# the rest is taken from twisted trial...
sels = reactor.removeAll()
if sels:
log.info('comptest',
'leftover selectables...: %r %r' % (sels, reactor.waker))
for sel in sels:
if interfaces.IProcessTransport.providedBy(sel):
sel.signalProcess('KILL')
def cleanup_reactor(force=False):
log.debug('comptest', 'running cleanup_reactor...')
delayed = reactor.getDelayedCalls()
for dc in delayed:
dc.cancel()
# the rest is taken from twisted trial...
sels = reactor.removeAll()
if sels:
log.info('comptest', 'leftover selectables...: %r %r' %
(sels, reactor.waker))
for sel in sels:
if interfaces.IProcessTransport.providedBy(sel):
sel.signalProcess('KILL')
def command(player, command, args):
if command == 'stop':
player.kick_all('Server stopped')
plugin.log(player.username + ' has stopped server')
time.sleep(1)
from twisted.internet import reactor
reactor.removeAll()
reactor.iterate()
reactor.stop()
if command == 'tp':
if len(args) == 3:
x, y, z = args[0], args[1], args[2]
player.set_position(x, y, z)
player.send_chat('Teleported to X:%s Y:%s Z:%s' %
(str(x), str(y), str(z)))
else:
player.send_chat('Need 3 args: x,y,z')
if command == 'item' or command == 'give':
if len(args) == 3:
id, count, slot = int(args[0]), int(args[1]), int(args[2])
player.send_set_slot(id, count, slot)
else:
player.send_chat('3 args need')
if command == 'help':
player.send_chat(
'/tp [x, y, z]\n/stop\n/title line1 line2 2\n/give id count slot')
if command == 'title':
if len(args) == 3:
player.send_title(args[0], args[1], 25, int(args[2]) * 25, 25)
else:
player.send_chat('3 args need')
if command == 'brodcast' or command == 'bc':
if len(args) == 0:
player.send_chat('Enter your message')
else:
player.send_chat_all(''.join(args))
def handler(player, command, args):
if command == "stop":
player.send_chat("Server stopping... You will be kicked in two seconds")
time.sleep(2)
plugin.log(player.nickname + " has stopped the server!")
from twisted.internet import reactor # Import reactor and call stop methods
reactor.removeAll()
reactor.iterate()
reactor.stop()
if command == "tppos":
# If command called with 3 arguments
if len(args) == 3:
# Set player position
try:
x, y, z = [float(arg) for arg in args] # Convert strings to floats
player.set_position(x, y, z)
player.send_chat("Teleported to X:{0} Y:{1} Z:{2} successfully".format(x, y, z))
except ValueError: # If we can't convert it
player.send_chat("You need to supply numbers!")
else:
player.send_chat("tppos takes 3 arguments: x,y,z")
if command == "help":
# TODO: Make something useful here
player.send_chat("There's nothing here, sorry :(")
def checkReactor(self, phase, *_):
delayed_calls = reactor.getDelayedCalls()
if delayed_calls:
self._logger.error("The reactor was dirty during %s:", phase)
for dc in delayed_calls:
self._logger.error("> %s", dc)
dc.cancel()
from pony.orm.core import local
if local.db_context_counter > 0:
self._logger.error("Leftover pony db sessions found!")
from pony.orm import db_session
for _ in range(local.db_context_counter):
db_session.__exit__()
has_network_selectables = False
for item in reactor.getReaders() + reactor.getWriters():
if isinstance(item, HTTPChannel) or isinstance(item, Client):
has_network_selectables = True
break
if has_network_selectables:
# TODO(Martijn): we wait a while before we continue the check since network selectables
# might take some time to cleanup. I'm not sure what's causing this.
yield deferLater(reactor, 0.2, lambda: None)
# This is the same check as in the _cleanReactor method of Twisted's Trial
selectable_strings = []
for sel in reactor.removeAll():
if interfaces.IProcessTransport.providedBy(sel):
self._logger.error("Sending kill signal to %s", repr(sel))
sel.signalProcess('KILL')
selectable_strings.append(repr(sel))
self.assertFalse(selectable_strings,
"The reactor has leftover readers/writers during %s: %r" % (phase, selectable_strings))
# Check whether we have closed all the sockets
open_readers = reactor.getReaders()
for reader in open_readers:
self.assertNotIsInstance(reader, BasePort)
# Check whether the threadpool is clean
tp_items = len(reactor.getThreadPool().working)
if tp_items > 0: # Print all stacks to debug this issue
self.watchdog.print_all_stacks()
self.assertEqual(tp_items, 0, "Still items left in the threadpool")
def clean_reactor():
reactor.removeAll()
def signal_handler(signal, frame):
print 'Terminating...'
reactor.removeAll()
reactor.stop()
def _done(self):
print 'in _done'
os.system('killall -9 node')
reactor.removeAll()
reactor.stop()
def tearDown(self):
"""Cleanup method after each ``test_*`` method runs; removes all
selectable readers and writers from the reactor.
"""
reactor.removeAll()
def tearDown(self):
yield self.client.system_drop_keyspace(self.my_keyspace.name)
self.cmanager.shutdown()
for c in reactor.getDelayedCalls():
c.cancel()
reactor.removeAll()
def _cleanSelectables(self):
reactor.removeAll()
def main():
reactor.disconnectAll()
log.warning("Ethereum Stratum proxy version: %s" % version.VERSION)
# Connect to Stratum pool, main monitoring connection
log.warning("Trying to connect to Stratum pool at %s:%d" % (mainpool, mainport))
f = SocketTransportClientFactory(mainpool, mainport,
debug=settings.DEBUG, proxy=None,
event_handler=client_service.ClientMiningService)
f1 = None
f2 = None
f3 = None
if settings.POOL_FAILOVER_ENABLE:
if not (backuppool1 is None):
log.warning("Trying to connect to failover Stratum pool-1 at %s:%d" % (backuppool1, backupport1))
f1 = SocketTransportClientFactory(backuppool1, backupport1,
debug=settings.DEBUG, proxy=None,
event_handler=client_service.ClientMiningService)
f1.is_failover = True
if not (backuppool2 is None):
log.warning("Trying to connect to failover Stratum pool-2 at %s:%d" % (backuppool2, backupport2))
f2 = SocketTransportClientFactory(backuppool2, backupport2,
debug=settings.DEBUG, proxy=None,
event_handler=client_service.ClientMiningService)
f2.is_failover = True
if not (backuppool3 is None):
log.warning("Trying to connect to failover Stratum pool-3 at %s:%d" % (backuppool3, backupport3))
f3 = SocketTransportClientFactory(backuppool3, backupport3,
debug=settings.DEBUG, proxy=None,
event_handler=client_service.ClientMiningService)
f3.is_failover = True
job_registry = jobs.JobRegistry(f,f1,f2,f3)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
f.on_connect.addCallback(on_connect)
f.on_disconnect.addCallback(on_disconnect)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
if f1:
f1.on_connect.addCallback(on_connect)
f1.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f1)
if f2:
f2.on_connect.addCallback(on_connect)
f2.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f2)
if f3:
f3.on_connect.addCallback(on_connect)
f3.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f3)
# Block until proxy connect to the pool
try:
yield f.on_connect
except TransportException:
log.error("First pool server must be online during proxy startup. Dying Gracefully.")
reactor.stop()
reactor.removeAll()
return
if len(proxywallet)!=42 and len(proxywallet)!=40:
conn = reactor.listenTCP(settings.PORT, Site(getwork_listener.Root(job_registry, False)), interface=settings.HOST)
else:
conn = reactor.listenTCP(settings.PORT, Site(getwork_listener.Root(job_registry, settings.ENABLE_WORKER_ID)), interface=settings.HOST)
try:
conn.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) # Enable keepalive packets
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 60) # Seconds before sending keepalive probes
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPINTVL, 1) # Interval in seconds between keepalive probes
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPCNT, 5) # Failed keepalive probles before declaring other end dead
except:
pass # Some socket features are not available on all platforms (you can guess which one)
log.warning("-----------------------------------------------------------------------")
if settings.HOST == '0.0.0.0':
log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d" % settings.PORT)
else:
log.warning("LISTENING FOR MINERS ON http://%s:%d" % (settings.HOST, settings.PORT))
log.warning("-----------------------------------------------------------------------")
log.warning("Wallet: %s" % proxywallet)
if len(proxywallet)!=42 and len(proxywallet)!=40:
log.warning("Wallet is not 40/42 Characters in Length, WORKER ID DISABLED")
log.warning("OK if using non-eth address based pool authentication")
log.warning("Otherwise - BAD ETH WALLET")
else:
log.warning("Worker ID enabled: %s" % settings.ENABLE_WORKER_ID)
if settings.MONITORING:
log.warning("Email monitoring on %s" % settings.MONITORING_EMAIL)
else:
log.warning("Email monitoring disabled")
log.warning("Failover enabled: %s" % settings.POOL_FAILOVER_ENABLE)
log.warning("-----------------------------------------------------------------------")
def rrun(servers):
print "\n\nRestaring listeners."
reactor.removeAll()
for server in servers:
server.spinUp()
reactor.callLater(20, rrun, servers)
def handle_signal(signal, frame):
print('SIGINT received, stop')
reactor.removeAll()
reactor.stop()
def _done(self):
print 'in _done'
os.system('killall -9 node')
reactor.removeAll()
reactor.stop()
def tearDown(self):
del self.channel_layer
reactor.removeAll()
super(TwistedTests, self).tearDown()
def tearDown(self):
reactor.removeAll()
super(RabbitmqChannelLayerTwistedTest, self).tearDown()
def tearDown(self):
del self.channel_layer
reactor.removeAll()
super(TwistedTests, self).tearDown()
def tearDown(self):
os.environ.pop("SENTRY_DSN", None)
reactor.removeAll()
def tearDown(self):
reactor.removeAll()
return self.port.stopListening()
def main():
reactor.disconnectAll()
log.warning("Ethereum Stratum proxy version: %s" % version.VERSION)
# Connect to Stratum pool, main monitoring connection
log.warning("Trying to connect to Stratum pool at %s:%d" %
(mainpool, mainport))
f = SocketTransportClientFactory(
mainpool,
mainport,
debug=settings.DEBUG,
proxy=None,
event_handler=client_service.ClientMiningService)
f1 = None
f2 = None
f3 = None
if settings.POOL_FAILOVER_ENABLE:
if not (backuppool1 is None):
log.warning(
"Trying to connect to failover Stratum pool-1 at %s:%d" %
(backuppool1, backupport1))
f1 = SocketTransportClientFactory(
backuppool1,
backupport1,
debug=settings.DEBUG,
proxy=None,
event_handler=client_service.ClientMiningService)
f1.is_failover = True
if not (backuppool2 is None):
log.warning(
"Trying to connect to failover Stratum pool-2 at %s:%d" %
(backuppool2, backupport2))
f2 = SocketTransportClientFactory(
backuppool2,
backupport2,
debug=settings.DEBUG,
proxy=None,
event_handler=client_service.ClientMiningService)
f2.is_failover = True
if not (backuppool3 is None):
log.warning(
"Trying to connect to failover Stratum pool-3 at %s:%d" %
(backuppool3, backupport3))
f3 = SocketTransportClientFactory(
backuppool3,
backupport3,
debug=settings.DEBUG,
proxy=None,
event_handler=client_service.ClientMiningService)
f3.is_failover = True
job_registry = jobs.JobRegistry(f, f1, f2, f3)
client_service.ClientMiningService.job_registry = job_registry
client_service.ClientMiningService.reset_timeout()
f.on_connect.addCallback(on_connect)
f.on_disconnect.addCallback(on_disconnect)
# Cleanup properly on shutdown
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f)
if f1:
f1.on_connect.addCallback(on_connect)
f1.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f1)
if f2:
f2.on_connect.addCallback(on_connect)
f2.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f2)
if f3:
f3.on_connect.addCallback(on_connect)
f3.on_disconnect.addCallback(on_disconnect)
reactor.addSystemEventTrigger('before', 'shutdown', on_shutdown, f3)
# Block until proxy connect to the pool
try:
yield f.on_connect
except TransportException:
log.error(
"First pool server must be online during proxy startup. Dying Gracefully."
)
reactor.stop()
reactor.removeAll()
return
if len(proxywallet) != 42 and len(proxywallet) != 40:
conn = reactor.listenTCP(
settings.PORT,
Site(getwork_listener.Root(job_registry, False)),
interface=settings.HOST)
else:
conn = reactor.listenTCP(
settings.PORT,
Site(getwork_listener.Root(job_registry,
settings.ENABLE_WORKER_ID)),
interface=settings.HOST)
try:
conn.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE,
1) # Enable keepalive packets
conn.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE,
60) # Seconds before sending keepalive probes
conn.socket.setsockopt(
socket.SOL_TCP, socket.TCP_KEEPINTVL,
1) # Interval in seconds between keepalive probes
conn.socket.setsockopt(
socket.SOL_TCP, socket.TCP_KEEPCNT,
5) # Failed keepalive probles before declaring other end dead
except:
pass # Some socket features are not available on all platforms (you can guess which one)
log.warning(
"-----------------------------------------------------------------------"
)
if settings.HOST == '0.0.0.0':
log.warning("PROXY IS LISTENING ON ALL IPs ON PORT %d" % settings.PORT)
else:
log.warning("LISTENING FOR MINERS ON http://%s:%d" %
(settings.HOST, settings.PORT))
log.warning(
"-----------------------------------------------------------------------"
)
log.warning("Wallet: %s" % proxywallet)
if len(proxywallet) != 42 and len(proxywallet) != 40:
log.warning(
"Wallet is not 40/42 Characters in Length, WORKER ID DISABLED")
log.warning("OK if using non-eth address based pool authentication")
log.warning("Otherwise - BAD ETH WALLET")
else:
log.warning("Worker ID enabled: %s" % settings.ENABLE_WORKER_ID)
if settings.MONITORING:
log.warning("Email monitoring on %s" % settings.MONITORING_EMAIL)
else:
log.warning("Email monitoring disabled")
log.warning("Failover enabled: %s" % settings.POOL_FAILOVER_ENABLE)
log.warning(
"-----------------------------------------------------------------------"
)
def tearDown(self):
"""Cleanup method after each ``test_*`` method runs; removes all
selectable readers and writers from the reactor.
"""
reactor.removeAll()
def ctrl_c_handler(signum, *args):
reactor.removeAll()
reactor.iterate()
reactor.stop()
return
def command_stop(self, ctx, *args):
ctx.server.logger.info("Server close by " + ctx.player.display_name)
reactor.removeAll()
reactor.iterate()
reactor.stop()
def tearDown(self):
reactor.removeAll()
deferredResult(self.server.stopListening())
def signal_handler(signal, frame):
print 'You pressed Ctrl+C!'
reactor.removeAll()
reactor.iterate()
reactor.stop()
def rrun(factory):
reactor.removeAll()
port = random.randrange(500, 599)
print "Listening @ %s" % port
reactor.listenTCP(port, factory)
reactor.callLater(10, rrun, factory)
def stop_server():
reactor.removeAll()
def tearDown(self):
yield self.client.system_drop_keyspace(self.my_keyspace.name)
self.cmanager.shutdown()
for c in reactor.getDelayedCalls():
c.cancel()
reactor.removeAll()
def exit():
reactor.removeAll()
reactor.iterate()
reactor.stop()
def stop(self):
self.alive = 0
reactor.removeAll()
reactor.iterate()
reactor.stop()
def _cleanSelectables(self):
reactor.removeAll()
def stop(self):
reactor.removeAll()
reactor.stop()
self._running = False
