def Get(self, map_id, topic_id, user=None, domain=None):
m = model.Map.Get(map_id)
if not m:
logging.severe('No map with id %s' % map_id)
raise base_handler.Error(404, 'No such map.')
self.GetForMap(m.map_root, m.current_version_id, topic_id, None,
domain)
def __init__(self, control):
with open(control['meshFile'], 'rb') as meshfile:
try:
meshData = pickle.load(meshfile)
except EOFError:
logging.severe("Meshfile is empty")
raise
self.nodes = meshData[0]
self.triangles = meshData[1]
self.nNodes = len(self.nodes)
self.nTriangles = len(self.triangles)
self.Dirichlet_functions = control['Dirichlet_functions']
self.Neumann_functions = control['Neumann_functions']
self._Dirichlet_nodes = meshData[
2] #Internal to the element, includes sublists
self.Dirichlet_nodes = [] #Publicly accessible, single vector
for nodes in self._Dirichlet_nodes:
self.Dirichlet_nodes += nodes
self.Neumann_facets = meshData[3]
self.elements = []
for triangle in self.triangles:
corners = (self.nodes[triangle[0]], \
self.nodes[triangle[1]], \
self.nodes[triangle[2]])
self.elements.append(Element(corners, triangle))
def greedy_generate_step(self):
def sorted_dict():
l = [(k, v) for k, v in self.scatter_dict.items()]
return self.sort_scatter_list(l)
def add_penalty(members):
for m in members:
self.scatter_dict[m] += 1
def remove_penalty(members):
for m in members:
self.scatter_dict[m] -= 1
def select_node(r, scatter_list, nodes):
if r == 0:
if tuple(sorted(nodes)) in self.greedy_copysets:
return False
else:
return True
else:
for i in range(self.n):
if scatter_list[i][0] in nodes:
continue
curr_node = scatter_list[i][0]
nodes.append(curr_node)
curr_members = self.get_copysets_member(curr_node)
add_penalty(curr_members)
sig = select_node(r - 1, sorted_dict(), nodes)
remove_penalty(curr_members)
if sig:
return True
else:
nodes.remove(nodes[-1])
logging.severe("no avaliable copyset")
return False
scatter_list = sorted_dict()
# Generate till minimal SW satisfies requirement
while scatter_list[0][1] < self.s:
nodes = []
sig = select_node(self.r, scatter_list, nodes)
if sig == False:
logging.severe("should not happen")
for node in nodes:
members = self.get_copysets_member(node)
sw = len(nodes) - 1
for n in nodes:
if n in members:
sw -= 1
self.scatter_dict[node] += sw
self.greedy_copysets.add(tuple(sorted(nodes)))
scatter_list = sorted_dict()
def Get(self, label, topic_id, user=None, domain=None):
domain = domain or config.Get('primary_domain') or ''
entry = model.CatalogEntry.Get(domain, label)
if not entry:
logging.severe('No map with label %s under domain %s' % (label, domain))
raise base_handler.Error(404, 'No such map.')
self.GetForMap(entry.map_root, entry.map_version_id, topic_id, label,
domain)
def Get(self, label, topic_id, user=None, domain=None):
domain = domain or config.Get('primary_domain') or ''
entry = model.CatalogEntry.Get(domain, label)
if not entry:
logging.severe('No map with label %s under domain %s' %
(label, domain))
raise base_handler.Error(404, 'No such map.')
self.GetForMap(entry.map_root, entry.map_version_id, topic_id, label,
domain)
def run(config):
with contextlib.ExitStack() as stack:
db = stack.enter_context(photonai.db.Session(**config['db']))
# Randomly sample a game to play
bots = db.sample_bots(2)
if len(bots) < 2:
raise NotEnoughBotsError
bot_a, bot_b = bots
bots = [(bot, load_bot(bot, config, stack))
for bot in bots]
map = random.choice(config['maps'])
seed = random.randint(0, 2 ** 31)
logging.debug('Playing %s (v%d) vs %s (v%d) on %s (seed %d)',
bot_a['name'], bot_a['version'],
bot_b['name'], bot_b['version'],
map, seed)
# Play the game
tmp_out = stack.enter_context(tempfile.NamedTemporaryFile())
result = photonai.run.run_game(
bots=bots,
writer=photonai.run.AvroWriter(tmp_out),
seed=seed,
map=map,
time_limit=config['time_limit'],
step_duration=config['step_duration'])
logging.debug('Winner %s', result.winner)
# Save a record
game_id = db.add_game(
bot_a=bot_a['id'],
bot_b=bot_b['id'],
winner=(result.winner and {
bot_a['name']: bot_a['id'],
bot_b['name']: bot_b['id'],
}[result.winner['name']]),
map=map,
seed=seed)
logging.debug('Game %d: winner %s',
game_id, result.winner and result.winner['name'])
# Save the replay
if config['replay_folder'] is not None:
tmp_out.flush()
dest = os.path.join(config['replay_folder'],
'%d.avro' % game_id)
logging.debug('Saving replay to %s', dest)
if os.path.exists(dest):
logging.severe('Replay for game %d already exists!', game_id)
else:
shutil.copyfile(tmp_out.name, dest)
def Get(self, label, user=None, domain=None):
domain = domain or config.Get('primary_domain') or ''
entry = model.CatalogEntry.Get(domain, label)
if not entry:
logging.severe('No map with label %s under domain %s' % (label, domain))
raise base_handler.Error(404, 'No such map.')
topics = entry.map_root.get('topics', [])
if not topics:
logging.severe('Map with label %s has no topics' % label)
raise base_handler.Error(404, 'Map has no topics.')
self.redirect('%s/%s' % (label, str(topics[0]['id'])))
def Get(self, label, user=None, domain=None):
domain = domain or config.Get('primary_domain') or ''
entry = model.CatalogEntry.Get(domain, label)
if not entry:
logging.severe('No map with label %s under domain %s' %
(label, domain))
raise base_handler.Error(404, 'No such map.')
topics = entry.map_root.get('topics', [])
if not topics:
logging.severe('Map with label %s has no topics' % label)
raise base_handler.Error(404, 'Map has no topics.')
self.redirect('%s/%s' % (label, str(topics[0]['id'])))
def select_node(r, scatter_list, nodes):
if r == 0:
if tuple(sorted(nodes)) in self.greedy_copysets:
return False
else:
return True
else:
for i in range(self.n):
if scatter_list[i][0] in nodes:
continue
curr_node = scatter_list[i][0]
nodes.append(curr_node)
curr_members = self.get_copysets_member(curr_node)
add_penalty(curr_members)
sig = select_node(r - 1, sorted_dict(), nodes)
remove_penalty(curr_members)
if sig:
return True
else:
nodes.remove(nodes[-1])
logging.severe("no avaliable copyset")
return False
# -*- coding: utf-8 -*-
import psycopg2
import sys, logging, subprocess
host = sys.argv[1]
port = sys.argv[2]
user = sys.argv[3]
passw = sys.argv[4]
db = sys.argv[5]
username = sys.argv[6]
con = psycopg2.connect(host=host, port=port, user=user, password=passw, dbname=db)
try:
cur = con.cursor()
cur.execute('select password from credentials.user_password where username = %s',(username,))
cur.rowcount <= 0:
logging.severe('no existe ningún usuario : {}'.format(username))
sys.exit(1)
pp = cur.fetchone()
passww = pp['password']
subprocess.call(['passwd',passww], shell=False)
except Exception as e:
logging.exception(e)
finally:
con.close()
def Get(self, map_id, topic_id, user=None, domain=None):
m = model.Map.Get(map_id)
if not m:
logging.severe('No map with id %s' % map_id)
raise base_handler.Error(404, 'No such map.')
self.GetForMap(m.map_root, m.current_version_id, topic_id, None, domain)
