fix: filter last maven repository_url erros

Signed-off-by: Umberto Sgueglia <usgueglia@contractor.linuxfoundation.org>

Author: ulemons

services/apps/packages_worker/src/maven/__tests__/normalize.test.ts

@@ -103,6 +103,14 @@ describe('parseRepoUrl', () => {
     expect(result?.host).toBe('other')
   })
 
+  it('keeps the full path as name (no owner) for known SVN hosts', () => {
+    expect(parseRepoUrl('https://svn.apache.org/repos/asf/geronimo/server')).toEqual({
+      host: 'svn',
+      owner: null,
+      name: 'repos/asf/geronimo/server',
+    })
+  })
+
   it('returns null for invalid URLs', () => {
     expect(parseRepoUrl('not-a-url')).toBeNull()
   })
@@ -160,8 +168,40 @@ describe('normalizeScmUrl', () => {
     )
   })
 
-  it('returns null for non-https result', () => {
-    expect(normalizeScmUrl('svn://svn.apache.org/repos/commons-lang')).toBeNull()
+  it('returns null for non-https, non-SVN schemes', () => {
+    expect(normalizeScmUrl('ftp://ftp.apache.org/repos/commons-lang')).toBeNull()
+  })
+
+  // SVN has no owner/repo shape and is mapped even though the hosts are largely
+  // unreachable today — see normalizeSvnUrl / normalizeSvnScmUrl docstrings.
+  it('maps svn:// URLs on known SVN hosts to a canonical link', () => {
+    expect(normalizeScmUrl('svn://svn.apache.org/repos/asf/commons-lang/trunk')).toBe(
+      'https://svn.apache.org/repos/asf/commons-lang',
+    )
+  })
+
+  it('maps scm:svn: connection strings, unifying viewvc/repos-asf to the same link', () => {
+    expect(
+      normalizeScmUrl(
+        'scm:svn:http://svn.apache.org/repos/asf/geronimo/server/tags/geronimo-3.0.1',
+      ),
+    ).toBe('https://svn.apache.org/repos/asf/geronimo/server')
+    expect(
+      normalizeScmUrl('http://svn.apache.org/viewvc/geronimo/server/tags/geronimo-3.0.1'),
+    ).toBe('https://svn.apache.org/repos/asf/geronimo/server')
+  })
+
+  it('maps svn+ssh: with an embedded user and SourceForge /p/.../code paths', () => {
+    expect(
+      normalizeScmUrl('scm:svn:svn+ssh://albertil@svn.forge.objectweb.org/svnroot/myproj/trunk'),
+    ).toBe('https://svn.forge.objectweb.org/svnroot/myproj')
+    expect(normalizeScmUrl('http://svn.code.sf.net/p/myproj/code/trunk/foo')).toBe(
+      'https://svn.code.sf.net/p/myproj/code',
+    )
+  })
+
+  it('does not map dead services that incidentally match an "svn" text filter', () => {
+    expect(normalizeScmUrl('http://specs.googlecode.com/svn/trunk')).toBeNull()
   })
 
   // Gap B — recover repository_url from inputs that were previously dropped
@@ -480,9 +520,19 @@ describe('normalizeScmUrl', () => {
     expect(normalizeScmUrl('https://git.iem.at/owner/repo')).toBe('https://git.iem.at/owner/repo')
   })
 
-  it('still returns null for internal or non-allowlisted hosts', () => {
-    expect(normalizeScmUrl('https://git.corp.adobe.com/team/project')).toBeNull()
-    expect(normalizeScmUrl('https://gitlab.alibaba-inc.com/team/project')).toBeNull()
+  // Internal-only hosts are mapped despite being unreachable for external
+  // consumers — see the SCM_HOSTS docstring.
+  it('maps internal-only hosts (git.corp.adobe.com, gitlab.alibaba-inc.com)', () => {
+    expect(normalizeScmUrl('https://git.corp.adobe.com/team/project')).toBe(
+      'https://git.corp.adobe.com/team/project',
+    )
+    expect(normalizeScmUrl('https://gitlab.alibaba-inc.com/team/project')).toBe(
+      'https://gitlab.alibaba-inc.com/team/project',
+    )
+  })
+
+  it('still returns null for genuinely non-allowlisted hosts', () => {
+    expect(normalizeScmUrl('https://git.some-random-unlisted-host.example/team/project')).toBeNull()
   })
 
   it('preserves nested GitLab group namespaces instead of truncating to the group', () => {
@@ -515,6 +565,26 @@ describe('normalizeScmUrl', () => {
   it('returns null for a GitLab namespace with no project segment', () => {
     expect(normalizeScmUrl('https://gitlab.com/onlygroup')).toBeNull()
   })
+
+  // OpenDaylight's Gerrit: both the gitweb browse query and the SSH clone form
+  // (port, no git@ user) unify to the same gitweb browse link.
+  it('maps OpenDaylight Gerrit gitweb query and SSH clone URLs to the same link', () => {
+    expect(
+      normalizeScmUrl('https://git.opendaylight.org/gerrit/gitweb?p=netconf.git;a=summary'),
+    ).toBe('https://git.opendaylight.org/gerrit/gitweb?p=netconf.git')
+    expect(normalizeScmUrl('scm:git:ssh://git.opendaylight.org:29418/aaa.git')).toBe(
+      'https://git.opendaylight.org/gerrit/gitweb?p=aaa.git',
+    )
+  })
+
+  it('returns null for Gerrit shapes with no derivable repo identity', () => {
+    // Bare Gerrit root — no path at all, nothing to extract.
+    expect(normalizeScmUrl('http://gerrit.onosproject.org/')).toBeNull()
+    // Gerrit admin-UI fragment path — not a clone shape.
+    expect(
+      normalizeScmUrl('https://gerrit.wikimedia.org/r/#/admin/projects/wikidata/query/rdf'),
+    ).toBeNull()
+  })
 })
 
 describe('interpolateProperties', () => {

services/apps/packages_worker/src/maven/extract.ts

@@ -494,8 +494,11 @@ export async function extractArtifact(groupId: string, artifactId: string, versi
  *
  * Still NOT handled (need more than a host allowlist, or are unreachable):
  *   - eclipse.gerrithub.io: Gerrit admin-UI paths (`/admin/repos/...`), not a clone shape.
- *   - internal-only hosts (git.corp.adobe.com, gitlab.alibaba-inc.com): unreachable
- *     for consumers, so intentionally excluded.
+ *
+ * Internal-only hosts (git.corp.adobe.com, fit.corp.adobe.com, gitlab.alibaba-inc.com)
+ * are included below even though they're unreachable for external consumers — per
+ * product decision, an internal SCM URL should still resolve to a canonical link
+ * rather than being dropped to null.
  */
 const SCM_HOSTS = new Set([
   'github.com',
@@ -505,10 +508,12 @@ const SCM_HOSTS = new Set([
   'codeberg.org',
   // Self-hosted GitLab / Gitea instances seen in Maven POMs with clean
   // /<owner>/<repo> paths (same shape as gitlab.com — handled by the generic logic).
-  // Internal-only hosts (git.corp.adobe.com, gitlab.alibaba-inc.com) are excluded:
-  // their links are unreachable for consumers. The ≥2-segment owner/repo requirement
-  // acts as a safety net so a mis-classified host yields NULL, never a junk link.
+  // The ≥2-segment owner/repo requirement acts as a safety net so a mis-classified
+  // host yields NULL, never a junk link.
   'gitlab.smartb.city',
+  'git.corp.adobe.com',
+  'fit.corp.adobe.com',
+  'gitlab.alibaba-inc.com',
   'gitlab.ow2.org',
   'gitlab.nuiton.org',
   'gitlab.inria.fr',
@@ -769,6 +774,26 @@ function normalizeGooglesourceUrl(host: string, pathname: string): string | null
   return `https://${host}${path}`
 }
 
+/**
+ * OpenDaylight's self-hosted Gerrit serves the same flat (no-owner) repo naming as
+ * ASF's gitweb, in two forms seen in the wild: a gitweb browse query
+ * (`/gerrit/gitweb?p=<repo>.git;a=summary`) and an SSH clone URL with an explicit
+ * Gerrit port and no `git@` user (`ssh://git.opendaylight.org:29418/<repo>.git`).
+ * Both are unified to the gitweb browse form so the stored link is always
+ * resolvable in a browser, not just via `git clone`.
+ */
+const OPENDALIGHT_GERRIT_HOST = 'git.opendaylight.org'
+
+function normalizeOpendaylightGerritUrl(pathname: string, search: string): string | null {
+  const queryRepo = new URLSearchParams(search).get('p')
+  const segments = pathname.split('/').filter(Boolean)
+  const rawName = queryRepo ?? (segments.length === 1 ? segments[0] : null)
+  const name = rawName ? extractGitwebRepoName(rawName) : null
+  if (!name) return null
+
+  return `https://${OPENDALIGHT_GERRIT_HOST}/gerrit/gitweb?p=${name}.git`
+}
+
 /**
  * GitLab — gitlab.com and self-hosted instances — supports nested group
  * namespaces (group/subgroup/.../project), so the repository path is NOT limited
@@ -796,6 +821,133 @@ function normalizeGitlabUrl(host: string, pathname: string): string | null {
   return `https://${host}/${host === 'gitlab.com' ? path.toLowerCase() : path}`
 }
 
+/**
+ * Subversion hosts unambiguously identifiable by hostname alone (the "svn" in the
+ * name), so a bare `http://svn.apache.org/...` URL is recognised as SVN even without
+ * an `scm:svn:` connection-string prefix or `svn(+ssh)://` scheme.
+ */
+const SVN_HOSTS = new Set([
+  'svn.apache.org',
+  'svn.eu.apache.org',
+  'svn.sonatype.org',
+  'svn.forge.objectweb.org',
+  'svn.code.sf.net',
+  'svn.codehaus.org',
+  'svn.java.net',
+  'websvn.ow2.org',
+])
+
+/**
+ * Hosts that only count as SVN when explicitly marked (`scm:svn:` prefix or
+ * `svn(+ssh)://` scheme) — the bare hostname is shared with non-SVN content
+ * (java.net hosted forums, wikis, JIRA, etc. alongside its SVN forge).
+ */
+const SVN_HOSTS_REQUIRE_EXPLICIT_MARKER = new Set(['java.net'])
+
+function isSvnSourceforgeHost(host: string): boolean {
+  return host.endsWith('.svn.sourceforge.net')
+}
+
+const APACHE_SVN_HOSTS = new Set(['svn.apache.org', 'svn.eu.apache.org'])
+
+/**
+ * Whether `host` (lowercased, no `www.`) is one of the SVN hosts this module
+ * normalizes. Exported so callers persisting the normalized URL elsewhere
+ * (e.g. `parseRepoUrl` in `./normalize`) can special-case SVN's owner/repo-less
+ * path shape instead of applying a generic two-segment split.
+ */
+export function isSvnHost(host: string): boolean {
+  return (
+    SVN_HOSTS.has(host) || isSvnSourceforgeHost(host) || SVN_HOSTS_REQUIRE_EXPLICIT_MARKER.has(host)
+  )
+}
+
+/**
+ * Subversion has no owner/repo shape — its near-universal convention is
+ * <project>[/<module>]/{trunk|tags|branches}/... . The canonical link keeps
+ * everything up to (but not including) that trunk/tags/branches marker, the closest
+ * SVN equivalent of a repo root. Apache's three script fronts (viewvc, viewcvs.cgi,
+ * repos/asf) all serve the same repos, so they're unified to the /repos/asf/ form
+ * regardless of which one the declared URL used — mirrors wrapAsfRepo for git.
+ *
+ * Kept even though these hosts are largely dead/unreachable today (Apache, Sonatype
+ * and ObjectWeb's SVN forges have moved to Git) per explicit product decision: an SVN
+ * declared_repository_url should still resolve to a canonical link, not stay null.
+ */
+function normalizeSvnUrl(host: string, pathname: string): string | null {
+  const rest = pathname.replace(/^\/+/, '')
+  const markerMatch = rest.match(/^(viewvc|viewcvs\.cgi|repos\/asf|svnroot|svn|p)\/(.*)$/)
+  const scriptPrefix = markerMatch?.[1] ?? null
+  const afterPrefix = markerMatch ? markerMatch[2] : rest
+
+  const segments = afterPrefix.split('/').filter(Boolean)
+  if (segments.some((s) => /\$\{|%7B/i.test(s))) return null
+
+  if (scriptPrefix === 'p') {
+    // SourceForge /p/<project>/code/... — "code" is a fixed marker, not part of the path.
+    return segments[0] ? `https://${host}/p/${segments[0]}/code` : null
+  }
+
+  const branchMarkerIndex = segments.findIndex((s) => /^(trunk|tags|branches)$/i.test(s))
+  const projectSegments = branchMarkerIndex === -1 ? segments : segments.slice(0, branchMarkerIndex)
+
+  if (projectSegments.length === 0) {
+    // Legacy SourceForge subdomain form (<project>.svn.sourceforge.net) with no
+    // path beyond trunk/tags/branches — the project name is the subdomain itself.
+    if (isSvnSourceforgeHost(host)) {
+      const project = host.replace(/\.svn\.sourceforge\.net$/, '')
+      return project ? `https://${host}/svnroot/${project}` : null
+    }
+    return null
+  }
+
+  if (APACHE_SVN_HOSTS.has(host)) return `https://${host}/repos/asf/${projectSegments.join('/')}`
+
+  const prefix = scriptPrefix && scriptPrefix !== 'repos/asf' ? `${scriptPrefix}/` : ''
+  return `https://${host}${prefix ? `/${prefix}` : '/'}${projectSegments.join('/')}`
+}
+
+/**
+ * Detects and normalizes Maven `scm:svn:` connection strings and bare SVN URLs.
+ * Returns `undefined` when the input isn't SVN at all (falls through to the
+ * git-oriented logic below); `null` when it's SVN but not on a known SVN host or
+ * not resolvable; otherwise the canonical link.
+ */
+function normalizeSvnScmUrl(raw: string): string | null | undefined {
+  const hadSvnScmPrefix = /^scm:svn:/i.test(raw)
+  let s = raw.replace(/^scm:svn:/i, '')
+
+  const hasSvnScheme = /^svn(\+ssh)?:\/\//i.test(s)
+  s = s.replace(/^svn\+ssh:\/\//i, 'https://').replace(/^svn:\/\//i, 'https://')
+
+  if (!/^https?:\/\//i.test(s)) {
+    if (!hadSvnScmPrefix && !hasSvnScheme) return undefined
+    s = `https://${s.replace(/^https?:\/\//i, '')}`
+  }
+
+  // Strip an embedded user@ (svn+ssh://user@host/... form)
+  s = s.replace(/^(https?:\/\/)[^@/]+@/, '$1')
+
+  let parsed: URL
+  try {
+    parsed = new URL(s)
+  } catch {
+    return hadSvnScmPrefix || hasSvnScheme ? null : undefined
+  }
+
+  const host = parsed.hostname.toLowerCase().replace(/^www\./, '')
+  const isUnambiguousSvnHost = SVN_HOSTS.has(host) || isSvnSourceforgeHost(host)
+
+  if (!hadSvnScmPrefix && !hasSvnScheme && !isUnambiguousSvnHost) return undefined
+
+  const isSvnHost =
+    isUnambiguousSvnHost ||
+    (SVN_HOSTS_REQUIRE_EXPLICIT_MARKER.has(host) && (hadSvnScmPrefix || hasSvnScheme))
+  if (!isSvnHost) return null
+
+  return normalizeSvnUrl(host, parsed.pathname)
+}
+
 /**
  * Converts the raw SCM URL from a POM (declared_repository_url) into a clean,
  * canonical `https://<host>/<owner>/<repo>` repository URL suitable for storage
@@ -813,14 +965,21 @@ function normalizeGitlabUrl(host: string, pathname: string): string | null {
  *   https://github.com:owner/repo            → https://github.com/owner/repo
  *   ssh://git@github.com:owner/repo.git      → https://github.com/owner/repo
  *
+ * SVN connection strings (`scm:svn:...`, `svn(+ssh)://...`) are handled separately
+ * by normalizeSvnScmUrl, which has no owner/repo shape and is dispatched before any
+ * of the git-oriented rewriting below — see its docstring for the SVN conventions.
+ *
  * Rejected (→ null): website-only URLs (https://meson.ai/), non-SCM hosts
- * (svn://…, http://source.android.com), placeholders (Private, ${scm-url}).
+ * (http://source.android.com), placeholders (Private, ${scm-url}).
  */
 export function normalizeScmUrl(raw: string | null): string | null {
   if (!raw) return null
   let s = raw.trim()
   if (!s) return null
 
+  const svnResult = normalizeSvnScmUrl(s)
+  if (svnResult !== undefined) return svnResult
+
   // Strip Maven scm:git: / scm: prefix
   s = s.replace(/^scm:git:/i, '').replace(/^scm:/i, '')
 
@@ -836,6 +995,9 @@ export function normalizeScmUrl(raw: string | null): string | null {
   // ssh://git@host/… → https://host/…
   s = s.replace(/^ssh:\/\/git@([^/]+)\//, 'https://$1/')
 
+  // ssh://host:port/… (no git@ user, real numeric Gerrit-style port) → https://host/…
+  s = s.replace(/^ssh:\/\/([^@/:]+):\d+\//, 'https://$1/')
+
   // git:// → https://, and upgrade http:// → https:// — done before the SCP-colon
   // rule below so that git://host:owner/repo is normalised too.
   s = s.replace(/^git:\/\//, 'https://').replace(/^http:\/\//, 'https://')
@@ -879,6 +1041,10 @@ export function normalizeScmUrl(raw: string | null): string | null {
     return normalizeGitwebQueryUrl(host, parsed.search)
   }
 
+  if (host === OPENDALIGHT_GERRIT_HOST) {
+    return normalizeOpendaylightGerritUrl(parsed.pathname, parsed.search)
+  }
+
   if (ECLIPSE_CGIT_HOSTS.has(host)) {
     return normalizeEclipseCgitUrl(host, parsed.pathname)
   }

services/apps/packages_worker/src/maven/normalize.ts

@@ -1,3 +1,5 @@
+import { isSvnHost } from './extract'
+
 export function isPrerelease(version: string): boolean {
   return /-(SNAPSHOT|alpha|beta|rc|cr|m\d+|dev)/i.test(version)
 }
@@ -8,12 +10,19 @@ export function parseRepoUrl(
   try {
     const parsed = new URL(url)
     const h = parsed.hostname.toLowerCase()
+    const parts = parsed.pathname.split('/').filter(Boolean)
+
+    // SVN has no owner/repo concept — its canonical path is a single project
+    // identifier (e.g. /repos/asf/geronimo/server), so splitting it into
+    // parts[0]/parts[1] like a git host would produce garbage (owner='repos',
+    // name='asf'). Keep the whole path as `name` instead.
+    if (isSvnHost(h)) return { host: 'svn', owner: null, name: parts.join('/') || null }
+
     let host: string
     if (h === 'github.com' || h.endsWith('.github.com')) host = 'github'
     else if (h === 'gitlab.com' || h.includes('gitlab')) host = 'gitlab'
     else if (h === 'bitbucket.org') host = 'bitbucket'
     else host = 'other'
-    const parts = parsed.pathname.split('/').filter(Boolean)
     return { host, owner: parts[0] ?? null, name: parts[1] ?? null }
   } catch {
     return null