能否通过插件扩展Artifactory的PyPI仓库以兼容旧系统？

Absolutely! You can build a custom Artifactory User Plugin to resolve all three compatibility problems you’re hitting with your legacy system migration. Even though the official docs don’t explicitly call out callbacks for POST /api/pypi/<index-name>, we can use request interception in the plugin to handle these scenarios.

1. Handling PyPixmlrpc Compatibility #

Legacy scripts relying on PyPixmlrpc expect XML-RPC formatted requests/responses, which Artifactory’s native PyPI API doesn’t support. The plugin can intercept XML-RPC calls to the PyPI endpoint, translate them to Artifactory’s REST API, and format responses back to XML-RPC.

• Intercept POST requests to /api/pypi/<index-name>/rpc
• Parse the XML-RPC payload to identify the method being called (e.g., list_packages, release_urls)
• Map the method to Artifactory’s equivalent REST endpoints
• Convert Artifactory’s JSON response back to XML-RPC format for the legacy script

2. Simulating upload_docs Support #

Artifactory doesn’t natively support the upload_docs method, but we can mock this in the plugin to keep your legacy scripts working:

• Catch the upload_docs XML-RPC call
• Optionally, save the uploaded documentation files to a dedicated path in your Artifactory repository (e.g., <repo>/docs/<package-name>)
• Return a successful XML-RPC response to the script, as if the docs were uploaded

3. Adjusting register API Response Status Code #

The legacy script expects a 200 OK response from the register endpoint, but Artifactory returns 204 No Content. The plugin can override the response status code after Artifactory processes the request:

• Intercept the register method call (or the POST request to /api/pypi/<index-name> for registration)
• After Artifactory successfully registers the package, modify the response status code from 204 to 200
• Keep the response body consistent with what the legacy script expects

Sample Plugin Code (Groovy) #

import org.artifactory.request.Request
import org.artifactory.response.Response
import org.artifactory.webapp.servlet.HttpArtifactoryRequest
import groovy.xml.XmlSlurper
import groovy.xml.MarkupBuilder

def handlePyPiRequests = { Request request, Response response ->
    def path = request.getRequestURI()
    def method = request.getMethod()

    // Handle XML-RPC requests for PyPixmlrpc compatibility
    if (method == "POST" && path.endsWith("/rpc")) {
        def xmlPayload = new String(request.getInputStream().getBytes())
        def slurper = new XmlSlurper()
        def rpcRequest = slurper.parseText(xmlPayload)
        def rpcMethod = rpcRequest.methodName.text()

        // Handle upload_docs mock
        if (rpcMethod == "upload_docs") {
            // Extract package name and docs from params (customize as needed)
            def packageName = rpcRequest.params.param[0].value.string.text()
            // Optional: Save docs to Artifactory storage
            // def docsContent = rpcRequest.params.param[1].value.base64.text()
            // repositories.getRepository("pypi-local").createFile("/docs/${packageName}/index.html", docsContent.decodeBase64())
            
            // Return successful XML-RPC response
            def writer = new StringWriter()
            def xml = new MarkupBuilder(writer)
            xml.methodResponse {
                params {
                    param {
                        value {
                            boolean_(true)
                        }
                    }
                }
            }
            response.setStatus(200)
            response.setContentType("text/xml")
            response.getOutputStream().write(writer.toString().getBytes())
            return true // Skip Artifactory's native processing
        }

        // Handle register method status code adjustment
        if (rpcMethod == "register") {
            // Let Artifactory process the registration first
            def chain = request.getChain()
            chain.doFilter(request.getRequest(), response.getResponse())
            
            // Override status code from 204 to 200
            if (response.getStatus() == 204) {
                response.setStatus(200)
            }
            return true
        }

        // Add other PyPixmlrpc method mappings here (e.g., list_packages)
    }

    // For non-RPC register requests (direct POST to /api/pypi/<index>)
    if (method == "POST" && path.startsWith("/api/pypi/") && !path.endsWith("/rpc")) {
        // Check if this is a registration request (adjust logic based on your payload)
        def payload = new String(request.getInputStream().getBytes())
        if (payload.contains(":action") && payload.contains("submit")) {
            def chain = request.getChain()
            chain.doFilter(request.getRequest(), response.getResponse())
            
            if (response.getStatus() == 204) {
                response.setStatus(200)
            }
            return true
        }
    }

    return false // Let Artifactory handle other requests normally
}

// Register the request interceptor
requestInterceptors << handlePyPiRequests

Notes for Implementation #

• Test thoroughly: Deploy this plugin to a staging Artifactory instance first to validate it works with your legacy scripts.
• Customize payload parsing: Adjust the XML-RPC parsing logic to match exactly what your legacy scripts are sending (e.g., parameter order, data formats).
• Storage for docs: If you want to persist the uploaded documentation, expand the upload_docs section to save files to your desired repository path.
• Artifactory version: Ensure the plugin is compatible with your Artifactory version (most recent versions support request interceptors in user plugins).

内容的提问来源于stack exchange，提问作者Rafael Almeida