@kernel-sig/console 0.1.0

package/backend/app/domain/meeting.py

@@ -0,0 +1,408 @@
+"""SIG 例会纪要解析。
+
+数据源是 Etherpad 上的活文档 ``etherpad.openeuler.org/p/Kernel-meetings``，
+历次会议按时间倒序累积在同一页。它是人写的自由文本，所以这里的解析器
+按"尽力而为"设计：能认出来的字段就取，认不出来就跳过，绝不抛异常。
+
+理由很直接 —— 下一次有人换个格式写纪要时，抛异常会让整场会议的数据
+一起消失；而少解析一个字段只是少一条信息。上游是外部输入，不能要求它
+稳定。
+
+纪要里最有价值的部分是「进展update」议题，它其实是**结构化的版本合入报告**：
+
+    【OLK-6.6】
+    OLK-6.6开发分支tag更新到6.6.0-170.0.0，期间合入补丁590个
+    git log 6.6.0-167.0.0..6.6.0-170.0.0 --oneline --no-merges | wc -l
+    ISO镜像和update rpm包获取链接：
+            https://repo.openeuler.org/openEuler-24.03-LTS-SP1
+    CVE: (124)
+    CVE-2026-74739,CVE-2026-74544,...
+    Bugfix:
+    nfs: use nfsi->rwsem to protect traversal of the file lock list
+                    https://atomgit.com/openeuler/kernel/pull/26235
+    Feature:
+    ...
+
+这一段既是双周合入总结，也是各版本的 release notes：tag 区间、补丁数、
+CVE 清单、按类别归好的补丁列表。解析出来就能直接把 PR 号链回本地 PR 表。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import date
+from itertools import pairwise
+
+from app.domain.release import normalize_branch_name
+
+# 【2026/9/4 14:00 Kernel SIG 双周例会】；早期会议没写时间
+_MEETING_HEADER = re.compile(
+    r"^【\s*(\d{4})/(\d{1,2})/(\d{1,2})(?:\s+(\d{1,2}:\d{2}))?\s*([^】]+?)\s*】\s*$"
+)
+
+# 【OLK-6.6】—— 必须是整行只有标签，否则是「【OLK-6.6】xxx」这种带前缀的议题标题
+_PROGRESS_HEADER = re.compile(r"^【\s*([^】]+?)\s*】\s*$")
+
+# 一、上期遗留问题跟踪 / 二、议题列表
+_SECTION = re.compile(r"^([一二三四五六七八九十]+)、\s*(.+)$")
+
+# 议题一：进展update（吴腾达）；编号有重复也有占位的 X
+_AGENDA = re.compile(r"^议题\s*([一二三四五六七八九十\dXx]+)\s*[：:]\s*(.*)$")
+
+# 轮值主持：关文涛【轮值主持顺序：曾昭荣->桑力鹏->...】
+_HOST = re.compile(r"^轮值主持\s*[：:]\s*([^【（(]+)")
+_HOST_ORDER = re.compile(r"【[^】]*顺序\s*[：:]\s*([^】]+)】")
+_NEXT_HOST = re.compile(r"^下次轮值主持\s*[：:]\s*(.+?)\s*$")
+_MEETING_URL = re.compile(r"^会议链接\s*[：:]\s*(\S+)\s*$")
+_MINUTES_URL = re.compile(r"^会议纪要\s*[：:]\s*(\S+)\s*$")
+
+# 分支 tag 更新：OLK-6.6开发分支tag更新到6.6.0-170.0.0，期间合入补丁590个
+_TAG_UPDATE = re.compile(r"更新到\s*([\w.\-]+)\s*[，,]\s*期间合入补丁\s*(\d+)\s*个")
+# git log 6.6.0-167.0.0..6.6.0-170.0.0 --oneline --no-merges | wc -l
+_GIT_RANGE = re.compile(r"git log\s+([\w.\-]+)\.\.([\w.\-]+)")
+_ISO_SECTION = re.compile(r"^ISO\s*镜像|^ISO镜像|获取链接\s*[：:]")
+_CVE_SECTION = re.compile(r"^CVE\s*[：:]\s*[（(]?\s*(\d*)\s*[)）]?\s*$")
+_CVE_ID = re.compile(r"CVE-\d{4}-\d{4,7}")
+
+# 分组标题：短的、以冒号结尾、可带 (N) 计数。Bugfix: / LTS：/ 灵衢: (13)
+_PROGRESS_GROUP = re.compile(r"^([^：:\s][^：:]{0,23}?)\s*[：:]\s*(?:[（(]\s*(\d+)\s*[)）])?\s*$")
+
+# 缩进的 URL 行（补丁链接、镜像链接）
+_INDENTED_URL = re.compile(r"^\s+(\S+://\S+)\s*$")
+
+# PR / Issue 链接。atomgit 与 gitcode 都在用，都要认。
+_LINK = re.compile(
+    r"https?://(?:www\.)?(?:atomgit\.com|gitcode\.com)/[\w.\-]+/[\w.\-]+/"
+    r"(pull|merge_requests|issues?)/(\d+)",
+    re.IGNORECASE,
+)
+
+# 被截断的链接，末尾没有编号（实测存在，如 ".../pull/"）
+_TRUNCATED_LINK = re.compile(
+    r"https?://(?:www\.)?(?:atomgit\.com|gitcode\.com)/[\w.\-]+/[\w.\-]+/(?:pull|issues?)/\s*$",
+    re.IGNORECASE,
+)
+
+# 分组标题里出现这些词说明它不是补丁分组，是别的段落标题
+_NOT_A_GROUP = ("ISO", "获取链接", "git log", "镜像")
+
+# 纪要里留着给人填写的模板行，不是真议题。
+# 当成议题收录会让每场会议都凭空多出一个汇报人是"汇报人"的条目。
+_TEMPLATE_MARKERS = ("其他议题在这里补充", "议题在这里补充", "格式：议题名称")
+
+
+@dataclass
+class ProgressItem:
+    """进展报告里的一条补丁。"""
+
+    title: str
+    pull_number: int | None = None
+    url: str | None = None
+
+
+@dataclass
+class ProgressGroup:
+    """补丁分组。``count`` 是作者自己写的条数，可能与实际条数不一致。"""
+
+    name: str
+    count: int | None = None
+    items: list[ProgressItem] = field(default_factory=list)
+
+
+@dataclass
+class BranchProgress:
+    """一个分支在一期内的合入情况。"""
+
+    branch: str
+    from_tag: str | None = None
+    to_tag: str | None = None
+    patch_count: int | None = None
+    """作者自报的合入补丁数。"""
+
+    iso_urls: list[str] = field(default_factory=list)
+    cve_ids: list[str] = field(default_factory=list)
+    groups: list[ProgressGroup] = field(default_factory=list)
+
+    @property
+    def listed_patch_count(self) -> int:
+        """分组里实际列出的补丁条数。与 ``patch_count`` 不必然相等。"""
+        return sum(len(group.items) for group in self.groups)
+
+
+@dataclass
+class AgendaDraft:
+    num: str
+    title: str
+    owner: str | None
+    body: str
+    pull_numbers: list[int] = field(default_factory=list)
+    issue_numbers: list[int] = field(default_factory=list)
+    progress: list[BranchProgress] = field(default_factory=list)
+
+
+@dataclass
+class MeetingDraft:
+    date: date
+    time: str | None
+    title: str
+    host: str | None = None
+    host_order: list[str] = field(default_factory=list)
+    next_host: str | None = None
+    meeting_url: str | None = None
+    minutes_url: str | None = None
+    legacy: str = ""
+    agendas: list[AgendaDraft] = field(default_factory=list)
+
+    @property
+    def pull_numbers(self) -> list[int]:
+        seen: dict[int, None] = {}
+        for agenda in self.agendas:
+            for number in agenda.pull_numbers:
+                seen.setdefault(number, None)
+        return list(seen)
+
+
+# ---------------------------------------------------------------------------
+# 会议纪要
+# ---------------------------------------------------------------------------
+
+
+def parse_pad(text: str) -> list[MeetingDraft]:
+    """把整页 Etherpad 文本切成按时间倒序的会议列表。
+
+    切分依据是会议标题行，而不是分隔线 —— 分隔线是人工画的，
+    有的会议没画（实测 17 场里就有），靠它切会漏。
+    """
+    lines = text.splitlines()
+    starts = [index for index, line in enumerate(lines) if _MEETING_HEADER.match(line)]
+    if not starts:
+        return []
+
+    # 末尾补一行长度作为最后一场的右界
+    bounds = [*starts, len(lines)]
+    meetings: list[MeetingDraft] = []
+    for begin, end in pairwise(bounds):
+        draft = _parse_meeting(lines[begin:end])
+        if draft is not None:
+            meetings.append(draft)
+    return meetings
+
+
+def _parse_meeting(block: list[str]) -> MeetingDraft | None:
+    header = _MEETING_HEADER.match(block[0])
+    if header is None:
+        return None
+
+    year, month, day, time_text, title = header.groups()
+    try:
+        meeting_date = date(int(year), int(month), int(day))
+    except ValueError:
+        # 手写日期会有 2/30 这种不存在的值。丢掉一场，不要丢掉整页。
+        return None
+
+    draft = MeetingDraft(date=meeting_date, time=time_text, title=title.strip())
+
+    section = ""
+    agenda: AgendaDraft | None = None
+    legacy_lines: list[str] = []
+    body: list[str] = []
+
+    def commit(current: AgendaDraft | None, lines: list[str]) -> None:
+        if current is None:
+            return
+        _finish_agenda(current, lines)
+        if not _is_template(current):
+            draft.agendas.append(current)
+
+    for line in block[1:]:
+        if draft.host is None and (match := _HOST.match(line)):
+            draft.host = match.group(1).strip()
+            if order := _HOST_ORDER.search(line):
+                draft.host_order = [
+                    part.strip() for part in re.split(r"->|→", order.group(1)) if part.strip()
+                ]
+            continue
+        if draft.next_host is None and (match := _NEXT_HOST.match(line)):
+            draft.next_host = match.group(1).strip()
+            continue
+        if draft.meeting_url is None and (match := _MEETING_URL.match(line)):
+            draft.meeting_url = match.group(1)
+            continue
+        if draft.minutes_url is None and (match := _MINUTES_URL.match(line)):
+            draft.minutes_url = match.group(1)
+            continue
+
+        if match := _SECTION.match(line):
+            commit(agenda, body)
+            agenda, body = None, []
+            section = match.group(2).strip()
+            continue
+
+        if match := _AGENDA.match(line):
+            commit(agenda, body)
+            agenda = _split_agenda(match.group(1), match.group(2))
+            body = []
+            continue
+
+        if agenda is not None:
+            body.append(line)
+        elif "遗留" in section:
+            legacy_lines.append(line)
+
+    commit(agenda, body)
+    draft.legacy = "\n".join(legacy_lines).strip()
+    return draft
+
+
+def _split_agenda(num: str, rest: str) -> AgendaDraft:
+    """拆出「标题（汇报人）」。中英文括号与全角空格都出现过。"""
+    rest = rest.strip()
+    owner = None
+    match = re.search(r"[（(]\s*([^（()）]+?)\s*[)）]\s*$", rest)
+    if match:
+        owner = match.group(1).strip()
+        rest = rest[: match.start()].strip()
+    return AgendaDraft(num=num.strip(), title=rest, owner=owner, body="")
+
+
+def _is_template(agenda: AgendaDraft) -> bool:
+    """模板占位议题。"""
+    return any(marker in agenda.title for marker in _TEMPLATE_MARKERS)
+
+
+def _finish_agenda(agenda: AgendaDraft, body: list[str]) -> None:
+    agenda.body = "\n".join(body).strip()
+    for match in _LINK.finditer(agenda.body):
+        kind, number = match.group(1).lower(), int(match.group(2))
+        if kind.startswith("issue"):
+            agenda.issue_numbers.append(number)
+        else:
+            agenda.pull_numbers.append(number)
+
+    # 只有「进展update」这类议题才带版本报告
+    if "进展" in agenda.title or "update" in agenda.title.lower():
+        agenda.progress = parse_progress_report(agenda.body)
+
+
+# ---------------------------------------------------------------------------
+# 版本进展报告
+# ---------------------------------------------------------------------------
+
+
+def parse_progress_report(text: str) -> list[BranchProgress]:
+    """从议题正文里抽出各分支的合入报告。
+
+    用一个显式状态机而不是正则一把梭：正文里 ``xxx:`` 形态的行太多，
+    补丁标题本身常含冒号（``nfs: use ...``），靠单条正则区分分组标题和
+    补丁标题必然互相误伤。
+    """
+    blocks: list[BranchProgress] = []
+    current: BranchProgress | None = None
+    group: ProgressGroup | None = None
+    mode = ""  # "" | "iso" | "cve"
+
+    pending_title: str | None = None
+
+    def flush_item(url: str | None = None) -> None:
+        nonlocal pending_title
+        if pending_title is None:
+            return
+        if current is not None and group is not None:
+            group.items.append(
+                ProgressItem(
+                    title=pending_title,
+                    pull_number=_pull_number(url) if url else None,
+                    url=url,
+                )
+            )
+        pending_title = None
+
+    for raw in text.splitlines():
+        line = raw.rstrip()
+        stripped = line.strip()
+
+        if match := _PROGRESS_HEADER.match(line):
+            flush_item()
+            current = BranchProgress(branch=normalize_branch_name(match.group(1)))
+            blocks.append(current)
+            group = None
+            mode = ""
+            continue
+
+        if current is None:
+            continue
+
+        if not stripped:
+            continue
+
+        # 补丁标题的下一行是缩进 URL
+        if (match := _INDENTED_URL.match(line)) and pending_title is not None:
+            flush_item(match.group(1))
+            continue
+        if _TRUNCATED_LINK.search(stripped):
+            # 编号被截断的链接：保留标题，但不猜编号
+            flush_item(None)
+            continue
+
+        flush_item()
+
+        if match := _TAG_UPDATE.search(stripped):
+            current.to_tag = match.group(1)
+            current.patch_count = int(match.group(2))
+            mode = ""
+            continue
+        if match := _GIT_RANGE.search(stripped):
+            current.from_tag = match.group(1)
+            current.to_tag = match.group(2)
+            mode = ""
+            continue
+        if _ISO_SECTION.match(stripped):
+            mode = "iso"
+            group = None
+            continue
+        if match := _CVE_SECTION.match(stripped):
+            mode = "cve"
+            group = None
+            continue
+        if stripped in ("CVE", "CVE:"):
+            mode = "cve"
+            group = None
+            continue
+
+        if mode == "iso":
+            # 镜像链接有时不带缩进
+            if "://" in stripped:
+                current.iso_urls.append(stripped)
+                continue
+            mode = ""
+
+        if mode == "cve":
+            found = _CVE_ID.findall(stripped)
+            if found:
+                current.cve_ids.extend(found)
+                # CVE 清单可能跨多行
+                continue
+            mode = ""
+
+        if match := _PROGRESS_GROUP.match(stripped):
+            name, count = match.group(1).strip(), match.group(2)
+            if not any(token in name for token in _NOT_A_GROUP) and "://" not in name:
+                group = ProgressGroup(name=name, count=int(count) if count else None)
+                current.groups.append(group)
+                continue
+
+        pending_title = stripped
+
+    flush_item()
+    return blocks
+
+
+def _pull_number(url: str | None) -> int | None:
+    if not url:
+        return None
+    match = _LINK.search(url)
+    if match is None:
+        return None
+    kind, number = match.group(1).lower(), int(match.group(2))
+    return number if not kind.startswith("issue") else None

package/backend/app/domain/release.py

@@ -0,0 +1,163 @@
+"""版本与分支的归类。
+
+openEuler 内核分两条线（见 sig/Kernel/README.md）：创新版本追求新特性验证，
+稳定版本（LTS / OLK）质量优先、维护期长。两条线的评审标准不同，
+混在一个列表里维护者没法按线分流，所以这里先把分支名解释成结构化事实。
+
+命名从名称能推出来的部分由代码推，推不出来的（生命周期、上游基线）留给
+``ksp_release_branch`` 登记表由人填 —— 猜测版本基线只会造出一个看起来
+权威、实际是编造的字段。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class BranchKind(StrEnum):
+    """分支所属的产品线。"""
+
+    OLK = "olk"
+    LTS = "lts"
+    INNOVATION = "innovation"
+    OTHER = "other"
+
+
+# OLK-6.6 / OLK-5.10
+_OLK = re.compile(r"^OLK-(\d+)\.(\d+)$", re.IGNORECASE)
+# openEuler-24.03-LTS、openEuler-22.03-LTS-SP4、openEuler-1.0-LTS
+# 版本号不限定两位：1.0-LTS 是真实存在的分支，而且 PR 量最大的一条
+_LTS = re.compile(r"^openEuler-(\d+\.\d+)-LTS(?:-SP(\d+))?$", re.IGNORECASE)
+# openEuler-26.09 这类 yy.mm 且非 LTS 的即创新版本
+_INNOVATION = re.compile(r"^openEuler-(\d{2})\.(\d{2})$", re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class BranchSpec:
+    """分支名的结构化解释。"""
+
+    name: str
+    """规范化后的名字。用于分组与展示。"""
+
+    kind: BranchKind
+    raw: str = ""
+    """上游原始名字。用于回查数据 —— 库里的 ``target_branch`` 存的就是它。"""
+
+    series: str | None = None
+    """发行版系列，如 ``24.03-LTS``。OLK 分支没有系列。"""
+
+    sp: int | None = None
+    """Service Pack 序号。"""
+
+    upstream_base: str | None = None
+    """上游内核基线，仅 OLK 分支可从名字推得。"""
+
+
+def normalize_branch_name(name: str) -> str:
+    """归一化分支名，只处理能确定等价的差异。
+
+    实测数据里同一个交付有四种写法混用：
+
+        openEuler-24.03-LTS-SP1     openEuler-24.03-LTS_SP1
+        openEuler-24.03-LTS         openEuler-24.03_LTS
+
+    不归一化会让同一个版本在统计里裂成两行，每个版本页的合入数都偏小。
+
+    只统一 ``LTS`` 与 ``SP\\d+`` 前后的分隔符与大小写。其余部分原样保留：
+    分支名大小写敏感，改错了会指向不存在的引用，因此不做泛化的小写化。
+    """
+    if not name:
+        return name
+    normalized = name.strip()
+    normalized = re.sub(r"[-_](lts)(?=[-_]|$)", "-LTS", normalized, flags=re.IGNORECASE)
+    normalized = re.sub(r"[-_](sp)(\d+)", r"-SP\2", normalized, flags=re.IGNORECASE)
+    return normalized
+
+
+def classify_branch(name: str) -> BranchSpec:
+    """把分支名解释成产品线、系列与 SP 序号。
+
+    认不出来的分支不报错：openEuler 会开临时分支，且分支名是外部输入。
+    归到 ``OTHER`` 后仍会出现在分支页，只是不带产品线标签。
+    """
+    raw = name.strip() if name else name
+    normalized = normalize_branch_name(name)
+
+    if match := _OLK.match(normalized):
+        version = f"{match.group(1)}.{match.group(2)}"
+        return BranchSpec(
+            name=normalized,
+            kind=BranchKind.OLK,
+            raw=raw,
+            upstream_base=version,
+        )
+
+    if match := _LTS.match(normalized):
+        version, sp = match.groups()
+        return BranchSpec(
+            name=normalized,
+            kind=BranchKind.LTS,
+            raw=raw,
+            series=f"{version}-LTS",
+            sp=int(sp) if sp else None,
+        )
+
+    if match := _INNOVATION.match(normalized):
+        return BranchSpec(
+            name=normalized,
+            kind=BranchKind.INNOVATION,
+            raw=raw,
+            series=match.group(0).removeprefix("openEuler-"),
+        )
+
+    return BranchSpec(name=normalized, kind=BranchKind.OTHER, raw=raw)
+
+
+# ---------------------------------------------------------------------------
+# 内核 tag
+# ---------------------------------------------------------------------------
+
+# 6.6.0-170.0.0 / 5.10.0-331.0.0 / 6.6.0-165
+_KERNEL_TAG = re.compile(r"^(\d+\.\d+)\.(\d+)-(\d+)(?:\.\d+)*$")
+
+
+@dataclass(frozen=True)
+class KernelTag:
+    base: str
+    """上游基线，如 ``6.6``。"""
+
+    build: int
+    """构建号，如 170。同一基线下单调递增。"""
+
+    raw: str
+
+
+def parse_kernel_tag(tag: str) -> KernelTag | None:
+    """解析 ``6.6.0-170.0.0`` 形态的 tag。
+
+    构建号是判断"两个 tag 之间合入了多少"的锚点：会议纪要里
+    ``6.6.0-167.0.0..6.6.0-170.0.0`` 就是靠它界定的区间。
+    """
+    match = _KERNEL_TAG.match(tag.strip())
+    if not match:
+        return None
+    return KernelTag(base=match.group(1), build=int(match.group(3)), raw=tag.strip())
+
+
+def compare_tags(left: str, right: str) -> int | None:
+    """按 (基线, 构建号) 比较两个 tag。无法解析时返回 None。
+
+    不能按字符串比：``6.6.0-99.0.0`` 字典序小于 ``6.6.0-170.0.0``，
+    但 9 与 170 的大小关系取决于先比构建号还是先比文本 —— 只有解析成
+    整数才不会在构建号跨过位数时翻车。
+    """
+    left_tag, right_tag = parse_kernel_tag(left), parse_kernel_tag(right)
+    if left_tag is None or right_tag is None:
+        return None
+    if left_tag.base != right_tag.base:
+        return None
+    if left_tag.build == right_tag.build:
+        return 0
+    return 1 if left_tag.build > right_tag.build else -1