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 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 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 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 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 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 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 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
return request.json
def download_media(url, dest, overwrite=False):
if os.path.exists(dest):
if overwrite:
os.remove(dest)
else:
return
request = Request(url).get()
request.write_to_file(dest)
def download_media(url, dest, overwrite=False):
if os.path.exists(dest):
if overwrite:
os.remove(dest)
else:
return
request = Request(url).get()
request.write_to_file(dest)
def download_media(url, dest, overwrite=False):
logger.debug("Downloading %s to %s", url, dest)
if system.path_exists(dest):
if overwrite:
os.remove(dest)
else:
return
request = Request(url).get()
request.write_to_file(dest)
def download_media(url, dest, overwrite=False):
"""Save a remote media locally"""
if system.path_exists(dest):
if overwrite:
os.remove(dest)
else:
return dest
request = Request(url).get()
request.write_to_file(dest)
return dest
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 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 download_media(url, dest, overwrite=False):
"""Save a remote media locally"""
if system.path_exists(dest):
if overwrite:
os.remove(dest)
else:
return dest
try:
request = Request(url).get()
except HTTPError:
return
request.write_to_file(dest)
return dest
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_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 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 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 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 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_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 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
def get_runner_info(self):
request = Request("{}/api/runners/{}".format(settings.SITE_URL, self.name))
return request.get().json
def do_command_line(self, command_line): # noqa: C901 # pylint: disable=arguments-differ
# pylint: disable=too-many-locals,too-many-return-statements,too-many-branches
# pylint: disable=too-many-statements
# TODO: split into multiple methods to reduce complexity (35)
options = command_line.get_options_dict()
# Use stdout to output logs, only if no command line argument is
# provided
argc = len(sys.argv) - 1
if "-d" in sys.argv or "--debug" in sys.argv:
argc -= 1
if not argc:
# Switch back the log output to stderr (the default in Python)
# to avoid messing with any output from command line options.
# Use when targetting Python 3.7 minimum
# console_handler.setStream(sys.stderr)
# Until then...
logger.removeHandler(log.console_handler)
log.console_handler = logging.StreamHandler(stream=sys.stdout)
log.console_handler.setFormatter(log.SIMPLE_FORMATTER)
logger.addHandler(log.console_handler)
# Set up logger
if options.contains("debug"):
log.console_handler.setFormatter(log.DEBUG_FORMATTER)
logger.setLevel(logging.DEBUG)
# Text only commands
# Print Lutris version and exit
if options.contains("version"):
executable_name = os.path.basename(sys.argv[0])
print(executable_name + "-" + settings.VERSION)
logger.setLevel(logging.NOTSET)
return 0
logger.info("Running Lutris %s", settings.VERSION)
migrate()
run_all_checks()
AsyncCall(init_dxvk_versions, None)
# List game
if options.contains("list-games"):
game_list = pga.get_games()
if options.contains("installed"):
game_list = [game for game in game_list if game["installed"]]
if options.contains("json"):
self.print_game_json(command_line, game_list)
else:
self.print_game_list(command_line, game_list)
return 0
# List Steam games
if options.contains("list-steam-games"):
self.print_steam_list(command_line)
return 0
# List Steam folders
if options.contains("list-steam-folders"):
self.print_steam_folders(command_line)
return 0
# Execute command in Lutris context
if options.contains("exec"):
command = options.lookup_value("exec").get_string()
self.execute_command(command)
return 0
if options.contains("submit-issue"):
IssueReportWindow(application=self)
return 0
try:
url = options.lookup_value(GLib.OPTION_REMAINING)
installer_info = self.get_lutris_action(url)
except ValueError:
self._print(command_line, "%s is not a valid URI" % url.get_strv())
return 1
game_slug = installer_info["game_slug"]
action = installer_info["action"]
revision = installer_info["revision"]
installer_file = None
if options.contains("install"):
installer_file = options.lookup_value("install").get_string()
if installer_file.startswith(("http:", "https:")):
try:
request = Request(installer_file).get()
except HTTPError:
self._print(command_line,
"Failed to download %s" % installer_file)
return 1
try:
headers = dict(request.response_headers)
file_name = headers["Content-Disposition"].split("=",
1)[-1]
except (KeyError, IndexError):
file_name = os.path.basename(installer_file)
file_path = os.path.join(tempfile.gettempdir(), file_name)
self._print(
command_line,
"download %s to %s started" % (installer_file, file_path))
with open(file_path, 'wb') as dest_file:
dest_file.write(request.content)
installer_file = file_path
action = "install"
else:
installer_file = os.path.abspath(installer_file)
action = "install"
if not os.path.isfile(installer_file):
self._print(command_line, "No such file: %s" % installer_file)
return 1
db_game = None
if game_slug:
if action == "rungameid":
# Force db_game to use game id
self.run_in_background = True
db_game = pga.get_game_by_field(game_slug, "id")
elif action == "rungame":
# Force db_game to use game slug
self.run_in_background = True
db_game = pga.get_game_by_field(game_slug, "slug")
elif action == "install":
# Installers can use game or installer slugs
self.run_in_background = True
db_game = pga.get_game_by_field(
game_slug, "slug") or pga.get_game_by_field(
game_slug, "installer_slug")
else:
# Dazed and confused, try anything that might works
db_game = (pga.get_game_by_field(game_slug, "id")
or pga.get_game_by_field(game_slug, "slug") or
pga.get_game_by_field(game_slug, "installer_slug"))
# Graphical commands
self.activate()
self.set_tray_icon()
if not action:
if db_game and db_game["installed"]:
# Game found but no action provided, ask what to do
dlg = InstallOrPlayDialog(db_game["name"])
if not dlg.action_confirmed:
action = None
elif dlg.action == "play":
action = "rungame"
elif dlg.action == "install":
action = "install"
elif game_slug or installer_file:
# No game found, default to install if a game_slug or
# installer_file is provided
action = "install"
if action == "install":
self.show_window(
InstallerWindow,
parent=self.window,
game_slug=game_slug,
installer_file=installer_file,
revision=revision,
)
elif action in ("rungame", "rungameid"):
if not db_game or not db_game["id"]:
logger.warning("No game found in library")
if not self.window.is_visible():
self.do_shutdown()
return 0
self.launch(Game(db_game["id"]))
return 0
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