def run(self):
s = socket(AF_INET, SOCK_STREAM)
s.connect(('127.0.0.1', TESTING_PORT))
s = JSONSocket(Socket(s))
s.write(({
'request': 'first-login',
'id_name': self.idname,
'shards': 1
}))
s.settimeout(20)
while not self._terminating:
try:
rd = s.read()
except DataNotAvailable:
s.write({'shards': 1})
continue
except ChannelClosed:
return
# allocation request readed
if self.fail:
s.write({'response': 'recess', 'gugid': rd['gugid']})
else:
s.write({
'response': 'allocated',
'gugid': rd['gugid'],
'tcp-interface': 'a',
'udp-interface': 'b',
'tcp-port': 10,
'udp-port': 20
})
def test_two_lshardmgrs_single_request(self):
"""Tests how to server allocates if there's a request and admittant lshardmgr connected,
and a failing lshardmgr connected.
This test is not deterministic, if it fails try again.
"""
self.LShardmgr('admit', fail=False).start()
self.LShardmgr('faily', fail=True).start()
sleep(0.01)
for x in xrange(0, 20):
s = socket(AF_INET, SOCK_STREAM)
s.connect(('127.0.0.1', TESTING_PORT))
s = JSONSocket(Socket(s))
s.write({
'request': 'allocate-shard',
'gugid': 'trololo',
'bpf_chunk': {
'map_name': 'Indianapolis',
'players': []
}
})
rsp = s.read()
self.assertEquals(rsp['response'], 'allocated')
self.assertEquals(rsp['gugid'], 'trololo')
s.close()
def test_no_lshardmgrs_single_request(self):
"""Tests how to server fails if there's a request and NO lshardmgrs connected"""
s = socket(AF_INET, SOCK_STREAM)
s.connect(('127.0.0.1', TESTING_PORT))
s = JSONSocket(Socket(s))
s.write({
'request': 'allocate-shard',
'gugid': 'trololo',
'bpf_chunk': {
'map_name': 'Indianapolis',
'players': []
}
})
rsp = s.read()
self.assertEquals(rsp['response'], 'recess')
self.assertEquals(rsp['gugid'], 'trololo')
def test_single_lshardmgrs_single_request(self):
"""Tests how to server allocates if there's a request and admittant lshardmgr connected"""
self.LShardmgr('admit', fail=False).start()
sleep(0.01)
s = socket(AF_INET, SOCK_STREAM)
s.connect(('127.0.0.1', TESTING_PORT))
s = JSONSocket(Socket(s))
s.write({
'request': 'allocate-shard',
'gugid': 'trololo',
'bpf_chunk': {
'map_name': 'Indianapolis',
'players': []
}
})
rsp = s.read()
self.assertEquals(rsp['response'], 'allocated')
self.assertEquals(rsp['gugid'], 'trololo')
def run(self):
"""Returns a tuple (IP, address) on success. Returns a string with
error code on failure. Returns with False on silent errors"""
print 'TRStartMatch(%s)' % self.alpha
if self.alpha.invalid:
return False # cannot make a match - it's been invalidated
self.pdb.alphas.remove(
self.alpha) # if alpha is valid then it's in the tables
# Has everybody locked in? If no we need to forcibly lock them in
if not self.alpha.has_everybody_locked_in():
for notlocked in self.alpha.get_those_who_did_not_lock():
# get applicable characters for player
heroes = self.pdb.pdbhelper.get_available_heroes(notlocked)
if len(heroes) == 0: # NO HEROES FOR PLAYER ?!?!?!?!?!?
self._rollback()
return '%s has no heroes to play with'
if TRHeroPick(self.pdb, notlocked,
choice(heroes)).start(slave=True) != None:
self._rollback()
return 'picking hero for %s failed'
# ============= PRECONDITIONS SATISFIED. EVERYBODY ONLINE AND WITH A HERO PICKED
# Sign off all players as entering PS_GAMMA
for pid in self.alpha.team1 + self.alpha.team2:
# sign off players as playing -> GAMMA
pir = self.pdb.ensure(pid)
pir.status = PS_GAMMA
pir.alpha = None
pir.queue = None
# Ok, so let's examine the match...
# Here we begin constructing tables
players = []
for pid in self.alpha.team1 + self.alpha.team2:
team_no = 0 if pid in self.alpha.team1 else 1
pd = {
'login': self.pdb.ensure(pid).login,
'password': self.pdb.pdbhelper.get_password_for_pid(pid),
'character': self.alpha.whom_picked_pid(pid),
'team': team_no
}
players.append(pd)
bpf = {
'players': players,
'map_name': 'Town',
}
# Compute the GUGID
gugid = '.'.join(
map(str, self.alpha.team1) + map(str, self.alpha.team2))
# ALLOCATE THE MATCH!!!
s = socket(AF_INET, SOCK_STREAM)
try:
s.connect(self.pdb.cshardmgr_interface)
except SocketError:
self._rollback()
return 'internal error: no cshard uplink'
s = JSONSocket(Socket(s))
s.settimeout(20)
try:
s.write({
'request': 'allocate-shard',
'gugid': gugid,
'bpf_chunk': bpf
})
rsp = s.read()
except (FatalException, NonfatalException):
self._rollback()
return 'internal error: cshard replica failure'
if 'response' not in rsp:
self._rollback()
return 'internal error: malformed cshard replica'
if rsp['response'] == 'recess':
self._rollback()
return 'shard overload'
conntriple = (rsp['tcp-interface'], rsp['tcp-port'], rsp['udp-port'])
# create BetaGamma object
team1 = dict([(pid, self.alpha.whom_picked_pid(pid))
for pid in self.alpha.team1])
team2 = dict([(pid, self.alpha.whom_picked_pid(pid))
for pid in self.alpha.team2])
bg = BetaGamma(team1, team2, gugid, self.alpha.qname)
self.pdb.betagammas.append(bg)
# Set the target server for players
for pid in self.alpha.team1 + self.alpha.team2:
self.pdb.ensure(pid).conn_triple = conntriple
self.pdb.ensure(pid).betagamma = bg
return conntriple
