739 lines
27 KiB
PowerShell
739 lines
27 KiB
PowerShell
# ============================================================
|
|
# Omika - Module commun de deploiement des services Windows
|
|
# ============================================================
|
|
# Utilise par les scripts Install-Omika*.ps1 (UN FICHIER PAR DEPLOIEMENT).
|
|
#
|
|
# Ce module regroupe ce qui etait duplique ou implicite dans l'ancien
|
|
# Install-OmikaServices.ps1 monolithique :
|
|
# - controle des droits administrateur ;
|
|
# - messages homogenes (etape / info / ok / avertissement / echec) ;
|
|
# - creation de dossiers idempotente ;
|
|
# - ACL NTFS AVEC CONTROLE DU CODE RETOUR d'icacls ;
|
|
# - validation du compte de service (existence + droit « Ouvrir une session
|
|
# en tant que service ») ;
|
|
# - creation / suppression / verification d'un service Windows.
|
|
#
|
|
# COMPATIBILITE : Windows PowerShell 5.1 (aucune syntaxe PS 7).
|
|
#
|
|
# CE MODULE NE DEMARRE JAMAIS UN SERVICE. Il cree et configure uniquement ;
|
|
# le demarrage reste une action manuelle et explicite (doctrine Phase 5C.2C).
|
|
#
|
|
# A PROPOS DE -WhatIf :
|
|
# Les variables de preference ($WhatIfPreference) NE se propagent PAS dans
|
|
# l'etat de session d'un module. Les scripts appelants doivent donc transmettre
|
|
# explicitement -WhatIf:$Simulation a chaque appel. Chaque fonction marquee
|
|
# [CmdletBinding(SupportsShouldProcess)] l'accepte.
|
|
# ============================================================
|
|
|
|
# --- Messages ----------------------------------------------------------------
|
|
|
|
function Write-OmikaStep {
|
|
param([Parameter(Mandatory = $true)][string]$Message)
|
|
Write-Host ''
|
|
Write-Host "== $Message ==" -ForegroundColor Cyan
|
|
}
|
|
|
|
function Write-OmikaInfo {
|
|
param([Parameter(Mandatory = $true)][string]$Message)
|
|
Write-Host " .. $Message"
|
|
}
|
|
|
|
function Write-OmikaOk {
|
|
param([Parameter(Mandatory = $true)][string]$Message)
|
|
Write-Host " OK $Message" -ForegroundColor Green
|
|
}
|
|
|
|
function Write-OmikaWarn {
|
|
param([Parameter(Mandatory = $true)][string]$Message)
|
|
Write-Host " ATTENTION $Message" -ForegroundColor Yellow
|
|
}
|
|
|
|
function Write-OmikaFail {
|
|
param([Parameter(Mandatory = $true)][string]$Message)
|
|
Write-Host " ECHEC $Message" -ForegroundColor Red
|
|
}
|
|
|
|
# --- Prerequis ---------------------------------------------------------------
|
|
|
|
function Assert-OmikaAdmin {
|
|
<#
|
|
.SYNOPSIS
|
|
Verifie que la session PowerShell est elevee. Leve une exception sinon.
|
|
#>
|
|
$identite = [Security.Principal.WindowsIdentity]::GetCurrent()
|
|
$principal = New-Object Security.Principal.WindowsPrincipal($identite)
|
|
if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
|
|
throw "Ce script doit etre execute en PowerShell ADMINISTRATEUR (clic droit -> Executer en tant qu'administrateur)."
|
|
}
|
|
}
|
|
|
|
function Get-OmikaPaths {
|
|
<#
|
|
.SYNOPSIS
|
|
Resout l'arborescence serveur C:\Omika (meme convention que
|
|
Install-OmikaServerFiles.ps1).
|
|
#>
|
|
param([string]$InstallRoot = 'C:\Omika')
|
|
|
|
return [pscustomobject]@{
|
|
InstallRoot = $InstallRoot
|
|
Apps = Join-Path $InstallRoot 'Apps'
|
|
Data = Join-Path $InstallRoot 'Data'
|
|
Logs = Join-Path $InstallRoot 'Logs'
|
|
Config = Join-Path $InstallRoot 'Config'
|
|
Backups = Join-Path $InstallRoot 'Backups'
|
|
Deploy = Join-Path $InstallRoot 'Deploy'
|
|
}
|
|
}
|
|
|
|
# --- Dossiers ----------------------------------------------------------------
|
|
|
|
function New-OmikaDirectory {
|
|
[CmdletBinding(SupportsShouldProcess = $true)]
|
|
param([Parameter(Mandatory = $true)][string]$Path)
|
|
|
|
if (Test-Path -LiteralPath $Path) {
|
|
Write-OmikaInfo "Dossier deja present : $Path"
|
|
return $false
|
|
}
|
|
if ($PSCmdlet.ShouldProcess($Path, 'Creer le dossier')) {
|
|
New-Item -ItemType Directory -Force -Path $Path | Out-Null
|
|
Write-OmikaOk "Dossier cree : $Path"
|
|
return $true
|
|
}
|
|
return $false
|
|
}
|
|
|
|
# --- Compte de service -------------------------------------------------------
|
|
|
|
function Resolve-OmikaAccountName {
|
|
<#
|
|
.SYNOPSIS
|
|
Normalise un compte de service en forme NON AMBIGUE 'ORDINATEUR\compte'.
|
|
|
|
.DESCRIPTION
|
|
L'ancien script passait la forme '.\svc_omika_api' directement a icacls.
|
|
La forme '.\' est une commodite de ligne de commande : elle n'est pas la
|
|
forme documentee d'icacls (qui attend 'Compte' ou 'Domaine\Compte').
|
|
Comme le bac a sable de developpement ne permet pas de verifier les
|
|
ecritures d'ACL, ce module ne pariera pas sur la forme '.\' : il resout
|
|
systematiquement en 'ORDINATEUR\compte', forme non ambigue, et le script
|
|
CONTROLE le code retour d'icacls (voir Grant-OmikaAcl).
|
|
#>
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Account,
|
|
[string]$ComputerName = $env:COMPUTERNAME
|
|
)
|
|
|
|
if ($Account -eq '.') { return "$ComputerName\$env:USERNAME" }
|
|
if ($Account.StartsWith('.\')) { return ('{0}\{1}' -f $ComputerName, $Account.Substring(2)) }
|
|
if ($Account.StartsWith('./')) { return ('{0}\{1}' -f $ComputerName, $Account.Substring(2)) }
|
|
return $Account
|
|
}
|
|
|
|
function Test-OmikaLocalAccount {
|
|
<#
|
|
.SYNOPSIS
|
|
Verifie qu'un compte de service existe sur la machine.
|
|
.OUTPUTS
|
|
PSCustomObject : Nom, FormeResolue, Existe ($true/$false/$null si domaine),
|
|
Actif, Sid, Raison.
|
|
#>
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Account,
|
|
[string]$ComputerName = $env:COMPUTERNAME
|
|
)
|
|
|
|
$resolu = Resolve-OmikaAccountName -Account $Account -ComputerName $ComputerName
|
|
$resultat = [pscustomobject]@{
|
|
Nom = $Account
|
|
FormeResolue = $resolu
|
|
Existe = $null
|
|
Actif = $null
|
|
Sid = $null
|
|
Raison = ''
|
|
}
|
|
|
|
# Compte de domaine : non verifiable localement (le DC est autoritaire).
|
|
$nomCourt = $resolu
|
|
if ($resolu.Contains('\')) { $nomCourt = $resolu.Substring($resolu.IndexOf('\') + 1) }
|
|
|
|
if ($resolu.Contains('\') -and -not $resolu.StartsWith("$ComputerName\", [System.StringComparison]::OrdinalIgnoreCase)) {
|
|
$resultat.Raison = 'compte de domaine : existence non verifiable depuis ce serveur'
|
|
return $resultat
|
|
}
|
|
|
|
# 1) Get-LocalUser (module LocalAccounts) : leve UserNotFoundException si le
|
|
# compte est absent. C'est le chemin nominal.
|
|
if (Get-Command -Name Get-LocalUser -ErrorAction SilentlyContinue) {
|
|
try {
|
|
$utilisateur = Get-LocalUser -Name $nomCourt -ErrorAction Stop
|
|
$resultat.Existe = $true
|
|
$resultat.Actif = [bool]$utilisateur.Enabled
|
|
if ($utilisateur.SID) { $resultat.Sid = $utilisateur.SID.Value }
|
|
return $resultat
|
|
}
|
|
catch {
|
|
if ($_.Exception.GetType().Name -eq 'UserNotFoundException') {
|
|
$resultat.Existe = $false
|
|
$resultat.Raison = "compte local introuvable : $resolu"
|
|
return $resultat
|
|
}
|
|
# Autre erreur (droits, module...) : on ne conclut pas, on passe au repli.
|
|
}
|
|
}
|
|
|
|
# 2) Repli net.exe user : code retour 0 = le compte existe, non nul = absent.
|
|
#
|
|
# PAS DE REPLI ADSI. Verifie en test sur ce poste :
|
|
# [ADSI]("WinNT://ORDINATEUR/compte,user") -> AUCUNE exception pour un
|
|
# compte inexistant (et .Name vide) : ce repli produisait un FAUX POSITIF
|
|
# « Existe = True », c'est-a-dire exactement le diagnostic inverse de
|
|
# celui attendu. Un faux positif est pire qu'une incertitude ici : le
|
|
# script laisserait creer un service avec un compte inexistant.
|
|
# Le nom est filtre sur le guillemet simple (argument de ligne de commande).
|
|
if ($nomCourt -notmatch "'") {
|
|
$ancien = $ErrorActionPreference
|
|
$ErrorActionPreference = 'Continue'
|
|
try {
|
|
$null = (& net.exe user $nomCourt 2>&1 | Out-String)
|
|
$code = $LASTEXITCODE
|
|
}
|
|
finally {
|
|
$ErrorActionPreference = $ancien
|
|
}
|
|
|
|
if ($code -eq 0) {
|
|
$resultat.Existe = $true
|
|
return $resultat
|
|
}
|
|
$resultat.Existe = $false
|
|
$resultat.Raison = "compte local introuvable : $resolu"
|
|
return $resultat
|
|
}
|
|
|
|
# 3) Ni l'un ni l'autre exploitable : on reste INDETERMINE (jamais « existe »).
|
|
$resultat.Raison = 'existence non verifiable (ni Get-LocalUser ni net.exe exploitables)'
|
|
return $resultat
|
|
}
|
|
|
|
function Get-OmikaServiceLogonRight {
|
|
<#
|
|
.SYNOPSIS
|
|
Lit la liste des comptes titulaires du droit « Ouvrir une session en tant
|
|
que service » (SeServiceLogonRight) via un export secedit.
|
|
.OUTPUTS
|
|
Tableau d'entrees (SID ou nom), ou $null si indeterminable (non admin).
|
|
#>
|
|
$fichier = Join-Path $env:TEMP ('omika-secedit-{0}.inf' -f ([guid]::NewGuid().ToString('N')))
|
|
$ancien = $ErrorActionPreference
|
|
$ErrorActionPreference = 'Continue'
|
|
try {
|
|
& secedit.exe /export /areas USER_RIGHTS /cfg $fichier | Out-Null
|
|
if (-not (Test-Path -LiteralPath $fichier)) { return $null }
|
|
|
|
# Les noms de privileges (SeServiceLogonRight) ne sont PAS localises :
|
|
# le filtrage fonctionne sur un Windows francais.
|
|
$ligne = Get-Content -LiteralPath $fichier |
|
|
Where-Object { $_ -match '^\s*SeServiceLogonRight\s*=' } |
|
|
Select-Object -First 1
|
|
if (-not $ligne) { return @() }
|
|
|
|
$valeur = ($ligne -split '=', 2)[1]
|
|
$entrees = @($valeur -split ',' | ForEach-Object { $_.Trim() } | Where-Object { $_ -ne '' })
|
|
return $entrees
|
|
}
|
|
catch {
|
|
return $null
|
|
}
|
|
finally {
|
|
$ErrorActionPreference = $ancien
|
|
if (Test-Path -LiteralPath $fichier) {
|
|
Remove-Item -LiteralPath $fichier -Force -ErrorAction SilentlyContinue
|
|
}
|
|
}
|
|
}
|
|
|
|
function Test-OmikaServiceLogonRight {
|
|
<#
|
|
.SYNOPSIS
|
|
Verifie que le compte possede le droit « Ouvrir une session en tant que
|
|
service ». C'est la cause n1 d'echec de demarrage (erreur 1069/1053).
|
|
.OUTPUTS
|
|
$true, $false, ou $null si le droit n'a pas pu etre determine.
|
|
#>
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Account,
|
|
[string]$ComputerName = $env:COMPUTERNAME
|
|
)
|
|
|
|
$compte = Test-OmikaLocalAccount -Account $Account -ComputerName $ComputerName
|
|
$droits = Get-OmikaServiceLogonRight
|
|
if ($null -eq $droits) { return $null }
|
|
|
|
$candidats = @()
|
|
if ($compte.Sid) { $candidats += $compte.Sid }
|
|
if ($compte.FormeResolue) { $candidats += $compte.FormeResolue }
|
|
$nomCourt = $compte.FormeResolue
|
|
if ($nomCourt.Contains('\')) { $nomCourt = $nomCourt.Substring($nomCourt.IndexOf('\') + 1) }
|
|
if ($nomCourt) { $candidats += $nomCourt }
|
|
|
|
foreach ($entree in $droits) {
|
|
foreach ($candidat in $candidats) {
|
|
if ([string]::IsNullOrWhiteSpace($candidat)) { continue }
|
|
if ($entree -eq $candidat) { return $true }
|
|
# secedit exporte les comptes locaux sous forme de SID (*S-1-5-21-...).
|
|
if ($entree -like "*$candidat*") { return $true }
|
|
}
|
|
}
|
|
return $false
|
|
}
|
|
|
|
function Assert-OmikaServiceAccount {
|
|
<#
|
|
.SYNOPSIS
|
|
Verifie le compte de service avant la creation (existence + droit de
|
|
connexion). Leve une exception si le compte n'existe pas ; avertit
|
|
seulement si un droit manque (New-Service peut encore reussir, mais le
|
|
DEMARRAGE echouera).
|
|
#>
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Account,
|
|
[string]$ComputerName = $env:COMPUTERNAME
|
|
)
|
|
|
|
$compte = Test-OmikaLocalAccount -Account $Account -ComputerName $ComputerName
|
|
Write-OmikaInfo "Compte de service : $($compte.FormeResolue)"
|
|
|
|
if ($compte.Existe -eq $false) {
|
|
throw ("Compte de service introuvable : $($compte.FormeResolue). " +
|
|
"Creez le compte local dedie AVANT ce script (jamais LocalSystem, " +
|
|
"jamais un compte humain).")
|
|
}
|
|
if ($compte.Existe -eq $null) {
|
|
Write-OmikaWarn "Existence du compte non verifiable ($($compte.Raison))."
|
|
}
|
|
elseif ($compte.Actif -eq $false) {
|
|
Write-OmikaWarn "Le compte $($compte.FormeResolue) est DESACTIVE : le service ne demarrera pas."
|
|
}
|
|
|
|
$droit = Test-OmikaServiceLogonRight -Account $Account -ComputerName $ComputerName
|
|
if ($droit -eq $false) {
|
|
Write-OmikaWarn "Le compte $($compte.FormeResolue) ne possede PAS le droit"
|
|
Write-OmikaWarn " « Ouvrir une session en tant que service » (SeServiceLogonRight)."
|
|
Write-OmikaWarn " -> La creation du service reussira, mais le DEMARRAGE echouera (erreur 1069)."
|
|
Write-OmikaWarn " -> secpol.msc : Attribution des droits utilisateur / Ouvrir une session en tant que service."
|
|
}
|
|
elseif ($droit -eq $null) {
|
|
Write-OmikaWarn "Droit de connexion en tant que service : non verifiable (secedit inaccessible)."
|
|
}
|
|
else {
|
|
Write-OmikaOk "Droit « Ouvrir une session en tant que service » : present."
|
|
}
|
|
|
|
return $compte
|
|
}
|
|
|
|
# --- ACL ---------------------------------------------------------------------
|
|
|
|
function Grant-OmikaAcl {
|
|
<#
|
|
.SYNOPSIS
|
|
Pose une ACL NTFS et CONTROLE le code retour d'icacls.
|
|
|
|
.DESCRIPTION
|
|
L'ancien script ignorait totalement le code retour d'icacls : une ACL
|
|
refusee passait inapercue a l'installation et ne se manifestait qu'au
|
|
premier demarrage du service, par une erreur d'acces illisible.
|
|
|
|
Deux cas sont distingues :
|
|
- dossier absent -> avertissement BRUYANT (sauf -RequireExisting) ;
|
|
- icacls en echec -> exception (le script s'arrete).
|
|
|
|
.PARAMETER Right
|
|
M = Modifier (ecriture), R = Lecture seule.
|
|
#>
|
|
[CmdletBinding(SupportsShouldProcess = $true)]
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Path,
|
|
[Parameter(Mandatory = $true)][string]$Account,
|
|
[ValidateSet('M', 'R')][string]$Right = 'M',
|
|
[switch]$RequireExisting
|
|
)
|
|
|
|
$resolu = Resolve-OmikaAccountName -Account $Account
|
|
|
|
if (-not (Test-Path -LiteralPath $Path)) {
|
|
$message = "Dossier absent, aucune ACL posee : $Path (compte $resolu)"
|
|
if ($RequireExisting) { throw $message }
|
|
Write-OmikaWarn $message
|
|
Write-OmikaWarn ' -> le service subira une erreur d''acces a son premier demarrage.'
|
|
return $false
|
|
}
|
|
|
|
$ace = '{0}:(OI)(CI){1}' -f $resolu, $Right
|
|
if (-not $PSCmdlet.ShouldProcess($Path, "ACL $Right pour $resolu")) { return $false }
|
|
|
|
# icacls ecrit ses erreurs sur stderr : sous $ErrorActionPreference='Stop' une
|
|
# NativeCommandError deviendrait TERMINANTE et masquerait le vrai code retour.
|
|
# On isole donc l'appel.
|
|
$ancien = $ErrorActionPreference
|
|
$ErrorActionPreference = 'Continue'
|
|
try {
|
|
$sortie = (& icacls.exe $Path /grant:r $ace 2>&1 | Out-String)
|
|
$code = $LASTEXITCODE
|
|
}
|
|
finally {
|
|
$ErrorActionPreference = $ancien
|
|
}
|
|
|
|
if ($code -ne 0) {
|
|
throw ("icacls a echoue (code $code) sur '$Path' pour '$resolu'.`n" +
|
|
"Sortie icacls : $($sortie.Trim())`n" +
|
|
"Verifiez que le compte existe et que la forme du nom est acceptee " +
|
|
"('ORDINATEUR\compte').")
|
|
}
|
|
|
|
Write-OmikaOk "ACL $Right : $resolu sur $Path"
|
|
return $true
|
|
}
|
|
|
|
# --- Service Windows ---------------------------------------------------------
|
|
|
|
function Get-OmikaServiceState {
|
|
<#
|
|
.SYNOPSIS
|
|
Etat reel d'un service (CIM), ou $null s'il n'existe pas.
|
|
Permet de detecter un service existant qui pointe sur un AUTRE binaire
|
|
ou tourne sous un AUTRE compte que ceux attendus.
|
|
#>
|
|
param([Parameter(Mandatory = $true)][string]$Name)
|
|
|
|
$service = Get-CimInstance -ClassName Win32_Service -Filter ("Name='{0}'" -f $Name) -ErrorAction SilentlyContinue
|
|
if (-not $service) { return $null }
|
|
|
|
return [pscustomobject]@{
|
|
Nom = $service.Name
|
|
NomAffiche = $service.DisplayName
|
|
Etat = $service.State
|
|
Demarrage = $service.StartMode
|
|
CheminExe = $service.PathName
|
|
Compte = $service.StartName
|
|
Description = $service.Description
|
|
}
|
|
}
|
|
|
|
function Install-OmikaService {
|
|
<#
|
|
.SYNOPSIS
|
|
Cree un service Windows (StartupType Manual par defaut), de facon
|
|
IDEMPOTENTE, et verifie ce qui a ete reellement cree.
|
|
|
|
.DESCRIPTION
|
|
- Service inexistant -> creation (mot de passe saisi via Get-Credential,
|
|
jamais en dur, jamais affiche).
|
|
- Service existant -> aucune creation ; comparaison du binaire et du
|
|
compte avec les valeurs attendues, avec avertissement si divergence.
|
|
- Ne demarre JAMAIS le service.
|
|
|
|
.OUTPUTS
|
|
PSCustomObject : Nom, Cree, ExistaitDeja, Conforme, Etat.
|
|
#>
|
|
[CmdletBinding(SupportsShouldProcess = $true)]
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Name,
|
|
[Parameter(Mandatory = $true)][string]$DisplayName,
|
|
[Parameter(Mandatory = $true)][string]$ExePath,
|
|
[Parameter(Mandatory = $true)][string]$Account,
|
|
[string]$Description = '',
|
|
[ValidateSet('Manual', 'Automatic', 'Disabled')][string]$StartupType = 'Manual'
|
|
)
|
|
|
|
$resultat = [pscustomobject]@{
|
|
Nom = $Name
|
|
Cree = $false
|
|
ExistaitDeja = $false
|
|
Conforme = $null
|
|
Etat = ''
|
|
}
|
|
|
|
if (-not (Test-Path -LiteralPath $ExePath -PathType Leaf)) {
|
|
throw "Executable introuvable pour le service '$Name' : $ExePath"
|
|
}
|
|
|
|
$attendu = '"{0}"' -f $ExePath
|
|
$existant = Get-OmikaServiceState -Name $Name
|
|
|
|
if ($existant) {
|
|
$resultat.ExistaitDeja = $true
|
|
$resultat.Etat = $existant.Etat
|
|
Write-OmikaInfo "Service '$Name' deja present : aucune creation (idempotent)."
|
|
|
|
$conforme = $true
|
|
if ($existant.CheminExe -and $existant.CheminExe.Trim('"') -ne $ExePath) {
|
|
Write-OmikaWarn " Binaire DIFFERENT de celui attendu :"
|
|
Write-OmikaWarn " attendu : $ExePath"
|
|
Write-OmikaWarn " reel : $($existant.CheminExe)"
|
|
$conforme = $false
|
|
}
|
|
$compteAttendu = (Resolve-OmikaAccountName -Account $Account).ToLowerInvariant()
|
|
if ($existant.Compte -and $existant.Compte.ToLowerInvariant() -ne $compteAttendu) {
|
|
Write-OmikaWarn " Compte DIFFERENT de celui attendu :"
|
|
Write-OmikaWarn " attendu : $compteAttendu"
|
|
Write-OmikaWarn " reel : $($existant.Compte)"
|
|
$conforme = $false
|
|
}
|
|
$resultat.Conforme = $conforme
|
|
return $resultat
|
|
}
|
|
|
|
if ($PSCmdlet.ShouldProcess($Name, "Creer le service Windows (compte $Account, $StartupType)")) {
|
|
$cred = Get-Credential -UserName $Account -Message "Mot de passe du compte de service $Name"
|
|
$parametres = @{
|
|
Name = $Name
|
|
DisplayName = $DisplayName
|
|
BinaryPathName = $attendu
|
|
Credential = $cred
|
|
StartupType = $StartupType
|
|
}
|
|
if ($Description) { $parametres['Description'] = $Description }
|
|
|
|
New-Service @parametres | Out-Null
|
|
Write-OmikaOk "Service cree : $Name ($StartupType, non demarre)."
|
|
$resultat.Cree = $true
|
|
|
|
$etat = Get-OmikaServiceState -Name $Name
|
|
if ($etat) { $resultat.Etat = $etat.Etat }
|
|
}
|
|
|
|
return $resultat
|
|
}
|
|
|
|
function Remove-OmikaService {
|
|
<#
|
|
.SYNOPSIS
|
|
Supprime un service Windows (rollback). Refuse si le service tourne
|
|
encore : il faut l'arreter explicitement d'abord (aucun arret automatique).
|
|
#>
|
|
[CmdletBinding(SupportsShouldProcess = $true)]
|
|
param([Parameter(Mandatory = $true)][string]$Name)
|
|
|
|
$existant = Get-OmikaServiceState -Name $Name
|
|
if (-not $existant) {
|
|
Write-OmikaInfo "Service '$Name' absent : rien a supprimer."
|
|
return $false
|
|
}
|
|
if ($existant.Etat -eq 'Running') {
|
|
throw "Le service '$Name' est en cours d'execution : arretez-le explicitement (Stop-Service $Name) avant de le supprimer."
|
|
}
|
|
|
|
if ($PSCmdlet.ShouldProcess($Name, 'Supprimer le service Windows')) {
|
|
$ancien = $ErrorActionPreference
|
|
$ErrorActionPreference = 'Continue'
|
|
try {
|
|
$sortie = (& sc.exe delete $Name 2>&1 | Out-String)
|
|
$code = $LASTEXITCODE
|
|
}
|
|
finally {
|
|
$ErrorActionPreference = $ancien
|
|
}
|
|
if ($code -ne 0) { throw "sc.exe delete a echoue (code $code) pour '$Name' : $($sortie.Trim())" }
|
|
Write-OmikaOk "Service supprime : $Name"
|
|
return $true
|
|
}
|
|
return $false
|
|
}
|
|
|
|
# --- Restitutions ------------------------------------------------------------
|
|
|
|
function Write-OmikaServiceSummary {
|
|
<#
|
|
.SYNOPSIS
|
|
Affiche un recapitulatif de fin d'installation : etat reel du service
|
|
et rappels de ce qui reste MANUEL.
|
|
#>
|
|
param(
|
|
[Parameter(Mandatory = $true)][string]$Name,
|
|
[string]$ExePath = '',
|
|
[string]$Account = '',
|
|
[string[]]$Rappels = @(),
|
|
[switch]$Supprime
|
|
)
|
|
|
|
Write-Host ''
|
|
if ($Supprime) {
|
|
Write-Host ("{0} : SUPPRIME." -f $Name) -ForegroundColor Green
|
|
return
|
|
}
|
|
|
|
Write-Host ("{0} : INSTALLATION TERMINEE (service NON demarre)." -f $Name) -ForegroundColor Green
|
|
|
|
$etat = Get-OmikaServiceState -Name $Name
|
|
if ($etat) {
|
|
Write-Host ''
|
|
Write-Host ' Etat reel du service :'
|
|
Write-Host (" Nom : {0}" -f $etat.Nom)
|
|
Write-Host (" Nom affiche : {0}" -f $etat.NomAffiche)
|
|
Write-Host (" Etat : {0}" -f $etat.Etat)
|
|
Write-Host (" Demarrage : {0}" -f $etat.Demarrage)
|
|
Write-Host (" Binaire : {0}" -f $etat.CheminExe)
|
|
Write-Host (" Compte : {0}" -f $etat.Compte)
|
|
}
|
|
else {
|
|
Write-OmikaWarn "Le service '$Name' est introuvable apres installation (mode -WhatIf ?)."
|
|
}
|
|
|
|
if ($Rappels.Count -gt 0) {
|
|
Write-Host ''
|
|
Write-Host ' RAPPELS (jamais automatises par ce script) :' -ForegroundColor Yellow
|
|
foreach ($rappel in $Rappels) {
|
|
Write-Host (" - {0}" -f $rappel) -ForegroundColor Yellow
|
|
}
|
|
}
|
|
|
|
Write-Host ''
|
|
Write-Host ' Le demarrage est une action MANUELLE et explicite :' -ForegroundColor Yellow
|
|
Write-Host (" Start-Service {0}" -f $Name) -ForegroundColor Yellow
|
|
Write-Host ''
|
|
}
|
|
|
|
# --- Port loopback -----------------------------------------------------------
|
|
|
|
function Get-OmikaDebutPlageEphemere {
|
|
<#
|
|
.SYNOPSIS
|
|
Borne basse de la plage de ports ephemere Windows (49152 par defaut).
|
|
.DESCRIPTION
|
|
La sortie de netsh est LOCALISEE : on prend le premier nombre de la
|
|
reponse, qui est toujours le port de debut, quelle que soit la langue.
|
|
#>
|
|
$texte = (netsh int ipv4 show dynamicport tcp | Out-String)
|
|
$nombres = [regex]::Matches($texte, '\d+')
|
|
if ($nombres.Count -ge 1) { return [int]$nombres[0].Value }
|
|
return 49152
|
|
}
|
|
|
|
function Get-OmikaPlagesReservees {
|
|
<#
|
|
.SYNOPSIS
|
|
Plages TCP reservees par Windows (Hyper-V / WSL / Docker peuvent en
|
|
reserver arbitrairement). Necessite une session elevee.
|
|
#>
|
|
$plages = @()
|
|
$ancien = $ErrorActionPreference
|
|
$ErrorActionPreference = 'Continue'
|
|
try {
|
|
$lignes = netsh int ipv4 show excludedportrange protocol=tcp
|
|
}
|
|
finally {
|
|
$ErrorActionPreference = $ancien
|
|
}
|
|
foreach ($ligne in $lignes) {
|
|
$m = [regex]::Match([string]$ligne, '^\s*(\d{1,5})\s+(\d{1,5})\s*$')
|
|
if ($m.Success) {
|
|
$plages += [pscustomobject]@{
|
|
Debut = [int]$m.Groups[1].Value
|
|
Fin = [int]$m.Groups[2].Value
|
|
}
|
|
}
|
|
}
|
|
return $plages
|
|
}
|
|
|
|
function Test-OmikaPortLibre {
|
|
<#
|
|
.SYNOPSIS
|
|
Determine si un port TCP est utilisable sur ce serveur.
|
|
|
|
.DESCRIPTION
|
|
Quatre causes de refus sont testees :
|
|
1. un processus ecoute deja sur ce port ;
|
|
2. le port tombe dans une plage RESERVEE par Windows ;
|
|
3. le port tombe dans la plage EPHEMERE (une connexion sortante peut le prendre) ;
|
|
4. la reservation reelle sur 127.0.0.1 echoue.
|
|
Le test 4 est la preuve : le port est reellement reserve puis relache.
|
|
|
|
.OUTPUTS
|
|
PSCustomObject : Port, Libre (booleen), Raisons (texte).
|
|
#>
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[ValidateRange(1, 65535)]
|
|
[int]$Port,
|
|
|
|
[switch]$VerifierPlagesReservees
|
|
)
|
|
|
|
$refus = New-Object System.Collections.Generic.List[string]
|
|
|
|
# --- 1. Deja en ecoute ? -----------------------------------------------
|
|
$ecoute = @(Get-NetTCPConnection -LocalPort $Port -State Listen -ErrorAction SilentlyContinue)
|
|
if ($ecoute.Count -gt 0) {
|
|
$qui = @()
|
|
foreach ($connexion in $ecoute) {
|
|
$processus = Get-Process -Id $connexion.OwningProcess -ErrorAction SilentlyContinue
|
|
if ($processus) { $qui += ('{0} (PID {1})' -f $processus.ProcessName, $connexion.OwningProcess) }
|
|
else { $qui += ('PID {0}' -f $connexion.OwningProcess) }
|
|
}
|
|
$refus.Add('deja en ecoute par ' + (($qui | Select-Object -Unique) -join ', '))
|
|
}
|
|
|
|
# --- 2. Plage reservee ? -----------------------------------------------
|
|
if ($VerifierPlagesReservees) {
|
|
foreach ($plage in (Get-OmikaPlagesReservees)) {
|
|
if ($Port -ge $plage.Debut -and $Port -le $plage.Fin) {
|
|
$refus.Add(('dans une plage RESERVEE par Windows ({0} a {1})' -f $plage.Debut, $plage.Fin))
|
|
}
|
|
}
|
|
}
|
|
|
|
# --- 3. Plage ephemere ? ----------------------------------------------
|
|
$debutEphemere = Get-OmikaDebutPlageEphemere
|
|
if ($Port -ge $debutEphemere) {
|
|
$refus.Add(('dans la plage EPHEMERE (a partir de {0}) : une connexion sortante peut le prendre' -f $debutEphemere))
|
|
}
|
|
|
|
# --- 4. Test reel : reserver le port sur 127.0.0.1 ---------------------
|
|
$verrou = $null
|
|
try {
|
|
$verrou = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, $Port)
|
|
$verrou.Start()
|
|
}
|
|
catch {
|
|
$refus.Add("reservation impossible : $($_.Exception.Message)")
|
|
}
|
|
finally {
|
|
if ($verrou) { try { $verrou.Stop() } catch { } }
|
|
}
|
|
|
|
return [pscustomobject]@{
|
|
Port = $Port
|
|
Libre = ($refus.Count -eq 0)
|
|
Raisons = ($refus -join ' ; ')
|
|
}
|
|
}
|
|
|
|
Export-ModuleMember -Function @(
|
|
'Write-OmikaStep',
|
|
'Write-OmikaInfo',
|
|
'Write-OmikaOk',
|
|
'Write-OmikaWarn',
|
|
'Write-OmikaFail',
|
|
'Assert-OmikaAdmin',
|
|
'Get-OmikaPaths',
|
|
'New-OmikaDirectory',
|
|
'Resolve-OmikaAccountName',
|
|
'Test-OmikaLocalAccount',
|
|
'Get-OmikaServiceLogonRight',
|
|
'Test-OmikaServiceLogonRight',
|
|
'Assert-OmikaServiceAccount',
|
|
'Grant-OmikaAcl',
|
|
'Get-OmikaServiceState',
|
|
'Install-OmikaService',
|
|
'Remove-OmikaService',
|
|
'Write-OmikaServiceSummary',
|
|
'Get-OmikaDebutPlageEphemere',
|
|
'Get-OmikaPlagesReservees',
|
|
'Test-OmikaPortLibre'
|
|
)
|