526 lines
23 KiB
PowerShell
526 lines
23 KiB
PowerShell
# ============================================================
|
|
# Omika - Generation / verification du manifeste des packs de langue
|
|
# (manifest.json de Omika.Langues.Api)
|
|
# ============================================================
|
|
# Le manifeste decrit les packs ONNX telechargeables par le mobile. Ce n'est PAS
|
|
# un fichier de publication : il decrit les fichiers REELLEMENT presents sous
|
|
# Langues__RootPath. Il se genere donc la ou sont les modeles, pas dans le depot.
|
|
#
|
|
# Arborescence attendue : <racine>\<code>\<sens>\<fichier>, ou <sens> vaut
|
|
# versFrancais, depuisFrancais, ou commun (poids partages par les deux sens d'un
|
|
# modele familial ; le mobile ne les telecharge qu'une fois).
|
|
#
|
|
# Deux champs ne peuvent pas etre saisis a la main sans risque :
|
|
# - tailleOctets : taille reelle (progression du telechargement mobile) ;
|
|
# - sha256 : empreinte d'integrite, reverifiee par le mobile APRES
|
|
# telechargement. Une empreinte fausse ou absente ne se voit
|
|
# QUE sur le telephone : le pack est refuse et pack.json
|
|
# n'est jamais ecrit (aucune erreur ne remonte au serveur).
|
|
# Ce script les calcule depuis les fichiers. Aucune valeur n'est inventee.
|
|
#
|
|
# Usage :
|
|
# .\New-OmikaLanguesManifeste.ps1 # genere sous RootPath
|
|
# .\New-OmikaLanguesManifeste.ps1 -WhatIf # simulation, affiche
|
|
# .\New-OmikaLanguesManifeste.ps1 -RootPathLangues D:\Modeles
|
|
# .\New-OmikaLanguesManifeste.ps1 -Verifier # controle d'integrite
|
|
# .\New-OmikaLanguesManifeste.ps1 -Libelles @{ es = 'Espagnol (Espagne)' }
|
|
#
|
|
# -Verifier compare le manifeste EXISTANT aux fichiers du disque et sort en
|
|
# erreur (code 1) au moindre ecart. Aucun droit administrateur n'est requis :
|
|
# c'est le controle a passer apres chaque ajout ou remplacement de modele.
|
|
#
|
|
# La racine par defaut est lue dans Langues__RootPath (MACHINE), donc la meme
|
|
# source de verite que le service : le manifeste est ecrit la ou l'API le lit.
|
|
# ============================================================
|
|
|
|
[CmdletBinding(SupportsShouldProcess = $true)]
|
|
param(
|
|
# Dossier racine des modeles. Par defaut : variable MACHINE Langues__RootPath,
|
|
# puis C:\Omika\Data\Langues (recommandation du DEPLOIEMENT_API_LANGUES.md §6).
|
|
[string]$RootPathLangues,
|
|
|
|
# Fichier manifeste. Par defaut : <RootPathLangues>\manifest.json.
|
|
[string]$Sortie,
|
|
|
|
# Version ecrite dans chaque pack (le mobile la compare a celle installee).
|
|
[string]$Version = '1.0.0',
|
|
|
|
# Libelles affiches, par code de langue. Complete/ecrase la table par defaut.
|
|
[hashtable]$Libelles = @{},
|
|
|
|
# Autorise l'ecriture d'un manifeste SANS aucun pack (deconseille : le mobile
|
|
# affiche alors « Aucun modele de langue n'est disponible sur le serveur »).
|
|
[switch]$AutoriserVide,
|
|
|
|
# Controle le manifeste existant au lieu de le regenerer.
|
|
[switch]$Verifier
|
|
)
|
|
|
|
$ErrorActionPreference = 'Stop'
|
|
|
|
# Sens canoniques : le mobile compare ces valeurs de facon SENSIBLE A LA CASSE.
|
|
# « commun » porte les poids PARTAGES par les deux sens d'un modele familial
|
|
# (opus-mt-tc-big-itc-itc) : le telephone les telecharge une seule fois, et
|
|
# chaque sens ne contient que son modele.json (jeton de cible).
|
|
$SensCanoniques = @('versFrancais', 'depuisFrancais', 'commun')
|
|
|
|
# Noms de vocabulaire reconnus par l'application (OnnxTranslationService) :
|
|
# vocab.spm = vocabulaire commun, source.spm / target.spm = vocabulaire par
|
|
# langue d'un modele Marian/OPUS-MT. Tout autre nom .spm n'est qu'un repli.
|
|
$NomsVocabulaire = @('vocab.spm', 'source.spm', 'target.spm')
|
|
|
|
$LibellesParDefaut = @{
|
|
'ar' = 'Arabe'
|
|
'bg' = 'Bulgare'
|
|
'ca' = 'Catalan'
|
|
'cs' = 'Tchèque'
|
|
'da' = 'Danois'
|
|
'de' = 'Allemand'
|
|
'el' = 'Grec'
|
|
'en' = 'Anglais'
|
|
'es' = 'Espagnol'
|
|
'et' = 'Estonien'
|
|
'fi' = 'Finnois'
|
|
'gl' = 'Galicien'
|
|
'hr' = 'Croate'
|
|
'hu' = 'Hongrois'
|
|
'is' = 'Islandais'
|
|
'it' = 'Italien'
|
|
'lt' = 'Lituanien'
|
|
'lv' = 'Letton'
|
|
'mk' = 'Macédonien'
|
|
'mt' = 'Maltais'
|
|
'nl' = 'Néerlandais'
|
|
'no' = 'Norvégien'
|
|
'pl' = 'Polonais'
|
|
'pt' = 'Portugais'
|
|
'ro' = 'Roumain'
|
|
'ru' = 'Russe'
|
|
'sk' = 'Slovaque'
|
|
'sl' = 'Slovène'
|
|
'sv' = 'Suédois'
|
|
'tr' = 'Turc'
|
|
'uk' = 'Ukrainien'
|
|
'zh' = 'Chinois'
|
|
}
|
|
|
|
function Write-ManifesteInfo([string]$message) { Write-Host (' ' + $message) }
|
|
function Write-ManifesteOk([string]$message) { Write-Host ('[OK] ' + $message) -ForegroundColor Green }
|
|
function Write-ManifesteAlerte([string]$message) { Write-Host ('[ALERTE] ' + $message) -ForegroundColor Yellow }
|
|
function Write-ManifesteEchec([string]$message) { Write-Host ('[ECHEC] ' + $message) -ForegroundColor Red }
|
|
|
|
function Format-ManifesteTaille([long]$octets) {
|
|
if ($octets -ge 1073741824) { return ('{0:N2} Gio' -f ($octets / 1073741824)) }
|
|
if ($octets -ge 1048576) { return ('{0:N1} Mio' -f ($octets / 1048576)) }
|
|
if ($octets -ge 1024) { return ('{0:N0} Kio' -f ($octets / 1024)) }
|
|
return ('{0} octets' -f $octets)
|
|
}
|
|
|
|
# Code de langue : memes regles que LanguagePaths.EstCodeValide cote application
|
|
# (2 a 10 caracteres, minuscules ASCII, chiffres, tiret). Un code invalide fait
|
|
# IGNORER le pack SILENCIEUSEMENT par le mobile : on refuse de l'ecrire.
|
|
function Test-ManifesteCodeValide([string]$code) {
|
|
if ([string]::IsNullOrWhiteSpace($code)) { return $false }
|
|
|
|
$valeur = $code.Trim()
|
|
if ($valeur.Length -lt 2 -or $valeur.Length -gt 10) { return $false }
|
|
if ($valeur[0] -eq '-' -or $valeur[-1] -eq '-') { return $false }
|
|
|
|
foreach ($c in $valeur.ToCharArray()) {
|
|
$autorise = (($c -ge 'a' -and $c -le 'z') -or ($c -ge '0' -and $c -le '9') -or $c -eq '-')
|
|
if (-not $autorise) { return $false }
|
|
}
|
|
|
|
return $true
|
|
}
|
|
|
|
# Retourne le sens canonique, ou $null si le dossier n'est pas un sens connu.
|
|
function Resolve-ManifesteSens([string]$nomDossier) {
|
|
foreach ($canonique in $SensCanoniques) {
|
|
if ([string]::Equals($nomDossier, $canonique, [System.StringComparison]::OrdinalIgnoreCase)) {
|
|
return $canonique
|
|
}
|
|
}
|
|
return $null
|
|
}
|
|
|
|
function Resolve-ManifesteLibelle([string]$code, [hashtable]$surcharge) {
|
|
if ($surcharge -and $surcharge.ContainsKey($code)) { return [string]$surcharge[$code] }
|
|
if ($LibellesParDefaut.ContainsKey($code)) { return [string]$LibellesParDefaut[$code] }
|
|
return $code.ToUpperInvariant()
|
|
}
|
|
|
|
# SHA-256 hexadecimal minuscule : exactement ce que le mobile recalcule.
|
|
function Get-ManifesteEmpreinte([string]$chemin) {
|
|
return (Get-FileHash -LiteralPath $chemin -Algorithm SHA256).Hash.ToLowerInvariant()
|
|
}
|
|
|
|
# Echappe une chaine pour du JSON (guillemets, antislash, caracteres de controle).
|
|
function ConvertTo-ManifesteJsonChaine([string]$valeur) {
|
|
$sb = New-Object System.Text.StringBuilder
|
|
[void]$sb.Append('"')
|
|
foreach ($c in $valeur.ToCharArray()) {
|
|
$code = [int]$c
|
|
if ($c -eq '"') { [void]$sb.Append('\"') }
|
|
elseif ($c -eq '\') { [void]$sb.Append('\\') }
|
|
elseif ($code -lt 32) { [void]$sb.Append(('\u{0:x4}' -f $code)) }
|
|
else { [void]$sb.Append($c) }
|
|
}
|
|
[void]$sb.Append('"')
|
|
return $sb.ToString()
|
|
}
|
|
|
|
function New-ManifesteBlocFichier([string]$sens, [string]$nomFichier, [long]$taille, [string]$sha256) {
|
|
$lignes = @(
|
|
' {'
|
|
(' "sens": ' + (ConvertTo-ManifesteJsonChaine $sens) + ',')
|
|
(' "nomFichier": ' + (ConvertTo-ManifesteJsonChaine $nomFichier) + ',')
|
|
(' "tailleOctets": ' + $taille + ',')
|
|
(' "sha256": ' + (ConvertTo-ManifesteJsonChaine $sha256))
|
|
' }'
|
|
)
|
|
return ($lignes -join "`r`n")
|
|
}
|
|
|
|
function New-ManifesteBlocPack([string]$code, [string]$libelle, [string]$version, $blocsFichiers) {
|
|
$lignes = @(
|
|
' {'
|
|
(' "code": ' + (ConvertTo-ManifesteJsonChaine $code) + ',')
|
|
(' "libelle": ' + (ConvertTo-ManifesteJsonChaine $libelle) + ',')
|
|
(' "version": ' + (ConvertTo-ManifesteJsonChaine $version) + ',')
|
|
' "fichiers": ['
|
|
($blocsFichiers -join (",`r`n"))
|
|
' ]'
|
|
' }'
|
|
)
|
|
return ($lignes -join "`r`n")
|
|
}
|
|
|
|
function New-ManifesteJsonText($blocsPacks) {
|
|
# Tableau vide ecrit « [] » et non « [\n\n] » : lisible et sans ligne blanche.
|
|
$corps = if ($blocsPacks.Count -eq 0) {
|
|
@(' "packs": []')
|
|
}
|
|
else {
|
|
@(
|
|
' "packs": ['
|
|
($blocsPacks -join (",`r`n"))
|
|
' ]'
|
|
)
|
|
}
|
|
|
|
$lignes = @('{') + $corps + @('}')
|
|
return (($lignes -join "`r`n") + "`r`n")
|
|
}
|
|
|
|
# JSON ecrit en UTF-8 SANS BOM : un manifeste est un fichier de donnees lu par
|
|
# l'API et par des outils externes, jamais un script.
|
|
function Write-ManifesteFichier([string]$chemin, [string]$contenu) {
|
|
$encodage = New-Object System.Text.UTF8Encoding($false)
|
|
[System.IO.File]::WriteAllText($chemin, $contenu, $encodage)
|
|
}
|
|
|
|
function Write-ManifesteBilan($echecs, $alertes) {
|
|
foreach ($alerte in $alertes) { Write-ManifesteAlerte $alerte }
|
|
foreach ($echec in $echecs) { Write-ManifesteEchec $echec }
|
|
Write-Host ''
|
|
if ($echecs.Count -gt 0) {
|
|
Write-Host ("=== RESULTAT : {0} ecart(s), {1} alerte(s) ===" -f $echecs.Count, $alertes.Count) -ForegroundColor Red
|
|
return $false
|
|
}
|
|
Write-Host ("=== RESULTAT : conforme ({0} alerte(s)) ===" -f $alertes.Count) -ForegroundColor Green
|
|
return $true
|
|
}
|
|
|
|
# --- Racine effective --------------------------------------------------------
|
|
if (-not $RootPathLangues) {
|
|
$RootPathLangues = [Environment]::GetEnvironmentVariable('Langues__RootPath', 'Machine')
|
|
}
|
|
if (-not $RootPathLangues) {
|
|
$RootPathLangues = [Environment]::GetEnvironmentVariable('Langues__RootPath', 'Process')
|
|
}
|
|
if (-not $RootPathLangues) {
|
|
$RootPathLangues = 'C:\Omika\Data\Langues'
|
|
}
|
|
$racine = $RootPathLangues.Trim().TrimEnd([char[]]@('\', '/'))
|
|
if (-not $Sortie) { $Sortie = Join-Path $racine 'manifest.json' }
|
|
|
|
Write-Host '=== Manifeste des packs de langue (Omika Langues API) ==='
|
|
Write-ManifesteInfo ("Racine des modeles : {0}" -f $racine)
|
|
Write-ManifesteInfo ("Manifeste : {0}" -f $Sortie)
|
|
if ($Verifier) { Write-ManifesteInfo 'Mode : VERIFICATION (aucune ecriture)' }
|
|
Write-Host ''
|
|
|
|
if (-not (Test-Path -LiteralPath $racine -PathType Container)) {
|
|
Write-ManifesteEchec ("Racine introuvable : {0}" -f $racine)
|
|
Write-ManifesteInfo 'Verifier Langues__RootPath (MACHINE), ou passer -RootPathLangues.'
|
|
exit 1
|
|
}
|
|
|
|
$echecs = New-Object 'System.Collections.Generic.List[string]'
|
|
$alertes = New-Object 'System.Collections.Generic.List[string]'
|
|
|
|
# ============================================================================
|
|
# MODE VERIFICATION
|
|
# ============================================================================
|
|
if ($Verifier) {
|
|
if (-not (Test-Path -LiteralPath $Sortie -PathType Leaf)) {
|
|
Write-ManifesteEchec ("Manifeste ABSENT : {0}" -f $Sortie)
|
|
Write-ManifesteInfo 'Sans ce fichier, GET /api/langues repond 404 (et le mobile n''a aucune langue).'
|
|
Write-ManifesteInfo 'Generer avec : .\New-OmikaLanguesManifeste.ps1'
|
|
exit 1
|
|
}
|
|
|
|
$manifeste = $null
|
|
try {
|
|
$manifeste = (Get-Content -LiteralPath $Sortie -Raw -Encoding UTF8 | ConvertFrom-Json)
|
|
}
|
|
catch {
|
|
Write-ManifesteEchec ("Manifeste illisible (JSON invalide) : {0}" -f $_.Exception.Message)
|
|
Write-ManifesteInfo 'Cote service : « Manifeste des langues illisible » puis 404.'
|
|
exit 1
|
|
}
|
|
|
|
$packs = @($manifeste.packs)
|
|
if ($packs.Count -eq 0) {
|
|
$echecs.Add('Le manifeste ne declare aucun pack : le mobile affichera « Aucun modele de langue n''est disponible sur le serveur ».')
|
|
}
|
|
|
|
$declare = New-Object 'System.Collections.Generic.List[string]'
|
|
$nbFichiers = 0
|
|
$octetsTotal = [long]0
|
|
|
|
foreach ($pack in $packs) {
|
|
$code = ([string]$pack.code).Trim().ToLowerInvariant()
|
|
if (-not (Test-ManifesteCodeValide $code)) {
|
|
$echecs.Add(("Pack « {0} » : code de langue invalide -> IGNORE SILENCIEUSEMENT par le mobile." -f $pack.code))
|
|
continue
|
|
}
|
|
if ([string]::IsNullOrWhiteSpace([string]$pack.libelle)) {
|
|
$alertes.Add(("Pack « {0} » : libelle vide (le code s'affichera a la place)." -f $code))
|
|
}
|
|
if ([string]::IsNullOrWhiteSpace([string]$pack.version)) {
|
|
$alertes.Add(("Pack « {0} » : version vide (comparaison d'installation impossible)." -f $code))
|
|
}
|
|
|
|
$fichiers = @($pack.fichiers)
|
|
if ($fichiers.Count -eq 0) {
|
|
$echecs.Add(("Pack « {0} » : aucun fichier declare." -f $code))
|
|
continue
|
|
}
|
|
|
|
foreach ($fichier in $fichiers) {
|
|
$sensManifeste = [string]$fichier.sens
|
|
$sens = Resolve-ManifesteSens $sensManifeste
|
|
if (-not $sens) {
|
|
$echecs.Add(("Pack « {0} » : sens inconnu « {1} » (attendu versFrancais, depuisFrancais ou commun)." -f $code, $sensManifeste))
|
|
continue
|
|
}
|
|
if ($sensManifeste -cne $sens) {
|
|
$echecs.Add(("Pack « {0} » : sens « {1} » a la mauvaise casse -> REFUSE par le mobile (comparaison sensible a la casse)." -f $code, $sensManifeste))
|
|
continue
|
|
}
|
|
|
|
$nomFichier = [string]$fichier.nomFichier
|
|
if ([string]::IsNullOrWhiteSpace($nomFichier)) {
|
|
$echecs.Add(("Pack « {0} » : nomFichier vide." -f $code))
|
|
continue
|
|
}
|
|
if ($nomFichier -ne [System.IO.Path]::GetFileName($nomFichier)) {
|
|
$echecs.Add(("Pack « {0} » : nomFichier « {1} » contient un chemin (interdit)." -f $code, $nomFichier))
|
|
continue
|
|
}
|
|
|
|
$chemin = Join-Path (Join-Path (Join-Path $racine $code) $sens) $nomFichier
|
|
$declare.Add($chemin.ToLowerInvariant())
|
|
$relatif = ('{0}/{1}/{2}' -f $code, $sens, $nomFichier)
|
|
|
|
# Un fichier declare est un fichier TELECHARGE par chaque telephone :
|
|
# signaler ceux qui ne servent a rien.
|
|
if ($nomFichier.EndsWith('.onnx', [System.StringComparison]::OrdinalIgnoreCase) `
|
|
-and $nomFichier -match 'past') {
|
|
$alertes.Add(("{0} : decodeur a cache (past_key_values) IGNORE par l'application, mais declare donc TELECHARGE pour rien." -f $relatif))
|
|
}
|
|
elseif ($nomFichier.EndsWith('.spm', [System.StringComparison]::OrdinalIgnoreCase) `
|
|
-and $NomsVocabulaire -notcontains $nomFichier) {
|
|
$alertes.Add(("{0} : nom de vocabulaire non reconnu (attendu vocab.spm, source.spm ou target.spm) : pris comme repli « premier .spm »." -f $relatif))
|
|
}
|
|
|
|
if (-not (Test-Path -LiteralPath $chemin -PathType Leaf)) {
|
|
$echecs.Add(("Fichier ABSENT sur le disque : {0} -> le mobile recevra 404." -f $relatif))
|
|
continue
|
|
}
|
|
|
|
$info = Get-Item -LiteralPath $chemin
|
|
$taille = [long]$fichier.tailleOctets
|
|
if ($taille -le 0) {
|
|
$alertes.Add(("{0} : tailleOctets non renseignee (0) -> pas de controle de taille ni de progression." -f $relatif))
|
|
}
|
|
elseif ($taille -ne $info.Length) {
|
|
$echecs.Add(("{0} : taille differente -> manifeste {1} octet(s), disque {2}." -f $relatif, $taille, $info.Length))
|
|
}
|
|
|
|
$sha = ([string]$fichier.sha256).Trim()
|
|
if ([string]::IsNullOrWhiteSpace($sha)) {
|
|
$echecs.Add(("{0} : empreinte SHA-256 absente -> le pack sera REFUSE par le mobile." -f $relatif))
|
|
continue
|
|
}
|
|
|
|
$reel = Get-ManifesteEmpreinte $chemin
|
|
if (-not [string]::Equals($sha, $reel, [System.StringComparison]::OrdinalIgnoreCase)) {
|
|
$echecs.Add(("{0} : empreinte differente ->`r`n manifeste {1}`r`n disque {2}" -f $relatif, $sha, $reel))
|
|
}
|
|
|
|
$nbFichiers++
|
|
$octetsTotal += $info.Length
|
|
}
|
|
}
|
|
|
|
# Fichiers presents mais non declares : jamais telecharges, poids mort.
|
|
foreach ($fichierDisque in @(Get-ChildItem -LiteralPath $racine -Recurse -File)) {
|
|
if ($fichierDisque.FullName.ToLowerInvariant() -eq $Sortie.ToLowerInvariant()) { continue }
|
|
# La sauvegarde du manifeste ecrite par ce script n'est evidemment pas un
|
|
# fichier de modele : la signaler serait un faux positif a chaque controle.
|
|
if ($fichierDisque.FullName.ToLowerInvariant() -eq ($Sortie + '.bak').ToLowerInvariant()) { continue }
|
|
|
|
$relatifDisque = $fichierDisque.FullName.Substring($racine.Length).TrimStart('\', '/')
|
|
# Dossiers techniques (ex. .hf-cache du script d'export, .tmp-*) : ce ne
|
|
# sont pas des modeles, et un cache peut contenir des milliers de fichiers.
|
|
if ($relatifDisque -match '(^|\\)\.[^\\]') { continue }
|
|
|
|
if (-not $declare.Contains($fichierDisque.FullName.ToLowerInvariant())) {
|
|
$alertes.Add(("Fichier non declare dans le manifeste (jamais telecharge) : {0}" -f $relatifDisque))
|
|
}
|
|
}
|
|
|
|
Write-ManifesteInfo ("{0} pack(s), {1} fichier(s) verifie(s), {2}" -f $packs.Count, $nbFichiers, (Format-ManifesteTaille $octetsTotal))
|
|
Write-Host ''
|
|
|
|
if (Write-ManifesteBilan $echecs $alertes) { exit 0 } else { exit 1 }
|
|
}
|
|
|
|
# ============================================================================
|
|
# MODE GENERATION
|
|
# ============================================================================
|
|
$dossiersPacks = @(Get-ChildItem -LiteralPath $racine -Directory |
|
|
Where-Object { -not $_.Name.StartsWith('.') } |
|
|
Sort-Object -Property Name)
|
|
if ($dossiersPacks.Count -eq 0) {
|
|
$message = ("Aucun sous-dossier de langue sous {0} (attendu : {0}\es\versFrancais\encoder.onnx)." -f $racine)
|
|
# -AutoriserVide couvre les DEUX causes de manifeste vide : racine sans
|
|
# dossier de langue, et dossiers sans aucun fichier exploitable.
|
|
if ($AutoriserVide) { $alertes.Add($message) } else { $echecs.Add($message) }
|
|
}
|
|
|
|
$blocsPacks = New-Object 'System.Collections.Generic.List[string]'
|
|
$recap = New-Object 'System.Collections.Generic.List[string]'
|
|
|
|
foreach ($dossierPack in $dossiersPacks) {
|
|
$nomDossier = $dossierPack.Name
|
|
$code = $nomDossier.Trim().ToLowerInvariant()
|
|
|
|
if (-not (Test-ManifesteCodeValide $code)) {
|
|
$alertes.Add(("Dossier ignore « {0} » : code de langue invalide (2 a 10 caracteres, minuscules a-z, chiffres, tiret)." -f $nomDossier))
|
|
continue
|
|
}
|
|
# -cne : comparaison SENSIBLE A LA CASSE. « -ne » considererait « ru » et
|
|
# « RU » comme egaux et ne signalerait rien.
|
|
if ($code -cne $nomDossier) {
|
|
$alertes.Add(("Dossier « {0} » : le manifeste ecrit « {1} ». Renommer le dossier si le volume peut etre sensible a la casse." -f $nomDossier, $code))
|
|
}
|
|
|
|
$libelle = Resolve-ManifesteLibelle $code $Libelles
|
|
$blocsFichiers = New-Object 'System.Collections.Generic.List[string]'
|
|
$nbFichiersPack = 0
|
|
$octetsPack = [long]0
|
|
|
|
foreach ($dossierSens in @(Get-ChildItem -LiteralPath $dossierPack.FullName -Directory | Sort-Object -Property Name)) {
|
|
$sens = Resolve-ManifesteSens $dossierSens.Name
|
|
if (-not $sens) {
|
|
$alertes.Add(("Dossier ignore {0}\{1} : sens inconnu (attendu versFrancais, depuisFrancais ou commun)." -f $nomDossier, $dossierSens.Name))
|
|
continue
|
|
}
|
|
if ($sens -cne $dossierSens.Name) {
|
|
$alertes.Add(("Dossier {0}\{1} : le manifeste ecrit « {2} » (casse canonique exigee par le mobile)." -f $nomDossier, $dossierSens.Name, $sens))
|
|
}
|
|
|
|
# L'API ne sert que {code}/{sens}/{fichier} : un sous-dossier n'est jamais atteignable.
|
|
foreach ($sousDossier in @(Get-ChildItem -LiteralPath $dossierSens.FullName -Directory)) {
|
|
$alertes.Add(("Dossier ignore {0}\{1}\{2} : l'API ne sert que {{code}}/{{sens}}/{{fichier}}." -f $nomDossier, $dossierSens.Name, $sousDossier.Name))
|
|
}
|
|
|
|
foreach ($fichier in @(Get-ChildItem -LiteralPath $dossierSens.FullName -File | Sort-Object -Property Name)) {
|
|
# Deux fichiers inutiles qu'il ne faut PAS livrer : declares ici, ils
|
|
# seraient telecharges par chaque telephone pour rien.
|
|
if ($fichier.Name.EndsWith('.onnx', [System.StringComparison]::OrdinalIgnoreCase) `
|
|
-and $fichier.Name -match 'past') {
|
|
$alertes.Add(("{0}\{1}\{2} (~{3}) : decodeur a cache (past_key_values) IGNORE par l'application, mais il serait TELECHARGE. Ne pas livrer ce fichier." -f $nomDossier, $dossierSens.Name, $fichier.Name, (Format-ManifesteTaille $fichier.Length)))
|
|
}
|
|
elseif ($fichier.Name.EndsWith('.spm', [System.StringComparison]::OrdinalIgnoreCase) `
|
|
-and $NomsVocabulaire -notcontains $fichier.Name) {
|
|
$alertes.Add(("{0}\{1}\{2} : nom de vocabulaire non reconnu (attendu vocab.spm, source.spm ou target.spm). L'application le prendrait comme repli « premier .spm » : verifier qu'il est bien le bon." -f $nomDossier, $dossierSens.Name, $fichier.Name))
|
|
}
|
|
|
|
$sha = Get-ManifesteEmpreinte $fichier.FullName
|
|
$blocsFichiers.Add((New-ManifesteBlocFichier -sens $sens -nomFichier $fichier.Name -taille $fichier.Length -sha256 $sha))
|
|
$nbFichiersPack++
|
|
$octetsPack += $fichier.Length
|
|
}
|
|
}
|
|
|
|
if ($nbFichiersPack -eq 0) {
|
|
$alertes.Add(("Pack « {0} » ignore : aucun fichier utilisable." -f $code))
|
|
continue
|
|
}
|
|
|
|
$blocsPacks.Add((New-ManifesteBlocPack -code $code -libelle $libelle -version $Version -blocsFichiers $blocsFichiers))
|
|
$recap.Add((' {0,-6} {1,-16} {2,3} fichier(s) {3,12}' -f $code, $libelle, $nbFichiersPack, (Format-ManifesteTaille $octetsPack)))
|
|
}
|
|
|
|
if ($blocsPacks.Count -eq 0 -and -not $AutoriserVide) {
|
|
$echecs.Add('Aucun pack exploitable : manifeste NON ecrit (un manifeste vide ferait afficher au mobile « Aucun modele de langue n''est disponible sur le serveur »).')
|
|
$echecs.Add('Corriger l''arborescence, ou forcer avec -AutoriserVide si c''est volontaire.')
|
|
}
|
|
|
|
if ($echecs.Count -gt 0) {
|
|
Write-ManifesteBilan $echecs $alertes | Out-Null
|
|
exit 1
|
|
}
|
|
|
|
$json = New-ManifesteJsonText $blocsPacks
|
|
|
|
foreach ($ligne in $recap) { Write-ManifesteInfo $ligne }
|
|
Write-Host ''
|
|
|
|
if (-not $PSCmdlet.ShouldProcess($Sortie, 'Ecriture du manifeste des packs de langue')) {
|
|
Write-ManifesteInfo 'Simulation (-WhatIf) : aucun fichier ecrit. Contenu qui aurait ete ecrit :'
|
|
Write-Host ''
|
|
Write-Host $json
|
|
Write-Host ''
|
|
Write-ManifesteBilan $echecs $alertes | Out-Null
|
|
exit 0
|
|
}
|
|
|
|
if (Test-Path -LiteralPath $Sortie -PathType Leaf) {
|
|
$sauvegarde = $Sortie + '.bak'
|
|
Copy-Item -LiteralPath $Sortie -Destination $sauvegarde -Force
|
|
Write-ManifesteInfo ("Manifeste precedent conserve : {0}" -f $sauvegarde)
|
|
}
|
|
|
|
Write-ManifesteFichier -chemin $Sortie -contenu $json
|
|
Write-ManifesteOk ("Manifeste ecrit : {0}" -f $Sortie)
|
|
Write-Host ''
|
|
|
|
foreach ($alerte in $alertes) { Write-ManifesteAlerte $alerte }
|
|
Write-Host ''
|
|
Write-ManifesteInfo 'Aucun demarrage/redemarrage de service n''est necessaire : l''API relit le'
|
|
Write-ManifesteInfo 'manifeste a CHAQUE appel de GET /api/langues.'
|
|
Write-ManifesteInfo 'Le mobile, lui, garde son index memorise : il faut un rafraichissement'
|
|
Write-ManifesteInfo '(liste des langues -> actualiser) pour voir la nouvelle liste.'
|
|
Write-Host ''
|
|
Write-ManifesteInfo 'Controles a enchainer :'
|
|
Write-ManifesteInfo (' 1. .\New-OmikaLanguesManifeste.ps1 -Verifier')
|
|
Write-ManifesteInfo ' 2. Invoke-RestMethod https://<URL_SRV_LANGUES>/api/langues | ConvertTo-Json -Depth 6'
|
|
|
|
exit 0
|