boxd 0.3.0.dev1040__tar.gz → 0.3.0.dev1041__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {boxd-0.3.0.dev1040/src/boxd.egg-info → boxd-0.3.0.dev1041}/PKG-INFO +1 -1
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/pyproject.toml +1 -1
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_client.py +10 -4
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_regions.py +174 -9
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_transport.py +22 -11
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_urls.py +35 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041/src/boxd.egg-info}/PKG-INFO +1 -1
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_raw_key.py +51 -3
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_regions.py +359 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_urls.py +44 -1
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/LICENSE +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/README.md +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/setup.cfg +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/__init__.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_credentials.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_generated/__init__.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_generated/api_pb2.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_generated/api_pb2_grpc.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_mappers.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_requests.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_streaming.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/_version_check.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/errors.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/models.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/py.typed +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/__init__.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/account.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/credentials.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/disks.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/domains.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/fs.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/machines.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/orgs.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/regions.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/snapshots.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/teams.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/resources/vars.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd/spec.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd.egg-info/SOURCES.txt +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd.egg-info/dependency_links.txt +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd.egg-info/requires.txt +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/src/boxd.egg-info/top_level.txt +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_create_in_one_call.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_credentials.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_delete_self.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_fs.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_mappers.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_namespaces.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_python_versions.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_requests.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_spec.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_streaming.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_transport.py +0 -0
- {boxd-0.3.0.dev1040 → boxd-0.3.0.dev1041}/tests/test_version_check.py +0 -0
|
@@ -72,16 +72,19 @@ class Boxd:
|
|
|
72
72
|
exchange_url=exchange_url_for(resolved or DEFAULT_BASE_URL),
|
|
73
73
|
)
|
|
74
74
|
|
|
75
|
-
def connect(url: str | None) -> SyncTransport:
|
|
75
|
+
def connect(url: str | None, *, derived: bool = False) -> SyncTransport:
|
|
76
76
|
# Every region's endpoint, and home's, share the one credential.
|
|
77
77
|
return SyncTransport(
|
|
78
78
|
base_url=url,
|
|
79
79
|
credentials=credentials,
|
|
80
80
|
timeout=timeout,
|
|
81
81
|
max_retries=max_retries,
|
|
82
|
+
derived=derived,
|
|
82
83
|
)
|
|
83
84
|
|
|
84
|
-
self._transport = SyncRouter(
|
|
85
|
+
self._transport = SyncRouter(
|
|
86
|
+
connect(resolved), region=region, connect=connect, credentials=credentials
|
|
87
|
+
)
|
|
85
88
|
|
|
86
89
|
self.machines = Machines(self._transport)
|
|
87
90
|
self.snapshots = Snapshots(self._transport)
|
|
@@ -143,16 +146,19 @@ class AsyncBoxd:
|
|
|
143
146
|
exchange_url=exchange_url_for(resolved or DEFAULT_BASE_URL),
|
|
144
147
|
)
|
|
145
148
|
|
|
146
|
-
def connect(url: str | None) -> AsyncTransport:
|
|
149
|
+
def connect(url: str | None, *, derived: bool = False) -> AsyncTransport:
|
|
147
150
|
# Every region's endpoint, and home's, share the one credential.
|
|
148
151
|
return AsyncTransport(
|
|
149
152
|
base_url=url,
|
|
150
153
|
credentials=credentials,
|
|
151
154
|
timeout=timeout,
|
|
152
155
|
max_retries=max_retries,
|
|
156
|
+
derived=derived,
|
|
153
157
|
)
|
|
154
158
|
|
|
155
|
-
self._transport = AsyncRouter(
|
|
159
|
+
self._transport = AsyncRouter(
|
|
160
|
+
connect(resolved), region=region, connect=connect, credentials=credentials
|
|
161
|
+
)
|
|
156
162
|
|
|
157
163
|
self.machines = AsyncMachines(self._transport)
|
|
158
164
|
self.snapshots = AsyncSnapshots(self._transport)
|
|
@@ -17,6 +17,23 @@ itself, but a region holds only the orgs that enabled it, so the default it
|
|
|
17
17
|
would pick can be another org. A region other than home is sent the org
|
|
18
18
|
home's ``ListRegions`` answer names instead.
|
|
19
19
|
|
|
20
|
+
Direct mode skips home. Asking it first costs a round trip to home before the
|
|
21
|
+
first call to a region, which from far away is most of the wait. With an API
|
|
22
|
+
key sent as itself (``_credentials.py``) and a call that names no org, the
|
|
23
|
+
call needs neither thing that answer gives: the key belongs to one org, which
|
|
24
|
+
the region applies, and the region checks the key itself. So such a call goes
|
|
25
|
+
straight to the region's name derived from home's, ``<region>.<home host>`` on
|
|
26
|
+
home's scheme and port (``_urls.region_base_url``), sent as it is. When it
|
|
27
|
+
fails there before reaching a handler (a connection error, or the region
|
|
28
|
+
refusing the key: "API key not recognized in region ...", or as a server from
|
|
29
|
+
before raw keys does), the region is asked through home for the rest of the
|
|
30
|
+
client's life and the call is sent again that way, which is also where an
|
|
31
|
+
unknown or not-enabled region is reported. Only a unary call is sent again,
|
|
32
|
+
so a stream (or a streamed request) goes to the derived name only once a
|
|
33
|
+
unary call there was answered. Calls that name an org, ``"all"`` lists,
|
|
34
|
+
tokens, in-machine credentials, a key that is exchanged, and a home whose
|
|
35
|
+
host is an IP address, ``localhost`` or one label keep asking home.
|
|
36
|
+
|
|
20
37
|
The router has the transport's surface (``call``, ``server_stream``,
|
|
21
38
|
``bidi``, ``close``), so the resource namespaces only pass ``region=``
|
|
22
39
|
through and never see an endpoint.
|
|
@@ -31,8 +48,11 @@ from typing import Any, Callable
|
|
|
31
48
|
|
|
32
49
|
from . import _mappers as m
|
|
33
50
|
from ._generated import api_pb2
|
|
51
|
+
from ._transport import refuses_raw_key
|
|
52
|
+
from ._urls import raw_key_allowed, region_base_url
|
|
34
53
|
from .errors import (
|
|
35
54
|
APIConnectionError,
|
|
55
|
+
AuthenticationError,
|
|
36
56
|
BoxdError,
|
|
37
57
|
MachineFilesystemError,
|
|
38
58
|
NotFoundError,
|
|
@@ -282,6 +302,30 @@ def _attach(err: NotFoundError, kind: str, name: str, found) -> None:
|
|
|
282
302
|
err.args = (err.message, *err.args[1:])
|
|
283
303
|
|
|
284
304
|
|
|
305
|
+
# The start of a region's refusal of a key it doesn't hold: the key was
|
|
306
|
+
# deleted, or its org doesn't use the region.
|
|
307
|
+
_KEY_NOT_IN_REGION = "API key not recognized in region"
|
|
308
|
+
|
|
309
|
+
|
|
310
|
+
def _missed_region(err: BoxdError) -> bool:
|
|
311
|
+
"""Whether a call sent to a region's derived name never reached a handler
|
|
312
|
+
there, so it can be sent again through home: the name led to no server (a
|
|
313
|
+
connection error: DNS, connect, TLS), the region doesn't hold the key, or
|
|
314
|
+
it refuses a key sent as itself as a server from before raw keys does."""
|
|
315
|
+
if isinstance(err, APIConnectionError):
|
|
316
|
+
return True
|
|
317
|
+
return (
|
|
318
|
+
isinstance(err, AuthenticationError)
|
|
319
|
+
and err.code == "unauthenticated"
|
|
320
|
+
and (err.message.startswith(_KEY_NOT_IN_REGION) or refuses_raw_key(err.message))
|
|
321
|
+
)
|
|
322
|
+
|
|
323
|
+
|
|
324
|
+
def _one_shot(request) -> bool:
|
|
325
|
+
"""A stream's request, or a client-streamed one: never sent twice."""
|
|
326
|
+
return not hasattr(request, "DESCRIPTOR")
|
|
327
|
+
|
|
328
|
+
|
|
285
329
|
def _worth_looking(err: BoxdError, lookup: tuple[str, str] | None) -> bool:
|
|
286
330
|
# A file the machine lacks, or a region that doesn't exist, is not a
|
|
287
331
|
# machine somewhere else.
|
|
@@ -293,16 +337,34 @@ def _worth_looking(err: BoxdError, lookup: tuple[str, str] | None) -> bool:
|
|
|
293
337
|
|
|
294
338
|
|
|
295
339
|
class _RouterBase:
|
|
296
|
-
def __init__(
|
|
340
|
+
def __init__(
|
|
341
|
+
self,
|
|
342
|
+
home,
|
|
343
|
+
*,
|
|
344
|
+
region: str | None,
|
|
345
|
+
connect: Callable[..., Any],
|
|
346
|
+
credentials=None,
|
|
347
|
+
):
|
|
348
|
+
"""`connect(url)` makes a transport for a region's endpoint;
|
|
349
|
+
`connect(url, derived=True)` one for its name derived from home's.
|
|
350
|
+
`credentials` is the client's, for direct mode; without them every
|
|
351
|
+
call to a region asks home first."""
|
|
297
352
|
self._home = home
|
|
298
353
|
self._region = resolve_region(region)
|
|
299
354
|
self._connect = connect
|
|
355
|
+
self._credentials = credentials
|
|
300
356
|
# ListRegions answers, by the org they were asked for ("" = default).
|
|
301
357
|
self._listings: dict[str, Any] = {}
|
|
302
358
|
# Region transports, by API endpoint. Home's region uses `_home`.
|
|
303
359
|
self._transports: dict[str, Any] = {}
|
|
304
360
|
# Console origins, by region id, once a region has been reached.
|
|
305
361
|
self._consoles: dict[str, str] = {}
|
|
362
|
+
# Direct mode, by region id: "confirmed" once a unary call sent to the
|
|
363
|
+
# derived name was answered; "off", for the client's life, once one
|
|
364
|
+
# never reached a handler there. Absent: not tried yet.
|
|
365
|
+
self._direct: dict[str, str] = {}
|
|
366
|
+
# Transports to regions' derived names, by region id.
|
|
367
|
+
self._derived: dict[str, Any] = {}
|
|
306
368
|
|
|
307
369
|
@property
|
|
308
370
|
def region(self) -> str | None:
|
|
@@ -332,6 +394,41 @@ class _RouterBase:
|
|
|
332
394
|
raise ValueError('region="all" is for list() calls only')
|
|
333
395
|
return target
|
|
334
396
|
|
|
397
|
+
def _direct_route(self, method: str, request, region: str | None):
|
|
398
|
+
"""Where a call goes in direct mode: ``(region, transport)`` to the
|
|
399
|
+
region's derived name, or None when direct mode doesn't apply (see the
|
|
400
|
+
module doc). The call is sent as it is: no org is filled in."""
|
|
401
|
+
target = self._target(method, region)
|
|
402
|
+
if self._credentials is None or target is None or _org_of(request):
|
|
403
|
+
return None
|
|
404
|
+
if self._direct.get(target) == "off":
|
|
405
|
+
return None
|
|
406
|
+
url = region_base_url(self._home.base_url, target)
|
|
407
|
+
if url is None:
|
|
408
|
+
return None
|
|
409
|
+
if self._credentials.raw_key(allowed=raw_key_allowed(url)) is None:
|
|
410
|
+
return None
|
|
411
|
+
transport = self._derived.get(target)
|
|
412
|
+
if transport is None:
|
|
413
|
+
transport = self._connect(url, derived=True)
|
|
414
|
+
self._derived[target] = transport
|
|
415
|
+
return target, transport
|
|
416
|
+
|
|
417
|
+
def _confirmed(self, region: str | None):
|
|
418
|
+
"""The transport to a region's derived name, once a unary call there
|
|
419
|
+
was answered; None before that, or after it fell back."""
|
|
420
|
+
if region is None or self._direct.get(region) != "confirmed":
|
|
421
|
+
return None
|
|
422
|
+
return self._derived.get(region)
|
|
423
|
+
|
|
424
|
+
def _confirm(self, region: str, transport) -> None:
|
|
425
|
+
if self._direct.get(region) == "off":
|
|
426
|
+
return
|
|
427
|
+
self._direct[region] = "confirmed"
|
|
428
|
+
# Its console is named like its API (`app.<region>.<zone>`), so home
|
|
429
|
+
# isn't asked for it either.
|
|
430
|
+
self._consoles[region] = transport.console_origin
|
|
431
|
+
|
|
335
432
|
def _remember(self, request, response) -> None:
|
|
336
433
|
# Every ListRegions answer refreshes the directory, whoever asked.
|
|
337
434
|
self._listings[request.org_id] = response
|
|
@@ -402,6 +499,14 @@ class SyncRouter(_RouterBase):
|
|
|
402
499
|
transport, listing = self._resolve(target, _org_of(request))
|
|
403
500
|
return transport, self._regional(transport, listing, request)
|
|
404
501
|
|
|
502
|
+
def _stream_route(self, method: str, request, region: str | None):
|
|
503
|
+
"""`_route` for a call that can't be sent again: a derived name only
|
|
504
|
+
once it is confirmed."""
|
|
505
|
+
confirmed = self._confirmed(self._target(method, region))
|
|
506
|
+
if confirmed is not None:
|
|
507
|
+
return confirmed, request
|
|
508
|
+
return self._route(method, request, region)
|
|
509
|
+
|
|
405
510
|
def _find_elsewhere(self, err, transport, lookup, org) -> None:
|
|
406
511
|
if not _worth_looking(err, lookup):
|
|
407
512
|
return
|
|
@@ -420,14 +525,40 @@ class SyncRouter(_RouterBase):
|
|
|
420
525
|
) -> NotFoundError:
|
|
421
526
|
"""Look up elsewhere a not-found the SDK raises itself (an answer that
|
|
422
527
|
carries nothing rather than a not-found status). Returns `err`."""
|
|
423
|
-
|
|
528
|
+
direct = self._direct_route(method, request, region)
|
|
529
|
+
if direct is not None:
|
|
530
|
+
transport = direct[1]
|
|
531
|
+
else:
|
|
532
|
+
transport, _ = self._route(method, request, region)
|
|
424
533
|
self._find_elsewhere(
|
|
425
534
|
err, transport, _lookup_of(method, request), _org_of(request)
|
|
426
535
|
)
|
|
427
536
|
return err
|
|
428
537
|
|
|
429
538
|
def call(self, method: str, request, *, region: str | None = None):
|
|
539
|
+
if _one_shot(request):
|
|
540
|
+
transport, sent = self._stream_route(method, request, region)
|
|
541
|
+
return self._send(transport, method, sent, request)
|
|
542
|
+
direct = self._direct_route(method, request, region)
|
|
543
|
+
if direct is not None:
|
|
544
|
+
target, transport = direct
|
|
545
|
+
try:
|
|
546
|
+
response = self._send(transport, method, request, request)
|
|
547
|
+
except BoxdError as err:
|
|
548
|
+
if not _missed_region(err):
|
|
549
|
+
raise
|
|
550
|
+
# Refused before any handler ran: ask home where the region
|
|
551
|
+
# is, from now on, and send the call there.
|
|
552
|
+
self._direct[target] = "off"
|
|
553
|
+
else:
|
|
554
|
+
self._confirm(target, transport)
|
|
555
|
+
return response
|
|
430
556
|
transport, sent = self._route(method, request, region)
|
|
557
|
+
return self._send(transport, method, sent, request)
|
|
558
|
+
|
|
559
|
+
def _send(self, transport, method: str, sent, request):
|
|
560
|
+
"""One call on `transport`: `sent` is what it is sent, `request` what
|
|
561
|
+
the caller asked for."""
|
|
431
562
|
try:
|
|
432
563
|
response = transport.call(method, sent)
|
|
433
564
|
except NotFoundError as err:
|
|
@@ -440,7 +571,7 @@ class SyncRouter(_RouterBase):
|
|
|
440
571
|
return response
|
|
441
572
|
|
|
442
573
|
def server_stream(self, method: str, request, *, region: str | None = None):
|
|
443
|
-
transport, sent = self.
|
|
574
|
+
transport, sent = self._stream_route(method, request, region)
|
|
444
575
|
lookup = _lookup_of(method, request)
|
|
445
576
|
return _FindingStream(
|
|
446
577
|
transport.server_stream(method, sent),
|
|
@@ -458,7 +589,7 @@ class SyncRouter(_RouterBase):
|
|
|
458
589
|
):
|
|
459
590
|
"""`machine` names the machine the stream is about (`Exec`), for the
|
|
460
591
|
hint on a not-found."""
|
|
461
|
-
transport, _ = self.
|
|
592
|
+
transport, _ = self._stream_route(method, None, region)
|
|
462
593
|
lookup = ("machine", machine) if machine else None
|
|
463
594
|
return _FindingStream(
|
|
464
595
|
transport.bidi(method, requests, timeout=timeout),
|
|
@@ -497,9 +628,10 @@ class SyncRouter(_RouterBase):
|
|
|
497
628
|
|
|
498
629
|
def close(self) -> None:
|
|
499
630
|
self._home.close()
|
|
500
|
-
for transport in self._transports.values():
|
|
631
|
+
for transport in [*self._transports.values(), *self._derived.values()]:
|
|
501
632
|
transport.close()
|
|
502
633
|
self._transports.clear()
|
|
634
|
+
self._derived.clear()
|
|
503
635
|
|
|
504
636
|
|
|
505
637
|
class AsyncRouter(_RouterBase):
|
|
@@ -532,6 +664,13 @@ class AsyncRouter(_RouterBase):
|
|
|
532
664
|
transport, listing = await self._resolve(target, _org_of(request))
|
|
533
665
|
return transport, self._regional(transport, listing, request)
|
|
534
666
|
|
|
667
|
+
async def _stream_route(self, method: str, request, region: str | None):
|
|
668
|
+
"""Async twin of :meth:`SyncRouter._stream_route`."""
|
|
669
|
+
confirmed = self._confirmed(self._target(method, region))
|
|
670
|
+
if confirmed is not None:
|
|
671
|
+
return confirmed, request
|
|
672
|
+
return await self._route(method, request, region)
|
|
673
|
+
|
|
535
674
|
async def _find_elsewhere(self, err, transport, lookup, org) -> None:
|
|
536
675
|
if not _worth_looking(err, lookup):
|
|
537
676
|
return
|
|
@@ -549,14 +688,39 @@ class AsyncRouter(_RouterBase):
|
|
|
549
688
|
self, err: NotFoundError, method: str, request, *, region: str | None = None
|
|
550
689
|
) -> NotFoundError:
|
|
551
690
|
"""Async twin of :meth:`SyncRouter.find_elsewhere`."""
|
|
552
|
-
|
|
691
|
+
direct = self._direct_route(method, request, region)
|
|
692
|
+
if direct is not None:
|
|
693
|
+
transport = direct[1]
|
|
694
|
+
else:
|
|
695
|
+
transport, _ = await self._route(method, request, region)
|
|
553
696
|
await self._find_elsewhere(
|
|
554
697
|
err, transport, _lookup_of(method, request), _org_of(request)
|
|
555
698
|
)
|
|
556
699
|
return err
|
|
557
700
|
|
|
558
701
|
async def call(self, method: str, request, *, region: str | None = None):
|
|
702
|
+
if _one_shot(request):
|
|
703
|
+
transport, sent = await self._stream_route(method, request, region)
|
|
704
|
+
return await self._send(transport, method, sent, request)
|
|
705
|
+
direct = self._direct_route(method, request, region)
|
|
706
|
+
if direct is not None:
|
|
707
|
+
target, transport = direct
|
|
708
|
+
try:
|
|
709
|
+
response = await self._send(transport, method, request, request)
|
|
710
|
+
except BoxdError as err:
|
|
711
|
+
if not _missed_region(err):
|
|
712
|
+
raise
|
|
713
|
+
# Refused before any handler ran: ask home where the region
|
|
714
|
+
# is, from now on, and send the call there.
|
|
715
|
+
self._direct[target] = "off"
|
|
716
|
+
else:
|
|
717
|
+
self._confirm(target, transport)
|
|
718
|
+
return response
|
|
559
719
|
transport, sent = await self._route(method, request, region)
|
|
720
|
+
return await self._send(transport, method, sent, request)
|
|
721
|
+
|
|
722
|
+
async def _send(self, transport, method: str, sent, request):
|
|
723
|
+
"""Async twin of :meth:`SyncRouter._send`."""
|
|
560
724
|
try:
|
|
561
725
|
response = await transport.call(method, sent)
|
|
562
726
|
except NotFoundError as err:
|
|
@@ -569,7 +733,7 @@ class AsyncRouter(_RouterBase):
|
|
|
569
733
|
return response
|
|
570
734
|
|
|
571
735
|
async def server_stream(self, method: str, request, *, region: str | None = None):
|
|
572
|
-
transport, sent = await self.
|
|
736
|
+
transport, sent = await self._stream_route(method, request, region)
|
|
573
737
|
lookup = _lookup_of(method, request)
|
|
574
738
|
return _AsyncFindingStream(
|
|
575
739
|
await transport.server_stream(method, sent),
|
|
@@ -585,7 +749,7 @@ class AsyncRouter(_RouterBase):
|
|
|
585
749
|
region: str | None = None,
|
|
586
750
|
machine: str | None = None,
|
|
587
751
|
):
|
|
588
|
-
transport, _ = await self.
|
|
752
|
+
transport, _ = await self._stream_route(method, None, region)
|
|
589
753
|
lookup = ("machine", machine) if machine else None
|
|
590
754
|
return _AsyncFindingStream(
|
|
591
755
|
await transport.bidi(method, requests, timeout=timeout),
|
|
@@ -619,9 +783,10 @@ class AsyncRouter(_RouterBase):
|
|
|
619
783
|
|
|
620
784
|
async def close(self) -> None:
|
|
621
785
|
await self._home.close()
|
|
622
|
-
for transport in self._transports.values():
|
|
786
|
+
for transport in [*self._transports.values(), *self._derived.values()]:
|
|
623
787
|
await transport.close()
|
|
624
788
|
self._transports.clear()
|
|
789
|
+
self._derived.clear()
|
|
625
790
|
|
|
626
791
|
|
|
627
792
|
class _FindingStream:
|
|
@@ -34,19 +34,23 @@ _CHANNEL_OPTIONS = [
|
|
|
34
34
|
]
|
|
35
35
|
|
|
36
36
|
|
|
37
|
+
def refuses_raw_key(details: str) -> bool:
|
|
38
|
+
"""Whether an `unauthenticated` answer to a call that carried the API key
|
|
39
|
+
itself means that server can't take a key that way, so the key is
|
|
40
|
+
exchanged: a server from before raw keys reads it as a malformed session
|
|
41
|
+
token ("invalid token: ..."), and one that takes keys refuses one sent
|
|
42
|
+
without TLS from a peer it doesn't see as loopback ("... accepted over TLS
|
|
43
|
+
only")."""
|
|
44
|
+
return details.startswith("invalid token") or "accepted over TLS only" in details
|
|
45
|
+
|
|
46
|
+
|
|
37
47
|
def _refuses_raw_key(err: grpc.RpcError) -> bool:
|
|
38
|
-
"""
|
|
39
|
-
means that server can't take a key that way, so the key is exchanged: a
|
|
40
|
-
server from before raw keys reads it as a malformed session token
|
|
41
|
-
("invalid token: ..."), and one that takes keys refuses one sent without
|
|
42
|
-
TLS from a peer it doesn't see as loopback ("... accepted over TLS only")."""
|
|
48
|
+
""":func:`refuses_raw_key` on a gRPC error."""
|
|
43
49
|
try:
|
|
44
50
|
code, details = err.code(), err.details() or ""
|
|
45
51
|
except Exception:
|
|
46
52
|
return False
|
|
47
|
-
return code == grpc.StatusCode.UNAUTHENTICATED and (
|
|
48
|
-
details.startswith("invalid token") or "accepted over TLS only" in details
|
|
49
|
-
)
|
|
53
|
+
return code == grpc.StatusCode.UNAUTHENTICATED and refuses_raw_key(details)
|
|
50
54
|
|
|
51
55
|
|
|
52
56
|
def _streamed(request) -> bool:
|
|
@@ -62,11 +66,18 @@ class _TransportBase:
|
|
|
62
66
|
credentials,
|
|
63
67
|
timeout: float,
|
|
64
68
|
max_retries: int,
|
|
69
|
+
derived: bool = False,
|
|
65
70
|
) -> None:
|
|
66
71
|
self._explicit_base_url = base_url
|
|
67
72
|
self._credentials = credentials
|
|
68
73
|
self._timeout = timeout
|
|
69
|
-
|
|
74
|
+
# `derived`: the base URL is a region's name derived from home's, not
|
|
75
|
+
# one home named (`_regions.py`, direct mode). A failure here goes back
|
|
76
|
+
# to the router, which asks home and sends the call again: no retries
|
|
77
|
+
# here, and a refusal of the API key itself is raised instead of
|
|
78
|
+
# answered by exchanging it.
|
|
79
|
+
self._derived = derived
|
|
80
|
+
self._max_retries = 0 if derived else max_retries
|
|
70
81
|
self._channel = None
|
|
71
82
|
self._stub: api_pb2_grpc.BoxdApiStub | None = None
|
|
72
83
|
# This endpoint has taken the API key itself (a call carrying it worked).
|
|
@@ -175,7 +186,7 @@ class SyncTransport(_TransportBase):
|
|
|
175
186
|
# Refused before any handler ran: nothing happened, so
|
|
176
187
|
# the call goes again on the exchanged session.
|
|
177
188
|
self._credentials.raw_key_refused()
|
|
178
|
-
if not _streamed(request):
|
|
189
|
+
if not _streamed(request) and not self._derived:
|
|
179
190
|
continue
|
|
180
191
|
if self._should_retry(e, attempt, request):
|
|
181
192
|
time.sleep(self._backoff(attempt))
|
|
@@ -271,7 +282,7 @@ class AsyncTransport(_TransportBase):
|
|
|
271
282
|
# Refused before any handler ran: nothing happened, so
|
|
272
283
|
# the call goes again on the exchanged session.
|
|
273
284
|
self._credentials.raw_key_refused()
|
|
274
|
-
if not _streamed(request):
|
|
285
|
+
if not _streamed(request) and not self._derived:
|
|
275
286
|
continue
|
|
276
287
|
if self._should_retry(e, attempt, request):
|
|
277
288
|
await asyncio.sleep(self._backoff(attempt))
|
|
@@ -9,6 +9,7 @@ from __future__ import annotations
|
|
|
9
9
|
|
|
10
10
|
import ipaddress
|
|
11
11
|
import os
|
|
12
|
+
import re
|
|
12
13
|
from typing import NamedTuple
|
|
13
14
|
|
|
14
15
|
# gRPC front door, over TLS. The proxy still accepts plain HTTP/2 on the same
|
|
@@ -117,6 +118,40 @@ def raw_key_allowed(base_url: str) -> bool:
|
|
|
117
118
|
return endpoint.use_tls or is_loopback_target(endpoint.target)
|
|
118
119
|
|
|
119
120
|
|
|
121
|
+
_DNS_LABEL = re.compile(r"[a-z0-9]([a-z0-9-]*[a-z0-9])?")
|
|
122
|
+
_PORT = re.compile(r"[0-9]+")
|
|
123
|
+
|
|
124
|
+
|
|
125
|
+
def region_base_url(home_base_url: str, region: str) -> str | None:
|
|
126
|
+
"""A region's API endpoint by the platform's naming: ``<region>.<host>`` on
|
|
127
|
+
the home base URL's scheme and port (home ``https://boxd.sh:9443`` → nyc
|
|
128
|
+
``https://nyc.boxd.sh:9443``).
|
|
129
|
+
|
|
130
|
+
None when the home host is not a DNS name a region can be put in front of
|
|
131
|
+
(an IP literal, ``localhost``, a name of one label), when the base URL has
|
|
132
|
+
a path, or when `region` is not one label.
|
|
133
|
+
"""
|
|
134
|
+
if not _DNS_LABEL.fullmatch(region):
|
|
135
|
+
return None
|
|
136
|
+
url = home_base_url.strip().rstrip("/")
|
|
137
|
+
scheme = next((s for s in ("https://", "http://") if url.startswith(s)), "")
|
|
138
|
+
authority = url[len(scheme) :]
|
|
139
|
+
if "/" in authority or authority.startswith("["):
|
|
140
|
+
return None
|
|
141
|
+
host, sep, port = authority.partition(":")
|
|
142
|
+
host = host.lower()
|
|
143
|
+
labels = host.split(".")
|
|
144
|
+
dns_name = (
|
|
145
|
+
len(labels) > 1
|
|
146
|
+
and all(_DNS_LABEL.fullmatch(label) for label in labels)
|
|
147
|
+
and not labels[-1].isdigit() # a dotted quad, valid or not
|
|
148
|
+
and labels[-1] != "localhost"
|
|
149
|
+
)
|
|
150
|
+
if not dns_name or (sep and not _PORT.fullmatch(port)):
|
|
151
|
+
return None
|
|
152
|
+
return f"{scheme}{region}.{host}{sep}{port}"
|
|
153
|
+
|
|
154
|
+
|
|
120
155
|
def _is_ip(host: str) -> bool:
|
|
121
156
|
try:
|
|
122
157
|
ipaddress.ip_address(host)
|
|
@@ -13,7 +13,7 @@ from boxd._credentials import AsyncCredentials, SyncCredentials
|
|
|
13
13
|
from boxd._generated import api_pb2
|
|
14
14
|
from boxd._transport import AsyncTransport, SyncTransport, _refuses_raw_key
|
|
15
15
|
from boxd._urls import is_loopback_target, raw_key_allowed
|
|
16
|
-
from boxd.errors import AuthenticationError
|
|
16
|
+
from boxd.errors import APIConnectionError, AuthenticationError
|
|
17
17
|
from fakes import FakeMulticallable, FakeRpcError, FakeStub
|
|
18
18
|
|
|
19
19
|
KEY = "bxd_test-key"
|
|
@@ -52,11 +52,19 @@ class Exchanges:
|
|
|
52
52
|
return exchange
|
|
53
53
|
|
|
54
54
|
|
|
55
|
-
def sync_transport(
|
|
55
|
+
def sync_transport(
|
|
56
|
+
stub_methods, *, base_url="http://127.0.0.1:9443", max_retries=0, derived=False
|
|
57
|
+
):
|
|
56
58
|
creds = SyncCredentials(api_key=KEY, token=None, exchange_url=EXCHANGE)
|
|
57
59
|
exchanges = Exchanges()
|
|
58
60
|
creds._exchange = exchanges.sync(creds)
|
|
59
|
-
t = SyncTransport(
|
|
61
|
+
t = SyncTransport(
|
|
62
|
+
base_url=base_url,
|
|
63
|
+
credentials=creds,
|
|
64
|
+
timeout=1.0,
|
|
65
|
+
max_retries=max_retries,
|
|
66
|
+
derived=derived,
|
|
67
|
+
)
|
|
60
68
|
t._stub = FakeStub(**stub_methods)
|
|
61
69
|
return t, exchanges
|
|
62
70
|
|
|
@@ -125,6 +133,27 @@ def test_an_old_servers_refusal_falls_back_to_the_exchange_for_good():
|
|
|
125
133
|
assert exchanges.count == 1
|
|
126
134
|
|
|
127
135
|
|
|
136
|
+
def test_a_regions_derived_name_raises_an_old_servers_refusal():
|
|
137
|
+
# The router asks home instead; every endpoint exchanges from now on.
|
|
138
|
+
get_vm = FakeMulticallable([old_refusal(), api_pb2.GetVmResponse()])
|
|
139
|
+
t, exchanges = sync_transport({"GetVm": get_vm}, derived=True)
|
|
140
|
+
with pytest.raises(AuthenticationError, match="invalid token"):
|
|
141
|
+
t.call("GetVm", REQUEST)
|
|
142
|
+
assert bearers(get_vm) == [f"Bearer {KEY}"]
|
|
143
|
+
assert exchanges.count == 0
|
|
144
|
+
assert t._credentials.raw_key(allowed=True) is None
|
|
145
|
+
|
|
146
|
+
|
|
147
|
+
def test_a_regions_derived_name_is_tried_once(monkeypatch):
|
|
148
|
+
monkeypatch.setattr("boxd._transport.time.sleep", lambda _: None)
|
|
149
|
+
unavailable = FakeRpcError(grpc.StatusCode.UNAVAILABLE, "DNS resolution failed")
|
|
150
|
+
get_vm = FakeMulticallable([unavailable, api_pb2.GetVmResponse()])
|
|
151
|
+
t, _ = sync_transport({"GetVm": get_vm}, max_retries=2, derived=True)
|
|
152
|
+
with pytest.raises(APIConnectionError):
|
|
153
|
+
t.call("GetVm", REQUEST)
|
|
154
|
+
assert get_vm.attempts == 1
|
|
155
|
+
|
|
156
|
+
|
|
128
157
|
def test_plaintext_to_another_host_exchanges_first():
|
|
129
158
|
response = api_pb2.GetVmResponse(vm_id="vm-1")
|
|
130
159
|
get_vm = FakeMulticallable([response])
|
|
@@ -228,6 +257,25 @@ async def test_async_an_old_servers_refusal_falls_back_to_the_exchange():
|
|
|
228
257
|
assert exchanges.count == 1
|
|
229
258
|
|
|
230
259
|
|
|
260
|
+
async def test_async_a_regions_derived_name_raises_an_old_servers_refusal():
|
|
261
|
+
creds = AsyncCredentials(api_key=KEY, token=None, exchange_url=EXCHANGE)
|
|
262
|
+
exchanges = Exchanges()
|
|
263
|
+
creds._exchange = exchanges.aio(creds)
|
|
264
|
+
t = AsyncTransport(
|
|
265
|
+
base_url="https://nyc.example.com:9443",
|
|
266
|
+
credentials=creds,
|
|
267
|
+
timeout=1.0,
|
|
268
|
+
max_retries=2,
|
|
269
|
+
derived=True,
|
|
270
|
+
)
|
|
271
|
+
get_vm = AioMethod([AioRefusal(OLD_REFUSAL), api_pb2.GetVmResponse()])
|
|
272
|
+
t._stub = FakeStub(GetVm=get_vm)
|
|
273
|
+
with pytest.raises(AuthenticationError, match="invalid token"):
|
|
274
|
+
await t.call("GetVm", REQUEST)
|
|
275
|
+
assert bearers(get_vm) == [f"Bearer {KEY}"]
|
|
276
|
+
assert exchanges.count == 0
|
|
277
|
+
|
|
278
|
+
|
|
231
279
|
async def test_async_a_server_that_takes_keys_gets_the_key():
|
|
232
280
|
creds = AsyncCredentials(api_key=KEY, token=None, exchange_url=EXCHANGE)
|
|
233
281
|
exchanges = Exchanges()
|
|
@@ -11,12 +11,14 @@ import grpc
|
|
|
11
11
|
import pytest
|
|
12
12
|
|
|
13
13
|
from boxd import AsyncBoxd, Boxd
|
|
14
|
+
from boxd._credentials import AsyncCredentials, SyncCredentials
|
|
14
15
|
from boxd._generated import api_pb2
|
|
15
16
|
from boxd._regions import AsyncRouter, SyncRouter, resolve_region
|
|
16
17
|
from boxd._urls import console_base_url
|
|
17
18
|
from boxd.errors import (
|
|
18
19
|
APIConnectionError,
|
|
19
20
|
APIStatusError,
|
|
21
|
+
AuthenticationError,
|
|
20
22
|
MachineFileNotFoundError,
|
|
21
23
|
NotFoundError,
|
|
22
24
|
RegionNotEnabledError,
|
|
@@ -780,3 +782,360 @@ def test_real_grpc_not_found_maps_before_the_lookup():
|
|
|
780
782
|
|
|
781
783
|
err = from_grpc_error(FakeRpcError(grpc.StatusCode.NOT_FOUND, "machine not found"))
|
|
782
784
|
assert isinstance(err, NotFoundError) and err.elsewhere == []
|
|
785
|
+
|
|
786
|
+
|
|
787
|
+
# --- direct mode: an API key skips asking home ---
|
|
788
|
+
|
|
789
|
+
KEY = "bxd_test-key"
|
|
790
|
+
EXCHANGE = "https://app.example.com/api/v1/auth/token"
|
|
791
|
+
# Where home's answer puts nyc when a test needs it apart from the derived
|
|
792
|
+
# name (on the platform the two are the same).
|
|
793
|
+
NYC_LISTED = "https://nyc-api.example.net:9443"
|
|
794
|
+
NOT_IN_REGION = (
|
|
795
|
+
"API key not recognized in region nyc: it was deleted, or its org doesn't "
|
|
796
|
+
"use this region (`boxd manage regions` lists your org's regions)"
|
|
797
|
+
)
|
|
798
|
+
|
|
799
|
+
|
|
800
|
+
def key_credentials(kind=SyncCredentials):
|
|
801
|
+
return kind(api_key=KEY, token=None, exchange_url=EXCHANGE)
|
|
802
|
+
|
|
803
|
+
|
|
804
|
+
def listed_apart(**kwargs):
|
|
805
|
+
"""`listing()` with nyc at NYC_LISTED."""
|
|
806
|
+
answer = listing(**kwargs)
|
|
807
|
+
answer.regions[1].api_endpoint = NYC_LISTED
|
|
808
|
+
return answer
|
|
809
|
+
|
|
810
|
+
|
|
811
|
+
def make_direct(
|
|
812
|
+
home_answers=None,
|
|
813
|
+
regions=None,
|
|
814
|
+
*,
|
|
815
|
+
region=None,
|
|
816
|
+
home_url=HOME,
|
|
817
|
+
credentials=None,
|
|
818
|
+
kind=Endpoint,
|
|
819
|
+
):
|
|
820
|
+
"""A router with the client's credential, as `Boxd` builds one. `made`
|
|
821
|
+
lists the endpoints it dialled, each marked `derived` or not."""
|
|
822
|
+
home = kind(home_url, home_answers)
|
|
823
|
+
made: list = []
|
|
824
|
+
|
|
825
|
+
def connect(url, *, derived=False):
|
|
826
|
+
endpoint = kind(url, (regions or {}).get(url))
|
|
827
|
+
endpoint.derived = derived
|
|
828
|
+
made.append(endpoint)
|
|
829
|
+
return endpoint
|
|
830
|
+
|
|
831
|
+
router_cls = AsyncRouter if kind is AsyncEndpoint else SyncRouter
|
|
832
|
+
if credentials is None:
|
|
833
|
+
credentials = key_credentials(
|
|
834
|
+
AsyncCredentials if kind is AsyncEndpoint else SyncCredentials
|
|
835
|
+
)
|
|
836
|
+
router = router_cls(home, region=region, connect=connect, credentials=credentials)
|
|
837
|
+
return router, home, made
|
|
838
|
+
|
|
839
|
+
|
|
840
|
+
def derived(made):
|
|
841
|
+
return next((e for e in made if e.derived), None)
|
|
842
|
+
|
|
843
|
+
|
|
844
|
+
def listed(made):
|
|
845
|
+
return next((e for e in made if not e.derived), None)
|
|
846
|
+
|
|
847
|
+
|
|
848
|
+
def test_direct_an_api_key_goes_straight_to_the_region_as_it_is():
|
|
849
|
+
router, home, made = make_direct(
|
|
850
|
+
regions={
|
|
851
|
+
NYC: {
|
|
852
|
+
"CreateVm": created(),
|
|
853
|
+
"GetVm": vm("a", "nyc"),
|
|
854
|
+
"ListVms": api_pb2.ListVmsResponse(vms=[vm("a", "nyc")]),
|
|
855
|
+
}
|
|
856
|
+
},
|
|
857
|
+
region="nyc",
|
|
858
|
+
)
|
|
859
|
+
machines = Machines(router)
|
|
860
|
+
machine = machines.create("a")
|
|
861
|
+
every = machines.list()
|
|
862
|
+
assert home.calls == []
|
|
863
|
+
assert len(made) == 1 and derived(made).url == NYC
|
|
864
|
+
# No org filled in: the key's org applies.
|
|
865
|
+
assert [(m, getattr(r, "org", None)) for m, r in derived(made).calls] == [
|
|
866
|
+
("CreateVm", ""),
|
|
867
|
+
("GetVm", None),
|
|
868
|
+
("ListVms", ""),
|
|
869
|
+
]
|
|
870
|
+
# The console is named like the API, so home isn't asked for it either.
|
|
871
|
+
assert machine.access.desktop_url == "https://app.nyc.boxd.example.com/desktop/a"
|
|
872
|
+
assert every[0].access.desktop_url == "https://app.nyc.boxd.example.com/desktop/a"
|
|
873
|
+
|
|
874
|
+
|
|
875
|
+
def test_direct_a_call_region_goes_there_and_account_calls_stay_home():
|
|
876
|
+
router, home, made = make_direct(
|
|
877
|
+
{"GetOrgMachineDefaults": api_pb2.GetOrgMachineDefaultsResponse()},
|
|
878
|
+
{LON: {"GetVm": vm("a", "lon")}},
|
|
879
|
+
)
|
|
880
|
+
Machines(router).get("a", region="lon")
|
|
881
|
+
Orgs(router).get_default_region()
|
|
882
|
+
assert derived(made).url == LON
|
|
883
|
+
assert home.methods() == ["GetOrgMachineDefaults"]
|
|
884
|
+
|
|
885
|
+
|
|
886
|
+
def test_direct_a_call_that_names_an_org_asks_home():
|
|
887
|
+
router, home, made = make_direct(
|
|
888
|
+
{"ListRegions": listed_apart()},
|
|
889
|
+
{NYC_LISTED: {"ListVms": api_pb2.ListVmsResponse()}},
|
|
890
|
+
)
|
|
891
|
+
Machines(router).list(org="acme", region="nyc")
|
|
892
|
+
assert home.methods() == ["ListRegions"]
|
|
893
|
+
assert home.calls[0][1].org_id == "acme"
|
|
894
|
+
assert [r.org for _, r in listed(made).calls] == ["acme"]
|
|
895
|
+
assert derived(made) is None
|
|
896
|
+
|
|
897
|
+
|
|
898
|
+
def test_direct_all_asks_home():
|
|
899
|
+
router, home, made = make_direct(
|
|
900
|
+
{"ListRegions": listing(), "ListVms": api_pb2.ListVmsResponse()},
|
|
901
|
+
{NYC: {"ListVms": api_pb2.ListVmsResponse()}},
|
|
902
|
+
)
|
|
903
|
+
Machines(router).list(region="all")
|
|
904
|
+
assert home.methods() == ["ListRegions", "ListVms"]
|
|
905
|
+
assert derived(made) is None
|
|
906
|
+
|
|
907
|
+
|
|
908
|
+
def test_direct_a_connection_error_goes_through_home_for_good():
|
|
909
|
+
router, home, made = make_direct(
|
|
910
|
+
{"ListRegions": listed_apart()},
|
|
911
|
+
{
|
|
912
|
+
NYC: {"GetVm": APIConnectionError("DNS resolution failed")},
|
|
913
|
+
NYC_LISTED: {
|
|
914
|
+
"GetVm": vm("alpha", "nyc"),
|
|
915
|
+
"ListVms": api_pb2.ListVmsResponse(),
|
|
916
|
+
},
|
|
917
|
+
},
|
|
918
|
+
region="nyc",
|
|
919
|
+
)
|
|
920
|
+
machines = Machines(router)
|
|
921
|
+
assert machines.get("alpha").region == "nyc"
|
|
922
|
+
machines.list()
|
|
923
|
+
assert derived(made).methods() == ["GetVm"]
|
|
924
|
+
assert home.methods() == ["ListRegions"]
|
|
925
|
+
# Through home, the region is sent the org home names, as before.
|
|
926
|
+
assert listed(made).url == NYC_LISTED
|
|
927
|
+
assert [(m, getattr(r, "org", None)) for m, r in listed(made).calls] == [
|
|
928
|
+
("GetVm", None),
|
|
929
|
+
("ListVms", "org-1"),
|
|
930
|
+
]
|
|
931
|
+
|
|
932
|
+
|
|
933
|
+
def test_direct_a_region_that_does_not_hold_the_key_is_explained_by_home():
|
|
934
|
+
router, home, made = make_direct(
|
|
935
|
+
{"ListRegions": listing(nyc="available")},
|
|
936
|
+
{NYC: {"CreateVm": AuthenticationError(NOT_IN_REGION)}},
|
|
937
|
+
)
|
|
938
|
+
with pytest.raises(RegionNotEnabledError, match='request_region\\("nyc"\\)'):
|
|
939
|
+
Machines(router).create("a", region="nyc")
|
|
940
|
+
assert derived(made).methods() == ["CreateVm"]
|
|
941
|
+
assert home.methods() == ["ListRegions"]
|
|
942
|
+
assert len(made) == 1
|
|
943
|
+
|
|
944
|
+
|
|
945
|
+
def test_direct_a_region_that_does_not_hold_the_key_yet_is_asked_through_home():
|
|
946
|
+
router, _, made = make_direct(
|
|
947
|
+
{"ListRegions": listed_apart()},
|
|
948
|
+
{
|
|
949
|
+
NYC: {"ListVms": AuthenticationError(NOT_IN_REGION)},
|
|
950
|
+
NYC_LISTED: {"ListVms": api_pb2.ListVmsResponse(vms=[vm("b", "nyc")])},
|
|
951
|
+
},
|
|
952
|
+
)
|
|
953
|
+
assert [m.name for m in Machines(router).list(region="nyc")] == ["b"]
|
|
954
|
+
assert derived(made).methods() == ["ListVms"]
|
|
955
|
+
assert [r.org for _, r in listed(made).calls] == ["org-1"]
|
|
956
|
+
|
|
957
|
+
|
|
958
|
+
def test_direct_an_unknown_region_is_reported_by_home():
|
|
959
|
+
router, home, _ = make_direct(
|
|
960
|
+
{"ListRegions": listing()},
|
|
961
|
+
{"https://sea.boxd.example.com:9443": {"GetVm": APIConnectionError("no host")}},
|
|
962
|
+
)
|
|
963
|
+
with pytest.raises(NotFoundError, match='no region "sea"') as e:
|
|
964
|
+
Machines(router).get("a", region="sea")
|
|
965
|
+
assert e.value.reason == "unknown_region"
|
|
966
|
+
assert home.methods() == ["ListRegions"]
|
|
967
|
+
|
|
968
|
+
|
|
969
|
+
def test_direct_any_other_error_is_the_calls_own():
|
|
970
|
+
router, home, made = make_direct(
|
|
971
|
+
regions={
|
|
972
|
+
NYC: {
|
|
973
|
+
"GetVm": NotFoundError("machine not found: foo"),
|
|
974
|
+
"FindElsewhere": elsewhere(exact=[("fra", "foo")]),
|
|
975
|
+
"StartVm": AuthenticationError("API key expired"),
|
|
976
|
+
}
|
|
977
|
+
},
|
|
978
|
+
region="nyc",
|
|
979
|
+
)
|
|
980
|
+
machines = Machines(router)
|
|
981
|
+
with pytest.raises(NotFoundError, match='pass region="fra"'):
|
|
982
|
+
machines.get("foo")
|
|
983
|
+
with pytest.raises(AuthenticationError, match="expired"):
|
|
984
|
+
machines.start("foo")
|
|
985
|
+
assert derived(made).methods() == ["GetVm", "FindElsewhere", "StartVm"]
|
|
986
|
+
assert home.calls == []
|
|
987
|
+
|
|
988
|
+
|
|
989
|
+
def test_direct_a_token_and_an_exchanged_key_ask_home():
|
|
990
|
+
exchanged = key_credentials()
|
|
991
|
+
exchanged.raw_key_refused()
|
|
992
|
+
token = SyncCredentials(api_key=None, token="t", exchange_url=EXCHANGE)
|
|
993
|
+
for credentials in (token, exchanged):
|
|
994
|
+
router, home, made = make_direct(
|
|
995
|
+
{"ListRegions": listing()},
|
|
996
|
+
{NYC: {"GetVm": vm()}},
|
|
997
|
+
region="nyc",
|
|
998
|
+
credentials=credentials,
|
|
999
|
+
)
|
|
1000
|
+
Machines(router).get("alpha")
|
|
1001
|
+
assert home.methods() == ["ListRegions"]
|
|
1002
|
+
assert derived(made) is None
|
|
1003
|
+
|
|
1004
|
+
|
|
1005
|
+
@pytest.mark.parametrize(
|
|
1006
|
+
"home_url",
|
|
1007
|
+
[
|
|
1008
|
+
"https://192.0.2.10:9443",
|
|
1009
|
+
"https://[2001:db8::1]:9443",
|
|
1010
|
+
"http://localhost:9443",
|
|
1011
|
+
"http://127.0.0.1:9443",
|
|
1012
|
+
"https://boxd:9443",
|
|
1013
|
+
"http://boxd.example.com:9443", # plaintext: the key is exchanged
|
|
1014
|
+
],
|
|
1015
|
+
)
|
|
1016
|
+
def test_direct_a_home_that_is_an_address_localhost_or_one_label_asks_home(home_url):
|
|
1017
|
+
router, home, made = make_direct(
|
|
1018
|
+
{"ListRegions": listing()},
|
|
1019
|
+
{NYC: {"GetVm": vm()}},
|
|
1020
|
+
region="nyc",
|
|
1021
|
+
home_url=home_url,
|
|
1022
|
+
)
|
|
1023
|
+
Machines(router).get("alpha")
|
|
1024
|
+
assert home.methods() == ["ListRegions"]
|
|
1025
|
+
assert derived(made) is None
|
|
1026
|
+
|
|
1027
|
+
|
|
1028
|
+
def test_direct_streams_go_there_only_after_a_unary_call_was_answered():
|
|
1029
|
+
# A list is one answer per call: a stream's answer is a list in one.
|
|
1030
|
+
chunks = [[api_pb2.ExecChunk(data=b"hi", exit_code=0)]]
|
|
1031
|
+
uploaded = api_pb2.UploadFileResponse(bytes_written=2)
|
|
1032
|
+
router, home, made = make_direct(
|
|
1033
|
+
{"ListRegions": listed_apart()},
|
|
1034
|
+
{
|
|
1035
|
+
NYC: {
|
|
1036
|
+
"GetVm": vm(),
|
|
1037
|
+
"Exec": chunks,
|
|
1038
|
+
"StreamLogs": [[]],
|
|
1039
|
+
"UploadFileStream": uploaded,
|
|
1040
|
+
},
|
|
1041
|
+
NYC_LISTED: {
|
|
1042
|
+
"Exec": chunks,
|
|
1043
|
+
"StreamLogs": [[]],
|
|
1044
|
+
"UploadFileStream": uploaded,
|
|
1045
|
+
},
|
|
1046
|
+
},
|
|
1047
|
+
region="nyc",
|
|
1048
|
+
)
|
|
1049
|
+
machines = Machines(router)
|
|
1050
|
+
# Nothing confirmed the derived name yet: through home, as before.
|
|
1051
|
+
assert machines.exec("alpha", "echo hi").stdout == "hi"
|
|
1052
|
+
list(machines.logs("alpha"))
|
|
1053
|
+
assert machines.files.upload("alpha", "/tmp/x", b"hi") == 2
|
|
1054
|
+
assert home.methods() == ["ListRegions"]
|
|
1055
|
+
assert listed(made).methods() == ["Exec", "StreamLogs", "UploadFileStream"]
|
|
1056
|
+
# A unary call answered there: streams follow it.
|
|
1057
|
+
machines.get("alpha")
|
|
1058
|
+
assert machines.exec("alpha", "echo hi").stdout == "hi"
|
|
1059
|
+
list(machines.logs("alpha"))
|
|
1060
|
+
assert machines.files.upload("alpha", "/tmp/x", b"hi") == 2
|
|
1061
|
+
assert derived(made).methods() == [
|
|
1062
|
+
"GetVm",
|
|
1063
|
+
"Exec",
|
|
1064
|
+
"StreamLogs",
|
|
1065
|
+
"UploadFileStream",
|
|
1066
|
+
]
|
|
1067
|
+
assert listed(made).methods() == ["Exec", "StreamLogs", "UploadFileStream"]
|
|
1068
|
+
|
|
1069
|
+
|
|
1070
|
+
def test_direct_a_region_that_fell_back_takes_its_streams_through_home():
|
|
1071
|
+
router, _, made = make_direct(
|
|
1072
|
+
{"ListRegions": listed_apart()},
|
|
1073
|
+
{
|
|
1074
|
+
NYC: {"GetVm": [vm(), APIConnectionError("reset")], "StreamLogs": [[]]},
|
|
1075
|
+
NYC_LISTED: {"GetVm": vm(), "StreamLogs": [[]]},
|
|
1076
|
+
},
|
|
1077
|
+
region="nyc",
|
|
1078
|
+
)
|
|
1079
|
+
machines = Machines(router)
|
|
1080
|
+
machines.get("alpha") # confirmed
|
|
1081
|
+
machines.get("alpha") # fails there: off
|
|
1082
|
+
list(machines.logs("alpha"))
|
|
1083
|
+
assert derived(made).methods() == ["GetVm", "GetVm"]
|
|
1084
|
+
assert listed(made).methods() == ["GetVm", "StreamLogs"]
|
|
1085
|
+
|
|
1086
|
+
|
|
1087
|
+
def test_direct_close_closes_the_derived_transports():
|
|
1088
|
+
router, _, made = make_direct(regions={NYC: {"GetVm": vm()}}, region="nyc")
|
|
1089
|
+
Machines(router).get("alpha")
|
|
1090
|
+
router.close()
|
|
1091
|
+
assert derived(made).closed
|
|
1092
|
+
|
|
1093
|
+
|
|
1094
|
+
def test_direct_the_client_wires_its_credential_and_derived_transports():
|
|
1095
|
+
boxd = Boxd(api_key=KEY, base_url=HOME, region="nyc")
|
|
1096
|
+
router = boxd._transport
|
|
1097
|
+
assert router._credentials is router._home._credentials
|
|
1098
|
+
nyc = router._connect(NYC, derived=True)
|
|
1099
|
+
assert nyc._derived and nyc._max_retries == 0
|
|
1100
|
+
assert nyc._credentials is router._credentials
|
|
1101
|
+
assert not router._home._derived and router._home._max_retries == 2
|
|
1102
|
+
|
|
1103
|
+
|
|
1104
|
+
async def test_async_direct_and_its_fallback():
|
|
1105
|
+
router, home, made = make_direct(
|
|
1106
|
+
{"ListRegions": listed_apart(nyc="available")},
|
|
1107
|
+
{
|
|
1108
|
+
NYC: {
|
|
1109
|
+
"GetVm": vm("a", "nyc"),
|
|
1110
|
+
"CreateVm": AuthenticationError(NOT_IN_REGION),
|
|
1111
|
+
},
|
|
1112
|
+
},
|
|
1113
|
+
region="nyc",
|
|
1114
|
+
kind=AsyncEndpoint,
|
|
1115
|
+
)
|
|
1116
|
+
machines = AsyncMachines(router)
|
|
1117
|
+
machine = await machines.get("a")
|
|
1118
|
+
assert machine.access.desktop_url == "https://app.nyc.boxd.example.com/desktop/a"
|
|
1119
|
+
assert home.calls == []
|
|
1120
|
+
with pytest.raises(RegionNotEnabledError):
|
|
1121
|
+
await machines.create("b")
|
|
1122
|
+
assert derived(made).methods() == ["GetVm", "CreateVm"]
|
|
1123
|
+
assert home.methods() == ["ListRegions"]
|
|
1124
|
+
|
|
1125
|
+
|
|
1126
|
+
async def test_async_direct_streams_wait_for_a_confirmed_unary_call():
|
|
1127
|
+
router, home, made = make_direct(
|
|
1128
|
+
{"ListRegions": listed_apart()},
|
|
1129
|
+
{NYC: {"GetVm": vm(), "StreamLogs": [[]]}, NYC_LISTED: {"StreamLogs": [[]]}},
|
|
1130
|
+
region="nyc",
|
|
1131
|
+
kind=AsyncEndpoint,
|
|
1132
|
+
)
|
|
1133
|
+
machines = AsyncMachines(router)
|
|
1134
|
+
async for _ in machines.logs("alpha"):
|
|
1135
|
+
pass
|
|
1136
|
+
await machines.get("alpha")
|
|
1137
|
+
async for _ in machines.logs("alpha"):
|
|
1138
|
+
pass
|
|
1139
|
+
assert listed(made).methods() == ["StreamLogs"]
|
|
1140
|
+
assert derived(made).methods() == ["GetVm", "StreamLogs"]
|
|
1141
|
+
assert home.methods() == ["ListRegions"]
|
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
"""Base-URL resolution, the derived exchange URL,
|
|
1
|
+
"""Base-URL resolution, the derived exchange URL, endpoint splitting, and a
|
|
2
|
+
region's name derived from home's."""
|
|
2
3
|
|
|
3
4
|
from __future__ import annotations
|
|
4
5
|
|
|
@@ -8,6 +9,7 @@ from boxd._urls import (
|
|
|
8
9
|
DEFAULT_BASE_URL,
|
|
9
10
|
console_base_url,
|
|
10
11
|
exchange_url_for,
|
|
12
|
+
region_base_url,
|
|
11
13
|
resolve_base_url,
|
|
12
14
|
resolve_endpoint,
|
|
13
15
|
)
|
|
@@ -137,3 +139,44 @@ def test_resolve_endpoint(url, target, tls):
|
|
|
137
139
|
endpoint = resolve_endpoint(url)
|
|
138
140
|
assert endpoint.target == target
|
|
139
141
|
assert endpoint.use_tls is tls
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
# --- region_base_url ---
|
|
145
|
+
|
|
146
|
+
|
|
147
|
+
@pytest.mark.parametrize(
|
|
148
|
+
"home,expected",
|
|
149
|
+
[
|
|
150
|
+
("https://boxd.example.com:9443", "https://nyc.boxd.example.com:9443"),
|
|
151
|
+
("https://boxd.example.com:9443/", "https://nyc.boxd.example.com:9443"),
|
|
152
|
+
("http://boxd.example.com:9443", "http://nyc.boxd.example.com:9443"),
|
|
153
|
+
("boxd.example.com:9443", "nyc.boxd.example.com:9443"),
|
|
154
|
+
("https://Boxd.Example.com", "https://nyc.boxd.example.com"),
|
|
155
|
+
],
|
|
156
|
+
)
|
|
157
|
+
def test_a_region_is_named_after_homes_host_on_its_scheme_and_port(home, expected):
|
|
158
|
+
assert region_base_url(home, "nyc") == expected
|
|
159
|
+
|
|
160
|
+
|
|
161
|
+
@pytest.mark.parametrize(
|
|
162
|
+
"home",
|
|
163
|
+
[
|
|
164
|
+
"https://192.0.2.10:9443",
|
|
165
|
+
"https://[2001:db8::1]:9443",
|
|
166
|
+
"http://localhost:9443",
|
|
167
|
+
"https://api.localhost:9443",
|
|
168
|
+
"http://127.0.0.1:9443",
|
|
169
|
+
"https://boxd:9443",
|
|
170
|
+
"https://boxd.example.com:9443/api",
|
|
171
|
+
"https://boxd.example.com:port",
|
|
172
|
+
],
|
|
173
|
+
)
|
|
174
|
+
def test_no_region_name_under_an_address_localhost_or_one_label(home):
|
|
175
|
+
assert region_base_url(home, "nyc") is None
|
|
176
|
+
|
|
177
|
+
|
|
178
|
+
def test_a_region_is_one_label():
|
|
179
|
+
assert region_base_url("https://boxd.example.com:9443", "us-east") == (
|
|
180
|
+
"https://us-east.boxd.example.com:9443"
|
|
181
|
+
)
|
|
182
|
+
assert region_base_url("https://boxd.example.com:9443", "n.yc") is None
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|