Public repos only

[hfhbd]

Due to the (stupid) design of GitHub, it's not possible to use it with internal/private repos.

Cite from GitHub support:

The https://github.com/OWNER/REPO/releases/download/TAG/ASSET URL is the browser download path. For private repositories it relies on an authenticated web session, and it will commonly return 404 to non-browser clients even if you include a personal access token in an Authorization header.
To download a private release asset with curl, use the Releases REST API and request the asset as application/octet-stream.

Using the GitHub API would be challenging/impossible with an ivy repository.

Options:

• GitHub changes its design
• Gradle adds built-in support for GitHub release assets
• Gradle adds a new api to register custom repository types Create custom ArtifactRepository type gradle/gradle#27449

I would prefer the latter.

Anyway, it should be mentioned in the README.md.

[aSemy]

Thanks! I've added a note to the README.

Until Gradle fixes gradle/gradle#27449 the only way to fix it would be the 'local Maven server' workaround, where Argh spins up a local server that will act as an intermediary and translate the requests to the correct GitHub API. Not ideal, but good enough.

[hfhbd]

Yeah, at work we use GitHub releases with an internal server that receives the GET requests from Gradle (by using ivy repo with maven layout) and uses the GH api to download the actual files. The server does not store the artifact in memory, but returns a 307 with the pre-signed url (from AWS S3 GitHub is using internally for release assets).

You can also use the GH api for public repos.

/**
 * @param requestPath [organisation]/[module]/[revision]/[artifact]-[revision](-[classifier])(.[ext])
 */
@Throws(Fault::class)
suspend fun getReleaseArtifact(
    @Header("httpPath") requestPath: String,
    @Header("Authorization") token: String,
    githubApiUrl: String,
    customConfig: HttpClientConfig<CIOEngineConfig>.() -> Unit = {
        install(HttpRequestRetry)
    },
    binaryHttpClient: HttpClient = HttpClient(CIO) {
        defaultRequest {
            url(githubApiUrl)
        }
        customConfig()
    },
): GetReleaseArtifactResult {
    val paths = requestPath.split("/")
    if (paths.size != GAV_LENGTH) {
        throw Fault(
            title = "Bad Request",
            message = "request url is not a gav",
            status = 400,
            instance = "/bad-request",
            input = null,
        )
    }

    try {
        val githubClient = createGitHubUserTokenClient(
            githubApiUrl = githubApiUrl,
            jwtToken = token.removePrefix("Bearer "),
            customConfig = customConfig,
        )

        val (organisation, _, revision, artifactRevisionClassifierExt) = paths
        val (owner, group) = organisation.split(".")

        val release = githubClient.getRelease(owner = owner, repo = group, tag = "v$revision")

        val releaseAsset = release.assets.singleOrNull {
            it.name == artifactRevisionClassifierExt
        } ?: throw Fault(
            title = "Not Found",
            message = "Couldn't find asset $artifactRevisionClassifierExt at repo $owner/$group@v$revision",
            status = 404,
            instance = "/not-found",
            input = Json.encodeToString(ListSerializer(String.serializer()), release.assets.map { it.name }),
        )

        val presignUrl = binaryHttpClient.head(releaseAsset.url) {
            accept(Application.OctetStream)
            bearerAuth(token.removePrefix("Bearer "))
        }

        return GetReleaseArtifactResult(
            assetUrl = releaseAsset.url,
            location = presignUrl.call.request.url.toString(),
        )
    } catch (fault: Fault) {
        throw fault
    } catch (e: ClientRequestException) {
        throw Fault(
            title = "Internal Server Error",
            message = e.message,
            status = e.response.status.value,
            instance = e.stackTraceToString(),
            input = e.response.bodyAsText(),
        )
    } catch (e: Exception) {
        throw Fault(
            title = "Internal Server Error",
            message = e.message ?: "Error while fetching release asset",
            status = 500,
            instance = e.stackTraceToString(),
            input = null,
        )
    }
}

private const val GAV_LENGTH = 4

class GetReleaseArtifactResult(
    @Header(STATUS_CODE_HEADER) val status: Int = 307,
    @Header("X-Github-Asset-url") val assetUrl: String,
    @Header("Location") val location: String,
)

So argh could use this code to spin a local server, but ideally, it needs to use a random port to not get any conflict or strange Gradle error messages. But changing the port of the local server will result into invalid caches and cc misses.