Trap exception ошибка

Продолжаем тему обработки ошибок в PowerShell, начатую в предыдущей статье. Сегодня речь пойдет об обработке прерывающих ошибок (исключений). Надо понимать, что сообщение об ошибке — это не то же самое, что исключение. Как вы помните, в PowerShell есть два типа ошибок — непрерывающие и прерывающие.

Непрерывающие ошибки позволяют продолжить работу, тогда как прерывающие останавливают выполнение команды. Остановка приводит к исключению (exception), которое и можно отлавливать и обрабатывать.

Примечание. Таким же образом можно обрабатывать и непрерывающие ошибки. Изменение параметра ErrorAction на Stop прервет выполнение команды и произведет исключение, которое можно уловить.

Для наглядности сгенерируем ошибку, попытавшись прочитать файл, на который у нас нет прав. А теперь обратимся к переменной $Error и выведем данные об исключении. Как видите, данное исключение имеет тип UnauthorizedAccessException и относится к базовому типу System.SystemException.

Для обработки исключений в PowerShell есть несколько способов, которые мы сегодня и рассмотрим.

Try/Catch/Finally

Конструкция Try/Catch/Finally предназначена для обработки исключений, возникающих в процессе выполнения скрипта. В блоке Try располагается исполняемый код, в котором должны отслеживаться ошибки. При возникновении в блоке Try прерывающей ошибки оболочка PowerShell ищет соответствующий блок Catch для обработки этой ошибки, и если он найден, то выполняет находящиеся в нем инструкции. Блок Catch может включать в себя любые команды, необходимые для обработки возникнувшей ошибки иили восстановления дальнейшей работы скрипта.

Блок Finally располагается обычно в конце скрипта. Команды, находящиеся в нем, выполняются в любом случае, независимо от возникновения ошибок. Была ли  ошибка перехвачена и обработана блоком Catch или при выполнении скрипта ошибок не возникало вообще, блок Finally будет выполнен. Присутствие этого блока в скрипте необязательно, основная его задача — высвобождение ресурсов (закрытие процессов, очистка памяти и т.п.).

В качестве примера в блок Try поместим код, который читает файлы из указанной директории. При возникновении проблем блок Catch выводит сообщение об ошибке, после чего отрабатывает блок Finally и работа скрипта завершается:

try {
Get-Content -Path ″C:Files*″ -ErrorAction Stop
}
catch {
Write-Host ″Some error was found.″
}
finally {
Write-Host ″Finish.″
}

Для блока Catch можно указать конкретный тип ошибки, добавив после ключевого слова Catch в квадратных скобках название исключения. Так в следующем примере укажем в качестве типа исключение System.UnauthorizedAccessException, которое возникает при отсутствии необходимых прав доступа к объекту:

try {
Get-Content -Path ″C:Files*″ -ErrorAction Stop
}
catch [System.UnauthorizedAccessException]
{
Write-Host ″File is not accessible.″
}
finally {
Write-Host ″Finish.″
}

Если для блока Catch указан тип ошибки, то этот блок будет обрабатывать только этот тип ошибок, или тип ошибок, наследуемый от указанного типа. При возникновении другого типа ошибка не будет обработана. Если же тип не указан, то блок будет обрабатывать любые типы ошибок, возникающие в блоке Try.

Блок Try может включать несколько блоков Catch, для разных типов ошибок, соответственно можно для каждого типа ошибки задать свой обработчик. Например, возьмем два блока Catch, один для ошибки при отсутствии прав доступа, а второй — для любых других ошибок, которые могут возникнуть в процессе выполнения скрипта:

try {
Get-Content -Path ″C:Files*″ -ErrorAction Stop
}
catch [System.UnauthorizedAccessException]
{
Write-Host ″File is not accessible.″
}
catch {
Write-Host ″Other type of error was found:″
Write-Host ″Exception type is $($_.Exception.GetType().Name)″
}
finally {
Write-Host ″Finish.″
}

Trap

Еще один способ обработки ошибок — это установка ловушки (trap). В этом варианте обработчик ошибок задается с помощью ключевого слова Trap, определяющего список команд, которые должны выполниться при возникновении прерывающей ошибки и исключения. Когда происходит исключение, то оболочка PowerShell ищет в коде инструкции Trap для данной ошибки, и если находит, то выполняет их.

Возьмем наиболее простой пример ловушки, которая обрабатывает все произошедшие исключения и выводит сообщение об ошибке:

trap {
Write-Host ″Error was found.″
}
Get-Content -Path C:File* -ErrorAction Stop

Так же, как и для trycatch, ключевое слово Trap позволяет задавать тип исключения, указав его в квадратных скобках. К примеру, можно задать в скрипте несколько ловушек, одну нацелив на конкретную ошибку, а вторую на обработку оставшихся:

trap [System.Management.Automation.ItemNotFoundException]
{
Write-Host ″File is not accessible.″
break
}
trap {
Write-Host ″Other error was found.″
continue
}
Get-Content -Path C:File* -ErrorAction Stop

Вместе с Trap можно использовать ключевые слова Break и Continue, которые позволяют определить, должен ли скрипт продолжать выполняться после возникновения прерывающей ошибки. По умолчанию при возникновении исключения выполняются команды, входящие в блок Trap, выводится информация об ошибке, после чего выполнение скрипта продолжается со строки, вызвавшей ошибку:

trap {
Write-Host ″Error was found.″
}
Write-Host ″Before error.″
Get-Content -Path C:File* -ErrorAction Stop
Write-Host ″After error.″

Если использовать ключевое слово Break, то при возникновении ошибки будет выполнены команды в блоке Trap, после чего выполнение скрипта будет прервано:

trap {
Write-Host ″Error was found.″
break
}
Write-Host ″Before error.″
Get-Content -Path C:File* -ErrorAction Stop
Write-Host ″After error.″

Как  видно из примера, команда, следующая за исключением, не отработала и сообщение ″After error.″ выведено не было.

Если же в Trap включено ключевое слово Continue, то выполнение скрипта будет продолжено, так же как и в случае по умолчанию. Единственное отличие в том, что с Continue ошибка не записывается в поток Error и не выводится на экран.

trap {
Write-Host ″Error was found.″
continue
}
Write-Host ″Before error.″
Get-Content -Path C:File* -ErrorAction Stop
Write-Host ″After error.″

Область действия

При отлове ошибок с помощью Trap надо помнить о такой вещи, как область действия (scope). Оболочка PowerShell является глобальной областью, в которую входят все процессы, запущенный скрипт получает собственную область, а если внутри скрипта определены функции, то внутри каждой определена своя, частная область действия. Это создает своего рода родительско-дочернюю иерархию.

При появлении исключения оболочка ищет ловушку в текущей области. Если в ней есть ловушка, она выполняется, если нет — то производится выход в вышестоящую область и поиск ловушки там. Когда ловушка находится, то происходит ее выполнение. Затем, если ловушка предусматривает продолжение работы, то оболочка возобновляет выполнение кода, начиная с той строки, которая вызвала исключение, но при этом оставаясь в той же области, не возвращаясь обратно.

Для примера возьмем функцию Content, внутри которой будет выполняться наш код. Область действия внутри функции назовем scope 1, а снаружи scope 2:

trap {
Write-Host ″Error was found.″
continue
}
function Content {
Write-Host ″Before error, scope1.″
Get-Content -Path C:File* -ErrorAction Stop
Write-Host ″After error, scope 1.″
}
Content
Write-Host ″After error, scope 2.″

При возникновении ошибки в функции Content оболочка будет искать ловушку внутри нее. Затем, не найдя ловушку внутри функции, оболочка выйдет из текущей области и будет искать в родительской области. Ловушка там есть, поэтому будет выполнена обработка ошибки, после чего Continue возобновит выполнение скрипта, но уже в родительской области (scope 2), не возвращаясь обратно в функцию (scope 1).

А теперь немного изменим скрипт, поместив ловушку внутрь функции:

function Content {
trap {
Write-Host ″Error was found.″
continue
}
Write-Host ″Before error, scope 1.″
Get-Content -Path C:File* -ErrorAction Stop
Write-Host ″After error, scope 1.″
}
Content
Write-Host ″After error, scope 2.″

Как видите, теперь при возникновении ошибки внутри функции будет произведена обработка ошибки, после чего выполнение  будет продолжено с той строки, в которой произошла ошибка — не выходя из функции.

Заключение

Если сравнить Try/Catch и Trap, то у каждого метода есть свои достоинства и недостатки. Конструкцию Try/Catch можно более точно нацелить на возможную ошибку, так как Catch обрабатывает только содержимое блока Try. Эту особенность удобно использовать при отладке скриптов, для поиска ошибок.

И наоборот, Trap является глобальным обработчиком, отлавливая ошибки во всем скрипте независимо от расположения. На мой взгляд это более жизненный вариант, который больше подходит для постоянной работы.

КРАТКОЕ ОПИСАНИЕ
    Описывает ключевое слово, обрабатывающее прерывающие ошибки.

ПОЛНОЕ ОПИСАНИЕ
    Прерывающая ошибка останавливает выполнение инструкции. Если
    Windows PowerShell не обрабатывает каким-либо образом прерывающую
    ошибку, Windows PowerShell прерывает и функцию или скрипт в
    текущем конвейере. В других языках, например C#, прерывающие
    ошибки называются исключениями.

    Ключевое слово Trap определяет список инструкций, которые нужно
    выполнить при возникновении прерывающей ошибки. Инструкции Trap
    обрабатывают прерывающие ошибки и обеспечивают продолжение
    выполнения скрипта или функции.

  Синтаксис

      Синтаксис инструкции Trap следующий:

          trap [[<тип_ошибки>]] {<список_инструкций>}

      Инструкция Trap включает список инструкций, которые нужно
      выполнить при возникновении прерывающей ошибки. Ключевое слово
      Trap может, кроме того, задавать тип ошибки. Тип ошибки
      указывается в квадратных скобках.

      Скрипт или команда могут содержать несколько инструкций Trap.
      Инструкции Trap можно помещать в любое место скрипта или команды.

  Перехват всех прерывающих ошибок

      При возникновении прерывающей ошибки, которая не обрабатывается
      скриптом или командой, Windows PowerShell проверяет, нет ли
      инструкции Trap для обработки этой ошибки. Если инструкция Trap
      есть, Windows PowerShell продолжает выполнять скрипт или
      команду в инструкции Trap.
 

      Ниже показан пример простейшей инструкции Trap:

          trap {«Обнаружена ошибка.»}

      Эта инструкция Trap перехватывает все прерывающие ошибки. Ниже
      показан пример функции, содержащей эту инструкцию Trap:

          function TrapTest {
              trap {«Обнаружена ошибка.»}
              nonsenseString
              }

      Эта функция включает бессмысленную строку, вызывающую ошибку.
      При выполнении эта функция возвращает следующие результаты:

          C:PS> TrapTest
          Обнаружена ошибка.

      Ниже показан пример инструкции Trap, выводящей ошибку с помощью
      автоматической переменной $_:

          function TrapTest {
              trap {«Обнаружена ошибка: $_»}
              nonsenseString
              }

      При выполнении эта версия функции возвращает следующие результаты:

          C:PS> TrapTest
          Обнаружена ошибка: условие «nonsenseString» не распознано
          как имя командлета, функции, файла скрипта или выполняемой
          программы. Проверьте правильность написания имени, наличие
          и правильность пути и повторите попытку.

      Инструкции Trap могут быть и сложнее. Инструкция Trap может
      включать несколько условий или вызовов функций. Она может
      записывать ошибку в журнал, тестировать или даже запускать
      другую программу.

   Перехват определенных прерывающих ошибок

      Ниже показан пример инструкции Trap, перехватывающей ошибки типа
      CommandNotFoundException:

          trap [System.Management.Automation.CommandNotFoundException]
              {«Перехвачена ошибка команды»}

      Когда функция или скрипт обнаруживает строку, не совпадающую с
      какой-нибудь известной командой, эта инструкция Trap отображает
      строку «Перехвачена ошибка команды». После выполнения
      инструкций списка Trap Windows PowerShell записывает объект
      ошибки в поток ошибок и продолжает выполнять скрипт.

      Windows PowerShell использует типы исключений Microsoft .NET
      Framework 3.0. В показанном ниже примере задается тип ошибок
      System.Exception:

          trap [System.Exception] {«Перехвачена ошибка»}

      Тип ошибок CommandNotFoundException наследуется от типа
      System.Exception. Эта инструкция перехватывает ошибку, которую
      создает неизвестная команда. Она, кроме того, перехватывает
      другие типы ошибок.

      В скрипте может быть несколько инструкций Trap. Одна ошибка
      может быть перехвачена только одной инструкцией Trap. Если
      происходит ошибка и при этом доступно несколько инструкций
      Trap, Windows PowerShell использует ту инструкцию Trap, тип
      ошибок которой лучше всего соответствует ошибке.

      В следующем примере скрипта содержится ошибка. Скрипт включает
      общую инструкцию Trap, перехватывающую любые прерывающие
      ошибки, и определенную инструкцию Trap, для которой задан тип
      CommandNotFoundException.

          trap {«Перехвачена другая прерывающая ошибка» } trap
          [System.Management.Automation.CommandNotFoundException] {«Перехвачена
   ошибка команды»} nonsenseString

      Выполнение скрипта приводит к таким результатам:

          Перехвачена ошибка команды
          Условие «nonsenseString» не распознано как имя командлета,
          функции, файла скрипта или выполняемой программы. Проверьте
          правильность написания имени, наличие и правильность пути и
          повторите попытку.
          В C:PS>testScript1.ps1:3 знак:19
          +   nonsenseString <<<<

      Так как Windows PowerShell не распознает «nonsenseString» как
      командлет или другой элемент, возвращается ошибка
      CommandNotFoundException. Эта прерывающая ошибка перехватывается
      определенной инструкцией Trap.

      Ниже показан пример скрипта с теми же инструкциями Trap, но с
      другой ошибкой:

          trap {«Перехвачена другая прерывающая ошибка» }
   trap [System.Management.Automation.CommandNotFoundException]
              {«Перехвачена ошибка команды»}
          1/$null

      Выполнение скрипта приводит к таким результатам:

          перехвачена другая прерывающая ошибка;
          попытка деления на ноль.
          В C:PS> errorX.ps1:3 знак:7
          +   1/ <<<< $null

      Попытка поделить на ноль не создает ошибку CommandNotFoundExcept
      ion. Эта ошибка перехватывается другой инструкцией Trap,
      предназначенной для любых прерывающих ошибок.

  Перехват ошибок и область

      Если прерывающая ошибка происходит в той же области, где
      находится инструкция Trap, Windows PowerShell после выполнения
      инструкций Trap продолжает с инструкции после ошибки. Если
      ошибка и инструкция Trap находятся в разных областях,
      выполнение продолжается со следующей инструкции из области, в
      которой находится инструкция Trap.
 

      Например, если ошибка происходит в функции, а инструкция Trap
      находится в этой функции, скрипт продолжается со следующей
      инструкции. Например, следующий скрипт содержит ошибку и
      инструкцию Trap:

          function function1 {
              trap { «Ошибка: » }
              NonsenseString
              «function1 выполнена»
              }

      Выполнение функции Function1 в следующей части скрипта приводит
      к таким результатам:

          function1
          Ошибка:
          Условие «NonsenseString» не распознано как имя командлета,
          функции, файла скрипта или выполняемой программы. Проверьте
          правильность написания имени, наличие и правильность пути и
          повторите попытку.
          В C:PS>TestScript1.ps1:3 знак:19
          +   NonsenseString <<<<

          function1 выполнена
 

      Инструкция Trap в функции перехватывает ошибку. После вывода
      сообщения Windows PowerShell продолжает выполнять функцию.
      Обратите внимание, что функция Function1 была выполнена.

      Сравните это со следующим примером, в котором содержатся те же
      ошибка и инструкция Trap. В этом примере инструкция Trap
      выполняется вне функции:

          function function2 {
              NonsenseString
              «function2 выполнена»
              }

          trap { «Ошибка: » }
              . . .
          function2

      Выполнение функции Function2 в следующей части скрипта приводит
      к таким результатам:

          Ошибка:
          Условие «NonsenseString» не распознано как имя командлета,
          функции, файла скрипта или выполняемой программы. Проверьте
          правильность написания имени, наличие и правильность пути и
          повторите попытку.
          В C:PS>TestScript2.ps1:4 знак:19
          +   NonsenseString <<<<

      В этом примере не была выполнена команда «function2 завершена».
      Несмотря на то что обе прерывающие ошибки произошли внутри
      функции, Windows PowerShell не возвращается обратно в функцию
      после выполнения инструкции Trap, потому что инструкция
      находилась вне функции.

  Использование ключевых слов Break и Continue

      Ключевые слова Break и Continue можно использовать в инструкции
      Trap, чтобы определить, будет ли скрипт или команда продолжать
      выполняться после прерывающей ошибки.

      Если в список инструкций Trap включена инструкция Break,
      Windows PowerShell прерывает функцию или скрипт. Следующий
      пример функции использует ключевое слово Break в инструкции Trap:

          C:PS> function break_example {
              trap {«Перехвачена ошибка»; break;}
              1/$null
              «Функция выполнена.»
              }

          C:PS> break_example
          Перехвачена ошибка
          Попытка деления на ноль.
          В строке:4 знак:7

      Инструкция Trap включала ключевое слово Break, поэтому функция
      перестала выполняться и строка «Функция выполнена» запущена не была.

      Если в инструкцию Trap включена инструкция Continue, Windows
      PowerShell продолжает после утверждения, вызвавшего ошибку, как
      если бы ключевых слов Break или Continue не было. Но с ключевым
      словом Continue Windows PowerShell не записывает ошибку в поток
      ошибок.

      Следующий пример функции использует ключевое слово Continue в
      инструкции Trap:

          C:PS> function continue_example {
              trap {«Перехвачена ошибка»; continue;}
       1/$null
              «Функция выполнена.»}

          C:PS> continue_example
          Перехвачена ошибка
          Функция выполнена.

      Функция продолжает выполнение после перехвата ошибки, и
      запускается инструкция «Функция выполнена». Ошибка не
      записывается в поток.

СМ. ТАКЖЕ
    about_Break
    about_Continue
    about_Throw
    about_Try_Catch_Finally
    about_Scopes
    about_Try_Catch_Finally

.

Инструкция Trap для обработки ошибок

Инструкция Trap для обработки ошибок появилась еще в PowerShell 1.0, но я ее по-прежнему часто использую в сценариях. Технология PowerShell построена на базе. NET Framework, и ошибки имеют несколько уровней. Возвращаемое PowerShell сообщение об ошибке верхнего уровня редко помогает решить проблему. Для примера рассмотрим случай использования метода SMO CheckTables(‘FAST’), по сути выполняющего инструкцию DBCC CHECKDB(N’AdventureWorks’, REPAIR_FAST). При вызове этого метода без блока обработки ошибок возвращается сообщение, как на рисунке 1.

Рисунок 1. Сообщение об ошибке, возвращаемое при использовании метода SMO CheckTables (‘FAST’)

Очевидно, что такое сообщение не несет никакой полезной информации, поэтому я часто использую функцию Trap:

# Handle any errors that occur
Trap {
# Handle the error
$err = $_.Exception
write-output $err.Message
while( $err.InnerException ) {
$err = $err.InnerExceptionне
write-output $err.Message
};
# End the script.
Break
}

Это позволяет при вызове метода CheckTables(‘FAST’) получить сообщение, подобное приведенному на рисунке 2.

Рисунок 2. Сообщения об ошибках, возвращаемые функцией Trap

Это сообщение содержит гораздо больше полезной информации и позволяет точно выяснить, в чем состоит проблема, и как ее решить. Ключевое слово break после точки с запятой в инструкции trap инициирует прекращение сценария после обнаружения и обработки ошибки. Ключевое слово continue позволяет продолжить выполнение сценария после обработки ошибок без прерывания.

Метод обработки ошибок Try-Catch-Finally

В PowerShell 2.0 был впервые реализован метод обработки ошибок Try-Catch-Finally, ставший привычным для большинства. NET-разработчиков. Этот метод отличается значительно большей гибкостью в обработке возможных проблем. Дополнительным преимуществом метода является возможность указывать различные типы обработки ошибок для разных ошибок. В приведенном в листинге примере также демонстрируется запуск метода CheckTables. Однако в данном случае каждый объект ItemNotFoundException обрабатывается отдельно, после чего обрабатываются все оставшиеся ошибки способом, аналогичным показанному в инструкции trap.

Очевидно, что такой вариант позволяет обрабатывать различные ошибки, а тот факт, что блоки Try-Catch-Finally могут быть вложенными, обеспечивает широкие возможности управления сценариями.

try {
# Connect to the specified instance
$s = new-object ('Microsoft.SqlServer.Management.Smo.Server') $inst
$db = $s.Databases[$dbname]
$db.CheckTables('Fast')
}
catch [System.Management.Automation.ItemNotFoundException] {
write-output»$dbname database not found«
}
catch {
# Handle the error
$err = $_.Exception
write-output $err.Message
while( $err.InnerException ) {
$err = $err.InnerException
write-output $err.Message
}
}
finally {
write-output»script completed"
}

Try like this:

trap { write-host "file not found, skipping";continue;}
$modtime = Get-ItemProperty c:manoj -erroraction stop

Based on comments from OP:

I think you misunderstood what is being said in the article you have linked to:

In this example, we used continue to caused execution to return to the
scope the trap is in and execute the next command. It’s important to
note that execution only returns to the scope of the trap, so if the
exception was thrown inside a function, or even inside a if statement,
and trapped outside of it … the continue will pick up at the end of
the nested scope.

So if you do something like this:

trap{ write-host $_; continue;}
throw "blah"
write-host after

after will be printed.

But if you do something like this:

trap{ write-host $_ ; continue}
function fun($f) {


      throw "blah"
      write-host after
}

fun
write-host "outside after"

after will NOT be printed, but outside after will be.

Alternatively, use a try-catch block:

      try{
      $modtime = (Get-ItemProperty $f -erroraction stop).LastWriteTime
      write-host "if file not found then shouldn't see this"
      }
      catch{
        write-host "file not found, skipping".
      }