Merge pull request #343 from digital-asset/python-daml-2-auth-compat

python: Miscellaneous fixes to improve compatibility with Daml 2 ledgers running behind auth.

Author: da-tanabe

.circleci/install-daml

@@ -8,7 +8,7 @@ function install {
         curl -sSL https://get.daml.com/ | sh
         link
     fi
-    daml install 2.0.0
+    daml install 2.2.0
     daml install 1.18.1
 }
 

VERSION

@@ -1 +1 @@
-7.7.5
+7.7.6

_build/daml-connect/daml-connect.conf

@@ -3,7 +3,7 @@
 
 [tool.poetry]
 name = "dazl"
-version = "7.7.5"
+version = "7.7.6"
 description = "high-level Ledger API client for Daml ledgers"
 license = "Apache-2.0"
 authors = ["Davin K. Tanabe <davin.tanabe@digitalasset.com>"]

pyproject.toml

@@ -0,0 +1,43 @@
+# Copyright (c) 2017-2022 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+from asyncio import sleep
+from datetime import datetime, timedelta
+from typing import Awaitable, Callable, TypeVar
+
+from grpc import RpcError, StatusCode
+
+T = TypeVar("T")
+
+DEFAULT_TIMEOUT = timedelta(minutes=1)
+
+
+def is_retryable_exception(ex: Exception) -> bool:
+    if not isinstance(ex, RpcError):
+        return False
+
+    # TODO: Expand on these categories as documented here:
+    #  https://docs.daml.com/app-dev/grpc/error-codes.html
+    return ex.code() == StatusCode.FAILED_PRECONDITION and ex.details().startswith(
+        "PARTY_ALLOCATION_WITHOUT_CONNECTED_DOMAIN"
+    )
+
+
+async def retry(
+    fn: Callable[[], Awaitable[T]],
+    *,
+    retry_safe_ex: Callable[[Exception], bool] = is_retryable_exception,
+    timeout: timedelta = DEFAULT_TIMEOUT
+) -> T:
+    a, b = 0, 1
+    start = datetime.utcnow()
+    while True:
+        try:
+            return await fn()
+        except Exception as ex:
+            if (datetime.now() - start) <= timeout and retry_safe_ex(ex):
+                # retry in increasing intervals according to the Fibonacci sequence;
+                # exponential backoff generally makes us wait too long
+                a, b = b, a + b
+                await sleep(a)
+            else:
+                raise

python/dazl/ledger/_retry.py

@@ -247,9 +247,9 @@ def token(self, value: str) -> None:
 
         v1_claims = claims.get(DamlLedgerApiNamespace)
         if "daml_ledger_api" in claims.get("scope", "").split(" "):
-            # "scope": "daml_ledegr_api" is present, which makes it a Daml V2 token
+            # "scope": "daml_ledger_api" is present, which makes it a Daml V2 token
             self._ledger_id = None
-            self._application_name = None
+            self._application_name = claims.get("sub")
             self._token_version = 2
 
         elif v1_claims is not None:
@@ -266,7 +266,7 @@ def token(self, value: str) -> None:
         else:
             # we're not _entirely_ sure what kind of token it is; assume it's 2
             self._ledger_id = None
-            self._application_name = None
+            self._application_name = claims.get("sub")
             self._token_version = 2
 
     def _set(self, *, read_as: Collection[Party], act_as: Collection[Party], admin: bool):

python/dazl/ledger/config/access.py

@@ -33,6 +33,7 @@
 from ...prim import ContractData, ContractId, Party, datetime_to_timestamp, to_parties
 from ...query import Filter, Queries, Query, parse_query
 from .._offsets import END, End, LedgerOffsetRange, from_offset_until_forever
+from .._retry import retry
 from ..api_types import (
     ActAs,
     Admin,
@@ -50,7 +51,7 @@
     Version,
 )
 from ..config import Config
-from ..config.access import PropertyBasedAccessConfig, TokenBasedAccessConfig
+from ..config.access import TokenBasedAccessConfig
 from ..errors import ProtocolWarning, _allow_cancel, _translate_exceptions
 from .channel import create_channel
 from .codec_aio import Codec
@@ -110,8 +111,10 @@ async def open(self) -> None:
                 for right in await self.list_user_rights():
                     if right == Admin:
                         admin = True
-                    elif isinstance(right, (ReadAs, ActAs)):
+                    elif isinstance(right, ReadAs):
                         read_as.append(right.party)
+                    elif isinstance(right, ActAs):
+                        act_as.append(right.party)
 
                 # noinspection PyProtectedMember
                 cast(TokenBasedAccessConfig, self._config.access)._set(
@@ -512,7 +515,7 @@ def _submit_and_wait_request(
         # this is support for versions of Daml Connect prior to 1.9.0
         act_as = meta.act_as
         if act_as is not None:
-            act_as_party = act_as[0]
+            act_as_party = act_as[0] if act_as else None
         else:
             raise ValueError("current access rights do not include any act-as parties")
 
@@ -748,7 +751,8 @@ async def allocate_party(
             party_id_hint=Party(identifier_hint) if identifier_hint else None,
             display_name=display_name,
         )
-        response = await stub.AllocateParty(request)
+
+        response = await retry(lambda: stub.AllocateParty(request))
         return Codec.decode_party_info(response.party_details)
 
     async def list_known_parties(self) -> Sequence[PartyInfo]:

python/dazl/ledger/grpc/conn_aio.py

@@ -1,12 +1,20 @@
 # Copyright (c) 2017-2022 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 import os
+import sys
 from typing import Sequence, Union
 
-__all__ = ["daml_sdk_versions"]
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
 
+__all__ = ["daml_sdk_versions", "known_version_1", "known_version_2", "known_versions"]
 
-known_versions = ("1.18.1", "2.0.0")
+
+known_version_1: Final = "1.18.1"
+known_version_2: Final = "2.2.0"
+known_versions: Final = (known_version_1, known_version_2)
 
 
 def daml_sdk_versions(

python/tests/unit/config.py

@@ -3,19 +3,45 @@
 from asyncio import sleep
 
 from dazl import connect, testing
+from dazl.ledger import ActAs, Admin, User
 from dazl.ledger.config.access import DamlLedgerApiNamespace
 import pytest
 
-from .config import daml_sdk_versions
+from .config import daml_sdk_versions, known_version_2
+from .dars import PostOffice
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("daml_sdk_version", daml_sdk_versions())
 async def test_v1_token(daml_sdk_version):
-    with testing.sandbox(version=daml_sdk_version, use_auth=True, ledger_id="sandbox") as sandbox:
+    async with testing.sandbox(
+        version=daml_sdk_version, use_auth=True, ledger_id="sandbox"
+    ) as sandbox:
         token = sandbox.sign_token({DamlLedgerApiNamespace: {"admin": True, "ledgerId": "sandbox"}})
         async with connect(url=sandbox.url, oauth_token=token) as conn:
             # the result of this call is not particularly interesting;
             # we just need to make sure it doesn't crash
             await conn.list_package_ids()
             await sleep(1)
+
+
+@pytest.mark.asyncio
+async def test_v2_token(sandbox_v2):
+    async with testing.sandbox(
+        version=known_version_2, use_auth=True, ledger_id="sandbox"
+    ) as sandbox:
+        # use an anonymous admin Daml V1 token to bootstrap users, because that's unfortunately
+        # the only way
+        token = sandbox.sign_token({DamlLedgerApiNamespace: {"admin": True, "ledgerId": "sandbox"}})
+        async with connect(url=sandbox.url, oauth_token=token) as conn:
+            p = await conn.allocate_party(identifier_hint="alice", display_name="alice")
+            await conn.create_user(User("alice", p.party), [Admin, ActAs(p.party)])
+            await conn.upload_package(PostOffice.read_bytes())
+
+        token = sandbox.sign_token({"sub": "alice", "scope": "daml_ledger_api"})
+        async with connect(url=sandbox.url, oauth_token=token) as conn:
+            # make sure we have admin rights
+            await conn.allocate_party()
+
+            # make sure we can create contracts
+            await conn.create("Main:PostmanRole", {"postman": p.party})