def character_knife():
"""Start a new knife run for a character."""
if "access_token" in request.args and "state" in request.args:
# verify token/start knife process for character
# do this all out of band, we might be error limited right now
if CACHE.get("authstate.{}".format(request.args["state"])):
CACHE.delete("authstate.{}".format(request.args["state"]))
token = uuid.uuid4()
CACHE.set("new.{}".format(token), request.args["access_token"])
return redirect("/view/{}/".format(token))
# start sso flow
state = uuid.uuid4()
CACHE.set("authstate.{}".format(state), "1", timeout=300)
return redirect(
("https://login.eveonline.com/oauth/authorize?response_type=token"
"&redirect_uri={callback}&client_id={client}"
"&scope={scopes}&state={state}").format(
callback=CALLBACK_URL,
client=CLIENT_ID,
scopes=SCOPES,
state=state,
))
def knife(uuid, token, verify, roles): # pylint: disable=R0914
"""Pull all ESI data for a character_id.
Args:
uuid: string uuid token
token: SSO access token
verify: dictionary return from /verify/
roles: list of corporation roles
"""
character_id = verify["CharacterID"]
LOG.info("knife run started for character: %s", character_id)
scopes = verify["Scopes"]
_, _, public = utils.request_or_wait(
"{}/latest/characters/{}/".format(ESI, character_id)
)
if isinstance(public, str):
CACHE.delete("{}{}".format(Keys.processing.value, uuid))
utils.write_data(uuid, {"public info failure": public})
return
headers = {"Authorization": "Bearer {}".format(token)}
results = get_results(public, character_id, scopes, roles, headers)
utils.write_data(uuid, results)
CACHE.delete("{}{}".format(Keys.processing.value, uuid))
CACHE.cache.inc(Keys.alltime.value, 1)
LOG.info("completed character: %r", character_id)
def process_new():
"""Process all new tokens, verify or we're done early."""
for new_key in utils.list_keys(Keys.new.value):
uuid = new_key.split(".")[-1]
LOG.warning("processing new uuid: %r", uuid)
token = CACHE.get(new_key)
CACHE.delete(new_key)
if not token:
LOG.warning("no token stored for uuid: %r", uuid)
continue
pending_key = "{}{}".format(Keys.pending.value, uuid)
CACHE.set(
pending_key,
"1",
timeout=70,
)
headers = {"Authorization": "Bearer {}".format(token)}
_, res = utils.request_or_wait(
"{}/verify/".format(ESI),
headers=headers,
)
failed = False
if isinstance(res, str) or "CharacterID" not in res:
utils.write_data(uuid, {"auth failure": res})
failed = True
else:
_, roles = utils.request_or_wait(
"{}/latest/characters/{}/roles/".format(
ESI,
res["CharacterID"],
),
headers=headers,
)
if isinstance(roles, str):
utils.write_data(uuid, {"roles failure": roles})
failed = True
CACHE.delete(pending_key)
if not failed:
CACHE.set(
"{}{}".format(Keys.processing.value, uuid),
res["CharacterID"],
timeout=7200,
)
WORKERS.append(
gevent.spawn(knife, uuid, token, res, roles)
)
def knife(uuid, token, verify, roles): # pylint: disable=R0914
"""Pull all ESI data for a character_id.
Args:
uuid: string uuid token
token: SSO access token
verify: dictionary return from /verify/
roles: list of corporation roles
"""
character_id = verify["CharacterID"]
LOG.warning("knife run started for character: %s", character_id)
scopes = verify["Scopes"]
_, public = utils.request_or_wait(
"{}/latest/characters/{}/".format(ESI, character_id)
)
if isinstance(public, str):
CACHE.delete("{}{}".format(Keys.processing.value, uuid))
utils.write_data(uuid, {"public info failure": public})
return
all_params = copy.deepcopy(ADDITIONAL_PARAMS)
known_params = {"character_id": character_id}
if public["corporation_id"] > 2000000:
known_params["corporation_id"] = public["corporation_id"]
else:
all_params.pop("corporation_id")
if "alliance_id" in public:
known_params["alliance_id"] = public["alliance_id"]
spec = utils.refresh_spec()
headers = {"Authorization": "Bearer {}".format(token)}
results = expand_params(
scopes,
roles,
spec,
known_params,
all_params,
headers,
)
urls = build_urls(scopes, roles, spec, known_params, all_params)
with ThreadPoolExecutor(max_workers=20) as pool:
futures = []
for url in urls:
futures.append(pool.submit(
utils.request_or_wait,
url,
headers=headers,
))
for future in as_completed(futures):
url, result = future.result()
results[url] = result
utils.write_data(uuid, results)
CACHE.delete("{}{}".format(Keys.processing.value, uuid))
LOG.warning("completed character: %r", character_id)
