Создаем PHP отладчик своими руками
Автор: sitemaker.ru
Так для чего же
все-таки нужна отладка программ? Каждому человеку свойственно
делать ошибки. Ошибки в программе приводят к ее неправильному
выполнению (или не выполнению вообще). PHP скрипты – это
программа, которая является основой вашего сайта.
Какие способы используют программисты для отладки? Обычно,
это вывод отладочной информации. Например, если во время
написания php скрипта нам понадобится посмотреть значение
переменной, то обычно мы это делаем так:
<?php
$myvariable = "Hello, PHP
world!";
echo $myvariable;
?>
Однако, это очень неудобно. Постоянно нужно
модифицировать скрипт. Тем более, если нам нужно будет
проверять значения переменных во многих местах.
Давайте сделаем простой отладчик. Пусть у него будет всего
несколько функций, но они вам помогут отладить практически
любой скрипт. Он позволяет остановить выполнение скрипта в
любом месте и просмореть или изменить переменные.
Основной идеей является модификация скрипта таким образом,
что скрипт сам приостановит свою работу в нужном месте и
передаст отладчику всю необходимую отладочную информацию. Под
отладчиком я подразумеваю внешнюю аппликацию с неким
интерфейсом, которая управляет работой скрипта: задает точки
останова, выводит отладочную информацию, значения переменных.
Для взаимодействия (общения) отладчика с php скриптом я решил
использовать сокеты, потому что php поддерживает сокеты, а
также это позволяет поместить отладчик на удаленной
машине.
Итак начнем. Основной задачей является остановка скрипта в
определенной точке. Для того, чтобы понять как он работает
давайте возьмем простой скрипт:
<?php
$browser = $HTTP_USER_AGENT;
?>
и модифицируем его таким образом, чтобы он приостановил
свое выполнение в 3-й строчке и сообщил об этом
отладчику:
<?php
$browser = $HTTP_USER_AGENT;
//А вот
тут, прямо перед 3-й строчкой мы вставим наш код :)
$debug_socket = socket_create (AF_INET, SOCK_STREAM, 0);
//создаем сокет для общения с отладчиком
socket_connect ($debug_socket, "127.0.0.1", "3451");
//соединямся с отладчиком
$debug_message = "Hello,
debugger. I stopped in line 3";
//формируем сообщение для отладчика
socket_write ($debug_socket, $debug_message, strlen ($debug_message));
//ну и
соответственно посылаем его
$todo = socket_read ($debug_socket, 65535);
//ждем
от отладчика команды для продолжения работы
socket_close ($debug_socket);
//закрываем сокет и продолжаем выполнение
скрипта
?>
Теперь подробнее, что же происходит по шагам:
1) Мы
написали скрипт и хотим его отладить :) Наш скрипт должен
находиться в documentroot
2) Говорим отладчику в каком
скрипте (файле) и в какой строчке остановить выполнение
3)
Отладчик модифицирует исходный файл, ну и сохраняет
оригинальный, на всякий случай ;)
4) Мы запускам броузер и
вводим адрес скрипта, для того, чтобы он выполнился
5)
Броузер соединяется с веб сервером, веб сервер запускает наш
модифицированый скрипт
6) Скрипт выполняется и в месте, где
мы его модифицировали, соединяется с отладчиком и «говорит»,
что так и так - приехали
7) Отладчик, в свою очередь,
сообщает пользователю, что скрипт «доехал» то точки
останова
8) Пользователь что-то там делает и дает команду
продолжать
9) Отладчик посылает скрипту команду
продолжать
10) Скрипт принимает эту команду и продолжает
делать свои грязные дела :)
Просто, не правда ли? :) Но это только половина задачи. А
вот как нам теперь узнать и изменить значения переменных? Да
точно также. Скрипт это сам сделает. Отладчик ему только
должен дать команду. В этом нам поможет одна из
замечательнейших возможностей PHP - команда eval
().
Реализуем это так:
<?php
$browser = $HTTP_USER_AGENT;
// Тут
пойдет наш код
$debug_socket = socket_create (AF_INET, SOCK_STREAM, 0);
socket_connect ($debug_socket, "127.0.0.1", "3451");
$debug_message = "Hello,
debugger. I stopped in line 3";
socket_write ($debug_socket, $debug_message, strlen ($debug_message));
$todo = socket_read ($debug_socket, 65535);
eval ($todo);
socket_close ($debug_socket);
?>
Всё также, как и в предыдущем примере, только теперь наша
задача получить значение переменной $browser. Схема действий
таже: скрипт выполняется, доходит до точки останова, говорит
отладчику, что «приехали»... Отладчик же, в свою очередь,
посылает скрипту PHP код, который выполнится в скрипте
командой eval (). А вот, что отладчик пошлет
туда:
<?php
socket_write ($debug_socket, $browser, strlen ($browser));
?>
В итоге скрипт выполнит эту строчку и вернет отладчику
значение переменной $browser.
Благодаря команде eval () отладчик может выполнить в точке
останова любые прихоти пользователя, вплоть до модификации
скрипта на лету, то есть во время отладки.
Идем дальше. Все не так просто, как кажется. До сих пор мы
умеем отлаживать простые скрипты. На самом деле в PHP есть
функции, классы, возможность подключения других скриптов
(команды require, require_once, include). Это делает нам целую
кучу проблем. Начнем с проблемы, когда один скрипт включает в
себя другие или сам себя.
Пусть мы для идентификации файла будем использовать сокет.
То есть перед началом выполнения скрипта мы создадим одно
соединие до конца выполнения.
<?php
//создаем сокет, по которому
данный файл скрипта будет общаться с отладчиком.
//Переменная сокета будет глобальной, так чтобы ее было
видно из всех функций
$debug_socket0 = socket_create (AF_INET, SOCK_STREAM, 0);
//соединяемся с отладчиком
socket_connect ($debug_socket0, "127.0.0.1", "3450");
if (!function_exists ("DebugBreak_0")) {
//определяем функцию для посылки отладчику
информации о точке останова
function DebugBreak_0 ($debug_line)
{
//используем переменную глобально
global $debug_socket0;
$DEBUGBREAK = sprintf ("%d", $debug_line);
//посылаем отладчику номер строки где
остановились
socket_write ($debug_socket0, $DEBUGBREAK, strlen ($DEBUGBREAK));
}
}
if (!function_exists ("DebugBreak2_0")) {
//определяем функцию получения команды от
отладчика
function DebugBreak2_0 ()
{
//используем переменную глобально
global $debug_socket0;
//получаем команду
$rd = socket_read ($debug_socket0, 65535);
//если ничего не приехало
if ($rd == "") {
//убиваем скрипт
printf ("Script
aborted!");
exit();
}
return $rd;
}
}
//посылаем отладчику имя файла скрипта
socket_write ($debug_socket0, "/index.php", strlen ("/index.php"));
//получаем от отладчика разрешение на
продолжение выполнения
$this_php_file = socket_read ($debug_socket0, 2048);
?>
Обратите внимание на то, что имя переменной сокета содержит
номер в конце. Это важно! Так как мы используем эту вставку в
начале каждого файла, то для каждого файла должен быть свой
сокет. Аналогично с именем функций DebugBreak_x. Для функций
мы также делаем проверку, не были ли они продекларированы
ранее.
С помощью функций мы создаем код, который будем помещать в
каждом месте где хотим сделать остановку:
<?php
$browser = $HTTP_USER_AGENT; //оригинальный код
//используем переменную
глобально
global $debug_socket0;
//Посылаем отладчику в какой строке (до
модификации) остановились
DebugBreak_0 (2);
//цикл выполнения команд от отладчика
while (true) {
//принимаем команду
$dbdata = DebugBreak2_0();
if ($dbdata != "continue") {
//определяем $debug_socket для того, чтобы
использовать его в eval();
$debug_socket = $debug_socket0;
//выполняем команду отладчика
eval ($dbdata);
}
else break;
}
?>
На этом с PHP мы закончим. Надеюсь вы поняли принцип. В
следущей части мы приступим к самому отладчику. :)
В предыдущей
части мы ознакомились с принципом работы отладчика с точки
зрения модификации на PHP. А сейчас приступим к созданию
самого отладчика. Именно отладчик модифицирует скрипт и
управляет его работой. Сразу скажу, эта статья предназначена
не для чайников. В создание отладчика будем использовать язык
програмирования C++ и библиотеку MFC (Microsoft Foundation
Classes).
Любая программа начинается с дизайна. Начнем с создания
static library, в которой будут заключены все необходимые
функции отладчика. Далее, static library можно использовать в
создании графических интерфейсов. Давайте подумаем какие
основные фунции на нужны:
- Инициализация отладчика
- Добавление/удаление точек останова. Ну как же без этого.
:)
- Управление скриптом: начать отладку, продолжить отладку
после точки останова, остановить отладку
- Получение/изменение значений переменных
Рассмотрим все по порядку.
Инициализация.
Здесь мы говорим отладчику где находятся файлы для отладки
– наш путь к DocumentRoot. Кроме этого нам нужно задать адреса
callback – функций, которые отладчик будет вызывать во время
следующих событий:
- Файл начал свое выполнение (соединился для разговора с
отладчиком).
- Файл закончил свое выполнение (рассоединился).
- Достигнута точка останова.
Добавление/удаление точек останова.
Обьект отладчика должен содержать список всех точек
останова. В первую очередь этот список нужен для того, чтобы
отладчик имел информацию о том, где модифицировать исходные
файлы. Список нужно сформировать до запуска скрипта, так как
во время выполнения скрипт модифицировать невозможно.
Следоваетельно, функции AddBreakpoint / RemoveBreakpoint нужны
только для составления списка. Параметры функций
соответственно: имя файла и номер строки где нужно установить
breakpoint.
Управление скриптом.
Пожалуй эта самая главная и сложная часть. Как мы сказали
ранее, есть несколько функций управления:
Начать отладку. Тут все и начинается. После
того, как сформировался список точек останова мы начинаем
модифицировать файлы. В прошлой части мы говорили о том, как
модифицировать файлы, поэтому я не буду на этом акцентировать
внимание. Итак, файлы мы модифицировали. Теперь нужно
запустить сервер, который будет ждать сообщений от скрипта.
Скрипт в данном случае является клиентом.
После того, как функция StartToDebug запускает сервер, она
возвращает результат - запустился сервер или нет. Сервер,
бегущий в thread'е ждет соединения. После запуска отладчика
пользователь запускает скрипт. Скрипт соединяется с сервером и
передает ему свое имя. Сервер заносит это имя и сокет в список
соединенных файлов. После этого происходит вызов
callback-функции, чтобы сообщить пользователю, что файл
соединился. Далее, для каждого файла создается поток, задача
которого получать и обрабатывать сообщения от скрипта. И вот
приходит сообщение: "привет сервер, приехали... 3 строка".
Отладчик вызывает callback-функцию BreakPoint и передает в нее
номер строки и имя файла, которое он находит в списке файлов
по сокету и переходит в ожидание команды на продолжение
выполнения работы скрипта.
Продолжить отладку после точки останова. Здесь ничего сложного нет. Функция просто дает команду
продолжать потоку, который принимает сообщения от файла.
Остановить отладку. Все, что нужно сделать –
уничтожить потоки, принимающие сообщения от скриптов;
уничтожить поток, который принимает соединения и восстановить
исходные файлы, то есть убрать наши модификации в
скриптах.
Получение/изменение значений переменных.
Давайте вспомним, что же делает скрипт, когда достигнута
точка останова? Он просто ждет команд от отладчика и выполняет
их командой eval(). Следовательно, чтобы получить или изменить
значение переменной нам надо послать скрипту php код, который
получит/передаст значение переменной.
В итоге наш дизайн выглядит так:
//Декларации callback функций
typedef void (*DEBUG_FILE_CONNECTED)(CString csFilePath);
typedef void (*DEBUG_FILE_DISCONNECTED)(CString csFilePath);
typedef void (*DEBUG_BREAKPOINT_REACHED)(CString csFilePath, int nLine);
typedef void (*DEBUG_SCRIPT_ERROR)(CString csText);
//Декларация класса отладчика
class CPHPDebug
{
public:
//функции установки callback функций
BOOL SetCallback_ScriptError (void * pFunc);
BOOL SetCallback_FileDisconnected (void * pFunc);
BOOL SetCallback_BreakPointReached (void * pFunc);
BOOL SetCallback_FileConnected (void * pFunc);
//Операции для работы с переменными PHP
CString GetVariableType (CString csVarName);
//Получить тип переменной
CString GetObjectClass (CString csVarName);
//Получить класс обьекта
CString GetArrayDump (CString csVarName);
//Получить дамп массива
int GetStringVariableLen (CString csVarName);
//Получить длину строковой переменной
BOOL SetVariableValue (CString csVarName, CString csVarValue);
//Установить значение переменной
CString GetResourceType (CString csVarName);
//Получить тип ресурса переменной
CString GetVariableValue (CString csVarName);
//Получить значение переменной (integer/string)
//Функции управления отладчиком
BOOL ResumeDebug ();
BOOL RemoveBreakPoint (CString csFilePath, int nLine);
BOOL AddBreakPoint (CString csFFF, int nLine);
BOOL StopDebugger ();
BOOL StartToDebug ();
BOOL Init (CString csDocumentPath, CString csServerPath);
CPHPDebug();
virtual ~CPHPDebug();
private:
CList<CString, CString> lstFiles;
//Список отлаживаемых файлов
//декларация функций потоков
static void ServerListenThread (CPHPDebug * pObj);
//поток приема соединений
static void DebugFileThread (CPHPDebuggerFile * pdf);
//поток приема сообщений от скриптов
static void ErrorListenThread (CPHPDebug * pObj);
//поток приема сообщений ошибок скриптов
SOCKET m_sockListen; //сокет, слушающий соединения скриптов
SOCKET m_sockErrorListen; //сокет, слушающий сообщения об ошибках скриптов
CString m_csServerPath; //путь к серверу
CString m_csDocumentPath; //путь к DocumentRoot
BOOL m_bInited;
//список точек останова
CList<CPHPBreakPoint, CPHPBreakPoint> m_lstBreakPoints;
//Список соединеных файлов
CList<CPHPDebuggerFile, CPHPDebuggerFile> m_lstPHPDebuggedFiles;
CString m_csDebugBreakSTR;
CString m_csFilePrefixSTR;
CString m_csFilePrefixErrH;
BOOL m_bDebugging;
//event handles
HANDLE m_hServerStartedEvent;
HANDLE m_hServerListenThread;
DWORD m_dwServerListenThreadID;
HANDLE m_hErrorThread;
DWORD m_dwErrorThreadID;
CPHPBreakPoint * m_ppbActiveBreakPoint; //активная точка останова
DEBUG_FILE_CONNECTED m_fnFileConnected;
DEBUG_FILE_DISCONNECTED m_fnFileDisconnected;
DEBUG_BREAKPOINT_REACHED m_fnBreakPointReached;
DEBUG_SCRIPT_ERROR m_fnScriptError;
SOCKET m_sockCurClient; //todo: use critical_section
};
О подробностях имплементации я рассказывать не буду. Вы
можете скачать
библиотеку где имплементирован класс отладчика. В следущей
части я приведу пример использования этой библиотеки. Также я
расскажу о том, как сделать On-Line отладчик.
