1. AD accounts that can be logged into on any machine in the lab.
   
2. The accounts these Jenkins services run as.
   
3. The accounts they log into the mainframe as.
   
4. The accounts the Selenium scripts run under.
   

1. Do you care what the original filename is?
   
2. Do you need the "latest" file by time or "latest" file by number?
   
3. Does the original filename dictate the ending files' names?
   

Set-StrictMode -Version Latest

Start-Transcript -Path "C:\agv\logs\AGV-Copy-$(get-date -UFormat %Y%m%d%H%M%S).log" -NoClobber

$arm_path = "C:\agv\arm"		#Assuming this is your source directory
$disk_path = "c:\agv\disk"		#Assuming this is your destination directory
$vis_path = "c:\agv\vis"		#IDK what this is.
$agv_num = 21

if( -not (Test-Path $arm_path)) {
    Write-Host "Source Directory not found at $arm_path"
    break
}

if( -not (Test-Path $disk_path)) {
    Write-Host "Disk Directory not found at $disk_path"
    break
}

if( -not (Test-Path $vis_path)) {
    Write-Host "Vis Directory not found at $vis_path"
    break
}

$latest_source = Get-ChildItem -Path $arm_path -Filter "ARM*.dat" | Sort -Descending LastWriteTime | Select -First 1

if( -not ($latest_source)) {
    Write-Host "No Valid Source File Found."
    break
}

Write-Host "Duplicating $($latest_source.Name) $agv_num times..."

foreach( $iteration in 1..$agv_num) {
    $pad_length = ([string]$agv_num).Length
    Copy-Item "$($arm_path)\$($latest_source)" -Destination "$($disk_path)\ARM$(([string]$iteration).PadLeft($pad_length,"0")).dat" -Force
    Write-Host "$($disk_path)\ARM$(([string]$iteration).PadLeft($pad_length,"0")).dat created."
}

Stop-Transcript

1. Verify the service exists.
   
2. Bail if it doesn't.
   
3. Verify the service is running.
   
4. Log that you are stopping the service.
   
5. Set the wait duration.
   
6. Stop the service as a job.
   
7. Cycle a while loop every second to check if it's still running.
   
8. Bail and Log if the job fails.
   
9. After the wait duration elapses, check if the service is running.
   
10. If it is, log and bail.
    
11. If it's good and stopped, log and continue.
    

• Our logging writes to ~4 separate log files of varying verbosity, by default, with some scripts adding more. this is in addition to any CM logs generated.
  
• These 4 log files are written for different audiences and obscured away at different levels based on technical competency of the target audience.
  
• One of the log files, the most public-facing, and the one we recommend end users and low-tier techs check, is written at script exit with an extension based on script function and status, replacing all previous logs of that type, regardless of extension.
  
• The typical extensions are .S (successful install), .F (Any failure), .U (successful uninstall), .I (script incomplete, probably pending reboot).
  
• Buuuuuttttt, there's no standard for what these logs contain. Some of the are 0-byte empty files, some include return codes, some include timestamps, some have human-readable summaries, it entirely varies not only by who wrote it, but how they were feeling that day.
  

function CSSDT-Stop-Service {
<#
	.SYNOPSIS
			A function that stops a service passed via pipeline
	.PARAMETERS
			 $service - Pipeline passed list of services
			 $Timeout - Timeout to wait for job completion.  Default=30s
	.RETURNS
			ExitCode: [String] True if service not present or if service present and successfully stopped.  Otherwise false.
			ExitMessage: [String] Interpreted error message.
	.USAGE
			 $ServiceResult = Get-Service "Winzip*" | CSSDT-Stop-Service
			 if(-not $ServiceResult.ExitCode) { LogLine "Error: [$($ServiceResult.ExitMessage)]" }
#>

	[CmdletBinding()]

	Param(
		[Parameter(Mandatory=$true,
		ValueFromPipeline=$true)]
			$service,
		[Parameter()]
			[int]$Timeout=30
	)

	process {
		$jobs = $Null
		$ExitCode = $True
		$ExitMessage = ""

		ForEach($current_service in $service) {
			echo "Stopping Service $($current_service.name)"
			$jobs += Start-Job -ScriptBlock {Stop-Service $input.Name } -inputObject $current_service
		}

		echo "Waiting up to $($Timeout) seconds for jobs to process..."
		$jobs | Wait-Job -Timeout -$Timeout | Out-Null

		ForEach($current_job in $(Get-Job $jobs)) {

			switch ($current_job.State) {
				"NotStarted" { $Exitcode=$False; $ExitMessage+="Error: Job not Started ($($current_job.Name)"}
				"Running" { $Exitcode=$False; $ExitMessage+="Error: Job Timed Out ($($current_job.Name)"}
				"Failed" { $Exitcode=$False; $ExitMessage+="Error: Failed ($($current_job.Name)"}
				"Blocked" { $Exitcode=$False; $ExitMessage+="Error: Job Blocked ($($current_job.Name)"}
			}

			if($current_job.Error) {
				$ExitCode = $False
				$ExitMessage = "Error: Stop-Service command returned error: $($current_job.error)"
			}
		}

		ForEach($current_service in $service) {
			if((Get-Service $current_service).Status -eq "Running") {
				$ExitCode = $False
				$ExitMessage = "Error: Post-check Failed.  Service $($current_service.Name) still running..."
			}
		}

		if($ExitCode) {
			echo "Service stopped..."
		} else {
			echo "Error: Service stop failure.  Exit Message [$($ExitMessage)]"
		}

		return @{ExitCode=$ExitCode; ExitMessage=$ExitMessage}
	}
}

Toshimo fucked around with this message at 00:28 on Jun 9, 2022

• 95% of what we write is installation wrappers.
  
• Half the team is old dudes who did WiseScript for like a decade and 1 of them is now mostly MSIs and does Powershell only when neccessary.
  
• We have exactly 1 piece of shared code, which is a single include file that just sets up logging and populates a bunch of environment variables.
  
• We write a bunch of small stuff on short notice that often gets yeeted out to prod for 5+ years and is never touched again. (We don't patch code)
  
• Everything has to work the first time, every time, because if a script fails 1% of the time, that's a loss larger than what any of us make in a year.
  
• We don't have any source control.
  
• We QC each others' stuff, but I'm not convinced any of us really knows wtf is going on with each others' code more than 50% of the time, because we have to jam in a bunch of edge case poo poo and documentation is often non-existent.