aggrega pull
aggrega pull löst alle Abhängigkeiten eines Release auf und schreibt eine Lockfile, die jede Abhängigkeit auf eine exakte Version und einen exakten Inhalts-Digest festlegt. Ein nachfolgendes aggrega build verwendet, was die Lockfile festlegt, verifiziert es und hält unter Nennung von allem an, was es benötigt und dort nicht festgelegt ist — so sind Builds reproduzierbar und offlinefähig.
Alles, was ein Build konsumiert, wird in diesem einen Moment festgelegt. Die Katalog-Entitäten, die Quellartefakte, auf die ein Recipe einen Provider verweist, und die entfernten Dokumente, die ein Provider während des Renderns anfordert, werden vom selben Befehl aufgelöst und im selben Schreibvorgang der Lockfile verzeichnet. aggrega pull ist der Schritt, der das Netzwerk berührt; der Build tut es nicht. Das ist die ganze Regel, und der Rest dieser Seite ist das, was daraus folgt.
Funktionsweise
aggrega pull löst drei Arten von Abhängigkeiten in einem Durchgang auf:
- Katalog-Entitäten — die Components, Features, Recipes, FeatureRecipes, Schema- und Mapping-Bibliotheken sowie Wasm-Plugins, auf die das Release verweist, transitiv aufgelöst (über
extends:,implements:,aggregate:, Feature-Anbindungen und die Stellen$import:/$ref:in Bibliotheken) und aus der Registry abgerufen, wenn sie nicht bereits lokal vorliegen. - Quellartefakte — die entfernte
source:, auf die ein einzelnes Recipe oder FeatureRecipe einen Provider verweist: ein Helm-Chart (OCI oder klassisches HTTPS) oder ein Compose-Fragment über HTTPS. Jedes wird abgerufen, zwischengespeichert und gepinnt. - Externe Eingaben — die entfernten Dokumente, die ein Provider beim Rendern vom Host anfordert, etwa ein
$refin dervalues.schema.jsoneines Charts, das auf eine URL zeigt. Jede wird abgerufen, unter ihrem Inhalts-Digest gespeichert und gepinnt.
Zwei der drei werden aus den Dokumenten gelesen, die Sie verfasst haben. Die dritte nicht: Externe Eingaben werden gefunden, indem das Release gerendert wird, weshalb dieser Befehl ein Rendering ausführt. Um den Befehl auszuführen, brauchen Sie nichts davon — Wie die Auflösung externe Eingaben findet beschreibt es vollständig, zusammen mit den Kosten des Renderings, dem, was geschieht, wenn es nicht abgeschlossen werden kann, und dem Verhältnis eines Builds, der sein eigenes Lockfile füllt, dazu.
Eine ohne Registry benannte Katalog-Entität wird über die Einstellung default_registry des Workspace abgerufen, und ein Repository-Pfad, den der Standardwert enthält, ist der Ort, von dem sie abgerufen wird. Mit default_registry: ghcr.io/acme wird core/api-server von ghcr.io/acme/component/core/api-server abgerufen — wo aggrega push es über denselben Standardwert veröffentlicht —, und dort wird auch nach seiner Signatur gesucht. Der Pfad bestimmt nur den Ort: Die Signatur, die ein Pull verlangt, die Schlüssel und Identitäten, denen er vertraut, und die Anmeldedaten, die er vorlegt, sind die für den Host hinterlegten, sodass der registries-Eintrag für ghcr.io jeden Pfad auf diesem Host bestimmt. Das Lockfile erfasst eine solche Entität anhand ihrer Identität, Version und Digests, so wie es eine Entität erfasst, die von einem Host ohne Pfad abgerufen wurde. Die Schreibweise eines Pfads ist unter Wie ein Registry-Host geschrieben wird beschrieben.
Der Befehl schreibt das Ergebnis in <release-stem>.lock neben dem Release. Ein Workspace, der ein Plugin anbindet, das ein Urteil aus Annahme oder Ablehnung zurückgibt, erhält außerdem eine zweite Datei in diesem Verzeichnis — den Plugin-Vertrauensdatensatz.
Ein Pull, der zum Pinnen aufgefordert wird, schreibt eine weitere Art von Datei. Neben jedem Recipe und FeatureRecipe in Ihren Katalogverzeichnissen, das eine Artefaktdatei importiert, auf eine vollständig ausgeschriebene entfernte source: verweist oder eine source: neben sich liest, liegt eine entity.lock, die festhält, welchen Digest dieser Inhalt ergab. Dies festzuhalten ist der Schritt des Entitätsautors, aggrega pin, und standardmäßig führt ein Pull ihn nicht aus: Er gleicht die Lock-Datei jeder solchen Entität mit dem ab, was der Schritt festhalten würde, und hält an, wo ein Pin fehlt. aggrega pull --pin-sources oder ein Workspace, der pin_sources_at_pull: true setzt, führt stattdessen den Schritt aus — und dann reicht die Wirkung eines Pulls über das Verzeichnis hinaus, in dem das Release liegt, wobei die von Ihnen verfassten Entitätsdateien nie beschrieben werden. Die Entitäts-Lock-Datei beschreibt diese Datei, und Vorschau dessen, was ein Pull schreiben würde zeigt die gesamte Menge für Ihren Workspace, bevor sich etwas bewegt.
Ein Pull, der abgelehnt wird, weil ein Verweis zu nichts aufgelöst wurde, nennt, woher lokale Entitäten gelesen werden, wo immer er läuft. Die Ablehnung enthält die eigene Darstellung des Workspace über die Verzeichnisse, aus denen er lokale Entitäten gelesen hat, und darüber, was zu ändern ist, damit die Entität gelesen wird — den Hinweis, den Woher lokale Entitäten gelesen werden zeigt —, und sie enthält sie bei diesem Befehl, bei einem Build, der zuerst seine Abhängigkeiten auflöst, beim Pull-Werkzeug von aggrega mcp und ebenso bei der Abhängigkeitsauflösung eines Editors, weil die Auflösung, die sie alle ausführen, sie zusammenstellt. Die Ablehnung des Pull-Werkzeugs nennt außerdem den Kurzcode und den beschreibenden Code der Bedingung, so wie ein Terminal den Kurzcode am Anfang der Ablehnung ausgibt. Eine Datei in diesen Verzeichnissen, die eine Aggrega-apiVersion deklariert — eine Zeile, die ohne Einrückung mit apiVersion: und einem Wert beginnt, der mit aggrega.ai/ anfängt — und nicht geladen werden konnte, etwa eine, die sich nicht als YAML parsen lässt, wird in derselben Ablehnung genannt, unter den beim Laden übersprungenen Katalogdateien, mit der eigenen Begründung des Parsers: Eine solche Datei könnte diejenige sein, die die Entität deklariert, die der Verweis nennt, und aus ihr lässt sich nichts lesen, das sagt, welche Entität sie deklariert. Eine YAML-Datei, die eine andere apiVersion oder keine deklariert, ist kein Aggrega-Dokument und wird dort nie genannt.
Das Lockfile
Das Lockfile pinnt jede Abhängigkeit auf ihre URI, ihre aufgelöste Version und ihren Inhalts-Digest. Es hat Abschnitte für Katalog-Entitäten, Schema- und Mapping-Bibliotheken (jede mit Rückverweisen auf die Components und Features, die sie nutzen), Wasm-Plugins, Quellartefakte, externe Eingaben (jede nach URL geschlüsselt und mit den Plugins, die sie angefordert haben) und die Release-Dateien selbst. Die Datei wird in einer kanonischen, deterministischen Form geschrieben.
Eine Entität wird anhand dessen erfasst, was eine Veröffentlichung von ihr enthält. Der Digest in der Zeile einer Entität umfasst ihr Dokument und jede Datei, die sie daneben benennt — die lokale source: eines Recipe oder FeatureRecipe, jede Datei, die ein $import: benennt, die entity.lock daneben, jede Schemadatei, die eine Component oder ein Feature importiert —, dieselbe Menge, die aggrega push veröffentlicht. Jede Datei trägt ihren Pfad und ihre Bytes bei, und sonst trägt nichts bei: nicht, wie ein Archiv komprimiert wurde, kein Zeitstempel, kein Berechtigungsbit, einschließlich des Ausführungsbits. Eine Entität, die keine Datei benennt, wird als dieses eine Dokument erfasst. Daher erfasst dieselbe Entität denselben Digest, ob sie aus Ihrem Katalogverzeichnis gelesen oder aus einer Registry abgerufen wurde, und ein aus einem Checkout committetes Lockfile lässt sich auf einem anderen Checkout desselben Commits verifizieren, unabhängig von dessen umask und davon, ob das System dieses Checkouts festhält, welche Dateien ausführbar sind. Ein unter einem Recipe bearbeitetes Chart, eine zu einer von ihm deklarierten Quelle hinzugefügte Datei und eine geänderte entity.lock ändern jeweils den Digest; ein Skript, dessen Ausführungsbit umgeschaltet wurde, und eine Notiz neben der Entität, die nichts benennt, nicht. Das Aggregate und das Manifest, die das Release benennt, werden auf dieselbe Weise erfasst, jedes als sein eines Dokument. Eine Bibliothek wird anhand des Digests ihrer Bytes erfasst, die ihr Dokument sind, wo immer sie gelesen wird.
Jedes Recipe und FeatureRecipe, das das Manifest bindet, ist eine Zeile, gleich welche Ebene es bindet. Eine Realisierung, die die name-Ebene des Manifest für eine einzelne Instanz oder eine einzelne Anbindung wählt, wird genau so beschafft und erfasst wie eine, die seine type-Ebene für jede Instanz eines Typs wählt, und das Feld referenced_from ihrer Zeile benennt den Eintrag, der sie bindet — manifest.spec.mappings.components.name.<instance> oder manifest.spec.mappings.features.name.<attachment>. Ein Build hält sie an diese Zeile, sodass ein Lockfile, das sie nicht erfasst, den Build anhält und dabei die Realisierung und diesen Eintrag benennt. Siehe Flaches URI-Mapping für die beiden Ebenen.
Die Anbindungen einer Verbindung sind genauso Abhängigkeiten wie die einer Komponente selbst. Das Feature, das eine Anbindung an einer Verbindung benennt — geschrieben an einem uses:-Eintrag einer Komponente im Aggregate oder an einem Verbindungseintrag im Release —, wird wie das Feature einer an der Komponente selbst geschriebenen Anbindung beschafft und erfasst, und das Feld referenced_from seiner Zeile benennt den vom Autor geschriebenen Verbindungseintrag, der auf .uses.<socket>.<alias>.features.<slot>.type endet. Auch die Realisierung, die das Manifest daran bindet, ist eine Zeile, ob features.type sie bindet oder features.name, geschlüsselt nach dem Namen der Anbindung, <alias>.<slot>. Ein Build hält beide an ihre Zeilen: Ein Lockfile ohne eine davon hält den Build an und benennt den Verweis und den Eintrag, der ihn anfordert, und ein Feature, dessen Inhalt sich seit dem Pull geändert hat, hält ihn an und benennt beide Digests. Siehe den Verbindungseintrag des Aggregate für die Anbindung selbst.
Eine Basis, die von einer Component oder einem Feature erweitert wird, ist eine Zeile, unabhängig davon, ob etwas anderes sie nennt. Der Pull folgt jedem extends: bis zum Ende seiner Kette und erfasst jede Basis unter ihrer eigenen Art, wobei das referenced_from ihrer Zeile das spec.extends der erweiternden Entität nennt — component(<name>:<version>).spec.extends. Ein Build liest die Basis aus dieser Zeile, sodass ein Manifest den eigenen Typ eines Wrappers abbildet und keine Zeile für dessen Basis benötigt. Eine Basis, die weder ein Katalogverzeichnis noch ein Cache noch eine Registry enthält, wird dort gemeldet, wo die Kette zusammengeführt wird — siehe An extends: chain cannot be assembled (Eine Kette kann nicht zusammengesetzt werden).
Das Release wird anhand seines Inhalts erfasst, nicht nur anhand seines Namens. Alles, was das Release anfordert — zu welcher Chart-Version eine Quelle aufgelöst wird, welche Komponenten in welcher Grenze landen —, wird aus dem Inhalt der Datei aufgelöst, daher erfasst release_documents den Digest des Release und jedes Release, das es erweitert, neben release, das es benennt. Bearbeiten Sie das Release nach dem Pull, und der nächste Build hält an, bevor etwas gerendert wird, benennt die bearbeitete Datei und fordert Sie auf, erneut zu pullen; ein einfaches aggrega pull --release <release> erfasst die Änderung und respektiert dabei jeden anderen Pin. Der Digest umfasst die Bytes der Datei, wie sie sind, daher zählt auch eine Änderung an einem Kommentar oder an Leerzeichen, genau wie beim Aggregate und beim Manifest. Eine Datei, die das Release über parameters importiert, wird nicht auf diese Weise erfasst.
Ein Pull sucht auf jedem Artefakt, dessen Signatur er prüft, nach einer Deprecation-Markierung und meldet, was er gefunden hat. Eine Markierung, deren eigene Signatur sich gegen einen Signierer verifizieren lässt, den der Pull anerkennt – den eigenen Signierer des Artefakts oder eine Identität in trusted_deprecation_identities der Registry –, wird festgehalten und mit ihrem Schweregrad und dem Signierer der Markierung angekündigt. Eine Markierung, die der Pull gefunden hat und nicht anerkennen konnte – unlesbar, unsigniert, von jemandem signiert, dem die Richtlinie nicht vertraut, oder mit einer Signatur, die nicht geprüft werden konnte –, wird als marker present but not honored gemeldet, mit dem Grund, und nicht festgehalten. Eine Abfrage, die nicht abgeschlossen werden konnte – der Pull konnte die Registry des Artefakts nicht öffnen, oder die Auflistung dessen, was daran angehängt ist, hat nicht geantwortet –, wird als marker lookup did not complete gemeldet, mit dem Grund, und hält nichts fest, weil der Pull nichts darüber erfahren hat, ob eine Markierung existiert. Bei einer Registry, deren eigene Vertrauensrichtlinie für die Art des Artefakts eine Signatur verlangt und nicht advisory ist, hält jeder dieser beiden Fälle den Pull an, statt gemeldet zu werden. Ein Artefakt ohne Markierung erzeugt keine Zeile, und wo die Signaturprüfung abgeschaltet ist, für den Workspace oder für die Registry des Artefakts, wird nach keiner Markierung gesucht.
Committen Sie <release-stem>.lock zusammen mit dem Release, so wie Sie jede Datei mit gepinnten Abhängigkeiten committen. Ein Diff des Lockfile zeigt Reviewern genau, welche Abhängigkeitsversionen und Digests sich geändert haben; eine Änderung am Digest einer Bibliothek benennt die betroffenen Nutzer.
Was ein bestimmter Pull getan hat — ob jede Entität frisch aus einer Registry abgerufen wurde (fetched-fresh), einen Cache-Slot wiederverwendet hat (cache-reuse), in einem lokalen Katalog gefunden wurde (local), aus der Kopie im Compiler-Binary bereitgestellt wurde (in-binary) oder extern war (external: das eigene Aggregate oder Manifest des Release, gelesen aus der Datei oder dem Eintrag, den das Release benennt, statt als eine seiner Abhängigkeiten aufgelöst; ein Aggregate, das der Pull aus einer Registry abgerufen hat, ist stattdessen fetched-fresh) —, ist eine flüchtige Pull-Ereignis-Diagnose, die von --detail auf stdout ausgegeben wird, und sie wird nie in das Lockfile geschrieben. Welche Quelle eine Entität bereitgestellt hat, hängt vom lokalen Zustand der pullenden Maschine ab, daher würde ihre Speicherung die Byte-Identität des Lockfile über Maschinen hinweg zerstören. Sie meldet, was dieser Pull getan hat, was sich danach nicht mehr rekonstruieren lässt (eine frisch gepullte Entität wird beim nächsten Lauf zwischengespeichert); für den Zustand der Auflösung der Abhängigkeiten eines Release nach dem Pull verwenden Sie aggrega inspect.
Die Entitäts-Lock-Datei
Ein Recipe oder FeatureRecipe kann von Bytes außerhalb seines eigenen Dokuments abhängen: einem Chart oder Fragment, das von einer entfernten source: abgerufen wird, einer Datei, die ein artifacts-Eintrag — oder ein Eintrag im boundary.artifacts eines Recipe — mit $import einbringt, oder den Dateien einer source:, die ein Verzeichnis oder eine Datei daneben benennt. Welchen Digest jedes davon ergab, wird in einer Datei namens entity.lock im selben Verzeichnis wie die Entitätsdatei festgehalten. Die von Ihnen geschriebene Entitätsdatei wird nie beschrieben; was abgeleitet wurde, liegt daneben. Das Schema der Entitäts-Lock-Datei beschreibt die Datei Feld für Feld.
Wer sie schreibt. Ein einziger Schritt schreibt sie: aggrega pin, den der Autor der Entität ausführt, der kein Release benötigt und jede Klasse von Pin erfasst, die die Lock-Datei enthält. aggrega pull --pin-sources und aggrega push --pin-sources führen denselben Schritt im Namen des Autors aus und schreiben dieselben Bytes. Ein Pull, der nicht zum Pinnen aufgefordert wurde, schreibt überhaupt keine Lock-Datei: Für jedes Recipe und FeatureRecipe, das das Release aus Ihren Katalogverzeichnissen baut, vergleicht er, was der Schritt erfassen würde, mit dem, was die Lock-Datei enthält, und hält an, wo ein Pin fehlt oder nicht mehr zu seiner Eingabe passt, wobei er die Entität, jede Eingabe und ihre Klasse sowie aggrega pin benennt. Die Dateien einer lokalen Quelle werden als eine Menge an ihre Pins gehalten: Eine Lock-Datei, die keine davon erfasst, hält den Pull an, ebenso eine Datei, die seit dem Pin hinzugefügt, geändert oder entfernt wurde. Der Workspace-Schlüssel pin_sources_at_pull macht das Pinnen zum Standard jedes Pulls, und --pin-sources=false stellt das Anhalten für einen Lauf wieder her. Pinnen ist eine Aufgabe des Autors, daher bedeutet ein Anhalten beim ersten Pull eines Nutzers, dass der Herausgeber der Entität sie nie gepinnt hat; die Abhilfe des Nutzers ist dieser Schlüssel, nicht eine manuelle Bearbeitung des Verzeichnisses eines anderen. aggrega pin legt dies vollständig dar.
Was sie enthält. Drei Listen, deren Zeilen jeweils eine Eingabe benennen:
sourceDigests— eine Zeile für jede entferntesource:, deren Koordinaten Sie vollständig ausgeschrieben haben, ohne Template inkind,url,chart,module_subdir,versionoderref. Die Zeile enthältkindundurlder Quelle, ihrchartodermodule_subdir, sofern vorhanden, die Version, zu der sie aufgelöst wurde — bei einer Git-Quelle den Commit, den ihrrefbenannt hat —, und den Inhalts-Digest des abgerufenen Archivs, dazu den Manifest-Digest bei einem über OCI abgerufenen Chart.artifactDigests— eine Zeile für jedenartifacts- oderboundary.artifacts-Eintrag, der von einer mit$importimportierten Datei geliefert wird, mit dem Namen des Eintrags und dem Digest der Bytes der Datei. Einartifacts-Eintrag wird mit seinem Schlüssel benannt und einboundary.artifacts-Eintrag alsboundary/<key>, sodass je ein Eintrag beider Blöcke unter demselben Schlüssel getrennt gepinnt wird.localSourceDigests— eine Zeile für jede Datei, die einesource:, die ein Verzeichnis oder eine Datei neben der Entität benennt, zu dem beiträgt, was eine Veröffentlichung der Entität enthält, mit dem Pfad der Datei neben der Entität und dem Digest ihrer Bytes. Für eine solche Quelle wird nichts abgerufen; der Digest ihrer Dateien wird so berechnet, wie sie vorliegen. Eine als Template geschriebene Quelle trägt jede Datei im Verzeichnis der Entität bei, daher hat jede davon eine Zeile.
Was sie nicht enthält:
- Eine entfernte Quelle, deren Koordinaten aus einem Template gefüllt werden — zum Beispiel eine
version, die aus.infragelesen wird. Welches Artefakt sie benennt, entscheidet jedes Release, das die Entität verwendet, daher wird jede Version, zu der sie aufgelöst wird, im Lockfile dieses Release gepinnt, und nichts darüber wird neben die Entität geschrieben. - Ein inline geschriebener
artifacts- oderboundary.artifacts-Eintrag, der Teil der Entitätsdatei ist, und ein aus einer ArtifactLibrary übernommener Eintrag, dessen Inhalt durch die Bibliotheksversion gepinnt wird, die das Lockfile erfasst.
Eine Entität, für die nichts zu pinnen ist, erhält keine entity.lock, und der Schritt entfernt sie, wenn er über eine Entität läuft, die keine mehr benötigt.
Committen Sie sie neben der Entität. Jedes Recipe und FeatureRecipe verwendet denselben Dateinamen, und das Verzeichnis, in dem die Datei liegt, sagt, zu welcher Entität sie gehört, sodass die Lock-Datei mit diesem Verzeichnis wandert. Sie enthält keinen Zeitstempel, und ihre Zeilen werden in fester Reihenfolge gehalten, sodass der Schritt bei unveränderten Eingaben sie byte-identisch lässt und ein Diff darüber die Quelle, die importierte Datei oder die Datei der lokalen Quelle benennt, die sich bewegt hat. Ein Verzeichnis enthält eine Lock-Datei, daher lehnt der Schritt ein Recipe oder FeatureRecipe ab, neben dem eine andere Entität liegt — jede Art hat ein eigenes Verzeichnis außer Aggregate, Release und Manifest —, und ein zum Pinnen aufgeforderter Pull lehnt eine solche Entität ab, bevor irgendetwas aufgelöst wird; Eine Entität pro Verzeichnis legt die Regel dar. Ein Pull, der nicht pinnt, schreibt nichts neben eine Entität und beurteilt ihr Verzeichnis nicht.
aggrega build hält Ihre Dateien daran. Ein Build liest die Lock-Datei und führt drei Vergleiche durch:
- Der Digest jeder importierten Datei wird erneut berechnet und mit ihrer Zeile verglichen, eine
boundary.artifacts-Datei genau wie eineartifacts-Datei. Eine nach dem Pinnen bearbeitete Datei hält den Build mit[CATALOG_ERROR E0026]an und benennt das Artefakt so, wie seine Zeile es benennt, die importierte Datei und beide Digests. - Der Digest der Dateien einer lokalen Quelle wird erneut berechnet und mit ihren Zeilen verglichen, als eine Menge, bevor der Provider die Quelle liest. Eine seit dem Pin bearbeitete, hinzugefügte oder entfernte Datei hält den Build mit
E0305unter der Komponenteninstanz an, deren Quelle sie ist, und benennt jede solche Datei und beide Digests; eine Datei neben der Entität, die die Quelle nicht beiträgt, wird nicht verglichen. Eine Lock-Datei, die für eine lokale Quelle keine Zeile erfasst, lässt nichts zu vergleichen, wie A local source no longer matches the pins recorded beside its Recipe (Eine lokale Quelle stimmt nicht mehr mit den neben ihrem Recipe erfassten Pins überein) beschreibt. - Jede Quellzeile wird mit dem Digest verglichen, den das Lockfile des Release für dieselbe Quelle erfasst. Eine Abweichung hält den Build mit
[FETCH_ERROR E0135]an und benennt die Lock-Datei und beide Digests. Die beiden Dateien werden von zwei Auflösungen derselben Quelle geschrieben — der des Pin-Schritts und der des Pulls —, daher weichen sie voneinander ab, wenn diese Auflösungen unterschiedliche Bytes erhalten haben oder wenn eine der beiden Dateien bearbeitet wurde. Unterschiedliche Bytes unter einer Version sind das, wonach ein Upstream aussieht, der eine Version erneut veröffentlicht hat.
Ein vor der Änderung geschriebenes Lockfile führt zuerst zum Anhalten, und ein Pull benennt die Datei. Das Lockfile erfasst die Entität anhand dessen, was sie enthält, und die Lock-Datei sowie jede Datei, die diese Vergleiche lesen, gehören dazu; daher hält ein Build — oder aggrega pull --verify — mit einem Lockfile, das geschrieben wurde, bevor sich eine importierte Datei, eine Datei einer lokalen Quelle oder die Lock-Datei selbst bewegt hat, an, bevor einer der drei Vergleiche läuft: The lockfile no longer matches what the release resolves to (Das Lockfile stimmt nicht mehr mit dem überein, wozu das Release aufgelöst wird), mit Nennung der Entität und beider Digests. Ein einfaches aggrega pull benennt dann die Datei, weil es die Lock-Datei an dem misst, was der Pin-Schritt erfassen würde, und die Eingabe ablehnt, deren Pin nicht mehr passt: An entity reads an input the lock beside it records no pin for (Eine Entität liest eine Eingabe, für die die Lock-Datei neben ihr keinen Pin erfasst).
Wo das Lockfile keinen Eintrag über den eigenen Inhalt der Entität hat, sind es die drei Vergleiche, auf die ein Build trifft. Ein Recipe oder FeatureRecipe, das das Manifest über einen Verweis benennt, der zugleich der Name einer Component oder eines Feature ist, die das Release erreicht, hat keinen eigenen Eintrag: Der Eintrag des Lockfile für diesen Verweis erfasst die Component oder das Feature, sodass sich im Lockfile nichts bewegt, wenn sich die Dateien des Recipe bewegen, und ein Build und ein verifizierender Pull melden die bewegte Datei mit dem obigen Code. Der Vergleich der Quellzeilen ist auch das, worauf ein Build trifft, wenn der source_artifacts-Eintrag des Lockfile der Datensatz ist, der sich geändert hat, während die Lock-Datei neben der Entität unverändert blieb.
Auf das Anhalten reagieren. Wenn Sie die importierte Datei absichtlich geändert haben, führen Sie aggrega pin für die Entität aus: Der Schritt erfasst den neuen Digest der Datei, und der nächste Build akzeptiert ihn. Wenn nicht, stellen Sie die Datei wieder her. Für eine lokale Quelle, die sich bewegt hat, gelten dieselben beiden Antworten: Pinnen Sie die Entität erneut, oder stellen Sie die Dateien wieder her, die das Anhalten benennt. Bei einer Quellzeile, die vom Lockfile abweicht, stellen Sie entity.lock aus der Versionskontrolle wieder her oder führen Sie aggrega pin für die Entität aus, um sie neu zu schreiben.
Auch aggrega pull --verify prüft sie. Ein verifizierender Pull führt dieselben drei Vergleiche über die Lock-Dateien neben den Recipes und FeatureRecipes durch, die das Release in Ihren Katalogverzeichnissen erreicht, meldet jeden Pin, den ein Build ablehnen würde, mit demselben Code und in denselben Worten, endet mit einem Exit-Code ungleich null, wenn es einen gibt, und schreibt keine Lock-Datei.
Wo keine Lock-Datei verglichen wird. Ein Recipe oder FeatureRecipe, das aus einer Registry statt aus einem Ihrer Katalogverzeichnisse aufgelöst wird, hat keine Lock-Datei, die ein Build liest; seine Quellen werden allein am Lockfile des Release gemessen. Und eine an einem Git-ref: geschriebene Quelle wird in der Lock-Datei mit dem Commit erfasst, zu dem dieser Ref aufgelöst wurde, während ein Build den Pin der Quelle bei der Version sucht, die die Entität benennt, sodass diese Zeile nie verglichen wird — weder von einem Build noch von einem verifizierenden Pull. Das Lockfile pinnt den Commit trotzdem, und jeder Build verifiziert das zwischengespeicherte Archiv dagegen.
Der Plugin-Vertrauensdatensatz
Manche Plugins, die der Workspace anbindet, prägen die gerenderte Ausgabe nie. Eine plugins.governance-Anbindung in einer ir-verdict- oder render-verdict-Rolle sowie jede plugins.linter-Anbindung geben ein Urteil aus Annahme oder Ablehnung zurück und sonst nichts — keines ihrer Bytes erreicht ein Artefakt. Daher sind sie nicht Teil dessen, was ein Build byte-genau reproduziert, und das Lockfile, das genau das pinnt, ist der falsche Ort für sie.
Ihre Identitäten kommen stattdessen in eine zweite committete Datei: plugins-trust.yaml, neben dem Lockfile. Sie enthält einen Eintrag pro solchem Plugin, der die Identitätskoordinate des Plugins, die dafür gewählte Version und den Inhalts-Digest des aufgelösten Artefakts festhält — dazu die Signatur, die der Pull für dieses Artefakt verifiziert hat, sofern er eine verifiziert hat, und, wenn der Herausgeber dieses Artefakt seit der Veröffentlichung als veraltet markiert hat, die Markierung, die der Pull gefunden und verifiziert hat. Das Schema des Plugin-Vertrauensdatensatzes beschreibt die Datei Feld für Feld.
Committen Sie plugins-trust.yaml zusammen mit dem Lockfile, aus demselben Grund, aus dem Sie das Lockfile committen: Ein Datensatz außerhalb der Versionskontrolle ist einer, den niemand prüfen und mit dem nichts verglichen werden kann. Committet ist er eine gemeinsame Aussage darüber, zu welchem Plugin jede dieser Anbindungen aufgelöst wurde, und ein Diff darüber benennt die Identität, die sich geändert hat.
Die Datei erscheint nur, wenn es etwas zu erfassen gibt. Ein Workspace, der kein urteilendes Plugin anbindet, löst keine solche Identität auf, daher schreibt der Pull keine Datei und sagt nichts darüber — eine Abwesenheit, keine fehlende Datei. Wenn der Pull sie erstellt, benennt er die erstellte Datei und fordert Sie auf, sie zu committen. Ein späterer Pull fügt eine Identität hinzu, die der Datensatz noch nicht enthält, und lässt jede bereits erfasste Identität genau so, wie sie ist.
Jede Änderung an dieser Datei wird angekündigt, und sonst nichts. Ein Pull, der den Datensatz ändert, gibt pro geändertem Eintrag eine Zeile aus und benennt das Plugin und die Art der Änderung: eine erstmals erfasste Identität, eine anstelle der vorhandenen übernommene Identität (mit Nennung beider, damit Sie sehen, was ausgetauscht wurde), eine Veraltungsmarkierung, die zu dem Artefakt erfasst wurde, das ein Eintrag bereits benennt, eine von einem Eintrag entfernte Veraltungsmarkierung, eine zu einem Eintrag erfasste oder von ihm entfernte Signatur oder der entfernte Eintrag. Die oben genannte Erstellungszeile ist separat und betrifft die Datei statt eines Eintrags, daher sagt eine erste Auflösung beides: Diese Datei ist neu und muss committet werden, und dies sind die Identitäten, die sie jetzt enthält.
Ein Pull, der den Datensatz genau so lässt, wie er war, sagt nichts darüber. Eine Zeile über diese Datei bedeutet also, dass sich die committete Datei bewegt hat und ihr Diff lesenswert ist — was hier mehr zählt als beim Lockfile. Alles, was das Lockfile pinnt, ist auch Teil dessen, was ein Build byte-genau reproduziert, sodass eine Änderung dort einen zweiten Ort hat, an dem sie sichtbar wird; die Identität eines Urteils-Plugins hat keinen. Diese Datei ist der einzige Ort, an dem ein ausgetauschtes Gate festgehalten wird.
aggrega pull --dry-run kündigt nichts davon an, weil es nichts ändert. Stattdessen führt es den Datensatz unter den Dateien auf, die es schreiben würde, wie Vorschau dessen, was ein Pull schreiben würde beschreibt.
Eine Veraltungsmarkierung wird einem Eintrag hinzugefügt, den der Datensatz bereits enthält, und das ist nicht dasselbe, wie ihn neu zu schreiben. Wenn ein Herausgeber ein Plugin als veraltet markiert, dem Sie bereits vertrauen, erfasst das nächste aggrega pull die Markierung am bestehenden Eintrag dieses Plugins — Koordinate, Version und Digest bleiben unberührt, weil sich das Artefakt nicht bewegt hat und nichts Neues übernommen wird. Ein einfacher Pull kann also einen deprecation-Block hinzufügen, und nur ein explizites Upgrade ändert je eine Identität. Eine Markierung wird nur zu dem Artefakt erfasst, das der Eintrag bereits benennt, und kein Pull verfolgt eine, die nicht mehr veröffentlicht wird: Eine erfasste Markierung verschwindet nur mit dem Eintrag, der sie trug, also entweder wenn dieser Eintrag entfernt wird oder wenn ein explizites Upgrade das Plugin erneut auflöst und an den Bytes, die der Eintrag bereits erfasst, keine Markierung findet.
Die verifizierte Signatur wird auf dieselbe Weise an einem Eintrag erfasst, und jeder Pull beantwortet sie neu. Der Pull verifiziert bei jedem Lauf die Signatur jedes dieser Plugins gegen die Vertrauensrichtlinie seiner Registry — ein Plugin, das eine Registry bereitstellt, wird jedes Mal anhand seiner Version abgerufen, da nichts es pinnt — und erfasst, was er verifiziert hat, am Eintrag des Plugins, wiederum ohne die Identität zu berühren: den Modus, den passenden Signierer und den Digest des zwischengespeicherten Signatur-Bundles, dieselbe signature, die ein Lockfile-Eintrag enthält. Anders als bei einer Markierung ersetzt die Antwort, was der Eintrag enthielt, und wo der Pull keine Signatur verifiziert hat — das Plugin trägt keine und keine ist erforderlich, oder skip_signature_verification oder eine advisory-Registry hat es zugelassen —, erfasst der Eintrag keine. Das verifizierte Signatur-Bundle wird ebenfalls erneut zwischengespeichert, und eine zwischengespeicherte Kopie, die nicht mehr zu ihrem Digest passt, wird neu geschrieben. So werden ein Eintrag, der seine Signatur verloren hat, ein Eintrag mit einer aus dem Eintrag eines anderen Plugins kopierten Signatur, ein Eintrag, dessen zwischengespeichertes Signatur-Bundle entfernt oder verändert wurde, oder ein Datensatz, der gelöscht oder vor der Erfassung einer Signatur geschrieben wurde, durch das nächste einfache aggrega pull repariert. Ein Build hält jedes solche Plugin an diese Tatsache: siehe Der Plugin-Vertrauensdatensatz auf der Build-Seite.
Eine aufgelöste Identität, die von der erfassten abweicht, hält den Pull an. Ein erfasster Eintrag benennt sowohl eine Version als auch einen Digest, daher ist die Bewegung des einen oder des anderen dasselbe Ereignis: Das Plugin, das ausgeführt würde, ist nicht das Plugin, für das der Datensatz geprüft wurde. Die Diagnose benennt das Plugin, was der Datensatz enthält und was diese Auflösung gemeldet hat, auf beiden Achsen zugleich — und der Pull stoppt, ohne den Datensatz zu berühren, sodass die geprüfte Identität zum Vergleich erhalten bleibt. Er hält allein wegen der Version an (eine erneute Veröffentlichung, deren Bytes sich nicht geändert haben), genau wie allein wegen des Digests (ein erneuter Push unter derselben Version).
aggrega pull --verify führt denselben Vergleich durch. Es schreibt keine der Dateien, die ein Pull committet, und übernimmt daher nichts; es meldet, ob diese Dateien noch beschreiben, was ein Pull heute auflösen würde, und der Datensatz ist eine davon. Es misst außerdem die Signatur jedes Eintrags an der, die die eigene Verifizierung des Plugins durch den Pull ergibt, und meldet einen Eintrag, dessen Signatur ein Pull erfassen, ersetzen oder entfernen würde — sowie ein Plugin, für das der Datensatz keinen Eintrag enthält, wo ein Build es ablehnt, weil keine Signatur erfasst ist —, wie Es vergleicht die erfassten Signaturen, in beiden Dateien beschreibt.
Um eine neue Identität zu übernehmen, fordern Sie sie namentlich an: aggrega pull --upgrade --release <release> <plugin>, wobei Sie das Plugin so benennen, wie es Ihre Anbindung in .aggrega-config.yaml benennt, ohne Versionssuffix. Das löst genau dieses eine Plugin erneut auf und schreibt seinen Eintrag neu, während jede andere gepinnte Abhängigkeit und jede andere erfasste Identität unberührt bleibt — und es funktioniert, obwohl das Plugin keinen Lockfile-Pin hat, weil ein benanntes Ziel auch eine dieser Anbindungen benennen darf. Ein bloßes aggrega pull --upgrade, das jede Abhängigkeit erneut auflöst, löst auch jede erfasste Identität erneut auf und schreibt sie neu. Ebenso aggrega build --upgrade, das einen bloßen vollständigen Refresh-Pull ausführt und keine Möglichkeit hat, ein einzelnes Ziel zu benennen.
Um eine Identität zu entfernen, fordern Sie auch das namentlich an. Das Lösen eines Plugins aus .aggrega-config.yaml entfernt seinen Eintrag nicht, und das ist beabsichtigt: Ein einfaches aggrega pull entfernt nie einen. Führen Sie aggrega pull --upgrade --release <release> <plugin> aus und benennen Sie das Plugin so, wie der Datensatz es benennt — mit seiner Identitätskoordinate, der Zeichenkette, die das unten beschriebene Anhalten ausgibt —, und der Eintrag wird entfernt, während jede andere gepinnte Abhängigkeit und jede andere erfasste Identität unberührt bleibt. Ein bloßes aggrega pull --upgrade entfernt jeden Eintrag, den keine Urteils-Anbindung mehr benennt, im selben Durchgang, der alles andere erneut auflöst.
Das Entfernen des letzten Eintrags lässt die Datei bestehen und leer, statt sie zu löschen. Ein leerer Datensatz enthält nichts, daher pinnt er nichts und hält nichts an — genau wie gar kein Datensatz —, und das Beibehalten der Datei bedeutet, dass die Entfernung in ihrem Diff als Entfernung erscheint.
Ein Datensatz, der sein Schema nicht erfüllt, hält jeden Befehl an, der ihn liest — einen Build, einen Release-bezogenen Lint und einen Pull, einschließlich eines Pulls, der selbst nichts zu erfassen hat. Ein geleerter und ein beschädigter Datensatz sind bewusst verschieden: Leeren ist die Art, den letzten Eintrag zu entfernen, und ein geleerter Datensatz bleibt still, während eine Datei, deren Inhalt sich nicht mehr parsen lässt, ein Fehler ist und kein leerer Datensatz — sie als leer zu lesen, würde das Kürzen der Datei zu einem Weg machen, den Vergleich abzuschalten. Stellen Sie sie aus der Versionskontrolle wieder her, um die geprüften Identitäten zurückzubekommen.
Ein Plugin, das aus der Kopie im Compiler-Binary bereitgestellt wird, wird nicht erfasst. Der Pull erfasst, was er beschafft hat — aus einer Registry abgerufen oder aus dem Cache gelesen —, und aus dem Binary wird nichts beschafft: Diese Bytes werden durch die Compiler-Version identifiziert, die sie enthält, daher gibt es keine eigene Auflösung zu erfassen. Das Anbinden eines Plugins, das das Binary bereits enthält, erzeugt daher keinen Eintrag dafür. Das bedeutet, dass der Datensatz bei beschafften Artefakten bleibt, nicht, dass eine Auflösung fehlgeschlagen ist.
Ein Build, ein Release-bezogener Lint und eine Release-bezogene Validierung halten die Workspace-Konfiguration an den Datensatz. Bevor eine dieser Anbindungen läuft, vergleichen aggrega build, aggrega lint --release und aggrega validate --release — und dieselben Operationen, über aggrega serve und aggrega mcp erreicht — die Urteils-Anbindungen, die die Konfiguration benennt, mit den Einträgen, die der Datensatz enthält. Ein Plugin, dessen aufgelöster Artefakt-Digest nicht der erfasste ist, wird abgelehnt statt ausgeführt. Ein Eintrag im Datensatz, für den keine konfigurierte Urteils-Anbindung aufkommt, hält den Lauf an: Ein Gate, das geprüft wurde und jetzt fehlt, hinterlässt eine Ausgabe, die sich nicht von einer von diesem Gate genehmigten Ausgabe unterscheiden lässt, und genau das kann jemand, der die Ausgabe liest, nicht sehen. Das Anhalten benennt das Plugin und bietet die zwei Abhilfen an, die sich danach unterscheiden, was Sie beabsichtigt haben — binden Sie das Plugin erneut an, wenn die Entfernung ein Versehen war, oder führen Sie das oben beschriebene explizite Upgrade aus, wenn sie beabsichtigt war —, und es gibt dieses Upgrade ausführungsbereit aus. Die umgekehrte Richtung — eine Anbindung, die der Datensatz noch nicht enthält — ist die oben beschriebene erste Sichtung, und keiner der beiden Vergleiche hält deswegen an; die Signaturanforderung ist die eine Bindung, der eine Anbindung ohne Eintrag nicht entgeht. Dieselben drei Oberflächen halten jedes Plugin, das sie aus dem Cache lesen, beim Laden an die Signatur, die sein Eintrag erfasst, wie die Build-Seite für einen Build beschreibt. Die Lint-Bereiche für den gesamten Katalog und für eine einzelne Entität ziehen keinen Datensatz heran.
Eine Validierung wird an den Datensatz gehalten, weil sie dieselben Prüfungen ausführt wie ein Build. aggrega validate --release erreicht jede Prüfung, die aggrega build erreicht, bis auf das Schreiben der Artefakte, Gate-Plugins eingeschlossen — das ist es, was „das validiert“ dasselbe bedeuten lässt wie „das baut“ —, daher wird die Identität des Plugins, das sie ausführt, genau wie bei einem Build mit dem Datensatz verglichen. Die anderen Bereiche von aggrega validate werden nicht daran gehalten: Die Validierung des gesamten Katalogs, einer einzelnen Entität oder eines Plugin-Binarys liest die Plugin-Anbindungen des Workspace überhaupt nicht, daher läuft in ihnen kein Urteils-Plugin, und es gibt nichts, woran ein Datensatz etwas halten könnte.
Eine Konfiguration an den Datensatz zu halten, stellt Anwesenheit und Identität fest, und nichts darüber hinaus. Es stellt fest, dass jedes Gate, das der Datensatz benennt, noch angebunden ist und dass jedes aus dem für es erfassten Artefakt läuft. Es stellt nicht fest, dass ein gelaufenes Gate überhaupt ein Urteil zurückgegeben hat, und ein solcher Fall wird nirgends erkannt: Eine Anbindung, deren function einen Export benennt, den das Plugin tatsächlich deklariert, der aber nicht der Urteils-Export ist, den ihr Socket liest, und deren Ausgabe kein Feld der obersten Ebene außerhalb der Form enthält, die dieser Socket erwartet — das leere Objekt ist der einfachste Fall —, läuft, gibt nichts zurück, aufgrund dessen abgelehnt werden könnte, und lässt den Build durch. Ihre Ausgabe ist von der eines genehmigenden Gates nicht zu unterscheiden, und kein Vergleich mit dem Datensatz kann es bemerken, weil am Datensatz nichts falsch ist: Das gelaufene Plugin ist genau das erfasste, und es hat einfach nichts ausgeführt. Zwei benachbarte Fälle halten an, sodass die Grenze nicht weiter ist, als sie sich liest — eine function, die einen Export benennt, den das Plugin nicht deklariert, wird beim Laden des Plugins abgelehnt, und eine Ausgabe mit einem Feld der obersten Ebene, das die Form des Sockets nicht deklariert, wird abgelehnt, statt als eine zufällig leere Urteilsliste gelesen zu werden. Eine erfasste Identität reicht also für sich allein nicht aus, damit ein Gate etwas beurteilt hat.
Der erfasste Digest bestimmt die Plugins, die der Workspace aus dem von aggrega pull befüllten Cache auflöst, und nichts, was er auf andere Weise auflöst. Das ist die Auflösung, die eine Urteils-Anbindung normalerweise nimmt — nichts pinnt sie im Lockfile, daher stammen ihre Bytes aus dem Cache, und bei diesem Lesen wird der aufgelöste Digest mit dem erfassten verglichen. Ein Urteils-Plugin, das der Workspace auf andere Weise auflöst, erreicht dieses Lesen nie und wird von dem bestimmt, was die Art seiner Auflösung bestimmt, statt vom Datensatz: Bytes aus der Kopie im Compiler-Binary werden durch die Compiler-Version identifiziert, die sie enthält, eine .wasm neben ihrer Katalog-Entität ist eine Datei in Ihrem eigenen Katalogverzeichnis, ein expliziter Dateisystempfad ist der Pfad, den Sie benannt haben, und ein Plugin mit einem Lockfile-Pin wird von diesem Pin bestimmt. Die andere Hälfte davon, eine Konfiguration an den Datensatz zu halten, ist nicht so begrenzt: Für jeden Eintrag, den der Datensatz enthält, muss weiterhin eine konfigurierte Anbindung aufkommen, wie auch immer dieses Plugin aufgelöst wird. Der Datensatz stellt also fest, dass die Gates, die er benennt, noch angebunden sind, was auch immer sie bereitstellt, und er stellt die Artefaktidentität derjenigen fest, die aus dem Cache bereitgestellt werden.
Beibehalten vs. Aktualisieren
Standardmäßig behält aggrega pull ein vorhandenes Lockfile bei: Eine bereits gepinnte Abhängigkeit wird exakt in ihre gepinnte Version aufgelöst (geprüft gegen ihren gepinnten Digest), nur noch nicht gepinnte Referenzen werden aufgelöst und hinzugefügt, und Pins für Referenzen, die das Release nicht mehr erreicht, werden entfernt. Ein erneuter Pull eines unveränderten Release ist daher wirkungslos — er reproduziert dasselbe Lockfile Byte für Byte (einschließlich generated_at). Das Hinzufügen einer neuen Abhängigkeit oder ein Pull, nachdem eine manuelle Bearbeitung einen Pin entfernt hat, löst nur diese Lücke auf und lässt alle anderen Pins unverändert.
Eine Abhängigkeit, die ein erneuter Pull aus dem Cache liest, wird genau so erfasst, wie der Pull, der sie abgerufen hat, sie erfasst hat. Ihre Zeile behält die Version, den Inhalts-digest und den manifest_digest — Letzteren aus dem Manifest, das im Cache neben dem Inhalt gespeichert ist — zusammen mit der signature und der deprecation, die jener Pull in der Registry verifiziert hat. Nichts davon wird erneut nachgeschlagen, solange ein Build die Zeile akzeptieren würde, und --detail meldet eine solche Abhängigkeit als cache-reuse. Ein erneuter Pull, dessen Abhängigkeiten alle im Cache liegen, über einem Lockfile, das jede von der Vertrauenskonfiguration verlangte Signatur und nur Signaturen erfasst, die ein Build akzeptiert, schreibt also dasselbe Lockfile, ob die Registry erreichbar ist oder nicht.
Ein erneuter Pull schlägt eine Signatur genau dort erneut nach, wo ein Build die Zeile ablehnen würde, und es gibt zwei solche Zeilen.
- Eine verlangte Signatur, die das Lockfile nicht erfasst. Wo die Vertrauenskonfiguration für eine Abhängigkeit, die der Cache bereitstellt, eine Signatur verlangt und die Lockfile-Zeile keine erfasst — die Zeile wurde bearbeitet, das Lockfile wurde über einem Cache, den ein früherer Pull gefüllt hat, neu geschrieben, oder die Anforderung wurde nach dem Pull hinzugefügt, der die Zeile geschrieben hat —, fragt der erneute Pull die Registry dieser Abhängigkeit nach ihrer Signatur, anhand des Digests des Manifests, das im Cache neben ihr gespeichert ist, genau wie bei einer Abhängigkeit, die er abruft, und erfasst die verifizierte Signatur in der Zeile. Diese Zeile ist diejenige, die ein Build ablehnt (No verified signature is recorded for an artifact that requires one (Für ein Artefakt, das eine Signatur erfordert, ist keine verifizierte Signatur erfasst)), daher beseitigt ein erneuter Pull diese Ablehnung. Eine Registry, die keine Signatur anhängt, oder eine Signatur, die die Vertrauenskonfiguration nicht akzeptiert, bricht den erneuten Pull ab, so wie sie einen Pull abbricht, der die Abhängigkeit abgerufen hat. Die Einstellungen, mit denen ein Pull eine Abhängigkeit ohne Signatur zulässt, lassen eine solche Zeile unverändert und fragen nichts zu ihr:
skip_signature_verificationauf oberster Ebene, derselbe Schalter im eigenen Eintrag der Registry außer für eine Art, die die workspaceweite Signierrichtlinie verlangt, und eine alsadvisorymarkierte Registry. - Eine erfasste Signatur, die ein Build nicht akzeptiert. Wo die Zeile eine Signatur erfasst, deren zwischengespeichertes Signaturbündel nach dem Pull, der es zwischengespeichert hat, entfernt oder verändert wurde — oder eine aus einer anderen Zeile kopierte
signature, deren Bündel intakt ist, aber für ein anderes Artefakt erstellt wurde —, lehnt ein Build die Zeile ab, unabhängig davon, was die Signaturanforderung besagt (A cached signature bundle does not match the digest recorded for it (Ein zwischengespeichertes Signaturbündel stimmt nicht mit dem dafür erfassten Digest überein), A recorded signature was made for a different artifact (Eine erfasste Signatur wurde für ein anderes Artefakt erstellt)). Deshalb fragt der erneute Pull die Registry dieser Abhängigkeit erneut nach ihrer Signatur, unabhängig von der Anforderung, über dieselbe Verifizierung, die eine abgerufene Abhängigkeit durchläuft: Was diese verifiziert, ersetzt die Signatur der Zeile, und das darin genannte Bündel wird erneut zwischengespeichert, wobei eine zwischengespeicherte Kopie, die nicht mehr zu ihrem Digest passt, neu geschrieben wird — sodass Zeile und Cache das enthalten, was der Pull hinterlassen hat, der die Abhängigkeit abgerufen hat. Eine Signatur, die die Vertrauenskonfiguration nicht akzeptiert, bricht den erneuten Pull ab, so wie sie einen Pull abbricht, der die Abhängigkeit abgerufen hat, und ebenso eine Registry, die keine anhängt, wo eine Signatur verlangt wird. Wo die Verifizierung keine erfasst —skip_signature_verification, wo es gilt und nichts fragt, eine Registry, die keine Signatur anhängt, wo keine verlangt wird, oder eineadvisory-Registry, wo nichts verifiziert wird —, wird die Signatur der Zeile gelöscht, was ein Build unter denselben Einstellungen zulässt.
Eine Zeile, deren erfasste Signatur ein Build akzeptiert, wird nicht erneut abgefragt, ebenso wenig eine Zeile ohne Signatur, für die nichts eine Signatur verlangt.
Eine ohne Registry benannte Abhängigkeit kann in einem Workspace, der jetzt keine default_registry mehr nennt, nicht abgefragt werden. Ihre Zeile wurde durch den Pull, der ihre Signatur erfasst hat, an eine Registry gebunden, und ohne Standard gibt es keine Registry, die man fragen könnte. Wo eine solche Zeile eine Signatur erfasst, die ein Build nicht akzeptiert, bricht der erneute Pull mit der Ablehnung des Builds selbst ab, meldet, dass keine Registry konfiguriert ist, um die Zeile erneut abzufragen, und lässt das Lockfile unverändert. Die Registry, aus der die Abhängigkeit stammt, als default_registry zu konfigurieren und erneut zu pullen, behebt das.
Was dieses Beibehalten regelt, ist das, was eine Registry oder der Cache bereitstellt. Eine Entität, die ein lokales Katalogverzeichnis liefert, wird aus diesem Verzeichnis aufgelöst, in der Version, die ihre Datei deklariert, und der Eintrag, den das Lockfile für sie erfasst, wird dabei nicht herangezogen. Das Lockfile erfasst eine solche Entität dennoch, Sie sehen sie also dort — aber diesen Eintrag manuell zu bearbeiten, hält die Entität nicht auf der Version, die Sie geschrieben haben, und der nächste Abgleich schreibt den Eintrag passend zur Datei neu. Um zu ändern, welche Version einer lokal gelieferten Entität ein Release auflöst, bearbeiten Sie die Katalogdatei statt des Lockfiles.
Ein Pin benennt Bytes, keinen Ort, daher wird ein Cache-Eintrag, der seinen Pin nicht mehr enthält, übergangen statt ihm zu vertrauen. Eine an Ort und Stelle bearbeitete Entität — ein neuer Inhalt unter derselben version — hinterlässt im Inhalts-Cache den früheren Inhalt unter diesem Namen und dieser Version. Ein Katalogverzeichnis wird zuerst gelesen, daher wird eine Entität, die eines noch liefert, aus ihrer Datei gepinnt, und der veraltete Eintrag wird nie gelesen. Das Rendering, das der Pull ausführt, um die externen Eingaben des Release zu ermitteln, liest jeden Pin so, wie ein Build es tut, aus dem Katalogverzeichnis, das die gepinnten Bytes enthält, und meldet den übergangenen Eintrag mit dem Hinweis, den aggrega build ausgibt. Wo kein Katalogverzeichnis die Entität liefert und eine Registry erreichbar ist, ruft der Pull die gepinnte Version erneut ab, schreibt den Eintrag neu und meldet dies auf der Standardfehlerausgabe, unter Nennung des Eintrags und beider Digests:
reuse: cache entry for <name>:<version> held <digest the entry held>, not the pinned <pinned digest>; refreshed from the registry (pin unchanged)Die abgerufenen Bytes werden wie bei jedem Abruf unter einem Pin am Pin gemessen, daher bricht eine Registry, die unter dieser Version andere Bytes ausliefert, den Pull ab, wie unten beschrieben. Wo keine Quelle die gepinnten Bytes enthält — kein Katalogverzeichnis liefert die Entität, der Cache-Eintrag enthält andere Bytes, und keine Registry stellt die gepinnte Version bereit oder der Lauf erreicht keine —, brechen der Pull und aggrega pull --verify mit E0135 ab — oder mit E0133, wo das Manifest des Cache-Eintrags nicht das ist, das das Lockfile pinnt —, unter Nennung jeder gelesenen Quelle und ihres Inhalts; wo der Lauf keine Registry erreicht hat, nennt der Abbruch auch den Schritt, der die gepinnte Version erneut abruft.
Um gepinnte Versionen zu aktualisieren, führen Sie aggrega pull --upgrade --release <release> aus — es verwirft die vorhandenen Pins und löst alle Abhängigkeiten erneut in die neuesten passenden Versionen auf. Das Aktualisieren ist der explizite Schritt; der Standard lässt eine gepinnte Abhängigkeit nie wandern. Dies entspricht der Konvention von npm ci / cargo / go build (der Standard setzt den Lock um; Aktualisieren ist Opt-in), und es ist das, was den automatischen Pull von aggrega build sicher macht — der Build löst genau das auf, was das Lockfile pinnt, und verschiebt nie stillschweigend eine Version.
Diese Form ohne Ziele verwirft jeden erfassten Pin und fragt daher vor jeder Aktion nach einer Bestätigung. Beantworten Sie sie für die nicht interaktive Verwendung vorab mit --yes; ist die Standardeingabe kein Terminal und fehlt --yes, lehnt sie ab, statt auf eine Antwort zu warten, die niemand geben kann. Das Benennen von Zielen (aggrega pull --upgrade --release <release> <uri>) behält jeden nicht benannten Pin bei, daher fragt diese Form nichts. aggrega build --upgrade führt die Form ohne Ziele aus und unterliegt denselben Bedingungen.
Wenn die Bytes einer gepinnten Version in der Registry nicht mehr zu dem Digest passen, den das Lockfile erfasst hat (eine Verletzung der Unveränderlichkeit upstream), bricht pull mit einem Integritätsfehler ab, statt die geänderten Bytes stillschweigend zu übernehmen — führen Sie --upgrade aus, um bewusst neu zu pinnen.
Ein Lockfile prüfen, ohne es zu schreiben
aggrega pull --verify --release <release> beantwortet eine Frage: Würde ein jetzt ausgeführtes aggrega pull das Lockfile oder den Plugin-Vertrauensdatensatz daneben ändern? Es führt die Auflösung durch, die ein Pull durchführen würde, vergleicht das Lockfile und den Datensatz damit und hält an, bevor etwas geschrieben wird, das ein Pull festschreibt — das Lockfile, der Plugin-Vertrauensdatensatz und jede entity.lock bleiben, wie sie sind. Es endet mit einem Exit-Code ungleich null bei einem fehlenden Lockfile und bei jeder Abweichung und nennt jede einzelne. Verwerfungsmarkierungen werden nicht verglichen, wie unten beschrieben. Es wird zusammen mit --upgrade, mit --dry-run und mit --pin-sources abgelehnt, welchen Wert dieses Flag auch erhält: Eine Prüfung erfasst weder einen Pin, der in einer entity.lock fehlt, noch bricht sie deswegen ab, sodass das Flag nichts ändern würde.
Es behält die erfassten Pins genau so bei wie ein Pull. Eine Abhängigkeit, die das Lockfile pinnt, wird in ihre gepinnte Version aufgelöst und gegen ihren gepinnten Digest geprüft, und eine Entität, die ein lokales Katalogverzeichnis liefert, wird aus diesem Verzeichnis aufgelöst, wie Beibehalten vs. Aktualisieren beschreibt. Daher:
- Eine Referenz, deren Registry seit dem Pull eine neuere Version veröffentlicht hat, ist kein Drift. Ein Pull würde ihren Pin beibehalten, das Lockfile ist also immer noch das, das ein Pull schreiben würde; mit
aggrega pull --upgradewird die neuere Version übernommen. - Eine Registry, die unter einer gepinnten Version jetzt andere Bytes ausliefert, bricht die Prüfung mit dem Integritätsfehler ab, der einen Pull abbricht, statt die Änderung als Drift zu melden.
- Eine manuell bearbeitete Lockfile-Zeile, ein bearbeitetes Release und eine in einem lokalen Katalogverzeichnis bearbeitete Entität werden jeweils gemeldet, weil jede davon eine Abweichung zwischen dem Lockfile und dem ist, was ein Pull jetzt auflöst.
Es liest und füllt den Cache wie ein Pull. Ein Eintrag, den der Cache unter seinem Pin enthält — eine Katalogentität oder die .wasm eines Plugins —, wird von dort gelesen, ohne eine Registry zu fragen; das erlaubt es, eine Prüfung im Offline-Modus über einem Workspace auszuführen, den ein verbundener Pull gefüllt hat. Ein Eintrag, den der Cache nicht enthält, wird abgerufen, wie ein Pull ihn abruft, und einer, der nicht mehr zu seinem Pin passt, wird genau so behandelt, wie ein Pull ihn behandelt. Eine Prüfung kann also den Cache ergänzen, und sie verschiebt nie einen Pin.
Es vergleicht die erfassten Signaturen in beiden Dateien
Die Signatur, die ein Pull für ein Artefakt verifiziert hat, ist Teil dessen, was er schreibt: die signature in einem Lockfile-Eintrag und in einem Eintrag von plugins-trust.yaml für ein Plugin, das in einer Verdict-Rolle angebunden ist. Sobald die Pins übereinstimmen, misst eine Prüfung jede erfasste Signatur an derjenigen, die ein Pull jetzt erfassen würde, und meldet jede, die ein Pull dort erfassen würde, wo keine erfasst ist, ersetzen oder löschen würde, unter A recorded signature is not the one a pull would record (Eine erfasste Signatur ist nicht die, die ein Pull erfassen würde). Jeder solche Eintrag in beiden Dateien wird im selben Lauf genannt.
Welche Lockfile-Einträge sie nachschlägt, entscheidet der Pull selbst. Ein erneuter Pull fragt eine Registry genau dort nach der Signatur eines Eintrags, wo Beibehalten vs. Aktualisieren es beschreibt, und eine Prüfung übernimmt dieselbe Entscheidung:
- Zwei werden gemeldet, ohne eine Registry zu fragen, weil ein Pull sie unabhängig von der Antwort der Registry neu schreibt: ein Eintrag, den der Cache bereitstellt und der keine Signatur erfasst, wo die Vertrauenskonfiguration eine verlangt — der Pull erfasst die Signatur des Artefakts oder hält an, wo sich keine feststellen lässt —, und ein Eintrag, dessen erfasste Signatur für ein anderes Artefakt erstellt wurde, die der Pull durch die eigene des Artefakts ersetzt.
- Jeder andere Eintrag, den ein Pull erneut nachschlagen würde, wird abgefragt, weil nur die Antwort der Registry sagt, ob der Pull ihn ändern würde: ein Eintrag, dessen Bytes diese Prüfung abgerufen hat, und ein Eintrag, dessen zwischengespeichertes Signaturbündel entfernt wurde, unlesbar ist oder verändert wurde. Die Prüfung fragt die Registry, wie es der Pull täte, und meldet den Eintrag, wo die Antwort seine Signatur erfasst, ersetzt oder löscht. Das verifizierte Signaturbündel wird so zwischengespeichert, wie ein Pull es zwischenspeichert, daher besteht ein Eintrag, dessen zwischengespeichertes Bündel entfernt wurde, während seine Registry die erfasste Signatur noch bereitstellt, die Prüfung und hinterlässt einen reparierten Cache.
Ein Eintrag, dessen erfasste Signatur ein Build akzeptiert, und ein Eintrag ohne Signatur, für den nichts eine Signatur verlangt, werden weder von einem Pull noch von einer Prüfung abgefragt.
Der Plugin-Vertrauensdatensatz wird an demselben Pull gemessen. Jeder Pull verifiziert die Signatur jedes in einer Verdict-Rolle angebundenen Plugins bei seiner Registry, und ebenso eine Prüfung, die einen Eintrag meldet, dessen Signatur diese Verifizierung erfassen, ersetzen oder löschen würde. Ein Plugin, für das der Datensatz keinen Eintrag enthält, wird dort gemeldet, wo ein Build es ablehnt, weil keine Signatur erfasst ist, denn ein Pull schreibt einen Eintrag mit seiner Signatur, und der Build lehnt das Plugin bis dahin ab. Jedes andere ist eine Erstsichtung, die eine Prüfung nicht meldet, so wie sie keine Identität meldet, die der Datensatz noch nicht enthält. Im Offline-Modus fragt eine Prüfung keine Registry zu diesen Plugins, und Offline beschreibt, was sie stattdessen meldet.
Verwerfungsmarkierungen werden nicht verglichen. Eine Markierung, die einem Artefakt nach dem Pull angehängt wird, ist Zustand der Registry und ändert sich, ohne dass sich im Workspace etwas ändert; eine Prüfung, die daran scheitert, würde einen Check über Dateien scheitern lassen, die Sie nicht angefasst haben. Aus demselben Grund gibt eine erfasste Markierung einem Build einen Hinweis, statt ihn anzuhalten. Ein Pull kann also eine Markierung an einem Eintrag erfassen, den eine Prüfung bestanden hat.
Vorschau auf das, was ein Pull schreiben würde
aggrega pull --dry-run --release <release> löst die Abhängigkeiten genau so auf wie ein gewöhnlicher Pull und gibt dann, statt zu schreiben, aus, was es geschrieben hätte: eine Kopfzeile mit dem Pfad jeder Datei, gefolgt von dem Inhalt, den diese Datei enthalten würde.
aggrega pull --dry-run --release release.yamlEs nennt jede Datei, nicht nur das Lockfile. Das Lockfile, die entity.lock neben jedem Recipe und FeatureRecipe, dessen erfasste Pins sich unter --pin-sources verschieben würden, und der Plugin-Vertrauensdatensatz erscheinen alle im selben Bericht, denn eine Vorschau, die nur das Lockfile zeigte, würde Ihnen beibringen, dass sich nur das Lockfile bewegt. Ein Pull, der bei einer nicht gepinnten Entität abbrechen würde, bricht aus demselben Grund auch unter --dry-run ab: Was eine Vorschau zeigt, ist das, was der Pull tun würde. Die Dateien, die ein Pull Byte für Byte unverändert ließe, erscheinen überhaupt nicht — ein Name im Bericht bedeutet, dass sich diese Datei gleich ändert. Die letzte Zeile zählt sie, und ein Workspace, den ein Pull nicht ändern würde, meldet eine Anzahl von null.
Auf der Festplatte bewegt sich nichts. Kein Lockfile wird geschrieben oder erstellt, kein Entitäts-Lock wird geschrieben oder entfernt, und kein Vertrauensdatensatz wird erstellt oder ergänzt. Wo eine Fähigkeit von mehr als einem Provider-Plugin bereitgestellt wird und nichts zwischen ihnen gewählt hat, bricht der Lauf ab und nennt, was anzugeben ist, statt anzubieten, die Wahl in Ihre Konfiguration zu schreiben — eine Vorschau bearbeitet nicht nebenbei eine Konfigurationsdatei.
Die Auflösung selbst läuft trotzdem, daher füllt sich der Cache trotzdem. Welche externen Eingaben ein Release verbraucht, ergibt sich aus seinem Rendering, und ein Lauf, der auf die Auflösung verzichtete, hätte nichts zu berichten, daher ruft --dry-run genau so ab und speichert, wie ein Pull es tut. Der Inhalt unter .aggrega/cache wird nur über die Pins gelesen, die ein Lockfile erfasst, daher ändert sein Befüllen nichts an dem, was ein Build auflöst; was ein Probelauf zeigt, ist das, was ein Pull schreiben würde.
Ein --upgrade ohne Ziele fragt unter diesem Flag nichts. Die Bestätigung gibt es, weil eine vollständige Aktualisierung jeden erfassten Pin verwirft, und eine Vorschau verwirft keinen — daher ist aggrega pull --dry-run --upgrade --release <release> die Form der Wahl, wenn Sie wissen möchten, was eine Aktualisierung Sie kosten würde, und sie läuft ohne Antwort.
Es wird nicht zusammen mit --verify akzeptiert, das ohnehin keine dieser Dateien schreibt. Das Paar ließe das Flag wirkungslos, während es so aussähe, als hätte es etwas bewirkt, daher wird es abgelehnt statt ignoriert.
Eine Sache kann eine Vorschau mit Pinning nicht immer vollständig zeigen, und sie sagt es, wenn das passiert. Ein Pull, der pinnen soll, schreibt die entity.lock neben jedem Recipe und FeatureRecipe neu und rendert dann das Release, um seine externen Eingaben zu ermitteln; eine Vorschau lässt diese Locks unberührt, daher wird dieses Rendering dort, wo ein dort erfasster Pin veraltet ist — Sie haben etwa eine importierte Datei bearbeitet, seit sie gepinnt wurde —, an dem veralteten Digest gemessen, den der ungeschriebene Lock noch erfasst, und hält an. Alles andere im Bericht ist genau das, was ein Pull schreiben würde; nur die Pins der externen Eingaben im gemeldeten Lockfile sind unvollständig. Der Lauf sagt das sowohl in seiner Ausgabe als auch in seiner Diagnose, statt Ihnen ein Lockfile zu übergeben, das vollständig aussieht. Eine erste Auflösung eines Workspace ist nicht betroffen, weil es noch keinen erfassten Digest gibt, gegenüber dem etwas veraltet sein könnte.
Die Komposition, die diese Pins beschreiben
Ein Lockfile pinnt, was ein Build dieses Release verbrauchen wird, daher zeichnet die Auflösung die Komposition, die dieser Build zeichnet: Sie löst die Dokumente auf, wendet die Transformationen an, die die Anbindungen des Workspace deklarieren, und unterzieht das Ergebnis den Prüfungen, die ein Build an einem fertigen Graphen vornimmt. Daraus folgen zwei Dinge, und beide treten in dem Durchlauf auf, der das Lockfile schreibt, statt beim ersten Build, der es liest.
Eine Komposition, die diese Prüfungen ablehnen, bricht den Pull ab. Eine uses:-Kante, deren Ziel den selector: ihres Sockets nicht erfüllt, ein Feature, das an eine Komponente angebunden ist, die sein appliesTo: nicht zulässt, und jeder andere Verstoß, den diese Prüfungen melden, halten diesen Befehl an, mit der Diagnose, die ein Build derselben Dokumente ausgibt — und der Abbruch nennt jeden Befund in einem Lauf statt nur den ersten, sodass ein Durchlauf Ihnen die ganze Liste zum Korrigieren liefert. Er geschieht vor dem Schreiben, daher bleiben <release-stem>.lock und plugins-trust.yaml genau so, wie sie waren, und ein Release, das sich nicht bauen lässt, wird nie als eines erfasst, das sich sauber aufgelöst hat. Nicht abgedeckt sind die Anbindungen, die ein Verdict zurückgeben: Hier läuft keine ir-verdict- oder render-verdict-Anbindung, daher hält ein ablehnendes Verdict den Build, das Release-bezogene Lint oder die Release-bezogene Validierung an, die es aufruft, und nicht diesen Befehl.
Eine Anbindung in einer Rolle, die den Graphen formt, läuft während dieses Durchlaufs, daher bricht ein Plugin, das sich nicht auflösen lässt, den Pull ab. Eine label-transform-Anbindung legt Knoten-Labels fest, bevor irgendetwas mit ihnen abgeglichen wird, und eine annotation-transform-Anbindung fügt Annotationen ein, die sich zu Feature-Anbindungen erweitern — beide ändern, was der Graph enthält, daher bedeutet das Zeichnen des Graphen, sie aufzurufen, und sie aufzurufen bedeutet, die eigenen Bytes jedes Plugins vorliegen zu haben. Ein Plugin, dessen Bytes dieser Durchlauf nicht beschaffen kann, bricht den Lauf ab und nennt das Plugin und das, was für es nicht gefunden wurde — dieselbe Ablehnung, die ein Build desselben Workspace ausspricht, wenn er sie nicht beschaffen kann. Was es aufruft, ist die Anbindungsliste, die dieser Durchlauf soeben aufgelöst hat, mit den Einstellungen und Definitionsdateien, die das Lockfile für einen späteren Build zur Rekonstruktion erfasst, sodass beide Durchläufe dieselbe Anbindung mit derselben Eingabe ausführen.
Auch ein Plugin, das ein Pipeline-Schritt nennt und das nichts enthält, bricht den Pull ab. Jedes Plugin, das die pipeline eines Recipe oder FeatureRecipe nennt, wird mit den übrigen Abhängigkeiten des Release aufgelöst — aus einem Katalogverzeichnis, der Kopie im Compiler-Binary, dem Inhalts-Cache oder der Registry —, und eines, das keine dieser Quellen enthält, könnte auch ein Build nicht laden. Daher hält der Pull an, bevor er etwas schreibt, und nennt das Plugin und das Recipe oder FeatureRecipe, dessen Pipeline es nennt, mit der Bedingung, die ein Build meldet, wenn er diesen Schritt erreicht (A plugin reference is not a Plugin entity (Eine Plugin-Referenz ist keine Plugin-Entität)). Das gilt für jedes Recipe und FeatureRecipe, das das Manifest bindet, einschließlich eines, das nichts in diesem Release anbindet, denn jedes wird aufgelöst und gepinnt, ob es gerendert wird oder nicht. Veröffentlichen Sie das Plugin oder legen Sie es mit seiner gebauten .wasm daneben in ein Katalogverzeichnis, und pullen Sie erneut.
Dieser Abbruch und ein eingeschränkter Lauf sind bewusst unterschiedliche Ergebnisse. Ein Rendering, das nicht abgeschlossen werden kann — das, welches sowohl Wie die Auflösung externe Eingaben findet als auch Offline beschreiben —, lässt jeden Abhängigkeits-Pin korrekt, daher werden die Pins geschrieben und das Fehlende wird gemeldet. Eine Komposition, die die Prüfungen ablehnen, ist kein Fehlen in dem, was aufgelöst wurde: Sie ist ein Release, das sich nicht bauen lässt, daher wird nichts dafür gepinnt, und der Lauf hält an.
Der Cache
Abgerufene Inhalte werden unter .aggrega/cache gespeichert, aufgeteilt in einen Teilbaum entities/ für Katalogentitäten, einen Teilbaum source-artifacts/ für Quellartefakte und einen Teilbaum inputs/ für die externen Eingaben, die ein Rendering verbraucht. Der Slot einer Katalogentität ist nach ihrer Art, ihrer Koordinate und ihrer Version benannt — sodass eine Component und ein Recipe, die sich eine Koordinate und eine Version teilen, zwei Slots behalten —, der eines Quellartefakts nach seiner Abrufquelle, seiner Version und einem Präfix seines Inhalts-Digests, und der einer externen Eingabe nach ihrem Inhalts-Digest; was ein Build aus jedem davon liest, wird gegen das geprüft, was das Lockfile erfasst. Identische Versions-Pins teilen sich daher über Releases hinweg einen Slot. Jeder Quellartefakt-Slot enthält das maßgebliche Archiv, eine neu erzeugte Extraktion und eine kleine Metadatendatei; die Extraktion wird bei jedem Lesen neu erzeugt, daher hängt die Build-Ausgabe vom Archiv und vom Lockfile ab, nicht vom Zustand der extrahierten Dateien.
Jeder Name, den der Cache aus einem Wert ableitet, wird von Windows, Linux und macOS gleichermaßen akzeptiert. Eine Koordinate, eine Version, ein Registry-Host oder ein Digest enthält Zeichen, die ein Dateiname nicht enthalten kann: den / zwischen den Teilen einer Koordinate, den : vor einer Version, innerhalb von sha256: und vor dem Port einer Registry. Daher wird jeder Wert — eine Art, eine Koordinate, eine Version, ein Registry-Host oder ein Digest — umgeschrieben, bevor er zu einem Verzeichnis- oder Dateinamen wird — ein Kleinbuchstabe, eine Ziffer, ., _ und - werden unverändert geschrieben, und jedes andere Zeichen wird als Escape-Sequenz geschrieben, die mit + beginnt. Die Component core/devtool/adminer:1.0.0 in Version 1.0.0 ist der Slot entities/+zx000043omponent/core+zsdevtool+zsadminer+zx00003a1.0.0/1.0.0/, und ein nach einem Inhalts-Digest benannter Slot ist sha256+zx00003a<hex>. Auch ein Großbuchstabe wird maskiert, sodass zwei Koordinaten, die sich nur in der Groß-/Kleinschreibung unterscheiden, auf einem Dateisystem, das diese ignoriert, zwei Slots behalten; bei einem Namen, den Windows für ein Gerät reserviert, etwa con, wird der erste Buchstabe maskiert; und kein Name endet auf einen Punkt. Zwei verschiedene Werte teilen sich nie einen Namen, und ein Wert hat auf jeder Maschine denselben Namen. aggrega cache status listet jeden Eintrag nach den Werten auf, aus denen seine Namen umgeschrieben wurden — eine Katalogentität nach ihrer Koordinate, Version und Art —, statt nach den umgeschriebenen Namen.
Ein Eintrag eines Archivs behält den Namen, den sein Herausgeber ihm gegeben hat, daher wird unter Windows einer abgelehnt, den Windows nicht aufnehmen kann. Die Dateien, die das Archiv eines Quellartefakts oder einer Katalogentität enthält, werden unter den Namen abgelegt, die das Archiv ihnen gibt, nicht vom Cache umgeschrieben. Wo die Extraktion unter Windows läuft, wird ein Eintrag mit einem Teil, den Windows so, wie er geschrieben ist, nicht aufnehmen kann — ein Name, den es für ein Gerät reserviert, etwa NUL oder aux, in beliebiger Groß-/Kleinschreibung und mit oder ohne Erweiterung, oder ein Teil, der auf einen Punkt oder ein Leerzeichen endet —, mit E0340 abgelehnt, unter Nennung des Eintrags, und nichts aus diesem Archiv wird abgelegt. Unter Linux und macOS wird ein solcher Eintrag so abgelegt, wie er benannt ist. Ein Eintrag, der aus dem Verzeichnis der Extraktion heraussteigt, wird auf jeder Maschine abgelehnt.
Der Slot einer Katalogentität ist nur mit seinem Manifest ein Eintrag. Der Slot enthält den Inhalt, den eine Registry bereitgestellt hat, und daneben das Manifest, das diesen Inhalt beschreibt. Ein Slot, der nur den Inhalt enthält — ein Abruf, der zwischen den beiden Schreibvorgängen abbrach, oder eine manuell dort abgelegte Datei —, ist kein Eintrag: Ein Pull und ein prüfender Pull fragen die Registry der Entität erneut danach, wo eine erreichbar ist, während ein Build, der nie abruft, die Entität als fehlend behandelt, wie es ein Pull tut, wenn keine Registry erreichbar ist.
Was in den Cache gelangt, wird an zwei Dingen gemessen: an der Form, die das eigene Schema der Entität beschreibt, und an dem Ort, den der Cache dafür nennt. Ein aus einer Registry abgerufener Inhalt wird vor dem Zwischenspeichern durch das Schema seiner Art geprüft — dieselbe Prüfung, die ihn wieder einliest —, daher bricht eine veröffentlichte Entität oder Bibliothek, die die Registry ausliefert und die ihr eigenes Schema ablehnt, den Pull ab und nennt, was abgerufen wurde, statt zwischengespeichert und später als Fehler angetroffen zu werden. Und ein Wert, aus dem ein Cache-Speicherort gebildet wird und der eine zwischengespeicherte Datei an einem anderen Ort ablegen würde als dem, den der Wert nennt — eine Version, die ein Pfad statt einer Version ist, ein Quell-url-Pfad oder ein module_subdir, der über seinen Platz hinaussteigt —, wird dort abgelehnt, wo der Speicherort gebildet wird, unter Nennung des fehlerhaften Werts. Ein Wert, der in einem von Ihnen verfassten Recipe oder FeatureRecipe steht, wird in dem Moment ebenso geprüft, in dem der Cache-Speicherort daraus gebildet wird — und das module_subdir einer Git-Quelle schon früher, bevor das Repository abgerufen wird, wie unten beschrieben.
Ein Git-Repository wird aus seinem eigenen Checkout archiviert. Für eine git-repository-Quelle checkt der Pull das Repository an dem Commit aus, den er pinnt, und archiviert das Verzeichnis, das module_subdir nennt, oder das gesamte Repository. Ein module_subdir, das in seiner geschriebenen Form über das Repository hinaussteigt — ../shared oder ..\shared —, wird abgelehnt, bevor das Repository abgerufen wird, mit E0307 unter Angabe des Werts, sodass nichts neben dem Checkout gelesen wird. Ein symbolischer Link, den das Repository committet, wird als die Datei oder das Verzeichnis archiviert, auf das er zeigt, sofern dieses innerhalb des Repository liegt — module_subdir selbst kann ein solcher Link sein. Einer, der aus dem Repository hinausführt, bricht den Pull mit E0321 ab, unter Nennung des Links und seines Ziels, und nichts wird zwischengespeichert, sodass ein Repository, aus dem Sie pullen, den Pull nicht dazu bringen kann, eine Datei Ihrer Maschine in das Artefakt zu kopieren. Der Checkout wird entfernt, sobald der Pull anhält, daher nennt die Meldung den Link nach seinem Ort im Repository sowie das Repository und die Revision, die die Quelle nennt, statt eines Verzeichnisses, das nicht mehr existiert. Den Link zu ändern ist Sache des Repository. Die Workspace-Grenze nennt die Regel, die hier angewendet wird.
Der Cache ist am Workspace verankert statt an dem Verzeichnis, aus dem Sie den Befehl ausgeführt haben, daher hat ein Workspace einen einzigen Cache, und ein Pull, der aus einem Unterverzeichnis ausgeführt wird, füllt denselben Speicher, den ein vom Stammverzeichnis aus ausgeführter Build liest.
Ein Pull, für den kein Workspace gefunden und keiner benannt wurde, wird abgelehnt, bevor etwas abgerufen wird. Wenn nichts ein Stammverzeichnis nennt und die Erkennung nichts verankert — ausgehend von dem Ordner, in dem Sie ihn ausführen, oder, bei einem über einen absoluten Pfad benannten Release, vom eigenen Ordner dieses Release —, wäre der Ordner das Stammverzeichnis, und ein darunter geschriebener Cache würde ihn zu einem Workspace machen. Daher hält der Pull an, schreibt weder Lockfile noch Cache und nennt den Ordner und die zwei Lösungswege: Benennen Sie Ihren Workspace mit --workspace-root oder AGGREGA_WORKSPACE_ROOT, oder geben Sie diesem Ordner eine .aggrega-config.yaml mit einem workspace:-Block. Das Pull-Tool von aggrega mcp, aufgerufen ohne workspace_root auf einem Server, der ohne Stammverzeichnis gestartet wurde, wird auf dieselbe Weise abgelehnt; Konfiguration listet die anderen Befehle auf, für die dies gilt.
Bauen, wo das Netzwerk nicht erreichbar ist
Da dieser Befehl der einzige Schritt ist, der nach außen greift, genügt ein verbundener Lauf, um jeden späteren Build lokal zu machen. Dieser Lauf schreibt das Lockfile und füllt den Workspace-Cache mit den Bytes, die diese Pins benennen, und ein Build braucht danach nichts darüber hinaus.
Drei Dinge wandern auf die getrennte Maschine:
- Das Release und sein Lockfile. Committen Sie
<release-stem>.lockneben dem Release; es teilt dem Build mit, in welche Version und welchen Digest jede Abhängigkeit aufgelöst wurde. plugins-trust.yaml, wo der Workspace ein Verdict zurückgebendes Plugin anbindet. Ein Build vergleicht die Verdict-Anbindungen, die seine Konfiguration nennt, mit diesem Datensatz, bevor eine davon läuft; den Datensatz mitzunehmen ist also das, was den getrennten Build an die geprüften Identitäten und an die Signaturen bindet, die der Pull für sie verifiziert hat. Committen Sie ihn neben dem Lockfile, wie Der Plugin-Vertrauensdatensatz beschreibt.- Das Cache-Verzeichnis. Die Entitäten, die Quellartefakte und die gepinnten Eingaben liegen alle darunter, und alles, was ein lokales
catalog_dirs-Verzeichnis nicht liefert, wird von dort gelesen.
Bauen Sie auf der getrennten Maschine wie gewohnt. Den Offline-Modus dort zu setzen lohnt sich, auch wenn ein Build über einem gefüllten Lockfile seine Hülle aus dem Cache liest: Er verwandelt einen möglichen Netzwerkzugriff in eine sofortige Ablehnung, die den Modus nennt, statt in einen Verbindungsversuch, der erst in ein Timeout laufen muss. Alles, was der Cache nicht enthält, und jede externe Eingabe, die das Lockfile nicht pinnt, bricht den Build ab und nennt, was fehlt und welche Auflösung es pinnen würde — nichts wird stillschweigend abgerufen, um die Lücke zu füllen.
Eine Air-Gap-Maschine und ein Offline-Workspace sind unterschiedliche Aussagen, und es lohnt sich, den Unterschied zu bewahren. Eine Maschine hinter einem Air Gap kann eine lokale Kopie einer Registry oder einen catalog_dirs-Katalog mit allem Nötigen enthalten; in diesem Fall lässt sich ein gewöhnlicher Pull auf dieser Maschine ganz ohne Zugriff nach außen erfüllen. Der Offline-Modus beschreibt, wonach ein Befehl greifen darf, nicht was die Maschine enthält; Offline legt dar, was er ablehnt und was er unberührt lässt.
Offline
Im Offline-Modus — dem Schlüssel offline auf oberster Ebene in einer Konfigurationsdatei, AGGREGA_OFFLINE in der Umgebung oder --offline auf der Befehlszeile — verweigert aggrega pull den Netzwerkzugriff. Die Ablehnung erfolgt, bevor eine Verbindung versucht wird, nicht als Timeout mitten in einem Abruf, daher erreicht ein Offline-Pull keine Registry und keine entfernte Quelle. Wo eine committete Datei oder eine exportierte Variable den Modus gesetzt hat und Sie ihn für einen Befehl umgehen möchten, erlaubt --offline=false das Netzwerk nur für diesen einen Lauf.
--upgrade wird in diesem Modus vollständig abgelehnt, und es ist hier die einzige Option, bei der das so ist. Eine vollständige Aktualisierung hebt jede Abhängigkeit auf die höchste Version an, die eine Registry derzeit anbietet, daher muss sie eine Registry fragen, was sie derzeit bereitstellt. Ein gewöhnlicher Pull muss das nicht: Er behält die bereits erfassten Pins bei, löst nur auf, was keinen hat, und lässt sich daher aus dem erfüllen, was die Maschine enthält. Die Ablehnung nennt, welche der drei Stellen den Modus gesetzt hat und wie sich das Netzwerk für einen Lauf erlauben lässt.
Die Auflösung greift dann nur auf das zurück, was die Maschine bereits enthält: den catalog_dirs-Suchstapel und den Cache unter .aggrega/cache. Mit einem Katalog und einem Cache, die jede Referenz erfüllen, wird ein Offline-Pull normal abgeschlossen und schreibt ein gewöhnliches Lockfile. Das Lockfile erfasst für jede Abhängigkeit URI, aufgelöste Version und Digest, und nie, welche dieser Stellen die Bytes bereitgestellt hat — daher schreiben ein Offline-Pull und ein Online-Pull, die dieselben Versionen auflösen, dasselbe Lockfile.
Eine Abhängigkeit, die ein Offline-Pull nicht lokal erfüllen kann, bricht ihn ab. Der Eintrag wird nie übersprungen:
- Eine Katalogentität, die sich nirgends auflösen lässt, bricht den Pull ab und nennt die Referenz und den Ort, von dem aus sie referenziert wurde, sodass sowohl die fehlende Abhängigkeit als auch das, was nach ihr verlangt hat, genannt werden.
- Eine entfernte
source:bricht den Pull ab, nennt die Quelle und fordert Sie auf, entweder den Netzwerkzugriff zu erlauben oder den Cache aus einer verbundenen Umgebung zu befüllen. - Eine Abhängigkeit, die der Cache enthält und deren verlangte Signatur das Lockfile nicht erfasst oder deren erfasste Signatur ein Build nicht akzeptiert, bricht den Pull mit der Offline-Ablehnung ab und nennt die Abhängigkeit: Die Signatur zu erfassen bedeutet, ihre Registry zu fragen, wie Beibehalten vs. Aktualisieren beschreibt. Das Netzwerk für diesen einen Lauf zu erlauben, erfasst sie. Eine erfasste Signatur, die ein Build akzeptiert, wird nicht erneut nachgeschlagen, daher hält sie einen Offline-Pull nicht an.
Eine externe Eingabe ist das Einzige, was nicht abbricht, und sie meldet das stattdessen. Das Rendering, das sie findet, kann nicht abrufen, was nicht bereits gespeichert ist, daher wird ein Offline-Pull über einem Release mit einer nicht gepinnten externen Eingabe abgeschlossen, schreibt jeden Abhängigkeits-Pin, den er aufgelöst hat, und meldet drei Dinge: dass das Rendering nicht abgeschlossen wurde, was er gepinnt hat, und dass ein Build dieses Release unter Nennung der URL abbrechen wird. Die Abhängigkeits-Pins, die er geschrieben hat, sind korrekt — nichts an ihnen hing vom Rendering ab —, daher werden sie behalten, statt verworfen zu werden, damit ein Leser sie reproduziert.
Das ist bewusst so und keine Lücke, und es gibt keinen Schalter dafür. Ein Pull, der korrekte Arbeit verwürfe, würde Sie den gelungenen Teil kosten; ein Pull, der stumm bliebe, würde Ihnen ein Lockfile übergeben, das vollständig aussieht und es nicht ist. Es auszusprechen ist das einzige Ergebnis, das Sie handlungsfähig lässt: Führen Sie den Pull erneut aus einer verbundenen Umgebung aus oder aus einer, deren Cache den Inhalt bereits enthält, und derselbe Befehl pinnt ihn.
Ein Offline-Pull ist also eine Weigerung, das Netzwerk anzufassen, statt ein reduziertes Ergebnis für alles, was ein Dokument nennt, und für externe Eingaben ist er eine abgeschlossene Auflösung, die Ihnen sagt, was sie nicht erreichen konnte. Ein vorhandenes Lockfile ist eines, dessen Abhängigkeitsauflösung abgeschlossen wurde; ob seine externen Eingaben vollständig sind, sagt Ihnen die eigene Ausgabe des Pulls, und daran misst ein Build es dann.
--verify deckt im Offline-Modus weniger ab und meldet das auch. Zu fragen, wohin ein erfasster Quell-Ref heute zeigt, bedeutet, sein Remote zu erreichen, was der Offline-Modus verweigert. Daher prüft ein Offline---verify die gepinnten Abhängigkeiten und überspringt diese Achse, und es gibt eine Zeile aus, die das sagt, statt eine Übereinstimmung zu melden, die es nie festgestellt hat. Eine erfasste Signatur, die nur ihre Registry bestätigen kann — bei einem Lockfile-Eintrag, dessen zwischengespeichertes Signaturbündel entfernt oder verändert wurde —, wird auf dieselbe Weise übersprungen, in einer Zeile, die jeden solchen Eintrag nennt:
verify: offline, so the signature the lockfile records for "<reference>" was not checked at its registry, which alone can say whether a pull would record it again; this verify does not cover itEine erfasste Signatur, die ein Pull unabhängig von der Antwort der Registry neu schreiben würde, wird auch offline gemeldet, weil keine Antwort nötig ist, um das zu wissen, wie Es vergleicht die erfassten Signaturen in beiden Dateien beschreibt.
Ein in einer Verdict-Rolle angebundenes Plugin, das eine Registry bereitstellt, ist der Punkt, an dem sich eine Offline-Prüfung und ein Offline-Pull trennen. Ein solches Plugin wird nie im Lockfile gepinnt, daher löst jeder Pull seine .wasm aus seiner Registry auf, und ein Offline-Pull über einem Workspace, der eines anbindet, hält dort an und nennt das Plugin als eines, dessen .wasm er nicht auflösen konnte — selbst wenn der Inhalts-Cache sie enthält, und unabhängig davon, ob diese Registry als advisory markiert ist oder die Signaturprüfung überspringt. Eine Offline-Prüfung fragt die Registry stattdessen nichts zu dem Plugin: Sie liest das Plugin aus dem Inhalts-Cache, wie ein Build es liest, und hält an, wo der Cache seine .wasm nicht enthält oder eine enthält, die nicht mehr zu dem Digest passt, den sein veröffentlichtes Manifest nennt. Sie misst die Identität des Plugins weiterhin am Plugin-Vertrauensdatensatz und prüft seine Host-Funktionen erneut gegen diese .wasm, und sie bricht ab, wo eines davon nicht übereinstimmt, genau wie eine verbundene Prüfung. Sie meldet das Plugin dort, wo ein Pull seinen Eintrag unabhängig von der Antwort der Registry neu schreibt, also dort, wo ein Build das Plugin wegen seines Eintrags ablehnt: weil keine Signatur erfasst ist, da sein Eintrag keine erfasst oder der Datensatz keinen Eintrag dafür enthält, oder weil die Signatur, die sein Eintrag erfasst, für ein anderes Artefakt erstellt wurde, die der Pull durch die eigene des Plugins ersetzt. Jeden anderen Eintrag — einen, dessen Signatur ein Build akzeptiert, und einen, dessen zwischengespeichertes Signaturbündel entfernt oder verändert wurde — nennt sie in einer Zeile, die besagt, dass seine Signatur nicht geprüft wurde, und meldet nichts zu dieser Signatur:
verify: offline, so the signature of "<plugin>" was not checked at its registry, which alone can say whether a pull would record the same signature on its entry in the plugin trust record; this verify does not cover itEine Offline-Prüfung übergeht also einen Eintrag, dessen Signatur ein verbundener Pull ersetzen oder löschen würde — etwa einen, dessen Signierer manuell bearbeitet wurde, oder einen, dem seine Registry keine Signatur mehr anhängt —, wobei diese Zeile das Einzige ist, was darauf hinweist. Eine Prüfung hinter einem Air Gap bleibt verfügbar; was sie Ihnen nicht sagt, ist, ob sich ein Ref seitdem bewegt hat oder ob eine übersprungene Signatur erneut erfasst würde. Ein Check, der nur den Exit-Code liest, deckt diese Fälle nur ab, wenn die Prüfung verbunden läuft.
Integration mit aggrega build
- Verifizierung.
aggrega buildverifiziert jede aufgelöste Abhängigkeit gegen das Lockfile und hält bei Drift an: eine Entität, eine Bibliothek oder ein Plugin, deren Inhalt nicht mehr zu ihrem Pin passt, eine Referenz, die das Release jetzt erreicht und die das Lockfile nicht pinnt, oder eine, die es pinnt und die das Release nicht mehr erreicht, sowie eine seit dem Pull bearbeitete Release-Datei. Führen Sieaggrega pull --release <release>aus, den Befehl, den der Abbruch ausgibt, um dies zu beheben: Der Pull löst das Release in seinem aktuellen Zustand auf, schreibt die Pins neu, die sich verschoben haben, und hält alle anderen fest, sodass sich nichts verschiebt, was Sie nicht geändert haben. Wo sich eine Datei unter der lokalen Quelle eines Recipe verschoben hat, nennt der Pull zuerstaggrega pinfür diese Entität, wie Die Entitäts-Lock-Datei beschreibt. Ein Lockfile, das dieser Befehl gerade geschrieben hat, besteht diese Prüfung, denn der Befehl führt dieselbe Prüfung aus, bevor er es schreibt; ein Build, der direkt nach einem Pull wegen Drift anhält, hat andere Eingaben erhalten als der Pull – ein--catalog-Verzeichnis, das dem einen übergeben wurde und dem anderen nicht, oder eine zwischen beiden bearbeitete Workspace-Konfiguration –, führen Sie die beiden also über dieselben Eingaben aus.aggrega validate --releaseund jede Auswahl vonaggrega inspect, die ein Release auflöst, unterziehen das Lockfile derselben Prüfung und lehnen mit demselben Abbruch ab, sodass keiner von beiden ein Lockfile durchgehen lässt, das ein Build ablehnt. - Automatischer Pull. Wenn das Lockfile fehlt und
auto_pulltrue ist, führtaggrega buildzuerst automatisch den Pull aus. Wennauto_pullfalse ist, was der Standardwert ist, hält der Build an und fordert Sie zum Pull auf. Der Pull, den ein Build ausführt, folgtpin_sources_at_pull, sodass er bei einer ungepinnten Entität genau so anhält wie ein Pull. Der Pull-Schritt, den ein Build ausführt, ist derselbe, den diese Seite beschreibt, sodass ein Build, der ein vorhandenes Lockfile befüllt, bei einer verschobenen Quell-Ref genau so anhält wieaggrega pull– siehe Determinismus und Integrität. - Offline. Im Offline-Modus verwendet
aggrega buildnur, was bereits auf dem Rechner vorhanden ist, und verweigert den Netzwerkzugriff, bevor ein Verbindungsversuch unternommen wird. Eine Referenz, deren Inhalt nicht im Cache liegt, hält den Build an, statt mitten in einem Abruf zu scheitern, und ein Build ohne Lockfile, der nicht aufgefordert wird, eines zu befüllen, hält an und nennt den Pull, der es befüllen würde, genau wie online.--auto-pullwird nicht verweigert: Die Befüllung, die es anfordert, ist der Pull, den diese Seite beschreibt, sodass es bei Katalogentitäten, die bereits im Cache liegen oder in einem lokalen Katalog vorhanden sind, das Lockfile schreibt, ohne eine Registry zu erreichen – ein Recipe, dessen Chart aus einer entfernten Quelle abgerufen wird, wird erneut aufgelöst und hält daher offline auch dort an, wo der Cache dieses Chart enthält –, und eine Referenz, die keiner von beiden enthält – oder eine im Cache, deren erforderliche Signatur das Lockfile nicht aufzeichnet oder deren aufgezeichnete Signatur ein Build nicht akzeptiert –, hält es mit der eigenen Verweigerung des Pulls an, die diese Referenz nennt.--upgradewird verweigert, aus dem Grund, den Offline nennt. - Katalogsuche. Der Pull berücksichtigt
catalog_dirsaus.aggrega-config.yaml, auch wenn kein--catalogangegeben ist – und die eigenen Verzeichnisse eines Release, wo die Konfiguration ihm unterworkspace.releaseswelche zuweist –, und löst denselben Suchstapel mit Vorrang des ersten Treffers auf wieaggrega build, sodass die Abhängigkeiten, die er pinnt, dem entsprechen, was der Build durchsucht. Ein aufgeführtes Verzeichnis, das kein Verzeichnis ist – dort existiert zum Beispiel nichts –, wird von beiden Befehlen abgelehnt, bevor irgendetwas aufgelöst oder geschrieben wird, wobei der Eintrag sowie die Konfigurationsdatei und die Zeile genannt werden, die ihn auflisten, wie Woher lokale Entitäten gelesen werden zeigt.
Wie die Auflösung externe Eingaben findet
Nichts in diesem Abschnitt ändert die obige Regel – es gibt weiterhin einen einzigen Moment, in dem etwas gepinnt wird, und das ist dieser Befehl. Beschrieben wird, wie der Befehl die dritte der drei Arten erreicht. Das ist wichtig, wenn Sie die Auflösung in eine Pipeline einbinden, einen Lauf lesen, der nur eingeschränkt abgeschlossen wurde, oder nachvollziehen wollen, warum dieser Befehl überhaupt rendert.
Eine Katalogentität und ein Quellartefakt werden jeweils in einem Dokument benannt; eine externe Eingabe nicht. Die ersten beiden aufzulösen bedeutet, zu lesen, was Sie geschrieben haben. Eine externe Eingabe wird von einem Provider mitten in einem Rendering benannt, und welche URLs er benennt, ergibt sich aus den gerenderten Werten – ein fehlender Werteeintrag lässt einen ganzen Teilbaum des Schemas eines Charts unkompiliert und jede entfernte Referenz in diesem Teilbaum unangefordert. Kein Lesen des Release kann die Menge aufzählen.
Der Befehl tut also zwei Dinge in einem Durchlauf: Er löst die Hülle auf, die die Dokumente benennen, und pinnt sie, und rendert diese Hülle dann, um zu sehen, welche entfernten Dokumente die Provider anfordern. Die gerenderten Artefakte werden verworfen, die Pins werden behalten. Beides geschieht innerhalb des einen Befehls, und keines ist ein zweiter Moment, in dem etwas gepinnt werden könnte – es gibt einen einzigen Schreibvorgang des Lockfiles, und er enthält jeden Pin.
Zwei Konsequenzen sollten Sie kennen, bevor Sie die Auflösung als günstigen Schritt in eine automatisierte Pipeline einbinden. Sie kostet mehr als eine Auflösung, die nur Dokumente liest, weil sie rendert. Und sie kann aus einem Grund scheitern, aus dem eine reine Dokumentauflösung nicht scheitern könnte: ein Provider, der dieses Release nicht rendern kann. In diesem Fall werden die Abhängigkeits-Pins dennoch geschrieben, weil nichts an ihnen vom Rendering abhing, und die Diagnose nennt die Phase, die angehalten hat, was gepinnt wurde und dass ein Build anhalten und die ungepinnte URL nennen wird. Der Lauf geht nicht verloren, und Offline zeigt dasselbe Ergebnis auf einem anderen Weg.
Das Rendering unterzieht das Lockfile außerdem dem Vergleich, den ein Build anwendet, bevor etwas geschrieben wird. Es führt die eigene Abfolge des Builds aus und vergleicht daher das Lockfile, das dieser Befehl gleich schreiben wird, mit dem, wozu ein Build desselben Release auflöst, genau so, wie ein Build ein Lockfile vergleicht, das er auf der Festplatte vorfindet. Ein Lockfile, das dieser Vergleich ablehnt, wird nicht geschrieben – ebenso wenig alles andere, was der Befehl danach geschrieben hätte –, und der Befehl hält mit der Meldung an, dass Auflösung und Build sich nicht einig sind, wovon das Release abhängt, gefolgt von jedem Eintrag, den der Vergleich genannt hat. Nichts in Ihren Dateien kann das verursachen, und eine erneute Auflösung würde zur selben Uneinigkeit führen; melden Sie es daher zusammen mit dem Release, statt es erneut zu versuchen. Es ist der einzige Rendering-Fehler, der das Schreiben verhindert, und der Grund, warum ein Build desselben Release über dieselben Eingaben bei einem von diesem Befehl geschriebenen Lockfile keinen Drift meldet.
Es gibt keinen Schalter, um das Rendering zu überspringen. Ein solcher Schalter würde genau die Überraschung als Option bewahren, die ein einziger Moment beseitigt: ein Release, das sich sauber auflöst, während eine Eingabe, die sein Rendering braucht, ungepinnt bleibt und erst zur Build-Zeit entdeckt wird.
--auto-pull bindet dieselbe Auflösung in einen Build ein, und der Build rendert nur einmal. Das Rendering der Befüllung ist dasjenige, das die externen Eingaben findet und pinnt, und der Build präsentiert dieses Rendering, statt ein zweites auszuführen, sodass ein Build mit einem einzigen Befehl dasselbe Rendering kostet wie ein gewöhnlicher Build über ein befülltes Lockfile. aggrega build legt dar, welche Rendering-Flags eines Builds es erreichen.
Die Menge ergibt sich aus den Parametern des Release, und so verhalten sich auch Component-Pins bereits. Die Parameter eines Release zwischen Auflösung und Build zu bearbeiten, ist eine Bearbeitung des Release, sodass der Build beim Drift-Vergleich anhält und die Datei nennt, bevor ein Rendering eine ungepinnte URL anfordern könnte; die Abhilfe ist dieser Befehl. Aus einer separaten Datei importierte Parameter werden nicht nach Inhalt aufgezeichnet, sodass eine Bearbeitung dieser Datei stattdessen das Rendering erreicht, das anhält und die ungepinnte URL nennt – wobei auch die Abhilfe diesen Befehl nennt.
Determinismus und Integrität
Die source: eines Recipe kann ihre Version per Template aus den aufgelösten values und infra des Release ableiten (und über dort definierte locals); diese werden zum Pull-Zeitpunkt aufgelöst, und das Ergebnis wird gepinnt. Der Pull wertet nur die locals:-Einträge aus, die die source:-Felder lesen, sowie die Einträge, die diese wiederum lesen, und zwar allein mit den eigenen Template-Helfern von Aggrega: Ein Eintrag, den die Quelle liest und der eine Sprig-Funktion aufruft, hält den Pull an und nennt dabei den Eintrag, das Feld und die Funktion, während ein Eintrag, den kein source:-Feld liest, dem Build überlassen wird, der ihn auswertet und prüft, wenn das Recipe gerendert wird — siehe Resolving a source: coordinate registers a narrower function set (Das Auflösen einer Koordinate registriert einen engeren Funktionsumfang). Ein veränderlicher Git-Tag oder -Branch wird auf den konkreten Commit gepinnt, auf den er zeigt, und die von Ihnen verfasste Ref wird daneben aufgezeichnet. Zur Build-Zeit wird der Digest des zwischengespeicherten Archivs erneut gegen das Lockfile verifiziert, sodass ein manipulierter Cache erkannt wird.
Eine aufgezeichnete Ref wird an den Commit gebunden, den sie gepinnt hat. Die Ref wird aufgezeichnet, weil spätere Läufe sie erneut abfragen, nicht der Lesbarkeit wegen – ein Build fragt, welches Artefakt sie benennt, und ein Pull fragt, ob sie noch dorthin zeigt, wohin sie gezeigt hat. Ein pull, der kein Upgrade ist, fragt jede aufgezeichnete Ref erneut, wohin sie zeigt, und eine Ref, die sich in ihrem Remote verschoben hat, hält den Lauf an – unter Nennung des Artefakts, der Ref, des Commits, den das Lockfile pinnt, und des Commits, zu dem sie jetzt auflöst –, statt die Verschiebung zu übernehmen. Führen Sie aggrega pull --upgrade --release <release> aus, um sie zu übernehmen. Ein gezieltes Upgrade, das Entitäts-URIs nennt, tut das nicht: Eine Quellreferenz ist keine Entität, die Sie nennen können, daher hält ein gezielter Lauf sie genau so fest wie ein einfacher Pull.
Diese Prüfung ist das Einzige, was die erneute Verifizierung des Digests zur Build-Zeit nicht für Sie leisten kann. Ein Pull, der eine verschobene Ref übernähme, würde die abgerufenen Bytes und den aufgezeichneten Digest im selben Schritt neu schreiben, sodass sich die beiden Werte, die ein Build vergleicht, gemeinsam verschoben hätten und übereinstimmen würden – und Sie würden anderen Quellinhalt bauen als den, gegen den das Lockfile geprüft wurde, ohne dass etwas dies meldet.
Nur eine Ref, die das Lockfile aufzeichnet, wird so festgehalten, und eine Ref wird immer dann aufgezeichnet, wenn Sie eine schreiben. Ein Recipe, das seine Quelle allein über version: benennt, hat keine Ref, sodass es für einen späteren Lauf nichts erneut abzufragen gibt – und das ist die richtige Antwort, denn eine Version, die Sie selbst geschrieben haben, kann sich nicht unbemerkt verschieben. Die Lockfile-Referenz gibt an, was aufgezeichnet wird.
Schreiben Sie die Ref, nicht den Commit. Ein build findet ein aus Git bezogenes Artefakt über die von Ihnen geschriebene Ref, abgeglichen mit der Ref, die das Lockfile aufgezeichnet hat, sodass ref: v1.2.3 gegen den Commit baut, auf den dieser Tag gepinnt wurde, und der Commit nie in Ihrem Recipe erscheinen muss. Einen veränderlichen Tag stattdessen in version: anzugeben, funktioniert nicht und ist auch nicht dafür gedacht: version: wird so abgeglichen, wie es geschrieben ist, und für eine Git-Quelle pinnt das Lockfile einen Commit.
Das Lockfile pinnt Inhalte, die aus Registries und entfernten Quellen abgerufen werden, und zeichnet den Digest jeder Entität auf, die es aus Ihren Katalogverzeichnissen auflöst – über die Entitätsdatei und jede Datei, die sie daneben nennt, wie Das Lockfile beschreibt –, sowie jeder Release-Datei, die die Auflösung gelesen hat. Die Dateien einer Quelle, die mit ./ oder ../ beginnt, und eine Artefaktdatei, die eine Entität importiert, werden ebenfalls einzeln in der Sperre neben dieser Entität gepinnt, wie Die Entitätssperre beschreibt, und das ist es, was die verschobene Datei benennt; die Integrität des restlichen Workspace zwischen Builds liegt in der Verantwortung des Versionskontrollsystems. Siehe byteidentische Ausgabe für den Umfang der Determinismusgarantie.
Authentifizierung
Registry-Anmeldedaten werden ausschließlich aus der Docker-Anmeldedatenkonfiguration gelesen: config.json in dem Verzeichnis, das DOCKER_CONFIG nennt, oder ~/.docker/config.json, wenn diese Variable nicht gesetzt ist, zusammen mit jedem Credential-Helper oder Schlüsselbund des Betriebssystems, an den die Datei über credsStore oder credHelpers delegiert. aggrega login <registry> schreibt dort Anmeldedaten, ebenso docker login <registry>; führen Sie einen der beiden vor aggrega pull für einen privaten OCI-Katalog oder eine private Chart-Registry aus. Die Dateien, die podman login und helm registry login schreiben, werden nicht gelesen.
Eine Credential-Konfiguration, die nicht gelesen werden kann, wird gemeldet, ohne ihren Inhalt preiszugeben. Wenn config.json kein gültiges JSON ist, der auth-Wert eines Eintrags kein base64-codierter, durch einen Doppelpunkt verbundener Benutzer und Passwort ist oder ein Credential-Helper, den die Datei nennt, nicht antworten kann, schlägt das Erreichen der Registry mit einer Meldung fehl, die die Registry und die Credential-Datei nennt, niemals aber den Inhalt der Datei oder des Eintrags. aggrega login und aggrega logout melden eine config.json, die kein gültiges JSON ist, auf dieselbe Weise und ändern nichts daran. Korrigieren Sie die Datei; ein Eintrag, der nicht gelesen werden kann, lässt sich auch mit aggrega login <registry> ersetzen.
Ein klassisches Helm-Chart-Repository oder Chart-Archiv (helm-https-chart), ein Compose-Fragment (compose-https-fragment) und ein über HTTP oder HTTPS erreichtes Git-Repository (git-repository) authentifizieren sich mit der netrc-Datei, der benutzerspezifischen Anmeldedatendatei, die auch curl und Git lesen. Sie ist der einzige Anmeldedatenspeicher, den diese drei Arten lesen: ~/.config/helm/repositories.yaml und Git-Credential-Helper werden nicht gelesen. Ein über SSH erreichtes Git-Repository authentifiziert sich über den SSH-Agenten und liest keine netrc-Datei.
machine charts.example.com login deploy-bot password <token>Welche Datei gelesen wird. Die Datei, die die Umgebungsvariable NETRC nennt, wenn sie gesetzt ist. Andernfalls .netrc in Ihrem Home-Verzeichnis; unter Windows _netrc in %USERPROFILE%, wenn diese Datei existiert, und andernfalls .netrc dort. Eine fehlende Datei enthält keine Anmeldedaten und ist kein Fehler. Eine Datei, die existiert und nicht gelesen werden kann oder nicht dem netrc-Format folgt, hält den Befehl mit E0360 an und nennt die Datei – und bei einem Formatfehler die Zeile –, aber nie, was die Datei enthält: The netrc file cannot be read (Die netrc-Datei kann nicht gelesen werden). Unter Linux und macOS erzeugt eine netrc-Datei, die andere Benutzer des Rechners lesen können, eine Warnung, die sie nennt; machen Sie sie nur für sich selbst lesbar (chmod 600).
Welcher Eintrag eine Anfrage beantwortet. Jede Anfrage wird anhand ihres Hosts nachgeschlagen – des Hostnamens ohne Port, ohne Beachtung der Groß- und Kleinschreibung – und vom ersten machine-Eintrag beantwortet, der diesen Host nennt, oder vom default-Eintrag, wenn keiner ihn nennt. login und password des Eintrags werden als HTTP-Basic-Anmeldedaten gesendet, über http wie über https; ein Eintrag, dem eines davon fehlt, sendet nichts. Ein Repository, dessen Index seine Charts auf einem anderen Host ablegt, wird pro Anfrage beantwortet: Die Index-Anfrage nimmt den Eintrag des Repository-Hosts, die Chart-Anfrage den des Chart-Hosts. Eine Anfrage, die ohne Anmeldedaten erfolgt, muss anonym lesbar sein, und ein Server, der mit 401 oder 403 antwortet, hält den Pull als nicht autorisierten Abruf an, dessen Abhilfe den hinzuzufügenden Eintrag und die Datei nennt, in der danach gesucht wurde.
Die Anmeldedaten werden nirgends geschrieben. Sie werden gelesen, wenn ein Abruf läuft, und mit der Anfrage gesendet: Die Lockfile, die entity.lock neben dem Recipe, der Quell-Cache und jede Meldung tragen die URL der Quelle so, wie Sie sie geschrieben haben.
Eine Quell-URL trägt keine Anmeldedaten. Ein Recipe oder FeatureRecipe, dessen Quell-url einen Benutzer vor den Host schreibt – https://user:token@charts.example.com/… oder ein allein geschriebenes Token wie https://token@charts.example.com/… –, wird beim Lesen des Dokuments mit E0361 abgelehnt, bevor irgendetwas abgerufen wird: Die Validierung des Recipe lehnt es ab, ebenso jeder Pull, jedes Pinnen und jeder Build, der es erreicht. Die Meldung nennt den Host und nie die Anmeldedaten: A source URL carries a credential (Eine Quell-URL enthält Anmeldedaten). Legen Sie die Anmeldedaten stattdessen in einem machine-Eintrag der netrc-Datei ab. Über SSH nennt ein allein geschriebener Benutzer – ssh://git@github.com/… – ein Konto statt eines Geheimnisses und wird akzeptiert, während ein dort geschriebenes Passwort ebenfalls abgelehnt wird.
Die Prüfung liest nur den Teil der URL vor dem Host. Ein Token in einem Query-String oder einem Pfad – …/index.yaml?access_token=… – wird nicht erkannt, schreiben Sie dort also keines: Die URL wird so, wie sie geschrieben ist, in der Lockfile, in der entity.lock und im Quell-Cache festgehalten, einschließlich der Namen der Cache-Verzeichnisse.
Umgebungsvariablen
Die Workspace-Einstellungen, die Pull liest, können über die Umgebung überschrieben werden, oberhalb der eingecheckten Konfiguration und unterhalb jedes Flags: AGGREGA_OFFLINE (siehe Offline und --offline für das Flag darüber), AGGREGA_CATALOG_DIRS (getrennt wie eine Pfadliste des Betriebssystems; geben Sie absolute Pfade an), AGGREGA_ARTIFACT_CACHE_DIR, AGGREGA_DEFAULT_REGISTRY und AGGREGA_SKIP_SIGNATURE_VERIFICATION (laut — überall dort, wo ein Pull eine Signatur geprüft hätte, protokolliert er eine Warnung, dass die Verifizierung global deaktiviert ist). Siehe environment-variables.md für die vollständige Liste und das Vorrangmodell.
Siehe auch
- ./aggrega-build.md – verifiziert das Lockfile und führt den Pull automatisch aus, wenn konfiguriert.
- ./aggrega-serve.md – der Daemon bietet dieselbe Auflösung unter
aggrega/resolveDependenciesund innerhalb vonaggrega/buildfür eine Anfrage, deren FeldautoPullsie anfordert, sodass ein Editor sie ausführen kann, ohne die Sitzung zu verlassen; in beiden Fällen läuft sie nur, wenn eine Anfrage sie nennt, und schreibt dasselbe Lockfile wie dieser Befehl. - ./aggrega-push.md – veröffentlicht Katalogentitäten in einer Registry.
- ./aggrega-lint.md – die Veröffentlichungsprüfung, die
aggrega pushvorausgeht. - ../../architecture/13-catalog-and-registry.md – das Katalog-, Lockfile- und Cache-Modell im Detail.
Übersicht
aggrega pull [<uri>...] [flags]Beschreibung
Resolve the Release's catalog and source dependencies into the cache and write the per-Release lockfile.
By default, pull reconciles the lockfile against the current dependency resolution while honoringthe pins it already records. That pin discipline governs what a registry or the content cacheserves: such an entity is fetched at its pinned version and verified against its pinned digest,and if the registry no longer serves the pinned bytes, pull halts rather than silently re-pinning.An entity a local catalog directory supplies is resolved from that directory instead, at theversion its file declares, and its recorded pin is not consulted — so editing a pin by hand doesnot hold a locally-supplied entity at that version, and the reconcile rewrites the entry to matchthe file. A reference with no pin — newly added, or removed from the lockfile by hand — isresolved fresh and added. Entities no longer among the resolved dependencies are pruned.Re-running pull on an unchanged dependency set is a no-op.
Use --upgrade with no positional arguments to discard the existing lockfile and re-resolveevery entity from current registry state, floating each dependency to the highest availableversion. That form drops every recorded pin, so it asks for confirmation first; --yes answers inadvance, and on a non-interactive stdin it refuses rather than waiting for an answer nobody cangive. Pass one or more entity URIs after --upgrade to upgrade only those: each named pinis dropped and re-resolved fresh while every other pin — and the recorded external inputs —is held unchanged. A named target may also be a plugin that returns an accept-or-reject verdict;such a plugin carries no lockfile pin, and its identity is recorded beside the lockfile instead.Naming one the workspace still attaches adopts the identity it resolves to. Naming one theworkspace no longer attaches drops its recorded identity — the one way to clear an entry thatoutlived the attachment it was recorded for. A bare --upgrade does both for every plugin at once.A URI given without --upgrade is a usage error.
Each Recipe and FeatureRecipe this Release builds from one of your catalog directories carriesthe pins for its own inputs in the entity.lock beside it: a remote source: written out in full,a file an artifacts entry imports, and each file of a local source:. Recording them is theentity author's step, aggrega pin.By default pull records none of them, and halts on an entity whose lock is missing any, namingthe entity, each input and its class, and the command that records them. A local source's filesare held to their pins as one set: a file added, changed or removed since the pin halts the pullthe same way.Pass --pin-sources, or set pin_sources_at_pull in the workspace configuration, to have pull runthat same step instead; --pin-sources=false restores the halt for one run.
Which files of a local source directory belong to its entity was decided when the entity waspinned, by the ignore rules of the plugin that served its capability for the author, and itsentity.lock records that decision. Where the plugin this workspace binds for that capabilitydeclares different rules, pull prints a warning naming both plugins and the difference, andcarries on: the entity's files are the ones its recorded rules kept.Flags
| Flag | Standard | Beschreibung |
|---|---|---|
--catalog | [] | Katalogverzeichnis; wiederholbar. Jedes —catalog <dir> wird dem Katalog-Suchstapel vorangestellt (der erste Treffer gewinnt): den catalog_dirs des Workspace oder, für ein Release, dem die Workspace-Konfiguration unter workspace.releases eigene Verzeichnisse gibt, denen dieses Release; der Stapel endet mit dem Verzeichnis namens catalog im Workspace-Stammverzeichnis, sofern es eines gibt. Eine leer geschriebene catalog_dirs-Liste liest überhaupt keinen lokalen Katalog. |
--detail | false | Gibt für jede aufgelöste Entität aus, was dieser Pull getan hat – frisch aus einer Registry abgerufen, einen Cache-Slot wiederverwendet, in einem lokalen Katalog gefunden, aus dem Compiler-Binary heraus bereitgestellt oder extern (das eigene Aggregate oder Manifest des Release, gelesen aus der Datei oder dem Eintrag, den das Release nennt). Nur stdout; wird nicht in das Lockfile geschrieben |
--dry-run | false | Löst die Abhängigkeiten auf und gibt aus, was dieser Pull schreiben würde, statt es zu schreiben: Der Pfad jeder Datei und der Inhalt, den sie enthalten würde, gehen an stdout, und das Lockfile, die entity.lock neben jedem Recipe und FeatureRecipe, dessen aufgezeichnete Pins sich unter —pin-sources verschieben würden, sowie der Plugin-Vertrauensdatensatz bleiben alle unberührt. Nur die Dateien, die sich tatsächlich ändern würden, werden genannt. Die Auflösung selbst läuft genau so wie sonst, sodass sich der Inhalts-Cache trotzdem füllt, ein Pull, der bei einer ungepinnten Entität anhalten würde, auch hier anhält und ein bloßes —upgrade nichts fragt, weil es keinen Pin verwirft – was ein Probelauf zeigt, ist das, was ein Pull schreiben würde. Nicht zulässig mit —verify, das ohnehin keine davon schreibt |
--include-prerelease | false | Noch nicht implementiert: wird akzeptiert und ignoriert, sodass ein Skript, das es übergibt, weiter funktioniert, wenn es Wirkung zu zeigen beginnt |
--pin-sources | false | Führt den Pin-Schritt des Entitätsautors über die Recipes und FeatureRecipes aus, die dieses Release baut, und zeichnet in der entity.lock neben jedem den Pin für jede Eingabe auf, die es liest – eine vollständig ausgeschriebene entfernte source:, eine Datei, die ein artifacts-Eintrag importiert, und jede Datei einer lokalen Quelle –, statt bei einer Entität anzuhalten, deren Sperre sie nicht aufzeichnet. Derselbe Schritt wie aggrega pin, der dieselben Bytes schreibt. Er schreibt neben die Entität und läuft daher nur dort, wo die Entität einen beschreibbaren Ort hat: ein Dokument in einem Ihrer Katalogverzeichnisse. Eine aus dem Cache aufgelöste Entität hat keinen und wird nie gepinnt. Überschreibt pin_sources_at_pull des Workspace in beide Richtungen: —pin-sources pinnt für diesen Lauf und —pin-sources=false hält für diesen Lauf an, unabhängig von der Einstellung |
--progress | false | Erzwingt die Pull-Fortschrittsanzeige auch dann, wenn stderr kein Terminal ist, und gibt pro Schritt nach dessen Abschluss eine einfache Zeile mit seiner Dauer aus. Der Standardwert ist auto: Die interaktive Phasen-Checkliste wird nur angezeigt, wenn stderr ein Terminal ist, das Escape-Sequenzen interpretiert, ein Terminal, das dies nicht tut, erhält dieselben einfachen Zeilen, und umgeleitete oder per Pipe weitergegebene Ausgabe erhält keine |
--quiet | false | Unterdrückt die Pull-Fortschrittsanzeige auf stderr. Wirkt sich nicht auf stdout aus. Hat Vorrang vor —progress |
--release | — | Pfad zur Release-YAML-Datei (erforderlich). Ein relativer Pfad wird gegen das Verzeichnis aufgelöst, in dem Sie den Befehl ausführen, nicht gegen das Workspace-Stammverzeichnis. Wenn dieses Verzeichnis in keinem Workspace liegt und kein Stammverzeichnis angegeben ist, findet ein absoluter Pfad den Workspace vom eigenen Ordner des Release aus |
--upgrade | false | Löst Abhängigkeiten anhand des aktuellen Registry-Zustands neu auf und hebt jede auf die höchste verfügbare Version an. Ohne Argumente (keine positionellen URIs) verwirft es das Lockfile, löst jede Entität neu auf und fragt zuerst nach einer Bestätigung, weil es jeden aufgezeichneten Pin verwirft; mit einer oder mehreren Entitäts-URIs löst es nur diese neu auf, hält alle anderen Pins und die aufgezeichneten externen Eingaben unverändert und fragt nichts (schließt sich mit —verify gegenseitig aus) |
--verify | false | Verifiziert das vorhandene Lockfile gegen die Abhängigkeitsauflösung, die ein Pull jetzt durchführen würde, ohne das Lockfile, den Plugin-Vertrauensdatensatz oder eine entity.lock zu schreiben; beendet sich bei Drift oder fehlendem Lockfile mit einem Exit-Code ungleich null. Die Auflösung berücksichtigt die Pins, die das Lockfile aufzeichnet, genau wie ein Pull: Eine Referenz, deren Registry seit dem Pull eine neuere Version veröffentlicht hat, ist kein Drift, weil ein Pull ihren Pin festhalten würde, und eine Registry, die jetzt unter einer gepinnten Version andere Bytes ausliefert, hält die Verifizierung an, wie sie einen Pull anhält. Der Inhalts-Cache wird gelesen und gefüllt, wie ein Pull ihn liest und füllt: Ein Eintrag, den der Cache unter seinem Pin enthält, wird von dort gelesen, ohne eine Registry zu fragen, einer, den er nicht enthält, wird abgerufen, und einer, der nicht mehr zu seinem Pin passt, wird genau so behandelt, wie ein Pull ihn behandelt. Hält außerdem die entity.lock neben jedem Recipe und FeatureRecipe in Ihren Katalogverzeichnissen, die das Release erreicht, an dem fest, womit ein Build sie vergleicht, und beendet sich mit einem Exit-Code ungleich null bei einem Pin, den ein Build ablehnen würde: eine importierte Datei, die nicht mehr zu ihrem aufgezeichneten Digest passt, eine lokale Quelle, deren Dateien nicht mehr zu ihren aufgezeichneten Digests passen, oder ein Quell-Pin, der dem Lockfile widerspricht. Vergleicht außerdem die Signatur, die das Lockfile für jedes Artefakt aufzeichnet, und den Plugin-Vertrauensdatensatz für jedes Plugin mit derjenigen, die ein Pull jetzt aufzeichnen würde, und beendet sich mit einem Exit-Code ungleich null, wo ein Pull eine aufzeichnen, ersetzen oder entfernen würde: Eine Signatur, die eine Anforderung verlangt und die nicht aufgezeichnet ist, und eine, die für ein anderes Artefakt erstellt wurde, werden gemeldet, ohne eine Registry zu fragen, weil ein Pull sie unabhängig von deren Antwort neu schreibt; eine Signatur, die ein Pull erneut nachschlägt und unverändert aufzeichnen könnte – das Artefakt wurde abgerufen, oder sein Signaturbündel im Cache wurde entfernt oder verändert –, wird bei ihrer Registry erfragt oder im Offline-Modus mit einer entsprechenden Zeile ungeprüft gelassen; und jedes Plugin, das der Plugin-Vertrauensdatensatz abdeckt, wird bei seiner Registry verifiziert, wie jeder Pull es verifiziert, außer im Offline-Modus, wo es aus dem Inhalts-Cache gelesen wird, wie ein Build es liest, seine Identität und seine Host-Funktionen dennoch geprüft werden und seine Signatur mit einer entsprechenden Zeile ungeprüft bleibt, es sei denn, ein Build lehnt es ab, weil keine Signatur aufgezeichnet ist oder eine für ein anderes Artefakt erstellte, was gemeldet wird. Deprecation-Markierungen werden nicht verglichen. Meldet außerdem die Compiler- und Core-Plugin-Versionen, die das Lockfile aufzeichnet – gemeldet zu Prüfzwecken und nie mit diesem Binary verglichen, sodass ein Toolchain-Unterschied nie Drift ist. Nicht zulässig mit —pin-sources, unabhängig vom angegebenen Wert: Eine Verifizierung zeichnet weder einen Pin auf, der in einer entity.lock fehlt, noch hält sie deswegen an, sodass das Flag nichts ändern würde (schließt sich mit —upgrade gegenseitig aus) |
--yes | false | Beantwortet die Bestätigung des bloßen —upgrade im Voraus, für die nicht interaktive Verwendung. Es betrifft nur diese eine Abfrage und sonst nichts: Jede andere Form des Pulls fragt nichts, sodass die Übergabe dort kein Verhalten ändert |