def poll(self, noLongerThan=1.0):
# poll the reactor for up to noLongerThan seconds
base = seconds()
try:
while (seconds() - base) <= noLongerThan:
callback = self.twistedQueue.get_nowait()
callback()
except Empty:
pass
def poll(self, noLongerThan=1.0):
# poll the reactor for up to noLongerThan seconds
base = seconds()
try:
while (seconds() - base) <= noLongerThan:
callback = self.twistedQueue.get_nowait()
callback()
except Empty:
pass
def simulate(self):
"""Run simulation loops and reschedule callbacks.
"""
if self.running:
t = 0.01
start = seconds()
while t > 0:
self.iterate(t)
t = 0.01 - (seconds() - start)
def scheduleAutoDeal(self):
self.cancelDealTimeout()
if self.factory.shutting_down:
self.log.debug("Not autodealing because server is shutting down")
return False
if not self.autodeal:
self.log.debug("No autodeal")
return False
if self.isRunning():
self.log.debug("Not autodealing %d because game is running", self.game.id)
return False
if self.game.state == pokergame.GAME_STATE_MUCK:
self.log.debug("Not autodealing %d because game is in muck state", self.game.id)
return False
if self.game.sitCount() < 2:
self.log.debug("Not autodealing %d because less than 2 players willing to play", self.game.id)
return False
if self.game.isTournament():
if self.tourney:
if self.tourney.state != pokertournament.TOURNAMENT_STATE_RUNNING:
self.log.debug("Not autodealing %d because in tournament state %s", self.game.id, self.tourney.state)
if self.tourney.state == pokertournament.TOURNAMENT_STATE_BREAK_WAIT:
self.broadcastMessage(PacketPokerGameMessage, "Tournament will break when the other tables finish their hand")
return False
elif not self.autodeal_temporary:
#
# Do not auto deal a table where there are only temporary
# users (i.e. bots)
#
only_temporary_users = True
for serial in self.game.serialsSit():
if not self.factory.isTemporaryUser(serial):
only_temporary_users = False
break
if only_temporary_users:
self.log.debug("Not autodealing because players are categorized as temporary")
return False
delay = self.game_delay["delay"]
if not self.allReadyToPlay() and delay > 0:
delta = (self.game_delay["start"] + delay) - seconds()
autodeal_max = float(self.delays.get("autodeal_max", 120))
delta = min(autodeal_max, max(0, delta))
self.game_delay["delay"] = (seconds() - self.game_delay["start"]) + delta
elif self.transient:
delta = int(self.delays.get("autodeal_tournament_min", 15))
if seconds() - self.game_delay["start"] > delta:
delta = 0
else:
delta = 0
self.log.debug("AutodealCheck scheduled in %f seconds", delta)
autodeal_check = max(0.01, float(self.delays.get("autodeal_check", 15)))
self.timer_info["dealTimeout"] = reactor.callLater(min(autodeal_check, delta), self.autoDealCheck, autodeal_check, delta)
return True
def _start(self, duration, *args, **kwargs):
self.stop()
self.duration = duration
self.running = True
self.timer_end = reactor.callLater(self.duration, self.end, *args, **kwargs)
self.start_time = seconds()
self.current_time = seconds()
self.end_time = seconds() + duration
self.start(*args, **kwargs)
if self.verbose > 2:
self.message("_start %d" % duration)
self._run(*args, **kwargs)
def _run(self, *args, **kwargs):
delta = seconds() - self.current_time
self.current_time += delta
self.fraction_from_start = ( self.current_time - self.start_time ) / self.duration
self.fraction_to_end = 1.0 - self.fraction_from_start
self.run(delta, *args, **kwargs)
now = seconds()
next_time = min(self.end_time, now + self.step)
if next_time > self.end_time:
next_time = self.end_time
delay = next_time - now
if delay > 0.0:
self.timer = reactor.callLater(delay, self._run, *args, **kwargs)
else:
self.stop()
def sendPacketData(self, data):
self.log.debug("sendPacketData %s", data)
factory = RestClientFactory(self.host, self.port, self.path, data,
self.timeout)
reactor.connectTCP(self.host, self.port, factory)
self.sentTime = seconds()
return factory.deferred
def sendPacketData(self, data):
if self.verbose > 3:
self.message('sendPacketData ' + data)
factory = RestClientFactory(self.host, self.port, self.path, data, self.timeout)
reactor.connectTCP(self.host, self.port, factory)
self.sentTime = seconds()
return factory.deferred
def reset(self, secondsFromNow):
"""Reschedule this call for a different time
@type secondsFromNow: C{float}
@param secondsFromNow: The number of seconds from the time of the
C{reset} call at which this call will be scheduled.
@raise AlreadyCancelled: Raised if this call has been cancelled.
@raise AlreadyCalled: Raised if this call has already been made.
"""
if self.cancelled:
raise error.AlreadyCancelled
elif self.called:
raise error.AlreadyCalled
else:
if self.seconds is None:
new_time = seconds() + secondsFromNow
else:
new_time = self.seconds() + secondsFromNow
if new_time < self.time:
self.delayed_time = 0
self.time = new_time
self.resetter(self)
else:
self.delayed_time = new_time - self.time
def reset(self, secondsFromNow):
"""Reschedule this call for a different time
@type secondsFromNow: C{float}
@param secondsFromNow: The number of seconds from the time of the
C{reset} call at which this call will be scheduled.
@raise AlreadyCancelled: Raised if this call has been cancelled.
@raise AlreadyCalled: Raised if this call has already been made.
"""
if self.cancelled:
raise error.AlreadyCancelled
elif self.called:
raise error.AlreadyCalled
else:
if self.seconds is None:
new_time = seconds() + secondsFromNow
else:
new_time = self.seconds() + secondsFromNow
if new_time < self.time:
self.delayed_time = 0
self.time = new_time
self.resetter(self)
else:
self.delayed_time = new_time - self.time
def check(self):
"""Periodically called method that does a single uptime check."""
if not self.active:
log.warn(
"ProxyFetchMonitoringProtocol.check() called while active == False"
)
return
# FIXME: Use GET as a workaround for a Twisted bug with HEAD/Content-length
# where it expects a body and throws a PartialDownload failure
url = random.choice(self.URL)
self.checkStartTime = seconds()
self.getPageDeferred = self.getProxyPage(
url,
method='GET',
host=self.server.ip,
port=self.server.port,
status=self.expectedStatus,
timeout=self.toGET,
followRedirect=False,
reactor=self.reactor).addCallbacks(self._fetchSuccessful,
self._fetchFailed).addBoth(
self._checkFinished)
return self.getPageDeferred
def setPlayerDelay(self, game, serial, value):
player = game.getPlayer(serial)
if player == None:
self.message(
"WARNING setPlayerDelay for a non-existing player %d" % serial)
else:
player.getUserData()['delay'] = seconds() + value
def test01_add_message(self):
# new instance of the chat plugin to test
chat_instance = Plugin(self.service, [])
# create a message event request
player_id = 200
sentence = "This is my sentence!"
now = int(runtime.seconds() * 1000)
request = Request(action=['message'], player_id=[player_id], sentence=[sentence])
# verify we have no messages yet
self.assertEquals(len(chat_instance.messages), 0)
# run the request
result = yield chat_instance.preprocess(True, request)
# verify we now have one message
self.assertEquals(len(chat_instance.messages), 1)
# verify the event has been removed from the pipeline
self.assertFalse(request.args.has_key('action'))
# verify the message we added is in the list
self.assertEquals(chat_instance.messages[0]["player_id"], player_id)
self.assertEquals(chat_instance.messages[0]["sentence"], sentence)
# check that the message has been recorded in log file
with open(os.path.join(self.test_logdir, 'chat', '%s.log' % strftime('%Y-%m-%d'))) as f:
lines = f.readlines()
self.assertEquals(len(lines), 1)
self.assertIn(sentence, lines[0])
self.assertIn('player_%d' % player_id, lines[0])
def publishPackets(self):
if not self._poll:
return
delay = 0.01
if len(self.publish_packets) > 0:
#
# If time has not come, make sure we are called at a later time
# to reconsider the situation
#
wait_for = self.publish_time - seconds()
if wait_for > 0:
self.log.debug("publishPacket: %f before next packet is sent",
wait_for)
delay = wait_for
self.block()
else:
self.publishPacket()
if len(self.publish_packets) > 0:
self.block()
else:
self.unblock()
else:
self.unblock()
self.publishPacketTriggerTimer(delay)
def publishPackets(self):
if not self._poll:
return
delay = 0.01
if len(self.publish_packets) > 0:
#
# If time has not come, make sure we are called at a later time
# to reconsider the situation
#
wait_for = self.publish_time - seconds()
if wait_for > 0:
if self.factory.verbose > 2:
self.message("publishPackets: %f before next packet is sent" % wait_for)
delay = wait_for
self.block()
else:
self.publishPacket()
if len(self.publish_packets) > 0:
self.block()
else:
self.unblock()
else:
self.unblock()
self.publishPacketTriggerTimer(delay)
def setPlayerDelay(self, game, serial, value):
player = game.getPlayer(serial)
if player == None:
self.log.warn("setPlayerDelay for a non-existing player %d",
serial)
else:
player.getUserData()['delay'] = seconds() + value
def start(self, interval, now=True):
"""Start running function every interval seconds.
@param interval: The number of seconds between calls. May be
less than one. Precision will depend on the underlying
platform, the available hardware, and the load on the system.
@param now: If True, run this call right now. Otherwise, wait
until the interval has elapsed before beginning.
@return: A Deferred whose callback will be invoked with
C{self} when C{self.stop} is called, or whose errback will be
invoked if the function raises an exception.
"""
assert not self.running, ("Tried to start an already running "
"LoopingCall.")
if interval < 0:
raise ValueError, "interval must be >= 0"
self.running = True
d = self.deferred = defer.Deferred()
self.starttime = seconds()
self.count = 0
self.interval = interval
if now:
self()
else:
self._reschedule()
return d
def testFetchSuccessful(self):
testResult = "Test page result"
self.monitor.checkStartTime = seconds()
with mock.patch.object(self.monitor, '_resultUp') as mock_resultUp:
r = self.monitor._fetchSuccessful(testResult)
mock_resultUp.assert_called_once()
self.assertIs(r, testResult)
def _fetchSuccessful(self, result):
"""Called when getProxyPage is finished successfully."""
self.report('Fetch successful, {0:.3f} s'.format((seconds() - self.checkStartTime)))
self._resultUp()
return result
def testFetchFailed(self):
testMessage = "Testing failed fetches"
testFailure = failure.Failure(defer.TimeoutError(testMessage))
self.monitor.checkStartTime = seconds()
with mock.patch.object(self.monitor, '_resultDown') as mock_resultDown:
self.monitor._fetchFailed(testFailure)
mock_resultDown.assert_called_once()
def processEnded(self, reason):
"""
Called when the process has ended
"""
duration = seconds() - self.checkStartTime
if reason.check(error.ProcessDone):
self._resultUp()
result = 'successful'
exitcode = 0
elif reason.check(error.ProcessTerminated):
self._resultDown(reason.getErrorMessage())
result = 'failed'
exitcode = reason.value.exitCode
else:
result = None
exitcode = None
self.runcommand_metrics['run_duration_seconds'].labels(
result=result, exitcode=exitcode,
**self.metric_labels
).set(duration)
self.runningProcessDeferred.callback(reason.type)
reason.trap(error.ProcessDone, error.ProcessTerminated)
def testCheck(self):
startSeconds = seconds()
self.monitor.active = True
with mock.patch.multiple(self.monitor,
getProxyPage=mock.DEFAULT,
_fetchSuccessful=mock.DEFAULT,
_fetchFailed=mock.DEFAULT,
_checkFinished=mock.DEFAULT) as mocks:
mocks['getProxyPage'].return_value = defer.Deferred()
d = self.monitor.check()
self.assertIsInstance(d, defer.Deferred)
self.assertGreaterEqual(self.monitor.checkStartTime, startSeconds)
# Check getProxyPage keyword arguments
kwargs = mocks['getProxyPage'].call_args[1]
self.assertEqual(kwargs['method'], "GET")
self.assertEqual(kwargs['host'], self.server.ip)
self.assertEqual(kwargs['port'], self.server.port)
self.assertEqual(kwargs['status'], self.monitor.expectedStatus)
self.assertEqual(kwargs['timeout'], self.monitor.toGET)
self.assertFalse(kwargs['followRedirect'])
# Check whether the callback works
testResult = "Test page"
self.monitor.getPageDeferred.callback(testResult)
mocks['_fetchSuccessful'].assert_called_once_with(testResult)
mocks['_fetchFailed'].assert_not_called()
mocks['_checkFinished'].assert_called()
def processEnded(self, reason):
"""
Called when the process has ended
"""
duration = seconds() - self.checkStartTime
if reason.check(error.ProcessDone):
self._resultUp()
result = 'successful'
exitcode = 0
elif reason.check(error.ProcessTerminated):
self._resultDown(reason.getErrorMessage())
result = 'failed'
exitcode = reason.value.exitCode
else:
result = None
exitcode = None
self.runcommand_metrics['run_duration_seconds'].labels(
result=result, exitcode=exitcode,
**self.metric_labels
).set(duration)
# Schedule the next check
if self.active:
self.checkCall = reactor.callLater(self.intvCheck, self.runCommand)
reason.trap(error.ProcessDone, error.ProcessTerminated)
def test01_add_message(self):
# new instance of the chat plugin to test
chat_instance = Plugin(self.service, [])
# create a message event request
player_id = 200
sentence = "This is my sentence!"
now = int(runtime.seconds() * 1000)
request = Request(action=['message'],
player_id=[player_id],
sentence=[sentence])
# verify we have no messages yet
self.assertEquals(len(chat_instance.messages), 0)
# run the request
result = yield chat_instance.preprocess(True, request)
# verify we now have one message
self.assertEquals(len(chat_instance.messages), 1)
# verify the event has been removed from the pipeline
self.assertFalse(request.args.has_key('action'))
# verify the message we added is in the list
self.assertEquals(chat_instance.messages[0]["player_id"], player_id)
self.assertEquals(chat_instance.messages[0]["sentence"], sentence)
# check that the message has been recorded in log file
with open(
os.path.join(self.test_logdir, 'chat',
'%s.log' % strftime('%Y-%m-%d'))) as f:
lines = f.readlines()
self.assertEquals(len(lines), 1)
self.assertIn(sentence, lines[0])
self.assertIn('player_%d' % player_id, lines[0])
def __str__(self):
if self._str is not None:
return self._str
if hasattr(self, 'func'):
if hasattr(self.func, 'func_name'):
func = self.func.func_name
if hasattr(self.func, 'im_class'):
func = self.func.im_class.__name__ + '.' + func
else:
func = reflect.safe_repr(self.func)
else:
func = None
if self.seconds is None:
now = seconds()
else:
now = self.seconds()
L = ["<DelayedCall %s [%ss] called=%s cancelled=%s" % (
id(self), self.time - now, self.called, self.cancelled)]
if func is not None:
L.extend((" ", func, "("))
if self.args:
L.append(", ".join([reflect.safe_repr(e) for e in self.args]))
if self.kw:
L.append(", ")
if self.kw:
L.append(", ".join(['%s=%s' % (k, reflect.safe_repr(v)) for (k, v) in self.kw.iteritems()]))
L.append(")")
if self.debug:
L.append("\n\ntraceback at creation: \n\n%s" % (' '.join(self.creator)))
L.append('>')
return "".join(L)
def test05_check_half_of_multiple_messages(self):
# new instance of the chat plugin to test
chat_instance = Plugin(self.service, [])
# create a message event request
player_ids = [200, 220, 999]
sentences = [
"This is my sentence!", "Yeah another test hello.",
"Ping ping poing pong."
]
when = []
for i in range(3):
sleep(0.1)
when.append(int(runtime.seconds() * 1000))
request = Request(action=['message'],
player_id=[player_ids[i]],
sentence=[sentences[i]])
# run the request
result = yield chat_instance.preprocess(True, request)
# check to make sure no message is returned if we ask for now or later
# we check right back to one second ago to make sure all recently added messages are caught
state, players_id_list = yield chat_instance.state(
{"modified": [when[-1] - 150]})
# this time because of the 100ms delay between messages, and only checking to 150ms ago
# we should only get the last two messages
self.assertEquals(len(state['messages']), 2)
for i in range(2):
self.assertEquals(state['messages'][i]['player_id'],
player_ids[i + 1])
self.assertEquals(state['messages'][i]['sentence'],
sentences[i + 1])
self.assertEquals(players_id_list, player_ids[-2:])
def check(self):
"""Periodically called method that does a single uptime check."""
if not self.active:
log.warn("ProxyFetchMonitoringProtocol.check() called while active == False")
return
# FIXME: Use GET as a workaround for a Twisted bug with HEAD/Content-length
# where it expects a body and throws a PartialDownload failure
url = random.choice(self.URL)
self.checkStartTime = seconds()
self.getPageDeferred = self.getProxyPage(
url,
method='GET',
host=self.server.ip,
port=self.server.port,
status=self.expectedStatus,
timeout=self.toGET,
followRedirect=False
).addCallbacks(
self._fetchSuccessful,
self._fetchFailed
).addBoth(self._checkFinished)
def sendPacketData(self, data):
if self.verbose > 3:
self.message('sendPacketData ' + data)
factory = RestClientFactory(self.host, self.port, self.path, data, self.timeout)
reactor.connectTCP(self.host, self.port, factory)
self.sentTime = seconds()
return factory.deferred
def _queryFailed(self, failure, query):
"""Called when the DNS query finished with a failure."""
queryStr = ", query: %s %s" % (query.name, dns.QUERY_TYPES[query.type])
# Don't act as if the check failed if we cancelled it
if failure.check(defer.CancelledError):
return None
elif failure.check(error.DNSQueryTimeoutError):
errorStr = "DNS query timeout" + queryStr
elif failure.check(error.DNSServerError):
errorStr = "DNS server error" + queryStr
elif failure.check(error.DNSNameError):
errorStr = "%s NXDOMAIN" % query.name
if not self.failOnNXDOMAIN:
self.report(errorStr, level=logging.INFO)
self._resultUp()
return None
elif failure.check(error.DNSQueryRefusedError):
errorStr = "DNS query refused" + queryStr
else:
errorStr = str(failure)
duration = runtime.seconds() - self.checkStartTime
self.report('DNS query failed, %.3f s' % (duration),
level=logging.ERROR)
self._resultDown(errorStr)
self.dnsquery_metrics['request_duration_seconds'].labels(
result='failed', **self.metric_labels).set(duration)
failure.trap(*self.catchList)
def _queryFailed(self, failure, query):
"""Called when the DNS query finished with a failure."""
queryStr = ", query: %s %s" % (query.name, dns.QUERY_TYPES[query.type])
# Don't act as if the check failed if we cancelled it
if failure.check(defer.CancelledError):
return None
elif failure.check(error.DNSQueryTimeoutError):
errorStr = "DNS query timeout" + queryStr
elif failure.check(error.DNSServerError):
errorStr = "DNS server error" + queryStr
elif failure.check(error.DNSNameError):
errorStr = "%s NXDOMAIN" % query.name
if not self.failOnNXDOMAIN:
self.report(errorStr, level=logging.INFO)
self._resultUp()
return None
elif failure.check(error.DNSQueryRefusedError):
errorStr = "DNS query refused" + queryStr
else:
errorStr = str(failure)
self.report(
'DNS query failed, %.3f s' % (runtime.seconds() - self.checkStartTime),
level=logging.ERROR
)
self._resultDown(errorStr)
failure.trap(*self.catchList)
def runUntilCurrent(self):
"""Run all pending timed calls.
"""
if self.threadCallQueue:
# Keep track of how many calls we actually make, as we're
# making them, in case another call is added to the queue
# while we're in this loop.
count = 0
total = len(self.threadCallQueue)
for (f, a, kw) in self.threadCallQueue:
try:
f(*a, **kw)
except:
log.err()
count += 1
if count == total:
break
del self.threadCallQueue[:count]
if self.threadCallQueue:
if self.waker:
self.waker.wakeUp()
# insert new delayed calls now
self._insertNewDelayedCalls()
now = seconds()
while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <=
now):
call = heappop(self._pendingTimedCalls)
if call.cancelled:
self._cancellations -= 1
continue
if call.delayed_time > 0:
call.activate_delay()
heappush(self._pendingTimedCalls, call)
continue
try:
call.called = 1
call.func(*call.args, **call.kw)
except:
log.deferr()
if hasattr(call, "creator"):
e = "\n"
e += " C: previous exception occurred in " + \
"a DelayedCall created here:\n"
e += " C:"
e += "".join(call.creator).rstrip().replace("\n", "\n C:")
e += "\n"
log.msg(e)
if (self._cancellations > 50
and self._cancellations > len(self._pendingTimedCalls) >> 1):
self._cancellations = 0
self._pendingTimedCalls = [
x for x in self._pendingTimedCalls if not x.cancelled
]
heapify(self._pendingTimedCalls)
def runUntilCurrent(self):
"""Run all pending timed calls.
"""
if self.threadCallQueue:
# Keep track of how many calls we actually make, as we're
# making them, in case another call is added to the queue
# while we're in this loop.
count = 0
total = len(self.threadCallQueue)
for (f, a, kw) in self.threadCallQueue:
try:
f(*a, **kw)
except:
log.err()
count += 1
if count == total:
break
del self.threadCallQueue[:count]
if len(self.threadCallQueue) > 0:
if self.waker:
self.waker.wakeUp()
# insert new delayed calls now
self._insertNewDelayedCalls()
now = seconds()
while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <= now):
call = heappop(self._pendingTimedCalls)
if call.cancelled:
self._cancellations-=1
continue
if call.delayed_time > 0:
call.activate_delay()
heappush(self._pendingTimedCalls, call)
continue
try:
call.called = 1
call.func(*call.args, **call.kw)
except:
log.deferr()
if hasattr(call, "creator"):
e = "\n"
e += " C: previous exception occurred in " + \
"a DelayedCall created here:\n"
e += " C:"
e += "".join(call.creator).rstrip().replace("\n","\n C:")
e += "\n"
log.msg(e)
if (self._cancellations > 50 and
self._cancellations > len(self._pendingTimedCalls) >> 1):
self._cancellations = 0
self._pendingTimedCalls = [x for x in self._pendingTimedCalls
if not x.cancelled]
heapify(self._pendingTimedCalls)
def setPlayerTimeout(self, game, packet):
if packet.timeout > 0:
packet.when = int(seconds())
player = game.getPlayer(packet.serial)
player.getUserData()['timeout'] = (packet.when, packet.timeout)
return True
else:
return False
def connectionRefused(self):
"""Called if an ICMP destination unreachable is received"""
self.last_down_timestamp = runtime.seconds()
self._resultDown()
self.report("{} ICMP destination unreachable received".format(
self.__report_prefix()),
level=logging.WARN)
def _fetchFailed(self, failure):
"""Called when getProxyPage finished with a failure."""
self.report('Fetch failed, %.3f s' % (seconds() - self.checkStartTime))
self._resultDown(failure.getErrorMessage())
failure.trap(*self.catchList)
def _fetchSuccessful(self, result):
"""Called when getProxyPage is finished successfully."""
self.report('Fetch successful, %.3f s' %
(seconds() - self.checkStartTime))
self._resultUp()
return result
def runCommand(self):
"""Periodically called method that does a single uptime check."""
self.checkStartTime = seconds()
self.runningProcess = self._spawnProcess(self, self.command, [self.command] + self.arguments,
sessionLeader=True, timeout=(self.timeout or None))
self.runningProcessDeferred = defer.Deferred()
return self.runningProcessDeferred
def timeout(self):
# insert new delayed calls to make sure to include them in timeout value
self._insertNewDelayedCalls()
if not self._pendingTimedCalls:
return None
return max(0, self._pendingTimedCalls[0].time - seconds())
def setPlayerTimeout(self, game, packet):
if packet.timeout > 0:
packet.when = int(seconds())
player = game.getPlayer(packet.serial)
player.getUserData()['timeout'] = ( packet.when, packet.timeout )
return True
else:
return False
def hold(self, delay, id = None):
if delay > 0:
delay = seconds() + delay
if id == None:
for (id, queue) in self._queues.iteritems():
queue.delay = delay
else:
self.getOrCreateQueue(id).delay = delay
def hold(self, delay, id=None):
if delay > 0:
delay = seconds() + delay
if id == None:
for (id, queue) in self._queues.iteritems():
queue.delay = delay
else:
self.getOrCreateQueue(id).delay = delay
def timeout(self):
# insert new delayed calls to make sure to include them in timeout value
self._insertNewDelayedCalls()
if not self._pendingTimedCalls:
return None
return max(0, self._pendingTimedCalls[0].time - seconds())
def canHandlePacket(self, packet):
if not self.factory.isAlwaysHandled(packet) and hasattr(packet, "game_id") and hasattr(packet, "serial"):
delay = self.getPlayerDelay(self.factory.packet2game(packet), packet.serial)
if delay <= seconds():
return ( True, 0 )
else:
return ( False, delay )
else:
return ( True, 0 )
def canHandlePacket(self, packet):
if not self.factory.isAlwaysHandled(packet) and hasattr(packet, "game_id") and hasattr(packet, "serial"):
delay = self.getPlayerDelay(self.factory.packet2game(packet), packet.serial)
if delay <= seconds():
return ( True, 0 )
else:
return ( False, delay )
else:
return ( True, 0 )
def test07_tourneyRegister(self):
"""
Register to a tourney thru a proxy, using an authenticated session
"""
#
# Create tourney
#
db = self.server_service.db
cursor = db.cursor()
cursor.execute(
"INSERT INTO tourneys_schedule SET "
"resthost_serial = %(rh_serial)d, "
"active = 'y', "
"start_time = %(stime)d, "
"description_long = 'no description long', "
"name = 'regularX', "
"variant = 'holem', "
"betting_structure = '1-2_20-200_no-limit', "
"currency_serial = 1" % {
'rh_serial': self.server_service.resthost_serial,
'stime': seconds() + 36000
})
schedule_serial = cursor.lastrowid
self.server_service.updateTourneysSchedule()
cursor.execute(
"SELECT serial FROM tourneys WHERE schedule_serial = %s",
schedule_serial)
tourney_serial = cursor.fetchone()[0]
cursor.close()
self.assertEqual(True,
self.server_service.tourneys.has_key(tourney_serial))
#
# Create user
#
info = self.server_service.auth(PACKET_LOGIN, ('user1', 'password1'),
PacketPokerRoles.PLAY)
serial = info[0][0]
self.proxy_site.memcache.set('auth', str(serial))
#
# Register tourney
#
d = client.getPage(
"http://127.0.0.1:19480/POKER_REST?uid=uid&auth=auth",
postdata=
'{"type":"PacketPokerTourneyRegister","tourney_serial":%d,"serial":%d}'
% (tourney_serial, serial))
def checkTable(result):
packets = Packet.JSON.decode(result)
self.assertEqual('PacketPokerTourneyRegister', packets[0]['type'])
self.assertEqual(tourney_serial, packets[0]['tourney_serial'])
return result
d.addCallback(checkTable)
return d
def touch(self, args):
self.modified = int(runtime.seconds() * 1000)
pollers = self.pollers
self.pollers = []
args['modified'] = [self.modified]
d = defer.DeferredList(pollers)
for poller in pollers:
poller.callback(deepcopy(args))
d.addCallback(lambda result: args)
return d
def longPoll(self):
if self.longPollFrequency > 0:
delta = seconds() - self.sentTime
in_line = len(self.queue.callbacks)
if in_line <= 0 and delta > self.longPollFrequency:
self.clearTimeout()
d = self.sendPacket(PacketPokerLongPoll(),'{ "type": "PacketPokerLongPoll" }')
d.addCallback(self.longPollCallback)
else:
self.scheduleLongPoll(delta)
def longPoll(self):
if self.longPollFrequency > 0:
delta = seconds() - self.sentTime
in_line = len(self.queue.callbacks)
if in_line <= 0 and delta > self.longPollFrequency:
self.clearTimeout()
d = self.sendPacket(PacketPokerLongPoll(),'{ "type": "PacketPokerLongPoll" }')
d.addCallback(self.longPollCallback)
else:
self.scheduleLongPoll(delta)
def callLater(self, _seconds, _f, *args, **kw):
"""See twisted.internet.interfaces.IReactorTime.callLater.
"""
assert callable(_f), "%s is not callable" % _f
assert sys.maxint >= _seconds >= 0, \
"%s is not greater than or equal to 0 seconds" % (_seconds,)
tple = DelayedCall(seconds() + _seconds, _f, args, kw,
self._cancelCallLater, self._moveCallLaterSooner)
self._newTimedCalls.append(tple)
return tple
def beginTurn(self):
self._startLockCheck()
self.cancelDealTimeout()
if self.game.isEndOrNull():
self.historyReset()
hand_serial = self.factory.getHandSerial()
self.log.debug("Dealing hand %s/%d", self.game.name, hand_serial)
self.game.setTime(seconds())
self.game.beginTurn(hand_serial)
for player in self.game.playersAll():
player.getUserData()['ready'] = True
def getDynamicConfig(self, cb):
# Requery the config if we haven't gotten an update in the
# last hour.
stale = ((self.cfg_lastUpdate is None) or
(seconds() - self.cfg_lastUpdate >= 60*5))
stale = True
if cb:
self.cfg_cb = cb
if stale or self.cfg_busy:
self.main.showLoginStatus(
local.dconfig_puller.startText(), counter=0)
# If an update is already in progress, just wait for it.
if self.cfg_busy:
return
# If we've done an update recently, then skip the query
if (not stale) and cb:
self.doCallback()
return
def success_cb(result):
if not result:
# This will trigger the err_cb below.
raise ValueError("Empty Config Reply")
try:
self.handleConfig(result)
self.cfg_lastUpdate = seconds()
self.cfg_busy = False
self.doCallback()
except:
# Don't want errors propagating up the chain.
twisted.python.log.err()
def err_cb(failure):
try:
if cb:
self.main.showLoginStatus(
"Query failed! Trying to proceed without it...")
self.cfg_busy = False
self.doCallback()
except:
# Don't want errors propagating up the chain.
twisted.python.log.err()
# Do Query
self.cfg_busy = True
d = local.dconfig_puller.query()
d.addCallback(success_cb)
d.addErrback(err_cb)
def callLater(self, _seconds, _f, *args, **kw):
"""See twisted.internet.interfaces.IReactorTime.callLater.
"""
assert callable(_f), "%s is not callable" % _f
assert sys.maxint >= _seconds >= 0, \
"%s is not greater than or equal to 0 seconds" % (_seconds,)
tple = DelayedCall(seconds() + _seconds, _f, args, kw,
self._cancelCallLater,
self._moveCallLaterSooner)
self._newTimedCalls.append(tple)
return tple
def _fetchFailed(self, failure):
"""Called when getProxyPage finished with a failure."""
# Don't act as if the check failed if we cancelled it
if failure.check(defer.CancelledError):
return None
self.report('Fetch failed, %.3f s' % (seconds() - self.checkStartTime))
self._resultDown(failure.getErrorMessage())
failure.trap(*self.catchList)
def testProcessEndedProcessTerminated(self):
"""Assert that an unclean (non-zero) exit reports the monitor as down"""
self.monitor.checkStartTime = runtime.seconds()
self.monitor.runningProcessDeferred = twisted.internet.defer.Deferred()
reason = failure.Failure(twisted.internet.error.ProcessTerminated("Process returned error"))
with mock.patch.multiple(self.monitor,
_resultUp=mock.DEFAULT,
_resultDown=mock.DEFAULT) as mocks:
self.monitor.processEnded(reason)
mocks['_resultDown'].assert_called()
mocks['_resultUp'].assert_not_called()
def pushPacket(self, packet):
id = self._packet2id(packet)
if id != None:
packet.time__ = seconds()
front = self._packet2front(packet)
if front and id in self._queues:
packet.nodelay__ = True
self._queues[id].packets.insert(0, packet)
else:
packet.nodelay__ = False
self.getOrCreateQueue(id).packets.append(packet)
self.triggerTimer()
def userCreate(self, name, password):
self.log.inform("creating user %s", name)
cursor = self.db.cursor()
cursor.execute(
"INSERT INTO users (created, name, password) values (%s, %s, %s)",
(seconds(), name, password)
)
serial = cursor.lastrowid
self.log.inform("create user with serial %s", serial)
cursor.execute("INSERT INTO users_private (serial) values (%s)", (serial,))
cursor.close()
return int(serial)
