Bump aiohttp from 3.5.4 to 3.7.4

Bumps [aiohttp](https://github.com/aio-libs/aiohttp) from 3.5.4 to 3.7.4.
- [Release notes](https://github.com/aio-libs/aiohttp/releases)
- [Changelog](https://github.com/aio-libs/aiohttp/blob/master/CHANGES.rst)
- [Commits](https://github.com/aio-libs/aiohttp/compare/v3.5.4...v3.7.4)

Signed-off-by: dependabot[bot] <support@github.com>

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: true
+contact_links:
+  - name: GOG GALAXY 2.0 issue
+    url: https://mantis2.gog.com/
+    about: Report issues related to GOG GALAXY 2.0, official integrations or the whole ecosystem
+  - name: Platform ID request
+    url: https://github.com/gogcom/galaxy-integrations-python-api/issues/160
+    about: Report missing platform id
+  - name: Community integrations
+    url: https://github.com/Mixaill/awesome-gog-galaxy
+    about: Find integrations and their maintainers, request new integrations or report issues related to unofficial integrations.

.github/ISSUE_TEMPLATE/problem_report.md

@@ -0,0 +1,14 @@
+---
+name: API issue
+about: Report a bug or problem with current API architecture
+
+---
+
+**Problem**
+<!-- Describe the problem you faced. -->
+
+**Solution**
+<!-- Describe the solution you'd like. -->
+
+**Alternatives**
+<!-- Optionally describe possible alternatives or current workarounds if any. -->

.gitignore

@@ -8,3 +8,4 @@ Pipfile
 .idea
 docs/source/_build
 .mypy_cache
+.pytest_cache

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: registry-gitlab.gog.com/galaxy-client/gitlab-ci-tools:latest
+image: registry-gitlab.gog.com/docker/python:3.7.3
 
 stages:
   - test
@@ -7,7 +7,7 @@ stages:
 test_package:
   stage: test
   script:
-    - pip install -r requirements.txt
+    - pip install -r requirements-dev.txt
     - pytest
   except:
     - tags

PLATFORM_IDs.md

@@ -4,10 +4,10 @@ Platform ID list for GOG Galaxy 2.0 Integrations
 
 | ID | Name |
 | --- | --- |
+| test | Testing purposes |
 | steam	| Steam |
 | psn	| PlayStation Network |
 | xboxone	| Xbox Live |
-| generic	| Manually added games |
 | origin	| Origin |
 | uplay	| Uplay |
 | battlenet	| Battle.net |
@@ -80,3 +80,12 @@ Platform ID list for GOG Galaxy 2.0 Integrations
 | nds	| Nintendo DS |
 | 3ds	| Nintendo 3DS |
 | pathofexile | Path of Exile |
+| twitch | Twitch |
+| minecraft | Minecraft |
+| gamesessions | GameSessions |
+| nuuvem | Nuuvem |
+| fxstore | FX Store |
+| indiegala | IndieGala |
+| playfire | Playfire |
+| oculus | Oculus |
+| rockstar | Rockstar |

README.md

@@ -36,20 +36,31 @@ Communication between an integration and the client is also possible with the us
 import sys
 from galaxy.api.plugin import Plugin, create_and_run_plugin
 from galaxy.api.consts import Platform
+from galaxy.api.types import Authentication, Game, LicenseInfo, LicenseType
+
 
 class PluginExample(Plugin):
     def __init__(self, reader, writer, token):
         super().__init__(
-            Platform.Generic, # Choose platform from available list
-            "0.1", # Version
+            Platform.Test,  # choose platform from available list
+            "0.1",  # version
             reader,
             writer,
             token
         )
 
     # implement methods
+
+    # required
     async def authenticate(self, stored_credentials=None):
-        pass
+        return Authentication('test_user_id', 'Test User Name')
+
+    # required
+    async def get_owned_games(self):
+        return [
+            Game('test', 'The Test', None, LicenseInfo(LicenseType.SinglePurchase))
+        ]
+
 
 def main():
     create_and_run_plugin(PluginExample, sys.argv)
@@ -76,6 +87,20 @@ In order to be found by GOG Galaxy 2.0 an integration folder should be placed in
 
     `~/Library/Application Support/GOG.com/Galaxy/plugins/installed`
 
+### Logging
+<a href='https://docs.python.org/3.7/howto/logging.html'>Root logger</a> is already setup by GOG Galaxy to store rotated log files in:
+
+- Windows:
+
+    `%programdata%\GOG.com\Galaxy\logs`
+
+- macOS:
+
+    `/Users/Shared/GOG.com/Galaxy/Logs`
+
+Plugin logs are kept in `plugin-<platform>-<guid>.log`.
+When debugging, inspecting the other side of communication in the `GalaxyClient.log` can be helpful as well.
+
 ### Manifest
 
 <a name="deploy-manifest"></a>
@@ -84,8 +109,8 @@ Obligatory JSON file to be placed in an integration folder.
 ```json
 {
     "name": "Example plugin",
-    "platform": "generic",
-    "guid": "UNIQUE-GUID",
+    "platform": "test",
+    "guid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
     "version": "0.1",
     "description": "Example plugin",
     "author": "Name",
@@ -97,9 +122,8 @@ Obligatory JSON file to be placed in an integration folder.
 
 | property      | description |
 |---------------|---|
-| `guid`        |   |
-| `description` |   |
-| `url`         |   |
+| `guid`        | custom Globally Unique Identifier |
+| `version`     | the same string as `version` in `Plugin` constructor |
 | `script`      | path of the entry point module, relative to the integration folder |
 
 ### Dependencies

requirements-dev.txt

@@ -0,0 +1,7 @@
+-r requirements.txt
+pytest==5.2.2
+pytest-asyncio==0.10.0
+pytest-mock==1.10.3
+pytest-mypy==0.4.1
+pytest-flakes==4.0.0
+types-certifi==2020.4.0

requirements.txt

@@ -1,10 +1,7 @@
 -e .
-pytest==5.2.2
-pytest-asyncio==0.10.0
-pytest-mock==1.10.3
-pytest-mypy==0.4.1
-pytest-flakes==4.0.0
-# because of pip bug https://github.com/pypa/pip/issues/4780
-aiohttp==3.5.4
+# Copied from setup.py because of a pip bug
+#   see https://github.com/pypa/pip/issues/4780
+aiohttp==3.7.4
 certifi==2019.3.9
-psutil==5.6.3; sys_platform == 'darwin'
+psutil==5.6.6; sys_platform == 'darwin'
+# End of copy from setup.py

setup.py

@@ -2,14 +2,15 @@ from setuptools import setup, find_packages
 
 setup(
     name="galaxy.plugin.api",
-    version="0.58",
+    version="0.68",
     description="GOG Galaxy Integrations Python API",
     author='Galaxy team',
     author_email='galaxy@gog.com',
     packages=find_packages("src"),
     package_dir={'': 'src'},
     install_requires=[
-        "aiohttp==3.5.4",
-        "certifi==2019.3.9"
+        "aiohttp>=3.5.4",
+        "certifi>=2019.3.9",
+        "psutil>=5.6.6; sys_platform == 'darwin'"
     ]
 )

src/galaxy/__init__.py

@@ -1 +1,6 @@
-__path__: str = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore
+import logging
+
+
+logging.getLogger(__name__).setLevel(logging.INFO)
+
+__path__: str = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore

src/galaxy/api/consts.py

@@ -114,6 +114,9 @@ class Feature(Enum):
     ImportGameLibrarySettings = "ImportGameLibrarySettings"
     ImportOSCompatibility = "ImportOSCompatibility"
     ImportUserPresence = "ImportUserPresence"
+    ImportLocalSize = "ImportLocalSize"
+    ImportSubscriptions = "ImportSubscriptions"
+    ImportSubscriptionGames = "ImportSubscriptionGames"
 
 
 class LicenseType(Enum):
@@ -149,3 +152,13 @@ class PresenceState(Enum):
     Online = "online"
     Offline = "offline"
     Away = "away"
+
+
+class SubscriptionDiscovery(Flag):
+    """Possible capabilities which inform what methods of subscriptions ownership detection are supported.
+
+    :param AUTOMATIC: integration can retrieve the proper status of subscription ownership.
+    :param USER_ENABLED: integration can handle override of ~class::`Subscription.owned` value to True
+    """
+    AUTOMATIC = 1
+    USER_ENABLED = 2

src/galaxy/api/errors.py

@@ -20,7 +20,7 @@ class BackendError(ApplicationError):
 
 class UnknownBackendResponse(ApplicationError):
     def __init__(self, data=None):
-        super().__init__(4, "Backend responded in uknown way", data)
+        super().__init__(4, "Backend responded in unknown way", data)
 
 class TooManyRequests(ApplicationError):
     def __init__(self, data=None):
@@ -34,10 +34,6 @@ class NetworkError(ApplicationError):
     def __init__(self, data=None):
         super().__init__(101, "Network error", data)
 
-class LoggedInElsewhere(ApplicationError):
-    def __init__(self, data=None):
-        super().__init__(102, "Logged in elsewhere", data)
-
 class ProtocolError(ApplicationError):
     def __init__(self, data=None):
         super().__init__(103, "Protocol error", data)

src/galaxy/api/importer.py

@@ -0,0 +1,102 @@
+import asyncio
+import logging
+from galaxy.api.jsonrpc import ApplicationError
+from galaxy.api.errors import ImportInProgress, UnknownError
+
+logger = logging.getLogger(__name__)
+
+
+class Importer:
+    def __init__(
+            self,
+            task_manger,
+            name,
+            get,
+            prepare_context,
+            notification_success,
+            notification_failure,
+            notification_finished,
+            complete,
+    ):
+        self._task_manager = task_manger
+        self._name = name
+        self._get = get
+        self._prepare_context = prepare_context
+        self._notification_success = notification_success
+        self._notification_failure = notification_failure
+        self._notification_finished = notification_finished
+        self._complete = complete
+
+        self._import_in_progress = False
+
+    async def _import_element(self, id_, context_):
+        try:
+            element = await self._get(id_, context_)
+            self._notification_success(id_, element)
+        except ApplicationError as error:
+            self._notification_failure(id_, error)
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.exception("Unexpected exception raised in %s importer", self._name)
+            self._notification_failure(id_, UnknownError())
+
+    async def _import_elements(self, ids_, context_):
+        try:
+            imports = [self._import_element(id_, context_) for id_ in ids_]
+            await asyncio.gather(*imports)
+            self._notification_finished()
+            self._complete()
+        except asyncio.CancelledError:
+            logger.debug("Importing %s cancelled", self._name)
+        finally:
+            self._import_in_progress = False
+
+    async def start(self, ids):
+        if self._import_in_progress:
+            raise ImportInProgress()
+
+        self._import_in_progress = True
+        try:
+            context = await self._prepare_context(ids)
+            self._task_manager.create_task(
+                self._import_elements(ids, context),
+                "{} import".format(self._name),
+                handle_exceptions=False
+            )
+        except:
+            self._import_in_progress = False
+            raise
+
+
+class CollectionImporter(Importer):
+    def __init__(self, notification_partially_finished, *args):
+        super().__init__(*args)
+        self._notification_partially_finished = notification_partially_finished
+
+    async def _import_element(self, id_, context_):
+        try:
+            async for element in self._get(id_, context_):
+                self._notification_success(id_, element)
+        except ApplicationError as error:
+            self._notification_failure(id_, error)
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.exception("Unexpected exception raised in %s importer", self._name)
+            self._notification_failure(id_, UnknownError())
+        finally:
+            self._notification_partially_finished(id_)
+
+
+class SynchroneousImporter(Importer):
+    async def _import_elements(self, ids_, context_):
+        try:
+            for id_ in ids_:
+                await self._import_element(id_, context_)
+            self._notification_finished()
+            self._complete()
+        except asyncio.CancelledError:
+            logger.debug("Importing %s cancelled", self._name)
+        finally:
+            self._import_in_progress = False

src/galaxy/api/jsonrpc.py

@@ -8,6 +8,10 @@ import json
 from galaxy.reader import StreamLineReader
 from galaxy.task_manager import TaskManager
 
+
+logger = logging.getLogger(__name__)
+
+
 class JsonRpcError(Exception):
     def __init__(self, code, message, data=None):
         self.code = code
@@ -25,7 +29,7 @@ class JsonRpcError(Exception):
         }
 
         if self.data is not None:
-            obj["error"]["data"] = self.data
+            obj["data"] = self.data
 
         return obj
 
@@ -89,7 +93,6 @@ class Connection():
         self._methods = {}
         self._notifications = {}
         self._task_manager = TaskManager("jsonrpc server")
-        self._write_lock = asyncio.Lock()
         self._last_request_id = 0
         self._requests_futures = {}
 
@@ -133,7 +136,7 @@ class Connection():
         future = loop.create_future()
         self._requests_futures[self._last_request_id] = (future, sensitive_params)
 
-        logging.info(
+        logger.info(
             "Sending request: id=%s, method=%s, params=%s",
             request_id, method, anonymise_sensitive_params(params, sensitive_params)
         )
@@ -151,7 +154,7 @@ class Connection():
             if False - no params are considered sensitive, if True - all params are considered sensitive
         """
 
-        logging.info(
+        logger.info(
             "Sending notification: method=%s, params=%s",
             method, anonymise_sensitive_params(params, sensitive_params)
         )
@@ -169,20 +172,20 @@ class Connection():
                 self._eof()
                 continue
             data = data.strip()
-            logging.debug("Received %d bytes of data", len(data))
+            logger.debug("Received %d bytes of data", len(data))
             self._handle_input(data)
             await asyncio.sleep(0) # To not starve task queue
 
     def close(self):
         if self._active:
-            logging.info("Closing JSON-RPC server - not more messages will be read")
+            logger.info("Closing JSON-RPC server - not more messages will be read")
             self._active = False
 
     async def wait_closed(self):
         await self._task_manager.wait()
 
     def _eof(self):
-        logging.info("Received EOF")
+        logger.info("Received EOF")
         self.close()
 
     def _handle_input(self, data):
@@ -204,7 +207,7 @@ class Connection():
         request_future = self._requests_futures.get(int(response.id))
         if request_future is None:
             response_type = "response" if response.result is not None else "error"
-            logging.warning("Received %s for unknown request: %s", response_type, response.id)
+            logger.warning("Received %s for unknown request: %s", response_type, response.id)
             return
 
         future, sensitive_params = request_future
@@ -225,7 +228,7 @@ class Connection():
     def _handle_notification(self, request):
         method = self._notifications.get(request.method)
         if not method:
-            logging.error("Received unknown notification: %s", request.method)
+            logger.error("Received unknown notification: %s", request.method)
             return
 
         callback, signature, immediate, sensitive_params = method
@@ -242,12 +245,12 @@ class Connection():
             try:
                 self._task_manager.create_task(callback(*bound_args.args, **bound_args.kwargs), request.method)
             except Exception:
-                logging.exception("Unexpected exception raised in notification handler")
+                logger.exception("Unexpected exception raised in notification handler")
 
     def _handle_request(self, request):
         method = self._methods.get(request.method)
         if not method:
-            logging.error("Received unknown request: %s", request.method)
+            logger.error("Received unknown request: %s", request.method)
             self._send_error(request.id, MethodNotFound())
             return
 
@@ -274,7 +277,7 @@ class Connection():
                 except asyncio.CancelledError:
                     self._send_error(request.id, Aborted())
                 except Exception as e:  #pylint: disable=broad-except
-                    logging.exception("Unexpected exception raised in plugin handler")
+                    logger.exception("Unexpected exception raised in plugin handler")
                     self._send_error(request.id, UnknownError(str(e)))
 
             self._task_manager.create_task(handle(), request.method)
@@ -296,19 +299,14 @@ class Connection():
         except TypeError:
             raise InvalidRequest()
 
-    def _send(self, data):
-        async def send_task(data_):
-            async with self._write_lock:
-                self._writer.write(data_)
-                await self._writer.drain()
-
+    def _send(self, data, log_level=logging.DEBUG):
         try:
             line = self._encoder.encode(data)
+            logger.log(log_level, "Sending data: %s", line)
             data = (line + "\n").encode("utf-8")
-            logging.debug("Sending %d byte of data", len(data))
-            self._task_manager.create_task(send_task(data), "send")
+            self._writer.write(data)
         except TypeError as error:
-            logging.error(str(error))
+            logger.error(str(error))
 
     def _send_response(self, request_id, result):
         response = {
@@ -316,7 +314,7 @@ class Connection():
             "id": request_id,
             "result": result
         }
-        self._send(response)
+        self._send(response, logging.INFO)
 
     def _send_error(self, request_id, error):
         response = {
@@ -324,8 +322,7 @@ class Connection():
             "id": request_id,
             "error": error.json()
         }
-
-        self._send(response)
+        self._send(response, logging.ERROR)
 
     def _send_request(self, request_id, method, params):
         request = {
@@ -334,7 +331,7 @@ class Connection():
             "id": request_id,
             "params": params
         }
-        self._send(request)
+        self._send(request, logging.NOTSET)
 
     def _send_notification(self, method, params):
         notification = {
@@ -342,24 +339,25 @@ class Connection():
             "method": method,
             "params": params
         }
-        self._send(notification)
+        self._send(notification, logging.NOTSET)
 
     @staticmethod
     def _log_request(request, sensitive_params):
         params = anonymise_sensitive_params(request.params, sensitive_params)
         if request.id is not None:
-            logging.info("Handling request: id=%s, method=%s, params=%s", request.id, request.method, params)
+            logger.info("Handling request: id=%s, method=%s, params=%s", request.id, request.method, params)
         else:
-            logging.info("Handling notification: method=%s, params=%s", request.method, params)
+            logger.info("Handling notification: method=%s, params=%s", request.method, params)
 
     @staticmethod
     def _log_response(response, sensitive_params):
         result = anonymise_sensitive_params(response.result, sensitive_params)
-        logging.info("Handling response: id=%s, result=%s", response.id, result)
+        logger.info("Handling response: id=%s, result=%s", response.id, result)
 
     @staticmethod
     def _log_error(response, error, sensitive_params):
-        data = anonymise_sensitive_params(error.data, sensitive_params)
-        logging.info("Handling error: id=%s, code=%s, description=%s, data=%s",
+        params = error.data if error.data is not None else {}
+        data = anonymise_sensitive_params(params, sensitive_params)
+        logger.info("Handling error: id=%s, code=%s, description=%s, data=%s",
             response.id, error.code, error.message, data
         )

src/galaxy/api/plugin.py

@@ -2,18 +2,21 @@ import asyncio
 import dataclasses
 import json
 import logging
-import logging.handlers
 import sys
 from enum import Enum
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union, AsyncGenerator
 
 from galaxy.api.consts import Feature, OSCompatibility
-from galaxy.api.errors import ImportInProgress, UnknownError
 from galaxy.api.jsonrpc import ApplicationError, Connection
 from galaxy.api.types import (
-    Achievement, Authentication, Game, GameLibrarySettings, GameTime, LocalGame, NextStep, UserInfo, UserPresence
+    Achievement, Authentication, Game, GameLibrarySettings, GameTime, LocalGame, NextStep, UserInfo, UserPresence,
+    Subscription, SubscriptionGame
 )
 from galaxy.task_manager import TaskManager
+from galaxy.api.importer import Importer, CollectionImporter, SynchroneousImporter
+
+
+logger = logging.getLogger(__name__)
 
 
 class JSONEncoder(json.JSONEncoder):
@@ -33,7 +36,7 @@ class Plugin:
     """Use and override methods of this class to create a new platform integration."""
 
     def __init__(self, platform, version, reader, writer, handshake_token):
-        logging.info("Creating plugin for platform %s, version %s", platform.value, version)
+        logger.info("Creating plugin for platform %s, version %s", platform.value, version)
         self._platform = platform
         self._version = version
 
@@ -46,17 +49,83 @@ class Plugin:
         encoder = JSONEncoder()
         self._connection = Connection(self._reader, self._writer, encoder)
 
-        self._achievements_import_in_progress = False
-        self._game_times_import_in_progress = False
-        self._game_library_settings_import_in_progress = False
-        self._os_compatibility_import_in_progress = False
-        self._user_presence_import_in_progress = False
-
         self._persistent_cache = dict()
 
         self._internal_task_manager = TaskManager("plugin internal")
         self._external_task_manager = TaskManager("plugin external")
 
+        self._achievements_importer = Importer(
+            self._external_task_manager,
+            "achievements",
+            self.get_unlocked_achievements,
+            self.prepare_achievements_context,
+            self._game_achievements_import_success,
+            self._game_achievements_import_failure,
+            self._achievements_import_finished,
+            self.achievements_import_complete
+        )
+        self._game_time_importer = Importer(
+            self._external_task_manager,
+            "game times",
+            self.get_game_time,
+            self.prepare_game_times_context,
+            self._game_time_import_success,
+            self._game_time_import_failure,
+            self._game_times_import_finished,
+            self.game_times_import_complete
+        )
+        self._game_library_settings_importer = Importer(
+            self._external_task_manager,
+            "game library settings",
+            self.get_game_library_settings,
+            self.prepare_game_library_settings_context,
+            self._game_library_settings_import_success,
+            self._game_library_settings_import_failure,
+            self._game_library_settings_import_finished,
+            self.game_library_settings_import_complete
+        )
+        self._os_compatibility_importer = Importer(
+            self._external_task_manager,
+            "os compatibility",
+            self.get_os_compatibility,
+            self.prepare_os_compatibility_context,
+            self._os_compatibility_import_success,
+            self._os_compatibility_import_failure,
+            self._os_compatibility_import_finished,
+            self.os_compatibility_import_complete
+        )
+        self._user_presence_importer = Importer(
+            self._external_task_manager,
+            "users presence",
+            self.get_user_presence,
+            self.prepare_user_presence_context,
+            self._user_presence_import_success,
+            self._user_presence_import_failure,
+            self._user_presence_import_finished,
+            self.user_presence_import_complete
+        )
+        self._local_size_importer = SynchroneousImporter(
+            self._external_task_manager,
+            "local size",
+            self.get_local_size,
+            self.prepare_local_size_context,
+            self._local_size_import_success,
+            self._local_size_import_failure,
+            self._local_size_import_finished,
+            self.local_size_import_complete
+        )
+        self._subscription_games_importer = CollectionImporter(
+            self._subscriptions_games_partial_import_finished,
+            self._external_task_manager,
+            "subscription games",
+            self.get_subscription_games,
+            self.prepare_subscription_games_context,
+            self._subscription_games_import_success,
+            self._subscription_games_import_failure,
+            self._subscription_games_import_finished,
+            self.subscription_games_import_complete
+        )
+
         # internal
         self._register_method("shutdown", self._shutdown, internal=True)
         self._register_method("get_capabilities", self._get_capabilities, internal=True, immediate=True)
@@ -123,6 +192,15 @@ class Plugin:
         self._register_method("start_user_presence_import", self._start_user_presence_import)
         self._detect_feature(Feature.ImportUserPresence, ["get_user_presence"])
 
+        self._register_method("start_local_size_import", self._start_local_size_import)
+        self._detect_feature(Feature.ImportLocalSize, ["get_local_size"])
+
+        self._register_method("import_subscriptions", self.get_subscriptions, result_name="subscriptions")
+        self._detect_feature(Feature.ImportSubscriptions, ["get_subscriptions"])
+
+        self._register_method("start_subscription_games_import", self._start_subscription_games_import)
+        self._detect_feature(Feature.ImportSubscriptionGames, ["get_subscription_games"])
+
     async def __aenter__(self):
         return self
 
@@ -150,7 +228,8 @@ class Plugin:
         if self._implements(methods):
             self._features.add(feature)
 
-    def _register_method(self, name, handler, result_name=None, internal=False, immediate=False, sensitive_params=False):
+    def _register_method(self, name, handler, result_name=None, internal=False, immediate=False,
+                         sensitive_params=False):
         def wrap_result(result):
             if result_name:
                 result = {
@@ -189,24 +268,31 @@ class Plugin:
     async def run(self):
         """Plugin's main coroutine."""
         await self._connection.run()
-        logging.debug("Plugin run loop finished")
+        logger.debug("Plugin run loop finished")
 
     def close(self) -> None:
         if not self._active:
             return
 
-        logging.info("Closing plugin")
+        logger.info("Closing plugin")
         self._connection.close()
         self._external_task_manager.cancel()
-        self._internal_task_manager.create_task(self.shutdown(), "shutdown")
+
+        async def shutdown():
+            try:
+                await asyncio.wait_for(self.shutdown(), 30)
+            except asyncio.TimeoutError:
+                logging.warning("Plugin shutdown timed out")
+
+        self._internal_task_manager.create_task(shutdown(), "shutdown")
         self._active = False
 
     async def wait_closed(self) -> None:
-        logging.debug("Waiting for plugin to close")
+        logger.debug("Waiting for plugin to close")
         await self._external_task_manager.wait()
         await self._internal_task_manager.wait()
         await self._connection.wait_closed()
-        logging.debug("Plugin closed")
+        logger.info("Plugin closed")
 
     def create_task(self, coro, description):
         """Wrapper around asyncio.create_task - takes care of canceling tasks on shutdown"""
@@ -217,11 +303,11 @@ class Plugin:
             try:
                 self.tick()
             except Exception:
-                logging.exception("Unexpected exception raised in plugin tick")
+                logger.exception("Unexpected exception raised in plugin tick")
             await asyncio.sleep(1)
 
     async def _shutdown(self):
-        logging.info("Shutting down")
+        logger.info("Shutting down")
         self.close()
         await self._external_task_manager.wait()
         await self._internal_task_manager.wait()
@@ -238,7 +324,7 @@ class Plugin:
         try:
             self.handshake_complete()
         except Exception:
-            logging.exception("Unhandled exception during `handshake_complete` step")
+            logger.exception("Unhandled exception during `handshake_complete` step")
         self._internal_task_manager.create_task(self._pass_control(), "tick")
 
     @staticmethod
@@ -426,7 +512,7 @@ class Plugin:
             }
         )
 
-    def _game_time_import_success(self, game_time: GameTime) -> None:
+    def _game_time_import_success(self, game_id: str, game_time: GameTime) -> None:
         params = {"game_time": game_time}
         self._connection.send_notification("game_time_import_success", params)
 
@@ -440,7 +526,7 @@ class Plugin:
     def _game_times_import_finished(self) -> None:
         self._connection.send_notification("game_times_import_finished", None)
 
-    def _game_library_settings_import_success(self, game_library_settings: GameLibrarySettings) -> None:
+    def _game_library_settings_import_success(self, game_id: str, game_library_settings: GameLibrarySettings) -> None:
         params = {"game_library_settings": game_library_settings}
         self._connection.send_notification("game_library_settings_import_success", params)
 
@@ -496,6 +582,57 @@ class Plugin:
     def _user_presence_import_finished(self) -> None:
         self._connection.send_notification("user_presence_import_finished", None)
 
+    def _local_size_import_success(self, game_id: str, size: Optional[int]) -> None:
+        self._connection.send_notification(
+            "local_size_import_success",
+            {
+                "game_id": game_id,
+                "local_size": size
+            }
+        )
+
+    def _local_size_import_failure(self, game_id: str, error: ApplicationError) -> None:
+        self._connection.send_notification(
+            "local_size_import_failure",
+            {
+                "game_id": game_id,
+                "error": error.json()
+            }
+        )
+
+    def _local_size_import_finished(self) -> None:
+        self._connection.send_notification("local_size_import_finished", None)
+
+    def _subscription_games_import_success(self, subscription_name: str,
+                                           subscription_games: Optional[List[SubscriptionGame]]) -> None:
+        self._connection.send_notification(
+            "subscription_games_import_success",
+            {
+                "subscription_name": subscription_name,
+                "subscription_games": subscription_games
+            }
+        )
+
+    def _subscription_games_import_failure(self, subscription_name: str, error: ApplicationError) -> None:
+        self._connection.send_notification(
+            "subscription_games_import_failure",
+            {
+                "subscription_name": subscription_name,
+                "error": error.json()
+            }
+        )
+
+    def _subscriptions_games_partial_import_finished(self, subscription_name: str) -> None:
+        self._connection.send_notification(
+            "subscription_games_partial_import_finished",
+            {
+               "subscription_name": subscription_name
+            }
+        )
+
+    def _subscription_games_import_finished(self) -> None:
+        self._connection.send_notification("subscription_games_import_finished", None)
+
     def lost_authentication(self) -> None:
         """Notify the client that integration has lost authentication for the
          current user and is unable to perform actions which would require it.
@@ -555,7 +692,7 @@ class Plugin:
         This method is called by the GOG Galaxy Client.
 
         :param stored_credentials: If the client received any credentials to store locally
-         in the previous session they will be passed here as a parameter.
+            in the previous session they will be passed here as a parameter.
 
 
         Example of possible override of the method:
@@ -577,7 +714,7 @@ class Plugin:
         raise NotImplementedError()
 
     async def pass_login_credentials(self, step: str, credentials: Dict[str, str], cookies: List[Dict[str, str]]) \
-        -> Union[NextStep, Authentication]:
+            -> Union[NextStep, Authentication]:
         """This method is called if we return :class:`~galaxy.api.types.NextStep` from :meth:`.authenticate`
         or :meth:`.pass_login_credentials`.
         This method's parameters provide the data extracted from the web page navigation that previous NextStep finished on.
@@ -627,36 +764,7 @@ class Plugin:
         raise NotImplementedError()
 
     async def _start_achievements_import(self, game_ids: List[str]) -> None:
-        if self._achievements_import_in_progress:
-            raise ImportInProgress()
-
-        context = await self.prepare_achievements_context(game_ids)
-
-        async def import_game_achievements(game_id, context_):
-            try:
-                achievements = await self.get_unlocked_achievements(game_id, context_)
-                self._game_achievements_import_success(game_id, achievements)
-            except ApplicationError as error:
-                self._game_achievements_import_failure(game_id, error)
-            except Exception:
-                logging.exception("Unexpected exception raised in import_game_achievements")
-                self._game_achievements_import_failure(game_id, UnknownError())
-
-        async def import_games_achievements(game_ids_, context_):
-            try:
-                imports = [import_game_achievements(game_id, context_) for game_id in game_ids_]
-                await asyncio.gather(*imports)
-            finally:
-                self._achievements_import_finished()
-                self._achievements_import_in_progress = False
-                self.achievements_import_complete()
-
-        self._external_task_manager.create_task(
-            import_games_achievements(game_ids, context),
-            "unlocked achievements import",
-            handle_exceptions=False
-        )
-        self._achievements_import_in_progress = True
+        await self._achievements_importer.start(game_ids)
 
     async def prepare_achievements_context(self, game_ids: List[str]) -> Any:
         """Override this method to prepare context for get_unlocked_achievements.
@@ -791,36 +899,7 @@ class Plugin:
         raise NotImplementedError()
 
     async def _start_game_times_import(self, game_ids: List[str]) -> None:
-        if self._game_times_import_in_progress:
-            raise ImportInProgress()
-
-        context = await self.prepare_game_times_context(game_ids)
-
-        async def import_game_time(game_id, context_):
-            try:
-                game_time = await self.get_game_time(game_id, context_)
-                self._game_time_import_success(game_time)
-            except ApplicationError as error:
-                self._game_time_import_failure(game_id, error)
-            except Exception:
-                logging.exception("Unexpected exception raised in import_game_time")
-                self._game_time_import_failure(game_id, UnknownError())
-
-        async def import_game_times(game_ids_, context_):
-            try:
-                imports = [import_game_time(game_id, context_) for game_id in game_ids_]
-                await asyncio.gather(*imports)
-            finally:
-                self._game_times_import_finished()
-                self._game_times_import_in_progress = False
-                self.game_times_import_complete()
-
-        self._external_task_manager.create_task(
-            import_game_times(game_ids, context),
-            "game times import",
-            handle_exceptions=False
-        )
-        self._game_times_import_in_progress = True
+        await self._game_time_importer.start(game_ids)
 
     async def prepare_game_times_context(self, game_ids: List[str]) -> Any:
         """Override this method to prepare context for get_game_time.
@@ -849,36 +928,7 @@ class Plugin:
         """
 
     async def _start_game_library_settings_import(self, game_ids: List[str]) -> None:
-        if self._game_library_settings_import_in_progress:
-            raise ImportInProgress()
-
-        context = await self.prepare_game_library_settings_context(game_ids)
-
-        async def import_game_library_settings(game_id, context_):
-            try:
-                game_library_settings = await self.get_game_library_settings(game_id, context_)
-                self._game_library_settings_import_success(game_library_settings)
-            except ApplicationError as error:
-                self._game_library_settings_import_failure(game_id, error)
-            except Exception:
-                logging.exception("Unexpected exception raised in import_game_library_settings")
-                self._game_library_settings_import_failure(game_id, UnknownError())
-
-        async def import_game_library_settings_set(game_ids_, context_):
-            try:
-                imports = [import_game_library_settings(game_id, context_) for game_id in game_ids_]
-                await asyncio.gather(*imports)
-            finally:
-                self._game_library_settings_import_finished()
-                self._game_library_settings_import_in_progress = False
-                self.game_library_settings_import_complete()
-
-        self._external_task_manager.create_task(
-            import_game_library_settings_set(game_ids, context),
-            "game library settings import",
-            handle_exceptions=False
-        )
-        self._game_library_settings_import_in_progress = True
+        await self._game_library_settings_importer.start(game_ids)
 
     async def prepare_game_library_settings_context(self, game_ids: List[str]) -> Any:
         """Override this method to prepare context for get_game_library_settings.
@@ -907,37 +957,7 @@ class Plugin:
         """
 
     async def _start_os_compatibility_import(self, game_ids: List[str]) -> None:
-        if self._os_compatibility_import_in_progress:
-            raise ImportInProgress()
-
-        context = await self.prepare_os_compatibility_context(game_ids)
-
-        async def import_os_compatibility(game_id, context_):
-            try:
-                os_compatibility = await self.get_os_compatibility(game_id, context_)
-                self._os_compatibility_import_success(game_id, os_compatibility)
-            except ApplicationError as error:
-                self._os_compatibility_import_failure(game_id, error)
-            except Exception:
-                logging.exception("Unexpected exception raised in import_os_compatibility")
-                self._os_compatibility_import_failure(game_id, UnknownError())
-
-        async def import_os_compatibility_set(game_ids_, context_):
-            try:
-                await asyncio.gather(*[
-                    import_os_compatibility(game_id, context_) for game_id in game_ids_
-                ])
-            finally:
-                self._os_compatibility_import_finished()
-                self._os_compatibility_import_in_progress = False
-                self.os_compatibility_import_complete()
-
-        self._external_task_manager.create_task(
-            import_os_compatibility_set(game_ids, context),
-            "game OS compatibility import",
-            handle_exceptions=False
-        )
-        self._os_compatibility_import_in_progress = True
+        await self._os_compatibility_importer.start(game_ids)
 
     async def prepare_os_compatibility_context(self, game_ids: List[str]) -> Any:
         """Override this method to prepare context for get_os_compatibility.
@@ -962,45 +982,15 @@ class Plugin:
     def os_compatibility_import_complete(self) -> None:
         """Override this method to handle operations after OS compatibility import is finished (like updating cache)."""
 
-    async def _start_user_presence_import(self, user_ids: List[str]) -> None:
-        if self._user_presence_import_in_progress:
-            raise ImportInProgress()
+    async def _start_user_presence_import(self, user_id_list: List[str]) -> None:
+        await self._user_presence_importer.start(user_id_list)
 
-        context = await self.prepare_user_presence_context(user_ids)
-
-        async def import_user_presence(user_id, context_) -> None:
-            try:
-                self._user_presence_import_success(user_id, await self.get_user_presence(user_id, context_))
-            except ApplicationError as error:
-                self._user_presence_import_failure(user_id, error)
-            except Exception:
-                logging.exception("Unexpected exception raised in import_user_presence")
-                self._user_presence_import_failure(user_id, UnknownError())
-
-        async def import_user_presence_set(user_ids_, context_) -> None:
-            try:
-                await asyncio.gather(*[
-                    import_user_presence(user_id, context_)
-                    for user_id in user_ids_
-                ])
-            finally:
-                self._user_presence_import_finished()
-                self._user_presence_import_in_progress = False
-                self.user_presence_import_complete()
-
-        self._external_task_manager.create_task(
-            import_user_presence_set(user_ids, context),
-            "user presence import",
-            handle_exceptions=False
-        )
-        self._user_presence_import_in_progress = True
-
-    async def prepare_user_presence_context(self, user_ids: List[str]) -> Any:
-        """Override this method to prepare context for get_user_presence.
+    async def prepare_user_presence_context(self, user_id_list: List[str]) -> Any:
+        """Override this method to prepare context for :meth:`get_user_presence`.
         This allows for optimizations like batch requests to platform API.
         Default implementation returns None.
 
-        :param user_ids: the ids of the users for whom presence information is imported
+        :param user_id_list: the ids of the users for whom presence information is imported
         :return: context
         """
         return None
@@ -1018,6 +1008,81 @@ class Plugin:
     def user_presence_import_complete(self) -> None:
         """Override this method to handle operations after presence import is finished (like updating cache)."""
 
+    async def _start_local_size_import(self, game_ids: List[str]) -> None:
+        await self._local_size_importer.start(game_ids)
+
+    async def prepare_local_size_context(self, game_ids: List[str]) -> Any:
+        """Override this method to prepare context for :meth:`get_local_size`
+        Default implementation returns None.
+
+        :param game_ids: the ids of the games for which information about size is imported
+        :return: context
+        """
+        return None
+
+    async def get_local_size(self, game_id: str, context: Any) -> Optional[int]:
+        """Override this method to return installed game size.
+
+        .. note::
+          It is preferable to avoid iterating over local game files when overriding this method.
+          If possible, please use a more efficient way of game size retrieval.
+
+        :param game_id: the id of the installed game
+        :param context: the value returned from :meth:`prepare_local_size_context`
+        :return: the size of the game on a user-owned storage device (in bytes) or `None` if the size cannot be determined
+        """
+        raise NotImplementedError()
+
+    def local_size_import_complete(self) -> None:
+        """Override this method to handle operations after local game size import is finished (like updating cache)."""
+
+    async def get_subscriptions(self) -> List[Subscription]:
+        """Override this method to return a list of
+        Subscriptions available on platform.
+        This method is called by the GOG Galaxy Client.
+        """
+        raise NotImplementedError()
+
+    async def _start_subscription_games_import(self, subscription_names: List[str]) -> None:
+        await self._subscription_games_importer.start(subscription_names)
+
+    async def prepare_subscription_games_context(self, subscription_names: List[str]) -> Any:
+        """Override this method to prepare context for :meth:`get_subscription_games`
+        Default implementation returns None.
+
+        :param subscription_names: the names of the subscriptions' for which subscriptions games are imported
+        :return: context
+        """
+        return None
+
+    async def get_subscription_games(self, subscription_name: str, context: Any) -> AsyncGenerator[
+        List[SubscriptionGame], None]:
+        """Override this method to provide SubscriptionGames for a given subscription.
+        This method should `yield` a list of SubscriptionGames -> yield [sub_games]
+
+        This method will only be used if :meth:`get_subscriptions` has been implemented.
+
+        :param context: the value returned from :meth:`prepare_subscription_games_context`
+        :return a generator object that yields SubscriptionGames
+
+        .. code-block:: python
+            :linenos:
+
+            async def get_subscription_games(subscription_name: str, context: Any):
+                while True:
+                    games_page = await self._get_subscriptions_from_backend(subscription_name, i)
+                    if not games_pages:
+                        yield None
+                    yield [SubGame(game['game_id'], game['game_title']) for game in games_page]
+
+        """
+        raise NotImplementedError()
+
+    def subscription_games_import_complete(self) -> None:
+        """Override this method to handle operations after
+        subscription games import is finished (like updating cache).
+        """
+
 
 def create_and_run_plugin(plugin_class, argv):
     """Call this method as an entry point for the implemented integration.
@@ -1037,7 +1102,7 @@ def create_and_run_plugin(plugin_class, argv):
                 main()
     """
     if len(argv) < 3:
-        logging.critical("Not enough parameters, required: token, port")
+        logger.critical("Not enough parameters, required: token, port")
         sys.exit(1)
 
     token = argv[1]
@@ -1045,23 +1110,27 @@ def create_and_run_plugin(plugin_class, argv):
     try:
         port = int(argv[2])
     except ValueError:
-        logging.critical("Failed to parse port value: %s", argv[2])
+        logger.critical("Failed to parse port value: %s", argv[2])
         sys.exit(2)
 
     if not (1 <= port <= 65535):
-        logging.critical("Port value out of range (1, 65535)")
+        logger.critical("Port value out of range (1, 65535)")
         sys.exit(3)
 
     if not issubclass(plugin_class, Plugin):
-        logging.critical("plugin_class must be subclass of Plugin")
+        logger.critical("plugin_class must be subclass of Plugin")
         sys.exit(4)
 
     async def coroutine():
         reader, writer = await asyncio.open_connection("127.0.0.1", port)
-        extra_info = writer.get_extra_info("sockname")
-        logging.info("Using local address: %s:%u", *extra_info)
-        async with plugin_class(reader, writer, token) as plugin:
-            await plugin.run()
+        try:
+            extra_info = writer.get_extra_info("sockname")
+            logger.info("Using local address: %s:%u", *extra_info)
+            async with plugin_class(reader, writer, token) as plugin:
+                await plugin.run()
+        finally:
+            writer.close()
+            await writer.wait_closed()
 
     try:
         if sys.platform == "win32":
@@ -1069,5 +1138,5 @@ def create_and_run_plugin(plugin_class, argv):
 
         asyncio.run(coroutine())
     except Exception:
-        logging.exception("Error while running plugin")
+        logger.exception("Error while running plugin")
         sys.exit(5)

src/galaxy/api/types.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
-from galaxy.api.consts import LicenseType, LocalGameState, PresenceState
+from galaxy.api.consts import LicenseType, LocalGameState, PresenceState, SubscriptionDiscovery
 
 
 @dataclass
@@ -62,10 +62,10 @@ class NextStep:
                 return NextStep("web_session", PARAMS, cookies=COOKIES, js=JS)
 
     :param auth_params: configuration options: {"window_title": :class:`str`, "window_width": :class:`str`,
-     "window_height": :class:`int`, "start_uri": :class:`int`, "end_uri_regex": :class:`str`}
+        "window_height": :class:`int`, "start_uri": :class:`int`, "end_uri_regex": :class:`str`}
     :param cookies: browser initial set of cookies
     :param js: a map of the url regex patterns into the list of *js* scripts that should be executed
-     on every document at given step of internal browser authentication.
+        on every document at given step of internal browser authentication.
     """
     next_step: str
     auth_params: Dict[str, str]
@@ -166,8 +166,8 @@ class UserInfo:
     """
     user_id: str
     user_name: str
-    avatar_url: Optional[str]
-    profile_url: Optional[str]
+    avatar_url: Optional[str] = None
+    profile_url: Optional[str] = None
 
 
 @dataclass
@@ -216,3 +216,42 @@ class UserPresence:
     game_title: Optional[str] = None
     in_game_status: Optional[str] = None
     full_status: Optional[str] = None
+
+
+@dataclass
+class Subscription:
+    """Information about a subscription.
+
+    :param subscription_name: name of the subscription, will also be used as its identifier.
+    :param owned: whether the subscription is owned or not, None if unknown.
+    :param end_time: unix timestamp of when the subscription ends, None if unknown.
+    :param subscription_discovery: combination of settings that can be manually
+        chosen by user to determine subscription handling behaviour. For example, if the integration cannot retrieve games
+        for subscription when user doesn't own it, then USER_ENABLED should not be used.
+        If the integration cannot determine subscription ownership for a user then AUTOMATIC should not be used.
+
+    """
+    subscription_name: str
+    owned: Optional[bool] = None
+    end_time: Optional[int] = None
+    subscription_discovery: SubscriptionDiscovery = SubscriptionDiscovery.AUTOMATIC | \
+                                                                 SubscriptionDiscovery.USER_ENABLED
+
+    def __post_init__(self):
+        assert self.subscription_discovery in [SubscriptionDiscovery.AUTOMATIC, SubscriptionDiscovery.USER_ENABLED,
+                                               SubscriptionDiscovery.AUTOMATIC | SubscriptionDiscovery.USER_ENABLED]
+
+
+@dataclass
+class SubscriptionGame:
+    """Information about a game from a subscription.
+
+    :param game_title: title of the game
+    :param game_id: id of the game
+    :param start_time: unix timestamp of when the game has been added to subscription
+    :param end_time: unix timestamp of when the game will be removed from subscription.
+    """
+    game_title: str
+    game_id: str
+    start_time: Optional[int] = None
+    end_time: Optional[int] = None

src/galaxy/http.py

@@ -1,12 +1,11 @@
 """
-This module standarize http traffic and the error handling for further communication with the GOG Galaxy 2.0.
+This module standardizes http traffic and the error handling for further communication with the GOG Galaxy 2.0.
 
 It is recommended to use provided convenient methods for HTTP requests, especially when dealing with authorized sessions.
-Examplary simple web service could looks like:
+Exemplary simple web service could looks like:
 
     .. code-block:: python
 
-        import logging
         from galaxy.http import create_client_session, handle_exception
 
         class BackendClient:
@@ -44,6 +43,8 @@ from galaxy.api.errors import (
 )
 
 
+logger = logging.getLogger(__name__)
+
 #: Default limit of the simultaneous connections for ssl connector.
 DEFAULT_LIMIT = 20
 #: Default timeout in seconds used for client session.
@@ -70,7 +71,7 @@ class HttpClient:
 
 def create_tcp_connector(*args, **kwargs) -> aiohttp.TCPConnector:
     """
-    Creates TCP connector with resonable defaults.
+    Creates TCP connector with reasonable defaults.
     For details about available parameters refer to
     `aiohttp.TCPConnector <https://docs.aiohttp.org/en/stable/client_reference.html#tcpconnector>`_
     """
@@ -84,11 +85,11 @@ def create_tcp_connector(*args, **kwargs) -> aiohttp.TCPConnector:
 
 def create_client_session(*args, **kwargs) -> aiohttp.ClientSession:
     """
-    Creates client session with resonable defaults.
+    Creates client session with reasonable defaults.
     For details about available parameters refer to
     `aiohttp.ClientSession <https://docs.aiohttp.org/en/stable/client_reference.html>`_
 
-    Examplary customization:
+    Exemplary customization:
 
     .. code-block:: python
 
@@ -122,25 +123,25 @@ def handle_exception():
         raise BackendNotAvailable()
     except aiohttp.ClientConnectionError:
         raise NetworkError()
-    except aiohttp.ContentTypeError:
-        raise UnknownBackendResponse()
+    except aiohttp.ContentTypeError as error:
+        raise UnknownBackendResponse(error.message)
     except aiohttp.ClientResponseError as error:
         if error.status == HTTPStatus.UNAUTHORIZED:
-            raise AuthenticationRequired()
+            raise AuthenticationRequired(error.message)
         if error.status == HTTPStatus.FORBIDDEN:
-            raise AccessDenied()
+            raise AccessDenied(error.message)
         if error.status == HTTPStatus.SERVICE_UNAVAILABLE:
-            raise BackendNotAvailable()
+            raise BackendNotAvailable(error.message)
         if error.status == HTTPStatus.TOO_MANY_REQUESTS:
-            raise TooManyRequests()
+            raise TooManyRequests(error.message)
         if error.status >= 500:
-            raise BackendError()
+            raise BackendError(error.message)
         if error.status >= 400:
-            logging.warning(
+            logger.warning(
                 "Got status %d while performing %s request for %s",
                 error.status, error.request_info.method, str(error.request_info.url)
             )
-            raise UnknownError()
-    except aiohttp.ClientError:
-        logging.exception("Caught exception while performing request")
-        raise UnknownError()
+            raise UnknownError(error.message)
+    except aiohttp.ClientError as e:
+        logger.exception("Caught exception while performing request")
+        raise UnknownError(repr(e))

src/galaxy/proc_tools.py

@@ -3,7 +3,6 @@ from dataclasses import dataclass
 from typing import Iterable, NewType, Optional, List, cast
 
 
-
 ProcessId = NewType("ProcessId", int)
 
 

src/galaxy/task_manager.py

@@ -3,6 +3,10 @@ import logging
 from collections import OrderedDict
 from itertools import count
 
+
+logger = logging.getLogger(__name__)
+
+
 class TaskManager:
     def __init__(self, name):
         self._name = name
@@ -15,23 +19,23 @@ class TaskManager:
         async def task_wrapper(task_id):
             try:
                 result = await coro
-                logging.debug("Task manager %s: finished task %d (%s)", self._name, task_id, description)
+                logger.debug("Task manager %s: finished task %d (%s)", self._name, task_id, description)
                 return result
             except asyncio.CancelledError:
                 if handle_exceptions:
-                    logging.debug("Task manager %s: canceled task %d (%s)", self._name, task_id, description)
+                    logger.debug("Task manager %s: canceled task %d (%s)", self._name, task_id, description)
                 else:
                     raise
             except Exception:
                 if handle_exceptions:
-                    logging.exception("Task manager %s: exception raised in task %d (%s)", self._name, task_id, description)
+                    logger.exception("Task manager %s: exception raised in task %d (%s)", self._name, task_id, description)
                 else:
                     raise
             finally:
                 del self._tasks[task_id]
 
         task_id = next(self._task_counter)
-        logging.debug("Task manager %s: creating task %d (%s)", self._name, task_id, description)
+        logger.debug("Task manager %s: creating task %d (%s)", self._name, task_id, description)
         task = asyncio.create_task(task_wrapper(task_id))
         self._tasks[task_id] = task
         return task

src/galaxy/unittest/mock.py

@@ -21,11 +21,19 @@ def coroutine_mock():
     corofunc.coro = coro
     return corofunc
 
+
 async def skip_loop(iterations=1):
     for _ in range(iterations):
         await asyncio.sleep(0)
 
 
 async def async_return_value(return_value, loop_iterations_delay=0):
-    await skip_loop(loop_iterations_delay)
+    if loop_iterations_delay > 0:
+        await skip_loop(loop_iterations_delay)
     return return_value
+
+
+async def async_raise(error, loop_iterations_delay=0):
+    if loop_iterations_delay > 0:
+        await skip_loop(loop_iterations_delay)
+    raise error

tests/conftest.py

@@ -64,6 +64,13 @@ async def plugin(reader, writer):
         "get_user_presence",
         "prepare_user_presence_context",
         "user_presence_import_complete",
+        "get_local_size",
+        "prepare_local_size_context",
+        "local_size_import_complete",
+        "get_subscriptions",
+        "get_subscription_games",
+        "prepare_subscription_games_context",
+        "subscription_games_import_complete"
     )
 
     with ExitStack() as stack:

tests/test_authenticate.py

@@ -2,8 +2,16 @@ import pytest
 
 from galaxy.api.types import Authentication
 from galaxy.api.errors import (
-    UnknownError, InvalidCredentials, NetworkError, LoggedInElsewhere, ProtocolError,
-    BackendNotAvailable, BackendTimeout, BackendError, TemporaryBlocked, Banned, AccessDenied
+    UnknownError,
+    BackendNotAvailable,
+    BackendTimeout,
+    BackendError,
+    InvalidCredentials,
+    NetworkError,
+    ProtocolError,
+    TemporaryBlocked,
+    Banned,
+    AccessDenied,
 )
 from galaxy.unittest.mock import async_return_value, skip_loop
 
@@ -42,7 +50,6 @@ async def test_success(plugin, read, write):
     pytest.param(BackendError, 4, "Backend error", id="backend_error"),
     pytest.param(InvalidCredentials, 100, "Invalid credentials", id="invalid_credentials"),
     pytest.param(NetworkError, 101, "Network error", id="network_error"),
-    pytest.param(LoggedInElsewhere, 102, "Logged in elsewhere", id="logged_elsewhere"),
     pytest.param(ProtocolError, 103, "Protocol error", id="protocol_error"),
     pytest.param(TemporaryBlocked, 104, "Temporary blocked", id="temporary_blocked"),
     pytest.param(Banned, 105, "Banned", id="banned"),

tests/test_features.py

@@ -17,7 +17,10 @@ def test_base_class():
         Feature.LaunchPlatformClient,
         Feature.ImportGameLibrarySettings,
         Feature.ImportOSCompatibility,
-        Feature.ImportUserPresence
+        Feature.ImportUserPresence,
+        Feature.ImportLocalSize,
+        Feature.ImportSubscriptions,
+        Feature.ImportSubscriptionGames
     }
 
 

tests/test_friends.py

@@ -18,7 +18,9 @@ async def test_get_friends_success(plugin, read, write):
     read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
     plugin.get_friends.return_value = async_return_value([
         UserInfo("3", "Jan", "https://avatar.url/u3", None),
-        UserInfo("5", "Ola", None, "https://profile.url/u5")
+        UserInfo("5", "Ola", None, "https://profile.url/u5"),
+        UserInfo("6", "Ola2", None),
+        UserInfo("7", "Ola3"),
     ])
     await plugin.run()
     plugin.get_friends.assert_called_with()
@@ -30,7 +32,9 @@ async def test_get_friends_success(plugin, read, write):
             "result": {
                 "friend_info_list": [
                     {"user_id": "3", "user_name": "Jan", "avatar_url": "https://avatar.url/u3"},
-                    {"user_id": "5", "user_name": "Ola", "profile_url": "https://profile.url/u5"}
+                    {"user_id": "5", "user_name": "Ola", "profile_url": "https://profile.url/u5"},
+                    {"user_id": "6", "user_name": "Ola2"},
+                    {"user_id": "7", "user_name": "Ola3"},
                 ]
             }
         }

tests/test_local_size.py

@@ -0,0 +1,191 @@
+from unittest.mock import call
+
+import pytest
+from galaxy.api.errors import FailedParsingManifest
+from galaxy.unittest.mock import async_return_value
+
+from tests import create_message, get_messages
+
+
+@pytest.mark.asyncio
+async def test_get_local_size_success(plugin, read, write):
+    context = {'abc': 'def'}
+    plugin.prepare_local_size_context.return_value = async_return_value(context)
+    request = {
+        "jsonrpc": "2.0",
+        "id": "11",
+        "method": "start_local_size_import",
+        "params": {"game_ids": ["777", "13", "42"]}
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_local_size.side_effect = [
+        async_return_value(100000000000, 1),
+        async_return_value(None),
+        async_return_value(3333333)
+    ]
+    await plugin.run()
+    plugin.get_local_size.assert_has_calls([
+        call("777", context),
+        call("13", context),
+        call("42", context)
+    ])
+    plugin.local_size_import_complete.assert_called_once_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "11",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_success",
+            "params": {
+                "game_id": "777",
+                "local_size": 100000000000
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_success",
+            "params": {
+                "game_id": "13",
+                "local_size": None
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_success",
+            "params": {
+                "game_id": "42",
+                "local_size": 3333333
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_finished",
+            "params": None
+        }
+    ]
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exception,code,message", [
+    (FailedParsingManifest, 200, "Failed parsing manifest"),
+    (KeyError, 0, "Unknown error")
+])
+async def test_get_local_size_error(exception, code, message, plugin, read, write):
+    game_id = "6"
+    request_id = "55"
+    plugin.prepare_local_size_context.return_value = async_return_value(None)
+    request = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "method": "start_local_size_import",
+        "params": {"game_ids": [game_id]}
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_local_size.side_effect = exception
+    await plugin.run()
+    plugin.get_local_size.assert_called()
+    plugin.local_size_import_complete.assert_called_once_with()
+
+    direct_response = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "result": None
+    }
+    responses = get_messages(write)
+    assert direct_response in responses
+    responses.remove(direct_response)
+    assert responses == [
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_failure",
+            "params": {
+                "game_id": game_id,
+                "error": {
+                    "code": code,
+                    "message": message
+                }
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_finished",
+            "params": None
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_prepare_get_local_size_context_error(plugin, read, write):
+    request_id = "31415"
+    error_details = "Unexpected syntax"
+    error_message, error_code = FailedParsingManifest().message, FailedParsingManifest().code
+    plugin.prepare_local_size_context.side_effect = FailedParsingManifest(error_details)
+    request = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "method": "start_local_size_import",
+        "params": {"game_ids": ["6"]}
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    await plugin.run()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": error_code,
+                "message": error_message,
+                "data": error_details
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_import_already_in_progress_error(plugin, read, write):
+    plugin.prepare_local_size_context.return_value = async_return_value(None)
+    plugin.get_local_size.return_value = async_return_value(100, 5)
+    requests = [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "method": "start_local_size_import",
+            "params": {
+                "game_ids": ["42"]
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "id": "4",
+            "method": "start_local_size_import",
+            "params": {
+                "game_ids": ["13"]
+            }
+        }
+    ]
+    read.side_effect = [
+        async_return_value(create_message(requests[0])),
+        async_return_value(create_message(requests[1])),
+        async_return_value(b"", 10)
+    ]
+
+    await plugin.run()
+
+    responses = get_messages(write)
+    assert {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": None
+    } in responses
+    assert {
+        "jsonrpc": "2.0",
+        "id": "4",
+        "error": {
+            "code": 600,
+            "message": "Import already in progress"
+        }
+    } in responses

tests/test_refresh_credentials.py

@@ -4,7 +4,7 @@ import asyncio
 from galaxy.unittest.mock import async_return_value
 from tests import create_message, get_messages
 from galaxy.api.errors import (
-    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied
+    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied, UnknownError
 )
 from galaxy.api.jsonrpc import JsonRpcError
 @pytest.mark.asyncio
@@ -40,7 +40,7 @@ async def test_refresh_credentials_success(plugin, read, write):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("exception", [
-    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied
+    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied, UnknownError
 ])
 async def test_refresh_credentials_failure(exception, plugin, read, write):
 

tests/test_subscriptions.py

@@ -0,0 +1,340 @@
+import pytest
+
+from galaxy.api.types import Subscription, SubscriptionGame
+from galaxy.api.consts import SubscriptionDiscovery
+from galaxy.api.errors import FailedParsingManifest, BackendError, UnknownError
+from galaxy.unittest.mock import async_return_value
+
+from tests import create_message, get_messages
+
+@pytest.mark.asyncio
+async def test_get_subscriptions_success(plugin, read, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_subscriptions"
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+
+    plugin.get_subscriptions.return_value = async_return_value([
+        Subscription("1"),
+        Subscription("2", False, subscription_discovery=SubscriptionDiscovery.AUTOMATIC),
+        Subscription("3", True, 1580899100, SubscriptionDiscovery.USER_ENABLED)
+    ])
+    await plugin.run()
+    plugin.get_subscriptions.assert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": {
+                "subscriptions": [
+                    {
+                        "subscription_name": "1",
+                        'subscription_discovery': 3
+                    },
+                    {
+                        "subscription_name": "2",
+                        "owned": False,
+                        'subscription_discovery': 1
+                    },
+                    {
+                        "subscription_name": "3",
+                        "owned": True,
+                        "end_time": 1580899100,
+                        'subscription_discovery': 2
+                    }
+                ]
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "error,code,message",
+    [
+        pytest.param(UnknownError, 0, "Unknown error", id="unknown_error"),
+        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", id="failed_parsing")
+    ],
+)
+async def test_get_subscriptions_failure_generic(plugin, read, write, error, code, message):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_subscriptions"
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_subscriptions.side_effect = error()
+    await plugin.run()
+    plugin.get_subscriptions.assert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "error": {
+                "code": code,
+                "message": message
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_get_subscription_games_success(plugin, read, write):
+    plugin.prepare_subscription_games_context.return_value = async_return_value(5)
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "start_subscription_games_import",
+        "params": {
+            "subscription_names": ["sub_a"]
+        }
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+
+    async def sub_games():
+        games = [
+        SubscriptionGame(game_title="game A", game_id="game_A"),
+        SubscriptionGame(game_title="game B", game_id="game_B", start_time=1548495632),
+        SubscriptionGame(game_title="game C", game_id="game_C", end_time=1548495633),
+        SubscriptionGame(game_title="game D", game_id="game_D", start_time=1548495632, end_time=1548495633),
+       ]
+        yield [game for game in games]
+
+    plugin.get_subscription_games.return_value = sub_games()
+    await plugin.run()
+    plugin.prepare_subscription_games_context.assert_called_with(["sub_a"])
+    plugin.get_subscription_games.assert_called_with("sub_a", 5)
+    plugin.subscription_games_import_complete.asert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_success",
+            "params": {
+                "subscription_name": "sub_a",
+                "subscription_games": [
+                    {
+                        "game_title": "game A",
+                        "game_id": "game_A"
+                    },
+                    {
+                        "game_title": "game B",
+                        "game_id": "game_B",
+                        "start_time": 1548495632
+                    },
+                    {
+                        "game_title": "game C",
+                        "game_id": "game_C",
+                        "end_time": 1548495633
+                    },
+                    {
+                        "game_title": "game D",
+                        "game_id": "game_D",
+                        "start_time": 1548495632,
+                        "end_time": 1548495633
+                    }
+                ]
+            }
+        },
+        {
+            'jsonrpc': '2.0',
+            'method':
+                'subscription_games_partial_import_finished',
+                'params': {
+                    "subscription_name": "sub_a"
+                }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_finished",
+            "params": None
+        }
+    ]
+
+@pytest.mark.asyncio
+async def test_get_subscription_games_success_empty(plugin, read, write):
+    plugin.prepare_subscription_games_context.return_value = async_return_value(5)
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "start_subscription_games_import",
+        "params": {
+            "subscription_names": ["sub_a"]
+        }
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+
+    async def sub_games():
+        yield None
+
+    plugin.get_subscription_games.return_value = sub_games()
+    await plugin.run()
+    plugin.prepare_subscription_games_context.assert_called_with(["sub_a"])
+    plugin.get_subscription_games.assert_called_with("sub_a", 5)
+    plugin.subscription_games_import_complete.asert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_success",
+            "params": {
+                "subscription_name": "sub_a",
+                "subscription_games": None
+            }
+        },
+        {
+            'jsonrpc': '2.0',
+            'method':
+                'subscription_games_partial_import_finished',
+                'params': {
+                    "subscription_name": "sub_a"
+                }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_finished",
+            "params": None
+        }
+    ]
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
+])
+async def test_get_subscription_games_error(exception, code, message, plugin, read, write):
+    plugin.prepare_subscription_games_context.return_value = async_return_value(None)
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "start_subscription_games_import",
+        "params": {
+            "subscription_names": ["sub_a"]
+        }
+    }
+
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_subscription_games.side_effect = exception
+    await plugin.run()
+    plugin.get_subscription_games.assert_called()
+    plugin.subscription_games_import_complete.asert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_failure",
+            "params": {
+                "subscription_name": "sub_a",
+                "error": {
+                    "code": code,
+                    "message": message
+                }
+            }
+        },
+        {
+            'jsonrpc': '2.0',
+            'method':
+                'subscription_games_partial_import_finished',
+                'params': {
+                    "subscription_name": "sub_a"
+                }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_finished",
+            "params": None
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_prepare_get_subscription_games_context_error(plugin, read, write):
+    request_id = "31415"
+    error_details = "Unexpected backend error"
+    error_message, error_code = BackendError().message, BackendError().code
+    plugin.prepare_subscription_games_context.side_effect = BackendError(error_details)
+    request = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "method": "start_subscription_games_import",
+        "params": {"subscription_names": ["sub_a", "sub_b"]}
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    await plugin.run()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": error_code,
+                "message": error_message,
+                "data": error_details
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_import_already_in_progress_error(plugin, read, write):
+    plugin.prepare_subscription_games_context.return_value = async_return_value(None)
+    requests = [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "method": "start_subscription_games_import",
+            "params": {
+                "subscription_names": ["sub_a"]
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "id": "4",
+            "method": "start_subscription_games_import",
+            "params": {
+                "subscription_names": ["sub_a","sub_b"]
+            }
+        }
+    ]
+    read.side_effect = [
+        async_return_value(create_message(requests[0])),
+        async_return_value(create_message(requests[1])),
+        async_return_value(b"", 10)
+    ]
+
+    await plugin.run()
+
+    responses = get_messages(write)
+    assert {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": None
+    } in responses
+    assert {
+        "jsonrpc": "2.0",
+        "id": "4",
+        "error": {
+            "code": 600,
+            "message": "Import already in progress"
+        }
+    } in responses
+

tests/test_user_presence.py

@@ -12,13 +12,13 @@ from tests import create_message, get_messages
 @pytest.mark.asyncio
 async def test_get_user_presence_success(plugin, read, write):
     context = "abc"
-    user_ids = ["666", "13", "42", "69", "22"]
+    user_id_list = ["666", "13", "42", "69", "22"]
     plugin.prepare_user_presence_context.return_value = async_return_value(context)
     request = {
         "jsonrpc": "2.0",
         "id": "11",
         "method": "start_user_presence_import",
-        "params": {"user_ids": user_ids}
+        "params": {"user_id_list": user_id_list}
     }
     read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
     plugin.get_user_presence.side_effect = [
@@ -60,7 +60,7 @@ async def test_get_user_presence_success(plugin, read, write):
     ]
     await plugin.run()
     plugin.get_user_presence.assert_has_calls([
-        call(user_id, context) for user_id in user_ids
+        call(user_id, context) for user_id in user_id_list
     ])
     plugin.user_presence_import_complete.assert_called_once_with()
 
@@ -151,7 +151,7 @@ async def test_get_user_presence_error(exception, code, message, plugin, read, w
         "jsonrpc": "2.0",
         "id": request_id,
         "method": "start_user_presence_import",
-        "params": {"user_ids": [user_id]}
+        "params": {"user_id_list": [user_id]}
     }
     read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
     plugin.get_user_presence.side_effect = exception
@@ -192,7 +192,7 @@ async def test_prepare_get_user_presence_context_error(plugin, read, write):
         "jsonrpc": "2.0",
         "id": request_id,
         "method": "start_user_presence_import",
-        "params": {"user_ids": ["6"]}
+        "params": {"user_id_list": ["6"]}
     }
     read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
     await plugin.run()
@@ -218,7 +218,7 @@ async def test_import_already_in_progress_error(plugin, read, write):
             "id": "3",
             "method": "start_user_presence_import",
             "params": {
-                "user_ids": ["42"]
+                "user_id_list": ["42"]
             }
         },
         {
@@ -226,7 +226,7 @@ async def test_import_already_in_progress_error(plugin, read, write):
             "id": "4",
             "method": "start_user_presence_import",
             "params": {
-                "user_ids": ["666"]
+                "user_id_list": ["666"]
             }
         }
     ]