{ # временно помещаем каталог с программой в пути поиска local $ENV{"PATH"} = $path_to_the_program; # каталог system($program_to_execute); # вызов программы } # значение $ENV{"PATH"} будет восстановлено
Выполнение внешних программ можно организовать с помощью функции open, если требуется обмениваться данными с этими программами, используя перенаправление потоков ввода-вывода. Для этого функции open() вместо имени файла передается командная строка с именем выполняемой программы и ее аргументами. Если нужно передать поток данных для обработки из Perl-программы в вызываемую программу, то перед командой указывается символ командного конвейера '|'. Как это делается, видно из очень простого примера, в котором случайным образом генерируются числовые пароли, а затем они направляются для сжатия в архив программой gzip:
# открываем выходной поток, направляем его внешней программе open my $archive, "| gzip > passwords.gz"; for (my $i = 1; $i <= 12; $i++) { # генерируем пароли printf $archive "%06.0f\n", rand 999999; } close $archive; # закрываем выходной поток
Когда нужно принять выходной поток внешней программы для обработки в Perl-программе, то символ конвейера команд '|' ставится в конце командной строки:
# открываем входной поток, полученный от внешней программы open my $archive, "gzip -d < passwords.gz |"; while (my $line = <$archive>) { # читаем пароли из архива print $line; } close $archive; # закрываем выходной поток
(Используемый в примерах архиватор gzip распространяется свободно, версии для самых разных ОС доступны на сайте http://www.gzip.org.)
Иногда требуется организовать выполнение программы таким образом: вначале запускается загрузчик, который, в зависимости от условий, заданных в конфигурации программы, запускает вместо себя основную программу. Этот подход можно реализовать с помощью функции exec, которая заменяет работающую программу на указанную. Так можно запускать не только Perl-программы. Этот прием можно проиллюстрировать таким примером:
print "Выполняется загрузчик: $0, PID:$$\n"; # заменить текущую программу на указанную my $program = $ARGV[0]; # имя программы в 1-м аргументе print "Запускается программа: $program\n"; exec 'perl', $program or die; # запуск программы print "Это сообщение никогда не напечатается!\n";
При запуске этого примера с параметром 'proc_executed.pl' будут выведены такие сообщения:
Выполняется загрузчик: proc_exec.pl, PID:652 Запускается программа: proc_executed.pl Выполняется программа: proc_executed.pl, PID:1872
Для организации параллельного выполнения процессов в Perl используется функция fork ("разветвить"). В результате ее работы создается копия выполняющегося процесса, которая тоже запускается на выполнение. Для этого в операционных системах семейства Unix происходит обращение к системному вызову fork. В других операционных системах работа функции fork() организуется исполняющей системой Perl. Функция fork() в родительском процессе возвращает PID дочернего процесса, число 0 - в дочернем процессе и неопределенное значение при невозможности запустить параллельный процесс. Это значение проверяется в программе, чтобы организовать выполнение различных действий в процессе-предке и процессе-потомке. Как это делается, показано на следующем схематичном примере (где оба процесса в цикле выводят числа, но с разными задержками):
my $pid = fork(); # 'разветвить' текущий процесс # fork вернет 0 в потомке и PID потомка в процессе-предке die "fork не отработал: $!" unless defined $pid; unless ($pid) { # процесс-потомок print "Начался потомок PID $$\n"; for (1..3) { print "Потомок PID $$ работает $_\n"; sleep 2; # 'заснуть' на 2 секунды } print "Закончился потомок PID $$\n"; exit; } if ($pid) { # процесс-предок print "Начался предок PID $$\n"; for (1..3) { print "Предок PID $$ работает $_\n"; sleep 1; # 'заснуть' на 1 секунду } # возможно, здесь нужно ждать завершения потомка: # print "Предок PID $$ ждет завершения $pid\n"; # waitpid $pid, 0; print "Закончился предок PID $$\n"; }
По сообщениям, выводимым при выполнении этого примера, видно, что родительский и порожденный процессы выполняются параллельно. Для того чтобы организовать в родительском процессе ожидание завершения дочернего процесса, применяется функция waitpid(), которой передается PID процесса-потомка (а также, возможно, дополнительные параметры). По выдаваемым сообщениям сравните два варианта выполнения приведенной выше программы - без ожидания завершения дочернего процесса и с ожиданием завершения процесса-потомка (для этого нужно раскомментарить вызов функции waitpid):
Без ожидания потомка С ожиданием потомка по waitpid() ---------------------------- -------------------------------- Начался потомок PID -1024 Начался потомок PID -1908 Потомок PID -1024 работает 1 Потомок PID -1908 работает 1 Начался предок PID 1504 Начался предок PID 1876 Предок PID 1504 работает 1 Предок PID 1876 работает 1 Предок PID 1504 работает 2 Предок PID 1876 работает 2 Потомок PID -1024 работает 2 Потомок PID -1908 работает 2 Предок PID 1504 работает 3 Предок PID 1876 работает 3 Закончился предок PID 1504 Предок PID 1876 ждет завершения -1908 Потомок PID -1024 работает 3 Потомок PID -1908 работает 3 Закончился потомок PID -1024 Закончился потомок PID -1908 Закончился предок PID 1876
Выполнение всей программы заканчивается, когда заканчивается последний порожденный процесс. Ожидание окончания выполнения всех дочерних процессов можно организовать с помощью функции wait(), которая возвращает PID завершившегося подпроцесса и -1, если все процессы-потомки завершили работу.
В Perl есть несколько способов организации взаимодействия процессов при их параллельном выполнении. Один из них - создать программный канал (pipe), который представляет из себя два файловых манипулятора - приемник (reader) и передатчик (writer) - связанных таким образом, что записанные в передатчик данные могут быть прочитаны из приемника. Программный канал создается с помощью функции pipe(), которой передаются имена двух файловых манипуляторов: приемника и источника. Один из вариантов взаимодействия процессов через программный канал показан в следующем примере:
use IO::Handle; # подключаем стандартный модуль pipe(READER, WRITER); # создаем программный канал WRITER->autoflush(1); # включаем авто-очистку буфера if ($pid = fork()) { # процесс-предок получает PID потомка close READER; # предок не будет читать из канала print WRITER "Послано предком (PID $$):\n"; for (my $n = 1; $n <= 5; $n++) { # запись в передатчик print WRITER "$n "; } close WRITER; # закрываем канал и waitpid $pid, 0; # ждем завершения потомка } die "fork не отработал: $!" unless defined $pid; if (!$pid) { # процесс-потомок получает 0 close WRITER; # предок не будет писать в канал print "Потомок (PID $$) прочитал:\n"; while (my $line = <READER>) { # чтение из приемника print "$line"; } close READER; # канал закрывается exit; # потомок завершает работу }
Во время выполнения этого примера в стандартный выходной поток будет выведено следующее:
Потомок (PID -2032) прочитал: Послано предком (PID 372): 1 2 3 4 5
Если нужно организовать передачу данных в обратном направлении, организуется канал, в котором передатчик будет в процессе-потомке, а приемник - в процессе-предке. Так как с помощью программного канала можно передавать данные только в одном направлении, то при необходимости двустороннего обмена данными между процессами создаются два программных канала на передачу в обоих направлениях.
Кроме программных каналов, процессы могут обмениваться информацией и другими способами: через именованные каналы (FIFO) и разделяемые области памяти, если они поддерживаются операционной системой, с помощью сокетов (что будет рассмотрено в следующей лекции) и при помощи сигналов.
В операционных системах имеется механизм, который может доставлять процессу уведомление о наступлении какого-либо события. Этот механизм основан на так называемых сигналах. Работа с ними происходит следующим образом. В программе может быть определен обработчик того или иного сигнала, который автоматически вызывается, когда ОС доставляет сигнал процессу. Сигналы могут отправляться операционной системой, или один процесс может с помощью ОС послать сигнал другому. Процесс, получивший сигнал, сам решает, каким образом реагировать на него, - например, он может проигнорировать сигнал. Перечень сигналов, получение которых можно попытаться обработать, находится в специальном хэше с именем %SIG. Поэтому допустимые идентификаторы сигналов можно вывести функцией keys(%SIG). Общеизвестный пример - сигнал прерывания выполнения программы INT, который посылает программе операционная система по нажатию на консоли сочетания клавиш Ctrl+C. Как устанавливать обработчик конкретного сигнала, показано на примере обработки сигнала INT:
# устанавливаем обработчик сигнала INT $SIG{INT} = \&sig_handler; # ссылка на подпрограмму # начало основной программы print "Работаю в поте лица...\n" while (1); # бесконечный цикл sub sig_handler { # подпрограмма-обработчик сигнала $SIG{INT} = \&sig_handler; # переустанавливаем обработчик print "Получен сигнал INT по нажатию Ctrl+C\n"; print "Заканчиваю работу!\n"; exit; # завершение выполнения программы }
Выполнение примера сопровождается выводом сообщений, подтверждающих обработку поступившего сигнала:
Работаю в поте лица... Получен сигнал INT по нажатию Ctrl+C Заканчиваю работу!
Примером реальной программы, выполняющейся в бесконечном цикле, может служить любой сервер, ожидающий запросов от клиентских программ и перечитывающий свой конфигурационный файл после получения определенного сигнала (обычно HUP или USR1). Если необходимо временно игнорировать какой-то сигнал, то соответствующему элементу хэша %SIG присваивается строка 'IGNORE'. Восстановить стандартную обработку сигнала можно, присвоив соответствующему элементу %SIG строку 'DEFAULT'.
Процесс может посылать сигналы самому себе, например, для отслеживания окончания запланированного периода времени (для обработки тайм-аута). В приведенном примере длительная операция прерывается по истечении указанного промежутка времени:
# устанавливаем обработчик сигнала ALRM (будильник) $SIG{ALRM} = sub { die "Timeout"; }; # анонимная подпрограмма $timeout = 3600; # определяем величину тайм-аута (сек.) eval { # блок обработки возможной ошибки alarm($timeout); # устанавливаем время отправки сигнала # некая длительная операция: print "Работаю в поте лица...\n" while (1); alarm(0); # нормальное завершение операции }; # в специальной переменной $@ - сообщение об ошибке if ($@ =~ /Timeout/) { # проверяем причину ошибки print "Аварийный выход по истечении времени!"; }
Отправка сигнала одним процессом другому также используется в качестве средства взаимодействия процессов. Сигнал отправляется процессу с помощью функции kill(), которой передаются два аргумента: номер сигнала и PID процесса. Схему реагирования порожденного процесса на сигналы, получаемые от процесса-предка, можно увидеть на следующем учебном примере:
my $parent = $$; # PID родительского процесса my $pid = fork(); # 'разветвить' текущий процесс # fork вернет PID потомка в процессе-предке и 0 в потомке die "fork не отработал: $!" unless defined $pid; if ($pid) { # ---------- родительский процесс ---------- print "Начался предок PID $$\n"; for (1..3) { print "Предок PID $$ работает $_\n"; print "Предок PID $$ отправил сигнал\n"; kill HUP, $pid; sleep 2; # 'заснуть' на 2 секунды } print "Закончился предок (PID $$)\n"; } unless ($pid) { # ---------- дочерний процесс ---------- my $counter = 0; # счетчик полученных сигналов $SIG{HUP} = sub { ### обработчик сигнала ### $counter++; print "\tПотомок получил $counter-й сигнал!\n"; }; ### конец обработчика сигнала ### print "\tНачался потомок PID $$ предка $parent\n"; for (1..7) { print "\tПотомок PID $$ работает $_\n"; sleep 1; # 'заснуть' на 1 секунду } print "\tЗакончился потомок PID $$\n"; }
Поведение этих процессов во время выполнения программы можно проследить по выводимым ими сообщениям:
Начался потомок PID -800 предка 696 Потомок PID -800 работает 1 Начался предок PID 696 Предок PID 696 работает 1 Предок PID 696 отправил сигнал Потомок получил 1-й сигнал! Потомок PID -800 работает 2 Предок PID 696 работает 2 Предок PID 696 отправил сигнал Потомок PID -800 работает 3 Потомок получил 2-й сигнал! Потомок PID -800 работает 4 Предок PID 696 работает 3 Предок PID 696 отправил сигнал Потомок PID -800 работает 5 Потомок получил 3-й сигнал! Потомок PID -800 работает 6 Закончился предок (PID 696) Потомок PID -800 работает 7 Закончился потомок PID -800
Сигналы нельзя считать слишком надежным и информативным средством обмена информацией: для передачи данных лучше использовать другие способы. Зато можно проверить состояние дочернего процесса, отправив ему особый нулевой сигнал функцией kill(0, $pid). Этот вызов не влияет на выполнение процесса-потомка, но возвращает истину (1), если процесс "жив", и ложь (0), если он завершился или ему нельзя посылать сигналы. Одинаковая реакция на нулевой сигнал гарантируется на различных платформах. Кроме того, можно прекратить выполнение дочернего процесса, отправив ему сигнал KILL вызовом kill(KILL, $pid).
В последних версиях Perl появилась еще одна модель многозадачности - легковесные процессы (light-weight processes), называемые также потоками управления или нитями. (По-английски фраза "Perl threads" звучит как каламбур и может быть переведена как "нитки жемчуга" или "жемчужные ожерелья"). Нити отличаются от полновесных процессов с независимыми ресурсами тем, что выполняются в рамках одного процесса в единой области памяти. Поэтому создание нити происходит быстрее запуска отдельного процесса и требует меньше ресурсов операционной системы. Выполнение нитей в одной области памяти позволяет эффективно организовать совместный доступ к разделяемым данным. Кроме того, программист получает более полный контроль над параллельно выполняющимися потоками управления. Принципиальное различие между полновесными процессами, созданными операционной системой, и многопоточными нитями показано на рис. 16.1.
Рис. 16.1. Полновесные процессы и нити (потоки управления)
Существует несколько моделей многопоточной обработки, например DEC, Java, POSIX, Win32. Perl предлагает свою модель многопоточного программирования, отличающуюся от перечисленных и имеющую свои достоинства и недостатки. Появление в Perl кросс-платформенных средств работы с легковесными процессами стало несомненным достижением, которое заставило по-новому взглянуть на программирование параллельных процессов. Применение легковесных процессов позволяет разрабатывать эффективные приложения, одинаково выполняющиеся на разных платформах.
Работать с легковесными процессами просто. Подключив средства работы с нитями прагмой use threads, можно создать нить с помощью метода threads->new (синоним: threads->create). Этому методу передается ссылка на именованную или анонимную подпрограмму, которая запускается на выполнение в виде параллельного потока управления. Результатом создания нити станет ссылка на объект типа threads, который будет использоваться для управления потоком. Создание нити выглядит так:
use threads; # подключить многопоточные средства my $thread = threads->new(\&pearl_thread); # запустить нить sub pearl_thread { # эта подпрограмма print "Это нить.\n"; # будет выполняться как нить } #
Итак, в определенной точке программы нить начала выполняться параллельно действиям в основной программе. Куда же должен произойти возврат, когда нить завершится? Это задается в основной программе с помощью метода join, который приостанавливает работу программы до завершения выполнения нити и возвращает результат, вычисленный нитью:
@result = $thread->join;
Действие, выполняемое методом join, называется "присоединение нити" или "объединение потоков". Как это происходит, показано на рис. 16.2.
Рис. 16.2. Присоединение нити с помощью join()
Каждой нити присваивается числовой идентификатор (Thread Identifier, TID), который можно получить с помощью метода tid. Создание нескольких нитей, объединение потоков и возврат значений из параллельно выполняющихся подпрограмм можно показать на таком примере:
use threads; # подключить многопоточные средства my @thread = (); # массив объектов типа threads for (my $i = 0; $i <= 2; $i++) { # создаем 3 нити $thread[$i] = threads->new(\&pearl_thread, $i); print "Создана $i-я нить. TID=", $thread[$i]->tid, "\n"; } for (my $i = 2; $i >= 0; $i--) { # присоединяем нити print "$i-я нить вернула ", $thread[$i]->join, "\n"; } sub pearl_thread ($) { # нить получает my $number = shift; # число, генерирует my $random = int(rand(7)) + 1; # случайное значение, print "\t$number-я нить ждет $random сек.\n"; sleep $random; # и, подождав немного, return $random; # возвращает его }
Сообщения, выводимые при выполнении этой программы, подтверждают независимое выполнение нитей и основной программы:
Создана 0-я нить. TID=1 Создана 1-я нить. TID=2 1-я нить ждет 7 сек. 0-я нить ждет 1 сек. Создана 2-я нить. TID=3 2-я нить ждет 3 сек. 2-я нить вернула 3 1-я нить вернула 7 0-я нить вернула 1
Параллельно выполняющийся поток можно "отсоединить", игнорируя его значение: это делается методом $thread->detach, после выполнения которого присоединить нить будет невозможно.
Нити, выполняющиеся параллельно с основной программой, могут иметь доступ к общим переменным: скалярам, массивам и хэшам. Это делается с помощью явного указания для разделяемой переменной атрибута shared. Помеченная этим атрибутом переменная будет доступна для чтения и изменения в параллельном потоке. Для остальных переменных при отсоединении нити создаются локальные для каждого потока копии. Это демонстрируется таким примитивным примером:
use threads; # подключить многопоточные средства use threads::shared; # и средства разделения данных my $public : shared = 0; # разделяемая переменная my $private = 0; # неразделяемая переменная threads->new(sub { # нить из анонимной подпрограммы $public++; $private++; # изменяем значения print "$public $private\n"; # будет выведено: 1 1 })->join; # дожидаемся результатов выполнения: print "$public ", # 1 ($public изменена в нити) "$private\n"; # 0 (в нити изменена копия $private)
Чтобы предотвратить в одной нити изменение другими нитями значения разделяемой переменной, эту переменную нужно заблокировать при помощи функции lock(). Разблокирование переменной происходит не с помощью функции, а при выходе из блока, в котором она была заблокирована. Это делается таким образом:
{ # блок для работы с разделяемой переменной lock $variable; # заблокировать переменную $variable = $new_value; # и изменить ее значение } # здесь $variable автоматически разблокируется
Нити могут обмениваться между собой данными. Например, с помощью стандартного модуля Thread::Queue организуется очередь для синхронизированной передачи данных из одной нити в другую. Пользоваться такой очередью гораздо проще, чем рассмотренными ранее программными каналами. Небольшой пример показывает, как помещать скалярные величины в очередь методом enqueue() и извлекать из нее методом dequeue(). Метод pending() возвращает число оставшихся в очереди элементов, поэтому может использоваться для окончания цикла чтения из очереди:
use threads; # подключить средства use Thread::Queue; # и модуль работы с очередью my $data_queue = Thread::Queue->new; # создаем очередь my $thread = threads->new(\&reader); # и нить # помещаем в очередь скалярные данные: $data_queue->enqueue(1987); # число $data_queue->enqueue('год'); # строку $data_queue->enqueue('рождения', 'Perl'); # список $thread->join; # ожидаем окончания нити exit; # перед завершением программы sub reader { # извлекаем данные из очереди, while ($data_queue->pending) { # пока она не пуста my $data_element = $data_queue->dequeue; print "'$data_element' извлечен из очереди\n"; } }
Автоматическая синхронизация доступа к очереди гарантирует очередность записи в очередь и чтение из нее, что видно из выполнения этого примера:
'1987' извлечен из очереди 'год' извлечен из очереди 'рождения' извлечен из очереди 'Perl' извлечен из очереди
Конечно, имеющиеся в Perl средства работы с легковесными процессами не ограничиваются перечисленными выше. Стандартные модули предоставляют и другие возможности эффективно организовать различные алгоритмы многопоточной обработки, не говоря уже о дополнительных модулях, имеющихся в архивах CPAN.
Существует много ситуаций, когда применение многозадачности не только оправданно, но и является единственно правильным решением задачи. Поэтому знание средств управления процессами дает вам новую точку зрения на решаемую проблему и расширяет ваш арсенал программных инструментов. В 6-й версии языка Perl средства распределенного программирования будут улучшены и дополнены, появятся сопрограммы (co-routines) и другие интересные возможности.
Лекция 17. Работа в IP-сетях
В этой лекции рассказывается об имеющихся в Perl возможностях обработки данных в IP-сетях, начиная с низкоуровневых средств и заканчивая классами для работы с основными сетевыми протоколами.
Цель лекции: узнать основные механизмы передачи данных по сети и научиться применять их для обработки данных в своих программах, используя стандартные и дополнительные модули Perl.
Сегодня большинство пользователей компьютеров воспринимают возможность обмена данными по компьютерной сети как нечто само собой разумеющееся. Это может быть небольшая офисная сеть из нескольких станций, корпоративная сеть, объединяющая многие сотни компьютеров, или подключение к глобальной сети Интернет. Легкость и удобство работы с многочисленными сетевыми сервисами стала возможной благодаря длительным усилиям многих выдающихся программистов, самых разных компаний и организаций из многих стран мира по созданию существующей инфраструктуры сетевых технологий. Эта инфраструктура основана на огромном числе стандартов, позволяющих согласованно использовать линии связи, аппаратуру передачи данных, компьютеры, операционные системы и прикладные программы для обмена информацией по сети.
Подавляющее большинство широко используемых сетей работает на основе протокола передачи данных IP (Internet Protocol), обеспечивающего надежное перемещение информации между компьютерами в разных сетях. Протокол - это система правил для согласованного взаимодействия при обмене информацией. При сетевом взаимодействии используется целый набор протоколов, обычно называемый стеком протоколов, который подразделяется на несколько уровней. На каждом из уровней выполняются определенные действия и преобразования данных. Протокол IP отвечает за сетевой уровень доставки информации, разделенной на специальные блоки данных, которые называются пакетами (packet).
Для идентификации объединенных в сети компьютеров или других сетевых устройств, обобщенно называемых хостами (host), используются последовательности из четырех чисел - IP-адреса: например, 192.168.82.83 или 172.16.2.73. Назначенный IP-адрес служит уникальным идентификатором хоста в конкретной сети. Кроме того, каждый хост, настроенный на работу с протоколом IP и даже не подключенный к сети, имеет собственный специальный адрес 127.0.0.1 - что-то вроде местоимения "я" на языке сетевых коммуникаций. Хост может иметь доменное имя, соответствующее его IP-адресу, например, имя хоста www.perl.com соответствует адресу 208.201.239.36. Собственному адресу 127.0.0.1 соответствует специальное имя localhost. Поскольку на каждом хосте может выполняться несколько сетевых программ, то для распределения между ними получаемых и отправляемых пакетов используются дополнительные числовые обозначения, так называемые номера портов. Поэтому программная точка отправления или доставки данных в IP-сетях определяется сочетанием адреса и порта, разделенных двоеточием. Многие номера портов по общепринятым соглашениям закреплены за определенными сетевыми службами. Например, обращение к web-серверу на текущей машине будет происходить по адресу и порту 127.0.0.1:80, а к почтовому серверу - по 127.0.0.1:25.
Для установления соединения между хостами и обмена данными в IP-сетях применяется механизм сокетов. Сокеты (socket) можно рассматривать как логические каналы двусторонней связи между сетевыми программами. Сокет определяется адресом хоста, номером порта и используемым протоколом обмена данными. Для организации пересылки данных между программами применяется один из двух протоколов транспортного уровня - UDP или TCP, выполняющихся поверх протокола IP. Протокол UDP (User Datagram Protocol) применяется для обмена независимыми блоками данных, называемыми дейтаграммами (datagram), без их гарантированной доставки адресату. Например, с использованием протокола UDP отправляются запросы управления устройствами или пересылается аудио- или видеотрансляция, когда потеря нескольких передаваемых пакетов не слишком существенна. Протокол TCP (Transmission Control Protocol) применяется для передачи по сети потока данных. При этом контролируется гарантированная доставка упорядоченной последовательности пакетов адресату. При помощи протокола TCP, например, отправляется электронная почта, передаются файлы и доставляются web-страницы.
Даже если в большинстве случаев при сетевом программировании на Perl используются более высокоуровневые средства, полезно хотя бы очень бегло познакомиться с принципами обмена данными через сокеты. Особенностью Perl, отражающей его сетевую направленность, стало то, что многие примитивные сетевые операции встроены в ядро языка, например: socket, socketpair, getsockname, getpeername, setsockopt, bind, listen, accept, send, recv, shutdown. Но гораздо удобнее и надежнее пользоваться стандартными модулями, реализующими средства работы с сокетами. В стандартном модуле Socket определены вспомогательные функции для работы с сокетами. Например, функция inet_ntoa() преобразует в строку двоичное представление IP-адреса, которое возвращает встроенная функция gethostbyname. А функция inet_aton() преобразует строковое представление адреса в двоичный вид, требуемый для встроенной функции gethostbyaddr, определяющей доменное имя хоста по IP-адресу. Работу этих функций можно показать на таком примере:
use Socket; # используем модуль работы с сокетами my $host_name = 'www.perl.com'; # по имени хоста my $address = gethostbyname($host_name); # узнаем адрес и my $ip_address = inet_ntoa($address); # преобразуем его print "$ip_address $host_name\n"; # в строку # результат: 208.201.239.36 www.perl.com $address = inet_aton($ip_address); # и обратно my $host_name = gethostbyaddr($address,AF_INET);# узнаем имя print "$ip_address $host_name\n"; # по адресу # результат: 208.201.239.36 www.perl.com
Класс IO::Socket предоставляет объектный интерфейс для встроенных функций и помогает справиться со многими трудностями и избежать некоторых ошибок при программировании передачи данных через сокеты. Максимально упрощенный пример демонстрирует написание сервера для приема сообщений по протоколу TCP:
use IO::Socket; # используем класс работы с сокетами my $server_port = 5555; # порт для обмена my $server = IO::Socket::INET->new( # создаем сокет LocalPort => $server_port, # на порту Type => SOCK_STREAM, # для потокового обмена Proto => 'tcp', # по протоколу TCP Listen => 10, # с 10-ю соединениями Reuse => 1) # or die "Ошибка запуска TCP сервера на $server_port ($@)"; while (my $client = $server->accept()) { # создаем поток для $client->autoflush(1); # клиента, очищаем буфер, my $message = <$client>; # читаем сообщение из него print $client "OK\n"; # посылаем ответ клиенту close $client; # и закрываем поток print STDERR $message; # выводим сообщение last if $message =~ /STOP/i; # выходим из цикла, если } # в сообщении есть STOP, close $server; # и закрываем сокет
Сокеты могут использоваться не только для обмена данными по сети, но и для межпроцессного взаимодействия, когда сервер и клиент работают на одном и том же компьютере. Для доступа к приведенному серверу можно использовать, например, такую клиентскую программу:
use IO::Socket; # используем модуль работы с сокетами my $server_host = '127.0.0.1'; # адрес сервера my $server_port = 5555; # и порт на нем my $socket = IO::Socket::INET->new( # создаем сокет Type => SOCK_STREAM, # для потокового обмена Proto => 'tcp', # по протоколу TCP PeerAddr => $server_host, # с удаленным адресом PeerPort => $server_port) # и портом or die "Ошибка соединения с $remote_host:$remote_port ($@)"; # сообщение задается my $message = $ARGV[0] || # параметром программы "Проверка связи!"; # или умолчанием print $socket "$message\n"; # отправляем его и my $answer = <$socket>; # принимаем ответ print "$answer"; # выводим ответ close $socket; # и закрываем сокет
Из этого незатейливого примера можно сделать такой вывод: для согласованной работы клиент и сервер должны следовать установленным "правилам общения" во время сеанса обмена данными, так называемому протоколу прикладного уровня. В нашем случае правила сводятся к тому, что обмен идет по порту 5555, сервер ждет от клиента только одно сообщение, клиент ждет обязательного ответа от сервера, который завершает работу по получении сообщения, в котором содержится строка 'STOP'. Подробные соглашения описываются в конкретных протоколах сетевого обмена, например: HTTP (передача гипертекстовых документов), SMTP (отправка электронной почты), FTP (передача файлов). Описание подобных протоколов и других соглашений публикуются в виде предложений RFC (Request For Comment) - фактических международных стандартов, на которые ориентируются разработчики сетевого программного обеспечения.