Second cut

Author: dralley

pulp_rust/app/urls.py

@@ -1,17 +1,26 @@
 from django.conf import settings
 from django.urls import path, re_path
 
-from pulp_rust.app.views import IndexRoot, CargoApiViewSet
+from pulp_rust.app.views import IndexRoot, CargoApiViewSet, CargoDownloadApiView
 
 if settings.DOMAIN_ENABLED:
     path_re = r"(?P<pulp_domain>[-a-zA-Z0-9_]+)/(?P<name>[\w-]+)/(?P<path>.*)"
-    CRATES_IO_URL = "<slug:pulp_domain>/<path:path>/"
+    CRATES_IO_URL = "pulp/cargo/<slug:pulp_domain>/<slug:repo>/"
 else:
     path_re = r"(?P<name>[\w-]+)/(?P<path>.*)"
-    CRATES_IO_URL = "<path:path>/"
+    CRATES_IO_URL = "pulp/cargo/<slug:repo>/"
 
 
 urlpatterns = [
-    path(CRATES_IO_URL, IndexRoot.as_view({"get": "retrieve"}), name="crates-io-root"),
-    re_path(rf"^pulp/cargo/{path_re}$", CargoApiViewSet.as_view({"get": "retrieve"})),
+    path(CRATES_IO_URL + "config.json", IndexRoot.as_view({"get": "retrieve"}), name="index-root"),
+    path(
+        CRATES_IO_URL + "api/v1/crates/<str:package>/<str:version>/<path:rest>",
+        CargoDownloadApiView.as_view(),
+        name="cargo-download-api",
+    ),
+    path(CRATES_IO_URL + "/<path:path>", CargoApiViewSet.as_view({"get": "retrieve"}), name="cargo-api"),
+
+
+
+    # re_path(rf"^pulp/cargo/{path_re}$", CargoApiViewSet.as_view({"get": "retrieve"})),
 ]

pulp_rust/app/views.py

@@ -1,11 +1,12 @@
 import json
 import logging
 
+from rest_framework.views import APIView
 from rest_framework.viewsets import ViewSet
 from rest_framework.renderers import BrowsableAPIRenderer, JSONRenderer, TemplateHTMLRenderer
 from rest_framework.response import Response
 from rest_framework.decorators import api_view
-from rest_framework.exceptions import NotAcceptable
+from rest_framework.exceptions import NotAcceptable, Throttled
 from django.core.exceptions import ObjectDoesNotExist
 from django.shortcuts import redirect
 from datetime import datetime, timezone, timedelta
@@ -32,20 +33,19 @@
 from pulpcore.plugin.tasking import dispatch
 from pulpcore.plugin.util import get_domain, get_url
 
-from pulp_rust.app.models import RustDistribution, RustContent
+from pulp_rust.app.models import RustDistribution, RustRepository, RustContent
 from pulp_rust.app.serializers import (
     IndexRootSerializer,
     RustContentSerializer,
 )
-
 from pulp_rust.app import tasks
 
 log = logging.getLogger(__name__)
 
 ORIGIN_HOST = settings.CONTENT_ORIGIN if settings.CONTENT_ORIGIN else settings.PYPI_API_HOSTNAME
 BASE_CONTENT_URL = urljoin(ORIGIN_HOST, settings.CONTENT_PATH_PREFIX)
 BASE_API_URL = settings.CRATES_IO_API_HOSTNAME
-CRATES_IO_API_URL = urljoin(BASE_API_URL, "/api/v1/crates/")
+CRATES_IO_API = "/api/v1/crates/"
 
 
 class ApiMixin:
@@ -55,22 +55,18 @@ class ApiMixin:
 
     @property
     def distribution(self):
-        if self._distro:
-            return self._distro
-
-        path = self.kwargs["path"]
-        distro = self.get_distribution(path)
-        self._distro = distro
-        return distro
+        if not self._distro:
+            self._distro = self.get_distribution(self.kwargs["repo"])
+        return self._distro
 
     @staticmethod
-    def get_distribution(path):
+    def get_distribution(repo):
         """Finds the distribution associated with this base_path."""
         distro_qs = RustDistribution.objects.select_related(
             "repository", "repository_version", "remote"
         )
         try:
-            return distro_qs.get(base_path=path, pulp_domain=get_domain())
+            return distro_qs.get(base_path=repo, pulp_domain=get_domain())
         except ObjectDoesNotExist:
             raise Http404(f"No RustDistribution found for base_path {path}")
 
@@ -104,18 +100,29 @@ def initial(self, request, *args, **kwargs):
         """Perform common initialization tasks for API endpoints."""
         super().initial(request, *args, **kwargs)
         domain_name = get_domain().name
+        log.warning(self.kwargs)
+        repo = self.kwargs["repo"]
         if settings.DOMAIN_ENABLED:
-            self.base_content_url = urljoin(BASE_CONTENT_URL, f"{domain_name}/")
-            self.base_api_url = urljoin(BASE_API_URL, f"{domain_name}/")
+            self.base_content_url = urljoin(BASE_CONTENT_URL, f"pulp/cargo/{domain_name}/{repo}/")
+            self.base_api_url = urljoin(BASE_API_URL, f"pulp/cargo/{domain_name}/{repo}/")
+            self.base_download_url = urljoin(
+                BASE_API_URL, f"pulp/cargo/{domain_name}/{repo}{CRATES_IO_API}"
+            )
         else:
-            self.base_content_url = BASE_CONTENT_URL
-            self.base_api_url = BASE_API_URL
+            self.base_content_url = urljoin(BASE_CONTENT_URL, f"pulp/cargo/{repo}/")
+            self.base_api_url = urljoin(BASE_API_URL, f"pulp/cargo/{repo}/")
+            self.base_download_url = urljoin(BASE_API_URL, f"pulp/cargo/{repo}{CRATES_IO_API}")
+
+    @classmethod
+    def urlpattern(cls):
+        """Mocking NamedModelViewSet behavior to get Cargo APIs to support RBAC access polices."""
+        return f"pulp/cargo/{cls.endpoint_name}"
 
 
 class CargoApiViewSet(ApiMixin, ViewSet):
     """View for the Cargo JSON metadata endpoint."""
 
-    endpoint_name = "api/v1/crates/"
+    endpoint_name = "api"
     DEFAULT_ACCESS_POLICY = {
         "statements": [
             {
@@ -131,7 +138,7 @@ class CargoApiViewSet(ApiMixin, ViewSet):
         responses={200: RustContentSerializer},
         summary="Get package metadata",
     )
-    def retrieve(self, request, path, meta):
+    def retrieve(self, request, path):
         """
         Retrieve crate metadata for the sparse protocol.
 
@@ -149,7 +156,7 @@ def retrieve(self, request, path, meta):
             return HttpResponseNotFound("No content available")
 
         # Extract crate name from the path
-        meta_path = PurePath(meta)
+        meta_path = PurePath(path)
         crate_name = meta_path.name.lower()
 
         # Query for all versions of this crate
@@ -222,8 +229,71 @@ def retrieve(self, request, path):
         """Gets index route."""
         return Response(
             data={
-                "dl": CRATES_IO_API_URL,
-                "api": BASE_API_URL,
+                "dl": self.base_download_url,
+                "api": self.base_api_url,
                 "auth-required": False,
             }
         )
+
+
+class CargoDownloadApiView(APIView):
+    """
+    ViewSet for interacting with maven deploy API
+    """
+
+    model = RustRepository
+    queryset = RustRepository.objects.all()
+
+    lookup_field = "name"
+
+    # Authentication disabled for now
+    authentication_classes = []
+    permission_classes = []
+
+    def redirect_to_content_app(self, distribution, relative_path, request):
+        scheme = request.META.get("HTTP_X_FORWARDED_PROTO", request.scheme)
+        hostname = request.META.get("HTTP_X_FORWARDED_HOST", request.get_host())
+        content_origin = f"{scheme}://{hostname}"
+        return redirect(
+            f"{content_origin}{settings.CONTENT_PATH_PREFIX}"
+            f"{get_full_path(distribution.base_path)}/{relative_path}"
+        )
+
+    def get_repository_and_distributions(self, name):
+        repository = get_object_or_404(RustRepository, name=name, pulp_domain=get_domain())
+        distribution = get_object_or_404(
+            RustDistribution, repository=repository, pulp_domain=get_domain()
+        )
+        return repository, distribution
+
+    def get(self, request, name, version):
+        """
+        Responds to GET requests about packages by reference
+        """
+        repo, distro = self.get_repository_and_distributions(name)
+        content = get_object_or_404(RustPackage, name=name, vers=version, pk__in=repo.latest_version().content)
+        relative_path = content.contentartifact_set.get().relative_path
+        return self.redirect_to_content_app(distro, relative_path, request)
+
+
+def has_task_completed(task):
+    """
+    Verify whether an immediate task ran properly.
+
+    Returns:
+        bool: True if the task ended successfully.
+
+    Raises:
+        Exception: If an error occured during the task's runtime.
+        Throttled: If the task did not run due to resource constraints.
+
+    """
+    if task.state == "completed":
+        task.delete()
+        return True
+    elif task.state == "canceled":
+        raise Throttled()
+    else:
+        error = task.error
+        task.delete()
+        raise Exception(str(error))