Šķîþ ţö ḿàîñ çöñţéñţ

É-01: Ţĥé þŕöçéššîñĝ éñĝîñé

Šüḿḿàŕý​

Çöñţéñţ îš þŕöçéššéđ ƃý à çĥàññéļ-ƃàšéđ šţŕéàḿîñĝ þîþéļîñé. Éàçĥ ţööļ ŕüñš îñ îţš öŵñ ĝöŕöüţîñé; ţööļš àŕé çöññéçţéđ ƃý ƃüƒƒéŕéđ çĥàññéļš ţĥàţ þŕöṽîđé àüţöḿàţîç ƃàçķþŕéššüŕé. Àñ errgroup.Group çööŕđîñàţéš éŕŕöŕš àñđ þŕöþàĝàţéš çöñţéẋţ çàñçéļļàţîöñ. Ƃļöçķ þàŕàļļéļîšḿ ŵîţĥîñ à ţööļ, ƒîļé àñđ đöçüḿéñţ çöñçüŕŕéñçý, àñđ šţŕéàḿîñĝ öƃšéŕṽàţîöñ éàçĥ ĥàṽé ţĥéîŕ öŵñ çöñţŕöļ. À ƒļöŵ îš đéçļàŕéđ àš à ĝŕàþĥ öƒ ñöđéš àñđ éđĝéš öŕ àš à ļîšţ öƒ šţéþš, àñđ îţ ŕüñš àš àñ öŕđéŕéđ çĥàîñ öƒ ţööļš: ţĥé ĥöšţ ţĥàţ ļöàđš à đéƒîñîţîöñ đéŕîṽéš ţĥàţ öŕđéŕ, àñđ à þàŕàļļéļ šţàĝé îñšîđé ţĥé çĥàîñ àđḿîţš à ƃöüñđéđ ñüḿƃéŕ öƒ Þàŕţš.

Çöñţéẋţ​

Ĝö'š ĝöŕöüţîñéš àñđ çĥàññéļš ḿàķé îţ ñàţüŕàļ ţö šţŕüçţüŕé à þîþéļîñé àš çöñçüŕŕéñţ šţàĝéš çöññéçţéđ ƃý ţýþéđ çĥàññéļš. Šüçĥ à þîþéļîñé ḿîẋéš ÇÞÜ-ƃöüñđ ŵöŕķ (ƒöŕḿàţ þàŕšîñĝ, çĥéçķš) ŵîţĥ ÎÖ-ƃöüñđ ŵöŕķ (ĻĻḾ çàļļš, ḿéḿöŕý ļööķüþš). Ţĥé šàḿé þîþéļîñé ḿüšţ àļšö ƃé đŕîṽéñ àţ šéṽéŕàļ šçàļéš: à šîñĝļé ƒîļé öñ à ļàþţöþ; ĥüñđŕéđš öƒ ƒîļéš îñ à ƃàţçĥ; à ļöñĝ-ļîṽéđ þŕöĵéçţ ŵîţĥ ḿàñý đöçüḿéñţš þŕöçéššéđ îñ þàŕàļļéļ.

Îţ ḿüšţ àļšö šüþþöŕţ ƃöţĥ đéçļàŕàţîṽé àüţĥöŕîñĝ (à ṽîšüàļ ƒļöŵ éđîţöŕ, ĥüḿàñ-ŕéàđàƃļé ÝÀḾĻ) àñđ þŕöĝŕàḿḿàţîç çöñšţŕüçţîöñ (ţĥé Ĝö ļîƃŕàŕý) ƒŕöḿ öñé đàţà ḿöđéļ.

Đéçîšîöñ​

Çĥàññéļ-ƃàšéđ þîþéļîñé​

Çöñţéñţ ƒļöŵš ţĥŕöüĝĥ à çĥàññéļ-ƃàšéđ çöñçüŕŕéñţ þîþéļîñé:

SourcebindingchanTool 1goroutinechanTool 2goroutinechan⋯chanSinkbinding

Çöñţéñţ éñţéŕš ţĥŕöüĝĥ à šöüŕçé ƃîñđîñĝ àñđ ļéàṽéš ţĥŕöüĝĥ à šîñķ ƃîñđîñĝ (É-04). Ƒöŕ ţĥé đéƒàüļţ file ƃîñđîñĝ ţĥéšé àŕé à ĐàţàƑöŕḿàţ ŕéàđéŕ àñđ ŵŕîţéŕ (É-02); à þŕöĵéçţ šţöŕé, à .kpz, öŕ àñ îñţéŕçĥàñĝé ƒîļé ƃîñđ ţĥé šàḿé šţŕéàḿ ŵîţĥ ñö ŕéàđéŕ öŕ ŵŕîţéŕ. Ƃéţŵééñ ţĥé éñđš, éàçĥ ţööļ ŕüñš îñ îţš öŵñ ĝöŕöüţîñé. Ƃüƒƒéŕéđ çĥàññéļš þŕöṽîđé ƃàçķþŕéššüŕé. errgroup.Group çööŕđîñàţéš éŕŕöŕ ĥàñđļîñĝ àçŕöšš ĝöŕöüţîñéš, àñđ çöñţéẋţ çàñçéļļàţîöñ þŕöþàĝàţéš ţö àļļ šţàĝéš.

Þàŕţš çàŕŕý ţýþéđ ŕéšöüŕçéš (Ƒ-02): Ƃļöçķš çöñţàîñ ţŕàñšļàţàƃļé çöñţéñţ, Đàţà çàŕŕîéš šţŕüçţüŕàļ ḿàŕķüþ, Ļàýéŕš ĝŕöüþ ñéšţéđ çöñţéñţ, Ḿéđîà ĥöļđš ƃîñàŕý àššéţš. Ţööļš đéçļàŕé ŵĥîçĥ ŕéšöüŕçé ţýþéš ţĥéý ĥàñđļé; ţĥé ŕéšţ þàšš ţĥŕöüĝĥ üñçĥàñĝéđ.

Éẋéçüţöŕ​

flow.DefaultExecutor öŕçĥéšţŕàţéš ţööļ çĥàîñš üšîñĝ ţĥé ĝöŕöüţîñé-þéŕ-ţööļ ḿöđéļ:

  • Éàçĥ ţööļ îñ ţĥé çĥàîñ ŕüñš îñ îţš öŵñ ĝöŕöüţîñé.
  • Ƃüƒƒéŕéđ çĥàññéļš (çöñƒîĝüŕàƃļé šîžé) çöññéçţ àđĵàçéñţ ţööļš.
  • errgroup çöļļéçţš ţĥé ƒîŕšţ éŕŕöŕ àñđ çàñçéļš ţĥé šĥàŕéđ çöñţéẋţ.
  • Þàŕàļļéļ đöçüḿéñţ þŕöçéššîñĝ îš ƃöüñđéđ ƃý à šéḿàþĥöŕé ŵöŕķéŕ þööļ.
  • ToolFactories çŕéàţé ƒŕéšĥ ţööļ îñšţàñçéš þéŕ đöçüḿéñţ, šö çöñçüŕŕéñţ đöçüḿéñţš ñéṽéŕ šĥàŕé ḿüţàƃļé ţööļ šţàţé.

Çöñƒîĝüŕàţîöñ üšéš ţĥé ƒüñçţîöñàļ-öþţîöñš þàţţéŕñ:

executor := flow.NewExecutor(
    flow.WithMaxConcurrency(8),
    flow.WithChannelSize(128),
    flow.WithCollectors(wordCounter, checkReport),
)

flow.WithImmutabilityCheck ţüŕñš öñ ţĥé þéŕ-đîšþàţçĥ çöñţéñţ-îḿḿüţàƃîļîţý ƃàçķšţöþ ƒöŕ à ŕüñ (É-03); îţ îš đéṽ/ţéšţ ţööļîñĝ àñđ îš öƒƒ üñļéšš à çàļļéŕ àšķš ƒöŕ îţ.

Þàŕàļļéļ ƃļöçķ þŕöçéššîñĝ​

Ƒöŕ ÎÖ-ƃöüñđ ţööļš (ĻĻḾ ţŕàñšļàţîöñ, ŕéḿöţé çĥéçķš), šéǫüéñţîàļ þéŕ-þàŕţ þŕöçéššîñĝ üñđéŕüţîļîžéš ţĥŕöüĝĥþüţ. tool.ParallelBlockTool ŕüñš ţĥé ƃļöçķ ĥàñđļéŕ öƒ à *tool.BaseTool öñ à ƒîẋéđ þööļ öƒ Ñ ŵöŕķéŕš ŵĥîļé þŕéšéŕṽîñĝ šţŕîçţ Þàŕţ öŕđéŕ. À ŵŕàþþéđ ţööļ öƒ àñöţĥéŕ çöñçŕéţé ţýþé, öŕ öñé ŵîţĥ ñö ţýþéđ ƃļöçķ ĥàñđļéŕ, ŕüñš ţĥŕöüĝĥ îţš öŵñ Process, àñđ à ŵŕàþþéđ SessionTool ķééþš îţš SessionProcess:

InputchanDispatcherseq numbers · N blocks admittedchanfixed pool · N workersWorker 1Worker 2Worker NchanReassemblybounded ring · in orderchanOutput

Ţĥé đîšþàţçĥéŕ ñüḿƃéŕš éṽéŕý îñçöḿîñĝ Þàŕţ àñđ àđḿîţš àţ ḿöšţ Ñ ƃļöçķš ŵĥöšé ŕéšüļţš ĥàṽé ñöţ ýéţ ŕéàçĥéđ ţĥé öüţþüţ. À ƃļöçķ ķééþš îţš þļàçé îñ ţĥàţ ŵîñđöŵ ƒŕöḿ àđḿîššîöñ üñţîļ îţ îš éḿîţţéđ, šö à šļöŵ ƒîŕšţ ƃļöçķ šţöþš ţĥé đîšþàţçĥéŕ ŕéàđîñĝ ƒüŕţĥéŕ îñþüţ éṽéñ ŵĥéñ ļàţéŕ ƃļöçķš ĥàṽé ƒîñîšĥéđ, àñđ đöŵñšţŕéàḿ ƃàçķþŕéššüŕé ŕéàçĥéš ţĥé îñþüţ. Ñöñ-Ƃļöçķ Þàŕţš çöüñţ àĝàîñšţ à šéþàŕàţé ŵîñđöŵ öƒ 4Ñ, šö Ñ ƃļöçķš šţàý îñ ƒļîĝĥţ ŵĥéñ à ŕéàđéŕ þüţš Đàţà öŕ Ĝŕöüþ Þàŕţš ƃéţŵééñ ţĥéḿ. Ŕéàššéḿƃļý ĥöļđš ţĥé àđḿîţţéđ Þàŕţš îñ à ŕîñĝ àñđ éḿîţš ţĥéḿ îñ îñþüţ öŕđéŕ, šö đöŵñšţŕéàḿ ţööļš šéé ţĥé šàḿé Þàŕţ öŕđéŕîñĝ ŵĥîçĥéṽéŕ ŵöŕķéŕ ƒîñîšĥéđ ƒîŕšţ. À đŕöþþéđ Þàŕţ àđṽàñçéš ţĥé šéǫüéñçé àñđ éḿîţš ñöţĥîñĝ.

Ŵĥéñ ţĥé îññéŕ ţööļ šéţš à ĥàñđļéŕ ƒöŕ à ñöñ-Ƃļöçķ Þàŕţ (Đàţà, Ḿéđîà, Ļàýéŕ, Ĝŕöüþ), ţĥàţ ĥàñđļéŕ ŕüñš àƒţéŕ éṽéŕý éàŕļîéŕ ƃļöçķ ĥàñđļéŕ ĥàš ƒîñîšĥéđ àñđ ƃéƒöŕé àñý ļàţéŕ ƃļöçķ šţàŕţš, šö à ĥàñđļéŕ ţĥàţ üþđàţéš ļàýéŕ öŕ ĝŕöüþ šţàţé ñéṽéŕ ŕüñš ƃéšîđé à ƃļöçķ ĥàñđļéŕ ţĥàţ ŕéàđš îţ. À ñöñ-Ƃļöçķ Þàŕţ ŵîţĥ ñö ĥàñđļéŕ þàššéš ţĥŕöüĝĥ îñ öŕđéŕ ŵîţĥöüţ ţĥàţ ŵàîţ. Ƃļöçķ ĥàñđļéŕš ḿüšţ ƃé šàƒé ţö çàļļ çöñçüŕŕéñţļý ƒöŕ đîšţîñçţ ƃļöçķš àñđ ḿüšţ öƃšéŕṽé ţĥé çöñţéẋţ ţĥéý ŕéçéîṽé: öñ àñ éŕŕöŕ öŕ çàñçéļļàţîöñ ţĥé ŵŕàþþéŕ çàñçéļš îţš ŵöŕķéŕš àñđ ĵöîñš ţĥéḿ ƃéƒöŕé îţ ŕéţüŕñš.

Àüţö-þàŕàļļéļîšḿ îš à ţööļ þŕöþéŕţý. Éàçĥ ţööļ đéçļàŕéš ToolMeta.DefaultParallelBlocks (É-03); ţĥé ŕüññéŕ ţàķéš ţĥé ḿàẋîḿüḿ àçŕöšš ţĥé ƒļöŵ'š ţööļš àñđ ŵŕàþš éṽéŕý ţööļ àţ ţĥàţ ŵîđţĥ. À þŕöĵéçţ ḿàý þîñ îţš öŵñ ṽàļüé, àñđ --parallel-blocks N öṽéŕŕîđéš ƃöţĥ (--parallel-blocks 1 đîšàƃļéš ţĥé ŵŕàþþéŕ). Ţĥé ţööļš ţĥàţ đéçļàŕé à đéƒàüļţ àŕé ţĥé ĻĻḾ-ƃàçķéđ öñéš, šö àñ öŕđîñàŕý ŕüļéš-öñļý ƒļöŵ ŕüñš šéǫüéñţîàļļý ŵîţĥ ñö çöñƒîĝüŕàţîöñ. Ţĥé ŵŕàþþéŕ þàŕàļļéļîžéš ţĥé ţýþéđ ƃļöçķ ĥàñđļéŕ öƒ à þļàîñ *tool.BaseTool öñļý. Ţĥé ĻĻḾ-ƃàçķéđ àñđ ḾŢ ţööļš éḿƃéđ BaseTool îñ ţýþéš öƒ ţĥéîŕ öŵñ, šö ţĥé ŵŕàþþéŕ ŕüñš éàçĥ öƒ ţĥéḿ ţĥŕöüĝĥ îţš öŵñ Process, ŵĥéŕé ÀÎ ţŕàñšļàţîöñ àñđ éñţîţý éẋţŕàçţîöñ ĥàṽé ţĥéîŕ öŵñ ƃàţçĥîñĝ àñđ çöñçüŕŕéñçý šéţţîñĝš. À đéçļàŕéđ đéƒàüļţ ţĥéŕéƒöŕé ŵîđéñš ţĥé þļàîñ BaseTool šţéþš ţĥàţ šĥàŕé à ƒļöŵ ŵîţĥ àñ ĻĻḾ-ƃàçķéđ ţööļ.

Ƃàţçĥ éẋéçüţöŕ​

flow.BatchExecutor þŕöçéššéš ḿüļţîþļé þŕé-ŕéàđ ƒîļéš ţĥŕöüĝĥ à ţööļ çĥàîñ ŵîţĥ çöñƒîĝüŕàƃļé ƒîļé-ļéṽéļ çöñçüŕŕéñçý:

type BatchConfig struct {
    FileConcurrency int         // max files processed in parallel (default: 1)
    ChannelSize     int         // per-pipeline channel buffer size (default: 64)
    SharedResources []io.Closer // resources shared across files (closed at end)
    FailFast        bool        // cancel remaining on first error (default: true)
}

Éàçĥ ƒîļé ĝéţš ƒŕéšĥ ţööļ îñšţàñçéš ƒŕöḿ ŢööļƑàçţöŕý ƒüñçţîöñš, þŕéṽéñţîñĝ šţàţé ļéàķàĝé ƃéţŵééñ çöñçüŕŕéñţ đöçüḿéñţš. Ŕéšüļţš àŕé ŕéţüŕñéđ îñ îñþüţ ƒîļé öŕđéŕ ŕéĝàŕđļéšš öƒ çöḿþļéţîöñ öŕđéŕ. Çöļļéçţöŕš àŕé çàļļéđ ŵîţĥ ḿüţéẋ þŕöţéçţîöñ ƒöŕ ţĥŕéàđ-šàƒé àĝĝŕéĝàţîöñ àçŕöšš ƒîļéš.

Çöñçüŕŕéñçý ļàýéŕîñĝ​

Éàçĥ éẋéçüţîöñ šüŕƒàçé ĥàš îţš öŵñ çöñçüŕŕéñçý çöñţŕöļ:

ĻàýéŕŠçöþéÇöñţŕöļÖŕđéŕ
ÞàŕàļļéļƂļöçķŢööļƂļöçķš ŵîţĥîñ öñé ţööļÑ ŵöŕķéŕš, àţ ḿöšţ Ñ àđḿîţţéđ ƃļöçķšŠţŕîçţ Þàŕţ öŕđéŕ
ƂàţçĥÉẋéçüţöŕḾüļţîþļé ƒîļéšƑîļéÇöñçüŕŕéñçý šéḿàþĥöŕéƑîļé öŕđéŕ þŕéšéŕṽéđ
ÉẋéçüţöŕḾüļţîþļé đöçüḿéñţšḾàẋÇöñçüŕŕéñçý šéḿàþĥöŕéĐöçüḿéñţ öŕđéŕ þŕéšéŕṽéđ
ŢàþþîñĝŢööļÖƃšéŕṽàţîöñÎñþüţ àñđ öüţþüţ îñţéŕçéþţöŕ ĝöŕöüţîñ隊éǫüéñţîàļ þéŕ ţööļ ƃöüñđàŕý

Ţĥé çĥàññéļ çàþàçîţîéš àñđ éàçĥ þàŕàļļéļ šţàĝé'š ŵîñđöŵš ƃöüñđ ţĥé Þàŕţš îñ ƒļîĝĥţ îñšîđé öñé ţööļ çĥàîñ, éẋçéþţ îñšîđé à ţööļ ţĥàţ ƃüƒƒéŕš îţš îñþüţ. ÀÎ ţŕàñšļàţîöñ àñđ éñţîţý éẋţŕàçţîöñ îñ ţĥéîŕ ƃàţçĥéđ ḿöđé, àñđ ḿéđîà ŕéƒîñé, ŕéàđ à ŵĥöļé đöçüḿéñţ'š Þàŕţš ƃéƒöŕé ţĥéý éḿîţ àñý; ţĥé ļàýéŕ þŕöçéššöŕ ĥöļđš öñé çĥîļđ ļàýéŕ àţ à ţîḿé. À ŕüñ'š ŵöŕķîñĝ šéţ àļšö đéþéñđš öñ ŵĥàţ šüŕŕöüñđš ţĥé çĥàîñ: Execute çöļļéçţš éàçĥ đöçüḿéñţ'š öüţþüţ Þàŕţš, BatchExecutor ţàķéš þŕé-ŕéàđ Þàŕţ šļîçéš àñđ ŕéţüŕñš öüţþüţ šļîçéš, àñđ à ƒîļé ŕüñ ƒééđš îţš ŕéàđéŕ çöñçüŕŕéñţļý öñļý ŵĥéñ ţĥé ŕéàđéŕ îš à šţŕéàḿîñĝ ŕéàđéŕ àñđ ñö þŕé-ŕéàđ çöñţéñţ îš šüþþļîéđ, ŵîţĥ à šţŕéàḿîñĝ šķéļéţöñ öñļý ŵĥéñ ţĥé ŵŕîţéŕ šţŕéàḿš ţöö. Ţĥé ƃöüñđš çöüñţ Þàŕţš, šö à šîñĝļé ļàŕĝé Ƃļöçķ öŕ à ŕéţàîñéđ šķéļéţöñ çàñ šţîļļ đöḿîñàţé ḿéḿöŕý.

Ţĥé ŵŕîţé šţàĝé​

À ƒîļé ŕüñ éñđš îñ ţĥé ƒöŕḿàţ ŵŕîţéŕ, àñđ ţĥé ŵŕîţéŕ'š ƃýţéš ŕéàçĥ ţĥé ƒîļé ţĥŕöüĝĥ ţĥé ƒîļé ĥöḿé öƒ ţĥé çĥàñĝé çöñţŕàçţ (É-09), ţĥé þļàçé éṽéŕý çĥàñĝé šéţ çöḿḿîţš ţöö. Ţĥé ƒîļé ŕüññéŕ (flow.FileRunner) đîĝéšţš ţĥé đéšţîñàţîöñ ƃéƒöŕé îţ ŕéàđš àñýţĥîñĝ, šţŕéàḿš ţĥé ŵŕîţéŕ'š öüţþüţ îñţö à ƒîļé šţàĝéđ ƃéšîđé ţĥé đéšţîñàţîöñ ŵîţĥ ţĥé đéšţîñàţîöñ'š ḿöđé (filehome.Home.Produce), àñđ çöḿḿîţš îţ: üñđéŕ ţĥé đéšţîñàţîöñ'š àđṽîšöŕý ļöçķ, ţĥé šţàĝéđ ƒîļé îš ŕéñàḿéđ öñţö ţĥé đéšţîñàţîöñ öñļý ŵĥîļé ţĥé đéšţîñàţîöñ šţîļļ ĥöļđš ŵĥàţ îţ ĥéļđ ŵĥéñ ţĥé ŕüñ ƃéĝàñ. À đéšţîñàţîöñ ţĥàţ çĥàñĝéđ ŵĥîļé ţĥé ŕüñ ŵöŕķéđ (à þéŕšöñ šàṽéđ îţ, à çĥàñĝé šéţ öŕ àñöţĥéŕ ŕüñ çöḿḿîţţéđ ƒîŕšţ) ķééþš ŵĥàţ îţ ĥöļđš, àñđ ţĥé ŕüñ ŕéþöŕţš îţ àš ḿöṽéđ (filehome.ErrMoved). À đéšţîñàţîöñ ţĥàţ àļŕéàđý ĥöļđš ţĥé ƃýţéš ţĥé ŕüñ þŕöđüçéđ îš ļéƒţ àš îţ îš. À ţööļ öŕ ŵŕîţéŕ éŕŕöŕ đîšçàŕđš ţĥé šţàĝéđ ƒîļé, šö à ƒàîļéđ ŕüñ ļéàṽéš ñö þàŕţîàļ đéšţîñàţîöñ.

À çàļļéŕ ţĥàţ ķééþš à ŕéçöŕđ öƒ ŵĥàţ à ŕüñ çĥàñĝéđ ƒöļļöŵš éàçĥ đöçüḿéñţ ţĥŕöüĝĥ FileRunnerConfig.Documents: îţ šééš éṽéŕý ƃļöçķ àš îţ ļéàṽéš ţĥé ŕéàđéŕ àñđ àš îţ ŕéàçĥéš ţĥé ŵŕîţéŕ, àñđ îţ çöḿḿîţš ţĥé šţàĝéđ đöçüḿéñţ îţšéļƒ. Ţĥé ķàþî ĥöšţ ŕéçöŕđš éàçĥ đöçüḿéñţ à ƒļöŵ ŵŕîţéš îñ à þŕöĵéçţ àš öñé content.edit, àþþļîéš ţĥé ŕüñ'š çĥàñĝéš àĝàîñ ţĥŕöüĝĥ ţĥé çĥàñĝé šéŕṽîçé ŵĥéñ ţĥé đéšţîñàţîöñ ḿöṽéđ, àñđ, üñđéŕ --print-ops, çöḿḿîţš ţĥŕöüĝĥ à ĥöḿé ţĥàţ ŵŕîţéš ñöţĥîñĝ àñđ þŕîñţš ţĥé çĥàñĝé šéţ ţĥé ŕüñ ŵöüļđ àþþļý (É-09). Ţĥé ķàþî ĥöšţ þàššéš ţĥé ĥöḿé îţš çĥàñĝé šéŕṽîçé çöḿḿîţš ţĥŕöüĝĥ, šö à ƒļöŵ àñđ à çĥàñĝé šéţ ŵŕîţîñĝ öñé ƒîļé ţàķé ţüŕñš üñđéŕ öñé ļöçķ.

Çöļļéçţöŕš àñđ šţŕéàḿîñĝ çöļļéçţöŕš​

Çöļļéçţöŕš àĝĝŕéĝàţé ŕéšüļţš àçŕöšš đöçüḿéñţš (ŵöŕđ çöüñţš, çĥéçķ ŕéþöŕţš, ţéŕḿ ļîšţš). Ţĥéý îḿþļéḿéñţ Collect(ctx, item, parts), çàļļéđ àƒţéŕ éàçĥ đöçüḿéñţ çöḿþļéţéš, àñđ Result() ƒöŕ ţĥé ƒîñàļ àĝĝŕéĝàţé. Çöļļéçţöŕš ḿüšţ ƃé ţĥŕéàđ-šàƒé šîñçé ḿüļţîþļé đöçüḿéñţš ḿàý çöḿþļéţé çöñçüŕŕéñţļý.

StreamingCollector éẋţéñđš Collector ŵîţĥ Observe(part) ƒöŕ îñļîñé öƃšéŕṽàţîöñ ŵîţĥöüţ àđđîñĝ à þîþéļîñé šţàĝé. TappingTool ŵŕàþš à ţööļ àñđ îţš šţŕéàḿîñĝ çöļļéçţöŕ: öüţþüţ Þàŕţš àŕé îñţéŕçéþţéđ àñđ þàššéđ ţö Observe() šýñçĥŕöñöüšļý ƃéƒöŕé ƒöŕŵàŕđîñĝ đöŵñšţŕéàḿ. Ţĥîš éñàƃļéš ŕéàļ-ţîḿé ḿéţŕîçš ŵîţĥöüţ ƃüƒƒéŕîñĝ ţĥé éñţîŕé ŕéšüļţ šéţ. Ţĥé ḿéţŕîçš, ţŕàçîñĝ àñđ ţàþþîñĝ ŵŕàþþéŕš šĥàŕé öñé îñţéŕçéþţöŕ: îţš îñþüţ šîđé šţöþš ŵàîţîñĝ ƒöŕ îñþüţ öñçé ţĥé çöñţéẋţ îš çàñçéļļéđ öŕ ţĥé îññéŕ ţööļ ŕéţüŕñš, îţš öüţþüţ šîđé ķééþš đŕàîñîñĝ ţĥé îññéŕ ţööļ šö à šéñđ ţĥé îññéŕ ţööļ đöéš ñöţ ĝüàŕđ šţîļļ çöḿþļéţéš, àñđ ƃöţĥ àŕé ĵöîñéđ ƃéƒöŕé ţĥé ŵŕàþþéŕ ŕéţüŕñš. À çàñçéļļéđ çöñţéẋţ šüŕƒàçéš àš ţĥé çöñţéẋţ éŕŕöŕ ŵĥéñ ţĥé îññéŕ ţööļ ŕéþöŕţš ñöñé.

Ƒļöŵ ţŕàçîñĝ àñđ ṽîšüàļîžàţîöñ​

flow.TraceRecorder çàþţüŕéš ţîḿéšţàḿþéđ éṽéñţš đüŕîñĝ ƒļöŵ éẋéçüţîöñ. flow.TracingTool ŵŕàþš éàçĥ ţööļ îñ ţĥé çĥàîñ àñđ ŕéçöŕđš éñţéŕ/éẋîţ éṽéñţš ŵîţĥ Þàŕţ šñàþšĥöţš. Ţĥé --trace path/to/trace.json ƒļàĝ öñ kapi run éñàƃļéš ţŕàçîñĝ. Ţĥé öüţþüţ îš à FlowTrace ĴŠÖÑ ƒîļé çöñţàîñîñĝ:

  • Ñöđéš: ţĥé ţööļ çĥàîñ ŵîţĥ çöñçüŕŕéñçý ḿéţàđàţà
  • Éṽéñţš: ţîḿéšţàḿþéđ éñţéŕ/éẋîţ éṽéñţš þéŕ Þàŕţ
  • Þàŕţ šñàþšĥöţš: Þàŕţ šţàţé ƃéƒöŕé àñđ àƒţéŕ éàçĥ ñöđé
  • Đüŕàţîöñ: ţöţàļ ƒļöŵ éẋéçüţîöñ ţîḿé îñ ḿîçŕöšéçöñđš

À ƃŕöŵšéŕ-ƃàšéđ ṽîšüàļîžàţîöñ ŕéñđéŕš ţĥé ţŕàçé àš àñ àñîḿàţéđ ƒļöŵ đîàĝŕàḿ ŵîţĥ þàŕţîçļéš ḿöṽîñĝ ţĥŕöüĝĥ ñöđéš, çĥàññéļ ƒîļļ îñđîçàţöŕš, àñđ ŵöŕķéŕ ļàñé šéþàŕàţîöñ ƒöŕ þàŕàļļéļ ţööļš. Ţĥé þļàýƃàçķ éñĝîñé šüþþöŕţš ṽàŕîàƃļé-šþééđ ŕéþļàý àñđ šééķîñĝ.

Öƃšéŕṽàţîöñ šéàḿ​

Ţŕàçîñĝ ţö à ƒîļé îš öñé çöñšüḿéŕ öƒ à ḿöŕé ĝéñéŕàļ šéàḿ. core/observe đéƒîñéš à Tracer / Span îñţéŕƒàçé ŵîţĥ à ñö-öþ đéƒàüļţ àñđ ñö đéþéñđéñçý öñ àñý ţéļéḿéţŕý ļîƃŕàŕý, šö îţ çöšţš ñöţĥîñĝ üñţîļ à ĥöšţ ŕéĝîšţéŕš à ţŕàçéŕ àţ šţàŕţüþ; kapi àñđ ţĥé đéšķţöþ ŕéĝîšţéŕ ñöñé. flow.WrapWithSpans ŵŕàþš éàçĥ ţööļ îñ à çĥàîñ šö ţĥàţ öñé šþàñ öþéñš þéŕ ţööļ îñṽöçàţîöñ (flow.tool), àñđ ţĥé ƒîļé ŕüññéŕ öþéñš öñé þéŕ ƒöŕḿàţ ŕéàđ àñđ ŵŕîţé (format.read, format.write). À SessionTool ķééþš îţš šéššîöñ þàţĥ ţĥŕöüĝĥ ţĥé ŵŕàþþéŕ, šö à ŕéšüḿàƃļé ŕüñ šţîļļ ŕéšüḿéš. Ḿöđéļ þŕöṽîđéŕ çàļļš çàŕŕý ţĥéîŕ öŵñ šþàñ ţĥŕöüĝĥ ţĥé šàḿé šéàḿ (É-07). Öñé šþàñ þéŕ ţööļ ŕàţĥéŕ ţĥàñ þéŕ Þàŕţ ķééþš ţĥé çöšţ þŕöþöŕţîöñàļ ţö ţĥé ĥàñđƒüļ öƒ ţööļš à ƒļöŵ ĥàš, ñöţ ţĥé ţĥöüšàñđš öƒ Þàŕţš îţ ḿöṽéš.

Ƒļöŵ đéƒîñîţîöñš​

flow.FlowDefinition îš à ĴŠÖÑ/ÝÀḾĻ-šéŕîàļîžàƃļé šţŕüçţ ţĥàţ çàþţüŕéš à ƒļöŵ ĝŕàþĥ (ñöđéš + éđĝéš) àñđ ţĥé ţööļ çöñƒîĝüŕàţîöñš ñééđéđ ţö ŕéçöñšţŕüçţ à ŕüññàƃļé ƒļöŵ. Ţĥîš šéþàŕàţéš ţĥé đéçļàŕàţîṽé đéšçŕîþţîöñ öƒ à ƒļöŵ ƒŕöḿ îţš ŕüñţîḿé éẋéçüţîöñ. Ţĥé ŕüñţîḿé flow.Flow îš ñàŕŕöŵéŕ ţĥàñ ţĥé ĝŕàþĥ: îţ ĥöļđš àñ öŕđéŕéđ []tool.Tool àñđ çöññéçţš éàçĥ ţööļ ţö ţĥé ñéẋţ, šö à ĥöšţ ţüŕñš à đéƒîñîţîöñ îñţö ţĥàţ öŕđéŕ ƃéƒöŕé àñýţĥîñĝ ŕüñš.

Éàçĥ FlowNode ĥàš:

  • ÎĐ: üñîǫüé îđéñţîƒîéŕ ŵîţĥîñ ţĥé đéƒîñîţîöñ
  • Ţýþé: flow.NodeTool ƒöŕ à þŕöçéššîñĝ šţéþ. NodeReader àñđ NodeWriter ŕéḿàîñ îñ ţĥé NodeType ṽöçàƃüļàŕý ƒöŕ ţĥé éđîţöŕ'š ĝŕàþĥ, ƃüţ éṽéŕý ƃüîļţ-îñ àñđ šţéþš-çöḿþîļéđ ƒļöŵ çàŕŕîéš ţööļ ñöđéš öñļý, ƃéçàüšé ţĥé éñđš àŕé ƃîñđîñĝš (É-04)
  • Ñàḿé: ţĥé ŕéĝîšţéŕéđ ñàḿé öƒ ţĥé ţööļ (é.ĝ. "pseudo-translate")
  • Ļàƃéļ: öþţîöñàļ đîšþļàý ļàƃéļ ƒöŕ ÜÎ ŕéñđéŕîñĝ
  • Çöñƒîĝ: öþţîöñàļ ķéý-ṽàļüé çöñƒîĝüŕàţîöñ ḿàþ
  • Þöšîţîöñ: ẋ/ý çööŕđîñàţéš ƒöŕ ṽîšüàļ ļàýöüţ îñ ţĥé ƒļöŵ éđîţöŕ

Ƃîñđîñĝš (É-04). À ƒļöŵ'š šöüŕçé àñđ šîñķ àŕé ƃîñđîñĝš ŕéšöļṽéđ ƒŕöḿ îñṽöçàţîöñ çöñţéẋţ (ƒîļé, ţĥé þŕöĵéçţ šţöŕé, à .kpz, îñţéŕçĥàñĝé îḿþöŕţ/éẋþöŕţ, öŕ ñöñé), šö ţĥé šàḿé ƒļöŵ ŕüñš öṽéŕ àñý öŕîĝîñ. Éṽéŕý ƃüîļţ-îñ ƒļöŵ ĝŕàþĥ çàŕŕîéš ţööļ ñöđéš öñļý. Ţĥé ĝŕàþĥ îš çöḿþöšîţîöñ; à šîñĝļé ţööļ îš îñṽöķéđ đîŕéçţļý, ñöţ ŵŕàþþéđ îñ à öñé-ţööļ ƒļöŵ.

Éàçĥ FlowEdge çöññéçţš à šöüŕçé ñöđé ţö à ţàŕĝéţ ñöđé. TopologicalOrder() öŕđéŕš ţĥé ñöđéš ŵîţĥ Ķàĥñ'š àļĝöŕîţĥḿ àñđ ŕéþöŕţš à çýçļé àš àñ éŕŕöŕ; Validate() çĥéçķš ñöđé îđéñţîƒîéŕš, ñöđé ţýþéš àñđ éđĝé éñđþöîñţš. Éàçĥ ĥöšţ þàţĥ đéŕîṽéš ţĥé çĥàîñ îñ îţš öŵñ ŵàý:

  • Ţĥé ƃüîļţ-îñ ƒļöŵ þàţĥ çĥéçķš đàţà ƒļöŵ àñđ ţŕàñšƒöŕḿéŕ þļàçéḿéñţ, ţĥéñ öŕđéŕš ţĥé ţööļ ñöđéš ƃý ţĥéîŕ çàñṽàš Ẋ þöšîţîöñ (orderedToolNodes).
  • Ţĥé þŕöĵéçţ ƒļöŵ ŕüññéŕ ƃüîļđš öñé ţööļ þéŕ šţéþ, îñ šţéþ öŕđéŕ, àñđ ŕéƒüšéš à ƒļöŵ ĥöļđîñĝ à parallel: šţéþ ƃéƒöŕé îţ ƃüîļđš àñý.
  • À Ĝö çàļļéŕ ţĥàţ ƒîļļš Flow.Tools šüþþļîéš ţĥé öŕđéŕ îţšéļƒ.

Ñö þàţĥ šçĥéđüļéš ƃŕàñçĥéš çöñçüŕŕéñţļý öŕ ĵöîñš ţĥéîŕ ŕéšüļţš, šö à ƒļöŵ ḿéàñţ ţö ŕüñ îš à ļîñéàŕ çĥàîñ.

Ţĥé ƃüîļţ-îñ ƒļöŵ çàţàļöĝ îš à þŕöđüçţ çöñçéŕñ àñđ ļîṽéš îñ ţĥé ĥöšţ ḿöđüļé (host/flowdef.BuiltInFlows), ñöţ îñ ţĥé éñĝîñé. Îţ çöṽéŕš ţŕàñšļàţîöñ ŵîţĥ ĝüàŕđŕàîļš, çĥéçķš, ḿéḿöŕý ŕéüšé, þšéüđö-ţŕàñšļàţîöñ, ţĥé ḿéđîà-ţö-šüƃţîţļé þàţĥš, àñđ ţĥé ŕéđàçţîöñ-ƃŕàçķéţéđ ƒļöŵš; ţĥé àüţĥöŕîţàţîṽé ļîšţ ŵîţĥ éàçĥ ƒļöŵ'š šţéþš îš kapi flows àñđ ţĥé ĝéñéŕàţéđ çöḿḿàñđ ŕéƒéŕéñçé.

kapi flows ļîšţš öñļý ţĥé çöḿþöšéđ (ḿüļţî-ţööļ) ƃüîļţ-îñ ƒļöŵš, ƃéçàüšé šîñĝļé-ţööļ đéƒîñîţîöñš àŕé šüŕƒàçéđ àš ţöþ-ļéṽéļ ţööļ çöḿḿàñđš ŕàţĥéŕ ţĥàñ àš ƒļöŵš. host/flowdef.FlowStore þéŕšîšţš üšéŕ-çŕéàţéđ ƒļöŵ đéƒîñîţîöñš àš ĴŠÖÑ ƒîļéš öñ đîšķ, đîšţîñĝüîšĥéđ ƃý šöüŕçé:

  • built-in: šĥîþš ŵîţĥ ñéöķàþî, îḿḿüţàƃļé
  • user: çŕéàţéđ ƃý ţĥé üšéŕ, šţöŕéđ îñ ţĥé üšéŕ'š çöñƒîĝ đîŕéçţöŕý

À þŕöĵéçţ'š öŵñ ñàḿéđ ƒļöŵš àŕé đéçļàŕéđ îñ îţš ŕéçîþé'š flows: ƃļöçķ ŕàţĥéŕ ţĥàñ šţöŕéđ àš ƒîļéš (É-04).

Šţéþš-ƃàšéđ ÝÀḾĻ ƒöŕḿàţ​

À ĥüḿàñ-ƒŕîéñđļý šţéþš ƒöŕḿàţ îš ţĥé þŕîḿàŕý àüţĥöŕîñĝ šüŕƒàçé ƒöŕ ƒļöŵš îñ ÝÀḾĻ (É-03):

apiVersion: v1
kind: FlowDefinition
metadata:
  name: Production Pipeline
spec:
  steps:
    - tool: recycle
      config: { fuzzyThreshold: 75 }
    - tool: translate
      config: { provider: anthropic }
    - tool: qa

Šţéþš ŕüñ îñ ţĥé öŕđéŕ ļîšţéđ. Ţĥé þàŕšéŕ àüţö-đéţéçţš ţĥé šĥàþé (šţéþš ṽš ĝŕàþĥ), àñđ StepsToGraph çöḿþîļéš šţéþš ţö à çĥàîñ öƒ ñöđéš àñđ éđĝéš. Îţ àļšö àççéþţš à parallel: ƃļöçķ àñđ çöḿþîļéš îţ ţö šéṽéŕàļ ñöđéš ƒéđ ƒŕöḿ ţĥé šàḿé þŕéđéçéššöŕ; ţĥàţ šĥàþé éẋîšţš îñ ţĥé đéƒîñîţîöñ ḿöđéļ öñļý, àñđ ñöñé öƒ ţĥé ĥöšţ þàţĥš àƃöṽé éẋéçüţéš îţ àš çöñçüŕŕéñţ ƃŕàñçĥéš.

Ţĥé šţéþš çàŕŕý öñļý ţĥé çöḿþöšîţîöñ. À ƒļöŵ'š šöüŕçé àñđ šîñķ àŕé ƃîñđîñĝš ŕéšöļṽéđ àţ îñṽöçàţîöñ (ƒîļé, ţĥé þŕöĵéçţ šţöŕé, à .kpz, îñţéŕçĥàñĝé, öŕ ñöñé; É-04) ŕàţĥéŕ ţĥàñ ƒîéļđš öƒ ţĥé ƒļöŵ đöçüḿéñţ.

Ƒàñ-öüţ àñđ ƃàţçĥîñĝ​

tool.Tee() îš à çĥàññéļ ĥéļþéŕ ƒöŕ à Ĝö çàļļéŕ: îţ ƒöŕŵàŕđš ţĥé šàḿé Þàŕţ þöîñţéŕ ţö éṽéŕý öüţþüţ çĥàññéļ, ţàķéš ƃàçķþŕéššüŕé ƒŕöḿ éàçĥ ŕéçéîṽéŕ, àñđ çļöšéš éṽéŕý öüţþüţ öñçé îţš îñþüţ çļöšéš öŕ îţš çöñţéẋţ îš çàñçéļļéđ. Ţĥé éẋéçüţöŕ ñéṽéŕ ŵîŕéš îţ ƒŕöḿ ĝŕàþĥ éđĝéš. À çàļļéŕ ţĥàţ üšéš îţ öŵñš ţĥé ƃŕàñçĥéš' ļîƒéçýçļé, àñđ çöñçüŕŕéñţ ŕéçéîṽéŕš šĥàŕé éàçĥ ḿüţàƃļé Ƃļöçķ, šö ţĥéý ḿüšţ çööŕđîñàţé àççéšš ţö îţ.

Ţĥé batch ţööļ îš à šţàĝé îñ à ļîñéàŕ çĥàîñ. Îţ ĥöļđš ƃļöçķš üñţîļ îţ ĥàš ţĥé çöñƒîĝüŕéđ ñüḿƃéŕ, ţĥéñ ƒöŕŵàŕđš ţĥéḿ öñé ƃý öñé; à ñöñ-ƃļöçķ Þàŕţ þàššéš ţĥŕöüĝĥ àţ öñçé, àĥéàđ öƒ àñý ƃļöçķš îţ ĥöļđš. Ĝŕöüþîñĝ ƃļöçķš îñţö öñé ŕéǫüéšţ ƒöŕ ƃàţçĥ-çàþàƃļé ŕéḿöţé ÀÞΚ àñđ ĻĻḾ þŕöḿþţš ĥàþþéñš îñšîđé ţĥé ţööļš ţĥàţ çàļļ ţĥéḿ (Ḿ-05).

Šçŕîþţ šţéþ​

Ţĥé script ţööļ ŕüñš üšéŕ-þŕöṽîđéđ ĴàṽàŠçŕîþţ (ÉŠ5) ṽîà ţĥé ĝöĵà ŕüñţîḿé. Éàçĥ ţööļ îñšţàñçé öŵñš îţš öŵñ goja.Runtime, ŵĥîçĥ îš šàƒé ƃéçàüšé ToolFactory ĝîṽéš öñé îñšţàñçé þéŕ ĝöŕöüţîñé. Ţĥé ĴŠ ÀÞÎ éẋþöšéš part, emit(), skip(), àñđ log() ƒöŕ ƒîļţéŕîñĝ àñđ ţŕàñšƒöŕḿîñĝ þàŕţš: ļîĝĥţŵéîĝĥţ çüšţöḿ ţŕàñšƒöŕḿàţîöñš ŵîţĥöüţ Ĝö çöđé. script îš îñ ţĥé éẋéç çļàšš: à ŕéçîþé çàññöţ àŕḿ îţ šîļéñţļý (É-06).

Ţéŕḿîñöļöĝý: Öķàþî → ñéöķàþî​

Ƒöŕ ŕéàđéŕš ƒàḿîļîàŕ ŵîţĥ ţĥé Öķàþî Ƒŕàḿéŵöŕķ, ţĥé éñĝîñé ḿàþš ţö Öķàþî çöñçéþţš àš ƒöļļöŵš:

Öķàþî (Ĵàṽà)ñéöķàþî (Ĝö)
ƑîļţéŕĐàţàƑöŕḿàţ (Ŕéàđéŕ/Ŵŕîţéŕ)
ŠţéþŢööļ
ÞîþéļîñéƑļöŵ
ÞîþéļîñéĐŕîṽéŕÉẋéçüţöŕ
ÉṽéñţÞàŕţ
ŢéẋţÜñîţƂļöçķ
ŢéẋţƑŕàĝḿéñţŔüñ šéǫüéñçé ([]Run)
ÇöđéŔüñ
ŠţàŕţŠüƃĐöçüḿéñţ/ŠţàŕţŠüƃƑîļţéŕÇĥîļđ Ļàýéŕ

Çöñšéǫüéñçéš​

  • Éàçĥ ţööļ ŕüñš çöñçüŕŕéñţļý; ḿüļţî-çöŕé ÇÞÜš àŕé üţîļîžéđ ŵîţĥîñ à šîñĝļé đöçüḿéñţ'š þîþéļîñé.
  • Ḿüļţîþļé đöçüḿéñţš þŕöçéšš îñ þàŕàļļéļ, ƃöüñđéđ ƃý MaxConcurrency.
  • Ƃàçķþŕéššüŕé îš àüţöḿàţîç: à šļöŵ ţööļ çàüšéš îţš îñþüţ çĥàññéļ ţö ƒîļļ, ŵĥîçĥ ƃļöçķš ţĥé üþšţŕéàḿ ţööļ ŵîţĥöüţ ḿàñüàļ çööŕđîñàţîöñ.
  • Çöñţéẋţ çàñçéļļàţîöñ çļéàñļý þŕöþàĝàţéš ţĥŕöüĝĥ ţĥé éñţîŕé çĥàîñ.
  • ŢööļƑàçţöŕîéš éñšüŕé ñö šĥàŕéđ ḿüţàƃļé šţàţé ƃéţŵééñ þàŕàļļéļ đöçüḿéñţš.
  • Çöļļéçţöŕš þŕöṽîđé çŕöšš-đöçüḿéñţ àĝĝŕéĝàţîöñ ŵîţĥöüţ ƃŕéàķîñĝ ţĥé šţŕéàḿîñĝ ḿöđéļ.
  • Ţööļ àüţĥöŕš đö ñöţ ḿàñàĝé ĝöŕöüţîñéš; ţĥé éẋéçüţöŕ ĥàñđļéš ļîƒéçýçļé, àñđ ParallelBlockTool šüþþļîéš îñţŕà-ţööļ þàŕàļļéļîšḿ ŵîţĥöüţ àñý çöñçüŕŕéñçý çöđé îñ ţĥé ţööļ. À šļöŵ ƃļöçķ ĥöļđš ƃàçķ àţ ḿöšţ Ñ àđḿîţţéđ ƃļöçķš àñđ 4Ñ öţĥéŕ Þàŕţš, šö à þàŕàļļéļ šţàĝé šţàýš ƃöüñđéđ ŵĥéñ îţš ŵöŕķéŕš ƒîñîšĥ öüţ öƒ öŕđéŕ.
  • StreamingCollector éñàƃļéš ŕéàļ-ţîḿé öƃšéŕṽàţîöñ öƒ þîþéļîñé öüţþüţ ŵîţĥöüţ ḿöđîƒýîñĝ ţĥé Þàŕţ šţŕéàḿ öŕ àđđîñĝ ƃüƒƒéŕîñĝ šţàĝéš.
  • Ƒļöŵ ţŕàçîñĝ éñàƃļéš þöšţ-ĥöç đéƃüĝĝîñĝ àñđ ṽîšüàļîžàţîöñ, ĥéļþîñĝ üšéŕš üñđéŕšţàñđ ţööļ ƃéĥàṽîöüŕ àñđ îđéñţîƒý ƃöţţļéñéçķš.
  • À ĥöšţ ţĥàţ öŕđéŕš à đéƒîñîţîöñ ŵîţĥ TopologicalOrder ŕéþöŕţš à çýçļé ƃéƒöŕé îţ ƃüîļđš àñý ţööļ.
  • ĴŠÖÑ àñđ ÝÀḾĻ šéŕîàļîžàţîöñ šüþþöŕţš îḿþöŕţ/éẋþöŕţ àñđ ṽéŕšîöñ çöñţŕöļ öƒ ƒļöŵ çöñƒîĝüŕàţîöñš.
  • Šţéþš-ƃàšéđ ÝÀḾĻ ḿàķéš ƒļöŵ àüţĥöŕîñĝ àççéššîƃļé ŵîţĥöüţ Ĝö; ţĥé ṽîšüàļ éđîţöŕ àñđ ţĥé ÝÀḾĻ šĥàŕé öñé ĝŕàþĥ ŕéþŕéšéñţàţîöñ, àñđ ŵĥàţ ŕüñš îš ţĥé öŕđéŕéđ çĥàîñ à ĥöšţ đéŕîṽéš ƒŕöḿ îţ.

Ŕéļàţéđ​