Close middleware setup parity gaps

Author: johnnygreco

projects/openshell-middleware-init/src/openshell_middleware_init/generator.py

@@ -5,6 +5,7 @@
 import ctypes
 import errno
 import hashlib
+import http.client
 import json
 import os
 import re
@@ -24,7 +25,6 @@
 from datetime import datetime, timezone
 from importlib.resources import files
 from pathlib import Path
-from typing import Any
 
 from openshell_middleware_init import __version__
 
@@ -36,6 +36,61 @@
 _PYTHON_PACKAGE_PATTERN = re.compile(r"^[a-z][a-z0-9_]*$")
 _PROJECT_NAME_PATTERN = re.compile(r"^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$")
 _NETWORK_ATTEMPTS = 4
+_RUST_KEYWORDS = {
+    "abstract",
+    "as",
+    "async",
+    "await",
+    "become",
+    "box",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "do",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "final",
+    "fn",
+    "for",
+    "gen",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "macro",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "override",
+    "priv",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "try",
+    "type",
+    "typeof",
+    "union",
+    "unsized",
+    "unsafe",
+    "use",
+    "virtual",
+    "where",
+    "while",
+    "yield",
+}
 
 
 class InitializationError(RuntimeError):
@@ -74,6 +129,7 @@ class TemplateContext:
     distribution_name: str
     package_name: str
     rust_crate_name: str
+    rust_lib_name: str
     service_name: str
 
     @property
@@ -83,6 +139,7 @@ def replacements(self) -> Mapping[str, str]:
             "__DISTRIBUTION_NAME__": self.distribution_name,
             "__PACKAGE_NAME__": self.package_name,
             "__RUST_CRATE_NAME__": self.rust_crate_name,
+            "__RUST_LIB_NAME__": self.rust_lib_name,
             "__SERVICE_NAME__": self.service_name,
         }
 
@@ -125,6 +182,7 @@ def initialize_project(
                 dir=destination.parent,
             )
         )
+        staging_path.chmod(0o755)
         _write_reservation_metadata(reservation, staging_path)
         proto, proto_url = downloader(version)
         _validate_proto(proto, version)
@@ -185,7 +243,8 @@ def _template_context(name: str, language: str, package_name: str | None) -> Tem
         raise InitializationError("--package-name is only valid with --language python")
 
     distribution_name = re.sub(r"[._]+", "-", normalized_name)
-    derived_package = re.sub(r"[^a-z0-9]+", "_", normalized_name).strip("_")
+    identifier = re.sub(r"[^a-z0-9]+", "_", normalized_name).strip("_")
+    derived_package = identifier
     if not derived_package or not derived_package[0].isalpha():
         derived_package = f"middleware_{derived_package}".rstrip("_")
     effective_package = package_name if package_name is not None else derived_package
@@ -195,11 +254,17 @@ def _template_context(name: str, language: str, package_name: str | None) -> Tem
             "lowercase letters, digits, and underscores"
         )
     service_name = normalized_name.replace("_", "-").replace(".", "-")
+    rust_lib_name = identifier
+    rust_crate_name = distribution_name
+    if not rust_lib_name[0].isalpha() or rust_lib_name in _RUST_KEYWORDS:
+        rust_lib_name = f"middleware_{rust_lib_name}"
+        rust_crate_name = f"middleware-{distribution_name}"
     return TemplateContext(
         project_name=normalized_name,
         distribution_name=distribution_name,
         package_name=effective_package,
-        rust_crate_name=distribution_name,
+        rust_crate_name=rust_crate_name,
+        rust_lib_name=rust_lib_name,
         service_name=service_name,
     )
 
@@ -223,9 +288,8 @@ def _resolve_latest_version() -> str:
         headers={"User-Agent": f"openshell-middleware-init/{__version__}"},
     )
     try:
-        with _urlopen_with_retries(request) as response:
-            resolved_url = response.geturl()
-    except (OSError, urllib.error.URLError) as error:
+        _, resolved_url = _fetch_url(request)
+    except (OSError, urllib.error.URLError, http.client.IncompleteRead) as error:
         raise InitializationError("could not resolve OpenShell's latest release") from error
     prefix = f"{_REPOSITORY_URL}/releases/tag/"
     if not resolved_url.startswith(prefix):
@@ -243,30 +307,47 @@ def _download_proto(version: str) -> tuple[bytes, str]:
         headers={"User-Agent": f"openshell-middleware-init/{__version__}"},
     )
     try:
-        with _urlopen_with_retries(request) as response:
-            return response.read(), url
-    except (OSError, urllib.error.URLError) as error:
+        body, _ = _fetch_url(request)
+        return body, url
+    except urllib.error.HTTPError as error:
+        if error.code == 404:
+            raise InitializationError(
+                f"{version} does not expose {_PROTO_PATH}; choose a middleware-capable release"
+            ) from error
+        raise InitializationError(
+            f"could not download {_PROTO_PATH} for {version}: HTTP {error.code}"
+        ) from error
+    except (OSError, urllib.error.URLError, http.client.IncompleteRead) as error:
         raise InitializationError(
-            f"{version} does not expose {_PROTO_PATH}; choose a middleware-capable release"
+            f"could not download {_PROTO_PATH} for {version}: {_network_error_reason(error)}"
         ) from error
 
 
-def _urlopen_with_retries(request: urllib.request.Request) -> Any:
-    """Open a URL with the same initial attempt plus three retries as the spike."""
+def _fetch_url(request: urllib.request.Request) -> tuple[bytes, str]:
+    """Fetch a complete response with the same transfer retries as the spike."""
     for attempt in range(_NETWORK_ATTEMPTS):
         try:
-            return urllib.request.urlopen(request, timeout=30)
+            with urllib.request.urlopen(request, timeout=30) as response:
+                return response.read(), response.geturl()
         except urllib.error.HTTPError as error:
             retryable = error.code in {408, 429} or 500 <= error.code < 600
             if not retryable or attempt == _NETWORK_ATTEMPTS - 1:
                 raise
-        except (OSError, urllib.error.URLError):
+        except (OSError, urllib.error.URLError, http.client.IncompleteRead):
             if attempt == _NETWORK_ATTEMPTS - 1:
                 raise
         time.sleep(0.25 * (2**attempt))
     raise AssertionError("network retry loop exhausted without returning or raising")
 
 
+def _network_error_reason(
+    error: OSError | urllib.error.URLError | http.client.IncompleteRead,
+) -> str:
+    if isinstance(error, urllib.error.URLError):
+        return str(error.reason)
+    return str(error)
+
+
 def _validate_proto(proto: bytes, version: str) -> None:
     required_fragments = (
         b"package openshell.middleware.v1;",

projects/openshell-middleware-init/src/openshell_middleware_init/templates/rust/Cargo.toml

@@ -5,6 +5,9 @@ edition = "2024"
 rust-version = "1.90"
 publish = false
 
+[lib]
+name = "__RUST_LIB_NAME__"
+
 [dependencies]
 prost = "0.14"
 prost-types = "0.14"

projects/openshell-middleware-init/src/openshell_middleware_init/templates/rust/src/main.rs

@@ -1,6 +1,6 @@
 use std::{env, error::Error, net::SocketAddr};
 
-use __PACKAGE_NAME__::middleware_service;
+use __RUST_LIB_NAME__::middleware_service;
 use tonic::transport::Server;
 
 #[tokio::main]

projects/openshell-middleware-init/tests/test_generator.py

@@ -3,8 +3,10 @@
 import ctypes
 import email.message
 import errno
+import http.client
 import json
 import os
+import stat
 import subprocess
 import sys
 import urllib.error
@@ -77,8 +79,11 @@ def test_generates_rust_project_with_normalized_crate_name(tmp_path: Path) -> No
     )
 
     assert result.run_command == "cargo run -- 127.0.0.1:50051"
-    assert 'name = "request-audit"' in (destination / "Cargo.toml").read_text()
+    cargo = (destination / "Cargo.toml").read_text()
+    assert 'name = "request-audit"' in cargo
+    assert '[lib]\nname = "request_audit"' in cargo
     assert "use request_audit::" in (destination / "src/main.rs").read_text()
+    assert stat.S_IMODE(destination.stat().st_mode) == 0o755
     manifest = json.loads((destination / "middleware-dev-manifest.json").read_text())
     assert manifest["languages"] == ["rust"]
     assert manifest["python_package"] is None
@@ -115,6 +120,33 @@ def test_numeric_project_name_gets_importable_python_package(tmp_path: Path) ->
     assert (destination / "src/middleware_123/server.py").is_file()
 
 
+@pytest.mark.parametrize(
+    ("name", "crate", "library"),
+    [
+        ("123", "middleware-123", "middleware_123"),
+        ("type", "middleware-type", "middleware_type"),
+    ],
+)
+def test_rust_project_names_get_valid_explicit_library_names(
+    tmp_path: Path, name: str, crate: str, library: str
+) -> None:
+    destination = tmp_path / name
+
+    initialize_project(
+        name=name,
+        language="rust",
+        requested_version="v0.0.86",
+        destination=destination,
+        download_proto=local_proto,
+        command_runner=no_op_runner,
+    )
+
+    cargo = (destination / "Cargo.toml").read_text()
+    assert f'name = "{crate}"' in cargo
+    assert f'[lib]\nname = "{library}"' in cargo
+    assert f"use {library}::middleware_service;" in (destination / "src/main.rs").read_text()
+
+
 def test_unsupported_platform_fails_before_filesystem_changes(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
@@ -378,7 +410,7 @@ def fail(*args: object, **kwargs: object) -> None:
     monkeypatch.setattr(generator.urllib.request, "urlopen", fail)
     monkeypatch.setattr(generator.time, "sleep", lambda _: None)
 
-    with pytest.raises(InitializationError, match="middleware-capable release"):
+    with pytest.raises(InitializationError, match=r"could not download.*missing"):
         generator._download_proto("v1.2.3")
 
 
@@ -401,6 +433,26 @@ def transient(*args: object, **kwargs: object) -> FakeResponse:
     assert attempts == 3
 
 
+def test_download_retries_interrupted_response_body(monkeypatch: pytest.MonkeyPatch) -> None:
+    attempts = 0
+
+    class InterruptedResponse(FakeResponse):
+        def read(self) -> bytes:
+            raise http.client.IncompleteRead(b"partial")
+
+    def interrupted_then_complete(*args: object, **kwargs: object) -> FakeResponse:
+        nonlocal attempts
+        del args, kwargs
+        attempts += 1
+        return InterruptedResponse() if attempts == 1 else FakeResponse(body=PROTO)
+
+    monkeypatch.setattr(generator.urllib.request, "urlopen", interrupted_then_complete)
+    monkeypatch.setattr(generator.time, "sleep", lambda _: None)
+
+    assert generator._download_proto("v1.2.3")[0] == PROTO
+    assert attempts == 2
+
+
 @pytest.mark.parametrize(("status", "expected_attempts"), [(503, 4), (404, 1)])
 def test_download_retries_only_retryable_http_statuses(
     monkeypatch: pytest.MonkeyPatch, status: int, expected_attempts: int
@@ -422,7 +474,8 @@ def fail(*args: object, **kwargs: object) -> None:
     monkeypatch.setattr(generator.urllib.request, "urlopen", fail)
     monkeypatch.setattr(generator.time, "sleep", lambda _: None)
 
-    with pytest.raises(InitializationError, match="middleware-capable release"):
+    expected_message = "middleware-capable release" if status == 404 else "HTTP 503"
+    with pytest.raises(InitializationError, match=expected_message):
         generator._download_proto("v1.2.3")
 
     assert attempts == expected_attempts