ਪਾਵਰਸ਼ੇਲ ਇਨਵੋਕ-ਕਮਾਂਡ ਤੋਂ SQL ਸਰਵਰ ਏਜੰਟ ਨੂੰ ਮੁੱਲ ਵਾਪਸ ਕਰਨਾ

ਮਲਟੀਪਲ MS-SQL ਸਰਵਰਾਂ 'ਤੇ ਬੈਕਅੱਪ ਪ੍ਰਬੰਧਨ ਲਈ ਆਪਣਾ ਤਰੀਕਾ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਮੈਂ ਰਿਮੋਟ ਕਾਲਾਂ ਦੌਰਾਨ PowerShell ਨੂੰ ਮੁੱਲ ਪਾਸ ਕਰਨ ਦੀ ਵਿਧੀ ਦਾ ਅਧਿਐਨ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਬਿਤਾਇਆ, ਇਸ ਲਈ ਮੈਂ ਆਪਣੇ ਲਈ ਇੱਕ ਰੀਮਾਈਂਡਰ ਲਿਖ ਰਿਹਾ ਹਾਂ ਜੇਕਰ ਇਹ ਕਿਸੇ ਹੋਰ ਲਈ ਕੰਮ ਆਉਂਦਾ ਹੈ।

ਤਾਂ, ਆਓ ਇੱਕ ਸਧਾਰਨ ਸਕ੍ਰਿਪਟ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੀਏ ਅਤੇ ਇਸਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਚਲਾਏ:

$exitcode = $args[0]
Write-Host 'Out to host.'
Write-Output 'Out to output.'
Write-Host ('ExitCode: ' + $exitcode)
Write-Output $exitcode
$host.SetShouldExit($exitcode)

ਸਕ੍ਰਿਪਟਾਂ ਚਲਾਉਣ ਲਈ, ਮੈਂ ਹੇਠ ਲਿਖੀ CMD ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ; ਮੈਂ ਇਸਨੂੰ ਹਰ ਵਾਰ ਸ਼ਾਮਲ ਨਹੀਂ ਕਰਾਂਗਾ:

@Echo OFF
PowerShell .TestOutput1.ps1 1
ECHO ERRORLEVEL=%ERRORLEVEL%

ਸਕਰੀਨ 'ਤੇ ਅਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਦੇਖਾਂਗੇ:

Out to host.
Out to output.
ExitCode: 1
1
ERRORLEVEL=1

ਹੁਣ ਉਹੀ ਸਕ੍ਰਿਪਟ WSMAN (ਰਿਮੋਟਲੀ) ਰਾਹੀਂ ਚਲਾਉਂਦੇ ਹਾਂ:

Invoke-Command -ComputerName . -ScriptBlock { &'D:sqlagentTestOutput1.ps1' $args[0] } -ArgumentList $args[0]

ਅਤੇ ਇੱਥੇ ਨਤੀਜਾ ਹੈ:

Out to host.
Out to output.
ExitCode: 2
2
ERRORLEVEL=0

ਬਹੁਤ ਵਧੀਆ, Errorlevel ਗਾਇਬ ਹੋ ਗਿਆ ਹੈ, ਪਰ ਸਾਨੂੰ ਅਜੇ ਵੀ ਸਕ੍ਰਿਪਟ ਤੋਂ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ! ਆਓ ਹੇਠ ਲਿਖਿਆਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

$res=Invoke-Command -ComputerName . -ScriptBlock { &'D:sqlagentTestOutput1.ps1' $args[0] } -ArgumentList $args[0]

ਇਹ ਹੋਰ ਵੀ ਦਿਲਚਸਪ ਹੈ। ਪੂਰਾ ਆਉਟਪੁੱਟ ਸੁਨੇਹਾ ਗਾਇਬ ਹੋ ਗਿਆ ਹੈ:

Out to host.
ExitCode: 2
ERRORLEVEL=0

ਹੁਣ, ਇੱਕ ਸਾਈਡ ਨੋਟ ਦੇ ਤੌਰ 'ਤੇ, ਜੇਕਰ ਤੁਸੀਂ Write-Output ਜਾਂ PowerShell ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਇੱਕ ਐਕਸਪ੍ਰੈਸ਼ਨ ਲਿਖਦੇ ਹੋ, ਬਿਨਾਂ ਕਿਸੇ ਵੇਰੀਏਬਲ ਨੂੰ ਦਿੱਤੇ (ਜੋ ਕਿ ਆਉਟਪੁੱਟ ਚੈਨਲ ਨੂੰ ਆਉਟਪੁੱਟ ਦਰਸਾਉਂਦਾ ਹੈ), ਤਾਂ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਚੱਲਦੇ ਹੋਏ ਵੀ ਕੁਝ ਵੀ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਿੰਟ ਨਹੀਂ ਹੋਵੇਗਾ! ਇਹ PowerShell ਦੇ ਪਾਈਪਲਾਈਨ ਆਰਕੀਟੈਕਚਰ ਦਾ ਨਤੀਜਾ ਹੈ—ਹਰੇਕ ਫੰਕਸ਼ਨ ਦੀ ਆਪਣੀ ਆਉਟਪੁੱਟ ਪਾਈਪਲਾਈਨ ਹੁੰਦੀ ਹੈ, ਇਸਦੇ ਲਈ ਇੱਕ ਐਰੇ ਬਣਾਈ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇਸ ਵਿੱਚ ਖਤਮ ਹੋਣ ਵਾਲੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਫੰਕਸ਼ਨ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਨਤੀਜਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਰਿਟਰਨ ਆਪਰੇਟਰ ਆਖਰੀ ਐਲੀਮੈਂਟ ਵਾਂਗ ਇਸ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਰਿਟਰਨ ਵੈਲਯੂ ਜੋੜਦਾ ਹੈ ਅਤੇ ਕਾਲਿੰਗ ਫੰਕਸ਼ਨ ਨੂੰ ਕੰਟਰੋਲ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ। ਦਰਸਾਉਣ ਲਈ, ਆਓ ਹੇਠਾਂ ਦਿੱਤੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਚਲਾਉਂਦੇ ਹਾਂ:

Function Write-Log {
  Param( [Parameter(Mandatory=$false, ValueFromPipeline=$true)] [String[]] $OutString = "`r`n" )
  Write-Output ("Function: "+$OutString)
  Return "ReturnValue"
}
Write-Output ("Main: "+"ParameterValue")
$res = Write-Log "ParameterValue"
$res.GetType()
$res.Length
$res | Foreach-Object { Write-Host ("Main: "+$_) }

ਅਤੇ ਇੱਥੇ ਨਤੀਜਾ ਹੈ:

Main: ParameterValue

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array
2
Main: Function: ParameterValue
Main: ReturnValue

ਮੁੱਖ ਫੰਕਸ਼ਨ (ਸਕ੍ਰਿਪਟ ਦਾ ਮੁੱਖ ਭਾਗ) ਦੀ ਆਪਣੀ ਆਉਟਪੁੱਟ ਪਾਈਪਲਾਈਨ ਵੀ ਹੈ, ਅਤੇ ਜੇਕਰ ਅਸੀਂ CMD ਤੋਂ ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦੇ ਹਾਂ, ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਰੀਡਾਇਰੈਕਟ ਕਰਦੇ ਹਾਂ,

PowerShell .TestOutput1.ps1 1 > TestOutput1.txt

ਫਿਰ ਅਸੀਂ ਸਕਰੀਨ ਤੇ ਵੇਖਾਂਗੇ

ERRORLEVEL=1

ਅਤੇ ਫਾਈਲ ਵਿੱਚ

Out to host.
Out to output.
ExitCode: 1
1

ਜੇਕਰ ਅਸੀਂ PowerShell ਤੋਂ ਇੱਕ ਸਮਾਨ ਕਾਲ ਕਰਦੇ ਹਾਂ

PS D:sqlagent> .TestOutput1.ps1 1 > TestOutput1.txt

ਫਿਰ ਸਕਰੀਨ 'ਤੇ ਹੋਵੇਗਾ

Out to host.
ExitCode: 1

ਅਤੇ ਫਾਈਲ ਵਿੱਚ

Out to output.
1

ਅਜਿਹਾ ਇਸ ਲਈ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ CMD ਪਾਵਰਸ਼ੈਲ ਲਾਂਚ ਕਰਦਾ ਹੈ, ਜੋ, ਜੇ ਹੋਰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਦੋ ਸਟ੍ਰੀਮਾਂ (ਹੋਸਟ ਅਤੇ ਆਉਟਪੁੱਟ) ਨੂੰ ਮਿਲਾਉਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ CMD ਨੂੰ ਦਿੰਦਾ ਹੈ, ਜੋ ਫਾਈਲ ਨੂੰ ਪ੍ਰਾਪਤ ਹੋਈ ਹਰ ਚੀਜ਼ ਭੇਜਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਪਾਵਰਸ਼ੈਲ ਤੋਂ ਲਾਂਚ ਕਰਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਹ ਦੋਵੇਂ ਸਟ੍ਰੀਮਾਂ ਵੱਖਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਰੀਡਾਇਰੈਕਸ਼ਨ ਚਿੰਨ੍ਹ ਸਿਰਫ਼ ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।

ਮੁੱਖ ਵਿਸ਼ੇ ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹੋਏ, ਯਾਦ ਰੱਖੋ ਕਿ PowerShell ਦੇ ਅੰਦਰ .NET ਆਬਜੈਕਟ ਮਾਡਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਇੱਕ ਸਿੰਗਲ ਕੰਪਿਊਟਰ (ਇੱਕ ਸਿੰਗਲ OS) ਦੇ ਅੰਦਰ ਮੌਜੂਦ ਹੈ। ਜਦੋਂ WSMAN ਰਾਹੀਂ ਰਿਮੋਟਲੀ ਕੋਡ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਆਬਜੈਕਟ ਟ੍ਰਾਂਸਫਰ XML ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਰਾਹੀਂ ਹੁੰਦਾ ਹੈ, ਜੋ ਸਾਡੀ ਖੋਜ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਦਿਲਚਸਪੀ ਜੋੜਦਾ ਹੈ। ਆਓ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨੂੰ ਚਲਾ ਕੇ ਆਪਣੇ ਪ੍ਰਯੋਗਾਂ ਨੂੰ ਜਾਰੀ ਰੱਖੀਏ:

$res=Invoke-Command -ComputerName . -ScriptBlock { &'D:sqlagentTestOutput1.ps1' $args[0] } -ArgumentList $args[0]
$res.GetType()
$host.SetShouldExit($res)

ਅਤੇ ਇਹ ਉਹ ਹੈ ਜੋ ਸਾਡੇ ਕੋਲ ਸਕ੍ਰੀਨ ਤੇ ਹੈ:

Out to host.

ExitCode: 3

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array
Не удается преобразовать аргумент "exitCode", со значением: "System.Object[]", для "SetShouldExit" в тип "System.Int32": "Не удается преобразовать значение "System.Object[]" типа "System.Object[]" в тип "System
.Int32"."
D:sqlagentTestOutput3.ps1:3 знак:1
+ $host.SetShouldExit($res)
+ ~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodException
    + FullyQualifiedErrorId : MethodArgumentConversionInvalidCastArgument

ERRORLEVEL=0

ਸ਼ਾਨਦਾਰ ਨਤੀਜਾ! ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਨਵੋਕ-ਕਮਾਂਡ ਨੂੰ ਕਾਲ ਕਰਨ ਵੇਲੇ, ਪਾਈਪਲਾਈਨਾਂ ਅਜੇ ਵੀ ਦੋ ਸਟ੍ਰੀਮਾਂ (ਹੋਸਟ ਅਤੇ ਆਉਟਪੁੱਟ) ਵਿੱਚ ਵੰਡੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਸਾਨੂੰ ਸਫਲਤਾ ਦੀ ਉਮੀਦ ਮਿਲਦੀ ਹੈ। ਆਓ ਰਿਮੋਟਲੀ ਚੱਲਣ ਵਾਲੀ ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਬਦਲ ਕੇ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਮੁੱਲ ਰੱਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

$exitcode = $args[0]
Write-Host 'Out to host.'
#Write-Output 'Out to output.'
Write-Host ('ExitCode: ' + $exitcode)
Write-Output $exitcode
$host.SetShouldExit($exitcode)

ਆਓ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਚਲਾਉਂਦੇ ਹਾਂ:

$res=Invoke-Command -ComputerName . -ScriptBlock { &'D:sqlagentTestOutput1.ps1' $args[0] } -ArgumentList $args[0]
$host.SetShouldExit($res)

ਅਤੇ... ਹਾਂ, ਇਹ ਜਿੱਤ ਵਾਂਗ ਲੱਗਦਾ ਹੈ!

Out to host.
ExitCode: 4

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Int32                                    System.ValueType


ERRORLEVEL=4

ਆਓ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਕਿ ਕੀ ਹੋਇਆ। ਅਸੀਂ PowerShell ਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਕਾਲ ਕੀਤੀ, ਜਿਸਨੇ ਬਦਲੇ ਵਿੱਚ ਇੱਕ ਰਿਮੋਟ ਕੰਪਿਊਟਰ 'ਤੇ PowerShell ਨੂੰ ਕਾਲ ਕੀਤਾ ਅਤੇ ਉੱਥੇ ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਇਆ। ਰਿਮੋਟ ਮਸ਼ੀਨ ਤੋਂ ਦੋ ਸਟ੍ਰੀਮਾਂ (ਹੋਸਟ ਅਤੇ ਆਉਟਪੁੱਟ) ਨੂੰ ਸੀਰੀਅਲਾਈਜ਼ ਕੀਤਾ ਗਿਆ ਅਤੇ ਵਾਪਸ ਪਾਸ ਕੀਤਾ ਗਿਆ। ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਸੀ, ਨੂੰ ਇੱਕ Int32 ਵਿੱਚ ਬਦਲਿਆ ਗਿਆ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਪਾਸੇ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪਾਸ ਕੀਤਾ ਗਿਆ, ਜਿਸਨੇ ਫਿਰ ਇਸਨੂੰ ਕਾਲਿੰਗ PowerShell ਦੇ ਐਗਜ਼ਿਟ ਕੋਡ ਵਜੋਂ ਵਰਤਿਆ।

ਅਤੇ ਅੰਤਿਮ ਜਾਂਚ ਦੇ ਤੌਰ 'ਤੇ, ਆਓ ਬਣਾਈਏ ਸਰਵਰ "ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ (cmdexec)" ਕਿਸਮ ਦਾ ਇੱਕ ਸਿੰਗਲ-ਸਟੈਪ SQL ਟਾਸਕ ਜਿਸ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਟੈਕਸਟ ਹਨ:

PowerShell -NonInteractive -NoProfile "$res=Invoke-Command -ComputerName BACKUPSERVER -ConfigurationName SQLAgent -ScriptBlock {&'D:sqlagentTestOutput1.ps1' 6}; $host.SetShouldExit($res)"

ਵਾਹ! ਕੰਮ ਇੱਕ ਗਲਤੀ ਨਾਲ ਪੂਰਾ ਹੋਇਆ, ਲੌਗ ਵਿੱਚ ਟੈਕਸਟ:

Выполняется от имени пользователя: DOMAINagentuser. Out to host. ExitCode: 6.  Код завершения процесса 6.  Шаг завершился с ошибкой.

ਸਿੱਟਾ:

• Write-Output ਦੀ ਵਰਤੋਂ ਕਰਨ ਅਤੇ ਅਸਾਈਨਮੈਂਟ ਤੋਂ ਬਿਨਾਂ ਸਮੀਕਰਨ ਨਿਰਧਾਰਤ ਕਰਨ ਤੋਂ ਬਚੋ। ਯਾਦ ਰੱਖੋ ਕਿ ਇਸ ਕੋਡ ਨੂੰ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਿਤੇ ਹੋਰ ਲਿਜਾਣ ਨਾਲ ਅਣਕਿਆਸੇ ਨਤੀਜੇ ਨਿਕਲ ਸਕਦੇ ਹਨ।
• ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਜੋ ਮੈਨੂਅਲ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਨਹੀਂ ਬਲਕਿ ਤੁਹਾਡੇ ਆਟੋਮੇਸ਼ਨ ਵਿਧੀਆਂ ਵਿੱਚ ਵਰਤੋਂ ਲਈ ਹਨ, ਖਾਸ ਕਰਕੇ WINRM ਰਾਹੀਂ ਰਿਮੋਟ ਕਾਲਾਂ ਲਈ, Try/Catch ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਨੂਅਲ ਐਰਰ ਹੈਂਡਲਿੰਗ ਲਾਗੂ ਕਰੋ, ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸਕ੍ਰਿਪਟ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਨੂੰ ਬਿਲਕੁਲ ਇੱਕ ਮੁੱਢਲਾ ਮੁੱਲ ਭੇਜਦੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਕਲਾਸਿਕ ਐਰਰਲੈਵਲ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਮੁੱਲ ਸੰਖਿਆਤਮਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸਰੋਤ: www.habr.com