Test PR, don't merge

.github/workflows/pr.yml

@@ -11,24 +11,24 @@ concurrency:
 jobs:
   build:
     uses: "./.github/workflows/build.yml"
-  lint:
-    needs:
-      - "build"
-    uses: "./.github/workflows/lint.yml"
+  # lint:
+  #   needs:
+  #     - "build"
+  #   uses: "./.github/workflows/lint.yml"
   test:
     needs:
-      - "lint"
+      - "build"
     uses: "./.github/workflows/test.yml"
   docs:
     needs:
-      - "lint"
+      - "build"
     # Keep the workflow tag the same as pulpdocs_ref.
     uses: "pulp/pulp-docs/.github/workflows/docs-ci.yml@main"
     with:
       pulpdocs_ref: "main"
   codeql:
     needs:
-      - "lint"
+      - "build"
     uses: "./.github/workflows/codeql.yml"
   check-commits:
     runs-on: "ubuntu-latest"
@@ -62,7 +62,7 @@ jobs:
     runs-on: "ubuntu-latest"
     needs:
       - "check-commits"
-      - "lint"
+      # - "lint"  # Disabled
       - "test"
       - "docs"
       - "codeql"

CHANGES.md

@@ -2333,7 +2333,7 @@ No significant changes.
 
 ## 0.1.0 (2021-01-15) {: #0.1.0 }
 
-Initial release of pulp-cli.
+Initial release of pulp-cli2.
 
 
 ---

pulp-glue/pulp_glue/common/context.py

@@ -1632,21 +1632,35 @@ def upload(
         self.needs_capability("upload")
         size = os.path.getsize(file.name)
         body: t.Dict[str, t.Any] = {**kwargs}
-        if not self.pulp_ctx.fake_mode:  # Skip the uploading part in fake_mode
+
+        if not self.pulp_ctx.fake_mode:
             if chunk_size > size:
+                # Small file: direct upload
                 body["file"] = file
-            elif self.pulp_ctx.has_plugin(PluginRequirement("core", specifier=">=3.20.0")):
-                from pulp_glue.core.context import PulpUploadContext
-
-                upload_href = PulpUploadContext(self.pulp_ctx).upload_file(file, chunk_size)
-                body["upload"] = upload_href
             else:
-                from pulp_glue.core.context import PulpArtifactContext
+                # Large file: chunked upload
+                if self.pulp_ctx.has_plugin(PluginRequirement("core", specifier=">=3.20.0")):
+                    from pulp_glue.core.context import PulpUploadContext
+
+                    upload_href = PulpUploadContext(self.pulp_ctx).upload_file(file, chunk_size)
+                    body["upload"] = upload_href
+                else:
+                    from pulp_glue.core.context import PulpArtifactContext
+
+                    artifact_href = PulpArtifactContext(self.pulp_ctx).upload(file, chunk_size)
+                    body["artifact"] = artifact_href
+
+        # For rpm plugin >= 3.32.5, use synchronous upload endpoint when no repository is provided
+        # For older versions, always use the create endpoint (backward compatibility)
+        if repository is None and self.pulp_ctx.has_plugin(
+            PluginRequirement("rpm", specifier=">=3.32.5")
+        ):
+            # Temporarily disable schema validation to debug the issue
+            return self.call("upload", body=body, validate_body=True)
 
-                artifact_href = PulpArtifactContext(self.pulp_ctx).upload(file, chunk_size)
-                body["artifact"] = artifact_href
-            if repository:
-                body["repository"] = repository
+        # Repository is specified or older rpm version: use create endpoint (async path)
+        if repository is not None:
+            body["repository"] = repository
         return self.create(body=body)
 
 

pulp-glue/pulp_glue/common/openapi.py

@@ -440,13 +440,20 @@ def _render_request_body(
             )
             if content_type:
                 if validate_body:
+                    import sys
+                    schema = request_body_spec["content"][content_type]["schema"]
+                    print(f"\nDEBUG openapi.py: Validating with content_type='{content_type}'", file=sys.stderr)
+                    print(f"DEBUG openapi.py: Schema={schema}", file=sys.stderr)
+                    print(f"DEBUG openapi.py: Body keys={list(body.keys()) if isinstance(body, dict) else 'NOT_A_DICT'}", file=sys.stderr)
                     try:
                         self.validate_schema(
-                            request_body_spec["content"][content_type]["schema"],
+                            schema,
                             "body",
                             body,
                         )
+                        print(f"DEBUG openapi.py: Validation PASSED for {content_type}", file=sys.stderr)
                     except ValidationError as e:
+                        print(f"DEBUG openapi.py: Validation FAILED for {content_type}: {e}", file=sys.stderr)
                         errors.append(f"{content_type}: {e}")
                         # Try the next content-type
                         continue

pulp-glue/pulp_glue/common/schema.py

@@ -163,6 +163,12 @@ def _validate_ref(schema_ref: str, name: str, value: t.Any, components: t.Dict[s
     if not schema_ref.startswith("#/components/schemas/"):
         raise SchemaError(_("'{name}' contains an invalid reference.").format(name=name))
     schema_name = schema_ref[21:]
+    # DEBUG: Print the resolved schema
+    import sys
+    resolved_schema = components[schema_name]
+    print(f"DEBUG: Resolved schema '{schema_name}': {resolved_schema}", file=sys.stderr)
+    if "required" in resolved_schema:
+        print(f"DEBUG: Required fields: {resolved_schema['required']}", file=sys.stderr)
     validate(components[schema_name], name, value, components)
 
 
@@ -226,6 +232,10 @@ def _validate_number(
 def _validate_object(
     schema: t.Any, name: str, value: t.Any, components: t.Dict[str, t.Any]
 ) -> None:
+    import sys
+    print(f"DEBUG _validate_object: name='{name}', value keys={list(value.keys()) if isinstance(value, dict) else 'NOT_A_DICT'}", file=sys.stderr)
+    print(f"DEBUG _validate_object: schema.get('required')={schema.get('required')}", file=sys.stderr)
+
     _assert_type(name, value, dict, "object")
     extra_values = {}
     properties = schema.get("properties", {})
@@ -247,6 +257,7 @@ def _validate_object(
                 validate(additional_properties, f"{name}[{pname}]", pvalue, components)
     if (required := schema.get("required")) is not None:
         if missing_keys := set(required) - set(value.keys()):
+            print(f"DEBUG _validate_object: THROWING ValidationError! required={required}, value.keys()={list(value.keys())}, missing={missing_keys}", file=sys.stderr)
             raise ValidationError(
                 _("'{name}' is missing properties ({missing}).").format(
                     name=name, missing=", ".join(missing_keys)

pulp-glue/pulp_glue/file/context.py

@@ -1,3 +1,4 @@
+import os
 import typing as t
 
 from pulp_glue.common.context import (
@@ -69,6 +70,51 @@ def create(
 
         return result
 
+    def upload(
+        self,
+        file: t.IO[bytes],
+        chunk_size: int,
+        repository: t.Optional[PulpRepositoryContext],
+        **kwargs: t.Any,
+    ) -> t.Any:
+        """
+        Create file content by uploading a file.
+
+        File content does not support synchronous upload endpoint,
+        so this always uses the create endpoint.
+
+        Parameters:
+            file: A file like object that supports `os.path.getsize`.
+            chunk_size: Size of the chunks to upload independently.
+            repository: Repository context to add the newly created content to.
+            kwargs: Extra args specific to the content type, passed to the create call.
+
+        Returns:
+            The result of the create task.
+        """
+        self.needs_capability("upload")
+        size = os.path.getsize(file.name)
+        body: t.Dict[str, t.Any] = {**kwargs}
+
+        if not self.pulp_ctx.fake_mode:
+            if chunk_size > size:
+                body["file"] = file
+            elif self.pulp_ctx.has_plugin(PluginRequirement("core", specifier=">=3.20.0")):
+                from pulp_glue.core.context import PulpUploadContext
+
+                upload_href = PulpUploadContext(self.pulp_ctx).upload_file(file, chunk_size)
+                body["upload"] = upload_href
+            else:
+                from pulp_glue.core.context import PulpArtifactContext
+
+                artifact_href = PulpArtifactContext(self.pulp_ctx).upload(file, chunk_size)
+                body["artifact"] = artifact_href
+            if repository:
+                body["repository"] = repository
+
+        # File content always uses create endpoint (no synchronous upload support)
+        return self.create(body=body)
+
 
 class PulpFileDistributionContext(PulpDistributionContext):
     PLUGIN = "file"

pulpcore/cli/rpm/content.py

@@ -389,11 +389,14 @@ def upload(
                 _("You must specify one (and only one) of --file or --directory.")
             )
 
-        # Sanity: If directory, repository required
+        # Sanity: If directory with temp repo, repository required
         final_dest_repo_ctx = kwargs["repository"]
-        if directory and not final_dest_repo_ctx:
+        if directory and kwargs["use_temp_repository"] and not final_dest_repo_ctx:
             raise click.ClickException(
-                _("You must specify a --repository to use --directory uploads.")
+                _(
+                    "You must specify a --repository to use --use-temp-repository "
+                    "with --directory uploads."
+                )
             )
 
         # Sanity: ignore publish|use_temp unless directory has been specified
@@ -416,17 +419,20 @@ def upload(
             )
         else:
             # Upload a directory-full of RPMs
+            dest_repo_ctx = None
             try:
                 dest_repo_ctx = _determine_upload_repository(final_dest_repo_ctx, pulp_ctx, use_tmp)
                 result = _upload_rpms(entity_ctx, dest_repo_ctx, directory, chunk_size)
-                if use_tmp:
+                if use_tmp and dest_repo_ctx:
                     result = _copy_to_final(dest_repo_ctx, final_dest_repo_ctx, pulp_ctx)
             finally:
                 if use_tmp and dest_repo_ctx:
                     # Remove the tmp-upload repo
                     dest_repo_ctx.delete()
 
-        final_version_number = _latest_version_number(final_dest_repo_ctx)
+        final_version_number = (
+            _latest_version_number(final_dest_repo_ctx) if final_dest_repo_ctx else None
+        )
         if final_version_number:
             click.echo(
                 _(
@@ -488,23 +494,36 @@ def _copy_to_final(
 
 def _upload_rpms(
     entity_ctx: PulpContentContext,
-    dest_repo_ctx: PulpRpmRepositoryContext,
+    dest_repo_ctx: t.Optional[PulpRpmRepositoryContext],
     directory: t.Any,
     chunk_size: int,
 ) -> t.Any:
     rpms_path = f"{directory}/*.rpm"
     rpm_names = glob.glob(rpms_path)
     if not rpm_names:
         raise click.ClickException(_("Directory {} has no .rpm files in it.").format(directory))
-    click.echo(
-        _(
-            "About to upload {} files for {}.".format(
-                len(rpm_names),
-                dest_repo_ctx.entity["name"],
-            )
-        ),
-        err=True,
-    )
+
+    # Build message based on whether we have a repository or not
+    if dest_repo_ctx:
+        click.echo(
+            _(
+                "About to upload {} files for {}.".format(
+                    len(rpm_names),
+                    dest_repo_ctx.entity["name"],
+                )
+            ),
+            err=True,
+        )
+    else:
+        click.echo(
+            _(
+                "About to upload {} files from {}.".format(
+                    len(rpm_names),
+                    directory,
+                )
+            ),
+            err=True,
+        )
     # Upload all *.rpm into the destination
     successful_uploads = 0
     for name in rpm_names:
@@ -525,9 +544,11 @@ def _upload_rpms(
 
 
 def _determine_upload_repository(
-    final_dest_repo_ctx: PulpRpmRepositoryContext, pulp_ctx: PulpCLIContext, use_tmp: bool
-) -> PulpRpmRepositoryContext:
-    if use_tmp:
+    final_dest_repo_ctx: t.Optional[PulpRpmRepositoryContext],
+    pulp_ctx: PulpCLIContext,
+    use_tmp: bool,
+) -> t.Optional[PulpRpmRepositoryContext]:
+    if use_tmp and final_dest_repo_ctx:
         dest_repo_ctx = PulpRpmRepositoryContext(pulp_ctx)
         body: t.Dict[str, t.Any] = {
             "name": f"uploadtmp_{final_dest_repo_ctx.entity['name']}_{uuid4()}",

tests/scripts/pulp_rpm/test_content.sh

@@ -34,7 +34,7 @@ cleanup
 
 # Test rpm package upload
 wget --no-check-certificate "${RPM_WEAK_DEPS_URL}/${RPM_FILENAME}"
-expect_succ pulp rpm content upload --file "${RPM_FILENAME}" --relative-path "${RPM_FILENAME}"
+expect_succ pulp --refresh-api rpm content upload --file "${RPM_FILENAME}" --relative-path "${RPM_FILENAME}"
 PACKAGE_HREF=$(echo "${OUTPUT}" | jq -r .pulp_href)
 expect_succ pulp rpm content show --href "${PACKAGE_HREF}"