Фильтрация выходных данных




Сколько познаю Perl, все не перестаю удивляться. Столько приятных сюрпризов не встречал еще нигде. Сам язык настолько логичен (если можно так выразиться), что открывает все свои тайны внимательному программисту, причем без частого обращения к документации. Вот и давеча, возникла у меня необходимость отфильтровать выходные данные некой CGI-программы…

Погодите разминать пальцы. Сначала выпьем по кружке кофею, а я, в это время, обрисую ситуацию в целом. Что такое фильтр на выходные данные всем понятно? Ну, если кому не понятно, то опять же – представим. Программа что-то там выводит в STDOUT (стандартный поток вывода), а в это время какая-то другая программа тихо и незаметно ворует эти данные и делает с ними все что заблагорассудится. Реальный пример? Ну, самое первое, что пришло мне в голову – это замена всех URL на гиперссылки. Или в помощь рассеянному программисту, вечно забывающему о HTTP- заголовках, проверять наличие оных заголовков и добавлять их если нужно. На самом деле, все может быть гораздо сложнее. Например, вырезание ненормативной лексики (этакий невидимый цензор) из текста сообщения, отправляемого посредством WEB- интерфейса, перед тем, как оно будет передаваться на вход SENDMAIL. Ну и в таком духе.

В общем, первая наша цель, это каким-то образом подсунуть новый STDOUT, который мы можем прочитать, программе, вывод от которой мы будем фильтровать. Но тут возможны варианты. Например, может быть, мы хотим организовать вывод по типу транзакции: или программа выполняется до конца, и выводится все содержимое, или же, в случае ошибки нужно сбросить данные, а вывести, например, LOCATION на страницу обработки ошибок. То есть, все зависит от уровня контроля над фильтруемым выходным потоком. Что бы совсем стало понятно, о чем я здесь распинаюсь, давайте напишем простой примерчик, демонстрирующий "тупой" фильтр-нумератор строк.

#!/usr/bin/perl –w

# nfilter.pl

filter();

for ($i = 0; $i < 20; $i ++)

{ print "Output line $i\n"; }

sub filter

{

die "Cannot fork" unless defined($fpid = open(STDOUT,"|-"));

return if ($fpid!= 0);

num = 0;

while (<STDIN>) { print "$num:\t$_"; $num ++; }

exit;

}

Не вздумайте запускать. Что, уже запустили? Тогда жмите Ctrl+C. За то, теперь навсегда запомните – нужно закрывать дескрипторы (желательно все:). В чем же дело? Почему программа зависла? Все порожденные процессы являются процессами единой задачи. Потоки ввода вывода автоматически закрываются, когда завершается последний процесс. Конструкция open(STDOUT, "|-") неявно вызывает fork. Вспомните документацию по файловым операциям:

open(HANDLE, "| $cmd"); # направить информацию на вход программы

Так вот, здесь аналогичная ситуация, только в качестве программы здесь создается дочерний процесс. А так как в качестве дескриптора мы указываем STDOUT, то в настоящем процессе он переопределяется. Как и в случае с fork, относительно данных – дублируется их состояние на момент перед вызовом fork. Таким образом, в дочерний процесс попадает нормальный не переопределенный STDOUT. Замечу, что open с указанными аргументами в качестве результата возвращает те же самые значения, что и fork. Далее, программа определяет в каком она потоке – если не в порожденном ($fpid!= 0), тогда возвращается и эмулирует вывод строк. Сам фильтр читает STDIN пока не закончатся данные. А данные закончатся, когда поток ввода будет закрыт (для родительского процесcа, это поток вывода). Родительский процесc уже завершил свою работу, а система ждет когда завершится последний процесс, что бы закрыть потоки. И так далее, и так далее. Чувствуете, где собака зарыта? После того, как вывод строк завершен, необходимо закрыть поток вывода, что бы фильтр, принимающий выходные данные через поток ввода вышел из цикла

while (<STDIN>) { print "$num:\t$_"; $num ++; }

Вот так то, берем и правим

#!/usr/bin/perl –w

# nfilter.pl

filter();

for ($i = 0; $i < 20; $i ++)

{ print "Output line\n"; }

close(STDOUT);

sub filter

{

die "Cannot fork" unless defined($fpid = open(STDOUT,"|-"));

return if ($fpid!= 0);

num = 0;

while (<STDIN>) { print "$num:\t$_"; $num ++; }

exit;

}

Ну это конечно, дюже примитивно. Но если нам нужно только лишь фильтровать, поток вывода, то сойдет. А вот если мы, например, пишем супер-систему обработки ошибок, то этого все-таки маловато. Представим, что этакий сторож фильтрует вывод и сразу отправляет его в настоящий STDOUT. А если возникла фатальная ошибка? Мы выводим сообщение об ошибке, но все это в догонку тому хламу, что уже был отправлен в STDOUT. Такая обработка ошибок, как говорится, "что мертвому припарка". Можно, конечно, накапливать вывод внутри фильтра и выводить только целиком. В случае чего, можно пришибить порожденный процесc с помощью оператора kill. Но увы, поток вывода уже переопределен безвозвратно.

Для решения этой проблемы мы должны кардинально изменить свое мировоззрение. Шучу, конечно. Достаточно вспомнить о таких полезных функциях как select и pipe. Функция select подменяет STDOUT новым дескриптором, а возвращает дескриптор потока вывода, который был актуален на момент до выполнения select, иначе говоря текущий STDOUT. Функция pipe связывает два дескриптора в режиме чтения-записи, то есть создает односторонний канал обмена данными. Отсюда и название – pipe.

Есть очень замечательное свойство систем UNIX - все потоки равны. Прям, коммунизм какой-то. Вот дедушка Ленин бы порадовался. А нам какая с этого польза? Ну как, мы, например, легко можем подсунуть функции select один из дескрипторов, связанных функцией pipe. Естественно, что будем подсовывать тот, который предназначен для записи, иначе я за последствия не ручаюсь. В общем такая незамысловатая программулина

#!/usr/bin/perl –w

# errfilter.pl

my ($fpid,$oldout);

pipe(FOR_READ,FOR_WRITE);

select((select(FOR_READ),$| = 1)[0]);

select((select(FOR_WRITE),$| = 1)[0]);

start_filter();

for ($i = 0; $i < 20; $i ++)

{ print "Output line\n"; }

# Error("bug");

close(FOR_WRITE);

waitpid($fpid,0);

sub start_filter

{

die "Cannot fork" unless defined($fpid = fork);

unless ($fpid == 0)

{

close(FOR_READ);

$oldout = select(FOR_WRITE);

return;

}

close(FOR_WRITE);

my ($out,$num) = ("",0);

while(<FOR_READ>) { $out.= "$num\t$_"; $num ++; }

close(FOR_READ);

print $out;

exit;

}

sub Error

{

my ($error_text) = @_;

select($oldout);

kill KILL => $fpid;

close(FOR_WRITE);

print "Error: $error_text\n";

exit;

}

Ну что, налили очередную порцию кофе? Тогда приступим к разбору полетов. Первым делом, программа связывает два дескриптора FOR_READ и FOR_WRITE в канал с помощью pipe. При этом, FOR_READ получится только для чтения, а FOR_WRITE, соответственно, только для записи. Про следующие две строки скажу только что они отключают буфферизацию. Для нас это пока не важно, их можно вообще убрать. Далее вызывается функция start_filter(). Вот на нее нужно взглянуть со всей внимательностью.

Первым делом, функция создает дубликат процесса. В родительском процессе закрывается ненужный дескриптор для чтения, а в качестве STDOUT подсовывается один конец созданного канала, тот который только для записи. После этого программа возвращается к своему основному бесполезному занятию, а точнее – эмулирует вывод. После того, как вывод завершен, не забываем закрыть дескриптор вывода, иначе все повиснет по причине вышеописанной. Далее ждем, когда дочерний поток завершится (можете закомментировать эту строку, и посмотреть что получится). На этом работа основного процесса завершена.

Вернемся к функции start_filter() в той его части, где выполняется непосредственно фильтрация. Первым делом неиспользуемый в дочернем процессе конец канала закрывается. Далее, процесс в цикле считывает данные из канала и конкатенирует их в переменной $out. Ну далее должно быть все понятно. Запустите программу. Работает? По крайней мере должна.

Теперь уберите комментарии из строки, где вызывается функция Error("bug"). Запустите программу снова. Ну, каков результат? Этого мы добивались? (Правильный ответ да, если нет, то смотрите что вы там понаписали).

Давайте посмотрим, что делает функция Error(). Первым делом восстанавливает стандартный поток вывода. В это время дочерний процесс в режиме накопления данных ничего об этом не подозревает. Следующая жестокая операция убивает дочерний процесс. А дочерний процесс еще ничего не вывел в поток вывода. После закрывается дескриптор для записи, и выполняется обработка ошибки. Ну и что бы миновать последние строки головного процесса выполняется exit.

Вот и все. Как уж вы будете применять полученную информацию на практике, дело ваше.

Что такое переменная

Переменные появились вместе с первыми языками программирования. Результат работы любой программы сводится к манипуляциям над какими-нибудь данными. Вы наверное уже знаете, что память - это последовательность ячеек, каждая из которых представляет собой числовое значение от 0 до 255 - 1 байт. Так как ячеек очень много, единственный вариант как то ориентироваться - это пронумеровать каждую ячейку. Так и есть - каждый байт оперативной памяти доступен процессору посредством порядкового номера ячейки - адреса.

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

С появлением первых языков программировани появилась очень полезная возможность ассоциировать с определенным адресом символьные имена. В отличии от адреса, имя переменной представляется некоторой лексемой, в достаточной мере отражающей содержимое конкретной ячейки памяти. Однако, имя это не все, что характеризует переменную. Так как процессор может работать с тремя типами данных (байт, слово и двойное слово), определение переменной в языках низкого и среднего уровней как правило сопровождается указанием типа переменной. Эти два параметра однозначно определяют расположение ячейки, и способ использования этой ячейки. Определим переменную типа байт (BYTE) с именем А. Естественно, что процессор, зная что переменная, находящаяся по такому адресу соответствует типу BYTE, при извлечении значения этой ячейки выберет такую команду, которая извлекает байт, а не слово или двойное слово.

В общем случае, переменная - это поименованная область памяти. В зависимости от языка, объявление переменной может сопровождаться указанием типа. Обычно, в языках высокого уровня указание типа не используется. Как правило, синтаксические различия между языками чаще всего проявляются именно в способах объявления переменных (C,C++ - конкретизация типа; perl - идентификатор структуры $,@ или %).

Однако, в современном мире программирования имя и тип это еще не все, что программист должен знать о переменной. Существуют такие понятия как пространство имен и область действия. Представьте, что вы пишете программу, в которой используются несколько переменных. Имена все переменных составляют список, определяющий пространство имен. Предположим, в процессе разработки вы допустили ошибку, и объявили две переменные с одинаковыми именами. При попытке собрать программу ваш компилятор предупредит об этой ошибке, что было бы невозможно, если бы имена всех переменных оставались без контроля со стороны компилятора. Таким образом, целостность пространства имен сваливается с плеч программиста на компилятор, что опять же, значительно облегчает процесс разработки и отладки. В действительности, приведенный пример не является ошибочным для всех языков программирования. Каждый компилятор (или интерпретатор) выдвигает свои требования к пространству имен и что в одном языке (в данном случае C и C++) является ошибкой, в других языках может таковой и не быть.

Если раньше программы были достаточно маленькими, что бы уместиться в одном файле, то сейчас исходный код программ может состоять из нескольких файлов. При этом абсолютно нереально запомнить уникальные имена по всей программе. В связи с этим (и не только) было введено понятие области действия (или области видимости) переменной. Область действия понятие абстрактное. Этот термин применителен только по отношению к языкам среднего и высшего уровней. Смысл в том, что бы как-то разбить пространство имен на несколько независимых частей. Таким образом, в одной программе смогут безболезненно сосуществовать несколько переменных с одинаковыми именами и типами. У опытных программистов область действия ассоциируется с текущим программным блоком, но так как мы еще не знаем, что такое программный блок, мы рассмотрим это на другом примере. Новичкам будет более понятна концепция разделения области действия в пределах разных файлов (такая методика используется, например, в perl). Это значит, что переменная объявленная в одном из файлов программы будет абсолютно не видна из других файлов программы (при условии, что мы объявим переменную с помощью спецификатора my). Таким образом, мы можем объявить переменную с именем Variable в нескольких файлах проекта и это не будет ошибкой. Более подробно области действия мы будем рассматривать в процессе разбора программных блоков.

Что такое тип данных

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

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

На этом этапе важно понять, что разные языки предназначены для разных уровней разработки. Например, в языках высокого уровня (таких как perl) не имеет значения строковые данные хранит переменная или числовые. Компилятор (или интерпретатор) самостоятельно определяет как ему интерпретировать значение в зависимости от контекста. Если необходимо выполнить арифметическое сложение, то выполняется попытка преобразовать значение переменной к числовому типу. Если же выполняется конкатенация или интерполяция строки, то любой числовой операнд будет автоматически преобразован к строковому типу.

Для языков более низкого уровня такое разделение более характерно, так как команды процессора работают с числами и строками по разному. А если спустится на самый нижний уровень (то есть на уровень команд процессора, которые в конечном итоге представляют любую программу не зависимо от языка разработки) 32х разрядных процессоров, то такое разделение просто необходимо. Необходимость разделения этих двух типов диктуется тем, что, как я уже говорил, числовые и строковые данные по разному хранятся в памяти. Помимо того, на уровне ассемблера мы увидим всего три типах данных: байт, слово и двойное слово. Последние два представляют собой типы, состоящие из нескольких экземпляров типа байт. Слово состоит из двух, а двойное слово, соответственно, из четырех байт. То есть, в конечном итоге, данные любого типа преобразуются к одному из этих трех числовых типов. Теперь должно быть понятно, почему говорят, что компьютер работает только с числами.

Методика представления символьных (или текстовых) данных в компьютере не так проста, как может показаться на первый взгляд. Во всяком случае, работать со строками гораздо сложнее, нежели с целыми числами. Большинство компиляторов реализуют свои механизмы работы с символьными данными, скрывая от программиста рутинный часто-использующийся код.

Как же хранится в памяти строковое значение? Любой текст состоит из символов и представляет собой определенную последовательность, для которой порядок расположения имеет первостепенное значение. Если не учитывать порядок то смысл текста будет утерян. Каждый символ определяется числовым значением - кодом. Теперь мы можем представить строку как последовательность чисел. Ну а с числами мы уже разобрались.

Теперь давайте разберемся со второй категорией типов данных - пользовательскими типами. Прилагательное "пользовательские" не совсем ясно отражает суть этой категории типов на данном этапе рассмотрения, правильнее было бы называть эти типы расширенными. Однако, это определение сразу же проясняется, когда мы начинаем говорить об этих типах как о наборах, состоящих из базовых типов. Проще всего уяснить суть на примерах. Для простоты мы будем рассматривать программу на языке perl, в котором тип единичного значения не существенен. Например, название улицы, номер дома и номер квартиры можно объединить в набор, представляющий собой новый тип значения - "адрес проживания". При этом, заметьте, что составные элементы нового типа представляют собой значения базовых типов: одного строкового и двух числовых. Однако, компилятор (или интерпретатор) не знает как обрабатывать новый тип "адрес проживания", он лишь знает как его хранить (так как знает способ хранения данных базовых типов). Программист должен реализовать механизм обработки самостоятельно.

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

Использование пользовательских типов данных является промежуточным этапом на пути к исследованию методологии объектно-ориентированного программирования. Этот этап относится к специфики модульного программирования. В качестве примера можно привести язык С, в котором введено понятие структур - возможности описания пользовательских типов, построенных на основе базовых. Структуры в C позволяют не только определять наборы, но также идентифицировать наборы и манипулировать ими на уровне единиц.

Следующим этапом эволюции в программирования было введение понятия класса данных. Методики объектно-ориентированного подхода в программировании очень хорошо просматриваются в языке C++. Считайте класс развитием структуры из C. Структуры позволяли только описывать данные, в то время как класс позволяет не только строить новые типы на основе базовых, но и определять методы обработки нового типа данных. Такое объединение данных и методов принято называть инкапсуляцией.

 



Поделиться:




Поиск по сайту

©2015-2024 poisk-ru.ru
Все права принадлежать их авторам. Данный сайт не претендует на авторства, а предоставляет бесплатное использование.
Дата создания страницы: 2019-07-23 Нарушение авторских прав и Нарушение персональных данных


Поиск по сайту: