Egalware/powershell-scripts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Accorpamento Progetti Powershell Script

Browse Source
This commit is contained in:
marco.locatelli@steamware.net
2024-02-21 11:23:47 +01:00
parent 236bcf195c
commit 7f87236961
33 changed files with 3392 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ApiGit/ApiGitResources/ApiScriptsConfig.ps1
+47
View File
@@ -0,0 +1,47 @@
######### FILE DI CONFIGURAZIONE PER SCRIPT API GIT #########
#### CONF GITLAB (ufficio, azzano, nembro) ####
#access token per autenticazione gitlab da profilo marco.locatelli@egalware.com con scadenza 31 dicembre 2024
$gitlabHead = @{"PRIVATE-TOKEN" = "glpat-VjT_SAsBk3s-yWE1LDUF" }
#nome utente che effettua i mirror push
$userName = "replica"
#token autenticazione utente replica azzano creato a gennaio 2024, scadenza 31 dicembere 2024
$tokenAzzano = "glpat-UHLqByZZr8tns6jwc4_-"
#access token per autenticazione gitlab da profilo marco.locatelli@egalware.com con scadenza 31 dicembre 2024
$azzanoHead = @{"PRIVATE-TOKEN" = "$($tokenAzzano)" }
#destinazione mirror per azzano
$destinationAzzano = "gitlab-azzano.steamware.net"
#token autenticazione utente replica nembro creato a gennaio 2024, scadenza 31 dicembere 2024
$tokenNembro = "glpat-puycZnyztFioe5tmkaso"
#access token per autenticazione gitlab-nembro
$nembroHead = @{"PRIVATE-TOKEN" = "$($tokenNembro)" }
#destinazione mirror per nembro
$destinationNembro = "gitlab-nembro.steamware.net"
#### CONF gitea.steamware.net ####
#destinazione mirror per gitea
$giteaDestination = "gitea.steamware.net"
#nome utente gitea che effettua i mirror push
$giteaUser = "replica"
#autenticazione replica gitea
$giteaPass = "ajejebrazorf92!"
#access token per autenticazione gitea da profilo replica
$giteaHead = @{"Authorization" = "token 3619817f299bb3d92c8a8f86d5fddbe877b60ffa" }
#### CONF gogs.steamware.net ####
#destinazione mirror per gogs
$gogsDestination = "gogs.steamware.net"
#nome utente gogs che effettua i mirror push
$gogsUser = "replica"
#password replica gogs
$gogsPass = "viaDante16!"
#access token per autenticazione gogs da profilo replica
$gogsHead = @{"Authorization" = "token bb6d8e9a4d76445e33b12e1664140043fdaa8d87" }
#### CONF LOG ####
#cartella file di log
$logFolder = "c:\Steamware\Logs\Gitlab\"
#livello di log: 0=log sintetico, 1=log errori, 2=log full, 3=log ampolloso
$logLevel = 3
#output a terminale: 0=disattivo, 1=abilitato
$terminalOutput = 1
ApiGit/ApiGitResources/ApiScriptsFunctions.ps1
+44
View File
@@ -0,0 +1,44 @@
######### FUNZIONI COMUNI PER SCRIPT API GIT #########
#scrittura output & log
Function WriteLogOutput {
Param ($logFile, $logType, [string]$logString)
#compongo path per file di log
$logPath = Join-Path $logFolder $logFile
#scrivo su file la stringa se il tipo di log è > o uguale al livello richiesto
if ($logType -le $logLevel) {
Add-content $logPath -value "$logString"
#scrivo su terminale la stringa se $terminalOutput=1
if ($terminalOutput -eq 1) {
Write-Output($logString)
}
}
}
#creazione nuovo mirror
Function FreshMirrorCreation {
Param ($projectNumber, $user, $auth, $destination, $path)
#compongo url da chiamare per creazione nuovo mirror
$callUrlCreateMirror = "https://gitlab.steamware.net/api/v4/projects/" + $projectNumber + "/remote_mirrors"
#creo url del nuovo mirror con username e token relativi a gitlab
$newMirror = "https://" + $user + ":" + $auth + "@" + $destination + "/" + $path
#creo body da convertire in json
$body =
@{
url = $newMirror
enabled = 1
}
#converto body in json prima di passarlo alla chiamata POST
$jsonBody = ConvertTo-Json -InputObject $body
#chiamata api POST che crea mirror con url e body specificati
$rebuildResponse = Invoke-WebRequest -Method Post -URI $callUrlCreateMirror -Headers $gitlabHead -ContentType "application/json" -Body $jsonBody -UseBasicParsing
#conversione da Json della risposta alla chiamata POST
$parsedRebuild = $rebuildResponse.Content | ConvertFrom-Json
#rilevo ID e URL nuovo mirror per scriverli nel log
foreach ($item in $parsedRebuild) {
$mirrorId = $($item.id)
$mirrorUrl = $($item.url)
}
#scrivo ID e URL nuovo mirror
WriteLogOutput $logFile 1 "NEW ID: $mirrorId - URL: $mirrorUrl - Mirror creato con successo"
}
ApiGit/CheckGitlabCommits.ps1
+127
View File
@@ -0,0 +1,127 @@
###Gitlab: controllo i commit recenti dei singoli progetti###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno verifica la presenza di commit recenti in una finestra di giorni specificata
#Poi invia le statistiche rilevate a zabbix per avere lo storico dei progetti con commit recenti
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 200
#conteggio progetti trovati
$projectsFound = 0
#conteggio progetti con commit negli ultimi giorni
$projectWithCommits = 0
#conteggio progetti senza commit negli ultimi giorni
$projectWithNoCommits = 0
#conteggio commits degli ultimi giorni
$recentCommits = 0
#ultimi giorni da considerare
$lastDays = 7
#data per conteggio commits degli ultimi giorni
$requestDate = (Get-Date).AddDays(-$lastDays).toString("yyyy-MM-dd")
#nome file di log
$logFile = "GitlabCommits.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB COMMITS" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB COMMITS" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB COMMITS" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB COMMITS" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "RICERCA DA $requestDate | ULTIMI $lastDays GIORNI"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
$callUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/repository/commits?per_page=100&since=" + $requestDate
try {
$Response = Invoke-WebRequest -URI $callUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedResponse = $Response.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
if ($parsedResponse.Count -eq 0 ) {
$projectWithNoCommits = $projectWithNoCommits + 1
}
else {
$projectWithCommits = $projectWithCommits + 1
foreach ($item in $parsedResponse) {
if ($item.web_url) {
WriteLogOutput $logFile 1 "Date: $($item.committed_date) - Web Url: $($item.web_url)"
$recentCommits = $recentCommits + 1
}
}
}
$projectsFound = $projectsFound + 1
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
#percentuale di projectWithCommits sul totale
$projectWithCommitsPercentage = [math]::Round(($projectWithCommits / $projectsFound) * 100, 1)
#percentuale di projectWithNoCommits sul totale
$projectWithNoCommitsPercentage = [math]::Round(($projectWithNoCommits / $projectsFound) * 100, 1)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#invio a zabbix le metriche rilevate tramite zabbix_sender.exe
WriteLogOutput $logFile 0 ""
#& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ProjectsFound -o $projectsFound
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.LastDaysCommits -o $lastDays
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.RecentCommits -o $recentCommits
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ProjectWithCommits -o $projectWithCommits
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ProjectWithNoCommits -o $projectWithNoCommits
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ProjectWithCommitsPercentage -o $projectWithCommitsPercentage
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ProjectWithNoCommitsPercentage -o $projectWithNoCommitsPercentage
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.CheckCommitsDuration -o $durataScript
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "PROGETTI TOTALI: $projectsFound"
WriteLogOutput $logFile 0 "COMMITS TOTALI: $recentCommits"
WriteLogOutput $logFile 0 "PROGETTI CON COMMITS: $projectWithCommits ($projectWithCommitsPercentage%)"
WriteLogOutput $logFile 0 "PROGETTI SENZA COMMITS: $projectWithNoCommits ($projectWithNoCommitsPercentage%)"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/CheckGitlabMirroring.ps1
+121
View File
@@ -0,0 +1,121 @@
###Gitlab: controllo lo stato dei mirror dei singoli progetti###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno verifica lo stato dei mirror, poi invia a zabbix le statistiche.
#Tendenzialmente ogni progetto dovrebbe avere 4 mirror abilitati: nembro, azzano, gitea, gogs
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 200
#conteggio progetti trovati
$existingProjects = 0
#conteggio mirroring in errore
$mirrorErrorsCount = 0
#conteggio mirroring riusciti
$mirrorSuccessCount = 0
#nome file di log
$logFile = "GitlabMirroring.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB MIRRORING" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB MIRRORING" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB MIRRORING" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB MIRRORING" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
#chiamata api che restituisce informazioni sullo stato dei mirror
$callUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors"
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
try {
#parsing della risposta api convertita da json
$Response = Invoke-WebRequest -URI $callUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedResponse = $Response.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
foreach ($item in $parsedResponse) {
#verifico se i mirroring trovati per il progetto corrente hanno status "finished"
if ($item.update_status.Equals("finished")) {
WriteLogOutput $logFile 2 "Mirror: $($item.url) - Status: $($item.update_status) - Last Success: $($item.last_successful_update_at)"
$mirrorSuccessCount = $mirrorSuccessCount + 1
}
#i mirroring che non hanno status "finished" vengono loggati con relativo errore
else {
WriteLogOutput $logFile 1 "Mirror: $($item.url) - Status: $($item.update_status) - Last Success: $($item.last_successful_update_at) - Last Attempt: $($item.last_update_started_at)"
WriteLogOutput $logFile 1 "Error: $($item.last_error)"
$mirrorErrorsCount = $mirrorErrorsCount + 1
}
}
$existingProjects = $existingProjects + 1
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
#somma di mirrorSuccess e mirrorErrors
$mirrorCount = $mirrorSuccessCount + $mirrorErrorsCount
#percentuale di mirrorSuccess sul totale
$mirrorSuccessPercentage = [math]::Round(($mirrorSuccessCount / $mirrorCount) * 100, 1)
#percentuale di mirrorErrors sul totale
$mirrorErrorsPercentage = [math]::Round(($mirrorErrorsCount / $mirrorCount) * 100, 1)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#invio a zabbix le metriche rilevate tramite zabbix_sender.exe
WriteLogOutput $logFile 0 ""
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.Projects -o $existingProjects
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.TotalMirror -o $mirrorCount
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.SuccessMirror -o $mirrorSuccessCount
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ErrorsMirror -o $mirrorErrorsCount
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.SuccessMirrorPercent -o $mirrorSuccessPercentage
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ErrorsMirrorPercent -o $mirrorErrorsPercentage
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.CheckMirrorDuration -o $durataScript
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "PROGETTI ANALIZZATI: $existingProjects"
WriteLogOutput $logFile 0 "MIRRORING TOTALI: $mirrorCount"
WriteLogOutput $logFile 0 "MIRRORING RIUSCITI: $mirrorSuccessCount ($mirrorSuccessPercentage%)"
WriteLogOutput $logFile 0 "MIRRORING FALLITI: $mirrorErrorsCount ($mirrorErrorsPercentage%)"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/CheckGitlabPipelines.ps1
+121
View File
@@ -0,0 +1,121 @@
###Gitlab: controllo lo stato delle pipeline dei singoli progetti###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno verifica la presenza e lo stato delle pipeline.
#Poi invia i dati rilevati a zabbix per avere lo storico dello stato delle pipelines.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 200
#conteggio progetti trovati
$projectsWithPipeline = 0
#conteggio pipeline in errore
$pipelineErrorsCount = 0
#conteggio pipeline riusciti
$pipelineSuccessCount = 0
#nome file di log
$logFile = "GitlabPipeline.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB PIPELINE" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB PIPELINE" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB PIPELINE" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB PIPELINE" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
$callUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/pipelines/latest"
try {
$Response = Invoke-WebRequest -URI $callUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedResponse = $Response.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
foreach ($item in $parsedResponse) {
#verifico se i pipeline trovati per il progetto corrente hanno status "success"
if ($item.status.Equals("success")) {
WriteLogOutput $logFile 2 "Pipeline: $($item.web_url) - Status: $($item.status)"
$pipelineSuccessCount = $pipelineSuccessCount + 1
}
#i pipeline che non hanno status "success" vengono loggati con relativo errore
else {
WriteLogOutput $logFile 1 "Pipeline: $($item.web_url) - Status: $($item.status)"
$pipelineErrorsCount = $pipelineErrorsCount + 1
}
}
$projectsWithPipeline = $projectsWithPipeline + 1
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
#somma di pipelineSuccess e pipelineErrors
$pipelineCount = $pipelineSuccessCount + $pipelineErrorsCount
#percentuale di pipelineSuccess sul totale
$pipelineSuccessPercentage = [math]::Round(($pipelineSuccessCount / $pipelineCount) * 100, 1)
#percentuale di pipelineErrors sul totale
$pipelineErrorsPercentage = [math]::Round(($pipelineErrorsCount / $pipelineCount) * 100, 1)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#invio a zabbix le metriche rilevate tramite zabbix_sender.exe
WriteLogOutput $logFile 0 ""
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ProjectsWithPipeline -o $projectsWithPipeline
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.TotalPipeline -o $pipelineCount
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.SuccessPipeline -o $pipelineSuccessCount
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ErrorsPipeline -o $pipelineErrorsCount
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.SuccessPipelinePercent -o $pipelineSuccessPercentage
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.ErrorsPipelinePercent -o $pipelineErrorsPercentage
& "C:\Program Files\Zabbix Agent\zabbix_sender.exe" -z zabproxy.ufficio -s "IIS04" -k Gitlab.CheckPipelineDuration -o $durataScript
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "PROGETTI CON PIPELINE ATTIVE: $projectsWithPipeline"
WriteLogOutput $logFile 0 "PIPELINE TROVATE: $pipelineCount"
WriteLogOutput $logFile 0 "PIPELINE RIUSCITE: $pipelineSuccessCount ($pipelineSuccessPercentage%)"
WriteLogOutput $logFile 0 "PIPELINE FALLITE: $pipelineErrorsCount ($pipelineErrorsPercentage%)"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/CheckGitlabProtectedBranches.ps1
+107
View File
@@ -0,0 +1,107 @@
###Gitlab: controllo i branch protetti (e eventualmente toglie la protezione) dai gitlab nembro e azzano###
#Questo script passa in rassegna tutti i progetti esistenti sui gitlab satellite nembro e azzano per verificare la presenza di branch protetti che potrebbero impedire
#il corretto funzionamento dei mirror verso tali repo. Se necessario questo script può anche rimuovere la protezione da tali branch.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 300
#conteggio progetti trovati
$existingProjects = 0
#conteggio progetti trovati
$protectedProjects = 0
#abilita o disabilita la cancellazione della protezione (1=cancella, 0=toca negot)
$deleteProtection = 0
#nome file di log
$logFile = "GitlabProtectedBranches.log"
#specifica quale installazione di gitlab va controllata
#$gitlabIstance = $destinationNembro
#$head = $nembroHead
$gitlabIstance = $destinationAzzano
$head = $azzanoHead
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB PROTECTED_BRANCHES" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB PROTECTED_BRANCHES" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB PROTECTED_BRANCHES" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO PROTECTED_BRANCHES" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
#chiamata api che restituisce informazioni sullo stato dei mirror
$callUrl = "https://" + $gitlabIstance + "/api/v4/projects/" + $projectCount + "/protected_branches"
try {
#parsing della risposta api convertita da json
$Response = Invoke-WebRequest -URI $callUrl -Headers $head -ContentType "application/json" -UseBasicParsing
$parsedResponse = $Response.Content | ConvertFrom-Json
#scrivo il numero del progetto
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
foreach ($item in $parsedResponse) {
WriteLogOutput $logFile 1 "Protected Branch Name: $($item.name) - Allow Force Push: $($item.allow_force_push)"
$protectedProjects = $protectedProjects + 1
if ($deleteProtection -eq 1) {
#nuovo URL x delete
$callUrlDelete = "https://" + $gitlabIstance + "/api/v4/projects/" + $projectCount + "/protected_branches/" + $item.name
#chiamo method DELETE
Invoke-WebRequest -Method Delete -URI $callUrlDelete -Headers $head -ContentType "application/json" -UseBasicParsing
}
}
$existingProjects = $existingProjects + 1
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "PROGETTI ANALIZZATI: $existingProjects"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "PROGETTI CON BRANCH PROTETTI: $protectedProjects"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/GitlabCreateDevelopBranch.ps1
+109
View File
@@ -0,0 +1,109 @@
###Gitlab: creazione branch develop se assente###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno controlla se esiste il branch develop. Se non esiste lo crea.
#Necessario per l'esecuzione dello script che crea i tag perchè tali tag vengono creati sul branch develop.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 200
#nome file di log
$logFile = "GitlabDevelopCreation.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#chiedo all'utente il project ID su cui lavorare
#$projectCount = Read-Host -Prompt 'Project ID per eseguire lo script: '
#chiedo all'utente quante volte devo ciclare sui project ID
#$projectNumber = Read-Host -Prompt 'Contatore dei Project ID su cui lavorare: '
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB DEVELOP CREATION" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB DEVELOP CREATION" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB DEVELOP CREATION" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB DEVELOP CREATION" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
#compongo chiamata api per lavorare sui branch
$branchUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/repository/branches"
try {
$branchesResponse = Invoke-WebRequest -URI $branchUrl -Method GET -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
#controllo se tra i branch esistenti non c'è develop, in tal caso procedo alla creazione
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
#controllo se tra i branch esistenti c'è master
if ($branchesResponse.Content -imatch '{"name":"master",') {
#scrivo il body della chiamata con il nome del branch da creare e il ref di partenza
$branchBody =
@{
branch = "develop";
ref = "master";
}
}
#controllo se tra i branch esistenti c'è main
elseif ($branchesResponse.Content -imatch '{"name":"main",') {
#scrivo il body della chiamata con il nome del branch da creare e il ref di partenza
$branchBody =
@{
branch = "develop";
ref = "main";
}
}
# converto body in json
$branchJSON = $branchBody | ConvertTo-Json
#webrequest che effettua la creazione del branch. Serve url, head per auth, body. specificare metodo POST
$gitResponse = Invoke-WebRequest -URI $branchUrl -Method POST -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing -Body $branchJSON
#parsing della risposta api convertita da json
$parsedResponse = $gitResponse.Content | ConvertFrom-Json
WriteLogOutput $logFile 1 "Branch Esistente: $($branchBody.ref) - Creato Branch: $($parsedResponse.name)"
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/GitlabCreateMissingMirrors.ps1
+111
View File
@@ -0,0 +1,111 @@
###Gitlab: creazione 4 mirror se assenti###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno controlla se esistono i 4 mirror standard (gitea gogs nembro azzano)
#Se trova che manca uno di questi quattro, viene creato
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 160
#numero massimo di progetti da analizzare
$projectNumber = 200
#nome file di log
$logFile = "GiteaNewMirrors.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#chiedo all'utente il project ID su cui lavorare
#$projectCount = Read-Host -Prompt 'Project ID per eseguire lo script: '
#chiedo all'utente quante volte devo ciclare sui project ID
#$projectNumber = Read-Host -Prompt 'Contatore dei Project ID su cui lavorare: '
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO NUOVI MIRROR" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI NUOVI MIRROR" }
2 { WriteLogOutput $logFile 0 "LOG FULL NUOVI MIRROR" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO NUOVI MIRROR" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
$callUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors"
try {
$gitlabResponse = Invoke-WebRequest -URI $callUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
#$parsedGitlabResponse = $gitlabResponse.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
#ricavo nome del progetto per poter creare mirror
$nameCall = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount
$nameResponse = Invoke-WebRequest -URI $nameCall -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
#parsing del contenuto della risposta da gitlab
$parsedNameResponse = $nameResponse.Content | ConvertFrom-Json
#compongo path con struttura Egalware/NomeProgetto.git
$simplePath = "Egalware/" + $($parsedNameResponse.path) + ".git"
#se la risposta non contiene "gitea" procedo a creare mirror relativo
if ($gitlabResponse.Content -inotmatch "gitea") {
#chiamo funzione per creare mirror verso gitea
FreshMirrorCreation $projectCount $giteaUser $giteaPass $giteaDestination $simplePath
}
#se la risposta non contiene "gogs" procedo a creare mirror relativo
if ($gitlabResponse.Content -inotmatch "gogs") {
#chiamo funzione per creare mirror verso gogs
FreshMirrorCreation $projectCount $gogsUser $gogsPass $gogsDestination $simplePath
}
#se la risposta non contiene "gitlab-nembro" procedo a creare mirror relativo
if ($gitlabResponse.Content -inotmatch "gitlab-nembro") {
#chiamo funzione per creare mirror verso gitlab-nembro
FreshMirrorCreation $projectCount $userName $tokenNembro $destinationNembro $simplePath
}
#se la risposta non contiene "gitlab-azzano" procedo a creare mirror relativo
if ($gitlabResponse.Content -inotmatch "gitlab-azzano") {
#chiamo funzione per creare mirror verso gitlab-azzano
FreshMirrorCreation $projectCount $userName $tokenAzzano $destinationAzzano $simplePath
}
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/GitlabCreateTags.ps1
+97
View File
@@ -0,0 +1,97 @@
###Gitlab: creazione tag su branch develop###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno crea un tag contenente la data odierna nel branch develop.
#(richiede esistenza di branch Develop)
#Viene usato per forzare il trigger di tutti i mirror configurati, senza modificare il progetto.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 200
#nome file di log
$logFile = "GitlabTagCreation.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB TAG CREATION" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB TAG CREATION" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB TAG CREATION" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB TAG CREATION" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#chiedo all'utente il project ID su cui lavorare
#$projectCount = Read-Host -Prompt 'Project ID per eseguire lo script: '
#chiedo all'utente quante volte devo ciclare sui project ID
#$projectNumber = Read-Host -Prompt 'Contatore dei Project ID su cui lavorare: '
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
#compongo chiamata api per lavorare sui tag
$tagsUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/repository/tags"
try {
$date = (Get-Date).toString("yyyy/MM/dd")
#scrivo il body della chiamata con il nome del tag da creare e il ref = develop
$tagBody =
@{
tag_name = "AutoSave_" + $date
ref = "develop";
}
# converto body in json
$tagJSON = $tagBody | ConvertTo-Json
#webrequest che effettua la creazione del tag. Serve url, head per auth, body. specificare metodo POST
$gitResponse = Invoke-WebRequest -URI $tagsUrl -Method POST -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing -Body $tagJSON
#parsing della risposta api convertita da json
$parsedResponse = $gitResponse.Content | ConvertFrom-Json
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
WriteLogOutput $logFile 1 "Nuovo Tag: $($parsedResponse.name)"
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/GitlabEditReposNamespace.ps1
+79
View File
@@ -0,0 +1,79 @@
###Gitlab: modifica dei namespace dei progetti###
#Questo script passa in rassegna tutti i progetti esistenti sui gitlab satellite e per ognuno imposta il namespace a "19", laddove 19 è l'ID di "Egalware"
#L'uso è una tantum, per riscrivere tutti i path con namespace corretti su gitlab nembro e azzano, per poter ricevere correttamente i mirror dal gitlab principale
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti da analizzare
$projectNumber = 200
#nome file di log
$logFile = "EditReposNamespace.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO MODIFICA REPO" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI MODIFICA REPO" }
2 { WriteLogOutput $logFile 0 "LOG FULL MODIFICA REPO" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO MODIFICA REPO" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber. su gitlab nembro e gitlab azzano il namespace 19 è il gruppo egalware
do {
$callGitlabUrl = "https://" + $destinationAzzano + "/api/v4/projects/" + $projectCount + "/transfer?namespace=19"
try {
$gitlabResponse = Invoke-WebRequest -URI $callGitlabUrl -Method PUT -Headers $azzanoHead -ContentType "application/json" -UseBasicParsing
$parsedGitlabResponse = $gitlabResponse.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
WriteLogOutput $logFile 1 "Nuovo path: $($parsedGitlabResponse.path_with_namespace)"
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/GitlabMirroringToGitea.ps1
+124
View File
@@ -0,0 +1,124 @@
###Gitlab: riscrive i mirror verso gitea###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno riscrive il mirror verso gitea (cancella mirror e ricrea)
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 42
#numero massimo di progetti
$projectNumber = 1
#inizializzo variabili vuote
$mirrorId = ""
$mirrorUrl = ""
$body = ""
$jsonBody = ""
#nome file di log
$logFile = "GitlabMirroringGitea.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB MIRRORING" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB MIRRORING" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB MIRRORING" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB MIRRORING" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
#chiamata api che restituisce informazioni sullo stato dei mirror
$callUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors"
try {
#parsing della risposta api convertita da json
$Response = Invoke-WebRequest -URI $callUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedResponse = $Response.Content | ConvertFrom-Json
#scrivo il numero del progetto
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
foreach ($item in $parsedResponse) {
$mirrorUrl = ""
$trunkedPath = ""
#controllo se l'url del mirror contiene gitea
if ($item.url.Contains("gitea")) {
$mirrorDestination = "@gitea.steamware.net"
#salvo id mirror e url mirror
$mirrorId = $($item.id)
$mirrorUrl = $($item.url)
WriteLogOutput $logFile 1 "ID: $mirrorId - URL: $mirrorUrl"
#tronco url fino a ".net"
$splitUrl = $mirrorUrl -split '.steamware.net/'
$trunkedPath = $splitUrl[1]
#compongo URL per cancellare mirror con ID trovato
$callUrlDeleteMirror = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors/" + $mirrorId
#chiamata api con method delete che cancella mirror con id specificato
Invoke-WebRequest -Method Delete -URI $callUrlDeleteMirror -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
#compongo url da chiamare per creazione nuovo mirror
$callUrlCreateMirror = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors"
#creo url del nuovo mirror con username e pass relativi a gitlab
$newMirror = "https://" + $giteaUser + ":" + $giteaPass + $mirrorDestination + "/" + $trunkedPath
#creo body da convertire in json
$body =
@{
url = $newMirror
enabled = 1
}
#converto body in json prima di passarlo alla chiamata POST
$jsonBody = ConvertTo-Json -InputObject $body
#chiamata api POST che crea mirror con url e body specificati
$rebuildResponse = Invoke-WebRequest -Method Post -URI $callUrlCreateMirror -Headers $gitlabHead -ContentType "application/json" -Body $jsonBody -UseBasicParsing
$parsedRebuild = $rebuildResponse.Content | ConvertFrom-Json
foreach ($item in $parsedRebuild) {
$mirrorId = $($item.id)
$mirrorUrl = $($item.url)
}
WriteLogOutput $logFile 1 "NEW ID: $mirrorId - URL: $mirrorUrl - Mirror ricostruito con successo"
}
}
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/GitlabRenewTokensMirrors.ps1
+140
View File
@@ -0,0 +1,140 @@
###Gitlab: Rinnovamento mirrors esistenti###
#Questo script viene utilizzato per cancellare e ricreare i mirror esistenti verso gitlab-nembro e gitlab-azzano. Da usare allo scadere dei token di autenticazione.
#Una volta inseriti i token nuovi nel file ApiScriptConfig, facendo girare questo script tutti i mirror verso nembro e azzano sono ricreati con il token nuovo.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 1
#numero massimo di progetti
$projectNumber = 200
#inizializzo variabili vuote
$mirrorId = ""
$mirrorUrl = ""
$body = ""
$jsonBody = ""
#nome file di log
$logFile = "GitlabRebuildMirroring.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITLAB MIRRORING" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITLAB MIRRORING" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITLAB MIRRORING" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITLAB MIRRORING" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
#chiamata api che restituisce informazioni sullo stato dei mirror
$callUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors"
try {
#parsing della risposta api convertita da json
$Response = Invoke-WebRequest -URI $callUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedResponse = $Response.Content | ConvertFrom-Json
#scrivo il numero del progetto
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
foreach ($item in $parsedResponse) {
$doExecute = "false"
$destinationToken = ""
$mirrorUrl = ""
$mirrorId = ""
#controllo se l'url del mirror contiene azzano
if ($item.url.Contains("azzano")) {
$doExecute = "true"
$destinationToken = $tokenAzzano
$mirrorDestination = "@gitlab-azzano.steamware.net"
}
#controllo se l'url del mirror contiene nembro
elseif ($item.url.Contains("nembro")) {
$doExecute = "true"
$destinationToken = $tokenNembro
$mirrorDestination = "@gitlab-nembro.steamware.net"
}
#verifico se devo effettuare cancellazione e creazione nuovo mirror
if ($doExecute -eq "true") {
#salvo id mirror e url mirror
$mirrorId = $($item.id)
$mirrorUrl = $($item.url)
#chiamata per rilevare path del repo
$nameCall = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount
$nameResponse = Invoke-WebRequest -URI $nameCall -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
#parsing del contenuto della risposta da gitlab
$parsedNameResponse = $nameResponse.Content | ConvertFrom-Json
$simplePath = "Egalware/" + $($parsedNameResponse.path) + ".git"
#compongo URL per cancellare mirror con ID trovato
$callUrlDeleteMirror = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors/" + $mirrorId
#chiamata api con method delete che cancella mirror con id specificato
Invoke-WebRequest -Method Delete -URI $callUrlDeleteMirror -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
#compongo url da chiamare per creazione nuovo mirror
$callUrlCreateMirror = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount + "/remote_mirrors"
#creo url del nuovo mirror con username e token relativi a gitlab
$newMirror = "https://" + $userName + ":" + $destinationToken + $mirrorDestination + "/" + $simplePath
#creo body da convertire in json
$body =
@{
url = $newMirror
enabled = 1
}
#converto body in json prima di passarlo alla chiamata POST
$jsonBody = ConvertTo-Json -InputObject $body
#chiamata api POST che crea mirror con url e body specificati
$rebuildResponse = Invoke-WebRequest -Method Post -URI $callUrlCreateMirror -Headers $gitlabHead -ContentType "application/json" -Body $jsonBody -UseBasicParsing
$parsedRebuild = $rebuildResponse.Content | ConvertFrom-Json
foreach ($item in $parsedRebuild) {
$mirrorId = $($item.id)
$mirrorUrl = $($item.url)
}
WriteLogOutput $logFile 1 "NEW ID: $mirrorId - URL: $mirrorUrl - Mirror ricostruito con successo"
}
}
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/ReposCreationAzzanoNembro.ps1
+99
View File
@@ -0,0 +1,99 @@
###Gitlab: Creazione repository su azzano e nembro###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno crea un repository con indirizzo semplice /egalware/nomeProgetto.git
#su gitlab azzano e gitlab nembro. Serve a creare i contenitori "vuoti" verso cui poi va creato il mirror da gitlab aziendale.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 150
#numero massimo di progetti da analizzare (messo a 1 per "sicura inserita" siccome questo script è potenzialmente pericoloso)
$projectNumber = 200
#nome file di log
$logFile = "AzzanoNembroReposCreation.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO CREAZIONE REPO" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI CREAZIONE REPO" }
2 { WriteLogOutput $logFile 0 "LOG FULL CREAZIONE REPO" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO CREAZIONE REPO" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
$callGitlabUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount
try {
$gitlabResponse = Invoke-WebRequest -URI $callGitlabUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedGitlabResponse = $gitlabResponse.Content | ConvertFrom-Json
#dichiaro un body da convertire in JSON con il nome del repo da creare
$body =
@{
name = $($parsedGitlabResponse.path);
#name = $($parsedGitlabResponse.name);
namespace_id = 19
#(namespace_id 19 è Egalware)
}
# Converting my hash to json format
$bodyJSON = $body | ConvertTo-Json
#chiamata per nembro
$callNembroUrl = "https://gitlab-nembro.steamware.net/api/v4/projects/"
$nembroResponse = Invoke-WebRequest -URI $callNembroUrl -Method POST -Headers $nembroHead -ContentType "application/json" -Body $bodyJSON
$parsedNembroResponse = $nembroResponse.Content | ConvertFrom-Json
#chiamata per azzano
$callAzzanoUrl = "https://gitlab-azzano.steamware.net/api/v4/projects/"
$azzanoResponse = Invoke-WebRequest -URI $callAzzanoUrl -Method POST -Headers $azzanoHead -ContentType "application/json" -Body $bodyJSON
$parsedAzzanoResponse = $azzanoResponse.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
WriteLogOutput $logFile 1 "Gitlab Project Name: $($parsedGitlabResponse.path)"
WriteLogOutput $logFile 1 "Progetto creato su gitlab-nembro: $($parsedNembroResponse.path_with_namespace)"
WriteLogOutput $logFile 1 "Progetto creato su gitlab-azzano: $($parsedAzzanoResponse.path_with_namespace)"
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/ReposCreationGitea.ps1
+108
View File
@@ -0,0 +1,108 @@
###Gitlab: Creazione repository su gitea###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno crea un repository con indirizzo semplice /egalware/nomeProgetto.git su gitea.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 150
#numero massimo di progetti da analizzare
$projectNumber = 200
#nome file di log
$logFile = "GiteaReposCreation.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#chiedo all'utente il project ID su cui lavorare
#$projectCount = Read-Host -Prompt 'Project ID per eseguire lo script: '
#chiedo all'utente quante volte devo ciclare sui project ID
#$projectNumber = Read-Host -Prompt 'Contatore dei Project ID su cui lavorare: '
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GITEA" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GITEA" }
2 { WriteLogOutput $logFile 0 "LOG FULL GITEA" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GITEA" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
$callGitlabUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount
try {
$gitlabResponse = Invoke-WebRequest -URI $callGitlabUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedGitlabResponse = $gitlabResponse.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
foreach ($gitlabItem in $parsedGitlabResponse) {
WriteLogOutput $logFile 1 "Gitlab Project Name: $($gitlabItem.name)"
$callGiteaUrl = "https://gitea.steamware.net/api/v1/orgs/Egalware/repos"
#dichiaro un body da convertire in JSON con il nome del repo da creare (prendo path o name a seconda delle necessità)
$giteaBody =
@{
name = $($gitlabItem.path);
#name = $($gitlabItem.name);
}
# Converting my hash to json format
$GiteaJSON = $giteaBody | ConvertTo-Json
try {
$giteaResponse = Invoke-WebRequest -URI $callGiteaUrl -Method POST -Headers $giteaHead -ContentType "application/json" -Body $GiteaJSON
$parsedGiteaResponse = $giteaResponse.Content | ConvertFrom-Json
foreach ($giteaItem in $parsedGiteaResponse) {
WriteLogOutput $logFile 1 "Gitea New Project Name: $($giteaItem.name)"
WriteLogOutput $logFile 1 "Status: $($giteaResponse.StatusDescription)"
WriteLogOutput $logFile 1 "When: $($giteaItem.created_at)"
}
}
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 $($parsedError.message)
}
}
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
ApiGit/ReposCreationGogs.ps1
+106
View File
@@ -0,0 +1,106 @@
###Gitlab: Creazione repository su gitea###
#Questo script passa in rassegna tutti i progetti esistenti sul gitlab aziendale e per ognuno crea un repository con indirizzo semplice /egalware/nomeProgetto.git su gogs.
#importo file contenente configurazioni
. .\ApiGit\ApiGitResources\ApiScriptsConfig.ps1
#importo file contenente funzioni
. .\ApiGit\ApiGitResources\ApiScriptsFunctions.ps1
#rilevo time per log inizio analisi
$startTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
# avvio stopwatch
$mainStopWatch = [system.diagnostics.stopwatch]::StartNew()
#contatore ciclo do while
$projectCount = 150
#numero massimo di progetti da analizzare
$projectNumber = 200
#nome file di log
$logFile = "GogsReposCreation.log"
#creazione folder di Log se non già esistente
if (Test-Path $logFolder) {
}
else {
New-Item $logFolder -ItemType Directory
}
#chiedo all'utente il project ID su cui lavorare
#$projectCount = Read-Host -Prompt 'Project ID per eseguire lo script: '
#chiedo all'utente quante volte devo ciclare sui project ID
#$projectNumber = Read-Host -Prompt 'Contatore dei Project ID su cui lavorare: '
#scrivo intestazione e inizio analisi
WriteLogOutput $logFile 0 "--------------------"
Switch ($logLevel) {
0 { WriteLogOutput $logFile 0 "LOG SINTETICO GOGS" }
1 { WriteLogOutput $logFile 0 "LOG ERRORI GOGS" }
2 { WriteLogOutput $logFile 0 "LOG FULL GOGS" }
3 { WriteLogOutput $logFile 0 "LOG AMPOLLOSO GOGS" }
}
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Percorso log: $logFolder"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Inizio Esecuzione Script: $startTime"
#ciclo principale do/while che cicla da 1 a N projectNumber
do {
$callGitlabUrl = "https://gitlab.steamware.net/api/v4/projects/" + $projectCount
try {
$gitlabResponse = Invoke-WebRequest -URI $callGitlabUrl -Headers $gitlabHead -ContentType "application/json" -UseBasicParsing
$parsedGitlabResponse = $gitlabResponse.Content | ConvertFrom-Json
#scrivo il numero del progetto nel terminale e su file
WriteLogOutput $logFile 1 ""
WriteLogOutput $logFile 1 "--------------------"
WriteLogOutput $logFile 1 "**PROGETTO $projectCount**"
foreach ($gitlabItem in $parsedGitlabResponse) {
WriteLogOutput $logFile 1 "Gitlab Project Name: $($gitlabItem.name)"
$callGogsUrl = "https://gogs.steamware.net/api/v1/admin/users/Egalware/repos"
#dichiaro un body da convertire in JSON con il nome del repo da creare
$gogsBody =
@{
name = $($gitlabItem.path);
#name = $($gitlabItem.name);
}
# Converting my hash to json format
$gogsJSON = $gogsBody | ConvertTo-Json
try {
$gogsResponse = Invoke-WebRequest -URI $callGogsUrl -Method POST -Headers $gogsHead -ContentType "application/json" -Body $gogsJSON
$parsedGogsResponse = $GogsResponse.Content | ConvertFrom-Json
foreach ($GogsItem in $parsedGogsResponse) {
WriteLogOutput $logFile 1 "Gogs New Project Name: $($gogsItem.name)"
}
}
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 $($parsedError.message)
}
}
}
#scrivo se trovo un errore durante il try/catch
catch {
$parsedError = $_ | ConvertFrom-Json
WriteLogOutput $logFile 3 ""
WriteLogOutput $logFile 3 "--------------------"
WriteLogOutput $logFile 3 "**ERRORE NEL PROGETTO $projectCount**"
WriteLogOutput $logFile 3 $($parsedError.message)
}
$projectCount = $projectCount + 1
}
#fine ciclo principale
while ($projectCount -le $projectNumber)
# fermo stopwatch e calcolo durata script
$mainStopWatch.Stop()
$durataScript = $mainStopWatch.Elapsed.TotalSeconds
#rilevo time per log fine analisi
$endTime = (Get-Date).toString("yyyy/MM/dd HH:mm:ss")
#scrivo a video le statistiche
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Fine Esecuzione Script: $endTime"
WriteLogOutput $logFile 0 ""
WriteLogOutput $logFile 0 "Durata Esecuzione Script: $durataScript secondi"
WriteLogOutput $logFile 0 ""
EgtDeploy/CLI/EgtBeamWallTest.ps1
+175
View File
@@ -0,0 +1,175 @@
### Esegue setup di BeamWall da repo Artifacts ###
#inizializzo variabili vuote
$ChosenBit = ""
$ChosenDll = ""
$ChosenDllD = ""
$SelBranch = ""
$SelArch = ""
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
#Definisco path test sottocartelle EgtBEAMWALL
$TestProgBWFolder = 'c:\EgtTestProg\EgtBEAMWALL'
$TestDataBWFolder = 'c:\EgtTestData\EgtBEAMWALL'
#Chiedo all'utente che branch desidera installare
function Show-MenuA
{
param (
[string]$Title = 'Seleziona Branch BeamWall'
)
Clear-Host
Write-Host ""
Write-Host "============= $Title ============="
Write-Host ""
Write-Host "1: Premi '1' per branch Develop"
Write-Host "2: Premi '2' per branch Master"
Write-Host "q: Premi 'q' tornare al menù principale"
Write-Host ""
}
Show-MenuA
#Salvo la selezione dell'utente
$MachineSelect = Read-Host 'Seleziona Branch BeamWall'
switch ($MachineSelect)
{
'1' {
$SelBranch = 'develop'
}
'2' {
$SelBranch = 'master'
}
'q' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
}
}
#Chiedo all'utente se vuole 32 bit o 64 bit
function Show-MenuB
{
param (
[string]$Title = 'Seleziona architettura BeamWall'
)
Clear-Host
Write-Host ""
Write-Host "============= $Title ============="
Write-Host ""
Write-Host "1: Premi '1' per x86"
Write-Host "2: Premi '2' per x64"
Write-Host "q: Premi 'q' tornare al menù principale"
Write-Host ""
}
Show-MenuB
#Salvo la selezione dell'utente 32 bit o 64 bit
$BitSelect = Read-Host "Seleziona architettura BeamWall"
switch ($BitSelect)
{
'1' {
$SelArch = 'x86'
}
'2' {
$SelArch = 'x64'
}
'q' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
}
}
#Switch fra 32 bit o 64 bit in base alla richiesta dell'utente
if($SelArch -eq 'x86'){
$ChosenBit = '32'
$ChosenDll = 'Dll32'
$ChosenDllD = 'DllD32'
}
else {
$ChosenBit = '64'
$ChosenDll = 'Dll64'
$ChosenDllD = 'DllD64'
}
Write-Output ""
Write-Output "Installing Test EgtBeamWall. Branch: $SelBranch Architecture: $ChosenBit bit"
Write-Output ""
Start-Sleep -seconds 5
#Pulisco cartella EgtTestProg\EgtBEAMWALL se già esistente, poi la creo
if (Test-Path -Path $TestProgBWFolder) {
"Prog esiste!"
Remove-Item -Recurse $TestProgBWFolder\*.*
} else {
new-item $TestProgBWFolder -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder) {
"Data esiste!"
Remove-Item -Recurse $TestDataBWFolder\*.*
} else {
new-item $TestDataBWFolder -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Temp se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Temp) {
"Temp esiste!"
Remove-Item -Recurse $TestDataBWFolder\Temp\*.*
} else {
new-item $TestDataBWFolder\Temp -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Macro se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Macro) {
"Macro esiste!"
Remove-Item -Recurse $TestDataBWFolder\Macro\*.*
} else {
new-item $TestDataBWFolder\Macro -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Config se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Config) {
"Config esiste!"
Remove-Item -Recurse $TestDataBWFolder\Config\*.*
} else {
new-item $TestDataBWFolder\Config -itemtype directory
}
#Copio la cartella Config
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL_Config\Config\ $TestDataBWFolder\Config
#Copio la cartella Messages
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\Messages $TestDataBWFolder\Config
#Copio la cartella Fonts
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\Fonts\ $TestDataBWFolder\Fonts
#Copio DataRoot.ini custom in c:\EgtTestProg\EgtBEAMWALL
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL_Config\ $TestProgBWFolder DataRoot.ini
#Copio il file Medium.ini in \Warehouse
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\EgtBEAMWALL\Warehouse\ $TestDataBWFolder\Warehouse Medium.ini
#Copio Resources
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\EgtBEAMWALL\Resources\ $TestDataBWFolder\Resources
#Copio la sottocartella 32 o 64 bit di Lualibs a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\LuaLibs\$ChosenBit $TestDataBWFolder\Lualibs
#Copio la cartella Dll32 o Dll64 a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\$ChosenDll $TestProgBWFolder
#Copio la cartella DllD32 o DllD64 a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\$ChosenDllD $TestProgBWFolder
#Copio Versione + Architettura di BEAMWALL richieste
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL\$SelBranch\$SelArch $TestProgBWFolder
#Cancello tutti i .exe.config e .dll.config perchè problematici in area Test
Remove-Item -Recurse $TestProgBWFolder\*.exe.config
Remove-Item -Recurse $TestProgBWFolder\*.dll.config
#Chiudo lanciando lo Script Manager per altre operazioni
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
EgtDeploy/CLI/EgtCAM5Test.ps1
+118
View File
@@ -0,0 +1,118 @@
### Esegue setup di EgtCAM5 da repo Artifacts ###
#inizializzo variabili vuote
$BitSelect = ""
$BitChoice = ""
$ChosenBit = ""
$ChosenDll = ""
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
$SrvEgtTech = '\\truenas\Artifacts\EGT_SRV\EgtTech'
#Definisco path test cartelle Egt
$TestProgFolder = 'c:\EgtTestProg'
$TestDataFolder = 'c:\EgtTestData'
#Definisco path test sottocartelle EgtCAM5
$TestProgCam5Folder = 'c:\EgtTestProg\EgtCAM5'
$TestDataCam5Folder = 'c:\EgtTestData\EgtCAM5'
#Chiedo all'utente se vuole 32 bit o 64 bit
function Show-MenuA
{
param (
[string]$Title = 'Seleziona architettura EgtCAM5'
)
Clear-Host
Write-Host ""
Write-Host "============= $Title ============="
Write-Host ""
Write-Host "1: Premi '1' per x86"
Write-Host "2: Premi '2' per x64"
Write-Host "q: Premi 'q' tornare al menù principale"
Write-Host ""
}
Show-MenuA
#Salvo la selezione dell'utente 32 bit o 64 bit
$BitSelect = Read-Host "Seleziona architettura EgTCAM5"
switch ($BitSelect)
{
'1' {
$BitChoice = 'x86'
}
'2' {
$BitChoice = 'x64'
}
'q' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
}
}
if($BitChoice -eq 'x86'){
$ChosenBit = '32'
$ChosenDll = 'Dll32'
}
else {
$ChosenBit = '64'
$ChosenDll = 'Dll64'
}
Write-Output ""
Write-Output "Installing Test EgtCAM5 Architecture: $ChosenBit bit"
Write-Output ""
Start-Sleep -seconds 5
#Pulisco cartella c:\EgtTestProg\EgtCAM5 se già esistente, poi la creo
if (Test-Path -Path $TestProgCam5Folder) {
"EgtTestProg\EgtCAM5 esiste!"
Remove-Item -Recurse $TestProgCam5Folder\*.*
} else {
new-item $TestProgCam5Folder -itemtype directory
}
#Pulisco cartella c:\EgtTestData\EgtCAM5 se già esistente, poi la creo
if (Test-Path -Path $TestDataCam5Folder) {
"EgtTestData\EgtCAM5 esiste!"
Remove-Item -Recurse $TestDataCam5Folder\*.*
} else {
new-item $TestDataCam5Folder -itemtype directory
}
#Copio la cartella EgtCAM5
ROBOCOPY /E $SrvEgtTech\EgtProg\EgtCAM5\ $TestProgCam5Folder
#Copio la cartella Dll desiderata
ROBOCOPY /E $SrvEgtTech\EgtProg\$ChosenDll\ $TestProgCam5Folder
#Copio EgtCAM5.ini custom in C:\EgtTestProg\EgtCAM5\Config
ROBOCOPY /E $Artifacts\EgtProg\EgtCAM5\Config\ $TestDataCam5Folder\Config EgtCAM5.ini
#Copio DataRoot.ini custom in C:\EgtTestProg\EgtCAM5
ROBOCOPY /E $Artifacts\EgtProg\EgtCAM5\Config\ $TestProgCam5Folder DataRoot.ini
#Copio la cartella Lualibs
ROBOCOPY /E $SrvEgtTech\EgtProg\LuaLibs\ $TestProgFolder\LuaLibs
#Copio la cartella Fonts
ROBOCOPY /E $SrvEgtTech\EgtProg\Fonts\ $TestProgFolder\Fonts
#Copio la cartella Messages
ROBOCOPY /E $SrvEgtTech\EgtData\Messages\ $TestDataFolder\Messages
#Copio cartella 3dPrinting
ROBOCOPY /E $Artifacts\EgtData\3dPrinting\$ChosenBit\ $TestDataCam5Folder\3dPrinting
#Copio cartella Beam
ROBOCOPY /E $Artifacts\EgtData\Beam\$ChosenBit\ $TestDataCam5Folder\Beam
#Copio cartella Wall
ROBOCOPY /E $Artifacts\EgtData\Wall\$ChosenBit\ $TestDataCam5Folder\Wall
#Copio cartella BeamWall
ROBOCOPY /E $Artifacts\EgtData\BeamWall\$ChosenBit\ $TestDataCam5Folder\BeamWall
#Chiudo lanciando lo Script Manager per altre operazioni
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
EgtDeploy/CLI/EgtScriptsManager.ps1
+42
View File
@@ -0,0 +1,42 @@
### TESTER SCRIPTS MANAGER ###
#inizializzo variabili vuote
$ScriptSelect=""
#Chiedo all'utente quale script eseguire
function Show-MenuA
{
param (
[string]$Title = 'Seleziona Operazione Desiderata'
)
Clear-Host
Write-Host ""
Write-Host "============== $Title =============="
Write-Host ""
Write-Host "1: Premi '1' per installare EgtCAM5 Test"
Write-Host "2: Premi '2' per installare EgtBEAMWALL Test"
Write-Host "3: Premi '3' per eseguire Machines Grabber"
Write-Host "q: Premi 'q' per uscire dal programma."
Write-Host ""
}
Show-MenuA
#Salvo la selezione dell'utente
$ScriptSelect = Read-Host 'Seleziona Operazione Desiderata'
Write-Host ""
switch ($ScriptSelect)
{
'1' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtCAM5Test.ps1
}
'2' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtBeamWallTest.ps1
}
'3' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\MachinesGrabber.ps1
}
'q' {
return
}
}
EgtDeploy/CLI/MachinesGrabber.ps1
+104
View File
@@ -0,0 +1,104 @@
### Copia le macchine desiderate da Artifacts alla cartella desiderata ###
#inizializzo variabili vuote
$SelDir=""
$SelMach=""
$FolderType=""
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
#Chiedo all'utente che macchine vuole copiare
function Show-MenuA
{
param (
[string]$Title = 'Seleziona Macchine da copiare'
)
Clear-Host
Write-Host ""
Write-Host "================ $Title ================"
Write-Host "1: Premi '1' per macchine Belotti"
Write-Host "2: Premi '2' per macchine CMS"
Write-Host "3: Premi '3' per macchine Essetre"
Write-Host "4: Premi '4' per macchine Multiax"
Write-Host "5: Premi '5' per macchine Omag"
Write-Host "q: Premi 'q' tornare al menù principale"
Write-Host ""
}
Show-MenuA
#Salvo la selezione dell'utente
$MachineSelect = Read-Host 'Seleziona Macchine da copiare'
switch ($MachineSelect)
{
'1' {
$SelMach = 'Belotti'
}
'2' {
$SelMach = 'CMS'
}
'3' {
$SelMach = 'Essetre'
}
'4' {
$SelMach = 'Multiax'
}
'5' {
$SelMach = 'Omag'
}
'q' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
}
}
#Chiedo all'utente in che directory copiare
function Show-MenuB
{
param (
[string]$Title = 'Seleziona directory di destinazione'
)
Clear-Host
Write-Host "================ $Title ================"
Write-Host ""
Write-Host "1: Premi '1' per directory TEST - C:\EgtTestData\EgtCAM5\Machines"
Write-Host "2: Premi '2' per directory STABLE - C:\ProgramData\EgalTech\EgtCAM5\Machines"
Write-Host "q: Premi 'q' per uscire dal programma."
Write-Host ""
}
Show-MenuB
#Salvo la selezione dell'utente
$DirectorySelect = Read-Host 'Seleziona directory di destinazione'
switch ($DirectorySelect)
{
'1' {
$SelDir = 'C:\EgtTestData\EgtCAM5\Machines'
$FolderType = 'Test'
}
'2' {
$SelDir = 'C:\ProgramData\EgalTech\EgtCAM5\Machines'
$FolderType = 'Stable'
}
'q' {
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
}
}
Write-Output ""
Write-Output "Copying machines $SelMach in folder $FolderType"
Write-Output ""
Start-Sleep -seconds 5
#Cerco le cartelle delle macchine richieste
$MachinesList = Get-ChildItem -Path $Artifacts\EGT_SRV\EgtTech\EgtData\Machines\ -Directory | Select-String -Pattern $SelMach
#Per ogni macchina richiesta trovata procedo a copiarla in EgtTestData\EgtCAM5\Machines
foreach($Machine in $MachinesList)
{
ROBOCOPY $Artifacts\EGT_SRV\EgtTech\EgtData\Machines\$Machine $SelDir\$Machine /MIR /FFT
}
#Chiudo lanciando lo Script Manager per altre operazioni
Powershell.exe -executionpolicy remotesigned -File .\CLI\EgtScriptsManager.ps1
EgtDeploy/Deploy certificati/.gitkeep
View File
EgtDeploy/Deploy certificati/ImportCertifcate.ps1
+5
View File
@@ -0,0 +1,5 @@
$client = new-object System.Net.WebClient
$client.DownloadFile("http://mapocrt.egalware.com:8085/maposrv.pfx","C:\Windows\Temp\maposrv.pfx")
$secureString = convertto-securestring "viadante16" -asplaintext -force
Import-PfxCertificate -FilePath C:\Windows\Temp\maposrv.pfx -CertStoreLocation Cert:\LocalMachine\My -Password $secureString
EgtDeploy/GUI/EgtBeamWallTestGUI.ps1
+262
View File
@@ -0,0 +1,262 @@
### GRAPHIC USER INTERFACE PER TEST BeamWall ###
#Caricamento classi di .NET Framework
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
Add-Type -AssemblyName PresentationFramework
#inizializzo variabili vuote
$ChosenBit = ""
$ChosenDll = ""
$ChosenDllD = ""
$SelBranch = ""
$SelArch = ""
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
#Definisco path test sottocartelle EgtBEAMWALL
$TestProgBWFolder = 'c:\EgtTestProg\EgtBEAMWALL'
$TestDataBWFolder = 'c:\EgtTestData\EgtBEAMWALL'
#numero di copie da effettuare
$CopyCount = 11
#assegno il range di valori min max della barra di progresso in base al numero delle macchine trovate
$MinMax = 0..$CopyCount | Measure-Object -Minimum -Maximum
function ProgressBarAndPercentageLabel{
# avanti uno step nella progress bar
$CopyProgressBar.PerformStep()
# calcolo il progresso in %
$ProgressFactor = ($CopyProgressBar.Value/$CopyProgressBar.Maximum)*100
$RoundedPercentage = [math]::Round($ProgressFactor)
#scrivo nel label dedicato la percentuale di avanzamento e faccio refresh progressbar
$PercentageLabel.Text = "$RoundedPercentage %"
$CopyProgressBar.Refresh()
}
#Definisco funzione che pulisce il contenuto delle cartelle prima di copiare i file da Truenas
function ClearFolders($TestProgBWFolder, $TestDataBWFolder){
#Pulisco cartella EgtTestProg\EgtBEAMWALL se già esistente, poi la creo
if (Test-Path -Path $TestProgBWFolder) {
"Prog esiste!"
Remove-Item -Recurse $TestProgBWFolder\*.*
} else {
new-item $TestProgBWFolder -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder) {
"Data esiste!"
Remove-Item -Recurse $TestDataBWFolder\*.*
} else {
new-item $TestDataBWFolder -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Temp se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Temp) {
"Temp esiste!"
Remove-Item -Recurse $TestDataBWFolder\Temp\*.*
} else {
new-item $TestDataBWFolder\Temp -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Macro se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Macro) {
"Macro esiste!"
Remove-Item -Recurse $TestDataBWFolder\Macro\*.*
} else {
new-item $TestDataBWFolder\Macro -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Config se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Config) {
"Config esiste!"
Remove-Item -Recurse $TestDataBWFolder\Config\*.*
} else {
new-item $TestDataBWFolder\Config -itemtype directory
}
}
#Definisco funzione che installa il beamwall richiesto, gli passo i parametri per l'architettura e il branch desiderato
function InstallRequiredBeamWall($ChosenBit, $ChosenDll, $ChosenDllD, $SelBranch, $SelArch){
#Copio la cartella Config
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL_Config\Config\ $TestDataBWFolder\Config
ProgressBarAndPercentageLabel
#Copio la cartella Messages
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\Messages $TestDataBWFolder\Config
ProgressBarAndPercentageLabel
#Copio la cartella Fonts
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\Fonts\ $TestDataBWFolder\Fonts
ProgressBarAndPercentageLabel
#Copio DataRoot.ini custom in c:\EgtTestProg\EgtBEAMWALL
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL_Config\ $TestProgBWFolder DataRoot.ini
ProgressBarAndPercentageLabel
#Copio il file Medium.ini in \Warehouse
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\EgtBEAMWALL\Warehouse\ $TestDataBWFolder\Warehouse Medium.ini
ProgressBarAndPercentageLabel
#Copio Resources
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\EgtBEAMWALL\Resources\ $TestDataBWFolder\Resources
ProgressBarAndPercentageLabel
#Copio la sottocartella 32 o 64 bit di Lualibs a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\LuaLibs\$ChosenBit $TestDataBWFolder\Lualibs
ProgressBarAndPercentageLabel
#Copio la cartella Dll32 o Dll64 a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\$ChosenDll $TestProgBWFolder
ProgressBarAndPercentageLabel
#Copio la cartella DllD32 o DllD64 a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\$ChosenDllD $TestProgBWFolder
ProgressBarAndPercentageLabel
#Copio Versione + Architettura di BEAMWALL richieste
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL\$SelBranch\$SelArch $TestProgBWFolder
ProgressBarAndPercentageLabel
#Cancello tutti i .exe.config e .dll.config perchè problematici in area Test
Remove-Item -Recurse $TestProgBWFolder\*.exe.config
Remove-Item -Recurse $TestProgBWFolder\*.dll.config
ProgressBarAndPercentageLabel
}
#Definisco una finestra in cui è possibile aggiungere controlli.
$BWForm = New-Object System.Windows.Forms.Form
$BWForm.Text = 'BeamWall Tester'
$BWForm.Size = New-Object System.Drawing.Size(400,420)
$BWForm.StartPosition = 'CenterScreen'
#Definisco una groupbox per la scelta dell'architettura
$ArchGroupBox = New-Object System.Windows.Forms.GroupBox
$ArchGroupBox.Location = New-Object System.Drawing.Size(20,20)
$ArchGroupBox.size = New-Object System.Drawing.Size(340,80)
$ArchGroupBox.text = "Seleziona architettura BeamWall da testare:"
$BWForm.Controls.Add($ArchGroupBox)
#Definisco il bottone per selezionare architettura x86
$x86Button = New-Object System.Windows.Forms.RadioButton
$x86Button.Location = New-Object System.Drawing.Point(20,20)
$x86Button.Size = New-Object System.Drawing.Size(100,23)
$x86Button.Text = 'x86'
$x86Button.Checked = $true
$BWForm.Controls.Add($x86Button)
$ArchGroupBox.Controls.Add($x86Button)
#Definisco il bottone per selezionare architettura x64
$x64Button = New-Object System.Windows.Forms.RadioButton
$x64Button.Location = New-Object System.Drawing.Point(20,40)
$x64Button.Size = New-Object System.Drawing.Size(100,23)
$x64Button.Text = 'x64'
$BWForm.Controls.Add($x64Button)
$ArchGroupBox.Controls.Add($x64Button)
#Definisco una groupbox per la scelta del branch
$BranchGroupBox = New-Object System.Windows.Forms.GroupBox
$BranchGroupBox.Location = New-Object System.Drawing.Size(20,120)
$BranchGroupBox.size = New-Object System.Drawing.Size(340,80)
$BranchGroupBox.text = "Seleziona branch BeamWall da testare:"
$BWForm.Controls.Add($BranchGroupBox)
#Definisco il bottone per selezionare develop
$DevelopButton = New-Object System.Windows.Forms.RadioButton
$DevelopButton.Location = New-Object System.Drawing.Point(20,20)
$DevelopButton.Size = New-Object System.Drawing.Size(100,23)
$DevelopButton.Text = 'Develop'
$DevelopButton.Checked = $true
$BWForm.Controls.Add($DevelopButton)
$BranchGroupBox.Controls.Add($DevelopButton)
#Definisco il bottone per selezionare master
$MasterButton = New-Object System.Windows.Forms.RadioButton
$MasterButton.Location = New-Object System.Drawing.Point(20,40)
$MasterButton.Size = New-Object System.Drawing.Size(100,23)
$MasterButton.Text = 'Master'
$BWForm.Controls.Add($MasterButton)
$BranchGroupBox.Controls.Add($MasterButton)
#Definisco un label per mostrare l'avanzamento dell'operazione in corso
$PercentageLabel = New-Object System.Windows.Forms.Label
$PercentageLabel.Location = New-Object System.Drawing.Point(180,220)
$PercentageLabel.Size = New-Object System.Drawing.Size(280,20)
$PercentageLabel.Text = ""
$PercentageLabel.Visible = $True
$BWForm.Controls.Add($PercentageLabel)
#Definisco la barra di avanzamento per mostrare il progresso della copia
$CopyProgressBar = New-Object System.Windows.Forms.ProgressBar
$CopyProgressBar.Width = 340
$CopyProgressBar.Height = 20
$CopyProgressBar.Location = New-Object System.Drawing.Point(20,240)
#assegno i valori minimi e massimi della barra progresso in base al range definito precedentemente
$CopyProgressBar.Minimum = $MinMax.Minimum
$CopyProgressBar.Maximum = $MinMax.Maximum
#inizializzo il value della progress bar al minimo
$CopyProgressBar.Value = $MinMax.Minimum
#definisco lo step della progress bar a 1 (1 step=1 cartella copiata)
$CopyProgressBar.Step = 1
$CopyProgressBar.Style = 'Continuous'
$CopyProgressBar.Visible = $True
$BWForm.Controls.Add($CopyProgressBar)
#Definisco il bottone per lanciare installazione di BEAMWALL
$InstallBWButton = New-Object System.Windows.Forms.Button
$InstallBWButton.Location = New-Object System.Drawing.Point(20,280)
$InstallBWButton.Size = New-Object System.Drawing.Size(120,23)
$InstallBWButton.Text = 'Installa BeamWall'
$InstallBWButton.Add_Click({
if ($x86Button.Checked -eq $true) {
$ChosenBit = '32'
$ChosenDll = 'Dll32'
$ChosenDllD = 'DllD32'
$SelArch = 'x86'
}
if ($x64Button.Checked -eq $true) {
$ChosenBit = '64'
$ChosenDll = 'Dll64'
$ChosenDllD = 'DllD64'
$SelArch = 'x64'
}
if ($DevelopButton.Checked -eq $true) {
$SelBranch = 'develop'
}
if ($MasterButton.Checked -eq $true) {
$SelBranch = 'master'
}
$UserConfirmation = [System.Windows.MessageBox]::Show("Install BeamWall $SelArch branch $SelBranch ?",'Conferma Installazione','YesNo','Info')
switch ($UserConfirmation){
'Yes' {
ClearFolders $TestProgBWFolder $TestDataBWFolder
InstallRequiredBeamWall $ChosenBit $ChosenDll $ChosenDllD $SelBranch $SelArch
[System.Windows.MessageBox]::Show("Beamwall $SelArch branch $SelBranch installato!",'Operazione terminata')
$BWForm.Close()
$BWForm.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtScriptsGUI.ps1
}
'No' {}
}
})
$BWForm.Controls.Add($InstallBWButton)
#Definisco il bottone per navigazione al menu precedente
$MenuReturn = New-Object System.Windows.Forms.Button
$MenuReturn.Location = New-Object System.Drawing.Point(260,280)
$MenuReturn.Size = New-Object System.Drawing.Size(100,23)
$MenuReturn.Text = 'Torna alla home'
$MenuReturn.Add_Click({
$BWForm.Close()
$BWForm.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtScriptsGUI.ps1
})
$BWForm.Controls.Add($MenuReturn)
#Proprietà Topmost su $true per forzare l'apertura della finestra sopra altre finestre e finestre di dialogo aperte.
$BWForm.Topmost = $true
#Visualizzo il modulo:
$BWForm.ShowDialog()
EgtDeploy/GUI/EgtCAM5TestGUI.ps1
+211
View File
@@ -0,0 +1,211 @@
### GRAPHIC USER INTERFACE PER TEST EGTCAM5 ###
#Caricamento classi di .NET Framework
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
Add-Type -AssemblyName PresentationFramework
#Inizializzo variabili vuote
$BitChoice = ""
$ChosenBit = ""
$ChosenDll = ""
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
$SrvEgtTech = '\\truenas\Artifacts\EGT_SRV\EgtTech'
#Definisco path test cartelle Egt
$TestProgFolder = 'c:\EgtTestProg'
$TestDataFolder = 'c:\EgtTestData'
#Definisco path test sottocartelle EgtCAM5
$TestProgCam5Folder = 'c:\EgtTestProg\EgtCAM5'
$TestDataCam5Folder = 'c:\EgtTestData\EgtCAM5'
#numero di copie da effettuare
$CopyCount = 12
#assegno il range di valori min max della barra di progresso in base al numero delle macchine trovate
$MinMax = 0..$CopyCount | Measure-Object -Minimum -Maximum
function ProgressBarAndPercentageLabel{
# avanti uno step nella progress bar
$CopyProgressBar.PerformStep()
# calcolo il progresso in %
$ProgressFactor = ($CopyProgressBar.Value/$CopyProgressBar.Maximum)*100
$RoundedPercentage = [math]::Round($ProgressFactor)
#scrivo nel label dedicato la percentuale di avanzamento e faccio refresh progressbar
$PercentageLabel.Text = "$RoundedPercentage %"
$CopyProgressBar.Refresh()
}
function ClearFolders($TestProgCam5Folder, $TestDataCam5Folder){
#Pulisco cartella c:\EgtTestProg\EgtCAM5 se già esistente, poi la creo
if (Test-Path -Path $TestProgCam5Folder) {
"EgtTestProg\EgtCAM5 esiste!"
Remove-Item -Recurse $TestProgCam5Folder\*.*
} else {
new-item $TestProgCam5Folder -itemtype directory
}
#Pulisco cartella c:\EgtTestData\EgtCAM5 se già esistente, poi la creo
if (Test-Path -Path $TestDataCam5Folder) {
"EgtTestData\EgtCAM5 esiste!"
Remove-Item -Recurse $TestDataCam5Folder\*.*
} else {
new-item $TestDataCam5Folder -itemtype directory
}
}
#Definisco funzione che installa il CAM5 richiesto, gli passo i parametri per l'architettura desiderata
function InstallRequiredCAM5($BitChoice, $ChosenBit, $ChosenDll){
#Copio la cartella EgtCAM5
ROBOCOPY /E $SrvEgtTech\EgtProg\EgtCAM5\ $TestProgCam5Folder
ProgressBarAndPercentageLabel
#Copio la cartella Dll desiderata
ROBOCOPY /E $SrvEgtTech\EgtProg\$ChosenDll\ $TestProgCam5Folder
ProgressBarAndPercentageLabel
#Copio EgtCAM5.ini custom in C:\EgtTestProg\EgtCAM5\Config
ROBOCOPY /E $Artifacts\EgtProg\EgtCAM5\Config\ $TestDataCam5Folder\Config EgtCAM5.ini
ProgressBarAndPercentageLabel
#Copio DataRoot.ini custom in C:\EgtTestProg\EgtCAM5
ROBOCOPY /E $Artifacts\EgtProg\EgtCAM5\Config\ $TestProgCam5Folder DataRoot.ini
ProgressBarAndPercentageLabel
#Copio la cartella Lualibs
ROBOCOPY /E $SrvEgtTech\EgtProg\LuaLibs\ $TestProgFolder\LuaLibs
ProgressBarAndPercentageLabel
#Copio la cartella Fonts
ROBOCOPY /E $SrvEgtTech\EgtProg\Fonts\ $TestProgFolder\Fonts
ProgressBarAndPercentageLabel
#Copio la cartella Messages
ROBOCOPY /E $SrvEgtTech\EgtData\Messages\ $TestDataFolder\Messages
ProgressBarAndPercentageLabel
#Copio la cartella ToolMakers
ROBOCOPY /E $SrvEgtTech\EgtData\ToolMakers\ $TestDataCam5Folder\ToolMakers
ProgressBarAndPercentageLabel
#Copio cartella 3dPrinting
ROBOCOPY /E $Artifacts\EgtData\3dPrinting\$ChosenBit\ $TestDataCam5Folder\3dPrinting
ProgressBarAndPercentageLabel
#Copio cartella Beam
ROBOCOPY /E $Artifacts\EgtData\Beam\$ChosenBit\ $TestDataCam5Folder\Beam
ProgressBarAndPercentageLabel
#Copio cartella Wall
ROBOCOPY /E $Artifacts\EgtData\Wall\$ChosenBit\ $TestDataCam5Folder\Wall
ProgressBarAndPercentageLabel
#Copio cartella BeamWall
ROBOCOPY /E $Artifacts\EgtData\BeamWall\$ChosenBit\ $TestDataCam5Folder\BeamWall
ProgressBarAndPercentageLabel
}
#Definisco una finestra in cui è possibile aggiungere controlli.
$Cam5Form = New-Object System.Windows.Forms.Form
$Cam5Form.Text = 'EgtCAM5 Tester'
$Cam5Form.Size = New-Object System.Drawing.Size(400,300)
$Cam5Form.StartPosition = 'CenterScreen'
#Definisco una groupbox per la scelta dell'architettura
$ArchGroupBox = New-Object System.Windows.Forms.GroupBox
$ArchGroupBox.Location = New-Object System.Drawing.Size(20,20)
$ArchGroupBox.size = New-Object System.Drawing.Size(340,80)
$ArchGroupBox.text = "Seleziona architettura EgtCAM5 da testare:"
$Cam5Form.Controls.Add($ArchGroupBox)
#Definisco il bottone per selezionare architettura x86
$x86Button = New-Object System.Windows.Forms.RadioButton
$x86Button.Location = New-Object System.Drawing.Point(20,20)
$x86Button.Size = New-Object System.Drawing.Size(100,23)
$x86Button.Text = 'x86'
$x86Button.Checked = $true
$Cam5Form.Controls.Add($x86Button)
$ArchGroupBox.Controls.Add($x86Button)
#Definisco il bottone per selezionare architettura x64
$x64Button = New-Object System.Windows.Forms.RadioButton
$x64Button.Location = New-Object System.Drawing.Point(20,40)
$x64Button.Size = New-Object System.Drawing.Size(100,23)
$x64Button.Text = 'x64'
$Cam5Form.Controls.Add($x64Button)
$ArchGroupBox.Controls.Add($x64Button)
#Definisco un label per mostrare l'avanzamento dell'operazione in corso
$PercentageLabel = New-Object System.Windows.Forms.Label
$PercentageLabel.Location = New-Object System.Drawing.Point(180,120)
$PercentageLabel.Size = New-Object System.Drawing.Size(280,20)
$PercentageLabel.Text = ""
$PercentageLabel.Visible = $True
$Cam5Form.Controls.Add($PercentageLabel)
#Definisco la barra di avanzamento per mostrare il progresso della copia
$CopyProgressBar = New-Object System.Windows.Forms.ProgressBar
$CopyProgressBar.Width = 320
$CopyProgressBar.Height = 20
$CopyProgressBar.Location = New-Object System.Drawing.Point(20,160)
#assegno i valori minimi e massimi della barra progresso in base al range definito precedentemente
$CopyProgressBar.Minimum = $MinMax.Minimum
$CopyProgressBar.Maximum = $MinMax.Maximum
#inizializzo il value della progress bar al minimo
$CopyProgressBar.Value = $MinMax.Minimum
#definisco lo step della progress bar a 1 (1 step=1 cartella copiata)
$CopyProgressBar.Step = 1
$CopyProgressBar.Style = 'Continuous'
$CopyProgressBar.Visible = $True
$Cam5Form.Controls.Add($CopyProgressBar)
#Definisco il bottone per lanciare installazione richiesta di EgtCAM5
$InstallCAM5Button = New-Object System.Windows.Forms.Button
$InstallCAM5Button.Location = New-Object System.Drawing.Point(20,220)
$InstallCAM5Button.Size = New-Object System.Drawing.Size(100,23)
$InstallCAM5Button.Text = 'Installa EgtCAM5'
$InstallCAM5Button.Add_Click({
if ($x86Button.Checked -eq $true) {
$BitChoice = 'x86'
$ChosenBit = '32'
$ChosenDll = 'Dll32'
}
if ($x64Button.Checked -eq $true) {
$BitChoice = 'x64'
$ChosenBit = '64'
$ChosenDll = 'Dll64'
}
$UserConfirmation = [System.Windows.MessageBox]::Show("Install EgtCAM5 $BitChoice ?",'Conferma Architettura','YesNo','Info')
switch ($UserConfirmation){
'Yes' {
ClearFolders $TestProgCam5Folder $TestDataCam5Folder
InstallRequiredCAM5 $BitChoice $ChosenBit $ChosenDll
[System.Windows.MessageBox]::Show("EgtCAM5 $BitChoice installato!",'Operazione terminata')
$Cam5Form.Close()
$Cam5Form.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtScriptsGUI.ps1
}
'No'{}
}
})
$Cam5Form.Controls.Add($InstallCAM5Button)
#Definisco il bottone per navigazione al menu precedente
$MenuReturn = New-Object System.Windows.Forms.Button
$MenuReturn.Location = New-Object System.Drawing.Point(260,220)
$MenuReturn.Size = New-Object System.Drawing.Size(100,23)
$MenuReturn.Text = 'Torna alla home'
$MenuReturn.Add_Click({
$Cam5Form.Close()
$Cam5Form.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtScriptsGUI.ps1
})
$Cam5Form.Controls.Add($MenuReturn)
#Proprietà Topmost su $true per forzare l'apertura della finestra sopra altre finestre e finestre di dialogo aperte.
$Cam5Form.Topmost = $true
#Visualizzo il modulo:
$Cam5Form.ShowDialog()
EgtDeploy/GUI/EgtScriptsGUI.ps1
+68
View File
@@ -0,0 +1,68 @@
### GRAPHIC USER INTERFACE PER TEST SCRIPTS ###
#Caricamento classi di .NET Framework
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
Add-Type -AssemblyName PresentationFramework
#Definisco una finestra in cui è possibile aggiungere controlli.
$MainForm = New-Object System.Windows.Forms.Form
$MainForm.Text = 'Egt Version Tester'
$MainForm.Size = New-Object System.Drawing.Size(400,300)
$MainForm.StartPosition = 'CenterScreen'
#Definisco un testo per chiedere all'utente che programma vuole installare
$InstLabel = New-Object System.Windows.Forms.Label
$InstLabel.Location = New-Object System.Drawing.Point(20,20)
$InstLabel.Size = New-Object System.Drawing.Size(280,20)
$InstLabel.Text = 'Seleziona il programma da testare:'
$MainForm.Controls.Add($InstLabel)
#Definisco il bottone per lanciare installazione di EgtCAM5
$CAM5Button = New-Object System.Windows.Forms.Button
$CAM5Button.Location = New-Object System.Drawing.Point(40,40)
$CAM5Button.Size = New-Object System.Drawing.Size(100,23)
$CAM5Button.Text = 'EgtCAM5'
$CAM5Button.Add_Click({
$MainForm.Close()
$MainForm.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtCAM5TestGUI.ps1
})
$MainForm.Controls.Add($CAM5Button)
#Definisco il bottone per lanciare installazione di BeamWall
$BWButton = New-Object System.Windows.Forms.Button
$BWButton.Location = New-Object System.Drawing.Point(40,70)
$BWButton.Size = New-Object System.Drawing.Size(100,23)
$BWButton.Text = 'BeamWall'
$BWButton.Add_Click({
$MainForm.Close()
$MainForm.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtBeamWallTestGUI.ps1
})
$MainForm.Controls.Add($BWButton)
#Definisco un testo per chiedere all'utente se vuole copiare macchine dal server
$MachLabel = New-Object System.Windows.Forms.Label
$MachLabel.Location = New-Object System.Drawing.Point(20,110)
$MachLabel.Size = New-Object System.Drawing.Size(280,20)
$MachLabel.Text = 'Copia macchine dal server:'
$MainForm.Controls.Add($MachLabel)
#Definisco il bottone per copiare macchine dal server
$MachButton = New-Object System.Windows.Forms.Button
$MachButton.Location = New-Object System.Drawing.Point(40,130)
$MachButton.Size = New-Object System.Drawing.Size(100,23)
$MachButton.Text = 'Copia Macchine'
$MachButton.Add_Click({
$MainForm.Close()
$MainForm.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\MachGrabberGUI.ps1
})
$MainForm.Controls.Add($MachButton)
#Proprietà Topmost su $true per forzare l'apertura della finestra sopra altre finestre e finestre di dialogo aperte.
$MainForm.Topmost = $true
#Visualizzo il modulo:
$MainForm.ShowDialog()
EgtDeploy/GUI/ExampleProgressBarGUI.ps1
+57
View File
@@ -0,0 +1,57 @@
Add-Type -AssemblyName System.Windows.Forms
# Range to count through
$Range = 1..100
# Determine minimum & maximum values of range
$MinMax = $Range | Measure-Object -Minimum -Maximum
#inizializzo counter a zero
$Counter = 0
# Function to run on button click
Function Start-Counting {
# On button click we set progress bar to start (minimum) value and refresh
$ProgressBar.Value = $MinMax.Minimum
$ProgressBar.Refresh()
$Button.Refresh()
Foreach ($Number in $Range) {
$Counter++
# Perform single step on progress bar and refresh
$ProgressBar.PerformStep()
$ProgressBar.Refresh()
# Step interval
Start-Sleep -Milliseconds 50
}
$Counter = 0
}
$ProgressForm = New-Object System.Windows.Forms.Form
$ProgressForm.Text = "Operation in progress..."
$ProgressForm.SizeGripStyle = "Hide"
$ProgressForm.StartPosition = "CenterScreen"
$ProgressForm.FormBorderStyle = "FixedDialog"
$ProgressForm.MaximizeBox = $False
$ProgressForm.Width = 400
$ProgressForm.Height = 200
$ProgressBar = New-Object System.Windows.Forms.ProgressBar
$ProgressBar.Width = 340
$ProgressBar.Height = 25
$ProgressBar.Visible = $True
$ProgressBar.Minimum = $MinMax.Minimum
$ProgressBar.Maximum = $MinMax.Maximum
$ProgressBar.Value = $MinMax.Minimum
$ProgressBar.Step = 1
$ProgressBar.Location = New-Object System.Drawing.Point(20,60)
$ProgressForm.Controls.Add($ProgressBar)
$Button = New-Object System.Windows.Forms.Button
$Button.Text = "Test Progress"
$Button.Width = 200
$Button.Height = 40
$Button.Add_Click({Start-Counting})
$Button.Location = New-Object System.Drawing.Point(20,90)
$Button.Font = "Microsoft Sans Serif,10"
$ProgressForm.Controls.Add($Button)
$ProgressForm.ShowDialog()
$ProgressForm.TopMost = $True
EgtDeploy/GUI/MachGrabberGUI.ps1
+232
View File
@@ -0,0 +1,232 @@
### GRAPHIC USER INTERFACE PER MACHINE GRABBER ###
#Caricamento classi di .NET Framework
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing
Add-Type -AssemblyName System.Runtime
Add-Type -AssemblyName PresentationFramework
#inizializzo variabili vuote
$SelDir=""
$SelMach=""
$TestDirectory="C:\EgtTestData\EgtCAM5\Machines"
$StableDirectory="C:\ProgramData\EgalTech\EgtCAM5\Machines"
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
#funzione MachineCopy: date le macchine da copiare e la folder di destinazione, fa la copia da truenas al pc locale e mostra l'avanzamento nella progress bar
function MachineCopy($SelMach, $SelDir){
#inizializzo counter a zero per avanzamento barra progresso
$Counter = 0
#Cerco le cartelle delle macchine richieste
$MachinesList = Get-ChildItem -Path $Artifacts\EGT_SRV\EgtTech\EgtData\Machines\ -Directory | Select-String -Pattern $SelMach
#ricavo il numero delle macchine richieste trovate
$MachinesCount = $MachinesList.Count
#assegno il range di valori min max della barra di progresso in base al numero delle macchine trovate
$MinMax = 0..$MachinesCount | Measure-Object -Minimum -Maximum
#assegno i valori minimi e massimi della barra progresso in base al range definito precedentemente
$CopyProgressBar.Minimum = $MinMax.Minimum
$CopyProgressBar.Maximum = $MinMax.Maximum
#inizializzo il value della progress bar al minimo
$CopyProgressBar.Value = $MinMax.Minimum
#definisco lo step della progress bar a 1 (1 step=1 cartella copiata)
$CopyProgressBar.Step = 1
#Per ogni macchina richiesta trovata procedo a copiarla in EgtTestData\EgtCAM5\Machines
foreach($Machine in $MachinesList){
ROBOCOPY $Artifacts\EGT_SRV\EgtTech\EgtData\Machines\$Machine $SelDir\$Machine /MIR /FFT
$Counter++
# avanti uno step nella progress bar
$CopyProgressBar.PerformStep()
# calcolo il progresso in %
$ProgressFactor = ($CopyProgressBar.Value/$CopyProgressBar.Maximum)*100
$RoundedPercentage = [math]::Round($ProgressFactor)
#scrivo nel label dedicato la percentuale di avanzamento e faccio refresh progressbar
$PercentageLabel.Text = "$RoundedPercentage %"
$CopyProgressBar.Refresh()
}
}
#Definisco una finestra in cui è possibile aggiungere controlli.
$MachGrabForm = New-Object System.Windows.Forms.Form
$MachGrabForm.Text = 'Machine Grabber'
$MachGrabForm.Size = New-Object System.Drawing.Size(500,500)
$MachGrabForm.StartPosition = 'CenterScreen'
#Definisco una groupbox per la scelta delle macchine
$MachGroupBox = New-Object System.Windows.Forms.GroupBox
$MachGroupBox.Location = New-Object System.Drawing.Size(20,20)
$MachGroupBox.size = New-Object System.Drawing.Size(440,140)
$MachGroupBox.text = "Seleziona macchine da copiare:"
$MachGrabForm.Controls.Add($MachGroupBox)
#Definisco il bottone per selezionare macchine Belotti
$BelottiButton = New-Object System.Windows.Forms.RadioButton
$BelottiButton.Location = New-Object System.Drawing.Point(20,20)
$BelottiButton.Size = New-Object System.Drawing.Size(100,23)
$BelottiButton.Text = 'Belotti'
$BelottiButton.Checked = $true
$MachGrabForm.Controls.Add($BelottiButton)
$MachGroupBox.Controls.Add($BelottiButton)
#Definisco il bottone per selezionare macchine Cms
$CmsButton = New-Object System.Windows.Forms.RadioButton
$CmsButton.Location = New-Object System.Drawing.Point(20,40)
$CmsButton.Size = New-Object System.Drawing.Size(100,23)
$CmsButton.Text = 'Cms'
$MachGrabForm.Controls.Add($CmsButton)
$MachGroupBox.Controls.Add($CmsButton)
#Definisco il bottone per selezionare macchine Essetre
$EssetreButton = New-Object System.Windows.Forms.RadioButton
$EssetreButton.Location = New-Object System.Drawing.Point(20,60)
$EssetreButton.Size = New-Object System.Drawing.Size(100,23)
$EssetreButton.Text = 'Essetre'
$MachGrabForm.Controls.Add($EssetreButton)
$MachGroupBox.Controls.Add($EssetreButton)
#Definisco il bottone per selezionare macchine Multiax
$MultiaxButton = New-Object System.Windows.Forms.RadioButton
$MultiaxButton.Location = New-Object System.Drawing.Point(20,80)
$MultiaxButton.Size = New-Object System.Drawing.Size(100,23)
$MultiaxButton.Text = 'Multiax'
$MachGrabForm.Controls.Add($MultiaxButton)
$MachGroupBox.Controls.Add($MultiaxButton)
#Definisco il bottone per selezionare macchine Omag
$OmagButton = New-Object System.Windows.Forms.RadioButton
$OmagButton.Location = New-Object System.Drawing.Point(20,100)
$OmagButton.Size = New-Object System.Drawing.Size(100,23)
$OmagButton.Text = 'Omag'
$MachGrabForm.Controls.Add($OmagButton)
$MachGroupBox.Controls.Add($OmagButton)
#Definisco una groupbox per la scelta della cartella di destinazione
$FolderGroupBox = New-Object System.Windows.Forms.GroupBox
$FolderGroupBox.Location = New-Object System.Drawing.Size(20,180)
$FolderGroupBox.size = New-Object System.Drawing.Size(440,120)
$FolderGroupBox.text = "Seleziona directory di destinazione:"
$MachGrabForm.Controls.Add($FolderGroupBox)
#Definisco il bottone per selezionare folder Test
$TestFolderButton = New-Object System.Windows.Forms.RadioButton
$TestFolderButton.Location = New-Object System.Drawing.Point(20,20)
$TestFolderButton.Size = New-Object System.Drawing.Size(400,23)
$TestFolderButton.Text = "Test $TestDirectory"
$TestFolderButton.Checked = $true
$FolderGroupBox.Controls.Add($TestFolderButton)
#Definisco il bottone per selezionare folder Stable
$StableFolderButton = New-Object System.Windows.Forms.RadioButton
$StableFolderButton.Location = New-Object System.Drawing.Point(20,50)
$StableFolderButton.Size = New-Object System.Drawing.Size(400,23)
$StableFolderButton.Text = "Stable $StableDirectory"
$FolderGroupBox.Controls.Add($StableFolderButton)
#Definisco il bottone per selezionare folder Custom
$CustomFolderButton = New-Object System.Windows.Forms.RadioButton
$CustomFolderButton.Location = New-Object System.Drawing.Point(20,80)
$CustomFolderButton.Size = New-Object System.Drawing.Size(80,23)
$CustomFolderButton.Text = 'Custom'
$CustomFolderButton.Add_Click({
$FolderBrowser = New-Object System.Windows.Forms.FolderBrowserDialog
$FolderBrowser.SelectedPath = "C:\"
[void]$FolderBrowser.ShowDialog()
$FolderBrowser.SelectedPath
$CustomFolderText.Text = $FolderBrowser.SelectedPath
})
$FolderGroupBox.Controls.Add($CustomFolderButton)
#Definisco il textbox che mostra la folder custom
$CustomFolderText = New-Object System.Windows.Forms.TextBox
$CustomFolderText.Location = New-Object System.Drawing.Point(100,80)
$CustomFolderText.Size = New-Object System.Drawing.Size(280,23)
$CustomFolderText.Text = ''
$CustomFolderText.Add_Click({
$FolderBrowser = New-Object System.Windows.Forms.FolderBrowserDialog
$FolderBrowser.SelectedPath = "C:\"
[void]$FolderBrowser.ShowDialog()
$FolderBrowser.SelectedPath
$CustomFolderText.Text = $FolderBrowser.SelectedPath
})
$FolderGroupBox.Controls.Add($CustomFolderText)
#Definisco un label per mostrare l'avanzamento dell'operazione in corso
$PercentageLabel = New-Object System.Windows.Forms.Label
$PercentageLabel.Location = New-Object System.Drawing.Point(220,340)
$PercentageLabel.Size = New-Object System.Drawing.Size(280,20)
$PercentageLabel.Text = ""
$MachGrabForm.Controls.Add($PercentageLabel)
#Definisco la barra di avanzamento per mostrare il progresso della copia
$CopyProgressBar = New-Object System.Windows.Forms.ProgressBar
$CopyProgressBar.Width = 440
$CopyProgressBar.Height = 20
$CopyProgressBar.Location = New-Object System.Drawing.Point(20,360)
$CopyProgressBar.Style = 'Continuous'
$CopyProgressBar.Visible = $True
$MachGrabForm.Controls.Add($CopyProgressBar)
#Definisco il bottone per lanciare la copia delle macchine richieste
$GrabMachButton = New-Object System.Windows.Forms.Button
$GrabMachButton.Location = New-Object System.Drawing.Point(20,400)
$GrabMachButton.Size = New-Object System.Drawing.Size(100,23)
$GrabMachButton.Text = 'Copia Macchine'
#Quando l'utente clicca il copia macchine verifico la selezione richiesta e la cartella di destinazione
$GrabMachButton.Add_Click({
if ($BelottiButton.Checked -eq $true) {
$SelMach = 'Belotti'
}
if ($CmsButton.Checked -eq $true) {
$SelMach = 'CMS'
}
if ($EssetreButton.Checked -eq $true) {
$SelMach = 'Essetre'
}
if ($MultiaxButton.Checked -eq $true) {
$SelMach = 'Multiax'
}
if ($OmagButton.Checked -eq $true) {
$SelMach = 'Omag'
}
if ($TestFolderButton.Checked -eq $true) {
$SelDir = $TestDirectory
}
if ($StableFolderButton.Checked -eq $true) {
$SelDir = $StableDirectory
}
if ($CustomFolderButton.Checked -eq $true) {
$SelDir = $CustomFolderText.Text
}
#chiedo all'utente conferma della copia richiesta
$UserConfirmation = [System.Windows.MessageBox]::Show("Copia macchine $SelMach in folder $SelDir ?",'Conferma copia','YesNo','Info')
switch ($UserConfirmation){
'Yes' {
#chiamo funzione MachineCopy che fa il robocopy e mostra la barra di avanzamento in base al numero di cartelle da copiare
MachineCopy $SelMach $SelDir
[System.Windows.MessageBox]::Show("Macchine $SelMach copiate in $SelDir",'Operazione terminata')
$CopyProgressBar.Value = $CopyProgressBar.Minimum
$PercentageLabel.Text = ""
}
'No'{}
}
})
$MachGrabForm.Controls.Add($GrabMachButton)
#Definisco il bottone per navigazione al menu precedente
$MenuReturn = New-Object System.Windows.Forms.Button
$MenuReturn.Location = New-Object System.Drawing.Point(360,400)
$MenuReturn.Size = New-Object System.Drawing.Size(100,23)
$MenuReturn.Text = 'Torna alla home'
$MenuReturn.Add_Click({
$MachGrabForm.Close()
$MachGrabForm.Dispose()
Powershell.exe -executionpolicy remotesigned -File .\GUI\EgtScriptsGUI.ps1
})
$MachGrabForm.Controls.Add($MenuReturn)
#Proprietà Topmost su $true per forzare l'apertura della finestra sopra altre finestre e finestre di dialogo aperte.
$MachGrabForm.Topmost = $true
#Visualizzo il modulo:
$MachGrabForm.ShowDialog()
EgtDeploy/OldVersions/EgtBeamWallTest_OldSelector.ps1
+155
View File
@@ -0,0 +1,155 @@
# Esegue setup di BeamWall da repo Artifacts
Write-Output ""
Write-Output "---------------------------------"
Write-Output "| EgtBEAMWALL Last Release Test |"
Write-Output "---------------------------------"
Write-Output ""
#inizializzo variabili vuote
$SelBranch = ""
$SelArch = ""
$ChosenBit = ""
$ChosenDll = ""
$ChosenDllD = ""
#Definisco path truenas di origine
$Artifacts = '\\truenas\Artifacts'
$BWSourceFolder = '\\truenas\Artifacts\EgtProg\EgtBEAMWALL'
#Definisco path test sottocartelle EgtBEAMWALL
$TestProgBWFolder = 'c:\EgtTestProg\EgtBEAMWALL'
$TestDataBWFolder = 'c:\EgtTestData\EgtBEAMWALL'
#Cerco le cartelle dei branch in \\truenas\Artifacts\EgtProg\EgtBEAMWALL
Write-Output ""
$BranchSelection = $false
$Branches = Get-ChildItem -Path $BWSourceFolder -Directory
$BranchCount = $Branches.Count
#Chiedo all'utente che branch desidera installare
do{
$idx = 1
Write-Output "-----------------------------"
foreach($item in $Branches)
{
Write-Output("$idx - $item")
$idx++
}
Write-Output "-----------------------------"
Write-Output ""
Write-Output ""
$SelBranch = @(Get-ChildItem $BWSourceFolder -Directory | Out-GridView -Title 'Scegli il branch EgtBeamWall da testare' -PassThru)
$BranchSelection = ($numSel -le $BranchCount)
} while(!$BranchSelection)
#Chiedo all'utente che architettura desidera installare
Write-Output ""
$ArchSelection = $false
$Architectures = 'x86','x64'
$ArchCount = $Architectures.Count
do{
$idx = 1
Write-Output "-----------------------------"
foreach($item in $Architectures)
{
Write-Output("$idx - $item")
$idx++
}
Write-Output "-----------------------------"
Write-Output ""
Write-Output ""
$SelArch = @($Architectures | Out-GridView -Title 'Scegli architettura EgtBeamWall da testare' -PassThru)
$ArchSelection = ($numSel -le $ArchCount)
Write-Output $SelArch
} while(!$ArchSelection)
#Switch fra 32 bit o 64 bit in base alla richiesta dell'utente
if($SelArch -eq 'x86'){
$ChosenBit = '32'
$ChosenDll = 'Dll32'
$ChosenDllD = 'DllD32'
}
else {
$ChosenBit = '64'
$ChosenDll = 'Dll64'
$ChosenDllD = 'DllD64'
}
#Pulisco cartella EgtTestProg\EgtBEAMWALL se già esistente, poi la creo
if (Test-Path -Path $TestProgBWFolder) {
"Prog esiste!"
Remove-Item -Recurse $TestProgBWFolder\*.*
} else {
new-item $TestProgBWFolder -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder) {
"Data esiste!"
Remove-Item -Recurse $TestDataBWFolder\*.*
} else {
new-item $TestDataBWFolder -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Temp se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Temp) {
"Temp esiste!"
Remove-Item -Recurse $TestDataBWFolder\Temp\*.*
} else {
new-item $TestDataBWFolder\Temp -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Macro se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Macro) {
"Macro esiste!"
Remove-Item -Recurse $TestDataBWFolder\Macro\*.*
} else {
new-item $TestDataBWFolder\Macro -itemtype directory
}
#Pulisco cartella EgtTestData\EgtBEAMWALL\Config se già esistente, poi la creo
if (Test-Path -Path $TestDataBWFolder\Config) {
"Config esiste!"
Remove-Item -Recurse $TestDataBWFolder\Config\*.*
} else {
new-item $TestDataBWFolder\Config -itemtype directory
}
#Copio la cartella Config
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL_Config\Config\ $TestDataBWFolder\Config
#Copio la cartella Messages
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\Messages $TestDataBWFolder\Config
#Copio la cartella Fonts
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\Fonts\ $TestDataBWFolder\Fonts
#Copio DataRoot.ini custom in c:\EgtTestProg\EgtBEAMWALL
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL_Config\ $TestProgBWFolder DataRoot.ini
#Copio il file Medium.ini in \Warehouse
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\EgtBEAMWALL\Warehouse\ $TestDataBWFolder\Warehouse Medium.ini
#Copio Resources
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtData\EgtBEAMWALL\Resources\ $TestDataBWFolder\Resources
#Copio la sottocartella 32 o 64 bit di Lualibs a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\LuaLibs\$ChosenBit $TestDataBWFolder\Lualibs
#Copio la cartella Dll32 o Dll64 a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\$ChosenDll $TestProgBWFolder
#Copio la cartella DllD32 o DllD64 a seconda della richiesta
ROBOCOPY /E $Artifacts\EGT_SRV\EgtTech\EgtProg\$ChosenDllD $TestProgBWFolder
#Copio Versione + Architettura di BEAMWALL richieste
ROBOCOPY /E $Artifacts\EgtProg\EgtBEAMWALL\$SelBranch\$SelArch $TestProgBWFolder
#Cancello tutti i .exe.config e .dll.config perchè problematici in area Test
Remove-Item -Recurse $TestProgBWFolder\*.exe.config
Remove-Item -Recurse $TestProgBWFolder\*.dll.config
#Chiudo lanciando lo Script Manager per altre operazioni
Powershell.exe -executionpolicy remotesigned -File .\EgtScriptsManager.ps1
EgtTest/TestEgtBeamWallv2.ps1
+246
View File
@@ -0,0 +1,246 @@
# Esegue setup versione richiesta di BeamWall da repo Artifacts
Write-Output "-----------------------------"
Write-Output "- EgtBeamWall "
Write-Output "-----------------------------"
Write-Output ""
Write-Output ""
$rPath = "\\10.74.82.50\EgtTech\"
$rUser = "10.74.82.50\Server"
$rPwd = "Dossena"
$zPath = "\\truenas\Artifacts\EgtProg\EgtBEAMWALL"
$zPathC = "\\truenas\Artifacts\EgtProg\EgtBEAMWALL_Config"
$progPath = "C:\EgtTestProg\EgtBEAMWALL"
$dataPath = "C:\EgtTestData"
$arch64 =""
$branch =""
$APP_NAME = "c:\EgtTestProg\EgtCAM5"
$Folder1 = 'c:\EgtTestProg'
$Folder2 = 'c:\EgtTestData'
"Test to see if folder [$Folder1] exists"
if (Test-Path -Path $Folder1) {
"Prog esiste!"
#rm -Recurse $Folder1\*.*
} else {
new-item c:\EgtTestProg\EgtBEAMWALL -itemtype directory
}
if (Test-Path -Path $Folder2) {
"Data esiste!"
#rm -Recurse $Folder2\*.*
} else {
new-item c:\EgtTestData\EgtBEAMWALL -itemtype directory
}
if ([System.IO.Directory]::Exists('V:\')) {
"Path exists!"
} else {
$secpasswd = ConvertTo-SecureString "Dossena" -AsPlainText -Force
$mycreds = New-Object System.Management.Automation.PSCredential ("10.74.82.50\Server", $secpasswd)
New-SmbMapping -LocalPath 'V:' -RemotePath '\\10.74.82.50\EgtTech' -Username '10.74.82.50\Server' -Password 'Dossena'
}
if ([System.IO.Directory]::Exists('U:\')) {
"Path exists!"
} else {
$secpasswd = ConvertTo-SecureString "Egalware_24068!" -AsPlainText -Force
$mycreds = New-Object System.Management.Automation.PSCredential ("steamw\egalware", $secpasswd)
New-SmbMapping -LocalPath 'U:' -RemotePath '\\10.74.82.201\Artifacts' -Username 'steamw\egalware' -Password 'Egalware_24068!'
}
$Folder5 = 'c:\EgtTestData\EgtBEAMWALL\Fonts'
if (Test-Path -Path $Folder5) {
"Font esiste!"
rm -Recurse $Folder5\*.*
} else {
new-item c:\EgtTestData\EgtBEAMWALL\Fonts -itemtype directory
}
$Folder6 = 'c:\EgtTestData\EgtBEAMWALL\Temp'
if (Test-Path -Path $Folder6) {
"Temp esiste!"
rm -Recurse $Folder6\*.*
} else {
new-item c:\EgtTestData\EgtBEAMWALL\Temp -itemtype directory
}
$Folder7 = 'c:\EgtTestData\EgtBEAMWALL\Config'
if (Test-Path -Path $Folder7) {
"Config esiste!"
rm -Recurse $Folder7\*.*
} else {
new-item c:\EgtTestData\Fonts -itemtype directory
}
# ora chiedo quale branch scegliere
Write-Output ""
$valOk = $false
$altern = Get-ChildItem -Path $zPath -Directory
$numFolder = $altern.Count
do{
$idx = 1
Write-Output "-----------------------------"
foreach($item in $altern)
{
Write-Output("$idx - $item")
$idx++
}
Write-Output "-----------------------------"
Write-Output ""
Write-Output ""
$branch = @(Get-ChildItem $zPath -Directory | Out-GridView -Title 'Scegli il branch' -PassThru)
$valOk = ($numSel -le $numFolder)
} while(!$valOk)
#$valOk = $false
#do{
# $arch64 = Read-Host "Vuoi Architettura 64 bit (s/n)"
# $valOk = ($arch64.ToUpper() -eq "N" -or $arch64.ToUpper() -eq "S")
#} while(!$valOk)
#Write-Output "64 bit: $arch64"
# ora chiedo quale variante vuole
Write-Output ""
$valOk = $false
$altern = Get-ChildItem -Path $zPath -Directory
$numFolder = $altern.Count
#do{
# $idx = 1
# Write-Output "-----------------------------"
# foreach($item in $altern)
# {
# Write-Output("$idx - $item")
# $idx++
# }
# Write-Output "-----------------------------"
# Write-Output ""
# Write-Output ""
# $choice = @(Get-ChildItem $zPath\$branch | Out-GridView -Title 'Scegli architettura x64 o x32' -PassThru)
# Write-Output "$choice"
# $valOk = ($numSel -le $numFolder)
#
#} while(!$valOk)
function Show-MenuA
{
param (
[string]$Title = 'Seleziona Architettura da testare'
)
Clear-Host
Write-Host "================ $Title ================"
Write-Host "1: Premi '1' per x86"
Write-Host "2: Premi '2' per x64"
Write-Host "q: Premi 'q' per uscire dal programma."
}
Show-MenuA –Title 'Seleziona Architettura da testare'
$selection = Read-Host "Seleziona"
switch ($selection)
{
'1' {
$choice = 'x86'
'Hai scelto 32'
} '2' {
$choice = 'x64'
'Hai scelto 64'
} 'q' {
return
}
}
#function Show-Menu
#{
# param (
# [string]$Title = 'Seleziona Architettura Lualibs'
# )
# Clear-Host
# Write-Host "================ $Title ================"
#
# Write-Host "1: Premi '1' per 32"
# Write-Host "2: Premi '2' per 64"
# Write-Host "q: Premi 'q' per uscire dal programma."
#}
#
#Show-Menu –Title 'Seleziona Architettura Lualibs'
#
#$selection = Read-Host "Seleziona"
# switch ($selection)
# {
# '1' {
# $choiceL = '32'
# 'Hai scelto 32'
# } '2' {
# $choiceL = '64'
# 'Hai scelto 64'
# } 'q' {
# return
# }
# }
# function Show-MenuC
#{
# param (
# [string]$Title = 'Seleziona Architettura Librerie C'
# )
# Clear-Host
# Write-Host "================ $Title ================"
#
# Write-Host "1: Premi '1' per 32"
# Write-Host "2: Premi '2' per 64"
# Write-Host "q: Premi 'q' per uscire dal programma."
#}
#
#Show-MenuC –Title 'Seleziona Architettura Librerie C'
#
#$selection2 = Read-Host "Seleziona"
# switch ($selection2)
# {
# '1' {
# $choiceC = 'Dll32'
# 'Hai scelto 32'
# } '2' {
# $choiceC = 'Dll64'
# 'Hai scelto 64'
# } 'q' {
# return
# }
# }
if($choice -eq 'x86'){
$choiceL = '32'
$choiceC = 'Dll32'
}else {
$choiceL = '64'
$choiceC = 'Dll64'
}
#$choiceL = @(Get-ChildItem V:\EgtProg\LuaLibs\ | Out-GridView -Title 'Scegli architettura Lualibs' -PassThru)
#$choiceC = @(Get-ChildItem V:\EgtProg\ | Out-GridView -Title 'Scegli architettura Librerie C' -PassThru)
ROBOCOPY /E U:\EgtProg\EgtBEAMWALL\$branch\$choice $progPath
ROBOCOPY /E U:\EgtProg\EgtBEAMWALL_Config\Config $dataPath\EgtBEAMWALL\Config
ROBOCOPY /E V:\EgtProg\LuaLibs\$choiceL $dataPath\Lualibs
ROBOCOPY /E U:\EgtProg\EgtBEAMWALL_Config $progPath DataRoot.ini
ROBOCOPY /E V:\EgtProg\$choiceC $progPath
#ROBOCOPY /E Z:\EgtData\Messages $dataPath\EgtBEAMWALL\Config
ROBOCOPY /E V:\EgtProg\Fonts $Folder5
EgtTest/TestEgtCAM5v2.ps1
+177
View File
@@ -0,0 +1,177 @@
# Esegue setup versione richiesta di BeamWall da repo Artifacts
Write-Output "-----------------------------"
Write-Output "- EgtBeamWall "
Write-Output "-----------------------------"
Write-Output ""
Write-Output ""
$rPath = "\\10.74.82.50\EgtTech\"
$rUser = "10.74.82.50\Server"
$rPwd = "Dossena"
$zPath = "\\truenas\Artifacts\EgtProg\EgtBEAMWALL"
$zPathC = "\\truenas\Artifacts\EgtProg\EgtBEAMWALL_Config"
$zPathS = "\\truenas\Artifacts\EgtCAM5"
$zPathD = "\\truenas\Artifacts\EgtData"
$zPath5 = "\\truenas\Artifacts\EgtProg\EgtCAM5\Config"
$progPath = "C:\EgtTestProg\EgtBEAMWALL"
$dataPath = "C:\EgtTestData"
$arch64 =""
$branch =""
$APP_NAME = "c:\EgtTestProg\EgtCAM5"
$Folder1 = 'c:\EgtTestProg'
$Folder2 = 'c:\EgtTestData'
"Test to see if folder [$Folder1] exists"
if (Test-Path -Path $Folder1) {
"Prog esiste!"
rm -Recurse $Folder1\*.*
} else {
new-item c:\EgtTestProg\EgtBEAMWALL -itemtype directory
}
if (Test-Path -Path $Folder2) {
"Data esiste!"
rm -Recurse $Folder2\*.*
} else {
new-item c:\EgtTestData\EgtBEAMWALL -itemtype directory
}
if ([System.IO.Directory]::Exists('V:\')) {
"Path exists!"
} else {
$secpasswd = ConvertTo-SecureString "Dossena" -AsPlainText -Force
$mycreds = New-Object System.Management.Automation.PSCredential ("10.74.82.50\Server", $secpasswd)
New-SmbMapping -LocalPath 'V:' -RemotePath '\\10.74.82.50\EgtTech' -Username '10.74.82.50\Server' -Password 'Dossena'
}
if ([System.IO.Directory]::Exists('U:\')) {
"Path exists!"
} else {
$secpasswd = ConvertTo-SecureString "Egalware_24068!" -AsPlainText -Force
$mycreds = New-Object System.Management.Automation.PSCredential ("steamw\egalware", $secpasswd)
New-SmbMapping -LocalPath 'U:' -RemotePath '\\10.74.82.201\Artifacts' -Username 'steamw\egalware' -Password 'Egalware_24068!'
}
$Folder4 = 'c:\EgtTestProg\EgtCAM5'
if (Test-Path -Path $Folder4) {
"EgtCAM5 esiste!"
rm -Recurse $Folder4\*.*
} else {
new-item c:\EgtTestProg\EgtCAM5 -itemtype directory
}
$Folder4v2 = 'c:\EgtTestData\EgtCAM5'
if (Test-Path -Path $Folder4v2) {
"EgtCAM5 esiste!"
rm -Recurse $Folder4v2\*.*
} else {
new-item c:\EgtTestData\EgtCAM5 -itemtype directory
}
function Show-Menu
{
param (
[string]$Title = 'Seleziona Architettura da testare'
)
Clear-Host
Write-Host "================ $Title ================"
Write-Host "1: Premi '1' per 32"
Write-Host "2: Premi '2' per 64"
Write-Host "q: Premi 'q' per uscire dal programma."
}
Show-Menu –Title 'Seleziona Architettura da testare'
$selection = Read-Host "Seleziona"
switch ($selection)
{
'1' {
$choiceD = '32'
'Hai scelto 32'
} '2' {
$choiceD = '64'
'Hai scelto 64'
} 'q' {
return
}
}
# function Show-MenuC
#{
# param (
# [string]$Title = 'Seleziona Architettura Librerie C'
# )
# Clear-Host
# Write-Host "================ $Title ================"
#
# Write-Host "1: Premi '1' per 32"
# Write-Host "2: Premi '2' per 64"
# Write-Host "q: Premi 'q' per uscire dal programma."
#}
#
#Show-MenuC –Title 'Seleziona Architettura Librerie C'
#
#$selection2 = Read-Host "Seleziona"
# switch ($selection2)
# {
# '1' {
# $choiceC = 'Dll32'
# 'Hai scelto 32'
# } '2' {
# $choiceC = 'Dll64'
# 'Hai scelto 64'
# } 'q' {
# return
# }
# }
if($choiceD -eq '32'){
$choiceC = 'Dll32'
}else {
$choiceC = 'Dll64'
}
#$choiceL = @(Get-ChildItem Z:\EgtProg\LuaLibs\ | Out-GridView -Title 'Scegli architettura Lualibs' -PassThru)
#$choiceC = @(Get-ChildItem Z:\EgtProg\ | Out-GridView -Title 'Scegli architettura Librerie C' -PassThru)
#$choiceD = @(Get-ChildItem U:\EgtData\Beam | Out-GridView -Title 'Scegli architettura Librerie Beam\Wall\BEamWall' -PassThru)
ROBOCOPY /E V:\EgtProg\LuaLibs\$choiceD $dataPath\Lualibs
ROBOCOPY /E V:\EgtProg\$choiceC $APP_NAME
#ROBOCOPY /E Z:\EgtData\Messages $dataPath\EgtBEAMWALL\Config
ROBOCOPY /E V:\EgtProg\EgtCAM5 $Folder4
ROBOCOPY /E U:\EgtCAM5 $Folder4v2
ROBOCOPY /E U:\EgtProg\EgtCAM5\Config $Folder4 DataRoot.ini
ROBOCOPY /E V:\EgtProg\Fonts $Folder4v2\Fonts
ROBOCOPY /E V:\EgtProg\LuaLibs\$choiceD $Folder4v2\Lualibs
#ROBOCOPY /E \\EGALTECHSERVER\EgtTech\EgtData\Machines $dataPath\EgtCAM5\Machines Essetre-*
$altern = Get-ChildItem -Path V:\EgtData\Machines -Directory | Select-String -Pattern "Essetre"
foreach($item in $altern)
{
ROBOCOPY V:\EgtData\Machines\$item $dataPath\EgtCAM5\Machines\$item /MIR /FFT
}
#ROBOCOPY \\EGALTECHSERVER\EgtTech\EgtData\Machines $dataPath\EgtCAM5\Machines /E /Z /ZB /R:5 /W:5 /TBD /NP /V /XD \\EGALTECHSERVER\EgtTech\EgtData\Machines\Multiax*
ROBOCOPY /E V:\EgtData\ToolMakers $Folder4v2\ToolMakers
ROBOCOPY /E U:\EgtData\Beam\$choiceD $Folder4v2\Beam
ROBOCOPY /E U:\EgtData\Wall\$choiceD $Folder4v2\Wall
ROBOCOPY /E U:\EgtData\BeamWall\$choiceD $Folder4v2\BeamWall
GPW_Scripts/GPW_CheckProj_office.ps1 → GPW/GPW_CheckProj_office.ps1
View File
GPW_Scripts/GPW_CheckScadenzeLic.ps1 → GPW/GPW_CheckScadenzeLic.ps1
View File
GPW_Scripts/GPW_CheckTimb_office.ps1 → GPW/GPW_CheckTimb_office.ps1
View File
GPW_Scripts/GPW_StartApps_office.ps1 → GPW/GPW_StartApps_office.ps1
View File