WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     | 1 |   ...   | 2 | 3 || 5 | 6 |   ...   | 8 |

«Создание сетевых приложений в среде Linux Руководство разработчика Шон Уолтон Москва • Санкт Петербург • Киев 2001 ББК 32.973.26 018.2.75 УДК 681.3.07 Издательский дом "Вильяме" По общим вопросам ...»

-- [ Страница 4 ] --

Таблица 8.1. Параметры функции select() и связанных с ней макросов Параметр Описание maxfd Число, на единицу большее номера самого старшего дескриптора в списке to_read Список дескрипторов каналов, из которых производится чтение данных to_write Список дескрипторов каналов, в которые осуществляется запись данных except Список дескрипторов каналов, предназначенных для чтения приоритетных со общений timeout Число микросекунд, в течение которых необходимо ждать f d Дескриптор добавляемого, удаляемого или проверяемого канала set Список дескрипторов Параметр maxfd равен порядковому номеру старшего дескриптора в списке плюс 1. Каждому заданию выделяется пул дескрипторов ввода вывода (обычно 1024), а каждому из его каналов назначается один дескриптор (первыми идут стандартные каналы: stdin — 0, stdout — 1, stderr — 2). Если в список to_read входят дескрипторы [3,6], в список to_write — дескрипторы [4—6], а в список except — дескрипторы [3,4], то параметр maxfd будет равен 6 (номер старшего де скриптора) плюс 1,т.е. 7.

Параметр timeout задает временной интервал, в течение которого функция вы полняется. Он может принимать следующие значения:

• NULL — функция ждет бесконечно долго;

• положительное число — функция ждет указанное число микросекунд;

• нуль — после проверки всех каналов функция немедленно завершается.

Предположим, в программе открыты три канала с дескрипторами [3,4,6], по которым посылаются данные:

/***************************************************************/ /*** Пример функции selectf) ***/ /***************************************************************/ int count;

fd_set set;

struct timeval timeout;

FD_ZERO(&set);

/* очищаем список */ FD_SET(3, &set);

/* добавляем канал #3 */ FD_SET(4, &set);

/* добавляем канал #4 */ FD_SET(5, &set);

/* добавляем канал #5 */ timeout.tv_sec = 5;

/* тайм аут длится 5,25 с */ Глава 8. Механизмы ввода вывода www.books-shop.com timeout.tv_usec = 250000;

/*— Ожидаем завершения функции select() —*/ if ( (count = select(6+l, &set, 0, 0, &itimeout)) > 0 ) /*** Находим канал, состояние которого изменилось ***/ else if ( count == 0 ) fprintf(stderr, "Timed out!");

else perror("Select");

В данном примере если функция select() возвращает положительное число, значит, в одном из трех каналов появились данные для чтения. Чтобы определить, какой именно из каналов готов, следует написать дополнительный код. Если функ ция возвращает 0, был превышен интервал ожидания, равный 5,25 секунды.

Функция poll() проще, чем select(), и ею легче управлять. В ней использует ся массив структур, определяющих поведение функции:

struct pollfd { int fd;

/* проверяемый дескриптор */ short events;

/* интересующие нас события */ short revents;

/* события, которые произошли в канале */ } В первом поле, fd, содержится дескриптор файла или сокета. Второе и третье поля, events и revents, являются битовыми масками, определяющими события, за которыми требуется следить.

• POLLERR. Любая ошибка. Функция завершается, если в канале возникла ошибка.

• POLLHUP. Отбой на другом конце канала. Функция завершается, если кли ент разрывает соединение.

• POLLIN. Поступили данные. Функция завершается, если во входном бу фере имеются данные.

• POLLINVAL. Канал fd не был открыт. Функция завершается, если канал не является открытым файлом или сокетом.

• POLLPRI. Приоритетные сообщения. Функция завершается, если поступи ло приоритетное сообщение.

• POLLOUT. Канал готов. Функция завершается, если вызов функции write () не будет блокирован.

Объявление функции poll() выглядит так:

linclude int poll(struct pollfd *list, unsigned int cnt, int timeout);

Программа заполняет массив структур pollfd, прежде чем вызвать функцию.

Параметр cnt определяет число дескрипторов в массиве. (Учтите, что массив де скрипторов должен быть непрерывным. Если один из каналов закрывается, необ ходимо переупорядочить, т.е. сжать, массив. Не во всех системах функция poll() 184 Часть II. Создание серверных приложений www.books-shop.com может работать с пустыми структурами.) Параметр timeout аналогичен одноимен ному параметру функции select(), но выражается в миллисекундах.

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

Реализация тайм аутов Вместо опроса каналов можно сообщить операционной системе о том, что ждать требуемого события нужно не дольше указанного времени. В Linux это нельзя сде лать напрямую. Существуют два способа реализации механизма тайм аутов:

• путем задания параметра timeout в функции select() или poll();

• путем посылки программе сигнала SIGALRM по истечении заданного вре мени.

Поддержка тайм аутов для сокетов в Linux Среди атрибутов сокета есть значения тайм аутов для операций чтения (SO_RCVTIMEO) и записи (SQ_SNDTIMEO). К сожалению, в настоящее время эти атрибуты нельзя модифицировать.

Функция select() задает значение тайм аута в микросекундах, а функция poll() — в миллисекундах. Эти функции использовать проще всего, но тайм аут будет применен ко всем каналам, перечисленным в списке.

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

В качестве альтернативы можно воспользоваться сигналом таймера SIGALRM.

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

Любое задание может послать сигнал самому себе, но оно должно знать, как его обрабатывать. В некоторых системах тайм аут задается с помощью функции alarm(), но предварительно следует включить обработку сигнала SIGALRM. Рассмот рим пример:

/*** Пример реализации тайм аута с помощью функции alarm(). ***/ /*** (Взято из файла echo timeout.с на Web узле.) ***/ /**************************************************************/ int sig_alarm(int sig) {/*** ничего не делаем ***/} Глава 8. Механизмы ввода вывода www.books-shop.com void reader() { struct sigaction act;

/* — Инициализируем «структуру — */ bzero(&act, sizeof(act));

act.sa_handler = sig_alarm;

act.sa_flags = SA_ONESHOT;

/* — Активизируем обработчик сигналов,—*/ if ( sigaction (SIGALARM, &act, 0) != 0 ) perror( "Could not set up timeout");

else /* — Если обработчик активизирован, — */ /* — запускаем таймер — */ alarm(TIMEOUT_SEC);

/* — Вызываем функцию, которая может — */ /* — завершиться по тайм ауту —*/ if ( recv(sd, buffer, sizeof(buffer), 0) < 0 ) { if (errno == EINTR) perror ("Timed out!");

} } В этой программе активизируется обработчик сигналов, запускается таймер, после чего вызывается функция recv(). Если за указанный промежуток времени функция не прочитает данные, программа получит сигнал SIGALRM. Выполнение функции recv() будет прервано, а в библиотечную переменную errno запишется код ошибки EINTR.

Чтобы добиться этого, из поля sa_flags структуры sigaction следует удалить флаг SA_RESTART. В главе 7, "Распределение нагрузки: многозадачность", говори лось о том, что при обработке сигналов данный флаг следует задавать. Но как видно из примера, это не относится к режиму тайм аутов.

И последнее замечание: избегайте использовать функцию alarm() вместе с системным вызовом sleep(), так как это может привести к возникновению про блем. Следует либо обрабатывать сигнал SIGALRM, либо вызывать функцию sleep(), но не смешивать их.

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

1 86 Часть II. Создание серверных приложений www.books-shop.com В этой главе рассматривались вопросы, связанные с блокированием ввода вывода (что это такое, когда оно необходимо и для чего оно нужно), а также описывались методики, позволяющие его избежать. Мы познакомились с функ цией fcntl(), ифающей важнейшую роль при переходе в режим неблокируемого ввода вывода.

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

Еще одним важным инструментом являются тайм ауты. Их можно реализовать посредством функции select() или poll() либо с помощью сигнала таймера, ко торый "будит" программу, если системный вызов выполняется слишком долго.

Глава 8. Механизмы ввода вывода www.books-shop.com Глава Повышение производительности В этой главе...

Подготовка к приему запросов на подключение Расширение возможностей сервера с помощью функции select() Анализ возможностей сокета Восстановление дескриптора сокета Досрочная отправка: перекрытие сообщений Проблемы файлового ввода вывода Ввод вывод по запросу: рациональное использование ресурсов процессора Отправка приоритетных сообщений Резюме www.books-shop.com Как добиться максимальной производительности сервера или клиента? В биб лиотеке Socket API имеется ряд средств, позволяющих решить эту задачу доста точно просто. Тем не менее следует рассмотреть проблему под разными углами, поскольку все ее аспекты тесно связаны друг с другом.

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

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

В этой главе приводятся практические советы относительно того, как повы сить производительность приложения.

Подготовка к приему запросов на подключение К настоящему моменту мы узнали, как создать сервер, как сделать его много задачным и как управлять вводом выводом. В главе 7, "Распределение нагрузки:

многозадачность", рассказывалось о том, как поручать задачу приема и обслужи вания запросов на подключение дочерним процессам, создавая их по мере необ ходимости. Однако в некоторых системах создавать каждый раз новое задание расточительно с точки зрения времени и ресурсов. Да и не всегда хочется писать отдельную программу, управляющую только сетевыми клиентами. В любом слу чае необходимо контролировать как размер серверной программы, так и число одновременных подключений, что требует дополнительного программирования.

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

/**************************************************************/ /*** Стандартный алгоритм обслуживания клиентов ***/ /**************************************************************/ int sd;

struct sockaddr_in addr;

if ( (sd = socket(PF_INET, SOCK_STREAM, 0)) < 0 ) PANIC("socket() failed");

bzero(&addr, sizeof(addr));

addr.sin_family = AF_INET;

addr.sin_port = htons(MY_PORT);

Глава 9. Повышение производительности www.books-shop.com addr.sin_addr = INADDR_ANY;

if (bind(sd, &addr, sizeof(addr)) != 0 ) PANIC("bind() failed");

if (listen(sd, 20) != 0) PANIC ("listen() failed");

for (;

;

} { int client, len=sizeof(addr);

client = accept(sd, &addr, &len);

if (client > 0) { int pid;

if ( (pid = fork()) == 0 ) { close(sd);

Child(client);

/* Обслуживаем нового клиента */ } else if( pid > 0 ) close(client);

else perror("fork() failed");

} } Этот алгоритм приводился в главе 7, "Распределение нагрузки: многозадач ность". Он хорошо подходит для обслуживания длительных соединений, таких как процесс регистрации пользователя в системе, сеанс работы с базой данных и т.д. Однако у него есть один существенный недостаток: что если исчерпается список доступных идентификаторов процессов? Что произойдет, если ресурсов ОЗУ окажется недостаточно для обслуживания существующего числа процессов и программе придется выгружать часть данных в файл подкачки? Эта проблема ха рактерна для процессов "кроликов".

Разница между ОЗУ и виртуальной памятью Может показаться, что выделение для файла подкачки большого раздела на диске решает мно гие проблемы в системе, но это обманчивое впечатление. На самом деле, чтобы добиться высо кой производительности, необходимо держать все активные процессы вместе со своими данны ми в ОЗУ. Если процесс был выгружен на диск, то время, затрачиваемое ядром на его после дующую загрузку обратно в память, сводит на нет скорость работы программы. Для решения проблемы производительности необходимо в первую очередь определить, какие ограничения существуют с точки зрения памяти, процессора и устройств ввода вывода.

Можно осуществлять подсчет числа процессов:

/***************************************************************/ /*** Алгоритм, в котором ограничено число потомков. ***/ /*** (Взято из файла capped servlets.c на Web узле.) ***/ /***************************************************************/ int ChildCount=0;

void sig_child(int sig) { wait(O);

ChildCount —;

} 190 Часть II. Создание серверных приложений www.books-shop.com for (;

;

) { int client, len=sizeof (addr);

while ( ChildCount >= MAXCLIENTS ) sleep(l);

client = accept (sd, &addr, &len);

if ( client > 0 ) { int pid;

if ( (pid = fork()) == 0 ) {/* — Потомок — */ close(sd);

Child(client);

/* — Обслуживаем нового клиента — */ } else if ( pid > 0 ) {/* — Предок — */ ChildCount++;

close(client) ;

} else perror("fork() failed");

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

Опять таки, этот алгоритм хорошо работает в случае длительных соединений.

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

Предварительное ветвление сервера На сервере могут выполняться 5—20 процессов, предназначенных для приема запросов от клиентов. Именно так распределяет нагрузку HTTP сервер. (Если в системе инсталлирован и запущен демон httpd, загляните в таблицу процессов, и вы обнаружите, что выполняется несколько его экземпляров.) Как потомок полу чает необходимую информацию, если в процессах не происходит совместного ис пользования данных? Ответ заключен в следующем фрагменте программы:

/***************************************************************/ /*** Фрагмент дочернего процесса ***/ /**************************************************************/ if ( (pid = fork()) == 0 ) { close(sd);

Child(client) ;

/* — Обслуживаем нового клиента —*/ } Глава 9. Повышение производительности piracy@books-shop.com Как можно заметить, дочерний процесс закрывает дескриптор сокета (sd). Но ведь клиентский дескриптор идентифицирует само соединение! Зачем процесс его закрывает?

Дело в том, что, когда создается дочерний процесс, он принимает дескрипто ры открытых файлов от своего родителя. Если какой либо из файлов потомку не нужен, он может его закрыть — это не повлияет на работу предка. В то же время файл можно вполне оставить открытым и продолжать читать или записывать в него данные параллельно с родительским процессом. Вот как создается несколь ко процессов, обслуживающих один и тот же сокет:

/*** Создание набора серверов потомков, ожидающих запросов ***/ /*** на установление соединения. ***/ /*** (Взято из файла preforking servlets.c на Web узле.) ***/ /***************************************************************/ int ChildCount=0;

void sig_child(int sig) { wait(O);

ChildCount— ;

main() /*** Регистрируем обработчик сигналов;

создаем и инициализируем сокет ***/ for (;

;

) if ( ChildCount < MAXCLIENTS ) if ( (pid = fork()) == 0 ) /*— Потомок —*/ for (;

;

) int client = accept(sd, 0, 0);

Child(client);

/*— Обслуживаем нового клиента —*/ else if ( pid > 0 ) /*— Предок —*/ ChildCount++;

else perror("fork() failed");

else sleep(l);

} } Здесь применяется обратный порядок вызова функций accept() и fork(): вме сто того чтобы создавать новый процесс после подключения, программа сначала запускает дочерний процесс, который затем ожидает поступления запросов.

В этом фрагменте может быть создано, к примеру, 10 процессов. Все они вхо дят в бесконечный цикл ожидания запросов. Если запросы не поступают, про 192 Часть П. Создание серверных приложений www.books-shop.com цессы блокируются (переходят в "спящий" режим). Когда появляется запрос, все процессы "пробуждаются", но только один из них устанавливает соединение, а остальные девять снова "отходят ко сну". Подобный цикл продолжается беско нечно долго.

Что произойдет, если один из процессов завершит работу? Именно по причи не возможности такого события в родительском процессе не происходит вызова функции accept(). Основная задача предка состоит в том, чтобы поддерживать нужное число потомков.

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

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

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

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

Первую задачу нельзя решить напрямую. Вспомните, что у каждого TCP сервера имеется очередь ожидания, создаваемая с помощью системного вызова listen(). Сетевая подсистема помещает в нее каждый поступающий запрос на подключение, а уже функция accept() принимает запрос и создает выделенный канал связи с клиентом. Если клиент ожидает своей очереди слишком долго, его терпение в конце концов заканчивается.

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

Глава 9. Повышение производительности www.books-shop.com Один из возможных методов напоминает ловлю рыбы на приманку. Рыбак пе риодически забрасывает наживку, а рыба ее съедает. Частота, с которой повторя ется этот процесс, позволяет определить, сколько рыбы водится в пруду или дан ном месте реки.

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

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

Именно здесь на помощь приходит статистика. В адаптивном алгоритме воз можны три ситуации: число соединений стабильно, растет или уменьшается. В первом случае в течение заданного промежутка времени число созданных сервле тов равно числу завершившихся. Например, если сервер порождает один сервлет каждые 60 секунд (с 30 секундным предельным временем простоя), схема этого процесса будет соответствовать верхней части рис. 9.1.

Рис. 9.1. Когда имеются необслуженные запросы, сервер создает дополнительные сервлеты Если число соединений увеличивается, то количество завершившихся сервле тов будет меньше, чем созданных. Отсутствие в течение заданного промежутка времени сигнала о завершении сервлета можно считать признаком того, что он обслуживает запрос на подключение. В этом случае сервер удваивает скорость создания сервлетов (см. рис. 9.1, внизу). Процесс продолжается до тех пор, пока не будет достигнута максимальная частота вызова функции fork() (к примеру, каждые 5 секунд).

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

/*** Адаптивный алгоритм создания сервлетов ***/ /*** (Взято из файла servlet chumner.c на Web узле.) ***/ /**************************************************************/ 194 Часть II. Создание серверных приложений www.books-shop.com int delay=MAXDELAY;

/* например, 5 секунд */ time_t lasttime;

void sig_child(int signum) { wait(O);

/* подтверждаем завершение */ timej&lasttime);

/* определяем текущее время */ delay = MAXDELAY;

/* сбрасываем значение задержки */ } void Chuiraner( void (*servlet)(void)) { time(&lasttime) ;

/* запоминаем дату начала процесса */ for (;

;

) { if ( !fork() ) /* создаем новый сервер */ servlet();

/* вызываем потомка (должен завершиться/ с помощью функции exit()) */ sleep(delay);

/* берем тайм аут */ /* если ни один из сервлетов не завершился, удваиваем частоту */ if ( times[0] timesll] >= delay 1 ) if ( delay > MINDELAY ) /* не опускаемся ниже минимального порога */ delay /= 2;

/* удваиваем частоту */ } } В этом фрагменте программы демонстрируется, как управлять группой сервле тов, проверяя время последнего завершения сервлета. При завершении также происходит сброс таймера (переменной delay), чтобы процесс начался заново.

Расширение возможностей сервера с помощью функции select() Применение процессов для управления соединениями — это достаточно по нятный и эффективный способ распределения задач на сервере. Эффективность обработки запросов еще более повышается, если ограничить число одновременно выполняющихся процессов и осуществлять их предварительное ветвление. Одна ко в рассмотренном алгоритме есть одна фундаментальная проблема: стихийное "затопление" планировщика лавиной процессов.

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

Глава 9. Повышение производительности www.books-shop.com Таблица процессов легко может включать несколько сотен процессов. В зависи мости от объема имеющейся оперативной памяти и размера файла подкачки число процессов может быть еще большим. Но подумайте о следующем ограничении:

Linux переключается между процессами каждые 10 мс. Сюда еще не входят задерж ки, связанные с выгрузкой контекста старого процесса и загрузкой нового.

Например, если работают 200 сервлетов, каждый процесс будет ждать 2 с, что бы получить маленькую долю процессорного времени в системе, где переключе ние задач происходит каждые 0,01 с. При условии, что в этом промежутке пере дается 1 Кбайт данных, общая скорость передачи данных составит 200 Кбайт/с в сети с пропускной способностью 10 Мбит/с (примерная норма в сетях TCP/IP).

Но в каждом конкретном соединении скорость передачи будет лишь 512 байт/с.

Это основное следствие неконтролируемого роста числа процессов.

Вторая проблема связана с сутью механизма предварительного ветвления: не сколько процессов могут ожидать одного и того же запроса на подключение.

Предположим, сервер создал 20 сервлетов и заблокировал их в ожидании запроса.

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

Решение проблемы "лавинного схода" в ядре Трудность, связанная с написанием книги по такой стремительно меняющейся системе, как Linux, заключается в том, что информация очень быстро устаревает. В Linux 2.4 проблема "лавинного схода" решена за счет того, что ядро посылает сигнал пробуждения только одному из заблокированных процессов.

Чрезмерное использование функции select() Одно из решений перечисленных проблем заключается в отказе от многоза дачности. В предыдущей главе рассказывалось о двух системных вызовах, позво ляющих реализовать переключение каналов ввода вывода: select() и poll(). Эти функции могут заменить собой сервлеты.

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

Однако соблазн отказаться от многозадачности и перейти к методике опроса каналов может привести к потере производительности. Когда за обработку ин формации отвечает одно задание, серверу приходится периодически ожидать вво да вывода. При этом теряется возможность выполнять другие действия. К приме ру, тот, кому когда либо приходилось компилировать ядро, наверняка замечал, что компиляция протекает быстрее, если задать многозадачный режим с помо щью опции j утилиты make. (При наличии достаточного количества оперативной памяти распределение обязанностей между двумя или тремя заданиями на каж дый процессор позволяет существенно сократить время компиляции.) 196 Часть П. Создание серверных приложений www.books-shop.com Разумное использование функции select() При создании мощного многопользовательского сервера распределять нагрузку можно различными способами. Два из них — это многозадачность и опрос кана лов ввода вывода. Но если использовать только многозадачный режим, можно потерять контроль над системным планировщиком и драгоценное время на бес конечном переключении задач. Если работать только по методике опроса, будут возникать периоды простоя и сократится пропускная способность сервера. Реше ние заключается в объединении двух методик. Разумно используя функцию select(), можно понизить влияние "узких мест" обеих методик, не теряя при этом никаких преимуществ.

В рассматриваемом алгоритме создается несколько процессов. С каждым из них связан набор открытых клиентских каналов. Переключением каналов управ ляет функция select().

/*** Пример разумного использования функции select(): каждый ***/ /*** потомок пытается принять запрос на подключение и в ***/ /*** случае успеха добавляет дескриптор соединения в список. ***/ /*** (Взято из файла smart select.с на Web yзлe.) ***/ int sd, maxfd=0;

fd_set set;

FD_ZERO(&set);

/*** Создание сокета и вызов функции fork() * * * / > :

/* — в дочернем процессе — */ maxfd ~ sd;

FD SET(sd, &set);

for(;

;

) { struct timeval timeout={2,0};

/* 2 секунды */ /* — Ожидаем команды — */ if ( select (maxfd+1, &set, 0, 0, stimeout) > 0 ) { /* — Если новое соединение, принимаем его — */ /* — и добавляем дескриптор в список — */ if ( FD_ISSET(sd, &set) ) { int client = accept(sd, 0, 0);

if ( maxfd < client ) maxfd = client;

FD SET(client, &set);

} /* — Если запрос от существующего клиента, — */ /*— обрабатываем его—*/ else /*** обработка запроса ***/ /* — ЕСЛИ клиент завершил работу, — */ /* — удаляем дескриптор из списка — */ } Глава 9. Повышение производительности www.books-shop.com В этой программе создается небольшое число процессов (намного меньше, чем в чисто многозадачном сервере), например 5—10 сервлетов, С каждым из сервлетов, в свою очередь, может быть связано 5 10 соединений.

Коллизии выбора Возможно, читателям доводилось слышать о проблеме в ВSD системах, которая называется коллизия выбора. В рассмотренной программе предполагается, что функция select() "пробуждается" только в том случае, когда меняется состояние одного из дескрипторов. Однако в BSD4.4 пробуждаются одновременно все процессы, заблокированные функцией select().

Похоже, что ОС Linux лишена подобного ограничения.

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

Данный алгоритм без труда реализуется в серверах, не хранящих информацию о состоянии транзакции. В этом случае транзакции, выполняемые на сервере, не должны иметь никакой связи друг с другом, а в каждом соединении должна вы полняться только одна транзакция. По такой схеме работают серверы с кратко временными соединениями, например HTTP сервер, сервер запросов к базе дан ных и модуль переадресации Web броузера.

Проблемы реализации Несложно заметить, что и в описанном алгоритме есть ряд недостатков. Пер вый из них заключается в том, сервер не может гарантировать одинаковую за грузку сервлетов. Чтобы устранить этот недостаток, можно добавить в программу ограничение на число создаваемых соединений в каждом сервлете:

/*** Ограничение числа соединений в сервлете ***/ /***********************************************/ if ( FD_ISSET(sd, &set) ) if ( ceiling < MAXCONNECTIONS ) { int client = accept(sd, 0, 0);

if ( maxfd < client ) maxfd = client;

FD_SET(client, &set);

ceiling++;

} Когда лимит соединений в данном сервлете исчерпан, запрос передается дру гому сервлету. Тем не менее распределение соединений между сервлетами осуще ствляется случайным образом.

Другой недостаток связан с контекстом соединения. Когда клиент подключа ется к серверу, последний проходит через несколько режимов работы, например режим регистрации и режим сеанса (если только сервер не работает в режиме от дельных транзакций). В предыдущем фрагменте профамма всегда возвращается в состояние ожидания после приема запроса. Если требуется отслеживать состоя 198 Часть IL Создание серверных приложений www.books-shop.com ние каждого соединения, необходимо проверять, какое именно сообщение при ходит по заданному соединению. Это не сложно реализовать, но необходимо тщательно спланировать программу.

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

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

Необходимо создать массив дескрипторов и воспользоваться функцией poll().

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

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

/****************************************************************/ /*** Пример распределения нагрузки: родительский поток ***/ /*** принимает запросы на подключение и распределяет их ***/ /*** между дочерними потоками. ***/ /*** (Взято из файла fair load.с на Web узле.) ***/ /****************************************************************/ int fd_count=0;

struct pollfd fds[MAXFDs];

/* обнуляется с помощью функции bzero() */ /*— Родительский поток —*/ int sd = socket(PF_INET, SOCK_STREAM, 0);

/*** Вызов функций bind() и llsten() ***/ for (;

;

) { int i;

/*— Проверяем наличие свободных позиций в очереди, —*/ /* — прежде чем принять запрос —*/ for ( i=0;

i

i++ ) if ( fds[i].events == 0 ) break;

if ( i == fd_count && fd_count < MAXFDs ) Глава 9. Повышение производительности www.books-shop.com fd_count++;

/* — ЕСЛИ свободные позиции имеются — */ ?

/* — устанавливаем соединение — */ if (i < fd_count) { fds[i].fd = accept (sd, 0,0);

fds[i].events = POLLIN | POLLHUP;

} else /* в противном случае ненадолго переходим */ sleep(1);

/* в "спящий" режим *[ } /* — Дочерний поток — */ void *Servlet(void *init) { int start = *(int*)init;

/* начало диапазона дескрипторов */ for (;

;

) { int result;

/* ожидаем 0,5 секунды */ if ( (result = poll(fds+start, RANGE, 500)) > 0 ) { int i;

for (i = 0;

i < RANGE;

i++) { if ( fds[i).revents & POLLIN ) /*** Обрабатываем сообщение.***/, else if ( fds[i].revents & POLLHUP ) /*** Разрываем соединение ***/ } } else if ( result < 0 ) perror( "poll() error");

Из приведенного фрагмента видно, как распределяются обязанности между предком и потомком. Родительский поток принимает запросы и помещает деск рипторы соединений в массив fds[]. Дочерний поток ожидает изменения состоя ния дескрипторов во вверенном ему диапазоне. (Если поле events в структуре pollfd равно нулю, функция poll() пропустит этот элемент массива. Если актив ных соединений нет, функция просто дождется окончания тайм аута и вернет 0.) Работать с потоками можно и в клиентской программе. Как рассказывалось в главе 7, "Распределение нагрузки: многозадачность", потоки очень полезны, ко гда требуется одновременно отправлять несколько независимых запросов, прини мать данные и обрабатывать их. Клиент может все это делать, поскольку большая часть времени в сетевых соединениях тратится на ожидание ответа сервера.

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

200 Чисть II, Создание серверных приложений www.books-shop.com Управление параметрами сокетов осуществляется с помощью функций getsockopt() и setsockopt(). Они позволяют конфигурировать как общие парамет ры, так и те, что зависят от протокола (полный список всех возможных парамет ров представлен в приложении А, "Информационные таблицы"). Прототипы этих функций таковы:

int getsockopt(int sd, int level, int optname, void *optval, socklen_t *optlen);

int setsockopt(int sd, int level, int optname, const void *optval, socklen_t optlen);

Каждый параметр относится к определенному уровню. В настоящее время в Linux определены 4 уровня: SOL_SOCKET, SOL_IP, SOL_IPV6 и SOL_TCP. В основном все параметры являются целочисленными или булевыми. При вызове любой из функций значение параметра передается через аргумент optval, а размерность значения указывается в аргументе optlen. В последнем аргументе функция getsockopt() возвращает реальное число байтов, занимаемое параметром.

Например, ниже показано, как сбросить флаг SOJCEEPALIVE:

/*** Пример функции setsockopt() ***/ int value=0;

/* FALSE */ if ( setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, Svalue, sizeof(value)) != 0 ) perror("setsockopt() failed");

А вот как можно узнать тип сокета:

/*** Пример функции getsockopt() ***/ int value;

int val size = sizeof(value);

if ( getsockopt(sd, SOL_SOCKET, SO_TYPE, &value, &value)) != 0 ) perror("getsockopt()failed");

" Общие параметры Общие параметры применимы ко всем сокетам. Они относятся к уровню SOL_SOCKET.

• SO_BROADCAST. Позволяет сокету посылать и принимать широковещатель ные сообщения. В широковещательном адресе все биты маски активной подсети равны единице (см. главу 2, "Основы TCP/IP"). Режим широ ковещания поддерживается не во всех сетях. Там, где он допустим, в этом режиме могут передаваться только дейтаграммы. (Булево значение, по умолчанию False) • SO_DEBUG. Включает/отключает режим регистрации всех отправляемых и принимаемых сообщений. Эта возможность поддерживается только в протоколе TCP. (Булево значение, по умолчанию False.) Глава 9. Повышение производительности piracy@books-shop.com SO_DONTROUTE. Включает/отключает маршрутизацию. В редких случаях пакеты не должны подвергаться маршрутизации. Например, это могут быть пакеты конфигурирования самого маршрутизатора. (Булево значе ние, по умолчанию False.) SO_ERROR. Содержит код последней ошибки сокета. Если не запросить этот параметр до момента выполнения следующей операции ввода вывода, будет установлена библиотечная переменная errno. (Целочисленное зна чение, по умолчанию 0, только для чтения.).

SO_KEEPALIVE. Если ТСР сокет не получает от внешнего узла сведений в течение двух часов, он посылает серию сообщений, пытаясь повторно установить соединение или определить причину проблемы. (Булево зна чение, по умолчанию True.) SO LINGER. Сркет не будет закрыт, если в его буферах есть данные. Функ ция close () помечает сокет как подлежащий закрытию (но не закрывает его) и немедленно завершается. Этот параметр сообщает сокету о том, что программа должна дождаться его закрытия. Значение параметра представ ляет собой структуру типа linger, в которой есть два поля: l_onoff (включить/отключить режим задержки) и l_linger (максимальная задерж ка в секундах). Когда режим задержки включен, а поле 1_linger равно ну лю, при закрытии сокета произойдет потеря содержимого буферов. Если же это поле не равно нулю, функция close() будет ждать в течение ука занного периода времени. (Структура типа linger, по умолчанию режим отключен.) SO_OOBINLINE. Через сокет можно посылать очень короткие сообщения, которые принимающая сторона не будет помещать в очередь, — они пе редаются отдельно (вне основной полосы пропускания). Режим внепо лосной передачи можно применять для передачи срочных сообщений.

Установка этого флага приводит к помещению внеполосных данных в обычную очередь, откуда сокет может прочесть их традиционным спо собом. (Булево значение, по умолчанию False.) SO_PASSCRED. Включает/отключает режим передачи пользовательских идентификаторов. (Булево значение, по умолчанию False.) SO_PEERCRED. Задает атрибуты идентификации передающей стороны (идентификаторы пользователя, группы и процесса). (Структура Типа ucred, по умолчанию обнулена.) SO_RCVBUF. С помощью этого параметра можно изменить размер входного буфера. Для TCP это значение должно быть в 3—4 раза больше макси мального размера сегмента (см. параметр TCP MAXSEG). В UDP подобная возможность недоступна, и все данные, не помещающиеся в буфере, бу дут потеряны. (Целочисленное значение, по умолчанию 65535 байтов.) SO_RCVLOWAT. Применяется в функциях, связанных с опросом каналов, и в режиме сигнального ввода вывода. Задает минимальное число байтов, после приема которых сокет будет считаться доступным для чтения. В Linux этот параметр доступен только для чтения. (Целочисленное значе ние, по умолчанию 1 байт.) 202 Часть П. Создание серверных приложений www.books-shop.com SO_RCVTIMEO. Задает предельную длительность тайм аута при чтении.

Когда функция чтения (read(), readv(), recv(), recvfrom() или recvmsg()) превышает указанное время ожидания, генерируется сообщение об ошибке. (Структура типа timeval, по умолчанию 1 с, только для чтения.) SO_REUSEADDR. С помощью этого параметра можно создать два сокета, ко торые совместно используют соединение по одному и тому же адре су/порту. Допускается совместное использование порта несколькими со кетами в пределах одного процесса, разных процессов и разных про грамм. Данный параметр полезен, когда сервер "рухнул" и его необходимо быстро перезапустить. Ядро обычно резервирует порт в те чение нескольких секунд после завершения его программы владельца.

Если в результате вызова функции bind() возникает ошибка "Port already used" (порт уже используется), установите рассматриваемый флаг, чтобы избежать этой ошибки. (Булево значение, по умолчанию False.) SO_SNDBUF. Позволяет задать размер выходного буфера. (Целочисленное значение.) SO_SNDLOWAT. Задает минимальный размер выходного буфера. Функция, связанная с опросом каналов, сообщает о том, что сокет готов для запи си, когда в буфере освобождается указанное число байтов. В режиме сигнального ввода вывода программа получает сигнал, когда в буфер за писывается данное количество байтов. В Linux этот параметр доступен только для чтения. (Целочисленное значение, по умолчанию 1 байт.) SO_SNDTIMEO. Задает предельную длительность тайм аута при записи. Ко гда функция записи (write(), writev(), send(), sendto() или sendmsg()) превышает указанное время ожидания, генерируется сообщение об ошибке. (Структура типа timeval, по умолчанию 1 с, только для чтения.) SO_TYPE. Содержит тип сокета. Это значение соответствует второму па раметру функции socket(). (Целочисленное значение, по умолчанию не инициализировано, только для чтения.) Параметры протокола IP Перечисленные ниже параметры применимы к дейтаграммным и неструктури рованным сокетам. Они относятся к уровню SOL_IP.

• IP_ADD_MEMBERSHIP. С помощью этого параметра происходит добавление адресата к группе многоадресной доставки сообщений. (Структура типа ip_mreq, по умолчанию не инициализирована, только для записи.) • IP_DROP_MEMBERSHIP. С помощью этого параметра происходит удаление адресата из группы многоадресной доставки сообщений. (Структура ти па ipjnreq, по умолчанию не инициализирована, только для записи.) • IP_HDRINCL. Установка этого флага свидетельствует о создании заголовка неструктурированного IP пакета. Единственное поле, которое не нужно заполнять, — это контрольная сумма. Данный параметр предназначен только для неструктурированных сокетов. (Булево значение, по умолча нию False.) Глава 9. Повышение производительности www.books-shop.com IP_MTU_DISCOVER. Позволяет начать процесс определения максимального размера передаваемого блока (MTU Maximum Transmission Unit). При этом отправитель и получатель договариваются о размере пакета. Дан ный параметр может принимать три значения:

• IP_PMTUDISC_DONT (0) — никогда не посылать нефрагментированные пакеты;

• IP_PMTUDISC WANT (1) — пользоваться подсказками конкретного уз ла;

• IP_PMTUDISC DO (2) — всегда посылать нефрагментированные паке ты. (Целочисленное значение, по умолчанию режим отключен.) IP_MULTICAST_IF. Задает исходящий групповой адрес сообщения, пред ставляющий собой адрес в стандарте IPv4, связанный с аппаратным уст ройством. У большинства машин есть только одна сетевая плата и один адрес, но у некоторых их больше. С помощью данного параметра можно выбрать, какой из адресов следует использовать. (Структура типа in_addr, по умолчанию в поле адреса записана константа INADDR_ANY.) IP_MULTICAST_LOOP. Разрешает обратную групповую связь. Входной буфер передающей программы получит копию отправляемого сообщения.

(Булево значение, по умолчанию False.) IP_MULTICAST_TTL. Задает максимальное число переходов (TTL — Time To Live) для сообщений, отправляемых в режиме групповой передачи. Если требуется вести групповое вещание в Internet, необходимо правильно инициализировать этот параметр, так как по умолчанию разрешен толь ко один переход. (Целочисленное значение, по умолчанию 1.) IP_OPTIONS. Позволяет выбирать конкретные IP опции. Эти опции пере даются в заголовке IP пакета и сообщают принимающей стороне раз личную служебную информацию (метки времени, уровень безопасности, предупреждения и т.д.). (Массив байтов, по умолчанию пуст.) IP_TOS. Позволяет определить тип обслуживания (TOS — Type Of Service), которое требуется для исходящего пакета. Может принимать четыре значения:

• IPTOS_LOWDELAY — минимальная задержка;

• IPTOS_THROUGHPUT — максимальная пропускная способность;

• IPTOS_RELIABILITY — максимальная надежность;

• IPTOS_LOWCOST — минимальная стоимость. (Целочисленное значе ние, по умолчанию дополнительное обслуживание не предусмот рено.) IP_TTL. Задает предельное время жизни всех пакетов. Равен максималь ному числу переходов, после которого пакет удаляется из сети.

(Целочисленное значение, по умолчанию 64.) 204 Часть II. Создание серверных приложений www.books-shop.com Параметры стандарта IPv Параметры данной группы применимы к сокетам, работающим по стандарту IPv6. Они относятся к уровню SOL_IPV6.

• IPV6_ADD_MEMBERSHIP. Как и в IPv4, с помощью этого параметра можно добавить адресата к группе многоадресной доставки сообщений.

(Структура типа ipv6_mreq, по умолчанию не инициализирована, только для записи.) • IPV6_ADDRFORM. С помощью этого параметра можно задать преобразование сокета из стандарта IPv4 в стандарт IPv6. (Булево значение, по умолча нию False.) • IPV6_CHECKSUM. При работе с неструктурированными сокетами стандарта IPv6 с помощью этого параметра можно задать смещение поля кон трольной суммы. Если он равен — 1, ядро не вычисляет контрольную сумму, а принимающая сторона ее не проверяет. (Целочисленное значе ние, по умолчанию — 1.) • IPV6_DROP_MEMBERSHIP. Как и в IPv4, с помощью этого параметра можно удалить адресата из группы многоадресной доставки сообщений.

(Структура типа ipv6_mreq, по умолчанию не инициализирована, только для записи.) • IPV6_DSTOPTS. С помощью этого параметра можно извлечь все опции из принятого пакета. Получить эту информацию в программе можно с по мощью функции recvmsg(). (Булево значение, по умолчанию False.) • IPV6_HOPLIMIT. Если этот флаг установлен и вызывается функция recvmsg(), из вспомогательного поля сообщения будет получено число переходов, в течение которых пакет еще может существовать. (Булево значение, по умолчанию False.) • IPV6_MULTICAST_HOPS. Как и в IPv4 (параметр IP_MULTICAST_TTL), задает максимальное число переходов для сообщений, отправляемых в режиме групповой передачи. (Целочисленное значение, по умолчанию 1.) • IPV6_MULTICAST_IF. Как и в IPv4, задает, какой IP адрес (определяемый номером интерфейса) использовать для групповых сообщений. (Целое число, по умолчанию 0.) • IPV6_MULTICAST_LOOP. Как и в IPv4, задает режим "эха" исходящих сооб щений при групповой передаче. (Булево значение, по умолчанию False.) • IPV6_NEXTHOP. Если этот флаг установлен, можно задать направление сле дующего перехода дейтаграммы. Чтобы выполнить эту операцию, необ ходимо иметь привилегии пользователя root. (Булево значение, по умол чанию False.) • IPV6_PKTINFO. Если этот флаг установлен, программе будет передан номер интерфейса и целевой адрес IPv6. (Булево значение, по умолчанию False.) • IPV6_PKTOPTIONS. С помощью этого параметра можно задать опции пакета в виде массива байтов. Данный массив передается с помощью функции sendmsg(). (Массив байтов, по умолчанию пуст.) Глава 9. Повышение производительности www.books-shop.com IPV6_UNICAST_HOPS. Как и в IPv4 (параметр IPJTTL), задает максимальное число переходов для одноадресных сообщений. (Целочисленное значе ние, по умолчанию 64.) Параметры протокола TCP Параметры данной группы применимы к ТСР сокетам. Они относятся к уров ню SOL_TCP.

• TCP_KEEPALIVE. Сокет, для которого установлен флаг SO_KEEPALIVE, ожида ет 2 часа, после чего пытается повторно установить соединение. С по мощью параметра TCP_KEEPALIVE можно изменить длительность ожида ния. Единицей измерения являются секунды. В Linux вместо этого па раметра используется функция sysctl(). (Целочисленное значение, по умолчанию 7200 с.) • TCP_MAXRT. С помощью этого параметра можно задать длительность ретрансляции в секундах. Если указано — 1, сетевая подсистема будет осуществлять ретрансляцию бесконечно долго. (Целочисленное значе ние, по умолчанию 0.) • TCP_MAXSEG. В TCP поток данных разбивается на блоки. Данный параметр задает максимальный размер сегмента данных в каждом блоке. Сетевая подсистема проверяет, не превышает ли это значение аналогичный па раметр самого узла. (Целочисленное значение, по умолчанию 540 бай тов.) • TCP_NODELAY. В TCP применяется алгоритм Нейгла, который запрещает отправку сообщений, размер которых меньше максимального, до тех пор, пока принимающая сторона не подтвердит получение ранее по сланных сообщений. Если установить этот флаг, алгоритм Нейгла будет отключен, вследствие чего можно посылать короткие сообщения до по лучения подтверждений. (Булево значение, по умолчанию False.) • TCP_STDURG. Этот параметр задает, где во входном потоке следует искать байт внеполосных данных. По умолчанию это байт, следующий за байтом, который был получен при вызове функции recv() с флагом MSG_OOB. По скольку во всех реализациях TCP такая установка поддерживается, ис пользовать данный параметр нет особой необходимости. В Linux он заме нен функцией sysctl(). (Целочисленное значение, по умолчанию 1.) Восстановление дескриптора сокета При написании серверных программ можно столкнутся с ситуацией, когда в результате вызова функции bind() возникает ошибка "Port already used" (порт уже используется). Это одна из самых распространенных ошибок (даже опытные программисты ее допускают), о ней чаще всего спрашивают в Usenet. Проблема связана с тем, как ядро назначает порт сокету.

В большинстве случаев ядро ждет несколько секунд, прежде чем повторно вы делить порт (иногда пауза затягивается до минуты). Это делается из соображений 206 Часть И. Создание серверных приложений www.books-shop.com предосторожности. Задержка необходима, чтобы пакеты, которые еще находятся в пути, были удалены, прежде чем будет установлено новое соединение.

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

/*** Пример повторного использования порта (для сервера, ***/ /*** который завис и должен быть запущен повторно) ***/ int value=l;

/* TRUE */ int sd = socket(PF_INET, SOCK_ADDR, 0 ) ;

if ( setsockopt(sd, SOL SOCKET, SO_REUSEADDR, &value, sizeof(value)) != 0 ) perror("setsockopt() failed");

/*** Вызовы функций bind(), listen() и accept() ***/ Можно также попробовать вызвать функцию bind() повторно, если возникает ошибка EAGAIN. Необходимо только быть уверенным в том, что никакая другая программа не использует этот же порт.

Когда флаг SO_REUSEADDR установлен, могут возникнуть другие проблемы. Напри мер, не нужно, чтобы два HTTP сервера работали одновременно по одному и тому же порту 80. Кроме того, попытка запуска сервера, который уже запущен, является серьезной ошибкой системного администратора. В этом случае можно, например, проверить идентификаторы выполняющихся процессов в каталоге /var.

Досрочная отправка: перекрытие сообщений Для сервера важно быстро восстанавливать свою работу в случае сбоев. (Имеет также значение, насколько быстро клиент способен послать запрос серверу.

Можно установить флаг TCP_NODELAY, чтобы максимально ускорить отправку кли ентских запросов.

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

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

Глава 9. Повышение производительности www.books-shop.com Проблемы файлового ввода вывода Когда смотришь на обилие параметров, связанных с передачей сообщений, хочется вернуться к стандартным системным или высокоуровневым библиотеч ным функциям файлового ввода вывода. Системные функции хорошо подходят для быстрой разработки приложений. Они хорошо документированы и имеют ряд возможностей, упрощающих программирование. По сути, при создании шаблона приложения следует использовать функции, которые наиболее соответствуют аналогичным функциям библиотеки Socket API. В то же время применение таких функций, как, например, printf(), следует ограничить, поскольку потом их труд нее преобразовывать.

Однако функции файлового ввода вывода нежелательно применять, если про изводительность приложения играет важную роль. Когда программа вызывает од ну из таких функций, передавая ей дескриптор сокета, система может по не скольку раз копировать данные из файловых буферов в буферы сокета. Это нано сит существенный удар по производительности. Даже низкоуровневые функции read() и write() проверяют тип дескриптора и, ecли он относится к сокету, вызы вают соответствующие функции Socket API.

При работе с сокетами лучше полагаться только на библиотеку Socket API.

Это также сделает программу понятнее и упростит ее отладку. Можно будет легко увидеть, где программа работает с файлом, а где — с сокетом.

Ввод вывод по запросу: рациональное использование ресурсов процессора У всех сетевых программ есть два общих компонента: собственно алгоритм и подсистема ввода вывода, с которой они работают. И если саму программу можно тщательно спроектировать и отладить, то второй компонент не является столь же гибким. Но одной из наиболее привлекательных черт Linux является то, что работу этой подсистемы можно настраивать. Функции ввода вывода библиотеки Socket API имеют множество параметров, позволяющих управлять приемом и передачей данных. Кроме того, очень мощными возможностями располагает функция fcntl().

В большинстве случаев ядро просто буферизует отправляемые сообщения. Это означает, что можно сосредоточиться на сборе информации и ее обработке. В главе 8, "Механизмы ввода вывода", рассказывалось о том, как с помощью ре жима асинхронного ввода вывода поручить ядру делать часть работы за вас. В этом случае программа возлагает задачу по генерированию сигналов на подсисте му ввода вывода.

Ускорение работы функции send() При отправке сообщения ядро копирует его в свои буферы и начинает про цесс создания пакета. После его окончания ядро возвращает в программу код за вершения. Таким образом, задержка связана с формированием результатов рабо ты функции send(). Если возникают какие то проблемы, ядро выдает сообщение об ошибке.

208 Часть П. Создание серверных приложений www.books-shop.com Однако большинство ошибок происходит в процессе передачи, а не в самой функции send(). Проблемы, связанные, например, с неправильным использова нием указателей, функция обнаруживает достаточно быстро, а вот о других ошибках будет сообщено только по завершении функции. С помощью параметра SO_ERROR сокета о них можно узнать даже раньше, чем будет установлена библио течная переменная errno.

Работу функции send() можно ускорить, если задать в ней опцию MSG_DONTWAIT.

В этом случае функция копирует сообщение в буфер и немедленно завершается.

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

Единственная ситуация, когда операция записи блокируется, — это перепол нение буфера. Оно нечасто происходит в системе, где много свободной памяти.

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

Разгрузка функции recv() В отличие от функции send(), большинство вызовов функции recv() блокиру ются, поскольку программа, как правило, выполняется быстрее, чем приходят данные. Когда во входных буферах имеются данные, функция recv() копирует их в память и завершается. Даже если в буфере всего один байт, функция вернет этот байт и завершится. (Изменить подобное поведение можно, установив флаг MSG_WAITALL.) Как правило, не нужно ждать поступления всех данных, так как программа в это время может выполнять множество других действий. Есть два выхода из си туации: создавать потоки, управляющие работой отдельных каналов, или исполь зовать сигналы. В первом случае следует помнить о системных ресурсах. Во первых, обязательно будет существовать задание, на какое то время заблокиро ванное функцией recv(). Во вторых, разрастается таблица процессов, что ведет к снижению производительности.

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

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

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

Отправка приоритетных сообщений В процессе обмена данными программе может потребоваться "разбудить" принимающую сторону или отменить какую то операцию. В протоколе TCP под держиваются срочные сообщения, которые проходят "сквозь" входную очередь.

Глава 9. Повышение производительности www.books-shop.com Такие сообщения называются внеполосными (ООВ — out of band). Несмотря на заманчивое название, действительность несколько разочаровывает: согласно спе цификации, срочное сообщение может занимать всего один байт (такие сообще ния поддерживаются и в других протоколах, но они иначе реализованы).

Если программа получает два срочных сообщения подряд, второе из них зати рает первое. Это связано с тем, как сетевая подсистема хранит срочные сообще ния: для каждого сокета зарезервирован буфер размером один байт.

Первоначально срочные сообщения применялись для соединений, работаю щих по принципу транзакций. Например, в Telnet требовалось передавать сигнал о прерывании сеанса (^С) по сети. С помощью срочных сообщений можно было сообщить клиенту или серверу тип операции, скажем reset transaction или restart transaction. Всего существует 256 возможных вариантов.

Если флаг SO_OOBINLINE сокета не установлен, ядро уведомит программу о по ступлении внеполосных данных с помощью сигнала SIGURG (по умолчанию этот сигнал игнорируется). В обработчике сигналов можно прочитать данные, задав в функции recv() опцию MSG_OOB.

Чтобы отправить срочное сообщение, необходимо установить флаг MSG ООВ в функции send(). Кроме того, как и в асинхронном режиме, необходимо с помо щью функции fcntl() включить обработку сигналов ввода вывода:

/*********************************************************/ /*** Запуск обработчика сигналов SIGIO и SIGURG ***/ /**********************************************************/ if ( fcntl(sockfd, F_SETOWN, getpid()) != 0 ) perror( "Can't claim SIGURG and SIGIO");

Эта функция сообщает ядру о том, что программа хочет получать асинхронные уведомления в виде сигналов SIGIO и SIGURG.

С помощью срочных сообщений можно проверять, не пропала ли принимаю щая сторона, так как, в отличие от обычных данных, внеполосные данные не блокируются. Вот как можно реализовать алгоритм "перестукивания" между сер вером и клиентом:

/****************************************************************/ /*** Обмен срочными сообщениями между клиентом и сервером ***/ /*** (сервер отвечает на сигналы). ***/ /*** (Взято из файла heartbeat server. с на Web узле.) ***/ int clientfd;

void sig_handler(int signum) { if ( signum == SIGURG ) { char c;

recv(clientfd, &c, sizeof(c));

if (с == '?') /* Ты жив? */ send(clientfd, "Y", 1, MSG ООВ);

/* ДА! */ } } int main() ( int sockfd;

struct sigaction act;

2 1 0 Часть II. Создание серверных приложений www.books-shop.com bzero(&act, sizeof(act));

act.sa handler = sig_handler;

sigaction(SIGURG, &act, 0);

/* регистрируем сигнал SIGURG */ /*** устанавливаем соединение ***/ /*— запуск обработчика сигналов SIGIO и SIGURG —*/ if ( fcntl(clientfd, F_SETOWN, getpid()) != 0 ) perror("Can't claim SIGURG and SIGIO");

/*** другие действия ***/ } В этом фрагменте сервер отвечает на запросы, посылаемые клиентом. Код клиента будет немного другим:

/****************************************************************/ /*** Обмен срочными сообщениями между клиентом и сервером ***/ /*** (клиент посылает сигналы). ***/ /*** (Взято из файла heartbeat client.с на Web узле.) ***/ int serverfd, got_reply=l;

void sig_handler(int signum) { if ( signum == SIGURG ) { char c;

recv(serverfd, &c, sizeof(c));

got_reply = ( с == 'Y' ) /* Получен ответ */ } else if (signum == SIGALARM) if ( got_reply ) { send(serverfd, "?", 1, MSG_OOB);

/* Ты жив? */ alarm(DELAY);

/* Небольшая пауза */ got reply = 0;

} else fprintf(stderr, "Lost connection to server!");

} int main() { struct sigaction act;

bzero(&act, sizeof(act));

act.sa_handler = sig_handler;

sigaction(SIGURG, &act, 0);

sigaction(SIGALRM, &act, 0);

/*** устанавливаем соединение ***/ /*— запуск обработчика сигналов SIGIO и SIGURG —*/ if ( fcntl(serverfd, F_SETOWN, getpid()) != 0 ) perrorj"Can't claim SIGURG and SIGIO");

alarm(DELAY);

/*** другие действия ***/ } Глава 9. Повышение производительности piracy@books-shop.com Можно реализовать полностью двустороннюю связь, осуществив несложную проверку на сервере. Если сообщение от клиента не поступило в течение задан ного промежутка времени, сервер будет знать о том, что на клиентском конце со единения произошла ошибка. Срочные сообщения позволяют получить больший контроль над соединением, если они поддерживаются на обоих концах соедине ния.

Резюме До сих пор в каждой главе рассматривался один из кусочков мозаики, каковой является код высокопроизводительного сервера или клиента. Любая сетевая про грамма должна управлять информацией, которую она отправляет и принимает.

Иногда применение многозадачности может привести к снижению производи тельности, если проявить невнимательность при написании программы.

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

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

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

212 Часть II. Создание серверных приложений www.books-shop.com Глава Создание устойчивых сокетов В этой главе...

Методы преобразования данных Проверка возвращаемых значений Обработка сигналов Управление ресурсами Критические серверы Согласованная работа клиента и сервера Отказ от обслуживания Резюме: несокрушимые серверы www.books-shop.com Итак, наша задача — создание клиентских и серверных приложений коммер ческого уровня. Это достойная цель, даже если программа будет распространяться бесплатно вместе с исходными текстами на условиях открытой лицензии. Ведь никому не хочется, чтобы его критиковали за ошибки программирования. Так как же сделать хорошую программу безупречной? Хороший вопрос!

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

Насколько надежной должна быть клиентская или серверная программа?

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

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

Методы преобразования данных Первый шаг в обеспечении устойчивости сетевой программы заключается в использовании функций преобразования из библиотеки Socket API. Существует множество функций, преобразующих адреса, имена и двоичные данные из одной кодировки в другую. Они важны, если необходимо гарантировать переносимость, тестируемость и долговечность программы.

Как описывалось в главе 2, "Основы TCP/IP", в сети применяется обратный порядок следования байтов. Это не имеет значения, если работать за компьюте ром Alpha или 68040, где по умолчанию используется данная кодировка. В таких системах функции заменяются "заглушками", которые не выполняют никаких действий. Но если вы читаете эту книгу, то, скорее всего, ваша программа будет распространяться в среде Linux. В этом случае функции преобразования обеспе чивают правильное представление информационных структур.

Тысячи программистов протестировали все библиотеки функций, имеющиеся в Linux. Возможно, некоторые из этих проверок касались только одной конкрет ной конфигурации, но организация GNU внимательно следит за надежностью распространяемых ею пакетов, тщательно и скрупулезно отлаживая их. Это слу жит фундаментом разработки устойчивых программ.

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

214 Часть II. Создание серверных приложений www.books-shop.com • если функция завершается без ошибок, она должна возвращать значение 0;

• если в процессе выполнения функции произошла ошибка, она должна возвращать отрицательное значение и записывать код ошибки в библио течную переменную errno;

• пользуйтесь стандартными кодами ошибок;

• передавайте структуры по ссылкам;

• старайтесь определять низкоуровневые функции и строить на их основе высокоуровневые;

• определяйте все параметры указатели, предназначенные только для чте ния, со спецификатором const;

• лучше создавать структуры, чем typedef определения (макротипы);

• предпочтительнее задавать имена переменных и функций в нижнем ре гистре, а не в верхнем, в то же время константы должны записываться прописными буквами;

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

Это лишь некоторые из правил. Наилучшим решением будет просмотреть текст стандартной функции и взять его за основу.

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

Проверка возвращаемых значений При работе с функциями библиотеки Socket API необходимо проверять ре зультаты их работы. В этом состоит особенность сетевого программирования:

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

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

• bind(). Программа, работающая с конкретным портом, должна его заре зервировать. Если это невозможно, необходимо узнать об этом как можно раньше. Ошибки могут быть связаны с конфликтами портов (порт уже используется другой программой) или с проблемами в самом сокете.

• connect(). Нельзя продолжить работу, если соединение не установлено.

Сообщения об ошибках могут иметь вид "host not found" (узел не най ден) или "host unreachable" (узел недоступен).

• accept(). Программа не может начать соединение, если данная функция не возвращает положительное число. (Теоретически возможно, что ле гальный дескриптор сокета равен нулю, но это очень необычная ситуа ция.) Наиболее распространенный код ошибки в данной ситуации — EINTR (вызов прерван сигналом). Это не критическая ошибка. Следует Глава10. Создание устойчивых сокетов www.books-shop.com либо вызвать функцию sigaction() с флагом SA_RESTART, либо проигно рировать ошибку и повторно вызвать функцию.

• Все функции ввода вывода (recv(), send() и т.д.). Эти функции опреде ляют, было ли сообщение послано или принято успешно. Возникающие в них ошибки свидетельствуют о разрыве соединения либо о прерыва нии по сигналу (см. выше). Применять высокоуровневые функции, на пример fprintf(), не стоит, так как они не позволяют отслеживать ошибки. Соединение может быть разорвано в любой момент, вследствие чего сигнал SIGPIPE приведет к аварийному завершению программы.

• gethostbyname(). Если в процессе работы этой функции произошла ошибка, будет получено значение 0 (или NULL). При последующем из влечении значения пустого указателя возникнет ошибка сегментации памяти, и программа завершится аварийно.

• fork(). Значение, возвращаемое этой функцией, указывает на то, где осуществляется вызов — в предке или потомке. Если оно отрицательно, значит, потомок не был создан или произошла системная ошибка.

• pthread_create(). Подобно функции fork(), необходимо убедиться в том, что дочернее задание было успешно создано.

• setsockopt()/getsockopt(). У сокетов есть множество параметров, с по мощью которых можно настраивать работу программы. Как правило, необходимо быть уверенным в успешном завершении этих функций, чтобы программа могла продолжить нормальную работу.

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

Ниже перечислен ряд менее критичных функций, возвращаемые значения ко торых можно проигнорировать.

• socket(). Ошибка в данной функции возникает только тогда, когда де скриптор сокета нельзя получить (нет привилегий или ядро не поддер живает эту функцию), указан неправильный параметр или таблица деск рипторов переполнена. В любом случае функции bind(), connect() и др.

вернут ошибку вида "not a socket" (дескриптор не относится к сокету).

• listen(). Если перед этим функция bind() завершилась успешно, мало вероятно, чтобы в данной функции произошла ошибка. Правда, следует учитывать, что длина очереди ожидания ограничена.

• close() или shutdown(). Если дескриптор файла неправильный, файл не был открыт. Так или иначе, после вызова любой из этих функций мож но считать файл закрытым и продолжать работу.

Как правило, за функцией, не являющейся критической, следует другая, более важная функция, которая сообщает о возникшей ошибке. Кроме того, неудачное завершение одной из перечисленных функций не приводит к катастрофическим последствиям. Конечно, это не означает, что на них можно не обращать внима 216 Часть //. Создание серверных приложений www.books-shop.com ние. При любых обстоятельствах дополнительная проверка того, успешно ли за вершилась функция, только повышает надежность программы.

Можно также перехватывать ошибки, возникающие не в системных или биб лиотечных функциях. Они связаны с динамичной природой сетей, в которых клиенты и серверы могут периодически "уходить в себя". Сетевая подсистема от слеживает некоторые ошибки в протоколах TCP/IP, постоянно проверяя готов ность канала к двунаправленному обмену сообщениями.

Если программа длительное время не посылала никаких сообщений, она должна самостоятельно проверить доступность канала. В противном случае ошибка, связанная с отсутствием соединения, будет представлена как ошибка ввода вывода, что дезориентирует пользователя. Определить подобного рода ошибку можно, вызвав функцию getsockopt() с аргументом SO_ERROR:

int error;

socklen_t size = sizeof(error);

if ( getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &size) == 0 ) if ( error != 0 ) fprintf(stderr, "socket error: %s(%d)\n", stderror(error), error);

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

Система также информирует программу об ошибках посредством сигналов.

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

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

С обработкой сигналов связаны свои проблемы, о ряде из которых упомина лось в главе 7, "Распределение нагрузки: многозадачность". Основная из них свя зана с тем, что любой процесс одновременно принимает только один сигнал кон кретного типа. Если во время выполнения обработчика поступает другой такой же сигнал, программа не узнает об этом событии.

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

Глава 10. Создание устойчивых сонетов www.books-shop.com Во вторых, можно разрешить прерывать выполнение обработчика. Применять данный подход следует осторожно, так как обработчик сигналов может помещать свои данные при каждом следующем вызове в специальный аппаратный стек.

Глубина этого стека по умолчанию невелика, поэтому легко возникает перепол нение стека., В третьих, можно заставить обработчик помещать сообщения о сигналах в очередь главной программы, которая будет сама их обрабатывать. Это не столь эффективное решение, как кажется на первый взгляд. Сигнал говорит лишь о том, что что то произошло. Программа знает только тип сигнала (в Linux их 32) и больше ничего. Программе придется самостоятельно определять, относится ли группа однотипных сообщений к одному или нескольким сигналам.

Порядок обработки каждого сигнала зависит от типа сигнала. Из всех 32 х сигналов (информацию о них можно получить в приложении А, "Информационные таблицы", и разделе 7 интерактивной документации) чаще всего обрабатываются такие: SIGPIPE, SIGURG, SIGCHLD, SIGHUP, SIGIO и SIGALRM.

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

Ошибка канала возникает, когда узел адресат закрывает соединение до окон чания сеанса передачи данных (см. файлы sigpipe client.c и sigpipe server.c на Web узле). То же самое произойдет, если направить длинный список файлов программе постраничной разбивки, например less, а затем завершить ее работу, не дойдя до конца списка, — будет выдано сообщение "broken pipe" (разрыв ка нала). Избежать получения сигнала SIGPIPE можно, задав опцию MSG_NOSIGNAL в функции send(). Но это не лучший подход.

Точный порядок обработки сигнала зависит от программы. В первую очередь необходимо закрыть файл, поскольку канал больше не существует. Если открыто несколько соединений и программа осуществляет их опрос, следует узнать, какое из соединений было закрыто.

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

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

218 Часть II. Создание серверных приложений www.books-shop.com SIGURG При передаче данных между клиентом и сервером необходимо учитывать все возможные способы обмена информацией. Программы могут посылать друг другу запросы на прерывание потока данных или инициализирующие сигналы (см. гла ву 9, "Повышение производительности"), пользуясь механизмом внеполосной передачи. Подобную ситуацию следует планировать заранее, так как по умолча нию сигнал SIGURG игнорируется. Его обработку нужно запрашивать особо.

Если программа получает несколько срочных сообщений подряд и не успевает их все обработать, лишние сообщения будут потеряны. Это объясняется тем, что во входящей очереди сокета зарезервирован только один байт для срочных сооб щений.

SIGCHLD Сигнал SIGCHLD возникает в многозадачной среде, когда дочернее задание (в частности, процесс) завершается. Ядро сохраняет контекст задания, чтобы роди тельская программа могла проверить, как завершился дочерний процесс. Если программа проигнорирует этот Сигнал, ссылка на контекст останется в таблице процессов в виде процесса зомби (см. главу 7, "Распределение нагрузки: много задачность").

Обычно при получении сигнала SIGCHLD программа вызывает функцию wait().

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

Поскольку функция wait() блокирует работу программы (а в обработчике сиг налов это крайне нежелательно), воспользуйтесь вместо нее функцией waitpid():

#include #include int waitpid(int pid, int *status, int options);

Параметр pid может принимать разные значения;

если он равен — 1, функция будет вести себя так же, как и обычная функция wait(). Параметр status анало гичен одноименному параметру функции wait() и содержит код завершения по томка. Чтобы предотвратить блокирование функции, следует задать параметр options равным WNOHANG. Когда все процессы зомби, ожидающие обработки, будут обслужены, функция вернет значение 0. Ниже показан типичный пример обра ботчика сигнала SIGCHLD.

/*** Улучшенный пример уничтожения зомби ***/ /*******************************************/ void sig_child(int signum) i while ( waitpid( l, 0, WNOHANG) > 0 );

} Это единственный случай, когда в обработчике сигналов следует применять цикл. Такова особенность работы функции waitpid(). Предположим, обработчик Глава 10. Создание устойчивых сокетов www.books-shop.com вызывается, когда завершается один из пррцессов потомков. Если бы на месте указанной функции стояла функция wait() и во время ее выполнения пришел новый сигнал, он был бы просто потерян. А вот функция waitpid() на следующей итерации цикла благополучно обнаружит появившийся контекст потомка. Таким образом, одна функция обрабатывает все отложенные команды завершения, а не только одну.

SIGHUP Что произойдет с дочерним процессом, если завершится родительская про грамма? Он получит сигнал SIGHUP. По умолчанию процесс прекращает свою ра боту. Обычно этого вполне достаточно.

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

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

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

Предварительно необходимо вручную уничтожить все дочерние процессы, отно сящиеся к старому предку. (Данную методику можно применять при обработке всех сигналов, приводящих к завершению работы сервера.) SIGIO Ускорить работу сетевой программы можно, поручив обработку событий вво да вывода ядру. Правильно написанная программа получает сигнал SIGIO всякий раз, когда буфер ввода вывода становится доступен для очередной операции (обращение к нему не вызовет блокирования программы). В случае записи дан ных это происходит, когда буфер готов принять хотя бы один байт (пороговое значение устанавливается с помощью параметра SO_SNDLOWAT сокета). В случае чтения данных сигнал поступает, если в буфере есть хотя бы один байт (пороговое значение устанавливается с помощью параметра SO_RCVLOWAT сокета). О реализации обработчика этого сигнала рассказывалось в главе 8, "Механизмы ввода вывода", а о способах повышения производительности подсистемы ввода вывода — в главе 9, "Повышение производительности".

SIGALRM Подобно сигналу SIGIO, программа получает сигнал SIGALRM, только если явно его запрашивает. Обычно он генерируется функцией alarm(), которая "будит" программу после небольшой паузы. Этот сигнал часто используется демонами, которые проверяют, работает ли та или иная программа.

220 Часть II. Создание серверных приложений www.books-shop.com Управление ресурсами Сигналы — это лишь малая часть ресурсов программы. Они позволяют сни зить вероятность повреждения системы и повысить производительность програм мы. Но необходимо также помнить о файлах, "куче" (динамических областях па мяти), статических данных, ресурсах процессора, дочерних процессах и совмест но используемой памяти. По настоящему надежный сервер (да и клиент тоже) должен тщательно заботиться о своих ресурсах.

Управление файлами При запуске программы автоматически создаются три стандартных файла (потока);

stdin, stdout и stderr. Это широко известный факт, как и то, что любой из перечисленных потоков можно переадресовать. Проблем с такой переадреса цией не возникает, так как ядро самостоятельно очищает потоки и освобождает их дескрипторы, когда программа завершает работу.

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

Динамическая память ("куча") Работа с "кучей" (динамически выделяемой памятью) требует тщательного слежения за каждым полученным блоком памяти. Для многих программистов, однако, это настоящая ахиллесова пята. Они часто забывают освобождать память, а возникающие "утечки" очень трудно обнаружить. Существуют специальные библиотеки функций (например, ElectricFence), позволяющих отслеживать выде ленные блоки памяти, но лучше всего придерживаться определенных правил ра боты с памятью.

Первая и наиболее часто встречающаяся ошибка заключается в том, что забы вают проверять значения, возвращаемые функциями malloc() и calloc() (в C++ необходимо перехватывать все исключения);

Если блок памяти запрашиваемого размера недоступен, функция возвращает NULL (0). В ответ на это, в зависимости от особенностей программы, можно завершить работу, изменить установки и по вторно вызвать функцию, уведомить пользователя и т.д. Некоторые программи сты любят проверять корректность каждой операции выделения памяти с помо щью функции assert(). К сожалению, если она завершается неуспешно, про грамма всегда прекращает работу.

Работая с памятью, будьте последовательны. Вызвав однажды функцию calloc(), вызывайте ее во всех остальных местах программы. Не смешивайте раз ные методики. В частности, в C++ оператор new не всегда работает корректно, если в программе встречаются вызовы функций malloc() и calloc(). А если вы полнить оператор delete по отношению к блоку памяти, выделенному с помо щью функции malloc(), результат будет непредсказуем.

Глава 10. Создание устойчивых сокетов piracy@books-shop.com Возьмите за правило присваивать освобождаемым указателям значение NULL.

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

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

В табл. 10.1 перечислены преимущества каждого подхода. Их можно чередо вать в одной и той же программе, следует только помнить о том, где и какого размера блоки были выделены.

Таблица 10.1. Сравнение методик выделения памяти Точное выделение Выделение с запасом Выделяется ровно столько памяти, сколько нужно Выделяется более крупный блок, в котором использу в программе ется столько памяти, сколько понадобится в тот или иной момент Выделенная память не тратится впустую Почти всегда часть памяти не используется Требуется несколько вызовов функций выделения Требуется только один вызов функции выделения и и освобождения памяти один — функции освобождения Высокая вероятность фрагментации "кучи" Малая вероятность фрагментации "кучи" Методика эффективна, когда память многократно Методика полезна, когда память выделяется в какой выделяется в разных местах программы то одной функции и сразу после этого освобождается Может вести к неэкономному расходу памяти, так Создается только один заголовок для всего блока как для каждого выделенного блока создается от дельный описательный заголовок (именно так подсистема динамической памяти выполняет ра боту с "кучей") Методика одинаково применима в любой системе Методика также применима в любой системе, но Linux обеспечивает для нее дополнительные пре имущества (с физической памятью связаны только те страницы размером 1 Кбайт, которые реально используются) Ошибки сегментации в функции malloc() Если при. вызове функции malloc() возникает ошибка сегментации, значит, программа повре дила блок памяти, выделенный кем то другим. Причиной ошибки обычно является неправильное применение строковых указателей или выход за пределы массива с последующим повреждением ячеек памяти, непринадлежащих программе.

В крупной программе может быть несколько независимых модулей, где при меняются различные методики выделения памяти. Работая сообща с другими программистами, установите "правила игры". Например, если из одного модуля в другой передается указатель, может ли он модифицироваться или необходимо обязательно делать копию?

222 Часть II. Создание серверных приложений www.books-shop.com Как правило, указатель "принадлежит" тому модулю, в котором он был соз дан. Это означает, что когда указатель передается в другой модуль, нужно каким то образом создать копию адресуемого блока памяти. Такой подход называют де тальным копированием, поскольку все ссылки внутри блока также должны быть раскрыты и скопированы.

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

int Counter;

/* неинициализированные данные */ char *words[] = {"the", "that", "a", 0};

;

/* инициализированные данные */ void fn(int arg1, char *arg2) /* параметры (стек) */ { int i, index;

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

Ресурсы процессора, совместно используемая память и процессы Что касается последних трех типов ресурсов, то здесь достаточно сделать лишь несколько замечаний.

• Совместно используемая память. Работа с ней напоминает работу с фай лами. Необходимо открывать, блокировать и закрывать доступ к общим областям памяти.

• Ресурсы процессора. Программа может легко захватить все время процес сора. Нужно не забывать периодически освобождать процессор.

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

Критические серверы Получение информации о внешних и внутренних событиях (сигналах, напри мер) важно для понимания того, как работает система. Создавая клиентские и серверные приложения, необходимо заранее определить, что может произойти и когда. Это позволит жестко регламентировать работу программы в любых ситуа циях. Сложность предварительного анализа связана с тем, что компьютеры могут Глава 10. Создание устойчивых сонетов www.books-shop.com иметь самую разную конфигурацию, даже если на них установлена одна и та же операционная система.

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

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

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

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

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

Джин не может сказать: "Подожди, пока я перезагружусь". Сервер должен быть всегда доступен и готов обрабатывать запросы.

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

они находят применение, в частности, в системах денежных переводов и электронной коммерции.

Коммуникационные события и прерывания В процессе покупки товара через Internet соединение неожиданно разрывает ся. Что могло стать причиной этого? Ведь протокол TCP считается достаточно надежным. Что же вызвало появление ошибки? Объяснений может быть масса.

Разрывы соединений могут приводить к утрате данных, денег и даже жизни.

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

224 Часть П. Создание серверных приложений www.books-shop.com Физические прерывания В сети может существовать столько видов физических соединений и способов потери несущей (пропадание электрического или оптического сигнала, передаю щего пакеты), что перечислить их все было бы трудно и вряд ли целесообразно.

Суть в том, что соединение между точками А и Б может быть разорвано.

Протокол TCP достаточно успешно справляется с подобными событиями. Не имеет значения тип физического носителя: кабель, оптоволокно или радиоволны.

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

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

Сбои маршрутизаторов Физические разрывы вызывают сбои в работе маршрутизаторов, проявляю щиеся в виде циклов. Сообщение циркулирует между маршрутизаторами до тех пор, пока не будет выявлено и исправлено. Это может вызывать дублирование и потерю пакетов. Однако в случае одиночного TCP соединения программа не сталкивается с подобными проблемами, так как протокол TCP оперативно ис правляет их.

Пропадание канала между клиентом и сервером ЕСЛИ нужно восстановить сеанс, следует учесть возможность дублирования.

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

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

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

Вторая проблема носит противоположный характер: дублирование транзакции.

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

Глава 10. Создание устойчивых сокетов www.books-shop.com Предположим, например, что клиент запрашивает перевод 100$ с депозит ного счета на текущий. До тех пор пока не будет получено подтверждение от сервера, клиент сохраняет сообщение в очереди транзакций. Затем происходит сбой, клиент аварийно завершает работу, и система сохраняет очередь транзак ций. После перезагрузки клиент извлекает транзакции из очереди и повторно их выполняет. Если сервер еще раз выполнит ту же самую транзакцию, будет переведено 200$, а не 100$.

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

Другой формой проверки является сертификация, при которой выясняется, действительно ли клиент тот, за кого себя выдает. В этом алгоритме подразумева ется наличие третьей стороны — органа сертификации. Когда сервер принимает запрос на подключение и начинает процесс регистрации, он требует от клиента сертификат подлинности, который затем направляется в орган сертификации. От туда поступает подтверждение подлинности.

Все эти и ряд других проблем следует учесть до того, как начнется написание программы. Если вспомнить о безопасности и методиках восстановления соеди нений после того, как программа реализована, никакими "заплатками" нельзя будет закрыть изъяны исходного алгоритма.

Способы возобновления сеанса Процедура возобновления сеанса является частью системы безопасности. Не обходимо позаботиться о защите критически важных данных и о сведении к ми нимуму операций взаимодействия с пользователем.

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

Обратное цитирование Заставить клиента обнаружить разрыв соединения не так то просто, поскольку сетевые ошибки возникают не сразу;

а через какое то время. Можно применять обратное квитирование — уста навливать соединение в обоих направлениях. Обычно клиент подключается к серверу. Но в алго ритме обратного квитирования сервер в ответ на запрос клиента сам подключается к «ему. Че рез обратный канал можно посылать служебные сообщения (например, о необходимости по вторного подключения). Реализовать такой канал можно не по протоколу ТСР, а с помощью надежного варианта протокола UDP.

Процесс установления соединения может включать принудительную повтор ную аутентификацию или сертификацию либо автоматическую регистрацию в системе. Это необходимый шаг при организации безопасных сеансов связи. Если повторное соединение устанавливается в рамках того же самого приложения, можно восстановить предьщущие параметры аутентификации и зарегистрировать 226 Часть П. Создание серверных приложений www.books-shop.com ся без участия пользователя. Процесс сертификации должен быть проведен зано во. К счастью, все это обычно осуществляется незаметно для пользователя.

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

Избежать потерь транзакций можно, если назначать им идентификационные номера, регистрировать их в журнале и высылать подтверждение по каждой из них. У транзакции должен быть уникальный идентификатор. Он отличается от идентификатора TCP сообщения, поскольку является уникальным во всех сеан сах. (В действительности придерживаться столь жесткого подхода не обязательно.

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

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

Получив второе подтверждение, клиент списывает отложенную транзакцию.

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

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

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

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

Глава 10. Создание устойчивых сокетов www.books-shop.com Сетевые взаимоблокировки В большинстве сетевых соединений определяется, какая программа должна начинать диалог первой. Например, одна программа посылает запросы, а другая отвечает на них. В качестве иллюстрации рассмотрим серверы HTTP и Telnet.

HTTP сервер принимает запросы от клиента, предоставляя клиенту право вести диалог. С другой стороны, сервер Telnet выдает пользователю приглашение на ввод имени и пароля. Будучи зарегистрированным в системе, клиент знает о том, что сервер готов отвечать, когда видит строку приглашения. Сервер Telnet может принимать и асинхронные команды, посылаемые посредством прерываний кла виатуры ().

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

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

Чтобы решить эту проблему, можно задать для соединения период тайм аута.

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

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

Эффективный способ предотвращения, обнаружения и снятия взаимоблоки ровок заключается в применении алгоритма "перестукивания", рассмотренного в предыдущей главе. Вместо того чтобы посылать друг другу запрос "Ты жив?", они могут передавать сообщение, указывающее на то, находится ли данная сторона в режиме ожидания.

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

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

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

228 Часть //. Создание серверных приложений www.books-shop.com Можно использовать другой подход — осуществить динамическое планирование соединений или назначить им приоритеты. Если, к примеру, выполняются три процесса, только один из них может получить доступ к процессору в конкретный момент времени. Поэтому планировщик повышает эффективный приоритет про цесса, проверяемого в настоящий момент. По завершении обслуживания приори тет процесса вновь понижается. Тем самым обеспечивается рациональное распре деление ресурсов процессора.

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

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

Как описывалось выше, сетевая подсистема принимает клиентские запросы на подключение по определенному порту. У данного порта есть очередь ожидания.

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

Итак, вот суть проблемы. Если нарушитель ничего не делал и не посылал ни каких данных, подсистема TCP/IP завершит соединение по тайм ауту. Казалось бы, все нормально. Но злоумышленник оказывается умнее. Он посылает не сколько байтов — этого недостаточно, чтобы заполнить какой либо буфер, но достаточно, чтобы блокировать функцию ввода вывода..

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

Предотвратить подобную ситуацию можно в три этапа.

1. Всегда задавайте тайм ауты для всех функций ввода вывода. Их легко реализовать, и они помогут не потерять контроль над сервером.

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

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

Глава 10. Создание устойчивых сокетов www.books-shop.com Резюме: несокрушимые серверы В данной главе рассказывалось о том, как создавать надежные и стабильно ра ботающие серверные и клиентские приложения. Было рассмотрено, как избегать проблем, связанных с сетевыми атаками, взаимоблокировками и зависаниями.

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

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

Важно также понимать, как работает сервер и как он взаимодействует с кли ентом. Это помогает настраивать работу сервера и делать его устойчивым.

230 Часть II. Создание серверных приложений www.books-shop.com Часть Объектно ориентированные III сокеты В этой части...

Глава 11. Экономия времени за счет объектов Глава 12. Сетевое программирование в Java Глава 13. Программирование сокетов в C++ Глава 14. Ограничения объектно ориентированного программирования piracy@books-shop.com Глава Экономия времени за счет объектов В этой главе...

Эволюция технологий программирования Рациональные методы программирования Основы объектно ориентированного программирования Характеристики объектов Расширение объектов Особые случай Языковая поддержка Резюме: объектно ориентированное мышление www.books-shop.com Батарейка в часах дает им энергию, которая приводит в действие часовой ме ханизм. Когда нужно заменить батарейку, вы просто вынимаете ее и вставляете новую. Представьте, как было бы здорово, если бы то же самое можно было де лать с программами, — отключить старую и подключить новую.

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

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

Примечание Эта глава предшествует главам, в которых рассказывается о конкретных способах создания объектно ориентированных сокетов. Чтобы понять особенности реализации сокетов в таких язы ках, как Java и C++, необходимо получить базовые представления об объектах. В книгах, посвя щенных объектно ориентированному программированию, не обойтись без вводного теоретиче ского раздела. Большинство программистов не понимает до конца объектную технологию, по этому создаваемые ими приложения не всегда соответствуют ее исходным положениям.

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

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

Блок схема демонстрировала пошаговый алгоритм преобразования осмысленных входных данных в требуемые выходные результаты.

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

Глава 11. Экономия времени за счет объектов www.books-shop.com На этапе описания исходных данных выяснялись системные требования. Здесь устанавливались границы между данными, вычисляемыми или определяемыми в самой программе, и данными, задаваемыми извне. На этом этапе разработчик должен был описать программное окружение системы и категорию пользовате лей, взаимодействующих с ней, а также решить, какие функции следует предло жить пользователю.

На этапе анализа задачи строились диаграммы потоков данных в системе, раз рабатывались архитектура системы и ее основные компоненты. Этот этап был еще достаточно абстрактным, и анализируемые данные представлялись не в кон кретном виде, а обобщенно: определялось, что должно быть на входе каждого компонента и что — на выходе.

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

Последний этап, системное проектирование, был посвящен разделению про блемы на функции и процедуры. В результате формировался либо общий алго ритм программы, либо ее блок схема.

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

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

Модульное программирование: структурный подход Одной из проблем функционального моделирования является частое нарушение правил видимости программных компонентов. Под областью видимости перемен ной, функции, процедуры или модуля понимаются границы, в пределах которых к каждому из этих компонентов можно обратиться. Когда такие границы в программе не выделены, программист невольно "сбрасывает все в кучу", чтобы максимально ускорить решение поставленной задачи. В такого рода программах любая функция имеет доступ ко всем остальным функциям и переменным. Создание глобальных переменных служит ярким примером нарушения правил видимости.

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

234 Часть III. Объектно ориентированные сокеты www.books-shop.com Многие программисты избегают глобальных переменных из за возможности побочных эффектов. Когда с такой переменной связано несколько разделов программы и в одном из них значение переменной изменяется, это отразится на всех остальных разделах (естественно, сказанное не относится к переменным константам).

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

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

Абстрактное программирование: отсутствие ненужной детализации Иногда в процессе реализации обнаруживается столько вариантов, что про граммисту приходится прибегать к абстракции. Применяя модульное программи рование на абстрактном уровне, можно представить данные как некие информа ционные блоки, не связанные с конкретной структурой модуля. Классическим примером является очередь, организованная по принципу FIFO (First In, First Out — первым пришел, первым обслужен). Программе не требуется знать, что на ходится в очереди, нужно лишь принимать и извлекать элементы.

Первые программные абстракции были реализованы для очередей, стеков, де ревьев, словарей, массивов и т.п. С каждым из перечисленных объектов связан свой набор методов, с которыми работают все программы. К примеру, в пятой версии операционной системы UNIX, прежде чем она была разделена, существо вало 10 реализаций очереди. Применяя абстрактное программирование, можно избежать подобного дублирования усилий и сосредоточиться на главном.

Решая поставленную задачу, необходимо проверить, можно ли представить ее в общем виде. Не исключено, что существуют части программы, которые приме няются многократно в различных ситуациях. Для многих задач уже имеются от лаженные обобщенные алгоритмы решения.

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

Объектно ориентированное программирова ние: естественный способ общения с миром В настоящее время программирование развивается в объектно ориентированном направлении. В объектном подходе концепция модульного программирования расширяется двумя вопросами: "Каким знанием обладает программа?" и "Что она делает?" Возможно, правильнее было бы употреблять термин моделирование обязанностей.

Глава 11. Экономия времени за счет объектов www.books-shop.com Объекты приближают программу к реальному миру. Все в природе наделено свойствами (атрибутами) и поведением (функциями или методами), а также внут ренними особенностями. Дети наследуют черты своих родителей. Все это находит отражение в объектах.

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

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

Повторное использование кода При правильном применении объектно ориентированный поход позволяет создавать программы, которые могут повторно использоваться другими програм мистами. Священная цель всех технологий программирования — "напиши один раз, используй многократно". Благодаря объектам эта цель становится реально достижимой.

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

Принцип повторного использования заключается в том, чтобы не изобретать колесо, а брать за основу готовые решения. Представьте, сколько строился бы дом, если бы строителям пришлось, кроме всего прочего, отливать металл для гвоздей. И это сегодня, когда в заводских условиях изготавливаются целые дома, доставляемые по частям прямо на участок в течение трех дней! Почему нельзя делать то же самое в компьютерной индустрии? Можно, но для этого требуется дисциплина.

Синдром ПНМ (придумано не мной) На самой первой своей работе мне посчастливилось иметь дело с наиболее талантливыми и умны ми инженерами, с которыми я когда либо сталкивался. Стремление выделиться из толпы требовало от меня постоянных умственных усилий. Я обратил внимание на одну характерную черту, свойст венную всем этим людям и ограничивающую их возможности. Их отличала подверженность син дрому ПНМ (придумано не мной), который проявлялся в следующем высказывании: "Если это сде лано не нами, значит, зто сделано неправильно.(или не идеально)". Я убедился в том, что подобная ошибочная (если не сказать заносчивая).точка зрений распространена практически во всех фирмах, занимающихся разработкой программного обеспечения.

236 Часть III. Объектно ориентированные сокеты www.books-shop.com Принцип повторного использования можно понимать двояко: как поиск гото вых решений и как продвижение своих собственных разработок. Первый случай понятен — это лишь вопрос доверия между вами и сторонним программистом.

Важно также наличие канала связи с ним.

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

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

Pages:     | 1 |   ...   | 2 | 3 || 5 | 6 |   ...   | 8 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

Материалы этого сайта размещены для ознакомления, все права принадлежат их авторам.
Если Вы не согласны с тем, что Ваш материал размещён на этом сайте, пожалуйста, напишите нам, мы в течении 1-2 рабочих дней удалим его.