def make_api_request(self, url):
"""Send a token authenticated request to GOG"""
try:
token = self.load_token()
except AuthenticationError:
return
if self.get_token_age() > 2600:
self.request_token(refresh_token=token["refresh_token"])
token = self.load_token()
if not token:
logger.warning(
"Request to %s cancelled because the GOG token could not be acquired",
url,
)
return
headers = {"Authorization": "Bearer " + token["access_token"]}
request = Request(url, headers=headers, cookies=self.load_cookies())
try:
request.get()
except HTTPError:
logger.error(
"Failed to request %s, check your GOG credentials and internet connectivity",
url,
)
return
request.get()
return request.json
def make_request(self, url):
"""Send a cookie authenticated HTTP request to GOG"""
request = Request(url, cookies=self.load_cookies())
request.get()
if request.content.startswith(b"<"):
raise AuthenticationError("Token expired, please log in again")
return request.json
def request_token(self, url="", refresh_token=""):
"""Get authentication token from GOG"""
if refresh_token:
grant_type = "refresh_token"
extra_params = {"refresh_token": refresh_token}
else:
grant_type = "authorization_code"
parsed_url = urlparse(url)
response_params = dict(parse_qsl(parsed_url.query))
if "code" not in response_params:
logger.error("code not received from GOG")
logger.error(response_params)
return
extra_params = {
"code": response_params["code"],
"redirect_uri": self.redirect_uri,
}
params = {
"client_id": self.client_id,
"client_secret": self.client_secret,
"grant_type": grant_type,
}
params.update(extra_params)
url = "https://auth.gog.com/token?" + urlencode(params)
request = Request(url)
try:
request.get()
except HTTPError:
logger.error("Failed to get token, check your GOG credentials")
return
token = request.json
with open(self.token_path, "w") as token_file:
token_file.write(json.dumps(token))
def request_token(self, url="", refresh_token=""):
"""Get authentication token from GOG"""
if refresh_token:
grant_type = "refresh_token"
extra_params = {"refresh_token": refresh_token}
else:
grant_type = "authorization_code"
parsed_url = urlparse(url)
response_params = dict(parse_qsl(parsed_url.query))
if "code" not in response_params:
logger.error("code not received from GOG")
logger.error(response_params)
return
extra_params = {
"code": response_params["code"],
"redirect_uri": self.redirect_uri,
}
params = {
"client_id": self.client_id,
"client_secret": self.client_secret,
"grant_type": grant_type,
}
params.update(extra_params)
url = "https://auth.gog.com/token?" + urlencode(params)
request = Request(url)
try:
request.get()
except HTTPError as ex:
logger.error("Failed to get token, check your GOG credentials")
return
token = request.json
with open(self.token_path, "w") as token_file:
token_file.write(json.dumps(token))
def make_api_request(self, url):
"""Make an authenticated request to the Humble API"""
request = Request(url, cookies=self.load_cookies())
try:
request.get()
except HTTPError:
logger.error(
"Failed to request %s, check your Humble Bundle credentials and internet connectivity",
url,
)
return
return request.json
def make_api_request(self, url):
"""Send a token authenticated request to GOG"""
try:
token = self.load_token()
except AuthenticationError:
return
if self.get_token_age() > 2600:
self.request_token(refresh_token=token["refresh_token"])
token = self.load_token()
headers = {"Authorization": "Bearer " + token["access_token"]}
request = Request(url, headers=headers, cookies=self.load_cookies())
request.get()
return request.json
def get_runner_info(self, version=None):
runner_api_url = 'https://lutris.net/api/runners/{}'.format(self.name)
request = Request(runner_api_url)
response = request.get()
response_content = response.json
if response_content:
versions = response_content.get('versions') or []
if version:
versions = [
v for v in versions if v['version'] == version
]
versions_for_arch = [
v for v in versions
if v['architecture'] == get_arch_for_api()
]
if len(versions_for_arch) == 1:
return versions_for_arch[0]
elif len(versions_for_arch) > 1:
default_version = [
v for v in versions_for_arch
if v['default'] is True
]
if default_version:
return default_version[0]
elif len(versions) == 1 and system.is_64bit:
return versions[0]
elif len(versions) > 1 and system.is_64bit:
default_version = [
v for v in versions
if v['default'] is True
]
if default_version:
return default_version[0]
def get_runner_info(self, version=None):
runner_api_url = "{}/api/runners/{}".format(settings.SITE_URL, self.name)
logger.info(
"Getting runner information for %s%s",
self.name,
"(version: %s)" % version if version else "",
)
request = Request(runner_api_url)
response = request.get()
response_content = response.json
if response_content:
versions = response_content.get("versions") or []
arch = self.arch
if version:
if version.endswith("-i386") or version.endswith("-x86_64"):
version, arch = version.rsplit("-", 1)
versions = [v for v in versions if v["version"] == version]
versions_for_arch = [v for v in versions if v["architecture"] == arch]
if len(versions_for_arch) == 1:
return versions_for_arch[0]
elif len(versions_for_arch) > 1:
default_version = [v for v in versions_for_arch if v["default"] is True]
if default_version:
return default_version[0]
elif len(versions) == 1 and system.LINUX_SYSTEM.is_64_bit:
return versions[0]
elif len(versions) > 1 and system.LINUX_SYSTEM.is_64_bit:
default_version = [v for v in versions if v["default"] is True]
if default_version:
return default_version[0]
# If we didn't find a proper version yet, return the first available.
if len(versions_for_arch) >= 1:
return versions_for_arch[0]
def fetch_script(game_slug, revision=None):
"""Download install script(s) for matching game_slug."""
if revision:
installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision)
key = None
else:
installer_url = settings.INSTALLER_URL % game_slug
key = 'results'
logger.debug("Fetching installer %s", installer_url)
request = Request(installer_url)
request.get()
response = request.json
if key:
return response[key]
else:
return response
def fetch_script(game_slug, revision=None):
"""Download install script(s) for matching game_slug."""
if revision:
installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision)
key = None
else:
installer_url = settings.INSTALLER_URL % game_slug
key = 'results'
logger.debug("Fetching installer %s", installer_url)
request = Request(installer_url)
request.get()
response = request.json
if key:
return response[key]
else:
return response
def get_runner_info(self, version=None):
runner_api_url = 'https://lutris.net/api/runners/{}'.format(self.name)
request = Request(runner_api_url)
response = request.get()
response_content = response.json
if response_content:
versions = response_content.get('versions') or []
if self.name == 'wine':
arch = 'i386'
else:
arch = self.arch
if version:
if version.endswith('-i386') or version.endswith('-x86_64'):
version, arch = version.rsplit('-', 1)
versions = [v for v in versions if v['version'] == version]
versions_for_arch = [
v for v in versions if v['architecture'] == arch
]
if len(versions_for_arch) == 1:
return versions_for_arch[0]
elif len(versions_for_arch) > 1:
default_version = [
v for v in versions_for_arch if v['default'] is True
]
if default_version:
return default_version[0]
elif len(versions) == 1 and system.is_64bit:
return versions[0]
elif len(versions) > 1 and system.is_64bit:
default_version = [v for v in versions if v['default'] is True]
if default_version:
return default_version[0]
def get_runner_info(self, version=None):
runner_api_url = '{}/api/runners/{}'.format(settings.SITE_URL,
self.name)
logger.info("Getting runner information for %s%s", self.name,
'(version: %s)' % version if version else '')
request = Request(runner_api_url)
response = request.get()
response_content = response.json
if response_content:
versions = response_content.get('versions') or []
logger.debug("Got %s versions", len(versions))
arch = self.arch
if version:
if version.endswith('-i386') or version.endswith('-x86_64'):
version, arch = version.rsplit('-', 1)
versions = [v for v in versions if v['version'] == version]
versions_for_arch = [
v for v in versions if v['architecture'] == arch
]
if len(versions_for_arch) == 1:
return versions_for_arch[0]
elif len(versions_for_arch) > 1:
default_version = [
v for v in versions_for_arch if v['default'] is True
]
if default_version:
return default_version[0]
elif len(versions) == 1 and system.is_64bit:
return versions[0]
elif len(versions) > 1 and system.is_64bit:
default_version = [v for v in versions if v['default'] is True]
if default_version:
return default_version[0]
def fetch_script(game_slug, revision=None):
"""Download install script(s) for matching game_slug."""
if revision:
installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision)
key = None
else:
installer_url = settings.INSTALLER_URL % game_slug
key = "results"
logger.debug("Fetching installer %s", installer_url)
request = Request(installer_url)
request.get()
response = request.json
if response is None:
raise RuntimeError("Couldn't get installer at %s" % installer_url)
if key:
return response[key]
return response
def make_api_request(self, url):
"""Send a token authenticated request to GOG"""
try:
token = self.load_token()
except AuthenticationError:
return
if self.get_token_age() > 2600:
self.request_token(refresh_token=token["refresh_token"])
token = self.load_token()
if not token:
logger.warning(
"Request to %s cancelled because the GOG token could not be acquired", url
)
return
headers = {"Authorization": "Bearer " + token["access_token"]}
request = Request(url, headers=headers, cookies=self.load_cookies())
request.get()
return request.json
def fetch_script(game_slug, revision=None):
"""Download install script(s) for matching game_slug."""
if revision:
installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision)
key = None
else:
installer_url = settings.INSTALLER_URL % game_slug
key = "results"
logger.debug("Fetching installer %s", installer_url)
request = Request(installer_url)
request.get()
response = request.json
if response is None:
raise RuntimeError("Couldn't get installer at %s" % installer_url)
if key:
return response[key]
return response
def get_runner_version(self, version=None):
"""Get the appropriate version for a runner
Params:
version (str): Optional version to lookup, will return this one if found
Returns:
dict: Dict containing version, architecture and url for the runner, None
if the data can't be retrieved.
"""
logger.info(
"Getting runner information for %s%s",
self.name,
" (version: %s)" % version if version else "",
)
try:
request = Request("{}/api/runners/{}".format(
settings.SITE_URL, self.name))
runner_info = request.get().json
if not runner_info:
logger.error("Failed to get runner information")
except HTTPError as ex:
logger.error("Unable to get runner information: %s", ex)
runner_info = None
if not runner_info:
return
versions = runner_info.get("versions") or []
arch = LINUX_SYSTEM.arch
if version:
if version.endswith("-i386") or version.endswith("-x86_64"):
version, arch = version.rsplit("-", 1)
versions = [v for v in versions if v["version"] == version]
versions_for_arch = [v for v in versions if v["architecture"] == arch]
if len(versions_for_arch) == 1:
return versions_for_arch[0]
if len(versions_for_arch) > 1:
default_version = [
v for v in versions_for_arch if v["default"] is True
]
if default_version:
return default_version[0]
elif len(versions) == 1 and LINUX_SYSTEM.is_64_bit:
return versions[0]
elif len(versions) > 1 and LINUX_SYSTEM.is_64_bit:
default_version = [v for v in versions if v["default"] is True]
if default_version:
return default_version[0]
# If we didn't find a proper version yet, return the first available.
if len(versions_for_arch) >= 1:
return versions_for_arch[0]
def fetch_script(game_slug, revision=None):
"""Download install script(s) for matching game_slug."""
if not game_slug:
raise ValueError("No game_slug provided. Can't query an installer")
if revision:
installer_url = settings.INSTALLER_REVISION_URL % (game_slug, revision)
else:
installer_url = settings.INSTALLER_URL % game_slug
logger.debug("Fetching installer %s", installer_url)
request = Request(installer_url)
request.get()
response = request.json
if response is None:
raise RuntimeError("Couldn't get installer at %s" % installer_url)
if not revision:
return response["results"]
# Revision requests return a single installer
return [response]
def get_runner_version(self, version=None):
"""Get the appropriate version for a runner
Params:
version (str): Optional version to lookup, will return this one if found
Returns:
dict: Dict containing version, architecture and url for the runner
"""
logger.info(
"Getting runner information for %s%s",
self.name,
" (version: %s)" % version if version else "",
)
request = Request("{}/api/runners/{}".format(settings.SITE_URL,
self.name))
runner_info = request.get().json
if not runner_info:
logger.error("Failed to get runner information")
return
system_architecture = system.LINUX_SYSTEM.arch
runner_versions = runner_info.get("versions") or []
compatible_runner_versions = list(
filter(
lambda runner_version: bool(
runner_version.get("architecture") == system_architecture),
runner_versions))
logger.debug(compatible_runner_versions)
runner_info_for_provided_version = []
if version:
runner_info_for_provided_version = [
v for v in compatible_runner_versions
if v["version"] == version
]
if len(runner_info_for_provided_version) != 0:
logger.info("Using provided version compatible for architecture")
return runner_info_for_provided_version[0]
if len(compatible_runner_versions) > 0:
logger.info("Using latest version compatible for architecture")
return compatible_runner_versions[len(compatible_runner_versions) -
1]
logger.error(
"The architecture of the system does not match any runner architecture currently provided by Lutris.net"
)
return {}
def get_runner_info(self, version=None):
runner_api_url = 'https://lutris.net/api/runners/{}'.format(self.name)
request = Request(runner_api_url)
response = request.get()
response_content = response.json
if response_content:
versions = response_content.get('versions') or []
if self.name == 'wine':
arch = 'i386'
else:
arch = self.arch
if version:
if version.endswith('-i386') or version.endswith('-x86_64'):
version, arch = version.rsplit('-', 1)
versions = [
v for v in versions if v['version'] == version
]
versions_for_arch = [
v for v in versions
if v['architecture'] == arch
]
if len(versions_for_arch) == 1:
return versions_for_arch[0]
elif len(versions_for_arch) > 1:
default_version = [
v for v in versions_for_arch
if v['default'] is True
]
if default_version:
return default_version[0]
elif len(versions) == 1 and system.is_64bit:
return versions[0]
elif len(versions) > 1 and system.is_64bit:
default_version = [
v for v in versions
if v['default'] is True
]
if default_version:
return default_version[0]
def get_runner_info(self):
request = Request("{}/api/runners/{}".format(settings.SITE_URL,
self.name))
return request.get().json
def make_request(self, url):
"""Send a cookie authenticated HTTP request to GOG"""
request = Request(url, cookies=self.load_cookies())
request.get()
return request.json
def fetch_script(game_ref):
"""Download install script(s) for matching game_ref."""
request = Request(settings.INSTALLER_URL % game_ref)
request.get()
return request.json
def fetch_script(game_ref):
"""Download install script(s) for matching game_ref."""
request = Request(settings.INSTALLER_URL % game_ref)
request.get()
return request.json
def make_request(self, url):
"""Send a cookie authenticated HTTP request to GOG"""
request = Request(url, cookies=self.load_cookies())
request.get()
return request.json
def get_runner_info(self):
request = Request("{}/api/runners/{}".format(settings.SITE_URL, self.name))
return request.get().json