configuration/principle/data/coordination.data.json
configuration/principle/data/coordination.data.json is a file in GovLab Context. 329 lines of code and 0 definitions.
{
"category": "Control / Coordination / Centralization",
"check": {
"population": "every node, service and workflow step that shares configuration, identity, logs, leadership or agreement",
"freshness": "a verdict stands until membership, topology or the coordinating policy changes",
"refusal": "the workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value",
"observation": "the control plane's recorded state compared with each participant's reported state",
"evidence": "none: the catalog states this check as a class, so a watched run belongs to each system that adopts it",
"authority": "the control plane's recorded state, which each participant's reported state is compared against"
},
"records": [
{
"id": "control-plane",
"name": "Control Plane",
"definition": "Descriptive data about the desired state of a distributed runtime, held in one place and applied to every node through a management interface.",
"type": "artifact",
"scope": [
"platform",
"infrastructure",
"distributed system"
],
"requires": [
"Management API",
"Policy"
],
"reinforces": [
"Governance",
"Orchestration"
],
"enables": ["Centralized Control of Distributed Runtime"],
"conflicts_with": ["Fully Decentralized Control"],
"tensions_with": ["Availability"],
"violated_by": ["lexicon:scattered-configuration"],
"detected_by": ["manual node/service control"],
"measured_by": [
"control coverage",
"control-plane availability"
],
"refactored_by": [
"lexicon:management-api",
"architecture:policy-as-code"
],
"enforced_by": ["platform architecture"],
"severity": "contextual",
"exemplar": {
"before": "for (const node of fooNodes) {\n node.configure({ retries: 3, timeoutMs: 500 });\n}",
"after": "controlPlane.apply(\"foo-service\", {\n retries: 3,\n timeoutMs: 500,\n rollout: \"progressive\",\n});",
"lang": "ts"
}
},
{
"id": "orchestration",
"distinctFrom": [
{
"id": "lexicon:coordinator",
"reason": "Orchestration is the mechanism of driving a workflow from one place, while the coordinator is the component that plays that role."
}
],
"name": "Orchestration",
"definition": "A mechanism that runs a multi-step workflow from one coordinator, which calls each step in order and tracks its outcome.",
"type": "mechanism",
"scope": [
"workflow",
"deployment",
"services"
],
"requires": ["Coordinator"],
"reinforces": [
"Control Plane",
"Saga"
],
"enables": ["Ordered Multi-Step Execution"],
"conflicts_with": ["Pure Choreography"],
"tensions_with": ["Centralized Coordinator Coupling"],
"violated_by": ["lexicon:pure-choreography"],
"detected_by": ["unclear workflow ownership"],
"measured_by": ["workflow observability/completion"],
"refactored_by": [],
"enforced_by": ["workflow tests"],
"severity": "contextual",
"exemplar": {
"before": "await fooService.create(foo);\nawait barService.create(bar);\nawait bazService.create(baz);",
"after": "await orchestrator.run(\"CreateFooFlow\", {\n steps: [\n step(\"foo\", () => fooService.create(foo)),\n step(\"bar\", () => barService.create(bar)),\n step(\"baz\", () => bazService.create(baz)),\n ],\n});",
"lang": "ts"
}
},
{
"id": "centralized-configuration",
"name": "Centralized Configuration",
"definition": "A design pattern that keeps every service's configuration in one versioned store the services read from.",
"type": "pattern",
"scope": [
"service",
"platform",
"runtime"
],
"requires": [
"Config Store",
"Access Control"
],
"reinforces": [
"Governance",
"Consistency"
],
"enables": ["Unified Config Management"],
"conflicts_with": ["Scattered Configuration"],
"tensions_with": ["Central Dependency Risk"],
"violated_by": ["lexicon:scattered-configuration"],
"detected_by": ["config drift"],
"measured_by": ["config drift count"],
"refactored_by": ["architecture:schema-validation"],
"enforced_by": ["config policy"],
"severity": "contextual",
"exemplar": {
"before": "const fooConfig = loadLocalFooConfig();\nconst barConfig = loadLocalBarConfig();\nconst bazConfig = loadLocalBazConfig();",
"after": "const config = await configService.readVersioned(\"platform/v3\");\nfooApp.apply(config.foo);\nbarApp.apply(config.bar);\nbazApp.apply(config.baz);",
"lang": "ts"
}
},
{
"id": "centralized-authentication",
"name": "Centralized Authentication",
"definition": "A design pattern that verifies identity once, at a shared identity provider, and passes the result to each service.",
"type": "pattern",
"scope": [
"identity",
"system"
],
"requires": ["Identity Provider"],
"reinforces": [
"Security",
"Governance"
],
"enables": ["Unified Identity"],
"conflicts_with": ["Scattered Auth Implementations"],
"tensions_with": ["Identity Provider Availability"],
"violated_by": ["lexicon:scattered-auth-implementations"],
"detected_by": ["duplicated credential stores"],
"measured_by": ["auth centralization coverage"],
"refactored_by": ["lexicon:identity-provider"],
"enforced_by": ["security policy"],
"severity": "recommended",
"exemplar": {
"before": "fooService.verifyToken(token);\nbarService.verifyToken(token);\nbazService.verifyToken(token);",
"after": "const identity = await identityProvider.authenticate(token);\nawait fooService.handle({ identity });\nawait barService.handle({ identity });\nawait bazService.handle({ identity });",
"lang": "ts"
}
},
{
"id": "centralized-logging",
"name": "Centralized Logging",
"definition": "A design pattern that ships structured logs from every instance to one aggregated store.",
"type": "pattern",
"scope": [
"services",
"platform"
],
"requires": ["Log Aggregation"],
"reinforces": [
"Observability",
"Auditability"
],
"enables": ["Cross-Service Analysis"],
"conflicts_with": ["Local-Only Logs"],
"tensions_with": ["Cost/Personal Data Exposure"],
"violated_by": ["lexicon:local-only-logs"],
"detected_by": ["missing log shipping"],
"measured_by": ["log ingestion coverage"],
"refactored_by": [
"lexicon:log-aggregation",
"architecture:canonical-data-model"
],
"enforced_by": ["observability policy"],
"severity": "recommended",
"exemplar": {
"before": "fooService.writeLocalLog(event);\nbarService.writeLocalLog(event);\nbazService.writeLocalLog(event);",
"after": "const sink = new CentralLogSink();\nfooService.useLogger(structuredLogger(sink));\nbarService.useLogger(structuredLogger(sink));\nbazService.useLogger(structuredLogger(sink));",
"lang": "ts"
}
},
{
"id": "decentralization",
"name": "Decentralization",
"definition": "A design rule that decisions and runtime control sit with the teams and services that own them, joined by contracts.",
"type": "principle",
"scope": [
"system",
"team",
"service"
],
"requires": [
"Autonomy",
"Contracts"
],
"reinforces": [
"Microservices",
"Resilience"
],
"enables": ["Independent Ownership"],
"conflicts_with": ["Centralized Control"],
"tensions_with": [
"Governance",
"Consistency"
],
"violated_by": ["lexicon:centralized-control"],
"detected_by": ["centralized team/service dependency"],
"measured_by": ["decision/deployment dependency count"],
"refactored_by": [
"lexicon:assign-owner",
"lexicon:management-api"
],
"enforced_by": ["ownership model"],
"severity": "contextual",
"exemplar": {
"before": "const coordinator = new GlobalFooCoordinator();\nawait coordinator.approveEveryFoo(foo);",
"after": "await fooNode.validate(foo);\nawait fooNode.commit(foo);\nawait fooNode.publish({ type: \"FooCommitted\", fooId: foo.id });",
"lang": "ts"
}
},
{
"id": "leader-election",
"name": "Leader Election",
"definition": "A mechanism that lets a group of nodes agree on one coordinator and replace it when it fails.",
"type": "mechanism",
"scope": [
"distributed system",
"coordination",
"availability"
],
"requires": ["Consensus"],
"reinforces": [
"Control Plane",
"Fault Tolerance"
],
"enables": [
"Single-Writer Coordination",
"Automatic Failover of Leadership"
],
"conflicts_with": ["Split-Brain Coordination"],
"tensions_with": ["Availability"],
"violated_by": ["lexicon:split-brain-coordination"],
"detected_by": ["concurrent leader actions / split-brain"],
"measured_by": ["split-brain incident rate"],
"refactored_by": [],
"enforced_by": ["distributed-systems review"],
"severity": "contextual",
"mandatoryFor": "distributed systems",
"exemplar": {
"before": "if (process.env.IS_LEADER === \"true\") runFooScheduler();",
"after": "const lease = await fooCoordinator.acquireLeadership(\"foo-scheduler\", { ttlMs: 10_000 });\nlease.onAcquired(() => runFooScheduler());\nlease.onLost(() => stopFooScheduler());",
"lang": "ts"
}
},
{
"id": "consensus",
"distinctFrom": [
{
"id": "architecture:leader-election",
"reason": "Consensus commits one value across a quorum, while leader election uses it to agree on one coordinator and replace it when it fails."
},
{
"id": "architecture:total-order-broadcast",
"reason": "Consensus agrees on one value, while total-order broadcast agrees on the order of every message."
}
],
"name": "Consensus",
"definition": "A mechanism that lets a quorum of nodes commit one value, so every correct node ends up with the same value.",
"type": "mechanism",
"scope": [
"distributed system",
"agreement",
"consistency"
],
"requires": ["Quorum"],
"reinforces": [
"Consistency",
"Fault Tolerance"
],
"enables": ["Agreed Single Value Across Nodes"],
"conflicts_with": ["Independent Node Decisions"],
"tensions_with": [
"Latency",
"Availability"
],
"violated_by": ["lexicon:independent-node-decisions"],
"detected_by": ["divergent committed state across replicas"],
"measured_by": ["agreement-violation rate"],
"refactored_by": [],
"enforced_by": ["distributed-systems review"],
"severity": "contextual",
"mandatoryFor": "distributed systems",
"exemplar": {
"before": "fooNodeA.setValue(value);",
"after": "const committed = await fooCluster.propose(value, { quorum: majority(fooNodes) });\nif (!committed.accepted) throw new NoQuorumError();",
"lang": "ts"
}
},
{
"id": "choreography",
"name": "Choreography",
"definition": "A mechanism that coordinates a cross-service flow through events, with each service reacting to the previous one's event.",
"type": "mechanism",
"scope": [
"distributed system",
"coordination",
"event"
],
"requires": ["Event-Driven Architecture"],
"reinforces": [
"Decentralization",
"Service Autonomy"
],
"enables": ["Central-Orchestrator-Free Coordination"],
"conflicts_with": ["Central Orchestrator Bottleneck"],
"tensions_with": ["Traceability"],
"violated_by": ["lexicon:central-orchestrator-bottleneck"],
"detected_by": ["a central coordinator coupled to all participants"],
"measured_by": ["orchestrator fan-out coupling"],
"refactored_by": [],
"enforced_by": ["architecture review"],
"severity": "contextual",
"exemplar": {
"before": "await orchestrator.run(\"CreateFoo\", [\n () => createFoo(foo),\n () => reserveBar(foo),\n () => notifyBaz(foo),\n]);",
"after": "fooEvents.on(\"FooCreated\", event => barService.reserve(event.fooId));\nbarEvents.on(\"BarReserved\", event => bazService.notify(event.fooId));",
"lang": "ts"
}
}
]
}