omdev 0.0.0.dev289__py3-none-any.whl → 0.0.0.dev291__py3-none-any.whl

omdev/scripts/ci.py

@@ -71,6 +71,7 @@ import urllib.parse
 import urllib.request
 import uuid
 import weakref
+import xml.etree.ElementTree as ET
 
 
 ########################################
@@ -103,6 +104,10 @@ TimeoutLike = ta.Union['Timeout', ta.Type['Timeout.Default'], ta.Iterable['Timeo
 # ../../omlish/sockets/addresses.py
 SocketAddress = ta.Any
 
+# github/api/v2/api.py
+GithubCacheServiceV2RequestT = ta.TypeVar('GithubCacheServiceV2RequestT')
+GithubCacheServiceV2ResponseT = ta.TypeVar('GithubCacheServiceV2ResponseT')
+
 # ../../omlish/argparse/cli.py
 ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 
@@ -418,6 +423,31 @@ class DockerPortRelay:
         ]
 
 
+########################################
+# ../../../omlish/http/urllib.py
+
+
+##
+
+
+class NonRaisingUrllibErrorProcessor(urllib.request.HTTPErrorProcessor):
+    """
+    https://stackoverflow.com/a/74844056
+
+    Usage:
+
+        opener = urllib.request.build_opener(NonRaisingUrllibErrorProcessor)
+        with opener.open(req) as resp:
+            ...
+    """
+
+    def http_response(self, request, response):
+        return response
+
+    def https_response(self, request, response):
+        return response
+
+
 ########################################
 # ../../../omlish/http/versions.py
 
@@ -1985,7 +2015,7 @@ def read_docker_tar_image_id(tar_file: str) -> str:
 
 
 ########################################
-# ../github/api.py
+# ../github/api/v1/api.py
 """
 export FILE_SIZE=$(stat --format="%s" $FILE)
 
@@ -2028,6 +2058,11 @@ curl -s \
 
 
 class GithubCacheServiceV1:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    #
+
     API_VERSION = '6.0-preview.1'
 
     @classmethod
@@ -2098,14 +2133,54 @@ class GithubCacheServiceV1:
         cache_size: ta.Optional[int]
 
 
+########################################
+# ../github/api/v2/api.py
+"""
+https://github.com/tonistiigi/go-actions-cache/blob/3e9a6642607fd6e4d5d4fdab7c91fe8bf4c36a25/cache_v2.go
+
+==
+
+curl -s \
+  -X POST \
+  "${ACTIONS_RESULTS_URL}twirp/github.actions.results.api.v1.CacheService/CreateCacheEntry" \
+  -H 'Content-Type: application/json' \
+  -H "Authorization: Bearer $ACTIONS_RUNTIME_TOKEN" \
+  -d '{"key": "foo", "version": "0000000000000000000000000000000000000000000000000000000000000001" }' \
+  | jq .
+
+curl -s \
+  -X POST \
+  "${ACTIONS_RESULTS_URL}twirp/github.actions.results.api.v1.CacheService/GetCacheEntryDownloadURL" \
+  -H 'Content-Type: application/json' \
+  -H "Authorization: Bearer $ACTIONS_RUNTIME_TOKEN" \
+  -d '{"key": "foo", "restoreKeys": [], "version": "0000000000000000000000000000000000000000000000000000000000000001" }' \
+  | jq .
+
+"""  # noqa
+
+
+##
+
+
 class GithubCacheServiceV2:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    #
+
     SERVICE_NAME = 'github.actions.results.api.v1.CacheService'
 
+    @classmethod
+    def get_service_url(cls, base_url: str) -> str:
+        return f'{base_url.rstrip("/")}/twirp/{cls.SERVICE_NAME}'
+
+    #
+
     @dc.dataclass(frozen=True)
-    class Method:
+    class Method(ta.Generic[GithubCacheServiceV2RequestT, GithubCacheServiceV2ResponseT]):
         name: str
-        request: type
-        response: type
+        request: ta.Type[GithubCacheServiceV2RequestT]
+        response: ta.Type[GithubCacheServiceV2ResponseT]
 
     #
 
@@ -2124,6 +2199,8 @@ class GithubCacheServiceV2:
         repository_id: int
         scope: ta.Sequence['GithubCacheServiceV2.CacheScope']
 
+    VERSION_LENGTH: int = 64
+
     #
 
     @dc.dataclass(frozen=True)
@@ -2132,12 +2209,18 @@ class GithubCacheServiceV2:
         version: str
         metadata: ta.Optional['GithubCacheServiceV2.CacheMetadata'] = None
 
+        def __post_init__(self) -> None:
+            check.equal(len(self.version), GithubCacheServiceV2.VERSION_LENGTH)
+
     @dc.dataclass(frozen=True)
     class CreateCacheEntryResponse:
         ok: bool
         signed_upload_url: str
 
-    CREATE_CACHE_ENTRY_METHOD = Method(
+    CREATE_CACHE_ENTRY_METHOD: Method[
+        CreateCacheEntryRequest,
+        CreateCacheEntryResponse,
+    ] = Method(
         'CreateCacheEntry',
         CreateCacheEntryRequest,
         CreateCacheEntryResponse,
@@ -2157,7 +2240,10 @@ class GithubCacheServiceV2:
         ok: bool
         entry_id: str
 
-    FINALIZE_CACHE_ENTRY_METHOD = Method(
+    FINALIZE_CACHE_ENTRY_METHOD: Method[
+        FinalizeCacheEntryUploadRequest,
+        FinalizeCacheEntryUploadResponse,
+    ] = Method(
         'FinalizeCacheEntryUpload',
         FinalizeCacheEntryUploadRequest,
         FinalizeCacheEntryUploadResponse,
@@ -2178,7 +2264,10 @@ class GithubCacheServiceV2:
         signed_download_url: str
         matched_key: str
 
-    GET_CACHE_ENTRY_DOWNLOAD_URL_METHOD = Method(
+    GET_CACHE_ENTRY_DOWNLOAD_URL_METHOD: Method[
+        GetCacheEntryDownloadUrlRequest,
+        GetCacheEntryDownloadUrlResponse,
+    ] = Method(
         'GetCacheEntryDownloadURL',
         GetCacheEntryDownloadUrlRequest,
         GetCacheEntryDownloadUrlResponse,
@@ -5978,13 +6067,14 @@ class FileCacheDataCache(DataCache):
 
 
 ########################################
-# ../github/client.py
+# ../github/api/clients.py
 
 
 ##
 
 
 class GithubCacheClient(abc.ABC):
+    @dc.dataclass(frozen=True)
     class Entry(abc.ABC):  # noqa
         pass
 
@@ -6007,18 +6097,21 @@ class GithubCacheClient(abc.ABC):
 ##
 
 
-class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
-    BASE_URL_ENV_VAR = register_github_env_var('ACTIONS_CACHE_URL')
+class BaseGithubCacheClient(GithubCacheClient, abc.ABC):
     AUTH_TOKEN_ENV_VAR = register_github_env_var('ACTIONS_RUNTIME_TOKEN')  # noqa
 
     KEY_SUFFIX_ENV_VAR = register_github_env_var('GITHUB_RUN_ID')
 
+    DEFAULT_CONCURRENCY = 4
+    DEFAULT_CHUNK_SIZE = 64 * 1024 * 1024
+
     #
 
     def __init__(
             self,
             *,
-            base_url: ta.Optional[str] = None,
+            service_url: str,
+
             auth_token: ta.Optional[str] = None,
 
             key_prefix: ta.Optional[str] = None,
@@ -6027,14 +6120,15 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
             cache_version: int = CI_CACHE_VERSION,
 
             loop: ta.Optional[asyncio.AbstractEventLoop] = None,
+
+            concurrency: int = DEFAULT_CONCURRENCY,
+            chunk_size: int = DEFAULT_CHUNK_SIZE,
     ) -> None:
         super().__init__()
 
         #
 
-        if base_url is None:
-            base_url = check.non_empty_str(self.BASE_URL_ENV_VAR())
-        self._service_url = GithubCacheServiceV1.get_service_url(base_url)
+        self._service_url = check.non_empty_str(service_url)
 
         if auth_token is None:
             auth_token = self.AUTH_TOKEN_ENV_VAR()
@@ -6056,7 +6150,16 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
 
         self._given_loop = loop
 
-    #
+        #
+
+        check.arg(concurrency > 0)
+        self._concurrency = concurrency
+
+        check.arg(chunk_size > 0)
+        self._chunk_size = chunk_size
+
+    ##
+    # misc
 
     def _get_loop(self) -> asyncio.AbstractEventLoop:
         if (loop := self._given_loop) is not None:
@@ -6065,21 +6168,25 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
 
     #
 
-    def build_request_headers(
+    def _load_json_bytes(self, b: ta.Optional[bytes]) -> ta.Optional[ta.Any]:
+        if not b:
+            return None
+        return json.loads(b.decode('utf-8-sig'))
+
+    ##
+    # requests
+
+    def _build_request_headers(
             self,
             headers: ta.Optional[ta.Mapping[str, str]] = None,
             *,
+            no_auth: bool = False,
             content_type: ta.Optional[str] = None,
             json_content: bool = False,
     ) -> ta.Dict[str, str]:
-        dct = {
-            'Accept': ';'.join([
-                'application/json',
-                f'api-version={GithubCacheServiceV1.API_VERSION}',
-            ]),
-        }
+        dct = {}
 
-        if (auth_token := self._auth_token):
+        if not no_auth and (auth_token := self._auth_token):
             dct['Authorization'] = f'Bearer {auth_token}'
 
         if content_type is None and json_content:
@@ -6094,19 +6201,13 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
 
     #
 
-    def load_json_bytes(self, b: ta.Optional[bytes]) -> ta.Optional[ta.Any]:
-        if not b:
-            return None
-        return json.loads(b.decode('utf-8-sig'))
-
-    #
-
-    async def send_url_request(
+    async def _send_urllib_request(
             self,
             req: urllib.request.Request,
     ) -> ta.Tuple[http.client.HTTPResponse, ta.Optional[bytes]]:
         def run_sync():
-            with urllib.request.urlopen(req) as resp:  # noqa
+            opener = urllib.request.build_opener(NonRaisingUrllibErrorProcessor)
+            with opener.open(req) as resp:  # noqa
                 body = resp.read()
             return (resp, body)
 
@@ -6122,18 +6223,32 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
         def __str__(self) -> str:
             return repr(self)
 
-    async def send_service_request(
+    async def _send_request(
             self,
-            path: str,
             *,
+            url: ta.Optional[str] = None,
+            path: ta.Optional[str] = None,
+
             method: ta.Optional[str] = None,
+
             headers: ta.Optional[ta.Mapping[str, str]] = None,
+            no_auth: bool = False,
             content_type: ta.Optional[str] = None,
+
             content: ta.Optional[bytes] = None,
             json_content: ta.Optional[ta.Any] = None,
+
             success_status_codes: ta.Optional[ta.Container[int]] = None,
+
+            retry_status_codes: ta.Optional[ta.Container[int]] = None,
+            num_retries: int = 0,
+            retry_sleep: ta.Optional[float] = None,
     ) -> ta.Optional[ta.Any]:
-        url = f'{self._service_url}/{path}'
+        if url is not None and path is not None:
+            raise RuntimeError('Must not pass both url and path')
+        elif path is not None:
+            url = f'{self._service_url}/{path}'
+        url = check.non_empty_str(url)
 
         if content is not None and json_content is not None:
             raise RuntimeError('Must not pass both content and json_content')
@@ -6146,33 +6261,52 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
         if method is None:
             method = 'POST' if content is not None else 'GET'
 
+        headers = self._build_request_headers(
+            headers,
+            no_auth=no_auth,
+            content_type=content_type,
+            json_content=header_json_content,
+        )
+
         #
 
-        req = urllib.request.Request(  # noqa
-            url,
-            method=method,
-            headers=self.build_request_headers(
-                headers,
-                content_type=content_type,
-                json_content=header_json_content,
-            ),
-            data=content,
-        )
+        for n in itertools.count():
+            req = urllib.request.Request(  # noqa
+                url,
+                method=method,
+                headers=headers,
+                data=content,
+            )
 
-        resp, body = await self.send_url_request(req)
+            resp, body = await self._send_urllib_request(req)
 
-        #
+            #
 
-        if success_status_codes is not None:
-            is_success = resp.status in success_status_codes
-        else:
-            is_success = (200 <= resp.status <= 300)
-        if not is_success:
-            raise self.ServiceRequestError(resp.status, body)
+            if success_status_codes is not None:
+                is_success = resp.status in success_status_codes
+            else:
+                is_success = (200 <= resp.status < 300)
+            if is_success:
+                return self._load_json_bytes(body)
+
+            #
 
-        return self.load_json_bytes(body)
+            log.debug(f'Request to url {url} got unsuccessful status code {resp.status}')  # noqa
 
-    #
+            if not (
+                retry_status_codes is not None and
+                resp.status in retry_status_codes and
+                n < num_retries
+            ):
+                raise self.ServiceRequestError(resp.status, body)
+
+            if retry_sleep is not None:
+                await asyncio.sleep(retry_sleep)
+
+        raise RuntimeError('Unreachable')
+
+    ##
+    # keys
 
     KEY_PART_SEPARATOR = '---'
 
@@ -6183,73 +6317,8 @@ class GithubCacheServiceV1BaseClient(GithubCacheClient, abc.ABC):
             ('' if partial_suffix else self._key_suffix),
         ])
 
-    #
-
-    @dc.dataclass(frozen=True)
-    class Entry(GithubCacheClient.Entry):
-        artifact: GithubCacheServiceV1.ArtifactCacheEntry
-
-    def get_entry_url(self, entry: GithubCacheClient.Entry) -> ta.Optional[str]:
-        entry1 = check.isinstance(entry, self.Entry)
-        return entry1.artifact.archive_location
-
-    #
-
-    def build_get_entry_url_path(self, *keys: str) -> str:
-        qp = dict(
-            keys=','.join(urllib.parse.quote_plus(k) for k in keys),
-            version=str(self._cache_version),
-        )
-
-        return '?'.join([
-            'cache',
-            '&'.join([
-                f'{k}={v}'
-                for k, v in qp.items()
-            ]),
-        ])
-
-    GET_ENTRY_SUCCESS_STATUS_CODES = (200, 204)
-
-
-##
-
-
-class GithubCacheServiceV1Client(GithubCacheServiceV1BaseClient):
-    DEFAULT_CONCURRENCY = 4
-
-    DEFAULT_CHUNK_SIZE = 32 * 1024 * 1024
-
-    def __init__(
-            self,
-            *,
-            concurrency: int = DEFAULT_CONCURRENCY,
-            chunk_size: int = DEFAULT_CHUNK_SIZE,
-            **kwargs: ta.Any,
-    ) -> None:
-        super().__init__(**kwargs)
-
-        check.arg(concurrency > 0)
-        self._concurrency = concurrency
-
-        check.arg(chunk_size > 0)
-        self._chunk_size = chunk_size
-
-    #
-
-    async def get_entry(self, key: str) -> ta.Optional[GithubCacheServiceV1BaseClient.Entry]:
-        obj = await self.send_service_request(
-            self.build_get_entry_url_path(self.fix_key(key, partial_suffix=True)),
-        )
-        if obj is None:
-            return None
-
-        return self.Entry(GithubCacheServiceV1.dataclass_from_json(
-            GithubCacheServiceV1.ArtifactCacheEntry,
-            obj,
-        ))
-
-    #
+    ##
+    # downloading
 
     @dc.dataclass(frozen=True)
     class _DownloadChunk:
@@ -6267,7 +6336,7 @@ class GithubCacheServiceV1Client(GithubCacheServiceV1BaseClient):
             },
         )
 
-        _, buf_ = await self.send_url_request(req)
+        _, buf_ = await self._send_urllib_request(req)
 
         buf = check.not_none(buf_)
         check.equal(len(buf), chunk.size)
@@ -6310,7 +6379,7 @@ class GithubCacheServiceV1Client(GithubCacheServiceV1BaseClient):
     #
     #     status_code = check.isinstance(curl_res['response_code'], int)
     #
-    #     if not (200 <= status_code <= 300):
+    #     if not (200 <= status_code < 300):
     #         raise RuntimeError(f'Curl chunk download {chunk} failed: {curl_res}')
 
     async def _download_file_chunk(self, chunk: _DownloadChunk) -> None:
@@ -6322,11 +6391,17 @@ class GithubCacheServiceV1Client(GithubCacheServiceV1BaseClient):
         ):
             await self._download_file_chunk_urllib(chunk)
 
-    async def _download_file(self, entry: GithubCacheServiceV1BaseClient.Entry, out_file: str) -> None:
-        key = check.non_empty_str(entry.artifact.cache_key)
-        url = check.non_empty_str(entry.artifact.archive_location)
+    async def _download_file_chunks(
+            self,
+            *,
+            key: str,
+            url: str,
+            out_file: str,
+    ) -> None:
+        check.non_empty_str(key)
+        check.non_empty_str(url)
 
-        head_resp, _ = await self.send_url_request(urllib.request.Request(  # noqa
+        head_resp, _ = await self._send_urllib_request(urllib.request.Request(  # noqa
             url,
             method='HEAD',
         ))
@@ -6355,109 +6430,281 @@ class GithubCacheServiceV1Client(GithubCacheServiceV1BaseClient):
 
         await asyncio_wait_concurrent(download_tasks, self._concurrency)
 
-    async def download_file(self, entry: GithubCacheClient.Entry, out_file: str) -> None:
-        entry1 = check.isinstance(entry, self.Entry)
-        with log_timing_context(
-                'Downloading github cache '
-                f'key {entry1.artifact.cache_key} '
-                f'version {entry1.artifact.cache_version} '
-                f'to {out_file}',
-        ):
-            await self._download_file(entry1, out_file)
+    ##
+    # uploading
 
-    #
+    @dc.dataclass(frozen=True)
+    class _UploadChunk:
+        url: str
+        key: str
+        in_file: str
+        offset: int
+        size: int
 
-    async def _upload_file_chunk(
-            self,
-            key: str,
-            cache_id: int,
-            in_file: str,
-            offset: int,
-            size: int,
-    ) -> None:
-        with log_timing_context(
-                f'Uploading github cache {key} '
-                f'file {in_file} '
-                f'chunk {offset} - {offset + size}',
-        ):
-            with open(in_file, 'rb') as f:  # noqa
-                f.seek(offset)
-                buf = f.read(size)
+    UPLOAD_CHUNK_NUM_RETRIES = 10
+    UPLOAD_CHUNK_RETRY_SLEEP = .5
 
-            check.equal(len(buf), size)
+    async def _upload_file_chunk_(self, chunk: _UploadChunk) -> None:
+        with open(chunk.in_file, 'rb') as f:  # noqa
+            f.seek(chunk.offset)
+            buf = f.read(chunk.size)
 
-            await self.send_service_request(
-                f'caches/{cache_id}',
-                method='PATCH',
-                content_type='application/octet-stream',
-                headers={
-                    'Content-Range': f'bytes {offset}-{offset + size - 1}/*',
-                },
-                content=buf,
-                success_status_codes=[204],
-            )
+        check.equal(len(buf), chunk.size)
 
-    async def _upload_file(self, key: str, in_file: str) -> None:
-        fixed_key = self.fix_key(key)
+        await self._send_request(
+            url=chunk.url,
 
-        check.state(os.path.isfile(in_file))
+            method='PATCH',
 
-        file_size = os.stat(in_file).st_size
+            headers={
+                'Content-Range': f'bytes {chunk.offset}-{chunk.offset + chunk.size - 1}/*',
+            },
+            no_auth=True,
+            content_type='application/octet-stream',
 
-        #
+            content=buf,
 
-        reserve_req = GithubCacheServiceV1.ReserveCacheRequest(
-            key=fixed_key,
-            cache_size=file_size,
-            version=str(self._cache_version),
-        )
-        reserve_resp_obj = await self.send_service_request(
-            'caches',
-            json_content=GithubCacheServiceV1.dataclass_to_json(reserve_req),
-            success_status_codes=[201],
-        )
-        reserve_resp = GithubCacheServiceV1.dataclass_from_json(  # noqa
-            GithubCacheServiceV1.ReserveCacheResponse,
-            reserve_resp_obj,
+            success_status_codes=[204],
+
+            # retry_status_codes=[405],
+            num_retries=self.UPLOAD_CHUNK_NUM_RETRIES,
+            retry_sleep=self.UPLOAD_CHUNK_RETRY_SLEEP,
         )
-        cache_id = check.isinstance(reserve_resp.cache_id, int)
 
-        log.debug(f'Github cache file {os.path.basename(in_file)} got id {cache_id}')  # noqa
+    async def _upload_file_chunk(self, chunk: _UploadChunk) -> None:
+        with log_timing_context(
+                f'Uploading github cache {chunk.key} '
+                f'file {chunk.in_file} '
+                f'chunk {chunk.offset} - {chunk.offset + chunk.size}',
+        ):
+            await self._upload_file_chunk_(chunk)
+
+    def _generate_file_upload_chunks(
+            self,
+            *,
+            in_file: str,
+            url: str,
+            key: str,
+
+            file_size: ta.Optional[int] = None,
+    ) -> ta.List[_UploadChunk]:
+        check.state(os.path.isfile(in_file))
+
+        if file_size is None:
+            file_size = os.stat(in_file).st_size
 
         #
 
-        upload_tasks = []
+        upload_chunks: ta.List[BaseGithubCacheClient._UploadChunk] = []
         chunk_size = self._chunk_size
         for i in range((file_size // chunk_size) + (1 if file_size % chunk_size else 0)):
             offset = i * chunk_size
             size = min(chunk_size, file_size - offset)
-            upload_tasks.append(self._upload_file_chunk(
-                fixed_key,
-                cache_id,
-                in_file,
-                offset,
-                size,
+            upload_chunks.append(self._UploadChunk(
+                url=url,
+                key=key,
+                in_file=in_file,
+                offset=offset,
+                size=size,
             ))
 
+        return upload_chunks
+
+    async def _upload_file_chunks(
+            self,
+            *,
+            in_file: str,
+            url: str,
+            key: str,
+
+            file_size: ta.Optional[int] = None,
+    ) -> None:
+        upload_tasks = []
+        for chunk in self._generate_file_upload_chunks(
+            in_file=in_file,
+            url=url,
+            key=key,
+            file_size=file_size,
+        ):
+            upload_tasks.append(self._upload_file_chunk(chunk))
+
         await asyncio_wait_concurrent(upload_tasks, self._concurrency)
 
-        #
 
-        commit_req = GithubCacheServiceV1.CommitCacheRequest(
-            size=file_size,
-        )
-        await self.send_service_request(
-            f'caches/{cache_id}',
-            json_content=GithubCacheServiceV1.dataclass_to_json(commit_req),
-            success_status_codes=[204],
-        )
+########################################
+# ../github/api/v2/azure.py
+"""
+TODO:
+ - ominfra? no, circdep
+"""
 
-    async def upload_file(self, key: str, in_file: str) -> None:
-        with log_timing_context(
-                f'Uploading github cache file {os.path.basename(in_file)} '
-                f'key {key}',
-        ):
-            await self._upload_file(key, in_file)
+
+##
+
+
+class AzureBlockBlobUploader:
+    """
+    https://learn.microsoft.com/en-us/rest/api/storageservices/put-block
+    https://learn.microsoft.com/en-us/rest/api/storageservices/put-block-list
+    """
+
+    DEFAULT_CONCURRENCY = 4
+
+    @dc.dataclass(frozen=True)
+    class Request:
+        method: str
+        url: str
+        headers: ta.Optional[ta.Dict[str, str]] = None
+        body: ta.Optional[bytes] = None
+
+    @dc.dataclass(frozen=True)
+    class Response:
+        status: int
+        headers: ta.Optional[ta.Mapping[str, str]] = None
+        data: ta.Optional[bytes] = None
+
+        def get_header(self, name: str) -> ta.Optional[str]:
+            for k, v in (self.headers or {}).items():
+                if k.lower() == name.lower():
+                    return v
+            return None
+
+    def __init__(
+            self,
+            blob_url_with_sas: str,
+            make_request: ta.Callable[[Request], ta.Awaitable[Response]],
+            *,
+            api_version: str = '2020-10-02',
+            concurrency: int = DEFAULT_CONCURRENCY,
+    ) -> None:
+        """
+        blob_url_with_sas should be of the form:
+           https://<account>.blob.core.windows.net/<container>/<blob>?<SAS-token>
+        """
+
+        super().__init__()
+
+        self._make_request = make_request
+        self._api_version = api_version
+        check.arg(concurrency >= 1)
+        self._concurrency = concurrency
+
+        parsed = urllib.parse.urlparse(blob_url_with_sas)
+        self._base_url = f'{parsed.scheme}://{parsed.netloc}'
+        parts = parsed.path.lstrip('/').split('/', 1)
+        self._container = parts[0]
+        self._blob_name = parts[1]
+        self._sas = parsed.query
+
+    def _headers(self) -> ta.Dict[str, str]:
+        """Standard headers for Azure Blob REST calls."""
+
+        now = datetime.datetime.now(datetime.UTC).strftime('%a, %d %b %Y %H:%M:%S GMT')
+        return {
+            'x-ms-date': now,
+            'x-ms-version': self._api_version,
+        }
+
+    @dc.dataclass(frozen=True)
+    class FileChunk:
+        in_file: str
+        offset: int
+        size: int
+
+    async def _upload_file_chunk_(
+            self,
+            block_id: str,
+            chunk: FileChunk,
+    ) -> None:
+        with open(chunk.in_file, 'rb') as f:  # noqa
+            f.seek(chunk.offset)
+            data = f.read(chunk.size)
+
+        check.equal(len(data), chunk.size)
+
+        params = {
+            'comp': 'block',
+            'blockid': block_id,
+        }
+        query = self._sas + '&' + urllib.parse.urlencode(params)
+        url = f'{self._base_url}/{self._container}/{self._blob_name}?{query}'
+
+        log.debug(f'Uploading azure blob chunk {chunk} with block id {block_id}')  # noqa
+
+        resp = await self._make_request(self.Request(
+            'PUT',
+            url,
+            headers=self._headers(),
+            body=data,
+        ))
+        if resp.status not in (201, 202):
+            raise RuntimeError(f'Put Block failed: {block_id=} {resp.status=}')
+
+    async def _upload_file_chunk(
+            self,
+            block_id: str,
+            chunk: FileChunk,
+    ) -> None:
+        with log_timing_context(f'Uploading azure blob chunk {chunk} with block id {block_id}'):
+            await self._upload_file_chunk_(
+                block_id,
+                chunk,
+            )
+
+    async def upload_file(
+            self,
+            chunks: ta.List[FileChunk],
+    ) -> ta.Dict[str, ta.Any]:
+        block_ids = []
+
+        # 1) Stage each block
+        upload_tasks = []
+        for idx, chunk in enumerate(chunks):
+            # Generate a predictable block ID (must be URL-safe base64)
+            raw_id = f'{idx:08d}'.encode()
+            block_id = base64.b64encode(raw_id).decode('utf-8')
+            block_ids.append(block_id)
+
+            upload_tasks.append(self._upload_file_chunk(
+                block_id,
+                chunk,
+            ))
+
+        await asyncio_wait_concurrent(upload_tasks, self._concurrency)
+
+        # 2) Commit block list
+        root = ET.Element('BlockList')
+        for bid in block_ids:
+            elm = ET.SubElement(root, 'Latest')
+            elm.text = bid
+        body = ET.tostring(root, encoding='utf-8', method='xml')
+
+        params = {'comp': 'blocklist'}
+        query = self._sas + '&' + urllib.parse.urlencode(params)
+        url = f'{self._base_url}/{self._container}/{self._blob_name}?{query}'
+
+        log.debug(f'Putting azure blob chunk list block ids {block_ids}')  # noqa
+
+        resp = await self._make_request(self.Request(
+            'PUT',
+            url,
+            headers={
+                **self._headers(),
+                'Content-Type': 'application/xml',
+            },
+            body=body,
+        ))
+        if resp.status not in (200, 201):
+            raise RuntimeError(f'Put Block List failed: {resp.status} {resp.data!r}')
+
+        ret = {
+            'status_code': resp.status,
+            'etag': resp.get_header('ETag'),
+        }
+
+        log.debug(f'Uploaded azure blob chunk {ret}')  # noqa
+
+        return ret
 
 
 ########################################
@@ -7708,119 +7955,351 @@ def subprocess_maybe_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
 
 
 ########################################
-# ../github/cache.py
+# ../github/api/v1/client.py
 
 
 ##
 
 
-class GithubCache(FileCache, DataCache):
-    @dc.dataclass(frozen=True)
-    class Config:
-        pass
+class GithubCacheServiceV1Client(BaseGithubCacheClient):
+    BASE_URL_ENV_VAR = register_github_env_var('ACTIONS_CACHE_URL')
 
     def __init__(
             self,
-            config: Config = Config(),
             *,
-            client: ta.Optional[GithubCacheClient] = None,
-            version: ta.Optional[CacheVersion] = None,
+            base_url: ta.Optional[str] = None,
 
-            local: DirectoryFileCache,
+            **kwargs: ta.Any,
     ) -> None:
+        if base_url is None:
+            base_url = check.non_empty_str(self.BASE_URL_ENV_VAR())
+        service_url = GithubCacheServiceV1.get_service_url(base_url)
+
         super().__init__(
-            version=version,
+            service_url=service_url,
+            **kwargs,
         )
 
-        self._config = config
+    #
 
-        if client is None:
-            client = GithubCacheServiceV1Client(
-                cache_version=self._version,
-            )
-        self._client: GithubCacheClient = client
+    def _build_request_headers(
+            self,
+            headers: ta.Optional[ta.Mapping[str, str]] = None,
+            **kwargs: ta.Any,
+    ) -> ta.Dict[str, str]:
+        return super()._build_request_headers(
+            {
+                'Accept': ';'.join([
+                    'application/json',
+                    f'api-version={GithubCacheServiceV1.API_VERSION}',
+                ]),
+                **(headers or {}),
+            },
+            **kwargs,
+        )
 
-        self._local = local
+    #
+
+    @dc.dataclass(frozen=True)
+    class Entry(GithubCacheClient.Entry):
+        artifact: GithubCacheServiceV1.ArtifactCacheEntry
+
+    def get_entry_url(self, entry: GithubCacheClient.Entry) -> ta.Optional[str]:
+        entry1 = check.isinstance(entry, self.Entry)
+        return entry1.artifact.archive_location
 
     #
 
-    async def get_file(self, key: str) -> ta.Optional[str]:
-        local_file = self._local.get_cache_file_path(key)
-        if os.path.exists(local_file):
-            return local_file
+    def _build_get_entry_url_path(self, *keys: str) -> str:
+        qp = dict(
+            keys=','.join(urllib.parse.quote_plus(k) for k in keys),
+            version=str(self._cache_version),
+        )
 
-        if (entry := await self._client.get_entry(key)) is None:
+        return '?'.join([
+            'cache',
+            '&'.join([
+                f'{k}={v}'
+                for k, v in qp.items()
+            ]),
+        ])
+
+    GET_ENTRY_SUCCESS_STATUS_CODES = (200, 204)
+
+    #
+
+    async def get_entry(self, key: str) -> ta.Optional[GithubCacheClient.Entry]:
+        obj = await self._send_request(
+            path=self._build_get_entry_url_path(self.fix_key(key, partial_suffix=True)),
+        )
+        if obj is None:
             return None
 
-        tmp_file = self._local.format_incomplete_file(local_file)
-        with unlinking_if_exists(tmp_file):
-            await self._client.download_file(entry, tmp_file)
+        return self.Entry(GithubCacheServiceV1.dataclass_from_json(
+            GithubCacheServiceV1.ArtifactCacheEntry,
+            obj,
+        ))
 
-            os.replace(tmp_file, local_file)
+    #
 
-        return local_file
+    async def download_file(self, entry: GithubCacheClient.Entry, out_file: str) -> None:
+        entry1 = check.isinstance(entry, self.Entry)
+        with log_timing_context(
+                'Downloading github cache '
+                f'key {entry1.artifact.cache_key} '
+                f'version {entry1.artifact.cache_version} '
+                f'to {out_file}',
+        ):
+            await self._download_file_chunks(
+                key=check.non_empty_str(entry1.artifact.cache_key),
+                url=check.non_empty_str(entry1.artifact.archive_location),
+                out_file=out_file,
+            )
 
-    async def put_file(
+    #
+
+    async def _upload_file(self, key: str, in_file: str) -> None:
+        fixed_key = self.fix_key(key)
+
+        check.state(os.path.isfile(in_file))
+        file_size = os.stat(in_file).st_size
+
+        #
+
+        reserve_req = GithubCacheServiceV1.ReserveCacheRequest(
+            key=fixed_key,
+            cache_size=file_size,
+            version=str(self._cache_version),
+        )
+        reserve_resp_obj = await self._send_request(
+            path='caches',
+            json_content=GithubCacheServiceV1.dataclass_to_json(reserve_req),
+            success_status_codes=[201],
+        )
+        reserve_resp = GithubCacheServiceV1.dataclass_from_json(  # noqa
+            GithubCacheServiceV1.ReserveCacheResponse,
+            reserve_resp_obj,
+        )
+        cache_id = check.isinstance(reserve_resp.cache_id, int)
+
+        log.debug(f'Github cache file {os.path.basename(in_file)} got id {cache_id}')  # noqa
+
+        #
+
+        url = f'{self._service_url}/caches/{cache_id}'
+
+        await self._upload_file_chunks(
+            in_file=in_file,
+            url=url,
+            key=fixed_key,
+            file_size=file_size,
+        )
+
+        #
+
+        commit_req = GithubCacheServiceV1.CommitCacheRequest(
+            size=file_size,
+        )
+        await self._send_request(
+            path=f'caches/{cache_id}',
+            json_content=GithubCacheServiceV1.dataclass_to_json(commit_req),
+            success_status_codes=[204],
+        )
+
+    async def upload_file(self, key: str, in_file: str) -> None:
+        with log_timing_context(
+                f'Uploading github cache file {os.path.basename(in_file)} '
+                f'key {key}',
+        ):
+            await self._upload_file(key, in_file)
+
+
+########################################
+# ../github/api/v2/client.py
+
+
+##
+
+
+class GithubCacheServiceV2Client(BaseGithubCacheClient):
+    BASE_URL_ENV_VAR = register_github_env_var('ACTIONS_RESULTS_URL')
+
+    def __init__(
             self,
-            key: str,
-            file_path: str,
             *,
-            steal: bool = False,
-    ) -> str:
-        cache_file_path = await self._local.put_file(
-            key,
-            file_path,
-            steal=steal,
+            base_url: ta.Optional[str] = None,
+
+            **kwargs: ta.Any,
+    ) -> None:
+        if base_url is None:
+            base_url = check.non_empty_str(self.BASE_URL_ENV_VAR())
+        service_url = GithubCacheServiceV2.get_service_url(base_url)
+
+        super().__init__(
+            service_url=service_url,
+            **kwargs,
         )
 
-        await self._client.upload_file(key, cache_file_path)
+    #
 
-        return cache_file_path
+    async def _send_method_request(
+            self,
+            method: GithubCacheServiceV2.Method[
+                GithubCacheServiceV2RequestT,
+                GithubCacheServiceV2ResponseT,
+            ],
+            request: GithubCacheServiceV2RequestT,
+            **kwargs: ta.Any,
+    ) -> ta.Optional[GithubCacheServiceV2ResponseT]:
+        obj = await self._send_request(
+            path=method.name,
+            json_content=dc.asdict(request),  # type: ignore[call-overload]
+            **kwargs,
+        )
+
+        if obj is None:
+            return None
+        return method.response(**obj)
 
     #
 
-    async def get_data(self, key: str) -> ta.Optional[DataCache.Data]:
-        local_file = self._local.get_cache_file_path(key)
-        if os.path.exists(local_file):
-            return DataCache.FileData(local_file)
+    @dc.dataclass(frozen=True)
+    class Entry(GithubCacheClient.Entry):
+        request: GithubCacheServiceV2.GetCacheEntryDownloadUrlRequest
+        response: GithubCacheServiceV2.GetCacheEntryDownloadUrlResponse
 
-        if (entry := await self._client.get_entry(key)) is None:
+        def __post_init__(self) -> None:
+            check.state(self.response.ok)
+            check.non_empty_str(self.response.signed_download_url)
+
+    def get_entry_url(self, entry: GithubCacheClient.Entry) -> ta.Optional[str]:
+        entry2 = check.isinstance(entry, self.Entry)
+        return check.non_empty_str(entry2.response.signed_download_url)
+
+    #
+
+    async def get_entry(self, key: str) -> ta.Optional[GithubCacheClient.Entry]:
+        version = str(self._cache_version).zfill(GithubCacheServiceV2.VERSION_LENGTH)
+
+        req = GithubCacheServiceV2.GetCacheEntryDownloadUrlRequest(
+            key=self.fix_key(key),
+            restore_keys=[self.fix_key(key, partial_suffix=True)],
+            version=version,
+        )
+
+        resp = await self._send_method_request(
+            GithubCacheServiceV2.GET_CACHE_ENTRY_DOWNLOAD_URL_METHOD,
+            req,
+        )
+        if resp is None or not resp.ok:
             return None
 
-        return DataCache.UrlData(check.non_empty_str(self._client.get_entry_url(entry)))
+        return self.Entry(
+            request=req,
+            response=resp,
+        )
 
-    async def put_data(self, key: str, data: DataCache.Data) -> None:
-        await FileCacheDataCache(self).put_data(key, data)
+    #
 
+    async def download_file(self, entry: GithubCacheClient.Entry, out_file: str) -> None:
+        entry2 = check.isinstance(entry, self.Entry)
+        with log_timing_context(
+                'Downloading github cache '
+                f'key {entry2.response.matched_key} '
+                f'version {entry2.request.version} '
+                f'to {out_file}',
+        ):
+            await self._download_file_chunks(
+                key=check.non_empty_str(entry2.response.matched_key),
+                url=check.non_empty_str(entry2.response.signed_download_url),
+                out_file=out_file,
+            )
 
-########################################
-# ../github/cli.py
-"""
-See:
- - https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28
-"""
+    #
 
+    async def _upload_file(self, key: str, in_file: str) -> None:
+        fixed_key = self.fix_key(key)
 
-class GithubCli(ArgparseCli):
-    @argparse_cmd()
-    def list_referenced_env_vars(self) -> None:
-        print('\n'.join(sorted(ev.k for ev in GITHUB_ENV_VARS)))
+        check.state(os.path.isfile(in_file))
+        file_size = os.stat(in_file).st_size
 
-    @argparse_cmd(
-        argparse_arg('key'),
-    )
-    async def get_cache_entry(self) -> None:
-        client = GithubCacheServiceV1Client()
-        entry = await client.get_entry(self.args.key)
-        if entry is None:
-            return
-        print(json_dumps_pretty(dc.asdict(entry)))  # noqa
+        #
 
-    @argparse_cmd(
-        argparse_arg('repository-id'),
-    )
-    def list_cache_entries(self) -> None:
-        raise NotImplementedError
+        version = str(self._cache_version).zfill(GithubCacheServiceV2.VERSION_LENGTH)
+
+        reserve_resp = check.not_none(await self._send_method_request(
+            GithubCacheServiceV2.CREATE_CACHE_ENTRY_METHOD,  # type: ignore[arg-type]
+            GithubCacheServiceV2.CreateCacheEntryRequest(
+                key=fixed_key,
+                version=version,
+            ),
+        ))
+        check.state(reserve_resp.ok)
+
+        log.debug(f'Github cache file {os.path.basename(in_file)} upload reserved for file size {file_size}')  # noqa
+
+        #
+
+        upload_chunks = self._generate_file_upload_chunks(
+            in_file=in_file,
+            url=reserve_resp.signed_upload_url,
+            key=fixed_key,
+            file_size=file_size,
+        )
+
+        az_chunks = [
+            AzureBlockBlobUploader.FileChunk(
+                in_file=in_file,
+                offset=c.offset,
+                size=c.size,
+            )
+            for c in upload_chunks
+        ]
+
+        async def az_make_request(req: AzureBlockBlobUploader.Request) -> AzureBlockBlobUploader.Response:
+            u_req = urllib.request.Request(  # noqa
+                req.url,
+                method=req.method,
+                headers=req.headers or {},
+                data=req.body,
+            )
+
+            u_resp, u_body = await self._send_urllib_request(u_req)
+
+            return AzureBlockBlobUploader.Response(
+                status=u_resp.status,
+                headers=dict(u_resp.headers),
+                data=u_body,
+            )
+
+        az_uploader = AzureBlockBlobUploader(
+            reserve_resp.signed_upload_url,
+            az_make_request,
+            concurrency=self._concurrency,
+        )
+
+        await az_uploader.upload_file(az_chunks)
+
+        #
+
+        commit_resp = check.not_none(await self._send_method_request(
+            GithubCacheServiceV2.FINALIZE_CACHE_ENTRY_METHOD,  # type: ignore[arg-type]
+            GithubCacheServiceV2.FinalizeCacheEntryUploadRequest(
+                key=fixed_key,
+                size_bytes=file_size,
+                version=version,
+            ),
+        ))
+        check.state(commit_resp.ok)
+
+        log.debug(f'Github cache file {os.path.basename(in_file)} upload complete, entry id {commit_resp.entry_id}')  # noqa
+
+    async def upload_file(self, key: str, in_file: str) -> None:
+        with log_timing_context(
+                f'Uploading github cache file {os.path.basename(in_file)} '
+                f'key {key}',
+        ):
+            await self._upload_file(key, in_file)
 
 
 ########################################
@@ -9619,20 +10098,129 @@ async def build_cache_served_docker_image_data_server_routes(
 
 
 ########################################
-# ../github/inject.py
+# ../github/cache.py
 
 
 ##
 
 
-def bind_github() -> InjectorBindings:
-    lst: ta.List[InjectorBindingOrBindings] = [
-        inj.bind(GithubCache, singleton=True),
-        inj.bind(DataCache, to_key=GithubCache),
-        inj.bind(FileCache, to_key=GithubCache),
-    ]
+class GithubCache(FileCache, DataCache):
+    @dc.dataclass(frozen=True)
+    class Config:
+        pass
 
-    return inj.as_bindings(*lst)
+    DEFAULT_CLIENT_VERSION: ta.ClassVar[int] = 2
+
+    DEFAULT_CLIENTS_BY_VERSION: ta.ClassVar[ta.Mapping[int, ta.Callable[..., GithubCacheClient]]] = {
+        1: GithubCacheServiceV1Client,
+        2: GithubCacheServiceV2Client,
+    }
+
+    def __init__(
+            self,
+            config: Config = Config(),
+            *,
+            client: ta.Optional[GithubCacheClient] = None,
+            default_client_version: ta.Optional[int] = None,
+
+            version: ta.Optional[CacheVersion] = None,
+
+            local: DirectoryFileCache,
+    ) -> None:
+        super().__init__(
+            version=version,
+        )
+
+        self._config = config
+
+        if client is None:
+            client_cls = self.DEFAULT_CLIENTS_BY_VERSION[default_client_version or self.DEFAULT_CLIENT_VERSION]
+            client = client_cls(
+                cache_version=self._version,
+            )
+        self._client: GithubCacheClient = client
+
+        self._local = local
+
+    #
+
+    async def get_file(self, key: str) -> ta.Optional[str]:
+        local_file = self._local.get_cache_file_path(key)
+        if os.path.exists(local_file):
+            return local_file
+
+        if (entry := await self._client.get_entry(key)) is None:
+            return None
+
+        tmp_file = self._local.format_incomplete_file(local_file)
+        with unlinking_if_exists(tmp_file):
+            await self._client.download_file(entry, tmp_file)
+
+            os.replace(tmp_file, local_file)
+
+        return local_file
+
+    async def put_file(
+            self,
+            key: str,
+            file_path: str,
+            *,
+            steal: bool = False,
+    ) -> str:
+        cache_file_path = await self._local.put_file(
+            key,
+            file_path,
+            steal=steal,
+        )
+
+        await self._client.upload_file(key, cache_file_path)
+
+        return cache_file_path
+
+    #
+
+    async def get_data(self, key: str) -> ta.Optional[DataCache.Data]:
+        local_file = self._local.get_cache_file_path(key)
+        if os.path.exists(local_file):
+            return DataCache.FileData(local_file)
+
+        if (entry := await self._client.get_entry(key)) is None:
+            return None
+
+        return DataCache.UrlData(check.non_empty_str(self._client.get_entry_url(entry)))
+
+    async def put_data(self, key: str, data: DataCache.Data) -> None:
+        await FileCacheDataCache(self).put_data(key, data)
+
+
+########################################
+# ../github/cli.py
+"""
+See:
+ - https://docs.github.com/en/rest/actions/cache?apiVersion=2022-11-28
+"""
+
+
+class GithubCli(ArgparseCli):
+    @argparse_cmd()
+    def list_referenced_env_vars(self) -> None:
+        print('\n'.join(sorted(ev.k for ev in GITHUB_ENV_VARS)))
+
+    @argparse_cmd(
+        argparse_arg('key'),
+    )
+    async def get_cache_entry(self) -> None:
+        client = GithubCacheServiceV1Client()
+        entry = await client.get_entry(self.args.key)
+        if entry is None:
+            return
+        print(json_dumps_pretty(dc.asdict(entry)))  # noqa
+
+    @argparse_cmd(
+        argparse_arg('repository-id'),
+    )
+    def list_cache_entries(self) -> None:
+        raise NotImplementedError
 
 
 ########################################
@@ -10325,6 +10913,23 @@ subprocesses = Subprocesses()
 SubprocessRun._DEFAULT_SUBPROCESSES = subprocesses  # noqa
 
 
+########################################
+# ../github/inject.py
+
+
+##
+
+
+def bind_github() -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(GithubCache, singleton=True),
+        inj.bind(DataCache, to_key=GithubCache),
+        inj.bind(FileCache, to_key=GithubCache),
+    ]
+
+    return inj.as_bindings(*lst)
+
+
 ########################################
 # ../requirements.py
 """