// 端到端处理管道。
//
// 前面几层各自都能单独用,但现场最常见的诉求是一句话:
// 「给我一段 TCP 字节流,还我可以直接写进库的数据」。
// Pipeline 把 分帧 → 解码 → 分包重组 → 转 Point → 规则校验 → 导出
// 串成一次 feed,并保留全过程统计,方便接监控。
///|
/// 全链路计数。字段对外只读,通过访问器取值,避免调用方直接改统计。
pub struct Stats {
mut frames : Int32
mut rejected : Int32
mut points : Int32
mut findings : Int32
mut errors : Int32
mut overflow : Int32
mut dropped_groups : Int32
mut pending_parts : Int32
}
///|
pub fn Stats::new() -> Stats {
{
frames: 0,
rejected: 0,
points: 0,
findings: 0,
errors: 0,
overflow: 0,
dropped_groups: 0,
pending_parts: 0,
}
}
///|
pub fn Stats::frames(self : Stats) -> Int32 {
self.frames
}
///|
pub fn Stats::rejected(self : Stats) -> Int32 {
self.rejected
}
///|
pub fn Stats::points(self : Stats) -> Int32 {
self.points
}
///|
pub fn Stats::errors(self : Stats) -> Int32 {
self.errors
}
///|
pub fn Stats::findings(self : Stats) -> Int32 {
self.findings
}
///|
pub fn Stats::overflow(self : Stats) -> Int32 {
self.overflow
}
///|
pub fn Stats::dropped_groups(self : Stats) -> Int32 {
self.dropped_groups
}
///|
pub fn Stats::pending_parts(self : Stats) -> Int32 {
self.pending_parts
}
///|
pub fn Stats::text(self : Stats) -> String {
"帧 \{self.frames} · 拒绝 \{self.rejected} · 数据点 \{self.points} · 发现 \{self.findings}(错误 \{self.errors}) · 缓冲区丢弃 \{self.overflow} · 未完成分包组 \{self.dropped_groups} · 待收分片 \{self.pending_parts}"
}
///|
pub fn Stats::to_json(self : Stats) -> String {
"{\"frames\":\{self.frames},\"rejected\":\{self.rejected},\"points\":\{self.points},\"findings\":\{self.findings},\"errors\":\{self.errors},\"overflow\":\{self.overflow},\"dropped_groups\":\{self.dropped_groups},\"pending_parts\":\{self.pending_parts}}"
}
///|
/// 一条产出:数据点、校验结果、按目标格式渲染好的一行。
pub(all) struct Output {
point : Point
findings : Array[Finding]
line : String
}
///|
/// 管道本体。构造后反复 feed 即可,内部保留分帧与重组的残余状态。
pub struct Pipeline {
framer : Framer
reassembler : Reassembler
rules : RuleSet
format : Format
columns : Array[String]
stats : Stats
mut group_meta : Point?
}
///|
pub fn Pipeline::new(
rules : RuleSet,
format : Format,
columns : Array[String],
) -> Pipeline {
{
framer: Framer::new(),
reassembler: Reassembler::new(),
rules,
format,
columns,
stats: Stats::new(),
group_meta: None,
}
}
///|
pub fn Pipeline::stats(self : Pipeline) -> Stats {
self.stats
}
///|
pub fn Pipeline::format(self : Pipeline) -> Format {
self.format
}
///|
pub fn Pipeline::header(self : Pipeline) -> String {
match self.format {
Csv => csv_header(self.columns)
_ => ""
}
}
///|
fn is_error(s : Severity) -> Bool {
match s {
Error => true
_ => false
}
}
///|
fn emit(
point : Point,
rules : RuleSet,
format : Format,
columns : Array[String],
stats : Stats,
out : Array[Output],
) -> Unit {
let findings = rules.check(point)
stats.points = stats.points + 1
stats.findings = stats.findings + findings.length()
for f in findings {
if is_error(f.severity) {
stats.errors = stats.errors + 1
}
}
out.push({ point, findings, line: render_line(point, format, columns), })
}
///|
/// 喂入一段文本,返回这段文本里能确认的全部产出。
///
/// 分包帧不会逐片出数据点:会先送进重组器,收齐后按包号拼成一条
/// 完整数据点再输出。这样上层拿到的永远是逻辑完整的一条记录。
pub fn Pipeline::feed(self : Pipeline, chunk : String) -> Array[Output] {
let out : Array[Output] = []
for event in self.framer.feed(chunk) {
match event {
Good(frame) => {
self.stats.frames = self.stats.frames + 1
if frame.segment.flag.is_split() {
let meta = frame.to_point()
if self.group_meta is None {
self.group_meta = Some(
Point::new(meta.timestamp, meta.source, meta.measurement),
)
}
self.stats.pending_parts = self.stats.pending_parts + 1
match self.reassembler.push(frame) {
Pending(_, _) => ()
Complete(area) => {
let merged = match self.group_meta {
Some(m) => Point::new(m.timestamp, m.source, m.measurement)
None =>
Point::new(meta.timestamp, meta.source, meta.measurement)
}
merged.add_area(area)
emit(
merged,
self.rules,
self.format,
self.columns,
self.stats,
out,
)
self.group_meta = None
self.stats.pending_parts = 0
}
Conflict(_) => {
self.stats.rejected = self.stats.rejected + 1
self.group_meta = None
self.stats.pending_parts = 0
}
NotSplit => ()
}
} else {
emit(
frame.to_point(),
self.rules,
self.format,
self.columns,
self.stats,
out,
)
}
}
Bad(_, _) => self.stats.rejected = self.stats.rejected + 1
Noise(_) => ()
Overflow(_) => self.stats.overflow = self.stats.overflow + 1
}
}
self.stats.dropped_groups = self.reassembler.dropped()
out
}
///|
/// 一次性处理整段文本,返回渲染结果。
///
/// 刻意复用 feed,而不是另写一遍:统计口径与流式调用必须完全一致,
/// 否则「批量跑一遍看看」和「上线跑流」会得到两套数字。
pub fn Pipeline::run(self : Pipeline, text : String) -> String {
let outputs = self.feed(text)
let points : Array[Point] = []
for o in outputs {
points.push(o.point)
}
render_all(points, self.format, self.columns)
}